MsgReplier.hpp

Go to the documentation of this file.

#ifndef RAD_MSG_REPLIER_HPP
#define RAD_MSG_REPLIER_HPP

#include <rad/MsgHandler.hpp>
#include <rad/Logger.hpp>
#include <rad/Assert.hpp>

#include <azmq/socket.hpp>
#include <azmq/message.hpp>

#include <boost/asio.hpp>

#include <map>


namespace rad {

class MsgReplier {

public:
    using MsgHandler_t = std::function<void (const std::string&, const std::string&, const void*, size_t)>;
    using MsgHandlerMap_t =  std::unordered_map<std::string, MsgHandler_t>;

    MsgReplier(const std::string& endpoint,
               boost::asio::io_service& ios,
               std::unique_ptr<MsgHandler>&& fallbackHandler);
    virtual ~MsgReplier();
    MsgReplier(MsgReplier&&) = default;

    void Start();
    void Stop();

    void AddMsgHandler(const std::string& requestName, MsgHandler_t handler);

    size_t Send(const std::string& identity,
                const std::string& replyType,
                const std::string& replyPayload);

    template<typename REPLY>
    size_t Send(const std::string& identity, const REPLY& replyPayload);

    MsgReplier(const MsgReplier&) = delete;
    MsgReplier& operator= (const MsgReplier&) = delete;

private:
    std::string                 mEndpoint;
    boost::asio::io_service&    mIOS;
    azmq::router_socket         mSocket;
    std::unique_ptr<MsgHandler> mFallbackHandler;
    MsgHandlerMap_t             mHandlersMap;

    void Register();
    void Callback(boost::system::error_code const& errorCode, azmq::message& msg, size_t nbytes);
};

template<typename TYPEREP>
size_t MsgReplier::Send(const std::string& identity, const TYPEREP& replyPayload)
{
    RAD_LOG_TRACE();

    RAD_ASSERTPTR(replyPayload.GetDescriptor());
    std::string replyType = replyPayload.GetDescriptor()->full_name();

    std::string str;
    if (replyPayload.SerializeToString(&str) == false) {
        RAD_LOG_ERROR() << "Failed serializing to string payload type <" << replyType << ">";
        return 0;
    }

    return Send(identity, replyType, str);
}

} // namespace rad

#endif