machine.hpp

//Copyright Florian Goujeon 2021 - 2025.
//Distributed under the Boost Software License, Version 1.0.
//(See accompanying file LICENSE or copy at
//https://www.boost.org/LICENSE_1_0.txt)
//Official repository: https://github.com/fgoujeon/maki

 
#ifndef MAKI_MACHINE_HPP
#define MAKI_MACHINE_HPP
 
#include "machine_conf.hpp"
#include "events.hpp"
#include "null.hpp"
#include "detail/path.hpp"
#include "detail/state_impls/simple.hpp" //NOLINT misc-include-cleaner
#include "detail/state_impls/composite.hpp" //NOLINT misc-include-cleaner
#include "detail/state_impls/composite_no_context.hpp"
#include "detail/context_holder.hpp"
#include "detail/event_action.hpp"
#include "detail/noinline.hpp"
#include "detail/function_queue.hpp"
#include "detail/tuple.hpp"
#include "detail/tlu/contains_if.hpp"
#include <type_traits>
#include <exception>
 
namespace maki
{
 
namespace detail
{
    enum class machine_operation: char
    {
        start,
        stop,
        process_event
    };
}
 
#define MAKI_DETAIL_MAYBE_CATCH(statement) /*NOLINT(cppcoreguidelines-macro-usage)*/ \
    if constexpr(detail::is_null_v<typename option_set_type::exception_handler_type>) \
    { \
        statement; \
    } \
    else \
    { \
        try \
        { \
            statement; \
        } \
        catch(...) \
        { \
            impl_of(conf).exception_handler(*this, std::current_exception()); \
        } \
    }

template<const auto& Conf>
class machine
{
public:
    static constexpr const auto& conf = Conf;
 
#ifndef MAKI_DETAIL_DOXYGEN
    using option_set_type = std::decay_t<decltype(impl_of(conf))>;
#endif
 
#ifdef MAKI_DETAIL_DOXYGEN
    using context_type = IMPLEMENTATION_DETAIL;
#else
    using context_type = typename option_set_type::context_type;
#endif
 
    static_assert
    (
        detail::is_machine_conf_v<std::decay_t<decltype(conf)>>,
        "Given `Conf` must be an instance of `maki::machine_conf`"
    );

    template<class... ContextArgs>
    explicit machine(ContextArgs&&... ctx_args):
        ctx_holder_(*this, std::forward<ContextArgs>(ctx_args)...),
        impl_(*this, context())
    {
        if constexpr(impl_of(conf).auto_start)
        {
            //start
            execute_operation_now<detail::machine_operation::start>(events::start{});
        }
    }
 
    machine(const machine&) = delete;
    machine(machine&&) = delete;
    machine& operator=(const machine&) = delete;
    machine& operator=(machine&&) = delete;
    ~machine() = default;

    context_type& context()
    {
        return ctx_holder_.get();
    }

    const context_type& context() const
    {
        return ctx_holder_.get();
    }

    [[nodiscard]] bool running() const
    {
        return !impl_.completed();
    }

    template<class Event = events::start>
    void start(const Event& event = {})
    {
        MAKI_DETAIL_MAYBE_CATCH(start_no_catch(event))
    }

    template<class Event = events::stop>
    void stop(const Event& event = {})
    {
        MAKI_DETAIL_MAYBE_CATCH(stop_no_catch(event))
    }

    template<class Event>
    void process_event(const Event& event)
    {
        MAKI_DETAIL_MAYBE_CATCH(process_event_no_catch(event))
    }

    template<class Event>
    void process_event_no_catch(const Event& event)
    {
        execute_operation<detail::machine_operation::process_event>(event);
    }

    template<class Event>
    void process_event_now(const Event& event)
    {
        MAKI_DETAIL_MAYBE_CATCH(process_event_now_no_catch(event))
    }

    template<class Event>
    bool check_event(const Event& event) const
    {
        auto processed = false;
        impl_.template call_internal_action<true>(*this, context(), event, processed);
        return processed;
    }

    template<class Event>
    MAKI_NOINLINE void push_event(const Event& event)
    {
        MAKI_DETAIL_MAYBE_CATCH(push_event_no_catch(event))
    }

    template<int Index>
    [[nodiscard]] const auto& region() const
    {
        return impl_.template region<Index>();
    }

    template<const auto& StateBuilder>
    [[nodiscard]] const auto& state() const
    {
        return impl_.template state<StateBuilder>();
    }

    template<const auto& StateBuilder>
    [[nodiscard]] bool is() const
    {
        return impl_.template is<StateBuilder>();
    }
 
private:
    class executing_operation_guard
    {
    public:
        executing_operation_guard(machine& self):
            self_(self)
        {
            self_.executing_operation_ = true;
        }
 
        executing_operation_guard(const executing_operation_guard&) = delete;
        executing_operation_guard(executing_operation_guard&&) = delete;
        executing_operation_guard& operator=(const executing_operation_guard&) = delete;
        executing_operation_guard& operator=(executing_operation_guard&&) = delete;
 
        ~executing_operation_guard()
        {
            self_.executing_operation_ = false;
        }
 
    private:
        machine& self_; //NOLINT(cppcoreguidelines-avoid-const-or-ref-data-members)
    };
 
