base_bitset_type.hpp

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
 */

 
#ifndef BASE_BITSET_TYPE_HPP
#define BASE_BITSET_TYPE_HPP
 
#include "bitmath_func.hpp"

template <typename Timpl, typename Tvalue_type, typename Tstorage, Tstorage Tmask = std::numeric_limits<Tstorage>::max()>
class BaseBitSet {
public:
  using ValueType = Tvalue_type; 
  using BaseType = Tstorage; 
  static constexpr Tstorage MASK = Tmask; 

  constexpr BaseBitSet() : data(0) {}

  explicit constexpr BaseBitSet(Tstorage data) : data(data & Tmask) {}
 
  constexpr auto operator <=>(const BaseBitSet &) const noexcept = default;

  constexpr Timpl &Set()
  {
    this->data = Tmask;
    return static_cast<Timpl&>(*this);
  }

  template <typename Treturn_type = Timpl> requires std::is_base_of_v<BaseBitSet<Timpl, Tvalue_type, Tstorage, Tmask>, Treturn_type>
  constexpr Treturn_type &Set(Tvalue_type value)
  {
    this->data |= (1ULL << Timpl::DecayValueType(value));
    return static_cast<Treturn_type &>(*this);
  }

  constexpr Timpl &Set(const Timpl &other)
  {
    this->data |= other.data;
    return static_cast<Timpl&>(*this);
  }

  constexpr Timpl &Set(Tvalue_type value, bool set)
  {
    return set ? this->Set(value) : this->Reset(value);
  }

  constexpr Timpl &Reset()
  {
    this->data = 0;
    return static_cast<Timpl &>(*this);
  }

  constexpr Timpl &Reset(Tvalue_type value)
  {
    this->data &= ~(1ULL << Timpl::DecayValueType(value));
    return static_cast<Timpl&>(*this);
  }

  constexpr Timpl &Reset(const Timpl &other)
  {
    this->data &= ~other.data;
    return static_cast<Timpl&>(*this);
  }

  constexpr Timpl &Flip()
  {
    this->data ^= Tmask;
    return static_cast<Timpl &>(*this);
  }

  constexpr Timpl &Flip(Tvalue_type value)
  {
    if (this->Test(value)) {
      return this->Reset(value);
    } else {
      return this->Set(value);
    }
  }

  constexpr Timpl &Flip(const Timpl &other)
  {
    this->data ^= other.data;
    return static_cast<Timpl&>(*this);
  }

  constexpr bool Test(Tvalue_type value) const
  {
    return (this->data & (1ULL << Timpl::DecayValueType(value))) != 0;
  }

  constexpr bool All(const Timpl &other) const
  {
    return (this->data & other.data) == other.data;
  }

  constexpr bool All() const
  {
    return this->data == Tmask;
  }

  constexpr bool Any(const Timpl &other) const
  {
    return (this->data & other.data) != 0;
  }

  constexpr bool Any() const
  {
    return this->data != 0;
  }

  constexpr bool None() const
  {
    return this->data == 0;
  }
 
  constexpr Timpl &operator|=(const Timpl &other)
  {
    this->data |= other.data;
    return static_cast<Timpl &>(*this);
  }
 
  constexpr Timpl operator|(const Timpl &other) const
  {
    return Timpl{static_cast<Tstorage>(this->data | other.data)};
  }
 
  constexpr Timpl &operator&=(const Timpl &other)
  {
    this->data &= other.data;
    return static_cast<Timpl &>(*this);
  }
 
  constexpr Timpl operator&(const Timpl &other) const
  {
    return Timpl{static_cast<Tstorage>(this->data & other.data)};
  }

  constexpr Tstorage base() const noexcept
  {
    return this->data;
  }

  constexpr bool IsValid() const
  {
    return (this->base() & Tmask) == this->base();
  }

  inline uint Count() const
  {
    return CountBits(this->base());
  }

  std::optional<Tvalue_type> GetNthSetBit(uint n) const
  {
    for (auto i : *this) {
      if (n == 0) return i;
      --n;
    }
 
    return std::nullopt;
  }

  auto begin() const { return SetBitIterator<Tvalue_type, Tstorage>(this->data).begin(); }

  auto end() const { return SetBitIterator<Tvalue_type, Tstorage>(this->data).end(); }
 
private:
  Tstorage data; 
};
 
#endif /* BASE_BITSET_TYPE_HPP */