MultiCustomStateManager.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_MULTICUSTOMSTATEMANAGER_H
#define MALENA_MULTICUSTOMSTATEMANAGER_H
 
#include <Malena/Core/malena_export.h>
#include <type_traits>
#include <tuple>
#include <functional>
#include <Malena/Utilities/TypeExtraction.h>
 
namespace ml
{
    // =========================================================================
    // SingleStateManager
    // =========================================================================

    template<typename StateEnum>
    class SingleStateManager
    {
        StateEnum _currentState{};
        std::function<void(StateEnum)> _onEnter;
        std::function<void(StateEnum)> _onExit;
 
    public:
        void setState(StateEnum newState)
        {
            if (_onExit)  _onExit(_currentState);
            _currentState = newState;
            if (_onEnter) _onEnter(_currentState);
        }

        StateEnum getState() const { return _currentState; }

        bool isState(StateEnum state) const { return _currentState == state; }

        void onStateEnter(std::function<void(StateEnum)> cb) { _onEnter = std::move(cb); }

        void onStateExit(std::function<void(StateEnum)> cb)  { _onExit  = std::move(cb); }

        void syncState(StateEnum state) { _currentState = state; }
    };
 
    // =========================================================================
    // MultiCustomStateManager
    // =========================================================================

    template<typename... StateEnums>
    class MultiCustomStateManager : public SingleStateManager<StateEnums>...
    {
    public:
        using SingleStateManager<StateEnums>::setState...;
        using SingleStateManager<StateEnums>::getState...;
        using SingleStateManager<StateEnums>::isState...;
        using SingleStateManager<StateEnums>::onStateEnter...;
        using SingleStateManager<StateEnums>::onStateExit...;
        using SingleStateManager<StateEnums>::syncState...;
    };

    template<>
    class MultiCustomStateManager<>
    {
    public:
        void setState(...)     {}
        void getState(...)     {}
        void isState(...)      {}
        void onStateEnter(...) {}
        void onStateExit(...)  {}
        void syncState(...)    {}
    };
 
    // =========================================================================
    // State extraction and gather helpers
    // =========================================================================


    template<typename M, typename = void>
    struct extract_ManifestState { using type = void; };
 
    template<typename M>
    struct extract_ManifestState<M, std::void_t<typename M::State>>
    { using type = typename M::State; };
 
    // ── Void filtering (mirrors the pattern in MultiCustomFlaggable) ──────────
 
    template<typename T, typename Acc>
    struct AppendStateIfNotVoid { using type = Acc; };
 
    template<typename T, typename... Acc>
    struct AppendStateIfNotVoid<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 FilterVoidStates;
 
    template<>
    struct FilterVoidStates<> { using type = std::tuple<>; };
 
    template<typename T, typename... Rest>
    struct FilterVoidStates<T, Rest...>
    {
        using type = typename AppendStateIfNotVoid<
            T,
            typename FilterVoidStates<Rest...>::type
        >::type;
    };
 
    template<typename Tuple>
    struct TupleToMultiStateManager;
 
    template<typename... StateEnums>
    struct TupleToMultiStateManager<std::tuple<StateEnums...>>
    { using type = MultiCustomStateManager<StateEnums...>; };

 
    // =========================================================================
    // GatherStates
    // =========================================================================

    template<typename ComponentManifest, typename... Traits>
    struct GatherStates
    {
        using AllStatesTuple = typename FilterVoidStates<
            typename extract_ManifestState<ComponentManifest>::type,
            typename extract_ManifestState<
                typename extract_TraitManifest<Traits>::type
            >::type...
        >::type;
 
        using type = typename TupleToMultiStateManager<AllStatesTuple>::type;
    };
 
} // namespace ml
 
#endif // MALENA_MULTICUSTOMSTATEMANAGER_H