msgReplier.hpp

Go to the documentation of this file.

#ifndef RAD_MSG_REPLIER_HPP
#define RAD_MSG_REPLIER_HPP

#include <rad/assert.hpp>
#include <rad/logger.hpp>
#include <rad/msgHandler.hpp>

#include <azmq/message.hpp>
#include <azmq/socket.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>&& fallback_handler);
    virtual ~MsgReplier();
    MsgReplier(MsgReplier&&) = default;

    void Start();
    void Stop();

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

    size_t Send(const std::string& identity, const std::string& reply_type,
                const std::string& reply_payload);

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

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

   private:
    std::string m_endpoint;
    boost::asio::io_service& m_ios;
    azmq::router_socket m_socket;
    std::unique_ptr<MsgHandler> m_fallback_handler;
    MsgHandlerMap_t m_handlers_map;

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

template <typename TYPEREP>
size_t MsgReplier::Send(const std::string& identity, const TYPEREP& reply_payload) {
    RAD_TRACE(GetLogger());

    RAD_ASSERTPTR(reply_payload.GetDescriptor());
    std::string reply_type = reply_payload.GetDescriptor()->full_name();

    std::string str;
    if (reply_payload.SerializeToString(&str) == false) {
        LOG4CPLUS_ERROR(GetLogger(),
                        "Failed serializing to string payload type <" << reply_type << ">");
        return 0;
    }

    return Send(identity, reply_type, str);
}

}  // namespace rad

#endif