flag.hpp

Go to the documentation of this file.

#pragma once
 
 
#include <commons/display_info.hpp>
#include <commons/fixed_string.hpp>
#include <commons/types.hpp>
 
#include <algorithm>
#include <concepts>
#include <map>
#include <optional>
#include <string_view>
#include <utility>
#include <vector>
 
namespace comms {
 
// ---------------------------------------------------------------------------
// Compile-time flag / category types
// ---------------------------------------------------------------------------
 
template <FixedString Name>
struct FlagCategory {
    static constexpr std::string_view name = Name.view();
};
 
struct UnsetFlagCategory : FlagCategory<"unset"> {};
 
template <FixedString Name, typename Category = UnsetFlagCategory>
struct Flag {
    static constexpr std::string_view name = Name.view();
    using category = Category;
    static constexpr std::string_view category_name = Category::name;
};
 
// ---------------------------------------------------------------------------
// Concepts
// ---------------------------------------------------------------------------
 
template <typename C>
concept AnyFlagCategory = requires {
    { C::name } -> std::convertible_to<std::string_view>;
};
 
template <typename F>
concept AnyFlag = requires {
    { F::name } -> std::convertible_to<std::string_view>;
    typename F::category;
    requires AnyFlagCategory<typename F::category>;
};
 
template <typename F, typename Category>
concept FlagInCategory = AnyFlag<F> && std::same_as<typename F::category, Category>;
 
// ---------------------------------------------------------------------------
// FlagRef — type-erased runtime handle
// ---------------------------------------------------------------------------
 
struct FlagRef {
    std::string_view name;                 
    std::string_view category;             
    const DisplayInfo* display = nullptr;  
 
    template <AnyFlag F>
    [[nodiscard]] static FlagRef of() noexcept {
        FlagRef r{.name = F::name, .category = F::category::name};
        if constexpr (Displayable<F>) {
            r.display = &display_info<F>();
        }
        return r;
    }
 
    bool operator==(const FlagRef& o) const noexcept {
        return name == o.name;
    }
};
 
// ---------------------------------------------------------------------------
// FlagSet — insertion-ordered unique set
// ---------------------------------------------------------------------------
 
class FlagSet {
    std::vector<FlagRef> items_;
 
public:
    template <AnyFlag F>
    bool insert() {
        return insert(FlagRef::of<F>());
    }
 
    bool insert(const FlagRef& f) {
        if (contains(f.name)) {
            return false;
        }
        items_.push_back(f);
        return true;
    }
 
    template <AnyFlag... Fs>
    [[nodiscard]] static FlagSet of() {
        FlagSet s;
        (s.insert<Fs>(), ...);
        return s;
    }
 
    template <AnyFlag F>
    [[nodiscard]] bool contains() const {
        return contains(F::name);
    }
 
    [[nodiscard]] bool contains(std::string_view name) const {
        return std::ranges::any_of(items_, [name](const FlagRef& f) { return f.name == name; });
    }
 
    [[nodiscard]] std::size_t count(const std::string_view name) const {
        return contains(name) ? 1U : 0U;
    }
 
    template <AnyFlag F>
    bool erase() {
        return erase(F::name);
    }
 
    bool erase(const std::string_view name) {
        for (auto it = items_.begin(); it != items_.end(); ++it) {
            if (it->name == name) {
                items_.erase(it);
                return true;
            }
        }
        return false;
    }
 
    void clear() noexcept {
        items_.clear();
    }
 
    [[nodiscard]] bool empty() const noexcept {
        return items_.empty();
    }
 
    [[nodiscard]] std::size_t size() const noexcept {
        return items_.size();
    }
 
    [[nodiscard]] auto begin() const noexcept {
        return items_.begin();
    }
 
    [[nodiscard]] auto end() const noexcept {
        return items_.end();
    }
 
