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

#include "config.h"

#include "DataBox.hpp"

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

#include "DataFactory.hpp"
#include "DataType.hpp"
#include "Double.hpp"
#include "Integer.hpp"
#include "String.hpp"
#include "Exceptions/UnexpectedDataTypeException.hpp"
#include <XmlAttribute.hpp>
#include <XmlAttributeVector.hpp>

#include <Exception.hpp>



using namespace mermaid::support::data;

using boost::static_pointer_cast;

using mermaid::support::errorhandling::Exception;
using mermaid::support::xml::XmlAttribute;
using mermaid::support::xml::XmlAttributeVector;
using mermaid::support::data::exceptions::UnexpectedDataTypeException;



DataBox::DataBox() : DataValue()
{
  type_ = DATABOX;
};



DataBox::DataBox (shared_ptr<DataStructureDescription> dsd) : DataValue()
{
  type_ = DATABOX;
  dataStructureDescription_ = dsd;
  valueVector_ = DataFactory::buildDataValueVector();
  
  std::vector<shared_ptr<DataItemDescription> > itemDescriptions = dsd->getItemDescriptionVector();
  
  //go through all items
  std::vector<shared_ptr<DataItemDescription> >::iterator itemIt;
  
  for (itemIt = itemDescriptions.begin(); itemIt != itemDescriptions.end(); itemIt++) {
    shared_ptr<DataItemDescription> did = *itemIt;
    
    std::string itemName = did->getItemName();
    std::string itemType = did->getItemType();
    bool isArray = did->isItemArray();
    bool isDynamic = ! (did->isArrayStatic());
    int staticArraySize = did->getStaticArraySize();
    
//         std::cerr << "Item name:\t" << itemName << "\ttype:\t" << itemType << "\tisArray:\t" << isArray << "\tisDynamic:\t" << isDynamic << std::endl;

    if (isArray == false) {
      if (itemType.compare ("integer") == 0) {
        this->addInteger (itemName);
      }
      else if (itemType.compare ("double") == 0) {
        this->addDouble (itemName);
      }
      else if (itemType.compare ("string") == 0) {
        this->addString (itemName);
      }
      else {
        //it may be the name of a previously declared data structure
        try {
          this->addDataBox (itemName, itemType);
        }
        catch (Exception &e) {
          throw Exception ("DataBox::DataBox(DataStructureDescription) : unknown data item type: " + itemType);
        }
      }
    }
    else {
      if (isDynamic == true) {
        if (itemType.compare ("integer") == 0) {
          this->addDynamicIntegerArray (itemName);
        }
        else if (itemType.compare ("double") == 0) {
          this->addDynamicDoubleArray (itemName);
        }
        else if (itemType.compare ("string") == 0) {
          this->addDynamicStringArray (itemName);
        }
        else {
          this->addDynamicDataBoxArray (itemName, itemType);
        }
        
      }
      else {
      
        if (itemType.compare ("integer") == 0) {
          this->addStaticIntegerArray (itemName, staticArraySize);
        }
        else if (itemType.compare ("double") == 0) {
          this->addStaticDoubleArray (itemName, staticArraySize);
        }
        else if (itemType.compare ("string") == 0) {
          this->addStaticStringArray (itemName, staticArraySize);
        }
        else {
          ////it may be the name of a previously declared data structure
          this->addStaticDataBoxArray (itemName, itemType, staticArraySize);
        }
      }
    }
  }
}; // DataBox()



DataBox::DataBox (const DataBox &dbox) : DataValue()
{
  type_ = DATABOX;
  //! @TODO do real copying of all data
  throw Exception ("DataBox:DataBox : copt constructor not supported");
  /*dataStructureDescription_ = dbox.dataStructureDescription_;
  valueVector_ = dbox.valueVector_;
  nameToPtrMap_ = dbox.nameToPtrMap_;
  ptrToNameMap_ = dbox.ptrToNameMap_;*/
}; // DataBox()



