reader.hh

#ifndef DUNE_FEM_IO_PARAMETER_READER_HH
#define DUNE_FEM_IO_PARAMETER_READER_HH
 
#include <cassert>
 
#include <functional>
#include <iostream>
#include <string>
#include <sstream>
#include <utility>
#include <stdexcept>
 
#include <dune/fem/io/parameter/exceptions.hh>
#include <dune/fem/io/parameter/parser.hh>
 
namespace Dune
{
 
  namespace Fem
  {
 
    static inline const std::string& checkParameterExistsString()
    {
      static const std::string defaultKeyForExistCheck("__ParameterReader::check-exists__");
      return defaultKeyForExistCheck;
    }
 
    // BasicParameterReader
    // --------------------
 
    template< class Parameter >
    struct BasicParameterReader
    {
      typedef BasicParameterReader<Parameter> ThisType;
      explicit BasicParameterReader ( Parameter parameter = Parameter() )
        : parameter_( std::move( parameter ) )
      {}
 
      bool exists ( const std::string &key ) const
      {
        return static_cast< bool >( parameter_( key, &checkParameterExistsString() ) );
      }
 
      template< class T >
      void get ( const std::string &key, T &value ) const
      {
        const std::string *string = parameter_( key, nullptr );
        if( !string )
          DUNE_THROW( ParameterNotFound, "Parameter '" << key << "' not found." );
        if( !ParameterParser< T >::parse( *string, value ) )
          DUNE_THROW( ParameterInvalid, "Parameter '" << key << "' invalid." );
      }
 
      template< class T >
      void get ( const std::string &key, const T &defaultValue, T &value ) const
      {
        const std::string defaultString = ParameterParser< T >::toString( defaultValue );
        const std::string *string = parameter_( key, &defaultString );
        assert( string );
        if( !ParameterParser< T >::parse( *string, value ) )
          DUNE_THROW( ParameterInvalid, "Parameter '" << key << "' invalid." );
      }
 
      void get ( const std::string &key, const char* defaultValue, std::string &value ) const
      {
        const std::string defaultString( defaultValue );
        const std::string *string = parameter_( key, &defaultString );
        assert( string );
        if( !ParameterParser< std::string >::parse( *string, value ) )
          DUNE_THROW( ParameterInvalid, "Parameter '" << key << "' invalid." );
      }
 
      template< class T, class Validator >
      void getValid ( const std::string &key, const Validator &validator, T &value ) const
      {
        const std::string *string = parameter_( key, nullptr );
        if( !string )
          DUNE_THROW( ParameterNotFound, "Parameter '" << key << "' not found." );
        if( !ParameterParser< T >::parse( *string, value ) || !validator( value ) )
          DUNE_THROW( ParameterInvalid, "Parameter '" << key << "' invalid." );
      }
 
      template< class T, class Validator >
      void getValid ( const std::string &key, const T &defaultValue, const Validator &validator, T &value ) const
      {
        const std::string defaultString = ParameterParser< T >::toString( defaultValue );
        const std::string *string = parameter_( key, &defaultString );
        assert( string );
        if( !ParameterParser< T >::parse( *string, value ) || !validator( value ) )
          DUNE_THROW( ParameterInvalid, "Parameter '" << key << "' invalid." );
      }
 
      template< class T >
      T getValue ( const std::string &key ) const
      {
        T value;
        get( key, value );
        return value;
      }
 
      template< class T >
      T getValue ( const std::string &key, const T &defaultValue ) const
      {
        T value = defaultValue;
        get( key, defaultValue, value );
        return value;
      }
 
      template< class T, class Validator >
      T getValidValue ( const std::string &key, const Validator &validator ) const
      {
        T value;
        getValid( key, validator, value );
        return value;
      }
 
      template< class T, class Validator >
      T getValidValue ( const std::string &key, const T &defaultValue, const Validator &validator ) const
      {
        T value;
        getValid( key, defaultValue, validator, value );
        return value;
      }
 
      template< int n >
      int getEnum ( const std::string &key, const std::string (&values)[ n ] ) const
      {
        const std::string *string = parameter_( key, nullptr );
        if( !string )
          DUNE_THROW( ParameterNotFound, "Parameter '" << key << "' not found." );
        return getEnumeration( key, *string, values );
      }
 
      template< int n >
      int getEnum ( const std::string &key, const std::string (&values)[ n ], int defaultValue ) const
      {
        const std::string *string = parameter_( key, &values[ defaultValue ] );
        return getEnumeration( key, *string, values );
      }
 
      int getEnum ( const std::string &key, const std::vector<std::string> &values ) const
      {
        const std::string *string = parameter_( key, nullptr );
        if( !string )
          DUNE_THROW( ParameterNotFound, "Parameter '" << key << "' not found." );
        return getEnumeration( key, *string, values );
      }
 
      int getEnum ( const std::string &key, const std::vector<std::string> &values, int defaultValue ) const
      {
        const std::string *string = parameter_( key, &values[ defaultValue ] );
        return getEnumeration( key, *string, values );
      }
 
      ThisType* clone() const { return new ThisType(parameter_); }
      Parameter parameter() { return parameter_; }
      const Parameter parameter() const { return parameter_; }
      void reset() {}
 
    private:
      template< int n >
      static int getEnumeration ( const std::string &key, const std::string& value, const std::string (&values)[ n ] )
      {
        return getEnumeration( key, value, values, n );
      }
 
      static int getEnumeration ( const std::string &key, const std::string& value, const std::vector<std::string>& values )
      {
        return getEnumeration( key, value, values, values.size() );
      }
 
      // implementation of getEnumeration
      template <class StringVector>
      static int getEnumeration ( const std::string &key, const std::string& value, const StringVector &values, const int n )
      {
        for( int i = 0; i < n; ++i )
        {
          if( value == values[ i ] )
            return i;
        }
 
        int j = -1;
        if( !ParameterParser< int >::parse( value, j ) )
          j = -1;
        if( (j < 0) || (j >= n) )
        {
          std::stringstream sstr;
          if ( value.find("help") == std::string::npos )
            sstr << std::endl << "Parameter '" << key << "' invalid." << std::endl;
          else
            sstr << "Help for parameter '" << key << "':" << std::endl;
 
          sstr << "Valid values are: ";
          for( int i = 0; i < n; ++i )
            sstr << values[ i ] << (i < n-1 ? ", " : "");
          sstr << std::endl;
 
          if ( value.find("help") == std::string::npos )
            DUNE_THROW( ParameterInvalid, sstr.str() );
          else
            throw std::runtime_error(sstr.str());
        }
        return j;
      }
 
    protected:
      Parameter parameter_;
    };
 
 
 
    // ParameterReader
    // ---------------
 
    typedef BasicParameterReader< std::function< const std::string *( const std::string &, const std::string * ) > > ParameterReader;
 
  } // namespace Fem
 
} // namespace Dune
 
#endif // #ifndef DUNE_FEM_IO_PARAMETER_READER_HH