itkParameterMapInterface.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright UMC Utrecht and contributors
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
 
#ifndef __itkParameterMapInterface_h
#define __itkParameterMapInterface_h
 
#include "itkObject.h"
#include "itkObjectFactory.h"
#include "itkMacro.h"
#include "itkNumericTraits.h"
 
#include "itkParameterFileParser.h"
 
#include <iostream>
 
namespace itk
{
 
class ParameterMapInterface : public Object
{
public:
 
  typedef ParameterMapInterface      Self;
  typedef Object                     Superclass;
  typedef SmartPointer< Self >       Pointer;
  typedef SmartPointer< const Self > ConstPointer;
 
  itkNewMacro( Self );
 
  itkTypeMacro( ParameterMapInterface, Object );
 
  typedef ParameterFileParser::ParameterValuesType ParameterValuesType;
  typedef ParameterFileParser::ParameterMapType    ParameterMapType;
 
  void SetParameterMap( const ParameterMapType & parMap );
 
  // \todo: we could think of a warning level. (maybe you want warnings, but
  // not when for example a parameter is not found at entry entry_nr but at entry 0 instead
  itkSetMacro( PrintErrorMessages, bool );
  itkGetConstMacro( PrintErrorMessages, bool );
 
  std::size_t CountNumberOfParameterEntries(
    const std::string & parameterName ) const;
 
  template< class T >
  bool ReadParameter( T & parameterValue,
    const std::string & parameterName,
    const unsigned int entry_nr,
    const bool printThisErrorMessage,
    std::string & errorMessage ) const
  {
    errorMessage = "";
 
    std::size_t numberOfEntries = this->CountNumberOfParameterEntries(
      parameterName );
 
    if( numberOfEntries == 0 )
    {
      std::stringstream ss;
      ss << "WARNING: The parameter \"" << parameterName
         << "\", requested at entry number " << entry_nr
         << ", does not exist at all.\n"
         << "  The default value \"" << parameterValue
         << "\" is used instead." << std::endl;
      if( printThisErrorMessage && this->m_PrintErrorMessages )
      {
        errorMessage = ss.str();
      }
 
      return false;
    }
 
    const ParameterValuesType & vec = this->m_ParameterMap.find( parameterName )->second;
 
    if( entry_nr >= numberOfEntries )
    {
      std::stringstream ss;
      ss << "WARNING: The parameter \"" << parameterName
         << "\" does not exist at entry number " << entry_nr
         << ".\n  The default value \"" << parameterValue
         << "\" is used instead." << std::endl;
      if( printThisErrorMessage && this->m_PrintErrorMessages )
      {
        errorMessage = ss.str();
      }
      return false;
    }
 
    bool castSuccesful = this->StringCast( vec[ entry_nr ], parameterValue );
 
    if( !castSuccesful )
    {
      std::stringstream ss;
      ss << "ERROR: Casting entry number " << entry_nr
         << " for the parameter \"" << parameterName
         << "\" failed!\n"
         << "  You tried to cast \"" << vec[ entry_nr ]
         << "\" from std::string to "
         << typeid( parameterValue ).name() << std::endl;
 
      itkExceptionMacro( << ss.str() );
    }
 
    return true;
 
  } // end ReadParameter()
 
 
  bool ReadParameter( bool & parameterValue,
    const std::string & parameterName,
    const unsigned int entry_nr,
    const bool printThisErrorMessage,
    std::string & errorMessage ) const;
 