    [[nodiscard]] std::map<std::string_view, std::vector<FlagRef>> group_by_category() const {
        std::map<std::string_view, std::vector<FlagRef>> groups;
        for (const auto& f : items_) {
            groups[f.category].push_back(f);
        }
        return groups;
    }
 
    bool operator==(const FlagSet&) const = default;  // order-sensitive
};
 
// ---------------------------------------------------------------------------
// GlobalFlagRegistry — Meyers singleton
// ---------------------------------------------------------------------------
 
class GlobalFlagRegistry {
    FlagSet flags_;
    GlobalFlagRegistry() = default;
 
public:
    GlobalFlagRegistry(const GlobalFlagRegistry&) = delete;
    GlobalFlagRegistry& operator=(const GlobalFlagRegistry&) = delete;
    GlobalFlagRegistry(GlobalFlagRegistry&&) = delete;
    GlobalFlagRegistry& operator=(GlobalFlagRegistry&&) = delete;
    ~GlobalFlagRegistry() = default;
 
    [[nodiscard]] static GlobalFlagRegistry& instance() noexcept {
        static GlobalFlagRegistry r;
        return r;
    }
 
    template <AnyFlag F>
    bool add() {
        return flags_.insert<F>();
    }
 
    bool add(const FlagRef& f) {
        return flags_.insert(f);
    }
 
    [[nodiscard]] const FlagSet& flags() const noexcept {
        return flags_;
    }
 
    [[nodiscard]] std::optional<FlagRef> find(const std::string_view name) const {
        for (const auto& f : flags_) {
            if (f.name == name) {
                return f;
            }
        }
        return std::nullopt;
    }
 
    [[nodiscard]] auto group_by_category() const {
        return flags_.group_by_category();
    }
};
 
template <AnyFlag F>
struct FlagRegistrar {
    FlagRegistrar() noexcept {
        GlobalFlagRegistry::instance().add<F>();
    }
};
 
// ---------------------------------------------------------------------------
// Mixins for types that own a FlagSet
// ---------------------------------------------------------------------------
 
template <typename F, typename... Categories>
concept AllowedFlag =
    AnyFlag<F> && (sizeof...(Categories) == 0 || (FlagInCategory<F, Categories> || ...));
 
class IHasFlags {
public:
    virtual ~IHasFlags() = default;
 
    [[nodiscard]] virtual const FlagSet& flags() const noexcept = 0;
 
    template <AnyFlag F>
    [[nodiscard]] bool has_flag() const {
        return flags().template contains<F>();
    }
 
    [[nodiscard]] bool has_flag(const std::string_view name) const {
        return flags().contains(name);
    }
 
protected:
    // Protected to prevent slicing through the interface; derived types remain
    // copyable/movable via their own (implicitly defined) operations.
    IHasFlags() = default;
    IHasFlags(const IHasFlags&) = default;
    IHasFlags(IHasFlags&&) = default;
    IHasFlags& operator=(const IHasFlags&) = default;
    IHasFlags& operator=(IHasFlags&&) = default;
};
 
template <typename... Categories>
class HasFlags : public IHasFlags {
public:
    [[nodiscard]] const FlagSet& flags() const noexcept override {
        return flags_;
    }
 
    template <AnyFlag F>
    static constexpr bool flag_allowed = AllowedFlag<F, Categories...>;
 
protected:
    FlagSet flags_;
};
 
template <typename Derived, typename... Categories>
class FlagBuilderMixin {
public:
    template <AnyFlag F>
    static constexpr bool flag_allowed = AllowedFlag<F, Categories...>;
 
    template <AnyFlag F>
        requires AllowedFlag<F, Categories...>
    Derived& insert_flag() {
        flags_.template insert<F>();
        return self();
    }
 
    Derived& insert_flag(const FlagRef& f) {
        flags_.insert(f);
        return self();
    }
 
    template <AnyFlag F>
        requires AllowedFlag<F, Categories...>
    Derived& flag() {
        return insert_flag<F>();
    }
 
