Parameter.h

Go to the documentation of this file.

#ifndef MARLINMT_PARAMETER_h
#define MARLINMT_PARAMETER_h 1

// -- std headers
#include <iostream>
#include <string>
#include <sstream>
#include <typeindex>
#include <memory>
#include <vector>
#include <set>
#include <any>
#include <functional>

// -- marlinmt headers
#include <marlinmt/Utils.h>
#include <marlinmt/Validator.h>

namespace marlinmt {
  
  class ConfigSection ;
  
  enum class EParameterType {
    eSimple,              
    eVector               
  };
  
  //--------------------------------------------------------------------------
  //--------------------------------------------------------------------------
  
  class ParameterImpl {
  public:
    using ValidatorFunction = std::any ;
    
  public:
    ParameterImpl() = delete ;
    ~ParameterImpl() = default ;
    
    template <typename T>
    inline ParameterImpl( 
      EParameterType paramType, 
      const std::string &na, 
      const std::string &desc, 
      std::shared_ptr<T> addr ) :
      _type(paramType),
      _name(na),
      _description(desc),
      _typeIndex(typeid(T)),
      _value(addr),
      _validator(createValidator<T>(nullptr)) {
      construct<T>() ;
    }
    
    template <typename T>
    inline ParameterImpl( 
      EParameterType paramType, 
      const std::string &na, 
      const std::string &desc, 
      std::shared_ptr<T> addr,
      T defVal ) :
      _type(paramType),
      _name(na),
      _description(desc),
      _typeIndex(typeid(T)),
      _value(addr),
      _defaultValue(std::make_shared<T>(std::move(defVal))),
      _validator(createValidator<T>(nullptr)) {
      construct<T>() ;
    }
    
    EParameterType type() const ;
        
    const std::string& name() const ;
    
    const std::string& description() const ;
    
    bool isSet() const ;
    
    bool hasDefault() const ;
    
    std::string str() const ;
    
    std::string defaultStr() const ;
    
    void str( const std::string &value ) ;
    
    std::string typeStr() const ;
    
    const std::type_index &typeIndex() const ;
    
    template <typename T>
    inline bool isType() const {
      return ( std::type_index(typeid(T)) == _typeIndex ) ;
    }
    
    template <typename T>
    inline void checkType() const {
      if( not isType<T>() ) {
        MARLINMT_THROW( "checkType failure. Given: " + std::string(details::type_info<T>::type) + ", stored: " + typeStr() ) ;
      }
    }
    
    template <typename T>
    void setValidator( ValidatorFunctionT<T> validator ) {
      checkType<T>() ;
      _validator = createValidator( validator ) ;
    }
    
    template <typename T>
    inline void set( const T &val ) {
      checkType<T>() ;
      if( _validator.has_value() ) {
        auto validatorT = std::any_cast<ValidatorFunctionT<T>>( _validator ) ;
        if (not validatorT( val ) ) {
          MARLINMT_THROW( "Parameter '" + name() + "': invalid parameter value" ) ;
        }
      }
      *std::static_pointer_cast<T>( _value ).get() = val ;
      _isSet = true ;
    }
    
    template <typename T>
    inline T get() const {
      checkType<T>() ;
      if( not isSet() ) {
        if( not hasDefault() ) {
          MARLINMT_THROW( "Parameter '" + name() +  "' not set" ) ;          
        }
        return *std::static_pointer_cast<T>( _defaultValue ).get() ;
      }
      return *std::static_pointer_cast<T>( _value ).get() ;
    }

    template <typename T>
    inline T get( const T &fallback ) const {
      try {
        return get<T>() ;
      }
      catch( Exception & ) {
        return fallback ;
      }
    }
    
    template <typename T>
    inline T getDefault() const {
      if( not hasDefault() ) {
        MARLINMT_THROW( "Parameter '" + name() + "' has no default value" ) ;
      }
      return *std::static_pointer_cast<T>( _defaultValue ).get() ;
    }
    
    void reset() ;
    
