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

#include "config.h"

#include "YarpServiceAsynchRequestType.hpp"

#include <DataBox.hpp>
#include <DataFactory.hpp>
#include <EntityDescription.hpp>
#include <EntityDescriptionRepository.hpp>
#include <Service.hpp>
#include <ServiceInstanceDescription.hpp>
#include <ServiceInterfaceDescription.hpp>
#include <ServiceTypeDescription.hpp>
#include <ServiceTypeDescriptionRepository.hpp>
#include <Exception.hpp>

#include <iostream>

using namespace mermaid::support::communication;

using mermaid::support::data::DataBox;
using mermaid::support::data::DataValueVector;
using mermaid::support::data::DataFactory;
using mermaid::support::errorhandling::Exception;
using mermaid::support::service::EntityDescription;
using mermaid::support::service::EntityDescriptionRepository;
using mermaid::support::service::Service;
using mermaid::support::service::ServiceInstanceDescription;
using mermaid::support::service::ServiceInterfaceDescription;
using mermaid::support::service::ServiceTypeDescription;
using mermaid::support::service::ServiceTypeDescriptionRepository;


using yarp::os::ConstString;
using yarp::os::Value;


YarpServiceAsynchRequestType::YarpServiceAsynchRequestType()
{
  //std::cerr << "YarpServiceAsynchRequestType::YarpServiceAsynchRequestType()" << std::endl;
  //validData_ = false;
}; // YarpYarpServiceAsynchRequestType()

YarpServiceAsynchRequestType::YarpServiceAsynchRequestType (std::string requesterEntityName, std::string requesterServiceName, std::string targetEntityName, std::string targetServiceName, std::string targetServiceInterfaceName, int requestId)
{
  requesterEntityName_ = requesterEntityName;
  requesterServiceName_ = requesterServiceName;
  targetEntityName_ = targetEntityName;
  targetServiceName_ = targetServiceName;
  targetServiceInterfaceName_ = targetServiceInterfaceName;
  requestId_ = requestId;
  //validData_ = true;
};

YarpServiceAsynchRequestType::YarpServiceAsynchRequestType (const YarpServiceAsynchRequestType &ysart)
{
  //throw Exception("YarpServiceAsynchRequestType::YarpServiceAsynchRequestType(const YarpServiceAsynchRequestType &ysart)");
  
  requesterEntityName_ = ysart.requesterEntityName_;
  requesterServiceName_ = ysart.requesterServiceName_;
  targetEntityName_ = ysart.targetEntityName_;
  targetServiceName_ = ysart.targetServiceName_;
  targetServiceInterfaceName_ = ysart.targetServiceInterfaceName_;
  requestId_ = ysart.requestId_;
  requestData_ = Bottle (ysart.requestData_);
  
}; // copy constructor


YarpServiceAsynchRequestType& YarpServiceAsynchRequestType::operator= (const YarpServiceAsynchRequestType & ysart)
{
  throw Exception ("YarpServiceAsynchRequestType::operator=");
}; // assignment operator