DataBox * DataBox::clone()
{
  return new DataBox (*this);
}; // clone()



std::string DataBox::getBoxStructureName() const
{
  return dataStructureDescription_->getName();
}; // getBoxStructureName()



shared_ptr<DataValue> DataBox::getValue (std::string valueName) const
{
  std::map<std::string, shared_ptr<DataValue> >::const_iterator it = nameToPtrMap_.find (valueName);
  
  if (it == nameToPtrMap_.end()) {
    throw Exception ("DataBox::getValue : request for an unknown name: " + valueName);
  }
  
  shared_ptr<DataValue> dv = (*it).second;
  
  if (dv == false) {
    throw Exception ("DataBox::getValue : request for an unknown name: " + valueName);
  }
  
  return dv;
}; // getValue()



shared_ptr<DataValueVector> DataBox::getDataValueVector() const
{
  return valueVector_;
}; // getDataVector()



int DataBox::getInteger (std::string name) const
{
  shared_ptr<DataValue> dv = getValue (name);
  
  if (dv->getType() != INTEGER) {
    throw Exception ("DataBox::getInteger : value is not an integer");
  }
  
  return ( (Integer*) dv.get())->getValue();
}; // getInteger()



shared_ptr<IntegerArray> DataBox::getIntegerArray (std::string name) const
{
  shared_ptr<DataValue> dv = getValue (name);
  
  if (dv->getType() != INTEGERARRAY) {
    throw Exception ("DataBox::getIntegerArray : value is not an integer array");
  }
  
  return static_pointer_cast<IntegerArray> (dv);
}; // getIntegerArray()



double DataBox::getDouble (std::string name) const
{
  shared_ptr<DataValue> dv = getValue (name);
  
  if (dv->getType() != DOUBLE) {
    throw Exception ("DataBox::getDouble : value is not a double");
  }
  
  return ( (Double*) dv.get())->getValue();
}; // getDouble()



shared_ptr<DoubleArray> DataBox::getDoubleArray (std::string name) const
{
  shared_ptr<DataValue> dv = getValue (name);
  
  if (dv->getType() != DOUBLEARRAY) {
    throw Exception ("DataBox::getDoubleArray : value is not a double array");
  }
  
  return static_pointer_cast<DoubleArray> (dv);
  
}; // getDoubleArray()



std::string DataBox::getString (std::string name) const
{
  shared_ptr<DataValue> dv = getValue (name);
  
  if (dv->getType() != STRING) {
    throw Exception ("DataBox::getString : value is not a string");
  }
  
  return ( (String*) dv.get())->getValue();
}; // getString()



shared_ptr<StringArray> DataBox::getStringArray (std::string name) const
{
  shared_ptr<DataValue> dv = getValue (name);
  
  if (dv->getType() != STRINGARRAY) {
    throw Exception ("DataBox::getStringArray : value is not a string array");
  }
  
  return static_pointer_cast<StringArray> (dv);
}; // getStringArray()



shared_ptr<DataBox> DataBox::getDataBox (std::string name) const
{
  shared_ptr<DataValue> dv = getValue (name);
  
  if (dv->getType() != DATABOX) {
    throw Exception ("DataBox::getDataBox : value is not a DataBox");
  }
  
  return static_pointer_cast<DataBox> (dv);
}; // getDataBox()



shared_ptr<DataBoxArray> DataBox::getDataBoxArray (std::string name) const
{
  shared_ptr<DataValue> dv = getValue (name);
  
  if (dv->getType() != DATABOXARRAY) {
    throw Exception ("DataBox::getDataBoxArray : value is not a DataBoxArray");
  }
  
  return static_pointer_cast<DataBoxArray> (dv);
}; // getDataBoxArray()



