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_context& 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_context& 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