    Derived& flag(const FlagRef& f) {
        return insert_flag(f);
    }
 
    template <AnyFlag F>
        requires AllowedFlag<F, Categories...>
    Derived& set_flag(const bool on) {
        if (on) {
            flags_.template insert<F>();
        } else {
            flags_.template erase<F>();
        }
        return self();
    }
 
    template <AnyFlag F>
    Derived& remove_flag() {
        flags_.template erase<F>();
        return self();
    }
 
    Derived& remove_flag(const std::string_view name) {
        flags_.erase(name);
        return self();
    }
 
    Derived& set_flags(FlagSet flags) {
        flags_ = std::move(flags);
        return self();
    }
 
    Derived& clear_flags() {
        flags_.clear();
        return self();
    }
 
protected:
    FlagSet flags_;
 
    [[nodiscard]] const FlagSet& flags() const noexcept {
        return flags_;
    }
 
private:
    Derived& self() noexcept {
        return static_cast<Derived&>(*this);
    }
};
 
template <typename Derived, typename... Categories>
class FlagBuilderGetters : public FlagBuilderMixin<Derived, Categories...>, public IHasFlags {
public:
    [[nodiscard]] const FlagSet& flags() const noexcept override {
        return this->flags_;
    }
};
 
}  // namespace comms
 
// ---------------------------------------------------------------------------
// Declaration macros (define-then-use, mirroring COMMONS_MUI_FAMILY). Each
// expands to a declaration; the caller supplies the trailing `;`.
//
// Registration caveat: the `inline` registrar registers once at static init
// (the Meyers singleton guarantees the registry exists first), so query the
// registry at or after `main`. In a *static library*, an unreferenced registrar
// may be stripped unless the archive is linked whole (e.g. `--whole-archive` /
// `-force_load`); reference the flag, or register explicitly, if that matters.
// ---------------------------------------------------------------------------
 
#define COMMONS_FLAG_CATEGORY(Ident, Name)                                                         \
    struct Ident : ::comms::FlagCategory<Name> {}
 
#define COMMONS_FLAG(Ident, Name)                                                                  \
    struct Ident : ::comms::Flag<Name> {}
 
#define COMMONS_FLAG_IN(Ident, Name, Cat)                                                          \
    struct Ident : ::comms::Flag<Name, Cat> {}
 
// NOLINTNEXTLINE(bugprone-macro-parentheses)
#define COMMONS_REGISTER_FLAG(Ident)                                                               \
    inline const ::comms::FlagRegistrar<Ident> commons_flag_registrar_##Ident {}
 
// NOLINTNEXTLINE(bugprone-macro-parentheses)
#define COMMONS_DEFINE_FLAG(Ident, Name)                                                           \
    struct Ident : ::comms::Flag<Name> {};                                                         \
    inline const ::comms::FlagRegistrar<Ident> commons_flag_registrar_##Ident
 
// NOLINTNEXTLINE(bugprone-macro-parentheses)
#define COMMONS_DEFINE_FLAG_IN(Ident, Name, Cat)                                                   \
    struct Ident : ::comms::Flag<Name, Cat> {};                                                    \
    inline const ::comms::FlagRegistrar<Ident> commons_flag_registrar_##Ident
 
// `ConceptName` is a concept name and `FlagTmpl` a template name — neither can be
// parenthesized, so the macro-parentheses check is suppressed here.
// NOLINTBEGIN(bugprone-macro-parentheses)
#define COMMONS_FLAG_FAMILY(CatIdent, Name, FlagTmpl, ConceptName)                                 \
    struct CatIdent : ::comms::FlagCategory<Name> {};                                              \
    template <::comms::FixedString N>                                                              \
    struct FlagTmpl : ::comms::Flag<N, CatIdent> {};                                               \
    template <typename F>                                                                          \
    concept ConceptName = ::comms::FlagInCategory<F, CatIdent>
// NOLINTEND(bugprone-macro-parentheses)