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

#include "config.h"

#include "YarpServiceAsynchOutputPort.hpp"
#include "PortNamingConvention.hpp"

#include <Entity.hpp>
#include <EntityDescription.hpp>
#include <Exception.hpp>
#include <Service.hpp>
#include <ServiceInterfaceDescription.hpp>

#include <yarp/os/all.h>

#include <iostream>

using namespace mermaid::support::communication;

using mermaid::support::errorhandling::Exception;
using mermaid::support::service::Entity;
using mermaid::support::service::EntityDescription;
using mermaid::support::service::Service;
using mermaid::support::service::ServiceInterfaceDescription;

using yarp::os::Network;

YarpServiceAsynchOutputPort::YarpServiceAsynchOutputPort (shared_ptr<Service> targetService, std::string requesterEntityName, std::string requesterServiceName) : BufferedPort<YarpServiceAsynchReplyType>()
{
  //std::cerr << "YarpServiceAsynchOutputPort::YarpServiceAsynchOutputPort(clientName=" << clientName << " ,serviceName=" << serviceName << ")" << std::endl;
  
  targetService_ = targetService;
  requesterEntityName_ = requesterEntityName;
  requesterServiceName_ = requesterServiceName;
  
  std::string targetEntityName = targetService->getEntity()->getEntityDescription()->getEntityName();
  std::string targetServiceName = targetService->getServiceInstanceDescription()->getServiceInstanceName();
  
  std::string outputPortName = PortNamingConvention::getServiceRequestOutputPortName (targetEntityName, targetServiceName, requesterEntityName, requesterServiceName);
  
  //open port
  if (!open (outputPortName.c_str())) {
    throw Exception ("YarpServiceAsynchOutputPort::YarpServiceAsynchOutputPort: could not open YARP port with name: " + outputPortName);
  }
  
  //set strict output
  this->setStrict (true);
  
}; // YarpServiceAsynchOutputPort


YarpServiceAsynchReplyType& YarpServiceAsynchOutputPort::prepare()
{
  //chack if we are connected
  if (getOutputCount() == 0) {
    std::string targetEntityName = targetService_->getEntity()->getEntityDescription()->getEntityName();
    std::string targetServiceName = targetService_->getServiceInstanceDescription()->getServiceInstanceName();
    
    std::string requesterServiceReplyPortName = PortNamingConvention::getServiceRequestReplyPortName (requesterEntityName_, requesterServiceName_, targetEntityName, targetServiceName);
    
    // connect to other port
    bool connectOk = Network::connect (this->getName().c_str(), requesterServiceReplyPortName.c_str());
    if (!connectOk) {
      throw Exception ("YarpServiceAsynchOutputPort::prepare() : could not connect to client with port name: \"" + requesterServiceReplyPortName + "\"");
    }
    else {
      //std::cerr << "YarpServiceAsynchOutputPort::prepare : CONNECT : connecting " << this->getName() << " to " << clientPortName << std::endl;
    }
  };
  
  return BufferedPort<YarpServiceAsynchReplyType>::prepare();
}; // prepare()