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 <rad/exceptions.hpp>
 
#include <mal/rr/ServerContextProvider.hpp>
#include <mal/utility/future.hpp>
#include <mal/MalException.hpp>
 
#include <type_traits>
#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&) = default;
    Request(Request&&) noexcept(std::is_nothrow_move_constructible<REQ_TYPE>()) = default;
 
    Request& operator=(const Request&) = default;
    Request& operator=(Request&&) noexcept(std::is_nothrow_move_assignable_v<REQ_TYPE>) = 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);
        try {
            m_rep_promise->set_value(reply);
        } catch(boost::wrapexcept<boost::promise_already_satisfied>& e) {
            RAD_LOG_THROW(rad::Exception, GetLogger(), "Reply or Exception was already sent.");
        }
    }
 
    template <class T>
    void SetException(const T& e) const {
        // EICSSW-1303 Exception type T must derive from elt::mal::MalException
        static_assert(std::is_base_of_v<elt::mal::MalException, T>,
                      "T must derive from MalException");
        RAD_TRACE(GetLogger());
        RAD_ASSERTPTR(m_rep_promise);
        try {
            m_rep_promise->set_exception(boost::copy_exception(e));
        } catch(boost::wrapexcept<boost::promise_already_satisfied>& e1) {
            RAD_LOG_THROW(rad::Exception, GetLogger(), "Reply or Exception was already sent.");
        }
    }
 
   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&) = default;
    Request(Request&&) noexcept = default;
 
    Request& operator=(const Request&) = default;
    Request& operator=(Request&&) noexcept = 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);
        try {
            m_rep_promise->set_value(reply);
        } catch(boost::wrapexcept<boost::promise_already_satisfied>& e) {
            RAD_LOG_THROW(rad::Exception, GetLogger(), "Reply or Exception was already sent.");
        }
    }
 
    template <class T>
    void SetException(const T& e) const {
        // EICSSW-1303 Exception type T must derive from elt::mal::MalException
        static_assert(std::is_base_of_v<elt::mal::MalException, T>,
                      "T must derive from MalException");
        RAD_TRACE(GetLogger());
        RAD_ASSERTPTR(m_rep_promise);
        try {
            m_rep_promise->set_exception(boost::copy_exception(e));
        } catch(boost::wrapexcept<boost::promise_already_satisfied>& e1) {
            RAD_LOG_THROW(rad::Exception, GetLogger(), "Reply or Exception was already sent.");
        }
    }
 
   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&) = default;
    RequestAmi(RequestAmi&&) noexcept(std::is_nothrow_move_constructible<REQ_TYPE>()) = default;
    // @}
 
    // @{
    RequestAmi& operator=(const RequestAmi&) = default;
    RequestAmi&
    operator=(RequestAmi&&) noexcept(std::is_nothrow_move_assignable_v<REQ_TYPE>) = 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&) = default;
    RequestAmi(RequestAmi&&) noexcept = default;
    // @}
 
    // @{
    RequestAmi& operator=(const RequestAmi&) = default;
    RequestAmi& operator=(RequestAmi&&) noexcept = 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