DataFactory.hpp

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

#ifndef __DATASTRUCTURE_DATAFACTORY_H_
#define __DATASTRUCTURE_DATAFACTORY_H_

#include <yarp/os/all.h>

#include <string>
#include "Boolean.hpp"
#include "DataBox.hpp"
#include "DataBoxArray.hpp"
#include "DataStructureDescription.hpp"
#include "DataValueVector.hpp"
#include "Double.hpp"
#include "DoubleArray.hpp"
#include "Integer.hpp"
#include "IntegerArray.hpp"
#include "String.hpp"
#include "StringArray.hpp"
#include "XmlDocument.hpp"



#include <map>

namespace mermaid
{
  namespace support
  {
    namespace data
    {
    
      using boost::shared_ptr;
      using mermaid::support::xml::XmlDocument;
      using mermaid::support::xml::XmlElement;
      using mermaid::support::xml::XmlElementVector;
      
      using yarp::os::Bottle;
      
      /**
      * @Class DataFactory DataFactory.hpp "DataFactory.hpp"
      * @Description Class representing a Data factory.
      * @Description This class is able to build Data from XML descriptions.
      * @Author Marco Barbosa + Nelson Ramos
      */
      
      class DataFactory
      {
      
        public:
          /**
          * @Description This method builds Integer from int value
          * @Argument value int value
          * @Returns Integer Class.
          */
          static shared_ptr<Integer> buildInteger (int value = 0);
          
          static shared_ptr<IntegerArray> buildDynamicIntegerArray();
          
          static shared_ptr<IntegerArray> buildStaticIntegerArray (int size);
          
          /**
          * @Description This method builds Double from float value
          * @Argument value double value
          * @Returns Double Class.
          */
          static shared_ptr<Double> buildDouble (double value = 0.0);
          
          static shared_ptr<DoubleArray> buildDynamicDoubleArray();
          
          static shared_ptr<DoubleArray> buildStaticDoubleArray (int size);
          
          /**
          * @Description This method builds String from string value
          * @Argument value string value
          * @Returns String Class.
          */
          static shared_ptr<String> buildString (std::string value = std::string (""));
          
          static shared_ptr<StringArray> buildDynamicStringArray();
          
          static shared_ptr<StringArray> buildStaticStringArray (int size);
          
          /**
           * @Description This method builds a DataBox from its type name
           * æArgument typeName Name of the DataBox type.
           */
          static shared_ptr<DataBox> buildDataBox (std::string typeName);
          
          static shared_ptr<DataBox> buildDataBoxFromStructureAndBottle (std::string structureTypeName, Bottle &bottle);
          static shared_ptr<DataBox> buildDataBoxFromStructureAndValueVector (std::string structureTypeName, shared_ptr<DataValueVector> vv);
          
          static shared_ptr<DataBoxArray> buildDynamicDataBoxArray (std::string typeName);
          
          static shared_ptr<DataBoxArray> buildStaticDataBoxArray (std::string typeName, int size);
          
          
          static shared_ptr<DataValueVector> buildDataValueVector (Bottle& b);
          static shared_ptr<DataValueVector> buildDataValueVector();
          
          
          static void loadDataDescription (shared_ptr<XmlDocument> document);
          
          static void writeDataBoxToBottle (shared_ptr<DataBox> box, Bottle &bottle);
          
          static shared_ptr<DataStructureDescription> getDataStructureDescription (std::string dataStructureName);
          
        private:
        
          static std::map<std::string, shared_ptr<DataStructureDescription> > dataStructureDescriptionMap;
          
      }; // DataFactory
    } // namespace data
  } // namespace support
} // namespace mermaid

#endif // __DATASTRUCTURE_DATAFACTORY_H_