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


#include "config.h"

#include "ServiceTypeDescriptionFactory.hpp"
#include "ServiceInterfaceDescription.hpp"
#include "ServiceTypeDescription.hpp"

#include <Exception.hpp>
#include <XmlElement.hpp>

#include <iostream>

using namespace mermaid::support::service;
using mermaid::support::errorhandling::Exception;
using mermaid::support::xml::XmlElement;

void ServiceTypeDescriptionFactory::populateServiceTypeDescriptionRepository (shared_ptr<ServiceTypeDescriptionRepository> repository, shared_ptr<XmlElement> serviceTypeDescriptionList)
{
  XmlElementVector serviceTypeDescriptionElements = serviceTypeDescriptionList->getChildrenElements().getElementsWithName ("service-type-description");
  
  XmlElementVector::iterator stdeIterator;
  
  for (stdeIterator = serviceTypeDescriptionElements.begin(); stdeIterator != serviceTypeDescriptionElements.end(); stdeIterator++) {
    shared_ptr<XmlElement> stde = *stdeIterator;
    XmlElementVector stdeChildren = stde->getChildrenElements();
    
    shared_ptr<XmlElement> stdeNameElement = stdeChildren.getFirstElementWithName ("name");
    shared_ptr<XmlElement> stdeCommentElement = stdeChildren.getFirstElementWithName ("comment");
    
    std::string stdName;
    {
      shared_ptr<XmlCharData> nameString = stdeNameElement->getFirstNonBlankCharData();
      
      if (nameString == false) {
        throw Exception ("ServiceTypeDescriptionFactory::populateServiceTypeDescriptionRepository : empty name for Service Type Description");
      }
      
      stdName = (std::string) (*nameString);
    }
    
    std::string stdComment;
    {
      shared_ptr<XmlCharData> commentString = stdeCommentElement->getFirstNonBlankCharData();
      
      if (commentString) {
        stdComment = (std::string) (*commentString);
      }
    }
    
//         std::cerr << "ServiceTypeDescriptionFactory::populateServiceTypeDescriptionRepository : creating ServiceTypeDescription\n\tserviceTypeName=\"" << stdName << "\"\n\tserviceTypeComment=\"" << stdComment << "\"" << std::endl;

    shared_ptr<ServiceTypeDescription> std (new ServiceTypeDescription (stdName, stdComment));
    repository->addServiceTypeDescription (std);
    
    XmlElementVector stdeInterfaceElements = stdeChildren.getElementsWithName ("service-interface");
    XmlElementVector::iterator stdeieIterator;
    
    for (stdeieIterator = stdeInterfaceElements.begin(); stdeieIterator != stdeInterfaceElements.end(); stdeieIterator++) {
      shared_ptr<XmlElement> interfaceElement = *stdeieIterator;
      XmlElementVector ieChildren = interfaceElement->getChildrenElements();
      
      shared_ptr<XmlElement> intNameElement = ieChildren.getFirstElementWithName ("name");
      shared_ptr<XmlElement> intCommentElement = ieChildren.getFirstElementWithName ("comment");
      shared_ptr<XmlElement> intInDataElement = ieChildren.getFirstElementWithName ("in-data");
      shared_ptr<XmlElement> intOutDataElement = ieChildren.getFirstElementWithName ("out-data");
      
      if (!intInDataElement)
        throw Exception ("ServiceTypeDescriptionFactory::populateServiceTypeDescriptionRepository : service-request in-data missing.");
      if (!intOutDataElement)
        throw Exception ("ServiceTypeDescriptionFactory::populateServiceTypeDescriptionRepository : service-request out-data missing.");
        
      shared_ptr<XmlCharData> intNameChar = intNameElement->getFirstNonBlankCharData();
      shared_ptr<XmlCharData> intCommentChar = intCommentElement->getFirstNonBlankCharData();
      shared_ptr<XmlCharData> intInDataChar = intInDataElement->getFirstNonBlankCharData();
      shared_ptr<XmlCharData> intOutDataChar = intOutDataElement->getFirstNonBlankCharData();
      
      std::string intName;
      if (intNameChar == false) {
        throw Exception ("ServiceTypeDescriptionFactory::populateServiceTypeDescriptionRepository : empty name for Service Interface");
      }
      intName = (std::string) ( (*intNameChar));
      
      std::string intComment;
      if (intCommentChar) {
        intComment = (std::string) ( (*intCommentChar));
      }
      
      std::string intInData;
      if (intInDataChar) {
        intInData = (std::string) ( (*intInDataChar));
      }
      
      std::string intOutData;
      if (intOutDataChar) {
        intOutData = (std::string) ( (*intOutDataChar));
      }
      
//             std::cerr << "\tadding DataFeedDescription\n\t\tserviceTypeName=\"" << stdName << "\"\n\t\tinterfaceName=\"" << intName << "\"\n\t\tinterfaceComment=\"" << intComment << "\"\n\t\tinterfaceInData=\"" << intInData << "\"\n\t\tinterfaceOutData=\"" << intOutData << "\"" << std::endl;

      shared_ptr<ServiceInterfaceDescription> sid (new ServiceInterfaceDescription (intName, intComment, intInData, intOutData));
      std->addServiceInterfaceDescription (sid);
    };
    
    XmlElementVector stdeDatafeedElements = stdeChildren.getElementsWithName ("data-feed");
    XmlElementVector::iterator stdedfeIterator;
    
    for (stdedfeIterator = stdeDatafeedElements.begin(); stdedfeIterator != stdeDatafeedElements.end(); stdedfeIterator++) {
      shared_ptr<XmlElement> datafeedElement = *stdedfeIterator;
      XmlElementVector dfeChildren = datafeedElement->getChildrenElements();
      
      shared_ptr<XmlElement> dfNameElement = dfeChildren.getFirstElementWithName ("name");
      shared_ptr<XmlElement> dfCommentElement = dfeChildren.getFirstElementWithName ("comment");
      shared_ptr<XmlElement> dfOutDataElement = dfeChildren.getFirstElementWithName ("out-data");
      
      if (!dfOutDataElement)
        throw Exception ("ServiceTypeDescriptionFactory::populateServiceTypeDescriptionRepository : data-feed out-data missing.");
      shared_ptr<XmlCharData> dfNameChar = dfNameElement->getFirstNonBlankCharData();
      shared_ptr<XmlCharData> dfCommentChar = dfCommentElement->getFirstNonBlankCharData();
      shared_ptr<XmlCharData> dfOutDataChar = dfOutDataElement->getFirstNonBlankCharData();
      
      std::string dfName = (std::string) ( (*dfNameChar));
      if (dfNameChar == false) {
        throw Exception ("ServiceTypeDescriptionFactory::populateServiceTypeDescriptionRepository : empty name for Datafeed");
      }
      dfName = (std::string) ( (*dfNameChar));
      
      std::string dfComment;
      if (dfCommentChar) {
        dfComment = (std::string) ( (*dfCommentChar));
      }
      
      std::string dfOutData;
      if (dfOutDataChar) {
        dfOutData = (std::string) ( (*dfOutDataChar));
      }
      
//             std::cerr << "\tadding ServiceInterfaceDescription\n\t\tserviceTypeName=\"" << stdName << "\"\n\t\tdatafeedName=\"" << dfName << "\"\n\t\tdatafeedComment=\"" << dfComment << "\"\n\t\tdatafeedOutData=\"" << dfOutData << "\"" << std::endl;

      shared_ptr<DataFeedDescription> dfd (new DataFeedDescription (dfName, dfComment, dfOutData));
      std->addDataFeedDescription (dfd);
    };
  };
}; // populateServiceTypeDescriptionRepository()