  template< class T >
  bool ReadParameter( T & parameterValue,
    const std::string & parameterName,
    const unsigned int entry_nr,
    std::string & errorMessage ) const
  {
    return this->ReadParameter( parameterValue, parameterName, entry_nr,
      true, errorMessage );
  }
 
 
  template< class T >
  bool ReadParameter( T & parameterValue,
    const std::string & parameterName,
    const std::string & prefix,
    const unsigned int entry_nr,
    const int default_entry_nr,
    const bool printThisErrorMessage,
    std::string & errorMessage ) const
  {
    std::string fullname = prefix + parameterName;
    bool        found    = false;
 
    std::string dummyString = "";
    if( default_entry_nr >= 0 )
    {
      unsigned int uintdefault = static_cast< unsigned int >( default_entry_nr );
      found |= this->ReadParameter( parameterValue, parameterName, uintdefault,
        false, dummyString );
      found |= this->ReadParameter( parameterValue, parameterName, entry_nr,
        false, dummyString );
      found |= this->ReadParameter( parameterValue, fullname, uintdefault,
        false, dummyString );
      found |= this->ReadParameter( parameterValue, fullname, entry_nr,
        false, dummyString );
    }
    else
    {
      found |= this->ReadParameter( parameterValue, parameterName, entry_nr,
        false, dummyString );
      found |= this->ReadParameter( parameterValue, fullname, entry_nr,
        false, dummyString );
    }
 
    if( !found && printThisErrorMessage && this->m_PrintErrorMessages )
    {
      return this->ReadParameter( parameterValue, parameterName, entry_nr,
        true, errorMessage );
    }
 
    return found;
 
  }
 
 
  template< class T >
  bool ReadParameter( T & parameterValue,
    const std::string & parameterName,
    const std::string & prefix,
    const unsigned int entry_nr,
    const unsigned int default_entry_nr,
    std::string & errorMessage ) const
  {
    return this->ReadParameter( parameterValue, parameterName, prefix,
      entry_nr, default_entry_nr, true, errorMessage );
  }
 
 
  template< class T >
  bool ReadParameter(
    std::vector< T > & parameterValues,
    const std::string & parameterName,
    const unsigned int entry_nr_start,
    const unsigned int entry_nr_end,
    const bool printThisErrorMessage,
    std::string & errorMessage ) const
  {
    errorMessage = "";
 
    std::size_t numberOfEntries = this->CountNumberOfParameterEntries(
      parameterName );
 
    if( numberOfEntries == 0 )
    {
      std::stringstream ss;
      ss << "WARNING: The parameter \"" << parameterName
         << "\", requested between entry numbers " << entry_nr_start
         << " and " << entry_nr_end
         << ", does not exist at all.\n"
         << "  The default values are used instead." << std::endl;
      if( printThisErrorMessage && this->m_PrintErrorMessages )
      {
        errorMessage = ss.str();
      }
      return false;
    }
 
    if( entry_nr_start > entry_nr_end )
    {
      std::stringstream ss;
      ss << "WARNING: The entry number start (" << entry_nr_start
         << ") should be smaller than entry number end (" << entry_nr_end
         << "). It was requested for parameter \"" << parameterName
         << "\"." << std::endl;
 
      itkExceptionMacro( << ss.str() );
    }
 
    if( entry_nr_end >= numberOfEntries )
    {
      std::stringstream ss;
      ss << "WARNING: The parameter \"" << parameterName
         << "\" does not exist at entry number " << entry_nr_end
         << ".\nThe default value \"" << itk::NumericTraits< T >::Zero
         << "\" is used instead." << std::endl;
      itkExceptionMacro( << ss.str() );
    }
 
    const ParameterValuesType & vec = this->m_ParameterMap.find( parameterName )->second;
 
    unsigned int j = 0;
    for( unsigned int i = entry_nr_start; i < entry_nr_end + 1; ++i )
    {
      bool castSuccesful = this->StringCast( vec[ i ], parameterValues[ j ] );
      j++;
 
      if( !castSuccesful )
      {
        std::stringstream ss;
        ss << "ERROR: Casting entry number " << i
           << " for the parameter \"" << parameterName
           << "\" failed!\n"
           << "  You tried to cast \"" << vec[ i ]
           << "\" from std::string to "
           << typeid( parameterValues[ 0 ] ).name() << std::endl;
 
        itkExceptionMacro( << ss.str() );
      }
    }
 
    return true;
  }
 
 
  bool ReadParameter(
    std::vector< std::string > & parameterValues,
    const std::string & parameterName,
    const unsigned int entry_nr_start,
    const unsigned int entry_nr_end,
    const bool printThisErrorMessage,
    std::string & errorMessage ) const;
 
protected:
 
  ParameterMapInterface();
  ~ParameterMapInterface() override;
 
private:
 
  ParameterMapInterface( const Self & ); // purposely not implemented
  void operator=( const Self & );        // purposely not implemented
 
  ParameterMapType m_ParameterMap;
 
  bool m_PrintErrorMessages;
 
  template< class T >
  bool StringCast( const std::string & parameterValue, T & casted ) const
  {
    std::stringstream ss( parameterValue );
 
    typename NumericTraits< T >::AccumulateType tempCasted;
    ss >> tempCasted;
    casted = static_cast< T >( tempCasted );
    if( ss.bad() || ss.fail() )
    {
      return false;
    }
    return true;
 
  } // end StringCast()
 
 
  bool StringCast( const std::string & parameterValue, std::string & casted ) const;
 
};
 
} // end of namespace itk
 
#endif // end __itkParameterMapInterface_h