MsgRequestorRaw.hpp

Go to the documentation of this file.

#ifndef RAD_MSG_REQUESTOR_RAW_HPP
#define RAD_MSG_REQUESTOR_RAW_HPP

#include <chrono>

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

#include <boost/asio.hpp>

#include <google/protobuf/message.h>

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

namespace rad {

class MsgRequestorRaw {

public:
    MsgRequestorRaw(const std::string& endpoint,
                    const std::string& identity,
                    boost::asio::io_service& ios,
                    std::function<void(const std::error_code& errCode, const std::string& msgTypeId, const void* pData, const size_t dataSize)>  replyHandler);
    virtual ~MsgRequestorRaw();

    size_t  Send(const std::string& payloadType, const std::string& payload, const long timeout = 0);

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

private:
    void ReplyCallback(const boost::system::error_code& errCode, azmq::message& msg, size_t nbytes);
    void TimeoutCallback(const boost::system::error_code& errCode);
    bool InstallTimer(const long timeout /*msec*/);
    void CancelTimer();

    std::string                 mEndpoint;
    std::string                 mIdentity;
    boost::asio::io_service&    mIOS;
    azmq::dealer_socket         mSocket;
    boost::asio::deadline_timer* mDeadlineTimer;

    std::function<void(const std::error_code& errCode, std::string const& msgTypeId, const void* pData, const size_t dataSize)> mReplyHandler;
};

struct MsgRequestorRaw2 {
    using handler_t = std::function<void(const std::error_code& /*errCode*/,
                                         std::string const& /*msgTypeId*/,
                                         const void* /*pData*/,
                                         const size_t /*dataSize*/)>;
    MsgRequestorRaw2(const std::string& endpoint,
                     const std::string& identity,
                     boost::asio::io_service& ios);
    ~MsgRequestorRaw2();

    size_t AsyncSendReceive(std::string const& payloadType,
                            std::string const& payload,
                            handler_t handler,
                            std::chrono::milliseconds const timeout = std::chrono::milliseconds(0));
    size_t AsyncSend(std::string const& payloadType,
                     std::string const& payload);
    void AsyncReceive(handler_t handler,
                      std::chrono::milliseconds const timeout = std::chrono::milliseconds(0));
    void Cancel() noexcept;

    MsgRequestorRaw2(const MsgRequestorRaw2&) = delete;
    MsgRequestorRaw2& operator=(const MsgRequestorRaw2&) = delete;
    MsgRequestorRaw2(MsgRequestorRaw2&&) = default;
    MsgRequestorRaw2& operator=(MsgRequestorRaw2&&) = default;

private:
    std::string m_endpoint;
    std::string m_identity;
    boost::asio::io_service& m_io_ctx;
    azmq::dealer_socket m_socket;
    handler_t m_handler;
};

} // namespace rad

#endif