void DataBox::setInteger (std::string name, int value)
{
  shared_ptr<DataValue> dv = getValue (name);
  
  if (dv == false) {
    throw Exception ("DataBox::setInteger : name not recognised");
  }
  
  if (dv->getType() != INTEGER) {
    throw Exception ("DataBox::setInteger : value is not an integer");
  }
  
  ( (Integer*) dv.get())->setValue (value);
}; // setInteger()



void DataBox::setDouble (std::string name, double value)
{
  shared_ptr<DataValue> dv = getValue (name);
  
  if (dv == false) {
    throw Exception ("DataBox::setDouble : name not recognised");
  }
  
  if (dv->getType() != DOUBLE) {
    throw Exception ("DataBox::setDouble: value is not a double");
  }
  
  ( (Double*) dv.get())->setValue (value);
}; // setDouble()



void DataBox::setString (std::string name, std::string value)
{
  shared_ptr<DataValue> dv = getValue (name);
  
  if (dv == false) {
    throw Exception ("DataBox::setString: name not recognised");
  }
  
  if (dv->getType() != STRING) {
    throw Exception ("DataBox::setString: value is not a string");
  }
  
  ( (String*) dv.get())->setValue (value);
}; // setString()



void DataBox::setValueFromString (std::string name, std::string value)
{
  shared_ptr<DataValue> dv = getValue (name);
  
  if (dv == false) {
    throw Exception ("DataBox::setValueFromString: name not recognised");
  }
  
  switch (dv->getType()) {
    case INTEGER: {
      std::stringstream ss;
      ss << value;
      int i;
      ss >> i;
      ( (Integer*) dv.get())->setValue (i);
    }
    break;
    
    case DOUBLE: {
      std::stringstream ss;
      ss << value;
      double d;
      ss >> d;
      ( (Double*) dv.get())->setValue (d);
    }
    break;
    
    case STRING: {
      ( (String*) dv.get())->setValue (value);
    }
    break;
    
    default: {
      throw Exception ("DataBox::setValueFromString: setting value for unsupported data type");
    }
  }
}; // setValueFromString()



void DataBox::addInteger (std::string name, int i)
{
  //std::cerr << "DataBox::addInteger(name=" << name << ",\ti=" << i << ")" << std::endl;
  shared_ptr<DataValue> dv = static_pointer_cast<DataValue> (DataFactory::buildInteger (i));
  addDataValue (name, dv);
}; // addInteger()



shared_ptr<IntegerArray> DataBox::addDynamicIntegerArray (std::string name)
{
  //std::cerr << "DataBox::addDynamicIntegerArray(name=" << name << ")" << std::endl;
  shared_ptr<DataValue> dv = DataFactory::buildDynamicIntegerArray();
  addDataValue (name, dv);
  return static_pointer_cast<IntegerArray> (dv);
}; // addDynamicIntegerArray()



shared_ptr<IntegerArray> DataBox::addStaticIntegerArray (std::string name, int size)
{
  //std::cerr << "DataBox::addStaticIntegerArray(name=" << name << " ,size=" << size << ")" << std::endl;
  shared_ptr<DataValue> dv = DataFactory::buildStaticIntegerArray (size);
  addDataValue (name, dv);
  return static_pointer_cast<IntegerArray> (dv);
}; // addStaticIntegerArray()



void DataBox::addDouble (std::string name, double d)
{
  //std::cerr << "DataBox::addDouble(name=" << name << ",\tid=" << d << ")" << std::endl;
  shared_ptr<DataValue> dv = DataFactory::buildDouble (d);
  addDataValue (name, dv);
}; // addDouble()



shared_ptr<DoubleArray> DataBox::addDynamicDoubleArray (std::string name)
{
  //std::cerr << "DataBox::addDynamicDoubleArray(name=" << name << ")" << std::endl;
  shared_ptr<DataValue> dv = DataFactory::buildDynamicDoubleArray();
  addDataValue (name, dv);
  return static_pointer_cast<DoubleArray> (dv);
}; // addDynamicDoubleArray()



