enum_flags.h

 
 
#pragma once
 
#include "flag_bits.h"
#include <bit>
#include <iterator>
 
 
namespace ghassanpl
{
    template <integral_or_enum ENUM, detail::valid_integral VALUE_TYPE = unsigned long long>
    struct enum_flag_changes;
 
    constexpr inline struct all_flags_t {} all_flags;
    constexpr inline struct no_flags_t {} no_flags;
    
    template <integral_or_enum ENUM, detail::valid_integral VALUE_TYPE = unsigned long long>
    struct enum_flags
    {
        using value_type = VALUE_TYPE;
 
        using enum_type = ENUM;
        using self_type = enum_flags;
 
        value_type bits = 0;
 
        constexpr enum_flags() noexcept = default;
        constexpr enum_flags(const enum_flags&) noexcept = default;
        constexpr enum_flags(enum_flags&&) noexcept = default;
        constexpr enum_flags& operator=(const enum_flags&) noexcept = default;
        constexpr enum_flags& operator=(enum_flags&&) noexcept = default;
 
        constexpr enum_flags(enum_type base_value) noexcept : bits(flag_bits<VALUE_TYPE>(base_value)) {}
        constexpr explicit enum_flags(value_type value) noexcept : bits(value) {}
 
        template <typename... ARGS>
        constexpr enum_flags(enum_type base_value, ARGS... args) noexcept : bits(flag_bits<VALUE_TYPE>(base_value, args...)) {}
 
        [[nodiscard]]
        constexpr static self_type from_bits(value_type val) noexcept {
            self_type ret;
            ret.bits = val;
            return ret;
        }
 
        [[nodiscard]]
        constexpr static self_type all() noexcept { return self_type::from_bits(~VALUE_TYPE{ 0 }); }
 
        constexpr enum_flags(all_flags_t) noexcept : bits(~VALUE_TYPE{0}) {}
 
        [[nodiscard]]
        constexpr static self_type all(enum_type last) noexcept { return self_type::from_bits(flag_bits<VALUE_TYPE>(last) | (flag_bits<VALUE_TYPE>(last) - 1)); }
        
        [[nodiscard]]
        constexpr static self_type none() noexcept { return {}; }
        
        constexpr enum_flags(no_flags_t) noexcept : bits(VALUE_TYPE{0}) {}
 
        [[nodiscard]]
        constexpr bool is_set(enum_type flag) const noexcept { return (bits & flag_bits<VALUE_TYPE>(flag)) != 0; }
        
        [[nodiscard]]
        constexpr bool contain(enum_type flag) const noexcept { return this->is_set(flag); }
        [[nodiscard]]
        constexpr bool contains(enum_type flag) const noexcept { return this->is_set(flag); }
 
        [[nodiscard]]
        constexpr int count() const noexcept { return std::popcount(bits); }
 
        [[nodiscard]]
        constexpr ENUM nth_set(size_t n) const noexcept {
            auto b = bits;
            while (n--) { b ^= (VALUE_TYPE{ 1 } << std::countr_zero(b)); }
            return static_cast<ENUM>(std::countr_zero(b));
        }
 
        [[nodiscard]]
        constexpr ENUM first_set() const noexcept { return static_cast<ENUM>(std::countr_zero(bits)); }
 
        template <typename T, typename... ARGS>
        [[nodiscard]]
        constexpr bool contains_any_of(T arg, ARGS... args) const noexcept
        {
            return this->is_set(arg) || (this->is_set(args) || ...);
        }
 
        [[nodiscard]]
        constexpr bool are_any_set() const noexcept { return bits != 0; }
 
        [[nodiscard]]
        constexpr bool full() const noexcept { return (~bits) == 0; }
 
        [[nodiscard]]
        constexpr bool contains_any_of(self_type other) const noexcept { return other.bits == 0 /* empty set */ || (bits & other.bits) != 0; }
 
