Flags.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2025-2026 Vincent Leroy
// SPDX-License-Identifier: MIT
//
// This file is part of dfx.
//
// Licensed under the MIT License. See the LICENSE file in the project root
// for full license information.
 
#pragma once
 
// Standard includes
#include <format>
#include <initializer_list>
#include <string_view>
#include <type_traits>
#include <vector>
 
// Project includes
#include "EnumString.hpp"
#include "Join.hpp"

 
namespace dfx::Utils
{
template<typename T>
concept IsEnum = std::is_enum_v<T>;

template<IsEnum Enum>
class Flags
{
public:
    using enum_type  = Enum;

    using value_type = std::underlying_type_t<Enum>;
 
public:
    constexpr Flags() noexcept = default;

    constexpr explicit(false) Flags(enum_type e) noexcept
        : _value { static_cast<value_type>(e) }
    {}

    constexpr explicit Flags(value_type val) noexcept
        : _value { val }
    {}

    constexpr explicit(false) Flags(std::initializer_list<enum_type> f) noexcept
    {
        for (auto const & val : f)
            _value |= static_cast<value_type>(val);
    }

    constexpr Flags<enum_type> & setFlag(enum_type flag, bool on = true) noexcept
    { return on ? (*this |= flag) : (*this &= Flags(~static_cast<value_type>(flag))); }

    constexpr Flags<enum_type> & toggleFlag(enum_type flag) noexcept
    { _value ^= static_cast<value_type>(flag); return *this; }

    constexpr Flags<enum_type> & reset() noexcept
    { _value = 0; return *this; }

    [[nodiscard]] constexpr bool testFlag(enum_type flag) const noexcept
    { return (_value & static_cast<value_type>(flag)) == static_cast<value_type>(flag); }

    [[nodiscard]] constexpr bool testAnyFlag(Flags<enum_type> const & flags) const noexcept
    { return (_value & flags._value) != 0; }

    [[nodiscard]] constexpr bool testAllFlags(Flags<enum_type> const & flags) const noexcept
    { return (_value & flags._value) == flags._value; }

    [[nodiscard]] constexpr bool operator==(Flags<enum_type> const & other) const noexcept { return _value == other._value; }
    [[nodiscard]] constexpr bool operator!=(Flags<enum_type> const & other) const noexcept { return !(*this == other); }
    [[nodiscard]] constexpr bool operator==(enum_type flag) const noexcept { return testAllFlags(flag); }
    [[nodiscard]] constexpr bool operator!=(enum_type flag) const noexcept { return !(*this == flag); }
 
    // Explicit conversion operators
    [[nodiscard]] constexpr explicit operator enum_type() const noexcept  { return static_cast<enum_type>(_value); }
    [[nodiscard]] constexpr explicit operator value_type() const noexcept { return _value; }
    [[nodiscard]] constexpr explicit operator bool() const noexcept { return _value != 0; }
 
    // logical and operations
    [[nodiscard]] constexpr Flags<enum_type> operator&(enum_type mask) const noexcept        { return Flags(_value & static_cast<value_type>(mask)); }
    [[nodiscard]] constexpr Flags<enum_type> operator&(Flags<enum_type> mask) const noexcept { return Flags(_value & mask._value); }
    constexpr Flags<enum_type> & operator&=(enum_type mask) noexcept                         { _value &= static_cast<value_type>(mask); return *this; }
    constexpr Flags<enum_type> & operator&=(Flags<enum_type> mask) noexcept                  { _value &= mask._value; return *this; }
 
    // logical or operations
    [[nodiscard]] constexpr Flags<enum_type> operator|(enum_type mask) const noexcept        { return Flags(_value | static_cast<value_type>(mask)); }
    [[nodiscard]] constexpr Flags<enum_type> operator|(Flags<enum_type> mask) const noexcept { return Flags(_value | mask._value); }
    constexpr Flags<enum_type> & operator|=(enum_type mask) noexcept                         { _value |= static_cast<value_type>(mask); return *this; }
    constexpr Flags<enum_type> & operator|=(Flags<enum_type> mask) noexcept                  { _value |= mask._value; return *this; }
 
    // logical xor operations
    [[nodiscard]] constexpr Flags<enum_type> operator^(enum_type mask) const noexcept        { return Flags(_value ^ static_cast<value_type>(mask)); }
    [[nodiscard]] constexpr Flags<enum_type> operator^(Flags<enum_type> mask) const noexcept { return Flags(_value ^ mask._value); }
    constexpr Flags<enum_type> & operator^=(enum_type mask) noexcept                         { _value ^= static_cast<value_type>(mask); return *this; }
    constexpr Flags<enum_type> & operator^=(Flags<enum_type> mask) noexcept                  { _value ^= mask._value; return *this; }
 
    // unary operations
    [[nodiscard]] constexpr Flags<enum_type> operator~() const noexcept { return Flags(~_value); }
    [[nodiscard]] constexpr bool operator!() const noexcept             { return !_value; }
 
private:
    value_type _value = 0;
};
} // !namespace dfx::Utils

#define DFX_DECLARE_FLAGS(FlagsName, Enum) \
    using FlagsName = ::dfx::Utils::Flags<Enum>

#define DFX_DECLARE_OPERATOR_FOR_FLAGS(FlagsName) \
    [[nodiscard]] constexpr ::dfx::Utils::Flags<FlagsName::enum_type> operator|(FlagsName::enum_type f1, FlagsName::enum_type f2) noexcept \
    { return ::dfx::Utils::Flags<FlagsName::enum_type>({ f1, f2 }); }

#define DFX_DECLARE_STD_FORMATTER_FOR_FLAGS(FlagsName) \
    template<> \
    struct std::formatter<FlagsName> : public formatter<std::string_view> \
    { \
        auto format(FlagsName const & f, format_context & ctx) const \
        { \
            std::vector<FlagsName::enum_type> vec; \
            for (auto const & value : ::dfx::Enum::allValues<FlagsName::enum_type>()) \
                if (f.testFlag(value)) \
                    vec.emplace_back(value); \
            return formatter<std::string_view>::format(std::format("{}", ::dfx::Utils::join(vec, "|")), ctx); \
        } \
    }