shared_ptr<DoubleArray> DataBox::addStaticDoubleArray (std::string name, int size)
{
  //std::cerr << "DataBox::addStaticDoubleArray(name=" << name << " ,size=" << size << ")" << std::endl;
  shared_ptr<DataValue> dv = DataFactory::buildStaticDoubleArray (size);
  addDataValue (name, dv);
  return static_pointer_cast<DoubleArray> (dv);
}; // addStaticDoubleArray()



void DataBox::addString (std::string name, std::string s)
{
  //std::cerr << "DataBox::addString(name=" << name << ",\ts=" << s << ")" << std::endl;
  shared_ptr<DataValue> dv = DataFactory::buildString (s);
  addDataValue (name, dv);
}; // addString()



shared_ptr<StringArray> DataBox::addDynamicStringArray (std::string name)
{
  //std::cerr << "DataBox::addDynamicStringArray(name=" << name << ")" << std::endl;
  shared_ptr<DataValue> dv = DataFactory::buildDynamicStringArray();
  addDataValue (name, dv);
  return static_pointer_cast<StringArray> (dv);
}; // addDynamicStringArray



shared_ptr<StringArray> DataBox::addStaticStringArray (std::string name, int size)
{
  //std::cerr << "DataBox::addStaticStringArray(name=" << name << " ,size=" << size << ")" << std::endl;
  shared_ptr<DataValue> dv = DataFactory::buildStaticStringArray (size);
  addDataValue (name, dv);
  return static_pointer_cast<StringArray> (dv);
}; // addStaticIntegerArray()



void DataBox::addDataBox (std::string name, std::string type)
{
  //std::cerr << "DataBox::addDataBox(name=" << name << " type=" << type << ")" << std::endl;
  shared_ptr<DataValue> dv = DataFactory::buildDataBox (type);
  addDataValue (name, dv);
}; // addDataBox()



shared_ptr<DataBoxArray> DataBox::addDynamicDataBoxArray (std::string name, std::string type)
{
  //std::cerr << "DataBox::addDynamicDataBoxArray(name=" << name  << " type=" << type << ")" << std::endl;
  shared_ptr<DataValue> dv = DataFactory::buildDynamicDataBoxArray (type);
  addDataValue (name, dv);
  return static_pointer_cast<DataBoxArray> (dv);
}; // addDynamicDataBoxArray()



shared_ptr<DataBoxArray> DataBox::addStaticDataBoxArray (std::string name, std::string type, int size)
{
  //std::cerr << "DataBox::addStaticDataBoxArray(name=" << name << " type=" << type << " size=" << size << ")" << std::endl;
  shared_ptr<DataValue> dv = DataFactory::buildStaticDataBoxArray (type, size);
  addDataValue (name, dv);
  return static_pointer_cast<DataBoxArray> (dv);
}; // addStaticDataBoxArray()



void DataBox::addDataValue (std::string name, shared_ptr<DataValue> value)
{
  valueVector_->pushBack (value);
  nameToPtrMap_[name] = value;
  ptrToNameMap_[value] = name;
}; // addDataValue()



