bitmath_func.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 <http://www.gnu.org/licenses/>.
 */
 
#ifndef BITMATH_FUNC_HPP
#define BITMATH_FUNC_HPP
 
template <typename T>
debug_inline constexpr static uint GB(const T x, const uint8_t s, const uint8_t n)
{
  return (x >> s) & (((T)1U << n) - 1);
}
debug_inline constexpr static uint GB(const T x, const uint8_t s, const uint8_t n) {…}
 
template <typename T, typename U>
constexpr T SB(T &x, const uint8_t s, const uint8_t n, const U d)
{
  x &= (T)(~((((T)1U << n) - 1) << s));
  x |= (T)(d << s);
  return x;
}
constexpr T SB(T &x, const uint8_t s, const uint8_t n, const U d) {…}
 
template <typename T, typename U>
constexpr T AB(T &x, const uint8_t s, const uint8_t n, const U i)
{
  const T mask = ((((T)1U << n) - 1) << s);
  x = (T)((x & ~mask) | ((x + (i << s)) & mask));
  return x;
}
constexpr T AB(T &x, const uint8_t s, const uint8_t n, const U i) {…}
 
template <typename T>
debug_inline constexpr bool HasBit(const T x, const uint8_t y)
{
  return (x & ((T)1U << y)) != 0;
}
debug_inline constexpr bool HasBit(const T x, const uint8_t y) {…}
 
template <typename T>
constexpr T SetBit(T &x, const uint8_t y)
{
  return x = (T)(x | ((T)1U << y));
}
constexpr T SetBit(T &x, const uint8_t y) {…}
 
template <typename T>
constexpr T ClrBit(T &x, const uint8_t y)
{
  return x = (T)(x & ~((T)1U << y));
}
constexpr T ClrBit(T &x, const uint8_t y) {…}
 
template <typename T>
constexpr T ToggleBit(T &x, const uint8_t y)
{
  return x = (T)(x ^ ((T)1U << y));
}
constexpr T ToggleBit(T &x, const uint8_t y) {…}
 
template <typename T>
constexpr T AssignBit(T &x, const uint8_t y, bool value)
{
  return SB<T>(x, y, 1, value ? 1 : 0);
}
constexpr T AssignBit(T &x, const uint8_t y, bool value) {…}
 
template <typename T>
constexpr uint8_t FindFirstBit(T x)
{
  if (x == 0) return 0;
 
  if constexpr (std::is_enum_v<T>) {
    return std::countr_zero<std::underlying_type_t<T>>(x);
  } else {
    return std::countr_zero(x);
  }
}
constexpr uint8_t FindFirstBit(T x) {…}
 
template <typename T>
constexpr uint8_t FindLastBit(T x)
{
  if (x == 0) return 0;
 
  return std::numeric_limits<T>::digits - std::countl_zero(x) - 1;
}
constexpr uint8_t FindLastBit(T x) {…}
 
template <typename T>
constexpr T KillFirstBit(T value)
{
  return value &= (T)(value - 1);
}
constexpr T KillFirstBit(T value) {…}
 
template <typename T>
constexpr uint CountBits(T value)
{
  if constexpr (std::is_enum_v<T>) {
    return std::popcount<std::underlying_type_t<T>>(value);
  } else {
    return std::popcount(value);
  }
}
constexpr uint CountBits(T value) {…}
 
template <typename T>
constexpr bool HasExactlyOneBit(T value)
{
  return value != 0 && (value & (value - 1)) == 0;
}
constexpr bool HasExactlyOneBit(T value) {…}
 
template <typename T>
constexpr bool HasAtMostOneBit(T value)
{
  return (value & (value - 1)) == 0;
}
constexpr bool HasAtMostOneBit(T value) {…}
 
template <typename Tbitpos = uint, typename Tbitset = uint>
struct SetBitIterator {
  struct Iterator {
    typedef Tbitpos value_type;
    typedef value_type *pointer;
    typedef value_type &reference;
    typedef size_t difference_type;
    typedef std::forward_iterator_tag iterator_category;
 
    explicit Iterator(Tbitset bitset) : bitset(bitset), bitpos(static_cast<Tbitpos>(0))
    {
      this->Validate();
    }
 
    bool operator==(const Iterator &other) const
    {
      return this->bitset == other.bitset;
    }
    Tbitpos operator*() const { return this->bitpos; }
    Iterator & operator++() { this->Next(); this->Validate(); return *this; }
 
  private:
    Tbitset bitset;
    Tbitpos bitpos;
    void Validate()
    {
      if (this->bitset != 0) {
        typename std::make_unsigned<Tbitset>::type unsigned_value = this->bitset;
        this->bitpos = static_cast<Tbitpos>(FindFirstBit(unsigned_value));
      }
    }
    void Next()
    {
      this->bitset = KillFirstBit(this->bitset);
    }
  };
  struct Iterator {…};
 
  SetBitIterator(Tbitset bitset) : bitset(bitset) {}
  Iterator begin() { return Iterator(this->bitset); }
  Iterator end() { return Iterator(static_cast<Tbitset>(0)); }
  bool empty() { return this->begin() == this->end(); }
 
private:
  Tbitset bitset;
};
struct SetBitIterator {…};
 
namespace std {
  template <typename T>
  [[nodiscard]] constexpr enable_if_t<is_integral_v<T>, T> byteswap(T x) noexcept
  {
    if constexpr (sizeof(T) == 1) return x;
    if constexpr (sizeof(T) == 2) return (x >> 8) | (x << 8);
    if constexpr (sizeof(T) == 4) return ((x >> 24) & 0xFF) | ((x >> 8) & 0xFF00) | ((x << 8) & 0xFF0000) | ((x << 24) & 0xFF000000);
  }
  [[nodiscard]] constexpr enable_if_t<is_integral_v<T>, T> byteswap(T x) noexcept {…}
}
 
#endif /* BITMATH_FUNC_HPP */