  private:
    using ValueType       = std::shared_ptr<void> ;
    using TypeFunction    = std::function<std::string()> ;
    using StrFunction     = std::function<std::string(ValueType)> ;
    using FromStrFunction = std::function<void(ValueType, const std::string &)> ;
    using ResetFunction   = std::function<void()> ;
    
    template <typename T>
    inline void construct() {
      _typeFunction = [] { return details::type_info<T>::type ; };
      _resetFunction = [this] { *std::static_pointer_cast<T>( _value ).get() = T() ; };
      _strFunction = [this]( ValueType ptr ) { return details::convert<T>::to_string( *std::static_pointer_cast<T>( ptr ).get() ) ; };
      _fromStrFunction = [this] ( ValueType ptr, const std::string &value ) { 
        T valueT = details::convert<T>::from_string( value ) ;
        if( _validator.has_value() ) {
          auto validatorT = std::any_cast<ValidatorFunctionT<T>>( _validator ) ;
          if( not validatorT( valueT ) ) {
            MARLINMT_THROW( "Parameter '" + name() + "': invalid parameter value" ) ;
          }
        }
        *std::static_pointer_cast<T>( ptr ).get() = valueT ;
      };
    }
    
    template <typename T>
    inline ValidatorFunction createValidator( ValidatorFunctionT<T> validatorT ) const {
      std::any validator {} ;
      if( nullptr != validatorT ) {
        validator = validatorT ;
      }
      return validator ;
    }
    
  private:
    EParameterType                               _type {} ;
    std::string                                  _name {} ;
    std::string                                  _description {} ;
    TypeFunction                                 _typeFunction {} ;
    StrFunction                                  _strFunction {} ;
    FromStrFunction                              _fromStrFunction {} ;
    ResetFunction                                _resetFunction {} ;
    bool                                         _isSet {false} ;
    std::type_index                              _typeIndex ;
    ValueType                                    _value {nullptr} ;
    ValueType                                    _defaultValue {nullptr} ;
    ValidatorFunction                            _validator {} ; 
  };
  
  //--------------------------------------------------------------------------
  //--------------------------------------------------------------------------
  
  class Configurable {
  public:
    Configurable() = default ;
    virtual ~Configurable() = default ;
    
    using ParameterMap = std::map<std::string, std::shared_ptr<ParameterImpl>> ;
    using iterator = ParameterMap::iterator ;
    using const_iterator = ParameterMap::const_iterator ;
    
    template <typename T>
    inline std::shared_ptr<ParameterImpl> addParameter( EParameterType paramType, const std::string &name, const std::string &desc, std::shared_ptr<T> value ) {
      checkParameter( name ) ;
      auto param = std::make_shared<ParameterImpl>( paramType, name, desc, value ) ;
      _parameters[ name ] = param ;
      return param ;
    }
    
    template <typename T>
    inline std::shared_ptr<ParameterImpl> addParameter( EParameterType paramType, const std::string &name, const std::string &desc, std::shared_ptr<T> value, T defVal ) {
      checkParameter( name ) ;
      auto param = std::make_shared<ParameterImpl>( paramType, name, desc, value, std::move(defVal) ) ;
      _parameters[ name ] = param ;
      return param ;
    }
    
    template <typename T>
    inline T parameter( const std::string &name ) const {
      checkParameter( name ) ;
      return _parameters.find( name )->second->get<T>()  ;
    }
    
    template <typename T>
    inline T parameter( const std::string &name, const T &fallback ) const {
      checkParameter( name ) ;
      return _parameters.find( name )->second->get<T>( fallback )  ;
    }
    
    void checkParameter( const std::string &name ) const ;

    bool exists( const std::string &name ) const ;

    bool isSet( const std::string &name ) const ;

    void clear() ;
    
    void unset() ;
    
    iterator begin() ;
    const_iterator begin() const ;
    iterator end() ;
    const_iterator end() const ;
    
  protected:
    ParameterMap               _parameters {} ;
  };
  
  //--------------------------------------------------------------------------
  //--------------------------------------------------------------------------
  
