Bitfield.h

#pragma once
 
#include <Foundation/Containers/DynamicArray.h>
#include <Foundation/Containers/HybridArray.h>
#include <Foundation/Containers/Implementation/BitIterator.h>
#include <Foundation/IO/Stream.h>
#include <Foundation/Math/Constants.h>
 
template <class Container>
class plBitfield
{
public:
  plBitfield() = default;
 
  plUInt32 GetCount() const; // [tested]
 
  template <typename = void>                       // Template is used to only conditionally compile this function in when it is actually used.
  void SetCountUninitialized(plUInt32 uiBitCount); // [tested]
 
  void SetCount(plUInt32 uiBitCount, bool bSetNew = false); // [tested]
 
  bool IsEmpty() const; // [tested]
 
  bool IsAnyBitSet(plUInt32 uiFirstBit = 0, plUInt32 uiNumBits = 0xFFFFFFFF) const; // [tested]
 
  bool IsNoBitSet(plUInt32 uiFirstBit = 0, plUInt32 uiNumBits = 0xFFFFFFFF) const; // [tested]
 
  bool AreAllBitsSet(plUInt32 uiFirstBit = 0, plUInt32 uiNumBits = 0xFFFFFFFF) const; // [tested]
 
  void Clear(); // [tested]
 
  void SetBit(plUInt32 uiBit); // [tested]
 
  void ClearBit(plUInt32 uiBit); // [tested]
 
  void SetBitValue(plUInt32 uiBit, bool bValue); // [tested]
 
  bool IsBitSet(plUInt32 uiBit) const; // [tested]
 
  void ClearAllBits(); // [tested]
 
  void SetAllBits(); // [tested]
 
  void SetBitRange(plUInt32 uiFirstBit, plUInt32 uiNumBits); // [tested]
 
  void ClearBitRange(plUInt32 uiFirstBit, plUInt32 uiNumBits); // [tested]
 
  void Swap(plBitfield<Container>& other); // [tested]
  struct ConstIterator
  {
    using iterator_category = std::forward_iterator_tag;
    using value_type = plUInt32;
    using sub_iterator = ::plBitIterator<plUInt32, true>;
 
    // Invalid iterator (end)
    PL_FORCE_INLINE ConstIterator() = default; // [tested]
 
    // Start iterator.
    explicit ConstIterator(const plBitfield<Container>& bitfield); // [tested]
 
    bool IsValid() const; // [tested]
 
    plUInt32 Value() const; // [tested]
 
    void Next();                                       // [tested]
 
    bool operator==(const ConstIterator& other) const; // [tested]
    bool operator!=(const ConstIterator& other) const; // [tested]
 
    plUInt32 operator*() const; // [tested]
 
    void operator++(); // [tested]
 
  private:
    void FindNextChunk(plUInt32 uiStartChunk);
 
  private:
    plUInt32 m_uiChunk = 0;
    sub_iterator m_Iterator;
    const plBitfield<Container>* m_pBitfield = nullptr;
  };
 
  ConstIterator GetIterator() const; // [tested]
 
  ConstIterator GetEndIterator() const; // [tested]
 
private:
  friend struct ConstIterator;
 
  plUInt32 GetBitInt(plUInt32 uiBitIndex) const;
  plUInt32 GetBitMask(plUInt32 uiBitIndex) const;
 
  plUInt32 m_uiCount = 0;
  Container m_Container;
};
 
using plDynamicBitfield = plBitfield<plDynamicArray<plUInt32>>;
 
template <plUInt32 BITS>
using plHybridBitfield = plBitfield<plHybridArray<plUInt32, (BITS + 31) / 32>>;
 
// begin() /end() for range-based for-loop support
template <typename Container>
typename plBitfield<Container>::ConstIterator begin(const plBitfield<Container>& container)
{
  return container.GetIterator();
}
 
template <typename Container>
typename plBitfield<Container>::ConstIterator cbegin(const plBitfield<Container>& container)
{
  return container.GetIterator();
}
 
template <typename Container>
typename plBitfield<Container>::ConstIterator end(const plBitfield<Container>& container)
{
  return container.GetEndIterator();
}
 
template <typename Container>
typename plBitfield<Container>::ConstIterator cend(const plBitfield<Container>& container)
{
  return container.GetEndIterator();
}
 
 
template <typename T>
class plStaticBitfield
{
public:
  using StorageType = T;
  using ConstIterator = plBitIterator<StorageType, true, plUInt32>;
 
  static constexpr plUInt32 GetStorageTypeBitCount() { return plMath::NumBits<T>(); }
 
  plStaticBitfield();
 
  static plStaticBitfield<T> MakeFromMask(StorageType bits);
 
  bool IsAnyBitSet() const; // [tested]
 
  bool IsNoBitSet() const; // [tested]
 
  bool AreAllBitsSet() const; // [tested]
 
  void SetBit(plUInt32 uiBit); // [tested]
 