int DataBox::setDataFromValueVector (shared_ptr<DataValueVector> vv, int startPos)
{
  std::vector<shared_ptr<DataItemDescription> > itemDescriptionVector = dataStructureDescription_->getItemDescriptionVector();
  std::vector<shared_ptr<DataItemDescription> >::iterator itemIt;
  
  int currentValueVectorPos = startPos;
  
  for (itemIt = itemDescriptionVector.begin(); itemIt != itemDescriptionVector.end(); itemIt++) {
    shared_ptr<DataItemDescription> itemDesc = *itemIt;
    
    std::string itemName = itemDesc->getItemName();
    std::string itemType = itemDesc->getItemType();
    bool isArray = itemDesc->isItemArray();
    bool isDynamic = ! (itemDesc->isArrayStatic());
    
    if (isArray == false) {
      if (itemType.compare ("integer") == 0) {
        // get next value from value vector
        shared_ptr<DataValue> value = vv->getValue (currentValueVectorPos++);
        
        if (value->getType() != INTEGER) {
          throw UnexpectedDataTypeException ("DataBox::setDataFromValueVector : unexpected data type");
        }
        
        int i = ( (Integer*) value.get())->getValue();
        //get integer from valuevector
        //std::cerr << "\taddInteger: itemName=" << itemName << ", value=" << i << std::endl;
        this->addInteger (itemName, i);
      }
      else if (itemType.compare ("double") == 0) {
        // get next value from value vector
        shared_ptr<DataValue> value = vv->getValue (currentValueVectorPos++);
        
        if (value->getType() != DOUBLE) {
          throw UnexpectedDataTypeException ("DataBox::setDataFromValueVector : unexpected data type");
        }
        
        double d = ( (Double*) value.get())->getValue();
        //std::cerr << "\taddDouble: itemName=" << itemName << ", value=" << d << std::endl;
        this->addDouble (itemName, d);
      }
      else if (itemType.compare ("string") == 0) {
        // get next value from value vector
        shared_ptr<DataValue> value = vv->getValue (currentValueVectorPos++);
        
        if (value->getType() != STRING) {
          throw UnexpectedDataTypeException ("DataBox::setDataFromValueVector : unexpected data type");
        }
        
        std::string s = ( (String*) value.get())->getValue();
        //std::cerr << "\taddString: itemName=" << itemName << ", value=" << s << std::endl;
        this->addString (itemName, s);
      }
      else {
        shared_ptr<DataBox> b = getDataBox (itemName);
        std::string bType = b->dataStructureDescription_->getName();
        
        if (bType.compare (itemType) != 0) {
          throw Exception ("DataBox::setDataFromValueVector : child data box not of the correct type");
        }
        
        int numConsumed = b->setDataFromValueVector (vv, currentValueVectorPos);
        currentValueVectorPos += numConsumed;
        
      }
    } // if isArray==false
    else {
      if (isDynamic == true) {
        shared_ptr<DataValue> sizeValue = vv->getValue (currentValueVectorPos++);
        int size = ( (Integer*) sizeValue.get())->getValue();
        
        //std::cerr << "DataBox::setDataFromValueVector : dynamic array size: " << size << std::endl;
        
        if (itemType.compare ("integer") == 0) {
          //std::cerr << "\taddDynamicIntegerArray: itemName=" << itemName << std::endl;
          shared_ptr<IntegerArray> ia = this->addDynamicIntegerArray (itemName);
          for (int n = 0; n < size; n++) {
            shared_ptr<DataValue> value = vv->getValue (currentValueVectorPos++);
            if (value->getType() != INTEGER) {
              throw UnexpectedDataTypeException ("DataBox::setDataFromValueVector : unexpected data type");
            }
            int i = ( (Integer*) value.get())->getValue();
            ia->pushBack (i);
          }
        }
        else if (itemType.compare ("double") == 0) {
          //std::cerr << "\taddDynamicDoubleArray: itemName=" << itemName << std::endl;
          shared_ptr<DoubleArray> da = this->addDynamicDoubleArray (itemName);
          for (int n = 0; n < size; n++) {
            shared_ptr<DataValue> value = vv->getValue (currentValueVectorPos++);
            if (value->getType() != DOUBLE) {
              throw UnexpectedDataTypeException ("DataBox::setDataFromValueVector : unexpected data type");
            }
            double d = ( (Double*) value.get())->getValue();
            da->pushBack (d);
          }
        }
        else if (itemType.compare ("string") == 0) {
          //std::cerr << "\taddDynamicStringArray: itemName=" << itemName << std::endl;
          shared_ptr<StringArray> sa = this->addDynamicStringArray (itemName);
          for (int n = 0; n < size; n++) {
            shared_ptr<DataValue> value = vv->getValue (currentValueVectorPos++);
            if (value->getType() != STRING) {
              throw UnexpectedDataTypeException ("DataBox::setDataFromValueVector : unexpected data type");
            }
            std::string s = ( (String*) value.get())->getValue();
            sa->pushBack (s);
          }
        }
        else {
          //throw Exception("DataBox::setDataFromValueVector : unknown data item type: " + itemType);
          shared_ptr<DataBoxArray> dba = this->addDynamicDataBoxArray (itemName, itemType);
          for (int n = 0; n < size; n++) {
            shared_ptr<DataBox> b = DataFactory::buildDataBox (itemType);
            int numConsumed = b->setDataFromValueVector (vv, currentValueVectorPos);
            currentValueVectorPos += numConsumed;
            dba->pushBack (b);
          }
        }
        
      } // if dynamic==true
      else {
        int size = itemDesc->getStaticArraySize();
        //std::cerr << "DataBox::setDataFromValueVector : static array size: " << size << std::endl;
        
        if (itemType.compare ("integer") == 0) {
          //std::cerr << "\taddStaticIntegerArray: itemName=" << itemName << std::endl;
          shared_ptr<IntegerArray> ia = this->addStaticIntegerArray (itemName, size);
          for (int n = 0; n < size; n++) {
            shared_ptr<DataValue> value = vv->getValue (currentValueVectorPos++);
            if (value->getType() != INTEGER) {
              throw UnexpectedDataTypeException ("DataBox::setDataFromValueVector : unexpected data type");
            }
            (*ia) [n] = static_pointer_cast<Integer> (value);
          }
        }
        else if (itemType.compare ("double") == 0) {
          //std::cerr << "\taddStaticDoubleArray: itemName=" << itemName << std::endl;
          shared_ptr<DoubleArray> da = this->addStaticDoubleArray (itemName, size);
          for (int n = 0; n < size; n++) {
            shared_ptr<DataValue> value = vv->getValue (currentValueVectorPos++);
            if (value->getType() != DOUBLE) {
              throw UnexpectedDataTypeException ("DataBox::setDataFromValueVector : unexpected data type");
            }
            (*da) [n] = static_pointer_cast<Double> (value);
          }
        }
        else if (itemType.compare ("string") == 0) {
          //std::cerr << "\taddStaticStringArray: itemName=" << itemName << std::endl;
          shared_ptr<StringArray> sa = this->addStaticStringArray (itemName, size);
          for (int n = 0; n < size; n++) {
            shared_ptr<DataValue> value = vv->getValue (currentValueVectorPos++);
            if (value->getType() != STRING) {
              throw UnexpectedDataTypeException ("DataBox::setDataFromValueVector : unexpected data type");
            }
            (*sa) [n] = static_pointer_cast<String> (value);
          }
        }
        else {
          //throw Exception("DataBox::setDataFromValueVector : unknown data item type: " + itemType);
          
          shared_ptr<DataBoxArray> dba = this->addStaticDataBoxArray (itemName, itemType, size);
          for (int n = 0; n < size; n++) {
            shared_ptr<DataBox> b = (*dba) [n];
            int numConsumed = b->setDataFromValueVector (vv, currentValueVectorPos);
            currentValueVectorPos += numConsumed;
          }
        }
      } // else dynamic==true
    } // else isarray==false
  } //iterator
  
  return currentValueVectorPos - startPos;
}; // setDataFromValueVector()



DataBox::operator std::string() const
{
  std::stringstream ss;
  std::map<std::string, shared_ptr<DataValue> >::const_iterator it;
  ss << "[DataBox: ";
  for (it = nameToPtrMap_.begin(); it != nameToPtrMap_.end(); it++) {
    std::pair<std::string, shared_ptr<DataValue> > p = *it;
    ss << "(name: " << p.first << "\tvalue:" << static_cast<std::string> (* (p.second)) << ")";
  };
  ss << "]";
  return ss.str();
}; // operator std::string()



void DataBox::print() const
{
  std::cerr << (std::string) *this;
}; // print()