state_machine.h

#pragma once

#include "detail/state_manager.h"
#include "contexts.h"

namespace escad
{

template<class States, class Events, class Context, class Tracer = detail::NullTracer>
class state_machine {
public:
    using context_type = Context;
    using states_type = States;
    using events_type = Events;
    using tracer_type = Tracer;

    template<
        class T = Context,
        std::enable_if_t<std::is_constructible_v<T>, bool> = true>
    state_machine()
        : context_ {}
        , manager_ {context_, tracer_}
    {
    }

    template<
        class T = Context,
        // enable this constructor only if Context is an lvalue ref
        std::enable_if_t<std::is_lvalue_reference_v<T>, bool> = true>
    state_machine(Context& ctx)
        : context_ {ctx}
        , manager_ {context_, tracer_}
    {
    }

    template<
        class T = Context,
        // enable this constructor only if Context is an rvalue ref
        std::enable_if_t<!std::is_lvalue_reference_v<T>, bool> = true>
    state_machine(Context&& ctx)
        : context_ {std::move(ctx)}
        , manager_ {context_, tracer_}
    {
    }

    template<class S, class E, class C>
    state_machine(S, E, C&& ctx)
        : context_ {std::forward<C>(ctx)}
        , manager_ {context_, tracer_}
    {
    }

    state_machine(States, Events, Context& ctx, Tracer&& tracer)
        : context_ {ctx}
        , tracer_ {std::move(tracer)}
        , manager_ {context_, tracer}
    {
    }

    template<class E>
    auto dispatch(E const& e) {
        return manager_.dispatch(e);
    }

    template<class E>
    auto dispatch(E const& e) const {
        return manager_.dispatch(e);
    }

    auto& tracer() {
        return tracer_;
    }

    auto const& tracer() const {
        return tracer_;
    }

    auto& context() {
        return context_;
    }

    auto const& context() const {
        return context_;
    }

private:
    Context                                 context_;
    Tracer                                  tracer_;
    detail::state_manager<
        States,
        std::remove_reference_t<Context>,
        Tracer>                             manager_;
};

template<class S, class E, class C> state_machine(S, E, C&) -> state_machine<S, E, C&>;
template<class S, class E, class C> state_machine(S, E, C&&) -> state_machine<S, E, C>;

} // namespace fsm