  void ClearBit(plUInt32 uiBit); // [tested]
 
  void SetBitValue(plUInt32 uiBit, bool bValue); // [tested]
 
  bool IsBitSet(plUInt32 uiBit) const; // [tested]
 
  void ClearAllBits(); // [tested]
 
  void SetAllBits(); // [tested]
 
  void SetBitRange(plUInt32 uiFirstBit, plUInt32 uiNumBits); // [tested]
 
  void ClearBitRange(plUInt32 uiFirstBit, plUInt32 uiNumBits); // [tested]
 
  plUInt32 GetLowestBitSet() const; // [tested]
 
  plUInt32 GetHighestBitSet() const; // [tested]
 
  plUInt32 GetNumBitsSet() const; // [tested]
 
  T GetValue() const; // [tested]
 
  void SetValue(T value); // [tested]
 
  void Swap(plStaticBitfield<T>& other); // [tested]
 
  PL_ALWAYS_INLINE void operator|=(const plStaticBitfield<T>& rhs) { m_Storage |= rhs.m_Storage; }
 
  PL_ALWAYS_INLINE void operator&=(const plStaticBitfield<T>& rhs) { m_Storage &= rhs.m_Storage; }
 
  plResult Serialize(plStreamWriter& inout_writer) const
  {
    inout_writer.WriteVersion(s_Version);
    inout_writer << m_Storage;
    return PL_SUCCESS;
  }
 
  plResult Deserialize(plStreamReader& inout_reader)
  {
    /*auto version =*/inout_reader.ReadVersion(s_Version);
    inout_reader >> m_Storage;
    return PL_SUCCESS;
  }
 
  ConstIterator GetIterator() const // [tested]
  {
    return ConstIterator(m_Storage);
  };
 
  ConstIterator GetEndIterator() const // [tested]
  {
    return ConstIterator();
  };
 
private:
  static constexpr plTypeVersion s_Version = 1;
 
  plStaticBitfield(StorageType initValue)
    : m_Storage(initValue)
  {
  }
 
  template <typename U>
  friend plStaticBitfield<U> operator|(plStaticBitfield<U> lhs, plStaticBitfield<U> rhs);
 
  template <typename U>
  friend plStaticBitfield<U> operator&(plStaticBitfield<U> lhs, plStaticBitfield<U> rhs);
 
  template <typename U>
  friend plStaticBitfield<U> operator^(plStaticBitfield<U> lhs, plStaticBitfield<U> rhs);
 
  template <typename U>
  friend bool operator==(plStaticBitfield<U> lhs, plStaticBitfield<U> rhs);
 
  template <typename U>
  friend bool operator!=(plStaticBitfield<U> lhs, plStaticBitfield<U> rhs);
 
  StorageType m_Storage = 0;
};
 
template <typename T>
inline plStaticBitfield<T> operator|(plStaticBitfield<T> lhs, plStaticBitfield<T> rhs)
{
  return plStaticBitfield<T>(lhs.m_Storage | rhs.m_Storage);
}
 
template <typename T>
inline plStaticBitfield<T> operator&(plStaticBitfield<T> lhs, plStaticBitfield<T> rhs)
{
  return plStaticBitfield<T>(lhs.m_Storage & rhs.m_Storage);
}
 
template <typename T>
inline plStaticBitfield<T> operator^(plStaticBitfield<T> lhs, plStaticBitfield<T> rhs)
{
  return plStaticBitfield<T>(lhs.m_Storage ^ rhs.m_Storage);
}
 
template <typename T>
inline bool operator==(plStaticBitfield<T> lhs, plStaticBitfield<T> rhs)
{
  return lhs.m_Storage == rhs.m_Storage;
}
 
template <typename T>
inline bool operator!=(plStaticBitfield<T> lhs, plStaticBitfield<T> rhs)
{
  return lhs.m_Storage != rhs.m_Storage;
}
 
// begin() /end() for range-based for-loop support
template <typename Container>
typename plStaticBitfield<Container>::ConstIterator begin(const plStaticBitfield<Container>& container)
{
  return container.GetIterator();
}
 
template <typename Container>
typename plStaticBitfield<Container>::ConstIterator cbegin(const plStaticBitfield<Container>& container)
{
  return container.GetIterator();
}
 
template <typename Container>
typename plStaticBitfield<Container>::ConstIterator end(const plStaticBitfield<Container>& container)
{
  return container.GetEndIterator();
}
 
template <typename Container>
typename plStaticBitfield<Container>::ConstIterator cend(const plStaticBitfield<Container>& container)
{
  return container.GetEndIterator();
}
 
using plStaticBitfield8 = plStaticBitfield<plUInt8>;
using plStaticBitfield16 = plStaticBitfield<plUInt16>;
using plStaticBitfield32 = plStaticBitfield<plUInt32>;
using plStaticBitfield64 = plStaticBitfield<plUInt64>;
 
#include <Foundation/Containers/Implementation/Bitfield_inl.h>