TBitFlags.h

Go to the documentation of this file.

#pragma once
 
#include "Utility/traits.h"
 
#include <type_traits>
#include <initializer_list>
 
namespace ph
{
 
template<typename Value, typename Input = Value>
class TBitFlags final
{
    static_assert(std::is_integral_v<Value>);
    static_assert(std::is_integral_v<Input> || std::is_enum_v<Input>);
 
    static_assert(sizeof(Value) >= sizeof(Input),
        "Input type may overflow Value type.");
 
private:
    using FlagsSet = std::initializer_list<Input>;
 
public:
    constexpr TBitFlags();
 
    explicit constexpr TBitFlags(const FlagsSet& flagsSet);
 
    explicit constexpr TBitFlags(Input flagsSet);
 
    template<typename OtherInput>
    explicit constexpr TBitFlags(const TBitFlags<Value, OtherInput>& otherFlags);
 
    constexpr TBitFlags& unionWith(const FlagsSet& flagsSet);
    constexpr TBitFlags& unionWith(const TBitFlags& flags);
 
    constexpr TBitFlags& intersectWith(const FlagsSet& flagsSet);
    
    constexpr TBitFlags& turnOn(const FlagsSet& flagsSet);
    constexpr TBitFlags& turnOff(const FlagsSet& flagsSet);
 
    constexpr bool hasNone(const FlagsSet& flagsSet) const;
 
    constexpr bool hasAny(const FlagsSet& flagsSet) const;
 
    constexpr bool hasAll(const FlagsSet& flagsSet) const;
 
    constexpr bool hasExactly(const FlagsSet& flagsSet) const;
 
    constexpr bool hasNone(Input flagsSet) const;
 
    constexpr bool hasAny(Input flagsSet) const;
 
    constexpr bool hasAll(Input flagsSet) const;
    
    constexpr bool hasExactly(Input flagsSet) const;
 
    constexpr bool has(Input singleFlag) const;
 
    constexpr bool hasNo(Input singleFlag) const;
    
    constexpr bool isEmpty() const;
 
    constexpr bool isEqual(const TBitFlags& other) const;
 
    constexpr Value get() const;
 
    // TODO: method for clear all flags
 
    constexpr TBitFlags& set(const FlagsSet& flagsSet);
    constexpr TBitFlags& set(Input flagsSet);
 
    constexpr Input getEnum() const
    requires CEnum<Input> && (sizeof(Input) >= sizeof(Value))
    {
        return static_cast<Input>(m_bits);
    }
 
private:
    Value m_bits;
 
    static constexpr Value collectFlags(const FlagsSet& flagsSet);
};
 
template<CEnum EnumType>
using TEnumFlags = TBitFlags<std::underlying_type_t<EnumType>, EnumType>;
 
}// end namespace ph
 
#define PH_DEFINE_INLINE_ENUM_FLAG_OPERATORS(EnumType)\
    static_assert(::ph::CEnum<EnumType>, #EnumType " must be an enum type");\
    \
    inline constexpr EnumType operator | (const EnumType lhs, const EnumType rhs)\
    {\
        return ::ph::TEnumFlags<EnumType>({lhs, rhs}).getEnum();\
    }\
    \
    inline constexpr EnumType operator & (const EnumType lhs, const EnumType rhs)\
    {\
        return ::ph::TEnumFlags<EnumType>({lhs}).intersectWith({rhs}).getEnum();\
    }
 
#include "Utility/TBitFlags.ipp"