        template <typename... ARGS>
        [[nodiscard]]
        constexpr bool contains_all_of(ARGS... args) const noexcept
        {
            return (this->is_set(args) && ...);
        }
 
        [[nodiscard]]
        constexpr bool contains_all_of(self_type other) const noexcept { return (bits & other.bits) == other.bits; }
        
        constexpr explicit operator bool() const noexcept { return bits != 0; }
 
        [[nodiscard]]
        constexpr enum_type to_enum_type() const noexcept { return (enum_type)bits; }
 
        template <std::convertible_to<ENUM>... ARGS>
        constexpr self_type& set(ARGS... args) noexcept { bits |= flag_bits<VALUE_TYPE>(args...); return *this; }
        constexpr self_type& set(self_type other) noexcept { bits |= other.bits; return *this; }
 
 
        template <std::convertible_to<ENUM>... ARGS>
        constexpr self_type& unset(ARGS... args) noexcept { bits &= ~ flag_bits<VALUE_TYPE>(args...); return *this; }
        constexpr self_type& unset(self_type other) noexcept { bits &= ~other.bits; return *this; }
 
        
        template <std::convertible_to<ENUM>... ARGS>
        constexpr self_type& toggle(ARGS... args) noexcept { bits ^= flag_bits<VALUE_TYPE>(args...); return *this; }
        constexpr self_type& toggle(self_type other) noexcept { bits ^= other.bits; return *this; }
 
        template <std::convertible_to<ENUM>... ARGS>
        constexpr self_type& set_to(bool val, ARGS... args) noexcept
        {
            if (val) bits |= flag_bits<VALUE_TYPE>(args...); else bits &= ~flag_bits<VALUE_TYPE>(args...);
            return *this;
        }
 
        constexpr self_type& set_to(bool val, self_type other) noexcept
        {
            if (val) bits |= other.bits; else bits &= ~other.bits;
            return *this;
        }
 
        [[nodiscard]]
        constexpr self_type but_only(self_type flags) const noexcept { return self_type::from_bits(bits & flags.bits); }
 
        [[nodiscard]]
        constexpr self_type intersected_with(self_type flags) const noexcept { return self_type::from_bits(bits & flags.bits); }
 
        [[nodiscard]]
        constexpr self_type operator+(enum_type flag) const noexcept { return self_type::from_bits(bits | flag_bits<VALUE_TYPE>(flag)); }
        [[nodiscard]]
        constexpr self_type operator-(enum_type flag) const noexcept { return self_type::from_bits(bits & ~ flag_bits<VALUE_TYPE>(flag)); }
 
        [[nodiscard]]
        constexpr self_type operator+(self_type flags) const noexcept { return self_type::from_bits(bits | flags.bits); }
        [[nodiscard]]
        constexpr self_type operator-(self_type flags) const noexcept { return self_type::from_bits(bits & ~flags.bits); }
        [[nodiscard]]
        constexpr self_type except_for(self_type flags) const noexcept { return self_type::from_bits(bits & ~flags.bits); }
        [[nodiscard]]
        constexpr self_type without(self_type flags) const noexcept { return self_type::from_bits(bits & ~flags.bits); }
 
        template <std::convertible_to<ENUM>... ARGS>
        [[nodiscard]] constexpr self_type except_for(ARGS... args) const noexcept { return self_type::from_bits(bits & ~flag_bits<VALUE_TYPE>(args...)); }
        template <std::convertible_to<ENUM>... ARGS>
        [[nodiscard]] constexpr self_type without(ARGS... args) const noexcept { return self_type::from_bits(bits & ~flag_bits<VALUE_TYPE>(args...)); }
 
        constexpr self_type& operator+=(enum_type flag) noexcept { bits |= flag_bits<VALUE_TYPE>(flag); return *this; }
        constexpr self_type& operator-=(enum_type flag) noexcept { bits &= ~ flag_bits<VALUE_TYPE>(flag); return *this; }
 