bool YarpServiceAsynchRequestType::write (ConnectionWriter& connection)
{
  //std::cerr << "YarpServiceAsynchRequestType::write()" << std::endl;
  
  /*if(validData_ == false)
  {
      return false;
  }*/
  
  //sleep(5);
  Bottle b = Bottle();
  /*connection.appendInt(BOTTLE_TAG_LIST);
  connection.appendInt(4); // 4 elements
  connection.appendInt(BOTTLE_TAG_STRING);
  connection.appendString(clientName_.c_str());
  connection.appendInt(BOTTLE_TAG_STRING);
  connection.appendString(serviceInterfaceName_.c_str());
  connection.appendInt(BOTTLE_TAG_INT);
  connection.appendInt(requestId_);*/
  //std::cerr << "YarpServiceAsynchRequestType::write() : writing data bottle" << std::endl;
  /*connection.appendInt(BOTTLE_TAG_LIST);
  bool writeOk = requestData_.write(connection);*/
  
  b.addString (requesterEntityName_.c_str());
  b.addString (requesterServiceName_.c_str());
  b.addString (targetEntityName_.c_str());
  b.addString (targetServiceName_.c_str());
  b.addString (targetServiceInterfaceName_.c_str());
  b.addInt (requestId_);
  Bottle& d = b.addList();
  //std::cerr << "Service Request Data:" << requestData_.toString().c_str() << std::endl;
  for (int i = 0; i < (int) requestData_.size(); i++) {
    d.add (requestData_.get (i));
  }
  //std::cerr << "YarpServiceAsynchRequestType::write : writing bottle:" << b.toString().c_str() << std::endl;
  bool writeOk = b.write (connection);
  
  
  connection.convertTextMode(); // if connection is text-mode, convert!
  
  /*if(writeOk)
  {
      std::cerr << "YarpServiceAsynchRequestType::write : write OK" << std::endl;
  }
  else
  {
      std::cerr << "YarpServiceAsynchRequestType::write : write FAILED" << std::endl;
  }*/
  return writeOk;
}; // write()


bool YarpServiceAsynchRequestType::read (ConnectionReader& connection)
{
  try {
    connection.convertTextMode(); // if connection is text-mode, convert!
    
    Bottle b = Bottle();
    bool readOk = b.read (connection);
    
    int bottleSize = b.size();
    if (bottleSize != 7) {
      std::cerr << "YarpServiceAsynchRequestType::read : size of the bottle should be 7, but it is: " << bottleSize << std::endl;
      return false;
    }
    
    
    Value requesterEntityNameValue = b.get (0);
    if (requesterEntityNameValue.isString() == false) {
      std::cerr << "YarpServiceAsynchRequestType::read : expected a string at position 0 of the bottle" << std::endl;
      return false;
    }
    requesterEntityName_ = std::string (requesterEntityNameValue.asString().c_str());
    
    Value requesterServiceNameValue = b.get (1);
    if (requesterServiceNameValue.isString() == false) {
      std::cerr << "YarpServiceAsynchRequestType::read : expected a string at position 1 of the bottle" << std::endl;
      return false;
    }
    requesterServiceName_ = std::string (requesterServiceNameValue.asString().c_str());
    
    Value targetEntityNameValue = b.get (2);
    if (targetEntityNameValue.isString() == false) {
      std::cerr << "YarpServiceAsynchRequestType::read : expected a string at position 2 of the bottle" << std::endl;
      return false;
    }
    targetEntityName_ = std::string (targetEntityNameValue.asString().c_str());
    
    Value targetServiceNameValue = b.get (3);
    if (targetServiceNameValue.isString() == false) {
      std::cerr << "YarpServiceAsynchRequestType::read : expected a string at position 3 of the bottle" << std::endl;
      return false;
    }
    targetServiceName_ = std::string (targetServiceNameValue.asString().c_str());
    
    Value targetServiceInterfaceValue = b.get (4);
    if (targetServiceInterfaceValue.isString() == false) {
      std::cerr << "YarpServiceAsynchRequestType::read : expected a string at position 4 of the bottle" << std::endl;
      return false;
    }
    targetServiceInterfaceName_ = std::string (targetServiceInterfaceValue.asString().c_str());
    
    Value requestIdValue = b.get (5);
    if (requestIdValue.isInt() == false) {
      std::cerr << "YarpServiceAsynchRequestType::read : expected an int at position 5 of the bottle" << std::endl;
    }
    requestId_ = requestIdValue.asInt();
    
    Value dataValue = b.get (6);
    if (dataValue.isList() == false) {
      std::cerr << "YarpServiceAsynchRequestType::read : expected a list at position 6 of the bottle" << std::endl;
    }
    
    requestData_ = Bottle (*dataValue.asList()); //! @TODO check if we can skip using the copy-constructor
    
    return readOk;
  }
  catch (...) {
    std::cerr << "YarpServiceAsynchRequestType: got a very strange exception" << std::endl;
    return false;
  }
}


