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

#include "config.h"

#include "YarpDataFeedInputPort.hpp"
#include "YarpDataFeedReconnectTask.hpp"
#include "YarpDataFeedReporter.hpp"

#include <ActiveObject.hpp>

#include <DataBox.hpp>
#include <DataFactory.hpp>
#include <Entity.hpp>
#include <EntityDescription.hpp>
#include <EntityDescriptionRepository.hpp>
#include <Exception.hpp>
#include <PortNamingConvention.hpp>
#include <Service.hpp>
#include <ServiceDataFeedDeliveryTask.hpp>
#include <ServiceInstanceDescription.hpp>
#include <ServiceTypeDescription.hpp>
#include <Task.hpp>

#include <iostream>

using namespace mermaid::support::communication;

using mermaid::support::activeobject::ActiveObject;
using mermaid::support::activeobject::Task;
using mermaid::support::data::DataBox;
using mermaid::support::data::DataFactory;
using mermaid::support::errorhandling::Exception;
using boost::shared_ptr;
using mermaid::support::service::Entity;
using mermaid::support::service::EntityDescription;
using mermaid::support::service::EntityDescriptionRepository;
using mermaid::support::service::Service;
using mermaid::support::service::ServiceDataFeedDeliveryTask;
using mermaid::support::service::ServiceInstanceDescription;
using mermaid::support::service::ServiceTypeDescription;

using yarp::os::Network;

YarpDataFeedInputPort::YarpDataFeedInputPort (std::string producerEntityName, std::string producerServiceName, std::string datafeedName, shared_ptr<Service> consumerService)
{
  producerEntityName_ = producerEntityName;
  producerServiceName_ = producerServiceName;
  dataFeedName_ = datafeedName;
  consumerService_ = consumerService;
  
  std::string consumerServiceName = consumerService_->getServiceInstanceDescription()->getServiceInstanceName();
  std::string consumerEntityName = consumerService_->getEntity()->getEntityDescription()->getEntityName();
  
  std::string inputPortName = PortNamingConvention::getDataFeedInputPortName (consumerEntityName, consumerServiceName, producerEntityName_, producerServiceName_, dataFeedName_);
  
  //open port
  if (!open (inputPortName.c_str())) {
    throw Exception ("YarpDataFeedInputPort::YarpDataFeedInputPort: could not open YARP port with name: " + inputPortName);
  }
  this->useCallback();
  
  //set strict output
  this->setStrict (true);
  
  //add reporter to port
  setReporter (* (new YarpDataFeedReporter (this)));
  
  if (connect() == false) {
    std::string outputPortName = PortNamingConvention::getDataFeedOutputPortName (producerEntityName_, producerServiceName_, dataFeedName_);
    
    //schedule port reconnection
    shared_ptr<Task> reconnectTask (new YarpDataFeedReconnectTask (this));
    getConsumerService()->getActiveObject()->addTask (reconnectTask);
    //throw Exception("YarpDataFeedInputPort::YarpDataFeedInputPort : could not connect to port: " + outputPortName);
  }
  
}; // YarpDataFeedInputPort()

bool YarpDataFeedInputPort::connect()
{
  //data feed port name
  std::string outputPortName = PortNamingConvention::getDataFeedOutputPortName (producerEntityName_, producerServiceName_, dataFeedName_);
  
  return Network::connect (outputPortName.c_str(), this->getName().c_str());
  
}; // connect()

YarpDataFeedInputPort::~YarpDataFeedInputPort()
{

}; // ~YarpDataFeedInputPort()

std::string YarpDataFeedInputPort::getProducerEntityName()
{
  return producerEntityName_;
}; // getProducerEntityName()

std::string YarpDataFeedInputPort::getProducerServiceName()
{
  return producerServiceName_;
}; // getProducerServiceName()

std::string YarpDataFeedInputPort::getDataFeedName()
{
  return dataFeedName_;
}; // getDataFeedName()

shared_ptr<Service> YarpDataFeedInputPort::getConsumerService()
{
  return consumerService_;
}; // getConsumerEntityName()

void YarpDataFeedInputPort::onRead (Bottle& data)
{
  std::string dataTypeName = EntityDescriptionRepository::getInstance()->getEntityDescription (producerEntityName_)->getServiceInstanceDescription (producerServiceName_)->getServiceTypeDescriptionWithDataFeedName (dataFeedName_)->getDataFeedDescription (dataFeedName_)->getDataFeedOutputDataName();
  
//     std::cerr << "YarpDataFeedInputPort::onRead : dataTypeName=\"" << dataTypeName << "\"" << std::endl;
  shared_ptr<DataBox> db;
  
  try {
    db = DataFactory::buildDataBoxFromStructureAndBottle (dataTypeName, data);
  }
  catch (Exception e) {
    std::cerr << "YarpDataFeedInputPort::onRead : input data was not correctly formatted: discarding." << std::endl;
    return;
  }
//     db->print();

  shared_ptr<Task> dt ( (Task*) new ServiceDataFeedDeliveryTask (consumerService_, producerEntityName_, producerServiceName_, dataFeedName_, db));
  shared_ptr<ActiveObject> ao = consumerService_->getActiveObject();
  ao->addTask (dt);
  
}; // onRead()