Bitflags.h

#pragma once
 
 
#include <Foundation/Basics.h>
#include <Foundation/Containers/Implementation/BitIterator.h>
#include <Foundation/Types/Enum.h>
 
template <typename T>
struct plBitflags
{
private:
  using Enum = typename T::Enum;
  using Bits = typename T::Bits;
  using StorageType = typename T::StorageType;
 
public:
  using ConstIterator = plBitIterator<Enum, false>;
 
  PL_ALWAYS_INLINE plBitflags()
    : m_Value(T::Default) // [tested]
  {
  }
 
  PL_ALWAYS_INLINE plBitflags(Enum flag1) // [tested]
  {
    m_Value = (StorageType)flag1;
  }
 
  PL_ALWAYS_INLINE void operator=(Enum flag1) { m_Value = (StorageType)flag1; }
 
  PL_ALWAYS_INLINE bool operator==(const StorageType rhs) const // [tested]
  {
    return m_Value == rhs;
  }
 
  PL_ALWAYS_INLINE bool operator!=(const StorageType rhs) const { return m_Value != rhs; }
 
  PL_ALWAYS_INLINE bool operator==(const plBitflags<T>& rhs) const { return m_Value == rhs.m_Value; }
 
  PL_ALWAYS_INLINE bool operator!=(const plBitflags<T>& rhs) const { return m_Value != rhs.m_Value; }
 
  PL_ALWAYS_INLINE void Clear() // [tested]
  {
    m_Value = 0;
  }
 
  PL_ALWAYS_INLINE bool IsSet(Enum flag) const // [tested]
  {
    return (m_Value & flag) != 0;
  }
 
  PL_ALWAYS_INLINE bool AreAllSet(const plBitflags<T>& rhs) const // [tested]
  {
    return (m_Value & rhs.m_Value) == rhs.m_Value;
  }
 
  PL_ALWAYS_INLINE bool AreNoneSet(const plBitflags<T>& rhs) const // [tested]
  {
    return (m_Value & rhs.m_Value) == 0;
  }
 
  PL_ALWAYS_INLINE bool IsAnySet(const plBitflags<T>& rhs) const // [tested]
  {
    return (m_Value & rhs.m_Value) != 0;
  }
 
  PL_ALWAYS_INLINE void Add(const plBitflags<T>& rhs) // [tested]
  {
    m_Value |= rhs.m_Value;
  }
 
  PL_ALWAYS_INLINE void Remove(const plBitflags<T>& rhs) // [tested]
  {
    m_Value &= (~rhs.m_Value);
  }
 
  PL_ALWAYS_INLINE void Toggle(const plBitflags<T>& rhs) // [tested]
  {
    m_Value ^= rhs.m_Value;
  }
 
  PL_ALWAYS_INLINE void AddOrRemove(const plBitflags<T>& rhs, bool bState) // [tested]
  {
    m_Value = (bState) ? m_Value | rhs.m_Value : m_Value & (~rhs.m_Value);
  }
 
  PL_ALWAYS_INLINE plBitflags<T> operator|(const plBitflags<T>& rhs) const // [tested]
  {
    return plBitflags<T>(m_Value | rhs.m_Value);
  }
 
  PL_ALWAYS_INLINE plBitflags<T> operator&(const plBitflags<T>& rhs) const // [tested]
  {
    return plBitflags<T>(m_Value & rhs.m_Value);
  }
 
  PL_ALWAYS_INLINE void operator|=(const plBitflags<T>& rhs) // [tested]
  {
    m_Value |= rhs.m_Value;
  }
 
  PL_ALWAYS_INLINE void operator&=(const plBitflags<T>& rhs) // [tested]
  {
    m_Value &= rhs.m_Value;
  }
 
  PL_ALWAYS_INLINE StorageType GetValue() const // [tested]
  {
    return m_Value;
  }
 
  PL_ALWAYS_INLINE void SetValue(StorageType value) // [tested]
  {
    m_Value = value;
  }
 
  PL_ALWAYS_INLINE bool IsNoFlagSet() const // [tested]
  {
    return m_Value == 0;
  }
 
  PL_ALWAYS_INLINE bool IsAnyFlagSet() const // [tested]
  {
    return m_Value != 0;
  }
 
  PL_ALWAYS_INLINE ConstIterator GetIterator() const // [tested]
  {
    return ConstIterator((Enum)m_Value);
  }
 
  PL_ALWAYS_INLINE ConstIterator GetEndIterator() const // [tested]
  {
    return ConstIterator();
  }
 
private:
  PL_ALWAYS_INLINE explicit plBitflags(StorageType flags)
    : m_Value(flags)
  {
  }
 
  union
  {
    StorageType m_Value;
    Bits m_bits;
  };
};
 
// begin() /end() for range-based for-loop support
template <typename T>
typename plBitflags<T>::ConstIterator begin(const plBitflags<T>& container)
{
  return container.GetIterator();
}
 
template <typename T>
typename plBitflags<T>::ConstIterator cbegin(const plBitflags<T>& container)
{
  return container.GetIterator();
}
 
template <typename T>
typename plBitflags<T>::ConstIterator end(const plBitflags<T>& container)
{
  return container.GetEndIterator();
}
 
template <typename T>
typename plBitflags<T>::ConstIterator cend(const plBitflags<T>& container)
{
  return container.GetEndIterator();
}
 
#define PL_DECLARE_FLAGS_OPERATORS(FlagsType)                                      \
  inline plBitflags<FlagsType> operator|(FlagsType::Enum lhs, FlagsType::Enum rhs) \
  {                                                                                \
    return (plBitflags<FlagsType>(lhs) | plBitflags<FlagsType>(rhs));              \
  }                                                                                \
                                                                                   \
  inline plBitflags<FlagsType> operator&(FlagsType::Enum lhs, FlagsType::Enum rhs) \
  {                                                                                \
    return (plBitflags<FlagsType>(lhs) & plBitflags<FlagsType>(rhs));              \
  }
 
 
 
#define PL_DECLARE_FLAGS_WITH_DEFAULT(InternalStorageType, BitflagsTypeName, DefaultValue, ...) \
  struct BitflagsTypeName                                                                       \
  {                                                                                             \
    static constexpr plUInt32 Count = PL_VA_NUM_ARGS(__VA_ARGS__);                              \
    using StorageType = InternalStorageType;                                                    \
    enum Enum                                                                                   \
    {                                                                                           \
      PL_EXPAND_ARGS_WITH_INDEX(PL_DECLARE_FLAGS_ENUM, ##__VA_ARGS__) Default = DefaultValue    \
    };                                                                                          \
    struct Bits                                                                                 \
    {                                                                                           \
      PL_EXPAND_ARGS(PL_DECLARE_FLAGS_BITS, ##__VA_ARGS__)                                      \
    };                                                                                          \
    PL_ENUM_TO_STRING(__VA_ARGS__)                                                              \
  };                                                                                            \
  PL_DECLARE_FLAGS_OPERATORS(BitflagsTypeName)
 
#define PL_DECLARE_FLAGS(InternalStorageType, BitflagsTypeName, ...) \
  PL_DECLARE_FLAGS_WITH_DEFAULT(InternalStorageType, BitflagsTypeName, 0, ##__VA_ARGS__)
 
#define PL_DECLARE_FLAGS_ENUM(name, n) name = PL_BIT(n),
 
#define PL_DECLARE_FLAGS_BITS(name) StorageType name : 1;