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