Enum.h

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

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

    EnumRange() requires requires { Enum::First; Enum::Last; }
        : EnumRange(Enum::First, Enum::Last) {}

    EnumRange(Enum first, Enum last)
        : m_first(static_cast<Underlying>(first)),
          m_last(static_cast<Underlying>(last)) {}

    struct iterator {
        using iterator_category = std::forward_iterator_tag;
        using difference_type   = std::ptrdiff_t;
        using value_type    = Enum;
        using reference     = Enum;
        using pointer       = Enum *;

        Underlying v;

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

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

        iterator operator++(int) {
            iterator temp = *this;
            ++(*this);
            return temp;
        }

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

    using value_type    = Enum;
    using const_iterator    = iterator;

    iterator begin() const { return { m_first }; }
    iterator end() const { return { m_last + 1 }; }
private:
    Underlying m_first;
    Underlying m_last;
};
 
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;
}