MIRA-doc-devel/RPCClient_8h_source.html

 /*
  * Copyright (C) 2012 by
  *   MetraLabs GmbH (MLAB), GERMANY
  * and
  *   Neuroinformatics and Cognitive Robotics Labs (NICR) at TU Ilmenau, GERMANY
  * All rights reserved.
  *
  * Contact: info@mira-project.org
  *
  * Commercial Usage:
  *   Licensees holding valid commercial licenses may use this file in
  *   accordance with the commercial license agreement provided with the
  *   software or, alternatively, in accordance with the terms contained in
  *   a written agreement between you and MLAB or NICR.
  *
  * GNU General Public License Usage:
  *   Alternatively, this file may be used under the terms of the GNU
  *   General Public License version 3.0 as published by the Free Software
  *   Foundation and appearing in the file LICENSE.GPL3 included in the
  *   packaging of this file. Please review the following information to
  *   ensure the GNU General Public License version 3.0 requirements will be
  *   met: http://www.gnu.org/copyleft/gpl.html.
  *   Alternatively you may (at your option) use any later version of the GNU
  *   General Public License if such license has been publicly approved by
  *   MLAB and NICR (or its successors, if any).
  *
  * IN NO EVENT SHALL "MLAB" OR "NICR" BE LIABLE TO ANY PARTY FOR DIRECT,
  * INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF
  * THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF "MLAB" OR
  * "NICR" HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * "MLAB" AND "NICR" SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING,
  * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
  * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
  * ON AN "AS IS" BASIS, AND "MLAB" AND "NICR" HAVE NO OBLIGATION TO
  * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS OR MODIFICATIONS.
  */

 #ifndef _MIRA_RPCCLIENT_H_
 #define _MIRA_RPCCLIENT_H_

 #ifndef Q_MOC_RUN
 #include <boost/preprocessor/repetition.hpp>
 #include <boost/thread/mutex.hpp>
 #endif

 #include <serialization/ReflectorInterface.h>

 #include <rpc/AbstractRPCClient.h>
 #include <rpc/RPCSignature.h>
 #include <rpc/RPCFuture.h>


 namespace mira {


 class RPCClient : public AbstractRPCClient
 {
 protected:

     struct PendingResponseBase {
         virtual ~PendingResponseBase() {}
         virtual void handleResponse(void* responsePtr) = 0;
         virtual void handleServiceRemoved() = 0;
         virtual int getBackendTypeId() const = 0;
     };

     template <typename Backend, typename R>
     struct PendingResponse : public PendingResponseBase {

         typedef typename Backend::ClientResponse Response;

         PendingResponse() : backendTypeId(typeId<Backend>()) {}

         virtual void handleResponse(void* responsePtr) {
             Response* concreteResponsePtr = static_cast<Response*>(responsePtr);
             concreteResponsePtr->getReturn(promise);
         }

         virtual void handleServiceRemoved() {
             promise.set_exception(boost::copy_exception(XRPC("Service removed (unpublished or remote disconnected)")));
         }

         virtual int getBackendTypeId() const { return backendTypeId; }

         boost::promise<R> promise;
         int backendTypeId;
     };

     typedef boost::shared_ptr<PendingResponseBase> PendingResponsePtr;

 private:
     template<typename Backend, typename Head, typename... Tail>
     void setParameters(typename Backend::ClientRequest& request, Head&& head, Tail&&... tail)
     {
         request.setParameter(std::forward<Head>(head));
         setParameters<Backend>(request, std::forward<Tail>(tail)...);
     }

     template<typename Backend>
     void setParameters(typename Backend::ClientRequest& request)
     {}

 public:
     template<typename Backend, typename R, typename... ARGS>
     RPCFuture<R> call(typename Backend::ClientRequest& request, const std::string& service,
                       const std::string& method, ARGS&&... args)
     {
         std::string callId = request.generateCallID();
         RPCFuture<R> future = addPendingResponse<Backend, R>(callId);
         request.setHeader(std::move(callId), service, makeRPCSignature<R, ARGS...>(method));
         setParameters<Backend>(request, std::forward<ARGS>(args)...);
         return future;
     }

     template <typename Backend, typename R>
     RPCFuture<R> addPendingResponse(const std::string& callId)
     {
         boost::shared_ptr<PendingResponse<Backend, R>> ptr(new PendingResponse<Backend,R>());
         boost::mutex::scoped_lock lock(mMutex);
         // the following may overwrite an existing pending response, which is
         // okay, as it might be intended by the user.
         mPendingResponses[callId] = ptr;
         return RPCFuture<R>(ptr->promise.get_future(), this, callId);
     }

 public:

     template <typename Backend>
     std::string handleResponse(typename Backend::ClientResponse& response)
     {
         std::string callId;
         response.getHeader(callId);

         boost::mutex::scoped_lock lock(mMutex);
         auto it = mPendingResponses.find(callId);

         // if call was already removed since future was destroyed, we can skip
         // handling the response and save performance
         if(it==mPendingResponses.end())
             return "";

         // check if expected response type and the given response type do match
         if(typeId<Backend>()!=it->second->getBackendTypeId())
             MIRA_THROW(XLogical, "The expected Response Backend type does not match "
                        "the given Response. Probably you sent an RPC call with a "
                        "different Request Backend that does not match to the received "
                        "Response");

         PendingResponsePtr r = it->second;
         mPendingResponses.erase(it);
         lock.unlock();

         r->handleResponse(&response);

         // the pending response r and its promise will be destroyed here,
         // which is okay, since the value or exception was set in
         // handleResponse above, hence no "broken promise" will occur

         return callId;
     }

     void handleServiceRemoved(const std::string& callId)
     {
         boost::mutex::scoped_lock lock(mMutex);
         auto it = mPendingResponses.find(callId);

         // if call was already removed since future was destroyed, we can skip this
         if(it==mPendingResponses.end())
             return;

         PendingResponsePtr r = it->second;
         mPendingResponses.erase(it);
         lock.unlock();

         r->handleServiceRemoved();
     }

     virtual void onDestructFuture(const std::string& callId)
     {
         boost::mutex::scoped_lock lock(mMutex);
         mPendingResponses.erase(callId);
     }

 private:

     typedef std::map<std::string, PendingResponsePtr> PendingResponses;
     PendingResponses mPendingResponses;
     boost::mutex mMutex;
 };


 }


 #endif
