YarpServiceAsynchRequestPort.cpp

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 YarpServiceAsynchRequestPort.cpp
 * @Description YarpServiceAsynchRequestPort implementation
 * @Status Work in Progress
 * @Version $Id: YarpServiceAsynchRequestPort.cpp 1 2011-03-04 18:13:18Z jreis $
 * @Maintainer
 */

#include "config.h"

#include "YarpServiceAsynchRequestPort.hpp"
#include "YarpServiceRequestPortReporter.hpp"
#include "PortNamingConvention.hpp"

#include <Exception.hpp>

#include <yarp/os/all.h>

#include <iostream>

using namespace mermaid::support::communication;

using mermaid::support::errorhandling::Exception;
using yarp::os::Network;

YarpServiceAsynchRequestPort::YarpServiceAsynchRequestPort (shared_ptr<Service> requesterService, shared_ptr<ServiceRequest> request) : BufferedPort<YarpServiceAsynchRequestType>()
{
  //std::cerr << "YarpServiceAsynchRequestPort::YarpServiceAsynchRequestPort(clientName=" << clientName << " ,serviceName=" << serviceName << ")" << std::endl;
  
  requesterService_ = requesterService;
  request_ = request;
  
  
  std::string requesterEntityName = request_->getRequesterEntityName();
  std::string requesterServiceName = request_->getRequesterServiceName();
  std::string targetEntityName = request_->getTargetEntityName();
  std::string targetServiceName = request_->getTargetServiceName();
  
  
  std::string portName = PortNamingConvention::getServiceRequestRequestPortName (requesterEntityName, requesterServiceName, targetEntityName, targetServiceName);
  
  //open port
  if (!open (portName.c_str())) {
    throw Exception ("YarpServiceAsynchRequestPort::YarpServiceAsynchRequestPort : could not open YARP port with name: " + portName);
  }
  
  //set strict output
  this->setStrict (true);
  
  //add reporter to port
  setReporter (* (new YarpServiceRequestPortReporter (this)));
  
}; // YarpServiceAsynchRequestPort()


YarpServiceAsynchRequestType& YarpServiceAsynchRequestPort::prepare()
{

  //std::cerr << "YarpServiceAsynchRequestPort::prepare : output count=" << getOutputCount() << std::endl;
  
  //check if we are connected
  if (getOutputCount() == 0) {
    std::string targetServiceInputPortName;
#ifdef USE_COMM
    std::string requesterEntityName = request_->getRequesterEntityName();
    std::string targetEntityName = request_->getTargetEntityName();
    if (requesterEntityName == targetEntityName)
      targetServiceInputPortName = PortNamingConvention::getServiceRequestInputPortName (targetEntityName, request_->getTargetServiceName());
    else
      targetServiceInputPortName = PortNamingConvention::getServiceRequestInputPortName (requesterEntityName, "COMM");
#else
    targetServiceInputPortName = PortNamingConvention::getServiceRequestInputPortName (request_->getTargetEntityName(), request_->getTargetServiceName());
#endif
      
    // connect to other port
    bool connectOk = Network::connect (this->getName().c_str(), targetServiceInputPortName.c_str());
    if (!connectOk) {
      throw Exception ("YarpServiceAsynchRequestPort::prepare() : could not connect to service with port name: " + targetServiceInputPortName);
    }
    else {
      //std::cerr << "YarpServiceAsynchRequestPort::prepare : CONNECT : connecting " << this->getName() << " to " << servicePortName << std::endl;
    }
    
  };
  
  return BufferedPort<YarpServiceAsynchRequestType>::prepare();
}; // prepare()