OMKParametersAccessor.inl

Go to the documentation of this file.

#ifndef PSPARAMETERSACCESSOR_INL
#define PSPARAMETERSACCESSOR_INL

#include "OMKParametersAccessor.h"
#include "OMKAttribute.h"
#include "OMKTracer.h"
#include "OMKConfigurationParameterDescriptor.h"
#include "OMKUniqueConfigurationParameter.h"
#include "OMKMultipleConfigurationParameter.h"
namespace OMK
{

//-------------------------------------------------------------------
template <>
inline
bool ParametersAccessor::getTxtValue( const std::string & textValue, std::string & value )
{
  value = textValue;
  return true;
}

//-------------------------------------------------------------------
template <>
inline
bool ParametersAccessor::setTxtValue( std::string& textValue, const std::string& value )
{
  textValue = value ;
  return true ;
}

//-------------------------------------------------------------------
template <>
inline
bool ParametersAccessor::getValue( const ConfigurationParameterDescriptor * nodeValue,
                                      const ConfigurationParameterDescriptor * & value,
                                      std::string& errorStr ) 
{
  errorStr = "The node is empty" ;
  // Get the value of the node
  value = nodeValue ;
  // if it is not null, return true
  return value != 0 ;
}
//-------------------------------------------------------------------
template <>
inline
bool ParametersAccessor::getValue( const ConfigurationParameterDescriptor * nodeValue,
                                      ConfigurationParameterDescriptor * & value,
                                      std::string& errorStr ) 
{
  value = 0 ;
  errorStr = "Unable to get a no-const ConfigurationParameterDescriptor*" ;
  return false ;
}
//-------------------------------------------------------------------
// Get a value for a T
template < typename T >
inline
bool ParametersAccessor::getValue( const ConfigurationParameterDescriptor * nodeValue, 
                                     T & value,
                                     std::string& errorStr )
{
  bool ok = ( nodeValue != NULL ) ;
  ok = ok && getTxtValue( nodeValue->getAssociatedString(), value ) ;
  if( !ok )
  {
    errorStr = "Cannot read the value in string \"" ;
    errorStr += nodeValue ? nodeValue->getAssociatedString() : "empty" ;
    errorStr += "\"" ;
  }
  return ok ;
}

//-------------------------------------------------------------------
// convert the string in a T value
template < typename T >
inline
bool ParametersAccessor::getTxtValue( const std::string & textValue, T & value )
{
  std::stringstream is;
  is << textValue;
  is >> value;
  return 0 != (void*)is;
}

//-------------------------------------------------------------------
template < typename T >
inline
bool ParametersAccessor::get( const ConfigurationParameterDescriptor * node,
                                const std::string & name,
                                T & value,
                                SimulatedObject* object ) 
{
  std::string errorStr ;
  // Get the node for the value
  const ConfigurationParameterDescriptor * nodeValue = getNodeValue( node, name, errorStr ) ;
  // if it is good, get the value else display error
  return ( nodeValue && getValue( nodeValue, value, errorStr ) ) 
      || displayError( name, "get", object, errorStr ) ;
}

//-------------------------------------------------------------------
template < typename T >
inline 
bool ParametersAccessor::get( const ConfigurationParameterDescriptor * node,
                                 const std::string & name,
                                 T & value,
                                 const std::map< std::string, T >& mapping,
                                 SimulatedObject* object )
{
  std::string errorStr ;
  // Get the node for the value
  const ConfigurationParameterDescriptor * nodeValue = getNodeValue( node, name, errorStr ) ;
  // get the value as a string and convert it with the mapping
  std::string txt ;
  bool ok = false ;
  if( nodeValue && getValue( nodeValue, txt, errorStr ) )
  {
    typename std::map< std::string, T >::const_iterator i = mapping.find( txt ) ;
    if( i != mapping.end() ) 
    {
      value = i->second ;
      ok = true ;
    }
    else
    {
      errorStr = "Cannot read a valid enum value in string \"" ;
      errorStr += txt ;
      errorStr += "\"" ;
    }
  }
  // true if it is good else display error
  return ok || displayError( name, "get", object, errorStr ) ;

}

//-------------------------------------------------------------------
template < typename T >
inline
bool ParametersAccessor::getValue( const ConfigurationParameterDescriptor * nodeValue, 
                                     OMK::IAttributeBaseT< T > & attr,
                                     std::string& errorStr )
{
  T value ;
  bool ok = ( nodeValue != NULL ) ;
  ok = ok && getValue( nodeValue, value, errorStr ) ;
  if( ok )
  {
    attr.set( value ) ; 
  }
  else
  {
    errorStr = "Cannot read the value in string \"" ;
    errorStr += nodeValue ? nodeValue->getAssociatedString() : "empty" ;
    errorStr += "\"" ;
  }
  return ok ;
}

//-------------------------------------------------------------------
template < typename T >
inline
bool ParametersAccessor::getValue( const ConfigurationParameterDescriptor * nodeValue, 
                                     std::vector< T > & values,
                                     std::string& errorStr )
{
  bool ok = ( nodeValue != NULL ) ;
  if( ok )
  {
    for( int i = 0 ; ok && ( i < nodeValue->getNumberOfSubItems() ) ; i++ )
    {
      T aValue;
      ok = ParametersAccessor::getValue( nodeValue->getSubDescriptorByPosition( i ), aValue, errorStr ) ;
      if( ok )
      {
        values.push_back(aValue);
      }
      else
      {
        std::ostringstream oss ;
        oss << ", cannot get the parameter number " << i ;
        errorStr += oss.str() ;
      }
    }
  }
  return ok ;
}

//-------------------------------------------------------------------
template < typename T >
inline
bool ParametersAccessor::getValue( const ConfigurationParameterDescriptor * nodeValue, 
                                     std::list< T > & values,
                                     std::string& errorStr )
{
  bool ok = ( nodeValue != NULL ) ;
  if( ok )
  {
    for( int i = 0 ; ok && ( i < nodeValue->getNumberOfSubItems() ) ; i++ )
    {
      T aValue;
      ok = ParametersAccessor::getValue( nodeValue->getSubDescriptorByPosition( i ), aValue, errorStr ) ;
      if( ok )
      {
        values.push_back(aValue);
      }
      else
      {
        std::ostringstream oss ;
        oss << ", cannot get the parameter number " << i ;
        errorStr += oss.str() ;
      }
    }
  }
  return ok ;
}

//-------------------------------------------------------------------
template < typename TK, typename TD >
inline
bool ParametersAccessor::getValue( const ConfigurationParameterDescriptor * nodeValue, 
                                     std::map< TK, TD > & values,
                                     std::string& errorStr )
{
  bool ok = ( nodeValue != NULL ) ;
  if( ok )
  {
    for( int i = 0 ; ok && ( i < nodeValue->getNumberOfSubItems() ) ; i++ )
    {
      std::pair< TK, TD > aValue;
      ok = ParametersAccessor::getValue( nodeValue->getSubDescriptorByPosition( i ), aValue, errorStr ) ;
      if( ok )
      {
        values[ aValue.first ] = aValue.second ;
      }
      else
      {
        std::ostringstream oss ;
        oss << ", cannot get the parameter number " << i ;
        errorStr += oss.str() ;
      }
    }
  }
  return ok ;
}

//-------------------------------------------------------------------
template < typename T1, typename T2 >
inline
bool ParametersAccessor::getValue( const ConfigurationParameterDescriptor * nodeValue, 
                                     std::pair< T1, T2 > & value,
                                     std::string& errorStr )
{
  bool ok( ( nodeValue != NULL ) && ( nodeValue->getNumberOfSubItems() == 2 ) ) ;
  if ( !ok && errorStr.empty() ) 
  {
    errorStr = "Bad format of pair (need 2 arguments)" + nodeValue->getAssociatedString() ; 
  }
  ok = ok && getValue( nodeValue->getSubDescriptorByPosition( 0 ), value.first, errorStr ) ;
  ok = ok && getValue( nodeValue->getSubDescriptorByPosition( 1 ), value.second, errorStr ) ;
  return ok ;
}


//-------------------------------------------------------------------
template < typename T >
inline
ConfigurationParameterDescriptor * ParametersAccessor::set(
                               ConfigurationParameterDescriptor *& node,
                               const std::string& name,
                               const T & value ) 
{
  std::string errorStr ;
  ConfigurationParameterDescriptor* newNode = setValue( value, errorStr ) ;
  if( newNode )
  {
    if( !node ) node = new MultipleConfigurationParameter() ;
    node->appendSubDescriptorNamed( name, newNode ) ;
  }
  else
  {
    OMERROR( "Warning in ParametersAccessor::Set with parameter [" + name + "]" << std::endl 
        << ">>> :-( " << errorStr ) ;
  }
  return newNode ;
}

//-------------------------------------------------------------------
template < typename T >
ConfigurationParameterDescriptor * ParametersAccessor::set( 
  ConfigurationParameterDescriptor *& node,
  const std::string& name,
  const T & value,
  const std::map< T, std::string >& mapping ) 
{
  bool ok = false ; 
  std::string errorStr ;
  std::string txt ;
  typename std::map< T, std::string >::const_iterator i = mapping.find( value ) ;
  if( i != mapping.end() ) 
  {
    txt = i->second ;
    ok = true ;
  }
  else
  {
    errorStr = "Cannot get a valid string value with the enum value #" ;
    errorStr += (int)value ;
  }

  ConfigurationParameterDescriptor* newNode = ok ? setValue( value, errorStr ) : 0 ; 
  if( newNode )
  {
    if( !node ) node = new MultipleConfigurationParameter() ;
    node->appendSubDescriptorNamed( name, newNode ) ;
  }
  if( !ok )
  {
    OMERROR( "Warning in ParametersAccessor::Set with parameter [" + name + "]" << std::endl 
        << ">>> :-( " << errorStr ) ;
  }
  return newNode ;
}


//-------------------------------------------------------------------
template < typename T >
inline
bool ParametersAccessor::setTxtValue( std::string& textValue, const T& value )
{
  std::stringstream os;
  os << value ;
  textValue = os.str() ;
  return 0 != (void*)os ;
}

//-------------------------------------------------------------------
template < typename T >
inline
ConfigurationParameterDescriptor *ParametersAccessor::setValue( const T& value,
                                                                      std::string& errorStr )
{
  ConfigurationParameterDescriptor *node = 0 ;
  std::string textValue ;
  if( setTxtValue( textValue, value ) ) 
  {
    node = new UniqueConfigurationParameter( textValue ) ;
  }
  else
  {
    errorStr = "Unable to convert the value in a string" ;
  }
  return node ;
}

//-------------------------------------------------------------------
template < typename T >
inline
ConfigurationParameterDescriptor *ParametersAccessor::setValue( const OMK::IAttributeBaseT< T >& attr,
                                                                      std::string& errorStr )
{
  ConfigurationParameterDescriptor *node = 0 ;
  std::string textValue ;
  if( setTxtValue( textValue, attr.get() ) ) 
  {
    node = new UniqueConfigurationParameter( textValue ) ;
  }
  else
  {
    errorStr = "Unable to convert the value of the attribut in a string" ;
  }
  return node ;
}

//-------------------------------------------------------------------
template < typename T >
inline
ConfigurationParameterDescriptor *ParametersAccessor::setValue( const std::vector< T >& values,
                                                                      std::string& errorStr )
{
  ConfigurationParameterDescriptor *node = new MultipleConfigurationParameter() ;
  for( unsigned int i = 0 ; i < values.size() ; i++ )
  {
    ConfigurationParameterDescriptor *itemNode = setValue( values[ i ], errorStr ) ;
    if( itemNode )
    {
      node->appendSubDescriptor( itemNode ) ;
    }
    else
    {
      errorStr += "\nUnable to set the value #" ;
      errorStr += i ;
    }
  }
  return node ;
}

//-------------------------------------------------------------------
template < typename T >
inline
ConfigurationParameterDescriptor *ParametersAccessor::setValue( const std::list< T >& values,
                                                                      std::string& errorStr )
{
  ConfigurationParameterDescriptor *node = new MultipleConfigurationParameter() ;
  for( typename std::list< T >::const_iterator i = values.begin() ; i != values.end() ; i++ )
  {
    ConfigurationParameterDescriptor *itemNode = setValue( *i, errorStr ) ;
    if( itemNode )
    {
      node->appendSubDescriptor( itemNode ) ;
    }
    else
    {
      errorStr += "\nUnable to set the value of the list" ;
    }
  }
  return node ;
}

//-------------------------------------------------------------------
template < typename TK, typename TD >
inline
ConfigurationParameterDescriptor *ParametersAccessor::setValue( const std::map< TK, TD >& values,
                                                                      std::string& errorStr )
{
  ConfigurationParameterDescriptor *node = new MultipleConfigurationParameter() ;
  for( typename std::map< TK, TD >::const_iterator i = values.begin() ; i != values.end() ; i++ )
  {
    ConfigurationParameterDescriptor *keyNode = setValue( i->first, errorStr ) ;
    ConfigurationParameterDescriptor *dataNode = setValue( i->second, errorStr ) ;
    if( keyNode && dataNode )
    {
      ConfigurationParameterDescriptor *itemNode = new MultipleConfigurationParameter() ;
      itemNode->appendSubDescriptor( keyNode ) ;
      itemNode->appendSubDescriptor( dataNode ) ;
      node->appendSubDescriptor( itemNode ) ;
    }
    else
    {
      errorStr += "\nUnable to set the value of the map" ;
    }
  }
  return node ;
}

//-------------------------------------------------------------------
template < typename T1, typename T2 >
inline
ConfigurationParameterDescriptor *ParametersAccessor::setValue( const std::pair< T1, T2 >& values,
                                                                      std::string& errorStr )
{
  ConfigurationParameterDescriptor *node = new MultipleConfigurationParameter ();
  ConfigurationParameterDescriptor *firstNode = setValue( values.first, errorStr ) ;
  ConfigurationParameterDescriptor *secondNode = setValue( values.second, errorStr ) ;
  if( firstNode && secondNode )
  {
    node->appendSubDescriptor( firstNode ) ;
    node->appendSubDescriptor( secondNode ) ;
  }
  else
  {
    errorStr += "\nUnable to set the value of the pair" ;
  }
  return node ;
}
} // namespace OMK

#endif // PSPARAMETERSACCESSOR_INL

---