flagnum.hpp

Go to the documentation of this file.

#pragma once

namespace templa
{
    template <typename ENUM>
    struct FlagEnum
    {
        static_assert(std::is_enum<ENUM>::value, "ENUM must be an enum type");

        using underlying_t = typename std::underlying_type<ENUM>::type;

        underlying_t mask = 0x000;

        FlagEnum() : mask{0} {}

        FlagEnum(ENUM single_flag) : mask(static_cast<underlying_t>(single_flag)) {}

        FlagEnum(const FlagEnum &o) : mask(o.mask) {}

        ~FlagEnum() = default;

        constexpr FlagEnum &operator|=(ENUM addValue)
        {
            mask |= static_cast<underlying_t>(addValue);
            return *this;
        }

        constexpr FlagEnum &operator&=(ENUM maskValue)
        {
            mask &= static_cast<underlying_t>(maskValue);
            return *this;
        }

        constexpr bool operator==(ENUM maskValue) const noexcept
        {
            return ((this->mask & static_cast<underlying_t>(maskValue)) == static_cast<underlying_t>(maskValue));
        }

        explicit operator bool() const noexcept
        {
            return mask != 0;
        }
    };

    template <typename E>
        requires std::is_enum_v<E>
    constexpr FlagEnum<E> operator|(E lhs, E rhs)
    {
        return FlagEnum<E>(lhs) | rhs;
    }

    template <typename E>
        requires std::is_enum_v<E>
    constexpr FlagEnum<E> operator&(E lhs, E rhs)
    {
        return FlagEnum<E>(lhs) & rhs;
    }

    template <typename E>
        requires std::is_enum_v<E>
    constexpr FlagEnum<E> operator~(E val)
    {
        return ~FlagEnum<E>(val);
    }
};