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/logger.hpp>
#include <rad/msgHandler.hpp>
#include <rad/topicHandler.hpp>
#include <rad/smEvent.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 {
 
template <typename T>
void DefaultRequestRejectHandler(const rad::AnyEvent& event, const std::string& state) {
    RAD_TRACE(GetLogger());
    auto req = rad::GetPayloadNothrow<T>(event);
    if (req == nullptr) {
        LOG4CPLUS_ERROR(GetLogger(), event.GetId() << " has no associated request!");
        return;
    }
    req->SetReplyValue("Request rejected in state " + state);
}
 
class SMAdapter : private scxml4cpp::EventListener, scxml4cpp::StatusListener {
   public:
    SMAdapter(boost::asio::io_context& 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,
              const scxml4cpp::ReplaceRules& replace_rules = scxml4cpp::ReplaceRules());
 
    void LoadFromString(const std::string& name, const std::string& model,
              std::list<scxml4cpp::Action*>* action_list,
              std::list<scxml4cpp::Activity*>* activity_list,
              const scxml4cpp::ReplaceRules& replace_rules = scxml4cpp::ReplaceRules());
 
    void Append(const std::string& filename,
                std::list<scxml4cpp::Action*>* action_list,
                std::list<scxml4cpp::Activity*>* activity_list,
                const scxml4cpp::ReplaceRules& replace_rules = scxml4cpp::ReplaceRules());
 
    void AppendFromString(const std::string& name,
                          const std::string& model,
                          std::list<scxml4cpp::Action*>* action_list,
                          std::list<scxml4cpp::Activity*>* activity_list,
                          const scxml4cpp::ReplaceRules& replace_rules =
                                  scxml4cpp::ReplaceRules());
 
    void Save(const std::string& filename);
 
    std::string GetStateMachineAsString();
 
    void Start();
 
    void Stop();
 
    void PostEvent(SharedEvent e);
 
    void ProcessEvent();
 
    void ProcessEvent(scxml4cpp::Event* e);
 
    void ProcessEvent(const AnyEvent& e);
 
    void SetStatusRepresentation(const bool use_fully_qualified_state);
 
    std::string GetStatus() const;
 
    std::list<scxml4cpp::State*> GetActiveStates();
 
    void AddStatusListener(scxml4cpp::StatusListener* listener);
 
    void RemoveStatusListener(scxml4cpp::StatusListener* listener);
 
    void AddEventListener(scxml4cpp::EventListener* listener);
 
    void RemoveEventListener(scxml4cpp::EventListener* listener);
 
    void SetStatusPublisher(std::function<void(const std::string&)> publisher);
 
    void PublishStatus();
 
    void RegisterRejectHandler(
        const std::string& id,
        std::function<void(const rad::AnyEvent&, const std::string& state)> handler);
 
    template <typename T>
    void RegisterDefaultRequestRejectHandler() {
        RAD_TRACE(GetLogger());
        LOG4CPLUS_DEBUG(GetLogger(), "Registering reject handler for event: " << T::ID);
        // std::cout << "Registering reject handler for event: " << T::ID << std::endl;
        RegisterRejectHandler(T::ID, DefaultRequestRejectHandler<T>);
    }
 
#if 0
    template <typename T>
    void RegisterDefaultRequestRejectHandler() {
        RAD_TRACE(GetLogger());
        LOG4CPLUS_DEBUG(GetLogger(), "Registering reject handler for event: " << T::ID);
        RegisterRejectHandler(T::ID, [](const rad::AnyEvent& event, std::string const& state) {
            RAD_TRACE(GetLogger());
            auto req = rad::GetPayloadNothrow<T>(event);
            if (req == nullptr) {
                LOG4CPLUS_ERROR(GetLogger(), event.GetId() << " has no associated request!");
                return;
            }
            req->SetReplyValue("Request rejected in state " + state);
        });
    }
#endif
 
    void SetLogLevel(const std::string& level);
 
    SMAdapter(const SMAdapter& e) = delete;
    SMAdapter& operator=(SMAdapter& e) = delete;
 
   private:
    boost::asio::io_context& m_ios;
    scxml4cpp::Context* m_context;
    scxml4cpp::EventQueue& m_external_events;
    scxml4cpp::Helper m_helper;
    std::unique_ptr<scxml4cpp::StateMachine> m_model;
    scxml4cpp::Executor* m_executor;
    std::string m_model_name;
    std::string m_status;
    std::string m_old_status;
    bool m_use_fully_qualified_state = false;
    SMEvent m_event;
    std::function<void(const std::string&)> m_status_publisher = nullptr;
    std::map<std::string, std::function<void(const rad::AnyEvent&, const std::string& state)>>
        m_reject_handlers;
 
    void Cleanup();
 
    void notifyStatus(std::list<scxml4cpp::State*>& status) override;
 
    void notifyEvent(scxml4cpp::Event* event) override;
};
 
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