  template <typename T>
  class ParameterBase {
  public:
    using ValueType = T ;
    
    virtual ~ParameterBase() = default ;
    
    inline ParameterBase( EParameterType paramType, const std::string &na, const std::string &desc ) {
      _impl = std::make_shared<ParameterImpl>( paramType, na, desc, _value ) ;
    }
    
    inline ParameterBase( EParameterType paramType, const std::string &na, const std::string &desc, const T &defVal ) {
      _impl = std::make_shared<ParameterImpl>( paramType, na, desc, _value, defVal ) ;
    }
    
    inline ParameterBase( Configurable &conf, EParameterType paramType, const std::string &na, const std::string &desc ) {
      _impl = conf.addParameter( paramType, na, desc, _value ) ;
    }
    
    inline ParameterBase( Configurable &conf, EParameterType paramType, const std::string &na, const std::string &desc, const T &defVal ) {
      _impl = conf.addParameter( paramType, na, desc, _value, defVal ) ;
    }

    inline EParameterType type() const {
      return _impl->type() ;
    }
    
    inline const std::string& name() const {
      return _impl->name() ;
    }
    
    inline const std::string& description() const {
      return _impl->description() ;
    }
    
    inline bool isSet() const {
      return _impl->isSet() ;
    }
    
    inline bool hasDefault() const {
      return _impl->hasDefault() ;
    }
    
    inline std::string str() const {
      return _impl->str() ;
    }
    
    inline std::string defaultStr() const {
      return _impl->defaultStr() ;
    }
    
    inline std::string typeStr() const {
      return _impl->typeStr() ;
    }
    
    inline const std::type_index &typeIndex() const {
      return _impl->typeIndex() ;
    }
    
    inline operator T() const {
      return get() ;
    }
    
    inline T get() const {
      return _impl->get<T>() ;
    }
    
    inline T get( const T &fallback ) const {
      return _impl->get<T>( fallback ) ;
    }
    
    inline void set( const T &value ) {
      _impl->set( value ) ;
    }

    inline void reset() {
      _impl->reset() ;
    }
    
    inline void setValidator( ValidatorFunctionT<T> validator ) {
      _impl->setValidator( validator ) ;
    }
    
  protected:
    std::shared_ptr<T>             _value { std::make_shared<T>() } ;
    std::shared_ptr<ParameterImpl> _impl {} ;
  };
  
  //--------------------------------------------------------------------------
  //--------------------------------------------------------------------------
  
  template <typename T>
  class Parameter : public ParameterBase<T> {
  public:
    Parameter() = delete ;
    Parameter( const Parameter<T> & ) = default ;
    Parameter<T> &operator=( const Parameter<T> & ) = default ;
    ~Parameter() = default ;

    inline Parameter( const std::string &na, const std::string &desc ) :
      ParameterBase<T>( EParameterType::eSimple, na, desc ) {
      /* nop */
    }
    
    inline Parameter( const std::string &na, const std::string &desc, const T &defVal ) :
      ParameterBase<T>( EParameterType::eSimple, na, desc, defVal ) {
      /* nop */
    }
    
    inline Parameter( Configurable &conf, const std::string &na, const std::string &desc ) :
      ParameterBase<T>( conf, EParameterType::eSimple, na, desc ) {
      /* nop */
    }
    
    inline Parameter( Configurable &conf, const std::string &na, const std::string &desc, const T &defVal ) :
      ParameterBase<T>( conf, EParameterType::eSimple, na, desc, defVal ) {
      /* nop */
    }
  };
  
  //--------------------------------------------------------------------------
  //--------------------------------------------------------------------------
  
  template <typename T>
  class VectorParameter : public ParameterBase<std::vector<T>> {
  public:
    using Base = ParameterBase<std::vector<T>> ;
    
    VectorParameter() = delete ;
    VectorParameter( const VectorParameter<T> & ) = default ;
    VectorParameter<T> &operator=( const VectorParameter<T> & ) = default ;
    ~VectorParameter() = default ;
    
