OMKParametersAccessor.h

Go to the documentation of this file.

#ifndef OMKParametersAccessorHEADER
#define OMKParametersAccessorHEADER

#include "OMKOpenMASK.h"
#include "vector"
#include "map"
#include "list"
#include "string"

namespace OMK  
{
  class ConfigurationParameterDescriptor ;
  class SimulatedObject ;
  class Controller ;
  class Name ;
  template< typename T >class IAttributeBaseT ;
  namespace Type
  {
    class Color ;
    class Transform ;
  }

class OMK_API ParametersAccessor
{
public:











  template < typename T >
  static bool get(
    const ConfigurationParameterDescriptor * node,
    const std::string & name,
    T & value,
    SimulatedObject* object = 0
  );
public:















  template < typename T >
  static bool get(
    const ConfigurationParameterDescriptor * node,
    const std::string & name,
    T & value,
    const std::map< std::string, T >& mapping,
    SimulatedObject* object = 0
  );












  static bool getAndCheckObject(
      const ConfigurationParameterDescriptor * node,
      const std::string & name,
      Name & objectName,
      Controller & controller,
      SimulatedObject * object = 0 ) ;
protected:

  static bool getValue( const ConfigurationParameterDescriptor * nodeValue, 
                        bool & value,
                        std::string& errorStr );
  static bool getValue( const ConfigurationParameterDescriptor * nodeValue, 
                        Type::Color & value,
                        std::string& errorStr );
  static bool getValue( const ConfigurationParameterDescriptor * nodeValue, 
                        Type::Transform & value,
                        std::string& errorStr );
  template < typename T >
  static bool getValue( const ConfigurationParameterDescriptor * nodeValue, 
                        IAttributeBaseT< T > & value,
                        std::string& errorStr );
  template < typename T >
  static bool getValue( const ConfigurationParameterDescriptor * nodeValue, 
                        std::vector< T > & value,
                        std::string& errorStr );
  template < typename T >
  static bool getValue( const ConfigurationParameterDescriptor * nodeValue, 
                        std::list< T > & value,
                        std::string& errorStr );
  template < typename T1, typename T2 >
  static bool getValue( const ConfigurationParameterDescriptor * nodeValue, 
                        std::pair< T1, T2 > & value,
                        std::string& errorStr ) ;
  template < typename TK, typename TD >
  static bool getValue( const ConfigurationParameterDescriptor * nodeValue, 
                        std::map< TK, TD > & value,
                        std::string& errorStr ) ;
  template < typename T >
  static bool getValue( const ConfigurationParameterDescriptor * nodeValue, 
                        T & value,
                        std::string& errorStr );





  template < typename T >
  static bool getTxtValue( const std::string & textValue, T & value );
  static const ConfigurationParameterDescriptor * getNodeValue(
            const ConfigurationParameterDescriptor * node,
            const std::string & name,
            std::string & errorStr ) ;
  static bool displayError(
            const std::string & name,
            const std::string & functionName,
            SimulatedObject* object,
            const std::string & errorStr ) ;
public:











  template < typename T >
  static ConfigurationParameterDescriptor * set( ConfigurationParameterDescriptor *& node,
                                                    const std::string& name,
                                                    const T & value ) ;
  static ConfigurationParameterDescriptor * set( ConfigurationParameterDescriptor *& node,
                                                    const std::string& name,
                                                    ConfigurationParameterDescriptor * newNode ) ;









  template < typename T >
  static ConfigurationParameterDescriptor * set( ConfigurationParameterDescriptor *& node,
                                                    const std::string& name,
                                                    const T & value,
                                                    const std::map< T, std::string >& mapping ) ;
protected:




  template < typename T >
  static bool setTxtValue( std::string & textValue, const T& value ) ;



  template < typename T >
  static ConfigurationParameterDescriptor *setValue( const T& value,
                        std::string& errorStr ) ;
  static ConfigurationParameterDescriptor *setValue( const bool& value,
                        std::string& errorStr ) ;
  static ConfigurationParameterDescriptor *setValue( const Type::Color& value,
                        std::string& errorStr ) ;
  static ConfigurationParameterDescriptor *setValue( const Type::Transform& value,
                        std::string& errorStr ) ;
  template < typename T >
  static ConfigurationParameterDescriptor *setValue( const IAttributeBaseT< T >& values,
                        std::string& errorStr ) ;
  template < typename T >
  static ConfigurationParameterDescriptor *setValue( const std::vector< T >& values,
                        std::string& errorStr ) ;
  template < typename T >
  static ConfigurationParameterDescriptor *setValue( const std::list< T >& value,
                        std::string& errorStr ) ;
  template < typename TK, typename TD >
  static ConfigurationParameterDescriptor *setValue( const std::map< TK, TD >& value,
                        std::string& errorStr ) ;
  template < typename T1, typename T2 >
  static ConfigurationParameterDescriptor *setValue( const std::pair< T1, T2 >& value,
                        std::string& errorStr ) ;
};
} // namespace OMK
#endif

---