/home/runner/work/kouta/kouta/include/kouta/utils/enum-set.hpp

Custom bitset implementation that allows using enumeration values as indices.The used enumeration type used must:

• Derive from std::size_t
• Not set any value for the labels (optionally, value 0 can be set for the first one)
• Contain a _Total label at the end

The _Total label is used to determine the number of values in the enumeration (by explicitly casting it to an std::size_t value).

 {c++}
enum class MyEnum : std::size_t
{
    A,
    B,
    C,
 
    _Total
};
 
EnumSet<MyEnum> set{MyEnum::A, MyEnum::C};
 
// Test and set using enumeration values
set.test(MyEnum::A);
set.set{MyEnum::B};
 
// Or raw indices
set.test(0);
set.set(1);

Template Parameters

TEnum

Enumeration type to use.

#pragma once
 
#include <bitset>
#include <initializer_list>
#include <type_traits>
 
namespace kouta::utils
{
    template<class TEnum>
        requires std::is_enum_v<TEnum>
    class EnumSet : public std::bitset<static_cast<std::size_t>(TEnum::_Total)>
    {
    public:
        using EnumType = TEnum;
 
        using BaseType = std::bitset<static_cast<std::size_t>(TEnum::_Total)>;
 
        using reference = BaseType::reference;
 
        // Re-export some methods
        using BaseType::BaseType;
        using BaseType::operator[];
        using BaseType::set;
        using BaseType::test;
 
        EnumSet(const std::initializer_list<TEnum>& values)
            : BaseType{}
        {
            for (auto v : values)
            {
                set(v);
            }
        }
 
        bool operator[](EnumType pos) const
        {
            return BaseType::operator[](static_cast<std::size_t>(pos));
        }
 
        reference operator[](EnumType pos)
        {
            return BaseType::operator[](static_cast<std::size_t>(pos));
        }
 
        bool test(EnumType pos) const
        {
            return test(static_cast<std::size_t>(pos));
        }
 
        EnumSet& set(EnumType pos, bool value = true)
        {
            set(static_cast<std::size_t>(pos), value);
 
            return *this;
        }
    };
}  // namespace kouta::utils