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

#include "config.h"

#include <sstream>
#include <boost/pointer_cast.hpp>

#include "DataFactory.hpp"

#include <XmlAttribute.hpp>
#include <XmlAttributeVector.hpp>
#include <XmlElement.hpp>
#include <XmlElementVector.hpp>
#include <XmlDocument.hpp>

#include "DataArray.hpp"
#include "DataType.hpp"

#include <Exception.hpp>

#include <iostream>
#include <sstream>

using namespace mermaid::support::data;

using mermaid::support::errorhandling::Exception;
using boost::shared_ptr;
using boost::static_pointer_cast;

using mermaid::support::xml::XmlAttribute;
using mermaid::support::xml::XmlAttributeVector;
using mermaid::support::xml::XmlDocument;
using mermaid::support::xml::XmlElement;
using mermaid::support::xml::XmlElementVector;

using yarp::os::Value;

std::map<std::string, shared_ptr<DataStructureDescription> > DataFactory::dataStructureDescriptionMap = std::map<std::string, shared_ptr<DataStructureDescription> >();

shared_ptr<Integer> DataFactory::buildInteger (int value)
{
  return shared_ptr<Integer> (new Integer (value));
};

shared_ptr<IntegerArray> DataFactory::buildDynamicIntegerArray()
{
  return shared_ptr<IntegerArray> (new IntegerArray());
};

shared_ptr<IntegerArray> DataFactory::buildStaticIntegerArray (int size)
{
  return shared_ptr<IntegerArray> (new IntegerArray (size));
};

shared_ptr<Double> DataFactory::buildDouble (double value)
{
  return shared_ptr<Double> (new Double (value));
};

shared_ptr<DoubleArray> DataFactory::buildDynamicDoubleArray()
{
  return shared_ptr<DoubleArray> (new DoubleArray());
};

shared_ptr<DoubleArray> DataFactory::buildStaticDoubleArray (int size)
{
  return shared_ptr<DoubleArray> (new DoubleArray (size));
};

shared_ptr<String> DataFactory::buildString (std::string value)
{
  return shared_ptr<String> (new String (value));
};

shared_ptr<StringArray> DataFactory::buildDynamicStringArray()
{
  return shared_ptr<StringArray> (new StringArray());
};

shared_ptr<StringArray> DataFactory::buildStaticStringArray (int size)
{
  return shared_ptr<StringArray> (new StringArray (size));
};


shared_ptr<DataValueVector> DataFactory::buildDataValueVector()
{
  //std::cerr << "DataFactory::buildDataValueVector()" << std::endl;
  DataValueVector * v = new DataValueVector();
  return shared_ptr<DataValueVector> (v);
};

shared_ptr<DataValueVector> DataFactory::buildDataValueVector (Bottle& b)
{
  shared_ptr<DataValueVector> v (new DataValueVector());
  
  for (int i = 0; i < (int) b.size(); i++) {
  
    //std::cerr << "DataFactory::buildDataValueVector : [" << i << "]: ";
    
    Value& element = b.get (i);
    
    if (element.isInt()) {
      shared_ptr<DataValue> i = DataFactory::buildInteger (element.asInt());
      v->pushBack (i);
      //std::cerr << "int " << element.asInt() << std::endl;
    }
    else if (element.isDouble()) {
      shared_ptr<DataValue> f = DataFactory::buildDouble (element.asDouble());
      v->pushBack (f);
      //std::cerr << "double " << element.asDouble() << std::endl;
    }
    else if (element.isString()) {
      shared_ptr<DataValue> s = DataFactory::buildString (std::string (element.asString().c_str()));
      v->pushBack (s);
      //std::cerr << "string \"" << element.asString() << "\"" << std::endl;
    }
    else if (element.isList()) {
      throw Exception ("DataFactory::buildDataValueVector : unable to read list");
      /*Bottle * b = element.asList();
      shared_ptr<DataValueVector> newVector(buildDataValueVector(*b).get());
      v->pushBack(newVector);*/
    }
    else {
      throw Exception ("DataFactory::buildDataValueVector : unrecognized type");
    }
  }
  
  return v;
};


void DataFactory::loadDataDescription (shared_ptr<XmlDocument> document)
{
  std::cerr << "DataFactory::loadDataDescription" << std::endl;
  
  shared_ptr<XmlElement> rootElement = document->getRootElement();
  XmlElementVector dataElements = rootElement->getChildrenElements();
  
  XmlElementVector::iterator it;
  
  for (it = dataElements.begin(); it != dataElements.end(); it++) {
    shared_ptr<XmlElement> e = *it;
    
    shared_ptr<DataStructureDescription> d (new DataStructureDescription (e));
    std::string dataStructureName = d->getName();
    dataStructureDescriptionMap[dataStructureName] = d;
    std::cerr << "DataFactory::loadDataDescription : loaded: " << dataStructureName << std::endl;
  };
}; // loadDataDescription()

