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

#include "config.h"

#include "ServiceConfiguration.hpp"


#include <Exception.hpp>

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

#include <sstream>

using namespace mermaid::support::service;
using mermaid::support::errorhandling::Exception;
using boost::shared_ptr;
using mermaid::support::xml::XmlCharData;
using mermaid::support::xml::XmlElement;
using mermaid::support::xml::XmlElementVector;

#include <iostream>

ServiceConfiguration::ServiceConfiguration (shared_ptr<XmlDocument> serviceConfiguration)
{

  shared_ptr<XmlElement> serviceConfigurationElement = serviceConfiguration->getRootElement();
  XmlElementVector serviceConfigurationChildren = serviceConfigurationElement->getChildrenElements();
  shared_ptr<XmlElement> updateFrequencyElement = serviceConfigurationChildren.getFirstElementWithName ("update-frequency");
  shared_ptr<XmlElement> configItemElement = serviceConfigurationChildren.getFirstElementWithName ("config-items");
  
  if (updateFrequencyElement == false) {
    throw Exception ("ServiceConfiguration::ServiceConfiguration() : no update-frequency element found in XML");
  };
  
  // read update-frequency
  {
    shared_ptr<XmlCharData> updateFrequencyChar = updateFrequencyElement->getFirstNonBlankCharData();
    
    if (updateFrequencyChar == false) {
      throw Exception ("ServiceConfiguration::ServiceConfiguration() : update-frequency item is empty");
    }
    
    std::string updateFrequency = (std::string) ( (*updateFrequencyChar));
    
    std::istringstream iss (updateFrequency);
    iss >> serviceUpdateFrequency_;
  }
  
  
  if (configItemElement == false) {
    return; //no config items
  };
  
  // read config-items
  {
    XmlElementVector configItemsChildren = configItemElement->getChildrenElements();
    
    XmlElementVector::iterator it;
    
    for (it = configItemsChildren.begin(); it != configItemsChildren.end(); it++) {
      shared_ptr<XmlElement> e = *it;
      
      if (e->getName() == "item") {
        XmlElementVector itemChildren = e->getChildrenElements();
        shared_ptr<XmlElement> nameElement = itemChildren.getFirstElementWithName ("name");
        shared_ptr<XmlElement> valueElement = itemChildren.getFirstElementWithName ("value");
        
        if (nameElement == false) {
          throw Exception ("ServiceConfiguration::ServiceConfiguration() : item's name element is not valid");
        }
        
        if (valueElement == false) {
          throw Exception ("ServiceConfiguration::ServiceConfiguration() : item's value element is not valid");
        }
        
        
        shared_ptr<XmlCharData> nameChar = nameElement->getFirstNonBlankCharData();
        shared_ptr<XmlCharData> valueChar = valueElement->getFirstNonBlankCharData();
        
        if (nameChar == false) {
          throw Exception ("ServiceConfiguration::ServiceConfiguration() : item's name element is empty");
        }
        
        if (valueChar == false) {
          throw Exception ("ServiceConfiguration::ServiceConfiguration() : item's value element is empty");
        }
        
        std::string nameString = (std::string) ( (*nameChar));
        std::string valueString = (std::string) ( (*valueChar));
        
        valuesMap_[nameString] = valueString;
      }
    }
  }
} //ServiceConfigurationstatic_pointer_cast<XmlElement>()

// ServiceConfiguration::ServiceConfiguration(float serviceUpdateFrequency)
// {
//     serviceUpdateFrequency_ = serviceUpdateFrequency;
// }; // ServiceConfiguration()

float ServiceConfiguration::getServiceUpdateFrequency()
{
  return serviceUpdateFrequency_;
}; // getServiceUpdateFrequency()

std::string ServiceConfiguration::getConfigValue (std::string name)
{
  std::map<std::string, std::string>::iterator it = valuesMap_.find (name);
  
  if (it != valuesMap_.end()) {
    return (*it).second;
  }
  else {
    throw Exception ("ServiceConfiguration::getConfigValue : unknown config item name: " + name);
  }
}; // getConfigValue()