stateMachineEngine.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_COMPONENTFRAMEWORK_STATEMACHINEENGINE_HPP
#define RTCTK_COMPONENTFRAMEWORK_STATEMACHINEENGINE_HPP
 
#include <rtctk/componentFramework/exceptions.hpp>
#include <rtctk/componentFramework/stopToken.hpp>
 
#include <rad/signal.hpp>
#include <rad/smAdapter.hpp>
 
namespace rtctk::componentFramework {
 
using ActionMethod = std::function<void(scxml4cpp::Context* c)>;
using GuardMethod = std::function<bool(scxml4cpp::Context* c)>;
using ActivityMethod = std::function<void(StopToken f)>;
using SuccessMethod = std::function<void()>;
using FailureMethod = std::function<void(std::exception_ptr)>;
using RejectMethod = std::function<void(const rad::AnyEvent&, const std::string& state)>;
using StateMethod = std::function<void(const std::string&)>;
 
class StateMachineEngine {
public:
    StateMachineEngine();
    ~StateMachineEngine();
 
    void RegisterExitEvent(rad::UniqueEvent exit_event);
 
    void RegisterModel(const std::string& name, const std::string& model);
 
    void AppendModel(const std::string& name, const std::string& model);
 
    void RegisterAction(std::string const& id, ActionMethod action);
 
    template <class Event>
    void RegisterActionStatic(std::string const& id, std::function<void(Event const&)> action) {
        assert(action);
        RegisterAction(id, [action = std::move(action)](scxml4cpp::Context* ctx) {
            assert(ctx);
            assert(ctx->getLastEvent());
            rad::SMEvent& ev = static_cast<rad::SMEvent&>(*ctx->getLastEvent());
            action(static_cast<Event const&>(ev.GetEv()));
        });
    }
 
    void RegisterGuard(std::string const& id, GuardMethod guard);
 
    template <class Event>
    void RegisterGuardStatic(std::string const& id, std::function<bool(Event const&)> guard) {
        assert(guard);
        RegisterGuard(id, [guard = std::move(guard)](scxml4cpp::Context* ctx) -> bool {
            assert(ctx);
            assert(ctx->getLastEvent());
            assert(ctx->getLastEvent()->getId() == Event::ID);
            rad::SMEvent& ev = static_cast<rad::SMEvent&>(*ctx->getLastEvent());
            return guard(static_cast<Event const&>(ev.GetEv()));
        });
    }
 
    void RegisterActivity(std::string const& id,
                          ActivityMethod activity,
                          SuccessMethod on_success,
                          FailureMethod on_failure);
 
    void RegisterRejectHandler(std::string const& id, RejectMethod reject);
 
    template <typename T, typename Ex>
    void RegisterRejectHandler() {
        RegisterRejectHandler(T::ID, [](const rad::AnyEvent& event, std::string const& state) {
            if (auto req = rad::GetPayloadNothrow<T>(event); req) {
                req->SetException(Ex{T::ID, state});
            }
        });
    }
 
    void RegisterStateChangeHandler(StateMethod on_statechange);
 
    void PostEvent(rad::SharedEvent s);
 
    std::string GetState();
 
    void Work();
 
    void Stop();
 
private:
    class MyEventListener : public scxml4cpp::EventListener {
    public:
        MyEventListener(rad::SMAdapter& engine);
        void notifyEvent(scxml4cpp::Event* ptr) override;
        void RegisterCallback(StateMethod cb);
 
    private:
        rad::SMAdapter& m_fsm_engine;
        StateMethod m_cb;
        std::string m_prev_state;
    };
 
    log4cplus::Logger& m_logger;
 
    boost::asio::io_service m_io_service;
    scxml4cpp::Context m_fsm_ctx;
    scxml4cpp::EventQueue m_event_queue;
    rad::SMAdapter m_fsm_engine;
    std::unique_ptr<rad::Signal> m_signal;
    std::unique_ptr<MyEventListener> m_event_listener;
    rad::UniqueEvent m_exit_event;
 
    struct Model {
        std::string name;
        std::string model;
    };
 
    Model m_core_model;
    std::list<Model> m_models_to_append;
    std::list<scxml4cpp::Action*> m_action_list;
    std::list<scxml4cpp::Activity*> m_activity_list;
};
 
template <typename EVENT>
std::shared_ptr<typename EVENT::payload_t> GetPayloadNothrow(scxml4cpp::Context* c) {
    rad::SMEvent* ev = dynamic_cast<rad::SMEvent*>(c->getLastEvent());
    if (ev == nullptr) {
        return nullptr;
    }  // Action has no event
 
    auto req = rad::GetPayloadNothrow<EVENT>(ev->GetEv());
    if (req == nullptr) {
        return nullptr;
    }  // Event has no associated request
 
    return std::make_shared<typename EVENT::payload_t>(*req);
}
 
}  // namespace rtctk::componentFramework
 
#endif  // RTCTK_COMPONENTFRAMEWORK_STATEMACHINEENGINE_HPP