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

#include "config.h"

#include "ServiceReply.hpp"

#include "EntityDescriptionRepository.hpp"
#include "ServiceTypeDescription.hpp"
#include "ServiceInterfaceDescription.hpp"
#include "ServiceInstanceDescription.hpp"


#include <DataFactory.hpp>
#include <Exception.hpp>
#include <Service.hpp>


using namespace mermaid::support::service;

using mermaid::support::data::DataFactory;
using mermaid::support::errorhandling::Exception;

ServiceReply::ServiceReply()
{
};

//ServiceReply::ServiceReply(std::string requesterEntityName, std::string requesterServiceName,std::string targetEntityName, std::string targetServiceName, std::string targetServiceInterfaceName, int requestId, std::string executionStatus)
ServiceReply::ServiceReply (shared_ptr<ServiceRequest> originalRequest, std::string executionStatus)
{
  requesterEntityName_ = originalRequest->getRequesterEntityName();
  requesterServiceName_ = originalRequest->getRequesterServiceName();
  targetEntityName_ = originalRequest->getTargetEntityName();
  targetServiceName_ = originalRequest->getTargetServiceName();
  targetServiceInterfaceName_ = originalRequest->getTargetServiceInterfaceName();
  requestId_ = originalRequest->getRequestId();
  executionStatus_ = executionStatus;
  
  
  std::string outputDataName = EntityDescriptionRepository::getInstance()->getEntityDescription (targetEntityName_)->getServiceInstanceDescription (targetServiceName_)->getServiceTypeDescriptionWithInterfaceName (targetServiceInterfaceName_)->getServiceInterfaceDescription (targetServiceInterfaceName_)->getServiceInterfaceOutputDataName();
  
  replyDataBox_ = DataFactory::buildDataBox (outputDataName);
}; // ServiceReply()

ServiceReply::ServiceReply (const ServiceReply &sr)
{
  throw Exception ("ServiceReply::ServiceReply(const ServiceReply &sr)");
}; // copy constructor

ServiceReply& ServiceReply::operator= (const ServiceReply & sr)
{
  throw Exception ("ServiceReply::operator=(const ServiceReply &sr)");
}; // assignment operator

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

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

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

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

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

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

bool ServiceReply::executionIsOk()
{
  return executionStatus_.compare ("OK") == 0;
}; // executionIsOk()

std::string ServiceReply::getExecutionStatus()
{
  return executionStatus_;
}; // getExecutionStatus()

/*shared_ptr<DataValueVector> ServiceReply::getReplyValueVector()
{
    if(replyValueVector_ == false)
    {
        throw Exception("ServiceReply::getReplyValueVector() : reply value vector is not valid");
    }
    return replyValueVector_;
    return replyDataBox_->getDataValueVector();
}; // getReplyData()*/

/*void ServiceReply::setReplyValueVector(shared_ptr<DataValueVector> valueVector)
{
    replyValueVector_ = valueVector;
}; // setReplyValueVector()*/

shared_ptr<DataBox> ServiceReply::getReplyDataBox()
{
  if (replyDataBox_ == false) {
    throw Exception ("ServiceReply::getReplyDataBox() : reply data box is not valid");
  }
  return replyDataBox_;
}; // getReplyDataBox()

void ServiceReply::setReplyDataBox (shared_ptr<DataBox> dataBox)
{
  replyDataBox_ = dataBox;
}; // setReplyDataBox()