BitIterator.h

#pragma once
 
#include <Foundation/Math/Math.h>
 
template <typename T, typename = std::void_t<>>
struct plBitIteratorStorage;
template <typename T>
struct plBitIteratorStorage<T, std::enable_if_t<sizeof(T) <= 4>>
{
  using Type = plUInt32;
};
template <typename T>
struct plBitIteratorStorage<T, std::enable_if_t<sizeof(T) >= 5>>
{
  using Type = plUInt64;
};
 
template <typename DataType, bool ReturnsIndex = true, typename ReturnType = DataType, typename StorageType = typename plBitIteratorStorage<DataType>::Type>
struct plBitIterator
{
  using iterator_category = std::forward_iterator_tag;
  using value_type = DataType;
  static_assert(sizeof(DataType) <= 8);
 
  // Invalid iterator (end)
  PL_ALWAYS_INLINE plBitIterator() = default;
 
  // Start iterator.
  PL_ALWAYS_INLINE explicit plBitIterator(DataType data)
  {
    m_uiMask = static_cast<StorageType>(data);
  }
 
  PL_ALWAYS_INLINE bool IsValid() const
  {
    return m_uiMask != 0;
  }
 
  PL_ALWAYS_INLINE ReturnType Value() const
  {
    if constexpr (ReturnsIndex)
    {
      return static_cast<ReturnType>(plMath::FirstBitLow(m_uiMask));
    }
    else
    {
      return static_cast<ReturnType>(PL_BIT(plMath::FirstBitLow(m_uiMask)));
    }
  }
 
  PL_ALWAYS_INLINE void Next()
  {
    // Clear the lowest set bit. Why this works: https://www.geeksforgeeks.org/turn-off-the-rightmost-set-bit/
    m_uiMask = m_uiMask & (m_uiMask - 1);
  }
 
  PL_ALWAYS_INLINE bool operator==(const plBitIterator& other) const
  {
    return m_uiMask == other.m_uiMask;
  }
 
  PL_ALWAYS_INLINE bool operator!=(const plBitIterator& other) const
  {
    return m_uiMask != other.m_uiMask;
  }
 
  PL_ALWAYS_INLINE ReturnType operator*() const
  {
    return Value();
  }
 
  PL_ALWAYS_INLINE void operator++()
  {
    Next();
  }
 
  StorageType m_uiMask = 0;
};