SMAdapter.hpp

Go to the documentation of this file.

#ifndef RAD_SM_ADAPTER_HPP
#define RAD_SM_ADAPTER_HPP

#include <rad/Dispatcher.hpp>
#include <rad/AnyEvent.hpp>
#include <rad/MsgHandler.hpp>
#include <rad/MsgReplier.hpp>
#include <rad/TopicSub.hpp>

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

#include <boost/asio.hpp>
#include <rad/SMEvent.hpp>

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

namespace rad {

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

    void  Load(const std::string& filename,
               std::list<scxml4cpp::Action*>* actionList,
               std::list<scxml4cpp::Activity*>* activityList);

    void RegisterEvents(std::vector<rad::EventInfo>& events);
    void UnregisterEvents();
    void EventCallback(const AnyEvent& e);

    void Start();
    void Stop();

    void PostEvent(UniqueEvent&& e);

    void ProcessEvent();
    void ProcessEvent(scxml4cpp::Event* 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&   mIOS;
    Dispatcher&                mEventDispatcher;
    std::list<Dispatcher::token_t> mEventHandlersTokens;
    scxml4cpp::Context*        mContext;
    scxml4cpp::EventQueue&     mExternalEvents;
    scxml4cpp::Helper          mHelper;
    scxml4cpp::Executor*       mExecutor;
    scxml4cpp::StateMachine    mModel;
    std::string                mModelName;
    SMEvent                    mEvent;

    void Cleanup();
};


template<typename EventType>
std::function<void (const std::string&, const std::string&, const void*, size_t)> ReqProcessEvent(SMAdapter& sm)
{
    RAD_LOG_TRACE();

    return [& /*sm*/] (const std::string& identity, const std::string& requestName, const void* pMsg, size_t msgSize) {
        auto ev = ParseRequestAndCreateEvent<EventType>(identity, requestName, pMsg, msgSize);
        sm.EventCallback(ev);  // Process event
    };
}

template<typename EventType>
std::function<void (const std::string&, const void*, size_t)> TopicProcessEvent(SMAdapter& sm)
{
    RAD_LOG_TRACE();

    return [& /*sm*/] (const std::string& topicName, const void* pMsg, size_t msgSize) {
        auto ev = ParseTopicAndCreateEvent<EventType>(topicName, pMsg, msgSize);
        sm.EventCallback(ev);  // Process event
    };
}


} // namespace rad

#endif