MultiCustomFlaggable.h

Go to the documentation of this file.

// Copyright (c) 2025 Dave R. Smith.
// Malena Framework — Licensed under PolyForm Noncommercial 1.0.0; commercial use requires a paid license. See LICENSE.
 
#ifndef MALENA_MULTICUSTOMFLAGGABLE_H
#define MALENA_MULTICUSTOMFLAGGABLE_H
 
#include <Malena/Core/malena_export.h>
#include <unordered_map>
#include <tuple>
#include <type_traits>
#include <Malena/Utilities/EnumClassHash.h>
#include <Malena/Utilities/TypeExtraction.h>
 
namespace ml
{
    // =========================================================================
    // SingleFlaggable
    // =========================================================================

    template<typename Enum>
    class SingleFlaggable
    {
        std::unordered_map<Enum, bool, EnumClassHash> _states;
 
    public:
        void enableFlag(Enum flag)          { _states[flag] = true; }

        void disableFlag(Enum flag)         { _states[flag] = false; }

        bool checkFlag(Enum flag) const     { auto it = _states.find(flag); return it != _states.end() && it->second; }

        void setFlag(Enum flag, bool value) { _states[flag] = value; }

        void toggleFlag(Enum flag)          { _states[flag] = !checkFlag(flag); }
    };
 
    // =========================================================================
    // MultiCustomFlaggable
    // =========================================================================

    template<typename... Enums>
    class MultiCustomFlaggable : public SingleFlaggable<Enums>...
    {
    public:
        using SingleFlaggable<Enums>::enableFlag...;
        using SingleFlaggable<Enums>::disableFlag...;
        using SingleFlaggable<Enums>::checkFlag...;
        using SingleFlaggable<Enums>::setFlag...;
        using SingleFlaggable<Enums>::toggleFlag...;
    };

    template<>
    class MultiCustomFlaggable<>
    {
    public:
        void enableFlag(...)         {}
        void disableFlag(...)        {}
        bool checkFlag(...)  const   { return false; }
        void setFlag(...)            {}
        void toggleFlag(...)         {}
    };
 
    // =========================================================================
    // Trait manifest detection helpers
    // =========================================================================


    template<typename M, typename = void>
    struct extract_ManifestFlags { using type = void; };
 
    template<typename M>
    struct extract_ManifestFlags<M, std::void_t<typename M::Flag>>
    { using type = typename M::Flag; };
 
    // ── Void filtering ────────────────────────────────────────────────────────
 
    template<typename T, typename Acc>
    struct AppendIfNotVoid { using type = Acc; };
 
    template<typename T, typename... Acc>
    struct AppendIfNotVoid<T, std::tuple<Acc...>>
    {
        using type = std::conditional_t<
            std::is_void_v<T>,
            std::tuple<Acc...>,
            std::tuple<Acc..., T>
        >;
    };
 
    template<typename... Ts>
    struct FilterVoid;
 
    template<>
    struct FilterVoid<> { using type = std::tuple<>; };
 
    template<typename T, typename... Rest>
    struct FilterVoid<T, Rest...>
    {
        using type = typename AppendIfNotVoid<
            T,
            typename FilterVoid<Rest...>::type
        >::type;
    };
 
    template<typename Tuple>
    struct TupleToMultiFlaggable;
 
    template<typename... Enums>
    struct TupleToMultiFlaggable<std::tuple<Enums...>>
    { using type = MultiCustomFlaggable<Enums...>; };

 
    // =========================================================================
    // GatherFlags
    // =========================================================================

    template<typename ComponentManifest, typename... Traits>
    struct GatherFlags
    {
        using AllFlagsTuple = typename FilterVoid<
            typename extract_ManifestFlags<ComponentManifest>::type,
            typename extract_ManifestFlags<
                typename extract_TraitManifest<Traits>::type
            >::type...
        >::type;
 
        using type = typename TupleToMultiFlaggable<AllFlagsTuple>::type;
    };
 
} // namespace ml
 
#endif // MALENA_MULTICUSTOMFLAGGABLE_H