AlgorithmParametersSerializer.h

Go to the documentation of this file.

/*  Copyright (C) 2008 National Institute For Space Research (INPE) - Brazil.
 
    This file is part of the TerraLib - a Framework for building GIS enabled applications.
 
    TerraLib 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.
 
    TerraLib 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 TerraLib. See COPYING. If not, write to
    TerraLib Team at <terralib-team@terralib.org>.
 */
 
#ifndef __TERRALIB_RP_INTERNAL_ALGORITHM_PARAMETERS_SERIALIZER_H
#define __TERRALIB_RP_INTERNAL_ALGORITHM_PARAMETERS_SERIALIZER_H
 
#include "Config.h"
 
#include<string>
#include<map>
#include<vector>
#include<complex>
 
#include <boost/numeric/ublas/matrix.hpp>
 
namespace te
{
  namespace rp
  {
    /*!
      \class AlgorithmParametersSerializer
      \brief A class to standardize algorithm parameters serialization.
    */
    class TERPEXPORT AlgorithmParametersSerializer
    {
      public:
 
        AlgorithmParametersSerializer();
 
        AlgorithmParametersSerializer( const AlgorithmParametersSerializer& other );
        
        ~AlgorithmParametersSerializer();
 
        AlgorithmParametersSerializer& operator=(
          const AlgorithmParametersSerializer& other );
 
        /*!
          \brief Set a non-empty algorithm name.
          \param The new non-empty algorithm name.
        */
        void setAlgorithmName( const std::string& name );
 
        /*!
          \brief Add a new parameter.
          \param name A new non-empty parameter name.
          \param value A new parameter value.
          \return true if ok, false on errors.
        */
        bool addParameter( const std::string& name, const std::string& value );
 
        /*!
          \brief Add a new parameter.
          \param name A new non-empty parameter name.
          \param value A new parameter value.
          \return true if ok, false on errors.
        */
        template< typename ValueType >
        bool addParameter( const std::string& name, const ValueType& value )
        {
          try
          {
            return addParameter( name, toString( value ) );
          }
          catch(...)
          {
            return false;
          }
        }
 
        /*!
          \brief Add a new multivalued parameter.
          \param name A new non-empty parameter name.
          \param value A new parameter values.
          \return true if ok, false on errors.
        */
        bool addMultivaluedParameter( const std::string& name,
          const std::vector< std::string >& values );
 
        /*!
          \brief Add a new multivalued parameter.
          \param name A new non-empty parameter name.
          \param value A new parameter values.
          \return true if ok, false on errors.
        */
        template< typename ValueType >
        bool addMultivaluedParameter( const std::string& name,
          const std::vector< ValueType >& values )
        {
          const std::size_t valuesSize = values.size();
          std::vector< std::string > stringValues;
 
          try
          {
            for( std::size_t valuesIdx = 0 ; valuesIdx < valuesSize ; ++valuesIdx )
            {
              stringValues.push_back( toString( values[ valuesIdx ] ) );
            }
          }
          catch(...)
          {
            return false;
          }
 
          return addMultivaluedParameter( name, stringValues );
        }
 
        /*!
          \brief Add a new multivalued parameter.
          \param name A new non-empty parameter name.
          \param value A new parameter values.
          \return true if ok, false on errors.
        */
        template< typename ValueType, typename KeyType >
        bool addMultivaluedParameter( const std::string& name,
          const std::map< KeyType, ValueType >& values )
        {
          const std::size_t valuesSize = values.size();
          std::vector< std::string > stringValues;
 
          try
          {
            typename std::map< KeyType, ValueType >::const_iterator it =
              values.begin();
            const typename std::map< KeyType, ValueType >::const_iterator itE =
              values.end();
 
            while( it != itE )
            {
              stringValues.push_back( toString( it->first ) );
              stringValues.push_back( toString( it->second ) );
              ++it;
            }
          }
          catch(...)
          {
            return false;
          }
 
          return addMultivaluedParameter( name, stringValues );
        }
 
        /*!
          \brief Add a new multivalued parameter in a matrix form.
          \param name A new non-empty parameter name.
          \param value A new parameter values in a matrix form.
          \return true if ok, false on errors.
        */
        template< typename ValueType >
        bool addMultivaluedParameter( const std::string& name,
          const boost::numeric::ublas::matrix< ValueType >& values )
        {
          const std::size_t valuesSize1 = values.size1();
          const std::size_t valuesSize2 = values.size2();
          std::size_t values2Idx = 0;
          std::vector< std::string > stringValues;
 
          try
          {
            for( std::size_t values1Idx = 0 ; values1Idx < valuesSize1 ; ++values1Idx )
            {
              for( values2Idx = 0 ; values2Idx < valuesSize2 ; ++values2Idx )
              {
                stringValues.push_back( toString( values( values1Idx, values2Idx ) ) );
              }
            }
          }
          catch(...)
          {
            return false;
          }
 
          return addMultivaluedParameter( name, stringValues );
        }        
        
        /*!
          \brief Add sets of new multivalued parameters.
          \param name A new non-empty parameter name.
          \param values Parameter values.
          \return true if ok, false on errors.
        */
        template< typename ValueType >
        bool addMultivaluedParameters( const std::string& name,
          const std::vector< std::vector< ValueType > >& values )
        {
          const std::size_t valuesSize = values.size();
 
          for( std::size_t valuesIdx = 0 ; valuesIdx < valuesSize ; ++valuesIdx )
          {
            if( ! addMultivaluedParameter( name, values[ valuesIdx ] ) )
            {
              return false;
            }
          }
 
          return true;
        }
        
        /*!
          \brief Add sets of new multivalued parameters in a matrix form.
          \param name A new non-empty parameter name.
          \param values Parameter values.
          \return true if ok, false on errors.
        */
        template< typename ValueType >
        bool addMultivaluedParameters( const std::string& name,
          const std::vector< boost::numeric::ublas::matrix< ValueType > >& values )
        {
          const std::size_t valuesSize = values.size();
 
          for( std::size_t valuesIdx = 0 ; valuesIdx < valuesSize ; ++valuesIdx )
          {
            if( ! addMultivaluedParameter( name, values[ valuesIdx ] ) )
            {
              return false;
            }
          }
 
          return true;
        }        
 
        /*!
          \brief Returns all serialized parameters formatted for raster metadata.
          \param metadata The output metadata.
        */
        void getMetaData( std::map<std::string, std::string>& metadata ) const;
 
        /*!
          \brief Reset to the initial empty state.
        */
        void reset();
 
      protected :
 
        typedef std::pair< std::string, std::vector< std::string > > ParsContPairT;
 
        typedef std::multimap<std::string, std::vector< std::string > > ParsContT;
 
        template< typename ValueType >
        std::string toString( const std::complex< ValueType >& value ) const
        {
          return std::to_string( value.real() ) + "+" +
            std::to_string( value.imag() ) + "i";
        }
 
        std::string toString( const std::string& value ) const
        {
          return value;
        }
 
        template< typename ValueType >
        std::string toString( const ValueType& value ) const
        {
          return std::to_string( value );
        }
        
      private :
 
        std::string m_algoName;
 
        ParsContT m_params;
 
    };
  } // end namespace rp
}   // end namespace te
 
#endif  // __TERRALIB_RP_INTERNAL_ALGORITHM_PARAMETERS_SERIALIZER_H