DeploymentConfiguration.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 DeploymentConfiguration.cpp
 * @Description Implementation of the DeploymentConfiguration class
 * @Status Implementing
 * @Version $Id: DeploymentConfiguration.cpp 1 2011-03-04 18:13:18Z jreis $
 * @Maintainer Marco Barbosa (mafb@isr.ist.utl.pt)
 */

#include "config.h"

#include "DeploymentConfiguration.hpp"

#include <Exception.hpp>

#include <XmlCharData.hpp>
#include <XmlElement.hpp>
#include <XmlElementVector.hpp>


#include <ActiveObjectConfiguration.hpp>
#include <ServiceDeploymentConfiguration.hpp>

#include <iostream>
#include <iterator>
#include <sstream>

using namespace mermaid::mermaidloader;

using std::string;

using mermaid::support::errorhandling::Exception;

using mermaid::support::xml::XmlCharData;
using mermaid::support::xml::XmlElement;
using mermaid::support::xml::XmlElementVector;

void DeploymentConfiguration::loadConfiguration (shared_ptr<XmlDocument> config)
{
  //std::cerr << "DeploymentConfiguration::loadConfiguration" << std::endl;
  
  _dataDescriptionFileList.clear();
  _serviceTypeDescriptionFileList.clear();
  _entityDescriptionFileList.clear();
  _activeObjectMap.clear();
  _activeObjectBelongedServices.clear();
  _serviceMap.clear();
  
  
  shared_ptr<XmlElement> rootElement = config->getRootElement();
  
  if (rootElement->getName().compare ("deployment-configuration") != 0) {
    throw Exception ("DeploymentConfiguration::loadConfiguration : invalid configuration");
  }
  
  XmlElementVector childrenElements = rootElement->getChildrenElements();
  
  XmlElementVector::iterator it;
  
  for (it = childrenElements.begin(); it != childrenElements.end(); it++) {
    shared_ptr<XmlElement> e = *it;
    
    //std::cerr << "DeploymentConfiguration::loadConfiguration : reading element: " << (string)*e << std::endl;
    
    if (e->getName().compare ("file-search-path") == 0) {
      shared_ptr<XmlCharData> pathCharData = e->getFirstNonBlankCharData();
      std::string path = (std::string) ( (*pathCharData));
      _fileSearchPathList.push_back (path);
    }
    else if (e->getName().compare ("data-description-file") == 0) {
      shared_ptr<XmlCharData> filenameCharData = e->getFirstNonBlankCharData();
      std::string filename = (std::string) ( (*filenameCharData));
      _dataDescriptionFileList.push_back (filename);
    }
    else if (e->getName().compare ("service-type-description-file") == 0) {
      shared_ptr<XmlCharData> filenameCharData = e->getFirstNonBlankCharData();
      std::string filename = (std::string) ( (*filenameCharData));
      _serviceTypeDescriptionFileList.push_back (filename);
    }
    else if (e->getName().compare ("entity-description-file") == 0) {
      shared_ptr<XmlCharData> filenameCharData = e->getFirstNonBlankCharData();
      std::string filename = (std::string) ( (*filenameCharData));
      _entityDescriptionFileList.push_back (filename);
    }
    else if (e->getName().compare ("active-object") == 0) {
      //std::cerr << "Processing active-object configuration" << std::endl;
      shared_ptr<ActiveObjectConfiguration> aoc = shared_ptr<ActiveObjectConfiguration> (new ActiveObjectConfiguration (e));
      if (_activeObjectMap.count (aoc->getName()) != 0) {
        throw Exception ("DeploymentConfiguration::loadConfiguration : more than one Active Object with the same name:" + aoc->getName());
      }
      _activeObjectMap[aoc->getName() ] = aoc;
      _activeObjectBelongedServices[aoc->getName() ] = vector< shared_ptr<ServiceDeploymentConfiguration> >();
    }
    else if (e->getName().compare ("service") == 0) {
      //std::cerr << "Processing service configuration" << std::endl;
      shared_ptr<ServiceDeploymentConfiguration> sc = shared_ptr<ServiceDeploymentConfiguration> (new ServiceDeploymentConfiguration (e));
      if (_serviceMap.count (sc->getServiceInstanceName()) != 0) {
        throw Exception ("DeploymentConfiguration::loadConfiguration : more than one Service with the same instance name:" + sc->getServiceInstanceName());
      }
      _serviceMap[sc->getServiceInstanceName() ] = sc;
      
      vector< shared_ptr<ServiceDeploymentConfiguration> > aoBelongedServiceVector = _activeObjectBelongedServices[sc->getServiceActiveObjectName() ];
      aoBelongedServiceVector.push_back (sc);
      _activeObjectBelongedServices[sc->getServiceActiveObjectName() ] = aoBelongedServiceVector;
    }
    else {
      throw Exception ("DeploymentConfiguration::loadConfiguration : invalid configuration");
    }
  }
  
}; // DeploymentConfiguration::loadConfiguration

FileSearchPathList DeploymentConfiguration::getFileSearchPathList()
{
  return _fileSearchPathList;
}; // DeploymentConfiguration::getFileSearchPathList()

DataDescriptionFileList DeploymentConfiguration::getDataDescriptionFileList()
{
  return _dataDescriptionFileList;
}; // DeploymentConfiguration::getDataDescriptionFileList()

ServiceTypeDescriptionFileList DeploymentConfiguration::getServiceTypeDescriptionFileList()
{
  return _serviceTypeDescriptionFileList;
}; // DeploymentConfiguration::getServiceTypeDescriptionFileList()

EntityDescriptionFileList DeploymentConfiguration::getEntityDescriptionFileList()
{
  return _entityDescriptionFileList;
}; // DeploymentConfiguration::getEntityDescriptionFileList()

ActiveObjectConfigurationNameMap DeploymentConfiguration::getActiveObjectConfigurationNameMap()
{
  return ActiveObjectConfigurationNameMap (_activeObjectMap);
}; // DeploymentConfiguration::getActiveObjectConfigurationNameMap()

ActiveObjectConfigurationServiceMap DeploymentConfiguration::getActiveObjectConfigurationServiceMap()
{
  return ActiveObjectConfigurationServiceMap (_activeObjectBelongedServices);
}; // DeploymentConfiguration::getActiveObjectConfigurationServiceMap()

ServiceDeploymentConfigurationNameMap DeploymentConfiguration::getServiceDeploymentConfigurationNameMap()
{
  return ServiceDeploymentConfigurationNameMap (_serviceMap);
}; // DeploymentConfiguration::getServiceDeploymentConfigurationNameMap()