void YarpServiceAsynchRequestType::setTargetEntityName (std::string targetEntityName)
{
  targetEntityName_ = targetEntityName;
}
void YarpServiceAsynchRequestType::setTargetServiceName (std::string targetServiceName)
{
  targetServiceName_ = targetServiceName;
};

std::string YarpServiceAsynchRequestType::getRequesterEntityName()
{
  return requesterEntityName_;
}; // getRequesterEntityName()

std::string YarpServiceAsynchRequestType::getRequesterServiceName()
{
  return requesterServiceName_;
}; // getRequesterServiceName()

std::string YarpServiceAsynchRequestType::getTargetEntityName()
{
  return targetEntityName_;
}; // getTargetEntityName()

std::string YarpServiceAsynchRequestType::getTargetServiceName()
{
  return targetServiceName_;
}; // getTargetServiceName()

std::string YarpServiceAsynchRequestType::getTargetServiceInterfaceName()
{
  return targetServiceInterfaceName_;
}; // getServiceInterfaceName()

int YarpServiceAsynchRequestType::getRequestId()
{
  return requestId_;
}; // getRequestId()

Bottle& YarpServiceAsynchRequestType::getRequestData()
{
  return requestData_;
}; // getRequestData()

void YarpServiceAsynchRequestType::convertFromServiceRequest (ServiceRequest &sar)
{
  requesterEntityName_ = sar.getRequesterEntityName();
  requesterServiceName_ = sar.getRequesterServiceName();
  targetEntityName_ = sar.getTargetEntityName();
  targetServiceName_ = sar.getTargetServiceName();
  targetServiceInterfaceName_ = sar.getTargetServiceInterfaceName();
  requestId_ = sar.getRequestId();
  requestData_.clear();
  DataFactory::writeDataBoxToBottle (sar.getRequestDataBox(), requestData_);
  
}; // convertFromServiceRequest()

shared_ptr<ServiceRequest> YarpServiceAsynchRequestType::convertToServiceRequest()
{

  shared_ptr<ServiceTypeDescription> serviceTypeDescription = EntityDescriptionRepository::getInstance()->getEntityDescription (targetEntityName_)->getServiceInstanceDescription (targetServiceName_)->getServiceTypeDescriptionWithInterfaceName (targetServiceInterfaceName_);
  
  std::string structureName = serviceTypeDescription->getServiceInterfaceDescription (targetServiceInterfaceName_)->getServiceInterfaceInputDataName();
  shared_ptr<DataBox> box = DataFactory::buildDataBoxFromStructureAndBottle (structureName, requestData_);
  
  shared_ptr<ServiceRequest> request (new ServiceRequest (requesterEntityName_, requesterServiceName_, targetEntityName_, targetServiceName_, targetServiceInterfaceName_, requestId_));
  request->setRequestDataBox (box);
  
  return request;
}; // convertToServiceRequest


/*YarpServiceAsynchRequestType& YarpServiceAsynchRequestType::operator=(ServiceRequest &sar)
{
    requesterEntityName_ = sar.getRequesterEntityName();
    requesterServiceName_= sar.getRequesterServiceName();
    serviceInterfaceName_ = sar.getServiceInterfaceName();
    requestId_ = sar.getRequestId();
    requestData_ = *sar.getRequestData()->getDataValueVector();
    validData_ = true;
    return *this;
}; // operator=()

YarpServiceAsynchRequestType::operator ServiceRequest ()
{
    CowPtr<DataBox> requestData = DataFactory::buildDataBoxFromStructureAndBottle(requestData_);
    return ServiceRequest(requesterEntityName_, requesterServiceName_, serviceInterfaceName_, requestId_, requestData);
}; // operator ServiceRequest &()*/