runtime_stack.h

Go to the documentation of this file.

#ifndef RUNTIME_STACK_H
#define RUNTIME_STACK_H
 
#include <MazeBuilder/runtime_app.h>
#include <MazeBuilder/state.h>
 
#include <algorithm>
#include <functional>
#include <memory>
#include <optional>
#include <ranges>
#include <string>
#include <string_view>
#include <unordered_map>
#include <vector>
 
namespace mazes
{
    class runtime_stack final
    {
    public:
        enum class operation : unsigned int
        {
            PUSH = 0,
            POP = 1,
            CLEAR = 2
        };
 
        explicit runtime_stack(const runtime_app::context& ctx);
 
        // Stack operations (deferred — applied by apply_pending_changes)
        void push_state(state::ID state_id) noexcept;
        void pop_state() noexcept;
        void clear_states() noexcept;
 
        void visit_states(const std::optional<args>& args, double elapsed) noexcept;
 
        [[nodiscard]] bool is_empty() const noexcept;
 
        template <typename T>
        void register_state(state::ID state_id)
        {
            m_factories.insert_or_assign(state_id, [this]()
            {
                return std::make_unique<T>(runtime_context, this);
            });
        }
 
        template <typename Pointer>
        [[nodiscard]] Pointer peek_state() const noexcept
        {
            auto reversed = m_states | std::views::reverse;
 
            auto it = std::ranges::find_if(reversed, [](const auto& sp)
            {
                return dynamic_cast<Pointer>(sp.get()) != nullptr;
            });
 
            if (it != std::ranges::cend(reversed))
            {
                return dynamic_cast<Pointer>(it->get());
            }
 
            return nullptr;
        }
 
    private:
        struct pending_change
        {
            explicit pending_change(operation action, state::ID id = state::ID::TOTAL)
                : action(action), state_id(id)
            {
            }
 
            operation action;
            state::ID state_id;
        };
 
        struct state_id_hash
        {
            std::size_t operator()(state::ID id) const noexcept
            {
                return std::hash<unsigned int>{}(static_cast<unsigned int>(id));
            }
        };
 
        // Apply all pending push/pop/clear operations
        void apply_pending_changes() noexcept;
 
        [[nodiscard]] std::unique_ptr<state> create_state(state::ID state_id)
        {
            if (const auto& found = m_factories.find(state_id); found != m_factories.cend())
            {
                return found->second();
            }
 
            throw std::runtime_error("runtime_stack::create_state - No factory for state ID: " +
                std::to_string(static_cast<unsigned int>(state_id)));
        }
 
        std::vector<std::unique_ptr<state>> m_states;
        std::vector<pending_change> m_pending;
        runtime_app::context runtime_context;
        std::unordered_map<state::ID,
                           std::function<std::unique_ptr<state>()>,
                           state_id_hash>
        m_factories;
    };
} // namespace mazes
 
#endif // RUNTIME_STACK_H