smRequestor.hpp

Go to the documentation of this file.

 
#ifndef RAD_SM_REQUESTOR_HPP
#define RAD_SM_REQUESTOR_HPP
 
#include <rad/anyEvent.hpp>
#include <rad/logger.hpp>
#include <rad/msgHandler.hpp>
#include <rad/msgRequestor.hpp>
#include <rad/smAdapter.hpp>
 
#include <functional>
 
namespace rad {
 
template <typename TYPEREQ, typename TYPEREP>
class SMRequestor {
   public:
    SMRequestor(const std::string& endpoint, const std::string& identity,
                boost::asio::io_context& ios, SMAdapter& sm, UniqueEvent&& ok_event,
                UniqueEvent&& err_event, UniqueEvent&& timeout_event);
    virtual ~SMRequestor();
 
    size_t Send(const TYPEREQ& payload, const long timeout = 0);
 
    const TYPEREP& GetReplyPayload();
 
    SMRequestor(const SMRequestor&) = delete;
    SMRequestor& operator=(const SMRequestor&) = delete;
 
   private:
    void ReplyHandler(const std::error_code& err_code, TYPEREP reply);
 
    MsgRequestor<TYPEREQ, TYPEREP> m_msg_requestor;
    SMAdapter& m_sm;
    UniqueEvent m_ok_event;
    UniqueEvent m_err_event;
    UniqueEvent m_timeout_event;
    TYPEREP m_reply_payload;
};
 
template <typename TYPEREQ, typename TYPEREP>
SMRequestor<TYPEREQ, TYPEREP>::SMRequestor(const std::string& endpoint, const std::string& identity,
                                           boost::asio::io_context& ios, SMAdapter& sm,
                                           UniqueEvent&& ok_event, UniqueEvent&& err_event,
                                           UniqueEvent&& timeout_event)
    : m_msg_requestor(endpoint, identity, ios,
                      std::bind(&SMRequestor<TYPEREQ, TYPEREP>::ReplyHandler, this,
                                std::placeholders::_1, std::placeholders::_2)),
      m_sm(sm),
      m_ok_event(std::move(ok_event)),
      m_err_event(std::move(err_event)),
      m_timeout_event(std::move(timeout_event)) {
    RAD_TRACE(GetLogger());
}
 
template <typename TYPEREQ, typename TYPEREP>
SMRequestor<TYPEREQ, TYPEREP>::~SMRequestor() {
    RAD_TRACE(GetLogger());
}
 
template <typename TYPEREQ, typename TYPEREP>
size_t SMRequestor<TYPEREQ, TYPEREP>::Send(const TYPEREQ& payload, const long timeout) {
    RAD_TRACE(GetLogger());
    return m_msg_requestor.Send(payload, timeout);
}
 
template <typename TYPEREQ, typename TYPEREP>
void SMRequestor<TYPEREQ, TYPEREP>::ReplyHandler(const std::error_code& err_code, TYPEREP reply) {
    RAD_TRACE(GetLogger());
 
    if (err_code == rad::ErrorCodes::REPLY_TIMEOUT) {
        LOG4CPLUS_DEBUG(GetLogger(), "Triggering timeout event.");
        m_sm.ProcessEvent(*m_timeout_event);
    } else {
        LOG4CPLUS_DEBUG(GetLogger(), "Triggering OK reply event.");
        m_reply_payload = reply;
        // TODO check if it is OK/ERR reply
        m_sm.ProcessEvent(*m_ok_event);
    }
}
 
template <typename TYPEREQ, typename TYPEREP>
const TYPEREP& SMRequestor<TYPEREQ, TYPEREP>::GetReplyPayload() {
    RAD_TRACE(GetLogger());
    return m_reply_payload;
}
 
}  // namespace rad
 
#endif  // RAD_SM_REQUESTOR_HPP