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/Dispatcher.hpp>
#include <rad/MsgRequestor.hpp>
#include <rad/MsgHandler.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_service& ios,
                rad::Dispatcher& dispatcher,
                UniqueEvent&& okEvent,
                UniqueEvent&& errEvent,
                UniqueEvent&& timeoutEvent);
    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& errCode, TYPEREP reply);

    MsgRequestor<TYPEREQ, TYPEREP> mMsgRequestor;
    rad::Dispatcher&        mDispatcher;
    UniqueEvent             mOkEvent;
    UniqueEvent             mErrEvent;
    UniqueEvent             mTimeoutEvent;
    TYPEREP                 mReplyPayload;
};



template<typename TYPEREQ, typename TYPEREP>
SMRequestor<TYPEREQ, TYPEREP>::SMRequestor(const std::string& endpoint,
                                           const std::string& identity,
                                           boost::asio::io_service& ios,
                                           Dispatcher& dispatcher,
                                           UniqueEvent&& okEvent,
                                           UniqueEvent&& errEvent,
                                           UniqueEvent&& timeoutEvent)
: mMsgRequestor(endpoint, identity, ios, std::bind(&SMRequestor<TYPEREQ, TYPEREP>::ReplyHandler, this, std::placeholders::_1, std::placeholders::_2)),
  mDispatcher(dispatcher),
  mOkEvent(std::move(okEvent)),
  mErrEvent(std::move(errEvent)),
  mTimeoutEvent(std::move(timeoutEvent))
{
    RAD_LOG_TRACE();
}

template<typename TYPEREQ, typename TYPEREP>
SMRequestor<TYPEREQ, TYPEREP>::~SMRequestor()
{
    RAD_LOG_TRACE();
}

template<typename TYPEREQ, typename TYPEREP>
size_t SMRequestor<TYPEREQ, TYPEREP>::Send(const TYPEREQ& payload, const long timeout)
{
    RAD_LOG_TRACE();
    return mMsgRequestor.Send(payload, timeout);
}

template<typename TYPEREQ, typename TYPEREP>
void SMRequestor<TYPEREQ, TYPEREP>::ReplyHandler(const std::error_code& errCode, TYPEREP reply)
{
    RAD_LOG_TRACE();

    if (!errCode) {
        mReplyPayload = reply;

        // @todo check if it is OK/ERR reply
        mDispatcher.dispatch(*mOkEvent);
    } else if (errCode == rad::ErrorCodes::REPLY_TIMEOUT) {
        mDispatcher.dispatch(*mTimeoutEvent);
    }
    //mDispatcher.dispatch(*mErrEvent);
}

template<typename TYPEREQ, typename TYPEREP>
const TYPEREP& SMRequestor<TYPEREQ, TYPEREP>::GetReplyPayload()
{
    RAD_LOG_TRACE();
    return mReplyPayload;
}

} // namespace rad

#endif