request.hpp

Go to the documentation of this file.

 
#ifndef RAD_MAL_REQUEST_HPP
#define RAD_MAL_REQUEST_HPP
 
#include <rad/assert.hpp>
#include <rad/logger.hpp>
 
#include <mal/rr/ServerContextProvider.hpp>
#include <mal/utility/future.hpp>
 
#include <string>
 
namespace rad {
namespace cii {
 
template <typename REP_TYPE, typename REQ_TYPE = void>
class Request {
   public:
    explicit Request(const REQ_TYPE& req_payload)
        : m_req_payload(req_payload),
          m_rep_promise(std::make_shared<elt::mal::promise<REP_TYPE>>()) {
        RAD_TRACE(GetLogger());
    }
 
    Request(const Request& r) = default;
 
    Request& operator=(const Request& r) = default;
 
    const REQ_TYPE& GetRequestPayload() const {
        RAD_TRACE(GetLogger());
        return m_req_payload;
    }
 
    elt::mal::future<REP_TYPE> GetReplyFuture() const {
        RAD_TRACE(GetLogger());
        RAD_ASSERTPTR(m_rep_promise);
        return m_rep_promise->get_future();
    }
 
    void SetReplyValue(const REP_TYPE& reply) const {
        RAD_TRACE(GetLogger());
        RAD_ASSERTPTR(m_rep_promise);
        m_rep_promise->set_value(reply);
    }
 
    template <class T>
    void SetException(const T& e) const {
        RAD_TRACE(GetLogger());
        RAD_ASSERTPTR(m_rep_promise);
        m_rep_promise->set_exception(boost::copy_exception(e));
    }
 
   private:
    REQ_TYPE m_req_payload;  // Payload associated to the request.
    /*
     *  We need a shared pointer to make Request copyable so
     *  it can be used as payload for the rad::Event class.
     */
    std::shared_ptr<elt::mal::promise<REP_TYPE>>
        m_rep_promise;  // Pointer to the promise associated to the reply.
};
 
template <class REP_TYPE>
class Request<REP_TYPE, void> {
   public:
    Request() : m_rep_promise(std::make_shared<elt::mal::promise<REP_TYPE>>()) {
        RAD_TRACE(GetLogger());
    }
 
    Request(const Request& r) = default;
 
    Request& operator=(const Request& r) = default;
 
    elt::mal::future<REP_TYPE> GetReplyFuture() const {
        RAD_TRACE(GetLogger());
        RAD_ASSERTPTR(m_rep_promise);
        return m_rep_promise->get_future();
    }
 
    void SetReplyValue(const REP_TYPE& reply) const {
        RAD_TRACE(GetLogger());
        RAD_ASSERTPTR(m_rep_promise);
        m_rep_promise->set_value(reply);
    }
 
    template <class T>
    void SetException(const T& e) const {
        RAD_TRACE(GetLogger());
        RAD_ASSERTPTR(m_rep_promise);
        m_rep_promise->set_exception(boost::copy_exception(e));
    }
 
   private:
    /*
     *  We need a shared pointer to make Request copyable so
     *  it can be used as payload for the rad::Event class.
     */
    std::shared_ptr<elt::mal::promise<REP_TYPE>>
        m_rep_promise;  // Pointer to the promise associated to the reply.
};
 
template <typename REP_TYPE, typename REQ_TYPE = void>
class RequestAmi {
   public:
    explicit RequestAmi(const REQ_TYPE& req_payload) {
        RAD_TRACE(GetLogger());
        m_server_ami = elt::mal::rr::ServerContextProvider::getInstance<
                           elt::mal::rr::ServerContext<REP_TYPE>>()
                           .createAmi();
    }
 
    RequestAmi(const RequestAmi& r) = default;
 
    RequestAmi& operator=(const RequestAmi& r) = default;
 
    const REQ_TYPE& GetRequestPayload() const {
        RAD_TRACE(GetLogger());
        return m_req_payload;
    }
 
    bool SetPartialReplyValue(const REP_TYPE& reply) const {
        RAD_TRACE(GetLogger());
        return m_server_ami->complete(reply);
    }
 
    bool SetFinalReplyValue(const REP_TYPE& reply) const {
        RAD_TRACE(GetLogger());
        return m_server_ami->completed(reply);
    }
 
    std::shared_ptr<::elt::mal::rr::Ami<REP_TYPE>> GetAmiServer() {
        RAD_TRACE(GetLogger());
        return m_server_ami;
    }
 
   private:
    REQ_TYPE m_req_payload;  // Payload associated to the request.
    std::shared_ptr<::elt::mal::rr::Ami<REP_TYPE>>
        m_server_ami;  // Pointer to the AMI object dealing with multiple replies.
};
 
template <class REP_TYPE>
class RequestAmi<REP_TYPE, void> {
   public:
    RequestAmi() {
        RAD_TRACE(GetLogger());
        m_server_ami = elt::mal::rr::ServerContextProvider::getInstance<
                           elt::mal::rr::ServerContext<REP_TYPE>>()
                           .createAmi();
    }
 
    RequestAmi(const RequestAmi& r) = default;
 
    RequestAmi& operator=(const RequestAmi& r) = default;
 
    bool SetPartialReplyValue(const REP_TYPE& reply) const {
        RAD_TRACE(GetLogger());
        return m_server_ami->complete(reply);
    }
 
    bool SetFinalReplyValue(const REP_TYPE& reply) const {
        RAD_TRACE(GetLogger());
        return m_server_ami->completed(reply);
    }
 
    std::shared_ptr<::elt::mal::rr::Ami<REP_TYPE>> GetAmiServer() {
        RAD_TRACE(GetLogger());
        return m_server_ami;
    }
 
   private:
    std::shared_ptr<::elt::mal::rr::ServerAmi<REP_TYPE>>
        m_server_ami;  // Pointer to the AMI object dealing with multiple replies.
};
 
}  // namespace cii
}  // namespace rad
 
#endif  // RAD_MAL_REQUEST_HPP