Parameters.h

 
#pragma once
 
#if defined(Parameters_RECURSES)
#error Recursive header files inclusion detected in Parameters.h
#else // defined(Parameters_RECURSES)
#define Parameters_RECURSES
 
#if !defined Parameters_h
#define Parameters_h
 
// Inclusions
#include <iostream>
#include <map>
#include <string>
#include <sstream>
#include "DGtal/base/Common.h"
 
namespace DGtal
{
  namespace detail
  {
    template <typename X, typename Y>
      struct ValueConverter {
        static Y cast( const X&  )
        {
          ASSERT( false
                  && "[ValueConverter<X,Y>::cast] there is no such generic type converter." );
          return Y();
        }
      };
    
    template <>
      struct ValueConverter< std::string, double >{
      static double cast( const std::string& value )
      {
        // note (JOL): cannot use atof (C) since it uses a different locale as program_options (C++).
        double val;
        std::istringstream iss( value );
        iss >> val;
        return val;
      }
    };
    
    template <>
      struct ValueConverter< std::string, float >{
      static float cast( const std::string& value )
      {
        // note (JOL): cannot use atof (C) since it uses a different locale as program_options (C++).
        float val;
        std::istringstream iss( value );
        iss >> val;
        return val;
      }
    };
 
    template <>
      struct ValueConverter< std::string, int >{
      static int cast( const std::string& value )
      {
        // note (JOL): cannot use atoi (C) since it uses a different locale as program_options (C++).
        int val;
        std::istringstream iss( value );
        iss >> val;
        return val;
      }
    };
    template < typename X >
      struct ValueConverter< X, std::string >{
      static std::string cast( const X& value )
      {
        std::ostringstream ss;
        ss << value;
        return ss.str();
      }
    };
 
  } // namespace detail
    
  struct ParameterValue {
    typedef ParameterValue Self;
    ParameterValue ()                = default;
    ParameterValue ( const Self& v ) = default;
    ParameterValue ( Self&& v )      = default;
    Self& operator=( const Self& v ) = default;
    ParameterValue ( const std::string& v );
    template <typename X>
    ParameterValue ( const X& v );
    template <typename T>
    T    as() const;
    void selfDisplay ( std::ostream & out ) const;
  protected:
    std::string myValue;
  };
 
  std::ostream&
  operator<< ( std::ostream & out, const ParameterValue & object );
  
  struct Parameters {
    typedef Parameters Self;
    
    Parameters()                         = default;
    ~Parameters()                        = default;
    Parameters( const Self& other )      = default;
    Parameters( Self&& other )           = default;
    Self& operator=( const Self& other ) = default;
    Parameters( std::string name, ParameterValue pv = ParameterValue() );
    Self& operator()( std::string name, ParameterValue pv = ParameterValue() );
    Self& operator()( const Self& params );
    ParameterValue operator[]( std::string name ) const;
    bool count( std::string name ) const;
 
    Self operator|( const Self& other ) const;
    
    // ----------------------- Interface --------------------------------------
  public:
 
    void selfDisplay ( std::ostream & out ) const;
 
    bool isValid() const;
    
  protected:
    std::map< std::string, ParameterValue > myParameters;
  };
 
  std::ostream&
  operator<< ( std::ostream & out, const Parameters & object );
 
} // namespace DGtal
 
 
// Includes inline functions.
#include "DGtal/helpers/Parameters.ih"
 
//                                                                           //
 
#endif // !defined Parameters_h
 
#undef Parameters_RECURSES
#endif // else defined(Parameters_RECURSES)