shared_ptr<DataBox> DataFactory::buildDataBox (std::string typeName)
{

  /*if(typeName == "")
  {
      return shared_ptr<DataBox>(new DataBox());
  }*/
  
  shared_ptr<DataStructureDescription> dsd = dataStructureDescriptionMap[typeName];
  
  if (dsd == false) {
    throw Exception ("DataFactory::buildDataBoxFromStructure : invalid type name: " + typeName);
  }
  
  shared_ptr<DataBox> dbox (new DataBox (dsd));
  
  return dbox;
};//buildDataFromStructure()

shared_ptr<DataBox> DataFactory::buildDataBoxFromStructureAndBottle (std::string structureTypeName, Bottle &bottle)
{
  //std::cerr << "DataFactory::buildDataBoxFromStructureAndBottle : structureTypeName=" << structureTypeName << ", bottle=" << bottle.toString() << std::endl;
  shared_ptr<DataValueVector> valueVector = buildDataValueVector (bottle);
  return buildDataBoxFromStructureAndValueVector (structureTypeName, valueVector);
  
}; // buildDataBoxFromStructureAndBottle()



shared_ptr<DataBox> DataFactory::buildDataBoxFromStructureAndValueVector (std::string structureTypeName, shared_ptr<DataValueVector> vv)
{
  //throw Exception("DataFactory::buildDataBoxFromStructureAndValueVector : not up to date");
  
  shared_ptr<DataBox> dbox = buildDataBox (structureTypeName);
  dbox->setDataFromValueVector (vv);
  return dbox;
  
}; // buildDataFromStructureAndValueVector()

shared_ptr<DataBoxArray> DataFactory::buildDynamicDataBoxArray (std::string typeName)
{
  return shared_ptr<DataBoxArray> (new DataBoxArray (typeName));
}; // buildDynamicDataBoxArray()

shared_ptr<DataBoxArray> DataFactory::buildStaticDataBoxArray (std::string typeName, int size)
{
  return shared_ptr<DataBoxArray> (new DataBoxArray (typeName, size));
}; // buildStaticDataBoxArray()


void DataFactory::writeDataBoxToBottle (shared_ptr<DataBox> box, Bottle &bottle)
{
//    std::cerr << "DataFactory::writeDataBoxToBottle : box=" << (std::string)((*box)) << std::endl;

  shared_ptr<DataValueVector>  vv = box->getDataValueVector();
  
  int vectorSize = vv->getSize();
  
  for (int i = 0; i < vectorSize; i++) {
    shared_ptr<DataValue> d = vv->getValue (i);
    DataType t = d->getType();
    
    if (t == INTEGER) {
      Integer * i = (Integer*) d.get();
      bottle.addInt (i->getValue());
    }
    else if (t == DOUBLE) {
      Double * f = (Double*) d.get();
      bottle.addDouble (f->getValue());
    }
    else if (t == STRING) {
      String * s = (String*) d.get();
      bottle.addString (s->getValue().c_str());
    }
    else if (t == INTEGERARRAY) {
      IntegerArray * a = (IntegerArray*) d.get();
      int size = a->getSize();
      
      if (a->isDynamic() == true) {
        bottle.addInt (size);
      }
      
      for (int i = 0; i < size; i++) {
        int integer = (*a) [i]->getValue();
        bottle.addInt (integer);
      }
    }
    else if (t == DOUBLEARRAY) {
      DoubleArray * a = (DoubleArray*) d.get();
      int size = a->getSize();
      
      if (a->isDynamic() == true) {
        bottle.addInt (size);
      }
      
      for (int i = 0; i < size; i++) {
        double d = (*a) [i]->getValue();
        bottle.addDouble (d);
      }
    }
    else if (t == STRINGARRAY) {
      StringArray * a = (StringArray*) d.get();
      int size = a->getSize();
      
      if (a->isDynamic() == true) {
        bottle.addInt (size);
      }
      
      for (int i = 0; i < size; i++) {
        std::string s = (*a) [i]->getValue();
        bottle.addString (s.c_str());
      }
    }
    else if (t == DATABOX) {
      shared_ptr<DataBox> box = static_pointer_cast<DataBox> (d);
      writeDataBoxToBottle (box, bottle);
    }
    else if (t == DATABOXARRAY) {
      DataBoxArray * a = (DataBoxArray*) d.get();
      int size = a->getSize();
      
      if (a->isDynamic() == true) {
        bottle.addInt (size);
      }
      
      for (int i = 0; i < size; i++) {
        shared_ptr<DataBox> b = (*a) [i];
        writeDataBoxToBottle (b, bottle);
      }
    }
    else {
      throw Exception ("DataFactory::writeDataBoxToBottle: unknown type conversion");
    }
  };
}; // writeDataBoxToBottle()

shared_ptr<DataStructureDescription> DataFactory::getDataStructureDescription (std::string dataStructureName)
{
  return dataStructureDescriptionMap[dataStructureName];
}