Enum.h

// SPDX-License-Identifier: GPL-2.0-only
 
#pragma once
 
#include <type_traits>
 
namespace SlHelpers {

template <typename Enum>
class EnumRange {
public:
    using Underlying = std::underlying_type_t<Enum>;

    struct iterator {
        Underlying v;

        Enum operator*() const { return static_cast<Enum>(v); }

        iterator &operator++() {
            ++v;
            return *this;
        }

        bool operator==(const iterator &other) const { return v == other.v; }
        bool operator!=(const iterator &other) const { return v != other.v; }
    };

    iterator begin() const { return { static_cast<Underlying>(Enum::First) }; }
    iterator end() const { return { static_cast<Underlying>(Enum::Last) + 1 }; }
};
 
template<typename E>
struct hasBitmaskOperators : std::false_type {};
 
#define ENABLE_BITMASK_OPERATORS(E) \
    template<> struct SlHelpers::hasBitmaskOperators<E> : std::true_type {}
 
template<typename E>
concept BitmaskEnum = std::is_enum_v<E> && hasBitmaskOperators<E>::value;
 
} // namespace
 
template<SlHelpers::BitmaskEnum E>
constexpr E operator~(E lhs)
{
    using underlying = std::underlying_type_t<E>;
    return static_cast<E>(~static_cast<underlying>(lhs));
}
 
template<SlHelpers::BitmaskEnum E>
constexpr E operator|(E lhs, E rhs)
{
    using underlying = std::underlying_type_t<E>;
    return static_cast<E>(static_cast<underlying>(lhs) | static_cast<underlying>(rhs));
}
 
template<SlHelpers::BitmaskEnum E>
constexpr E operator&(E lhs, E rhs)
{
    using underlying = std::underlying_type_t<E>;
    return static_cast<E>(static_cast<underlying>(lhs) & static_cast<underlying>(rhs));
}
 
template<SlHelpers::BitmaskEnum E>
constexpr E &operator|=(E &lhs, E rhs)
{
    return lhs = lhs | rhs;
}
 
template<SlHelpers::BitmaskEnum E>
constexpr E &operator&=(E &lhs, E rhs)
{
    return lhs = lhs & rhs;
}
 
template<SlHelpers::BitmaskEnum E>
constexpr bool hasFlag(E flags, E flag)
{
    return (flags & flag) != E::NONE;
}