mira::typeId
TypeId typeId()
Generates unique IDs for different types.
Definition: TypeId.h:94

mira::RPCClient
The RPCClient is responsible for handling the client-side of an rpc call.
Definition: RPCClient.h:103

mira::RPCClient::PendingResponseBase::handleServiceRemoved
virtual void handleServiceRemoved()=0

mira::RPCClient::handleServiceRemoved
void handleServiceRemoved(const std::string &callId)
Definition: RPCClient.h:293

mira
specialize cv::DataType for our ImgPixel and inherit from cv::DataType<Vec>
Definition: IOService.h:67

mira::RPCClient::PendingResponse
PendingResponse template class.
Definition: RPCClient.h:135

mira::RPCClient::PendingResponseBase::getBackendTypeId
virtual int getBackendTypeId() const =0

RPCFuture.h
Implementation of RPCFuture.

mira::RPCFuture
An RPCFuture is a proxy for the result of an asynchronous RPC call.
Definition: RPCFuture.h:173

MIRA_THROW
#define MIRA_THROW(ex, msg)
Macro for throwing an exception.
Definition: Exception.h:81

mira::RPCClient::addPendingResponse
RPCFuture< R > addPendingResponse(const std::string &callId)
Adds a new "PendingResponse" object for a call (with the specified callid) that was either generated ...
Definition: RPCClient.h:241

ReflectorInterface.h
Contains the base interface of all Reflectors, Serializers, etc.

AbstractRPCClient.h
Abstract interface for RPCClient.

mira::AbstractRPCClient
Abstract interface for RPCClient.
Definition: AbstractRPCClient.h:60

mira::XRPC
An exception that is thrown by the RPCServer if an RPC call fails.
Definition: RPCError.h:76

RPCSignature.h
RPCSignature for storing all information about an RPC method signature.

mira::RPCClient::PendingResponse::backendTypeId
int backendTypeId
Definition: RPCClient.h:167

mira::RPCClient::PendingResponseBase::~PendingResponseBase
virtual ~PendingResponseBase()
Definition: RPCClient.h:112

mira::RPCClient::PendingResponseBase
Interface for PendingResponse.
Definition: RPCClient.h:111

mira::RPCClient::PendingResponsePtr
boost::shared_ptr< PendingResponseBase > PendingResponsePtr
Definition: RPCClient.h:170

mira::RPCClient::onDestructFuture
virtual void onDestructFuture(const std::string &callId)
Is called by the RPCFutures that are created by the call() method upon the destruction of the RPCFutu...
Definition: RPCClient.h:314

mira::RPCClient::PendingResponse::handleResponse
virtual void handleResponse(void *responsePtr)
Handles the response by calling getReturn() of the RPCResponse backend.
Definition: RPCClient.h:146

mira::RPCClient::PendingResponse::handleServiceRemoved
virtual void handleServiceRemoved()
Handles the service being removed before a response is received.
Definition: RPCClient.h:154

mira::RPCClient::call
RPCFuture< R > call(typename Backend::ClientRequest &request, const std::string &service, const std::string &method, ARGS &&... args)
Generates an RPCRequest for an RPC call.
Definition: RPCClient.h:218

mira::RPCClient::PendingResponse::PendingResponse
PendingResponse()
Definition: RPCClient.h:139

mira::RPCClient::PendingResponse::Response
Backend::ClientResponse Response
Definition: RPCClient.h:137

mira::RPCClient::PendingResponseBase::handleResponse
virtual void handleResponse(void *responsePtr)=0

mira::RPCClient::PendingResponse::getBackendTypeId
virtual int getBackendTypeId() const
Returns the (non portable) type id of the used backend.
Definition: RPCClient.h:163

mira::RPCClient::PendingResponse::promise
boost::promise< R > promise
The boost::promise object that is used for generating and setting the RPCFuture.
Definition: RPCClient.h:166

mira::RPCClient::handleResponse
std::string handleResponse(typename Backend::ClientResponse &response)
Is called after the RPCServer has sent the response of the RPC call to handle the response and to set...
Definition: RPCClient.h:260