        constexpr self_type& operator+=(self_type flags) noexcept { bits |= flags.bits; return *this; }
        constexpr self_type& operator-=(self_type flags) noexcept { bits &= ~flags.bits; return *this; }
 
        constexpr auto operator<=>(enum_flags const& other) const noexcept = default;
 
        struct iterator
        {
            self_type::value_type bits;
            using bitset_type = std::make_unsigned_t<self_type::value_type>;
 
            using difference_type = int;
            using value_type = enum_type;
            using pointer_type = void;
            using reference = void;
            using iterator_category = std::forward_iterator_tag;
 
 
            enum_type operator*() const noexcept
            { 
                const auto bitset = static_cast<bitset_type>(bits);
#pragma warning(suppress: 4146)
                return static_cast<enum_type>(std::countr_zero(static_cast<bitset_type>(bitset & -bitset)));
            }
 
            iterator& operator++() noexcept
            {
                const auto bitset = static_cast<bitset_type>(bits);
#pragma warning(suppress: 4146)
                const auto t = static_cast<bitset_type>(bitset & -bitset);
                bits = static_cast<self_type::value_type>(bitset ^ t);
                return *this;
            }
 
            iterator operator++(int) noexcept { const auto result = *this; operator++(); return result; }
 
            auto operator<=>(iterator const& other) const noexcept = default;
        };
 
        iterator begin() const noexcept { return iterator{ bits }; }
        iterator end() const noexcept { return iterator{ {} }; }
        iterator cbegin() const noexcept { return iterator{ bits }; }
        iterator cend() const noexcept { return iterator{ {} }; }
 
        constexpr bool empty() const noexcept { return bits == 0; }
        constexpr void clear() noexcept { bits = 0; }
 
        template <typename FUNC>
        constexpr auto for_each(FUNC&& callback) const
        {
            using return_type = std::invoke_result_t<FUNC, enum_type>;
            using bitset_type = std::make_unsigned_t<value_type>;
            auto bitset = static_cast<bitset_type>(bits);
            while (bitset)
            {
#pragma warning(suppress: 4146)
                const auto t = static_cast<bitset_type>(bitset & -bitset);
                const auto r = std::countr_zero(t);
                if constexpr (std::is_convertible_v<return_type, bool>)
                {
                    if (auto ret = callback((enum_type)r)) return ret;
                }
                else
                    callback((enum_type)r);
                bitset ^= t;
            }
            if constexpr (std::is_convertible_v<return_type, bool>)
                return return_type{};
        }
 
        using flag_changes = enum_flag_changes<ENUM, VALUE_TYPE>;
 
        constexpr void apply(flag_changes changes) noexcept 
        {
            const auto bits_to_xor = changes.bits[0].bits & changes.bits[1].bits;
            bits ^= bits_to_xor; 
 
            changes.bits[0].bits &= ~bits_to_xor;
            changes.bits[1].bits &= ~bits_to_xor;
 
            bits &= ~changes.bits[1].bits;
            bits |= changes.bits[0].bits;
        }
 
        constexpr self_type operator+(flag_changes changes) const noexcept
        {
            auto result = *this;
            result.apply(changes);
            return result;
        }
    };
 
    template <typename TYPE>
    struct is_enum_flags : std::false_type {};
 
    template <typename ENUM, typename VALUE_TYPE>
    struct is_enum_flags<enum_flags<ENUM, VALUE_TYPE>> : std::true_type {};
 
    template <typename TYPE>
    constexpr bool is_enum_flags_v = is_enum_flags<TYPE>::value;
    
    enum class enum_flag_change : uint8_t
    {
        no_change,
        set,
        unset,
        toggle,
    };
 
    template <integral_or_enum ENUM, detail::valid_integral VALUE_TYPE>
    struct enum_flag_changes
    {
        using value_type = VALUE_TYPE;
 
        using enum_type = ENUM;
        using self_type = enum_flag_changes;
 
        using flags_type = enum_flags<ENUM, VALUE_TYPE>;
 