    struct real_operation_queue_holder
    {
        template<bool = true> //Dummy template for lazy evaluation
        using type = detail::function_queue
        <
            machine&,
            impl_of(conf).small_event_max_size,
            impl_of(conf).small_event_max_align
        >;
    };
    struct empty_holder
    {
        template<bool = true> //Dummy template for lazy evaluation
        struct type{};
    };
    using operation_queue_type = typename std::conditional_t
    <
        impl_of(conf).run_to_completion,
        real_operation_queue_holder,
        empty_holder
    >::template type<>;
 
    template<class Event>
    void start_no_catch(const Event& event)
    {
        if(!running())
        {
            execute_operation<detail::machine_operation::start>(event);
        }
    }
 
    template<class Event>
    void stop_no_catch(const Event& event)
    {
        if(running())
        {
            execute_operation<detail::machine_operation::stop>(event);
        }
    }
 
    template<class Event>
    void process_event_now_no_catch(const Event& event)
    {
        static_assert
        (
            impl_of(conf).process_event_now_enabled,
            "`maki::machine_conf::process_event_now_enabled()` hasn't been set to `true`"
        );
        execute_operation_now<detail::machine_operation::process_event>(event);
    }
 
    template<detail::machine_operation Operation, class Event>
    void execute_operation(const Event& event)
    {
        if constexpr(impl_of(conf).run_to_completion)
        {
            if(!executing_operation_) //If call is not recursive
            {
                execute_operation_now<Operation>(event);
            }
            else
            {
                //Push event to RTC queue in case of recursive call
                push_event_impl<Operation>(event);
            }
        }
        else
        {
            execute_one_operation<Operation>(event);
        }
    }
 
    template<detail::machine_operation Operation, class Event>
    void execute_operation_now(const Event& event)
    {
        if constexpr(impl_of(conf).run_to_completion)
        {
            auto grd = executing_operation_guard{*this};
 
            execute_one_operation<Operation>(event);
 
            //Process enqueued events, if any
            operation_queue_.invoke_and_pop_all(*this);
        }
        else
        {
            execute_one_operation<Operation>(event);
        }
    }
 
    template<class Event>
    MAKI_NOINLINE void push_event_no_catch(const Event& event)
    {
        static_assert(impl_of(conf).run_to_completion);
        push_event_impl<detail::machine_operation::process_event>(event);
    }
 
    template<detail::machine_operation Operation, class Event>
    void push_event_impl(const Event& event)
    {
        operation_queue_.template push<any_event_visitor<Operation>>(event);
    }

    void process_pending_events()
    {
        if(!executing_operation_)
        {
            auto grd = executing_operation_guard{*this};
            operation_queue_.invoke_and_pop_all(*this);
        }
    }
 
    template<detail::machine_operation Operation>
    struct any_event_visitor
    {
        template<class Event>
        static void call(const Event& event, machine& self)
        {
            self.execute_one_operation<Operation>(event);
        }
    };
 
    template<detail::machine_operation Operation, class Event>
    void execute_one_operation(const Event& event)
    {
        if constexpr(Operation == detail::machine_operation::start)
        {
            impl_.call_entry_action(*this, context(), event);
        }
        else if constexpr(Operation == detail::machine_operation::stop)
        {
            impl_.exit_to_finals(*this, context(), event);
        }
        else
        {
            constexpr auto has_matching_pre_processing_hook = detail::tlu::contains_if_v
            <
                pre_processing_hook_ptr_constant_list,
                detail::event_action_traits::for_event<Event>::template has_containing_event_set
            >;
 
            constexpr auto has_matching_post_processing_hook = detail::tlu::contains_if_v
            <
                post_processing_hook_ptr_constant_list,
                detail::event_action_traits::for_event<Event>::template has_containing_event_set
            >;
 
            //If running, execute pre-processing hook for `Event`, if any.
            if constexpr(has_matching_pre_processing_hook)
            {
                if(running())
                {
                    detail::call_matching_event_action<pre_processing_hook_ptr_constant_list>
                    (
                        *this,
                        context(),
                        event
                    );
                }
            }
 
            /*
            If running:
            - process the event;
            - execute the post-processing hook for `Event`, if any.
            */
            if constexpr(has_matching_post_processing_hook)
            {
                if(running())
                {
                    auto processed = false;
                    impl_.template call_internal_action<false>(*this, context(), event, processed);
                    detail::call_matching_event_action<post_processing_hook_ptr_constant_list>
                    (
                        *this,
                        context(),
                        event,
                        processed
                    );
                }
            }
            else
            {
                /*
                Note: We don't need to check if we're running here, as
                processing the event won't have any effect anyway if the machine
                is stopped.
                */
 
                impl_.template call_internal_action<false>(*this, context(), event);
            }
        }
    }
 
    static constexpr auto pre_processing_hooks = impl_of(conf).pre_processing_hooks;
    static constexpr auto post_processing_hooks = impl_of(conf).post_processing_hooks;
    static constexpr auto path = detail::path{};
 
    using pre_processing_hook_ptr_constant_list = detail::tuple_to_element_ptr_constant_list_t<pre_processing_hooks>;
    using post_processing_hook_ptr_constant_list = detail::tuple_to_element_ptr_constant_list_t<post_processing_hooks>;
 
    detail::context_holder<context_type, impl_of(conf).context_sig> ctx_holder_;
    detail::state_impls::composite_no_context<&conf, path> impl_;
    bool executing_operation_ = false;
    operation_queue_type operation_queue_;
};
 
#undef MAKI_DETAIL_MAYBE_CATCH
 
} //namespace
 
#endif