DataStructureDescription.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 DataStructureDescription.cpp
 * @Description DataStructureDescription class implementation.
 * @Status Implementing
 * @Version $Id: DataStructureDescription.cpp 1 2011-03-04 18:13:18Z jreis $
 * @Maintainer Marco Barbosa
 */

#include "config.h"

#include "DataStructureDescription.hpp"

#include <Exception.hpp>
#include <XmlAttribute.hpp>
#include <XmlAttributeVector.hpp>
#include <XmlElementVector.hpp>
#include <iostream>

using namespace mermaid::support::data;

using mermaid::support::errorhandling::Exception;
using mermaid::support::xml::XmlAttribute;
using mermaid::support::xml::XmlAttributeVector;
using mermaid::support::xml::XmlElementVector;

#include <sstream>

DataStructureDescription::DataStructureDescription (shared_ptr<XmlElement> structureDescriptionElement)
{
  if (structureDescriptionElement->getName().compare ("data-structure") != 0) {
    throw Exception ("DataStructureDescription::DataStructureDescription : expected \"data-structure\" element");
  }
  
  XmlElementVector children = structureDescriptionElement->getChildrenElements();
  
  shared_ptr<XmlElement> dataNameElement = children.getFirstElementWithName ("data-name");
  shared_ptr<XmlElement> dataCompositionElement = children.getFirstElementWithName ("data-composition");
  
  name_ = * (dataNameElement->getFirstNonBlankCharData());
  composition_ = XmlElement (*dataCompositionElement);
  
  
  XmlElementVector dataItemVector = dataCompositionElement->getChildrenElements();
  
  XmlElementVector::iterator it;
  
  for (it = dataItemVector.begin(); it != dataItemVector.end(); it++) {
    shared_ptr<XmlElement> dataItem = *it;
    XmlElementVector dataItemChildren = dataItem->getChildrenElements();
    
    shared_ptr<XmlElement> itemNameElement = dataItemChildren.getFirstElementWithName ("name");
    shared_ptr<XmlElement> itemTypeElement = dataItemChildren.getFirstElementWithName ("type");
    
    std::string itemName = * (itemNameElement->getFirstNonBlankCharData());
    std::string itemType = * (itemTypeElement->getFirstNonBlankCharData());
    
    XmlAttributeVector itemTypeAttributes = itemTypeElement->getAttributes();
    shared_ptr<XmlAttribute> isArrayAttribute = itemTypeAttributes.getFirstAttributeWithName ("isArray");
    shared_ptr<XmlAttribute> arraySizeAttribute = itemTypeAttributes.getFirstAttributeWithName ("arraySize");
    
    bool isArray = false;
    bool isDynamic = false;
    
    if (isArrayAttribute == false) {
      isArray = false;
    }
    else {
      isArray = isArrayAttribute->getValue().compare ("true") == 0 ? true : false;
    }
    
    if (isArray == true) {
      if (arraySizeAttribute == false) {
        isDynamic = true;
      }
      else {
        isDynamic = arraySizeAttribute->getValue().compare ("dynamic") == 0 ? true : false;
      }
    }
    
    
    //verify if item name collides with an item type name
    
    if ( (itemName.compare ("integer") == 0) | (itemName.compare ("double") == 0) | (itemName.compare ("string") == 0)) {
      throw Exception ("DataBox::DataBox(DataStructureDescription) : itemName cannot be any of: integer, double or string");
    }
    
    //std::cerr << "Item name:\t" << itemName << "\ttype:\t" << itemType << "\tisArray:\t" << isArray << "\tisDynamic:\t" << isDynamic << std::endl;
    
    if (isArray == false) {
      shared_ptr<DataItemDescription> did (new DataItemDescription (itemName, itemType));
      itemDescriptionVector_.push_back (did);
      
    }
    else {
      if (isDynamic == true) {
        shared_ptr<DataItemDescription> did (new DataItemDescription (itemName, itemType, true));
        itemDescriptionVector_.push_back (did);
      }
      else {
        std::stringstream ss;
        ss << arraySizeAttribute->getValue();
        int size;
        ss >> size;
        
        shared_ptr<DataItemDescription> did (new DataItemDescription (itemName, itemType, true, true, size));
        itemDescriptionVector_.push_back (did);
      }
    }
  }
  
  
  
}; // DataDataStructureDescription()

std::string DataStructureDescription::getName()
{
  return name_;
}; // getName()

std::vector<shared_ptr<DataItemDescription> > DataStructureDescription::getItemDescriptionVector()
{
  return itemDescriptionVector_;
}; // getItemDescriptionVector()