        constexpr enum_flag_changes() noexcept = default;
        constexpr enum_flag_changes(enum_flag_changes const&) noexcept = default;
        constexpr enum_flag_changes(enum_flag_changes&&) noexcept = default;
        constexpr enum_flag_changes& operator=(enum_flag_changes const&) noexcept = default;
        constexpr enum_flag_changes& operator=(enum_flag_changes&&) noexcept = default;
 
        static constexpr self_type no_changes() noexcept { return self_type{}; }
 
        template <std::convertible_to<ENUM>... ARGS>
        static constexpr self_type to_set(ARGS... args) noexcept { return self_type{ flag_bits<VALUE_TYPE>(args...), 0 }; }
        static constexpr self_type to_set(flags_type other) noexcept { return self_type{ other, 0 }; }
        template <std::convertible_to<ENUM>... ARGS>
        static constexpr self_type to_unset(ARGS... args) noexcept { return self_type{ 0, flag_bits<VALUE_TYPE>(args...) }; }
        static constexpr self_type to_unset(flags_type other) noexcept { return self_type{ 0, other }; }
        template <std::convertible_to<ENUM>... ARGS>
        static constexpr self_type to_toggle(ARGS... args) noexcept { return self_type{ flag_bits<VALUE_TYPE>(args...), flag_bits<VALUE_TYPE>(args...) }; }
        static constexpr self_type to_toggle(flags_type other) noexcept { return self_type{  other, other }; }
 
        template <std::convertible_to<ENUM>... ARGS>
        constexpr self_type& set_change_of(enum_flag_change change, ARGS... args) noexcept
        {
            switch (change)
            {
            case enum_flag_change::no_change: return dont_change(args...);
            case enum_flag_change::set: return set(args...);
            case enum_flag_change::unset: return unset(args...);
            case enum_flag_change::toggle: return toggle(args...);
            }
#if defined(__cpp_lib_unreachable) && __cpp_lib_unreachable >= 202202L
            std::unreachable();
#endif
        }
 
        constexpr enum_flag_change change_of(enum_type flag) const noexcept
        {
            return static_cast<enum_flag_change>(bits[0].is_set(flag) * 1 + bits[1].is_set(flag) * 2);
        }
 
        template <std::convertible_to<ENUM>... ARGS>
        constexpr self_type& set(ARGS... args) noexcept { bits[0].set(args...); bits[1].unset(args...); return *this; }
        constexpr self_type& set(flags_type other) noexcept { bits[0].set(other); bits[1].unset(other); return *this; }
 
        template <std::convertible_to<ENUM>... ARGS>
        constexpr self_type& unset(ARGS... args) noexcept { bits[0].unset(args...); bits[1].set(args...); return *this; }
        constexpr self_type& unset(flags_type other) noexcept { bits[0].unset(other); bits[1].set(other); return *this; }
 
        template <std::convertible_to<ENUM>... ARGS>
        constexpr self_type& toggle(ARGS... args) noexcept { bits[0].set(args...); bits[1].set(args...); return *this; }
        constexpr self_type& toggle(flags_type other) noexcept { bits[0].set(other); bits[1].set(other); return *this; }
 
        template <std::convertible_to<ENUM>... ARGS>
        constexpr self_type& dont_change(ARGS... args) noexcept { bits[0].unset(args...); bits[1].unset(args...); return *this; }
        constexpr self_type& dont_change(flags_type other) noexcept { bits[0].unset(other); bits[1].unset(other); return *this; }
 
        constexpr self_type& dont_change_any() noexcept { bits[0].clear(); bits[1].clear(); return *this; }
 
        constexpr auto operator<=>(self_type const& other) const noexcept = default;
 
        flags_type bits[2]{ {}, {} };
 
    private:
 
        constexpr enum_flag_changes(flags_type b0, flags_type b1) noexcept
            : bits(b0, b1)
        {
        }
 
    };
 
}