    inline VectorParameter( const std::string &na, const std::string &desc ) :
      Base( EParameterType::eVector, na, desc ) {
      /* nop */
    }
    
    inline VectorParameter( const std::string &na, const std::string &desc, const std::vector<T> &defVal ) :
      Base( EParameterType::eVector, na, desc, defVal ) {
      /* nop */
    }
    
    inline VectorParameter( Configurable &conf, const std::string &na, const std::string &desc ) :
      Base( conf, EParameterType::eVector, na, desc ) {
      /* nop */
    }
    
    inline VectorParameter( Configurable &conf, const std::string &na, const std::string &desc, const std::vector<T> &defVal ) :
      Base( conf, EParameterType::eVector, na, desc, defVal ) {
      /* nop */
    }
    
    // vector const (only) interface aliases
    auto at( typename std::vector<T>::size_type idx ) const { return Base::_value->at(idx) ; }
    auto operator[]( typename std::vector<T>::size_type idx ) const { return *(Base::_value)[idx] ; }
    auto front() const { return Base::_value->front() ; }
    auto back() const { return Base::_value->back() ; }
    auto data() const { return Base::_value->data() ; }
    auto begin() const { return Base::_value->begin() ; }
    auto end() const { return Base::_value->end() ; }
    auto cbegin() const { return Base::_value->cbegin() ; }
    auto cend() const { return Base::_value->cend() ; }
    auto rbegin() const { return Base::_value->rbegin() ; }
    auto rend() const { return Base::_value->rend() ; }
    auto crbegin() const { return Base::_value->crbegin() ; }
    auto crend() const { return Base::_value->crend() ; }
    auto empty() const { return Base::_value->empty() ; }
    auto size() const { return Base::_value->size() ; }
    auto max_size() const { return Base::_value->max_size() ; }
  };
  
  //--------------------------------------------------------------------------

  template <typename T>
  inline std::ostream &operator <<( std::ostream &stream, const Parameter<T> &rhs ) {
    stream << rhs.get() ;
    return stream ;
  }

  //--------------------------------------------------------------------------

  template <typename T, typename S>
  inline bool operator ==( const Parameter<T> &lhs, const S &rhs ) {
    return ( lhs.get() == rhs ) ;
  }

  //--------------------------------------------------------------------------

  template <typename T, typename S>
  inline bool operator !=( const Parameter<T> &lhs, const S &rhs ) {
    return ( lhs.get() != rhs ) ;
  }

  //--------------------------------------------------------------------------

  template <typename T, typename S>
  inline bool operator <( const Parameter<T> &lhs, const S &rhs ) {
    return ( lhs.get() < rhs ) ;
  }

  //--------------------------------------------------------------------------

  template <typename T, typename S>
  inline bool operator <=( const Parameter<T> &lhs, const S &rhs ) {
    return ( lhs.get() <= rhs ) ;
  }

  //--------------------------------------------------------------------------

  template <typename T, typename S>
  inline bool operator >( const Parameter<T> &lhs, const S &rhs ) {
    return ( lhs.get() > rhs ) ;
  }

  //--------------------------------------------------------------------------

  template <typename T, typename S>
  inline bool operator >=( const Parameter<T> &lhs, const S &rhs ) {
    return ( lhs.get() >= rhs ) ;
  }
  
  //--------------------------------------------------------------------------
  
  // helper types
  using IntParameter = Parameter<int> ;
  using UIntParameter = Parameter<unsigned int> ;
  using FloatParameter = Parameter<float> ;
  using DoubleParameter = Parameter<double> ;
  using BoolParameter = Parameter<bool> ;
  using StringParameter = Parameter<std::string> ;
  using IntVectorParameter = VectorParameter<int> ;
  using UIntVectorParameter = VectorParameter<unsigned int> ;
  using FloatVectorParameter = VectorParameter<float> ;
  using DoubleVectorParameter = VectorParameter<double> ;
  using BoolVectorParameter = VectorParameter<bool> ;
  using StringVectorParameter = VectorParameter<std::string> ;

} // end namespace marlinmt
#endif