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

#include "config.h"

#include "DataValueVector.hpp"

#include <DataFactory.hpp>

#include <Exception.hpp>

#include <sstream>
//#include <iostream>

using namespace mermaid::support::data;

using mermaid::support::data::DataFactory;
using mermaid::support::errorhandling::Exception;


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

DataValueVector::DataValueVector()
{
  setValue (vector<shared_ptr<DataValue> >());
};

DataValueVector::DataValueVector (vector<shared_ptr<DataValue> > value)
{
  setValue (value);
};

void DataValueVector::setValue (vector<shared_ptr<DataValue> > value)
{
  valueVector_ = value;
};

void DataValueVector::pushBack (shared_ptr<DataValue> value)
{
  valueVector_.push_back (value);
}; // pushBack()

shared_ptr<DataValue> DataValueVector::getValue (unsigned int pos)
{
  if (pos >= (unsigned int) valueVector_.size()) {
    throw Exception ("DataValueVector::getValue : accessing an invalid member");
  }
  return valueVector_[pos];
}; // getValue()

void DataValueVector::setValue (unsigned int pos, shared_ptr<DataValue> value)
{
  if (pos >= (unsigned int) valueVector_.size()) {
    throw Exception ("DataValueVector::setValue : accessing an invalid member");
  }
  valueVector_[pos] = value;
}; // setValue()

int DataValueVector::getSize()
{
  return valueVector_.size();
}; // getSize()

DataValueVector::operator std::string() const
{
  std::stringstream ss;
  
  ss << "<DataValueVector>";
  
  vector<shared_ptr<DataValue> >::const_iterator it;
  
  for (it = valueVector_.begin(); it != valueVector_.end(); it++) {
    shared_ptr<DataValue> d = *it;
    if (d == false) {
      throw Exception ("DataValueVector::operator std :: string() : invalid DataValue pointer inside the container");
    }
    ss << (std::string) *d;
    if ( (it + 1) != valueVector_.end()) {
      ss << "|";
    }
  }
  
  ss << "</DataValueVector>";
  
  return ss.str();
};

//conversion methods
/*DataValueVector& DataValueVector::operator=(Bottle &b)
{
    //std::cerr << "DataValueVector::operator=(Bottle &b)" << std::endl;
    DataValueVector::DataValueVector();

    buildDataValueVector(*this, b);

    return *this;
};*/


/*void DataValueVector::buildDataValueVector(DataValueVector &v, Bottle &b)
{

    for (int i=0; i<b.size(); i++) {

        //std::cerr << "DataValueVector::buildDataValueVector : [" << i << "]: ";

        Value& element = b.get(i);
        switch (element.getCode())
        {
            case BOTTLE_TAG_INT:
                {
                    shared_ptr<DataValue> i = DataFactory::buildInteger(element.asInt());
                    v.pushBack(i);
                    //std::cerr << "int " << element.asInt() << std::endl;
                }
                break;
            case BOTTLE_TAG_DOUBLE:
                {
                    shared_ptr<DataValue> f = DataFactory::buildFloat(element.asDouble());
                    v.pushBack(f);
                    //std::cerr << "float " << element.asDouble() << std::endl;
                }
                break;
            case BOTTLE_TAG_STRING:
                {
                    shared_ptr<DataValue> s = DataFactory::buildString(std::string(element.asString().c_str()));
                    v.pushBack(s);
                    //std::cerr << "string \"" << element.asString() << "\"" << std::endl;
                }
                break;
            case BOTTLE_TAG_BLOB:
                {
                    throw Exception("DataValueVector::buildDataValueVector : unsupported type: BLOB");
                    //std::cerr << "binary blob of length " << element.asBlobLength() << std::endl;
                }
                break;
            case BOTTLE_TAG_VOCAB:
                {
                    throw Exception("DataValueVector::buildDataValueVector : unsupported type: VOCAB");
                    //std::cerr << "vocab [" << Vocab::decode(element.asVocab()) << "]" << std::endl;
                }
                break;
            default:
                {
                    if (element.isList()) {
                        Bottle *lst = element.asList();
                        //std::cerr << "list of " << lst->size() << "elements" << std::endl;
                        shared_ptr<DataValue> newVector(new DataValueVector());
                        buildDataValueVector(*((DataValueVector*)newVector.get()), *lst);
                        v.pushBack(newVector);
                    } else {
                        throw Exception("DataValueVector::buildDataValueVector : unrecognized type");
                    }
                }
                break;
        }
    }
}; // buildDataValueVector*/

/*DataValueVector::operator Bottle ()
{
    //std::cerr << "DataValueVector::operator Bottle " << std::endl;
    Bottle b;

    vector<shared_ptr<DataValue> >::const_iterator it;

    for(it = valueVector_.begin(); it!=valueVector_.end(); it++)
    {
        shared_ptr<DataValue> d = *it;
        DataType t = d->getType();

        if(t==INTEGER)
        {
            Integer * i = (Integer*)d.get();
            b.addInt(i->getValue());
        }
        else if(t == FLOAT)
        {
            Float * f = (Float*)d.get();
            b.addDouble(f->getValue());
        }
        else if(t == STRING)
        {
            String * s = (String*)d.get();
            b.addString(s->getValue().c_str());
        }
        else
        {
            throw Exception("DataValueVector::operator Bottle : NOT IMPLEMENTED type conversion");//  d->getType() << std::endl;
        }
    }

    return b;
};*/