CommunicationGateway.hpp

Go to the documentation of this file.

/*
Copyright 2007, 2008, 2009, 2010, 2011 Instituto de Sistemas e Robotica, Instituto Superior Tecnico

This file is part of MeRMaID.

MeRMaID is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

MeRMaID is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with MeRMaID.  If not, see <http://www.gnu.org/licenses/>.
*/



/**
 * @Filename CommunicationGateway.hpp
 * @Description CommunicationGateway declaration
 * @Status Work in Progress
 * @Version $Id: CommunicationGateway.hpp 1 2011-03-04 18:13:18Z jreis $
 * @Maintainer
 */

#ifndef __COMMUNICATION_COMMUNICATIONGATEWAY_H
#define __COMMUNICATION_COMMUNICATIONGATEWAY_H

namespace mermaid
{
  namespace support
  {
    namespace communication
    {
      class CommunicationGateway;
    }
  }
}


#include <DataBox.hpp>

#include "YarpDataFeedInputPort.hpp"
#include "YarpDataFeedOutputPort.hpp"
#include "YarpServiceAsynchInputPort.hpp"
#include "YarpServiceAsynchReplyPort.hpp"
#include "YarpServiceAsynchRequestPort.hpp"
#include "YarpServiceAsynchOutputPort.hpp"

#ifdef USE_COMM
#include <Task.hpp>
#endif

#include <map>
#include <vector>

namespace mermaid
{
  namespace support
  {
    namespace communication
    {
      using mermaid::support::data::DataBox;
      using boost::shared_ptr;
      
      using mermaid::support::service::Service;
      using mermaid::support::service::ServiceReply;
      using mermaid::support::service::ServiceRequest;
      using std::vector;
      
#ifdef USE_COMM
      using mermaid::support::activeobject::Task;
#endif
      
      /**
      * @Class CommunicationGateway CommunicationGateway.hpp "CommunicationGateway.hpp"
      * @Description CommunicationGateway class.
      * @Author Marco Barbosa
      */
      class CommunicationGateway
      {
        public:
        
          CommunicationGateway();
          ~CommunicationGateway();
          
          //service stuff
          
          void registerService (shared_ptr<Service> s);
          void sendServiceRequest (shared_ptr<Service> requesterService, shared_ptr<ServiceRequest> sr);
          
          void sendServiceReply (shared_ptr<Service> targetService, std::string requesterEntityName, std::string requesterServiceName, shared_ptr<ServiceReply> sr);
          
          
          shared_ptr<YarpServiceAsynchRequestPort> getYarpServiceAsynchRequestPort (shared_ptr<Service> requesterService, shared_ptr<ServiceRequest> request);
          
          shared_ptr<YarpServiceAsynchReplyPort> getYarpServiceAsynchReplyPort (std::string targetEntityName, std::string targetServiceName, std::string requesterEntityName, std::string requesterServiceName);
          
          shared_ptr<YarpServiceAsynchOutputPort> getYarpServiceAsynchOutputPort (shared_ptr<Service> targetService, std::string requesterEntityName, std::string requesterServiceName);
          
          
          //data feed stuff
//                     void initializeDataFeed(std::string serviceName, std::string dataFeedName);
          void sendToDataFeed (std::string entityName, std::string serviceName, std::string dataFeedName, shared_ptr<DataBox> dataBox);
          void connectToDataFeed (std::string producerEntityName, std::string producerServiceName, std::string datafeedName, shared_ptr<Service> consumerService);
          
          
          void addYarpDataFeedOutputPort (shared_ptr<YarpDataFeedOutputPort> outputPort);
          shared_ptr<YarpDataFeedOutputPort> getYarpDataFeedOutputPort (std::string entityName, std::string serviceName, std::string feedName);
          
          void addYarpDataFeedInputPort (shared_ptr<YarpDataFeedInputPort> inputPort);
          shared_ptr<YarpDataFeedInputPort> getYarpDataFeedInputPort (std::string consumerEntityName, std::string consumerServiceName, std::string producerEntityName, std::string producerServiceName, std::string dataFeedName);
          
          //ServiceRequest map access
          void registerServiceRequest (shared_ptr<ServiceRequest> request);
          shared_ptr<ServiceRequest> getServiceRequest (std::string requesterEntityName, std::string requesterServiceName, int requestId);
          void unregisterServiceRequest (std::string requesterEntityName, std::string requesterServiceName, int requestId);
          
#ifdef USE_COMM
          void addDataFeedSetupTask (shared_ptr<Task> dst);
          bool isNewDataFeedSetupTaskAvailable();
          shared_ptr<Task> getDataFeedSetupTask();
          void notifyDataFeedSetupEnded();
#endif
          
        private:
        
          //asynch service request ports
          
          //map: pair<reqEnt,reqSer>->pair<tarEnt,tarSer>->requestPort
          std::map<std::pair<std::string, std::string>, std::map<std::pair<std::string, std::string>, shared_ptr<YarpServiceAsynchRequestPort> > > serviceAsynchRequestPorts_;
          
          //map: pair<reqEnt,reqSer>->pair<tarEnt,tarSer>->replyPort
          std::map<std::pair<std::string, std::string>, std::map<std::pair<std::string, std::string>, shared_ptr<YarpServiceAsynchReplyPort> > > serviceAsynchReplyPorts_;
          
          //map: serviceName->inputPort
          std::map<std::string, shared_ptr<YarpServiceAsynchInputPort> > serviceAsynchInputPorts_;
          
          //map: pair<reqEnt,reqSer>->pair<tarEnt,tarSer>->outputPort
          std::map<std::pair<std::string, std::string>, std::map<std::pair<std::string, std::string>, shared_ptr<YarpServiceAsynchOutputPort> > > serviceAsynchOutputPorts_;
          
          //data-feed ports: consumerEntityName -> consumerServiceName -> producerEntityName -> producerServiceName -> dataFeedName -> inputPort
          std::map<std::string, std::map<std::string, std::map<std::string, std::map<std::string, std::map<std::string, shared_ptr<YarpDataFeedInputPort> > > > > > dataFeedInputPorts_;
          
          //map: entityName -> serviceName -> feedname -> outputPort
          std::map<std::string, std::map<std::string, std::map<std::string, shared_ptr<YarpDataFeedOutputPort> > > > dataFeedOutputPorts_;
          
          //map: req entity name -> req. service name -> req. id -> ServiceRequest
          std::map<std::string, std::map<std::string, std::map<int, shared_ptr<ServiceRequest> > > > serviceRequests_;
          
#ifdef USE_COMM
          //vector of data feed setup tasks
          std::vector<shared_ptr<Task> > dataFeedSetupTasks_;
          bool executingSetupTask_;
#endif
          
      }; // class CommunicationGateway
    } // namespace communication
  } // namespace support
} // namespace mermaid


#endif // __COMMUNICATION_COMMUNICATIONGATEWAY_H