smAdapter.hpp

Go to the documentation of this file.

#ifndef RAD_SM_ADAPTER_HPP
#define RAD_SM_ADAPTER_HPP

#include <rad/anyEvent.hpp>
#include <rad/msgHandler.hpp>
#include <rad/msgReplier.hpp>
#include <rad/smEvent.hpp>
#include <rad/topicSub.hpp>

#include <scxml4cpp/Action.h>
#include <scxml4cpp/Activity.h>
#include <scxml4cpp/Context.h>
#include <scxml4cpp/DOMSCXMLReader.h>
#include <scxml4cpp/EventListener.h>
#include <scxml4cpp/EventQueue.h>
#include <scxml4cpp/Executor.h>
#include <scxml4cpp/StateMachine.h>
#include <scxml4cpp/StatusListener.h>

#include <boost/asio.hpp>

#include <list>
#include <memory>
#include <vector>

namespace rad {

class SMAdapter {
   public:
    SMAdapter(boost::asio::io_service& ios, scxml4cpp::Context* context,
              scxml4cpp::EventQueue& external_events);
    virtual ~SMAdapter();

    void Load(const std::string& filename, std::list<scxml4cpp::Action*>* action_list,
              std::list<scxml4cpp::Activity*>* activity_list);
    void Append(const std::string& filename, std::list<scxml4cpp::Action*>* action_list,
                std::list<scxml4cpp::Activity*>* activity_list);

    void Start();
    void Stop();

    void PostEvent(SharedEvent e);

    void ProcessEvent();
    void ProcessEvent(scxml4cpp::Event* e);
    void ProcessEvent(const AnyEvent& e);

    void AddStatusListener(scxml4cpp::StatusListener* listener);
    void AddEventListener(scxml4cpp::EventListener* listener);

    void SetLogLevel(const std::string& level);

    SMAdapter(const SMAdapter& e) = delete;
    SMAdapter& operator=(SMAdapter& e) = delete;

   private:
    boost::asio::io_service& m_ios;
    scxml4cpp::Context* m_context;
    scxml4cpp::EventQueue& m_external_events;
    scxml4cpp::Helper m_helper;
    scxml4cpp::Executor* m_executor;
    scxml4cpp::StateMachine m_model;
    std::string m_model_name;
    SMEvent m_event;

    void Cleanup();
};

template <typename EventType>
std::function<void(const std::string&, const std::string&, const void*, size_t)> ReqProcessEvent(
    SMAdapter& sm) {
    return [&/*sm*/](const std::string& identity, const std::string& request_name, const void* msg,
                     size_t msg_size) {
        auto ev = ParseRequestAndCreateEvent<EventType>(identity, request_name, msg, msg_size);
        sm.ProcessEvent(ev);  // Process event
    };
}

template <typename EventType>
std::function<void(const std::string&, const void*, size_t)> TopicProcessEvent(SMAdapter& sm) {
    return [&/*sm*/](const std::string& topic_name, const void* msg, size_t msg_size) {
        auto ev = ParseTopicAndCreateEvent<EventType>(topic_name, msg, msg_size);
        sm.ProcessEvent(ev);  // Process event
    };
}

}  // namespace rad

#endif  // RAD_SM_ADAPTER_HPP