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

#include "config.h"

#include "YarpServiceAsynchReplyType.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;


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

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

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


bool YarpServiceAsynchReplyType::write (ConnectionWriter& connection)
{
  //std::cerr << "YarpServiceAsynchReplyType::write()" << std::endl;
  
  /*if(validData_ == false)
  {
      return false;
  }*/
  
  Bottle b = Bottle();
  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();
  b.addString (executionStatus_.c_str());
  for (int i = 0; i < (int) replyData_.size(); i++) {
    d.add (replyData_.get (i));
  }
  //std::cerr << "YarpServiceAsynchReplyType::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 << "YarpServiceAsynchReplyType::write : write OK" << std::endl;
      }
      else
      {
  //         throw Exception("YarpServiceAsynchReplyType::write : write FAILED");
      }*/
  return writeOk;
}; // write()

bool YarpServiceAsynchReplyType::read (ConnectionReader& connection)
{
  //std::cerr << "YarpServiceAsynchReplyType::read()" << std::endl;
  
  //throw Exception("YarpServiceAsynchReplyType::read() : not implemented");
  
  connection.convertTextMode(); // if connection is text-mode, convert!
  
  Bottle b = Bottle();
  bool readOk = b.read (connection);
//     std::cerr << "YarpServiceAsynchReplyType::read : received bottle=\"" << b.toString().c_str() << "\"" << std::endl;

  //std::cerr << "\t" << b.toString() << std::endl;
  int bottleSize = b.size();
  if (bottleSize != 8) {
    std::cerr << "YarpServiceAsynchReplyType::read : size of the bottle should be 8, but it is: " << bottleSize << std::endl;
    return false;
  }
  
  Value requesterEntityNameValue = b.get (0);
  if (requesterEntityNameValue.isString() == false) {
    std::cerr << "YarpServiceAsynchReplyType::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 << "YarpServiceAsynchReplyType::read : expected a string at position 1 of the bottle" << std::endl;
    return false;
  }
  requesterServiceName_ = std::string (requesterServiceNameValue.asString().c_str());
//     std::cerr << "YarpServiceAsynchReplyType:read() : serviceInterfaceNameValue_=" << executionStatus_ << std::endl;

  Value targetEntityNameValue = b.get (2);
  if (targetEntityNameValue.isString() == false) {
    std::cerr << "YarpServiceAsynchReplyType::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 << "YarpServiceAsynchReplyType::read : expected a string at position 3 of the bottle" << std::endl;
    return false;
  }
  targetServiceName_ = std::string (targetServiceNameValue.asString().c_str());
  
  Value targetServiceInterfaceNameValue = b.get (4);
  if (targetServiceInterfaceNameValue.isString() == false) {
    std::cerr << "YarpServiceAsynchReplyType::read : expected a string at position 4 of the bottle" << std::endl;
    return false;
  }
  targetServiceInterfaceName_ = std::string (targetServiceInterfaceNameValue.asString().c_str());
  
  Value requestIdValue = b.get (5);
  if (requestIdValue.isInt() == false) {
    std::cerr << "YarpServiceAsynchReplyType::read : expected an int at position 5 of the bottle" << std::endl;
    return false;
  }
  requestId_ = requestIdValue.asInt();
//     std::cerr << "YarpServiceAsynchReplyType::read() : requestId_=" << requestId_ << std::endl;

  Value dataValue = b.get (6);
  if (dataValue.isList() == false) {
    std::cerr << "YarpServiceAsynchReplyType::read : expected a list at position 6 of the bottle" << std::endl;
    return false;
  }
//     std::cerr << "YarpServiceAsynchReplyType: reply data received=" << dataValue.toString().c_str() << std::endl;
  replyData_ = Bottle (*dataValue.asList()); //! @TODO check if we can skip using the copy-constructor
  //std::cerr << "YarpServiceAsynchReplyType::read : replyData_=" << replyData_.toString().c_str() << std::endl;
  
  
  Value executionStatusValue = b.get (7);
  if (executionStatusValue.isString() == false) {
    std::cerr << "YarpServiceAsynchReplyType::read : expected a string at position 7 of the bottle" << std::endl;
    return false;
  }
  executionStatus_ = std::string (executionStatusValue.asString().c_str());
//     std::cerr << "YarpServiceAsynchReplyType:read() : executionStatus_=" << executionStatus_ << std::endl;

  return readOk;
}

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

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

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

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

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

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

void YarpServiceAsynchReplyType::convertFromServiceReply (ServiceReply &sr)
{
  requesterEntityName_ = sr.getRequesterEntityName();
  requesterServiceName_ = sr.getRequesterServiceName();
  targetEntityName_ = sr.getTargetEntityName();
  targetServiceName_ = sr.getTargetServiceName();
  targetServiceInterfaceName_ = sr.getTargetServiceInterfaceName();
  requestId_ = sr.getRequestId();
  executionStatus_ = sr.getExecutionStatus();
  replyData_.clear();
  
  if (executionStatus_.compare ("OK") == 0) {
    DataFactory::writeDataBoxToBottle (sr.getReplyDataBox(), replyData_);
  }
}; // convertFromServiceReply()

shared_ptr<ServiceReply> YarpServiceAsynchReplyType::convertToServiceReply (shared_ptr<ServiceRequest> originalRequest)
{

  std::string targetEntityName = originalRequest->getTargetEntityName();
  std::string targetServiceName = originalRequest->getTargetServiceName();
  std::string targetServiceInterfaceName = originalRequest->getTargetServiceInterfaceName();
  
  shared_ptr<ServiceTypeDescription> serviceTypeDescription = EntityDescriptionRepository::getInstance()->getEntityDescription (targetEntityName)->getServiceInstanceDescription (targetServiceName)->getServiceTypeDescriptionWithInterfaceName (targetServiceInterfaceName);
  
  std::string structureName = serviceTypeDescription->getServiceInterfaceDescription (targetServiceInterfaceName)->getServiceInterfaceOutputDataName();
  shared_ptr<DataBox> box = DataFactory::buildDataBoxFromStructureAndBottle (structureName, replyData_);
  
  shared_ptr<ServiceReply> reply (new ServiceReply (originalRequest, executionStatus_));
  reply->setReplyDataBox (box);
  
  return reply;
}; // convertToServiceReply

Bottle& YarpServiceAsynchReplyType::getReplyData()
{
  return replyData_;
}; // getReplyData()