Configuration.h

Go to the documentation of this file.

#pragma once

// -- std headers
#include <string>
#include <map>
#include <vector>

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

namespace marlinmt {
  
  class Configurable ;
  
  class ConfigSection {
  public:
    using ConfigSectionMap = std::map<std::string, ConfigSection> ;
    using ParameterMap = std::map<std::string, std::string> ;
    using Metadata = std::map<std::string, std::string> ;
        
  public:
    // default copy and move
    ConfigSection( const ConfigSection& ) = default ;
    ConfigSection& operator=( const ConfigSection& ) = default ;
    ConfigSection( ConfigSection&& ) = default ;
    ConfigSection& operator=( ConfigSection&& ) = default ;
    
    ConfigSection( const std::string &name ) ;
    
    const std::string &name() const ;
    
    bool empty() const ;
    

    ConfigSection &section( const std::string &n ) ;
    
    const ConfigSection &section( const std::string &n ) const ;
    
    ConfigSection &addSection( const std::string &n ) ;
    
    bool hasSection( const std::string &n ) const ;
    
    std::vector<std::string> subsectionNames() const ;
    

    template <typename T>
    ConfigSection &setParameter( const std::string &n, const T &val ) {
      _parameters.insert_or_assign( n, details::convert<T>::to_string(val) ) ;
      return *this ;
    }
    
    template <typename T>
    inline T parameter( const std::string &n ) const {
      auto iter = _parameters.find( n ) ;
      if( _parameters.end() == iter  ) {
        MARLINMT_THROW( "No parameter '" + n + "' in section '" + name() + "'" ) ;
      }
      return details::convert<T>::from_string( iter->second ) ;
    }
    
    template <typename T>
    inline T parameter( const std::string &n, const T &defVal ) const {
      auto iter = _parameters.find( n ) ;
      if( _parameters.end() == iter  ) {
        return defVal ;
      }
      return details::convert<T>::from_string( iter->second ) ;
    }
    
    bool hasParameter( const std::string &n ) const ;
    
    std::vector<std::string> parameterNames() const ;
    
    const Metadata &metadata() const ;
    
    Metadata &metadata() ;
    
    void loadParameters( Configurable &cfg ) const ;
    
    const ParameterMap &parameters() const ;
    
  private:
    ConfigSectionMap           _subsections {} ;
    ParameterMap               _parameters {} ;
    Metadata                   _metadata {} ;
    const std::string          _name ;
  };
  
  //--------------------------------------------------------------------------
  //--------------------------------------------------------------------------
  
  class Configuration {
  public:
    using ConfigSectionMap = ConfigSection::ConfigSectionMap ;
    using ConstantsMap = std::map<std::string, std::string> ;
    
  public:
    // Default constructors, destructors, copy, move
    Configuration() = default ;
    ~Configuration() = default ;
    Configuration( const Configuration & ) = default ;
    Configuration( Configuration && ) = default ;
    Configuration& operator=( const Configuration & ) = default ;
    Configuration& operator=( Configuration && ) = default ;
    

    template <typename T>
    T constantAs( const std::string &cn ) const {
      auto iter = _constants.find( cn ) ;
      if( iter == _constants.end() ) {
        MARLINMT_THROW( "No constant '" + cn +  "' in configuration" ) ;
      }
      return details::convert<T>::from_string( iter->second ) ;
    }
    
    template <typename T>
    T constantAs( const std::string &cn, const T &defVal ) const {
      auto iter = _constants.find( cn ) ;
      if( iter == _constants.end() ) {
        return defVal ;
      }
      return details::convert<T>::from_string( iter->second ) ;
    }
    
    template <typename T>
    Configuration &addConstant( const std::string &cn, const T &val ) {
      auto iter = _constants.find( cn ) ;
      if( iter != _constants.end() ) {
        MARLINMT_THROW( "Constant '" + cn +  "' already present in configuration" ) ;
      }
      _constants.emplace( cn, details::convert<T>::to_string( val ) ) ;
      return *this ;
    }
    
    bool hasConstant( const std::string &cn ) const ;
    
    const ConstantsMap &constants() const ;
    

    ConfigSection &createSection( const std::string &sn ) ;
    
    ConfigSection &section( const std::string &sn ) ;
    
    const ConfigSection &section( const std::string &sn ) const ;
    
    std::vector<std::string> sections() const ;
    
    bool hasSection( const std::string &n ) const ;


    void replaceConstants( std::string& str ) const ;
    
  private:
    ConfigSectionMap           _sections {} ;
    ConstantsMap               _constants {} ;
  };
  
  std::ostream &operator<<( std::ostream &stream, const Configuration &cfg ) ;
  
  //--------------------------------------------------------------------------
  //--------------------------------------------------------------------------
  
  class ConfigReader {
  public:
    virtual ~ConfigReader() = default ;
    
    virtual void init( const std::string &desc ) = 0 ;

    virtual void read( Configuration &cfg ) = 0 ;
  };
  
  //--------------------------------------------------------------------------
  //--------------------------------------------------------------------------
  
  class ConfigWriter {
  public:    
    virtual ~ConfigWriter() = default ;
    
    virtual void init( const std::string &desc ) = 0 ;

    virtual void write( const Configuration &cfg ) = 0 ;
  };
  
  //--------------------------------------------------------------------------
  //--------------------------------------------------------------------------
  
  class ConfigHelper {
    // Static API only
    ConfigHelper() = delete ;
    ~ConfigHelper() = delete ;
    
  public:
    static std::pair<std::string, std::string> splitPluginInput( const std::string &str ) ;
    
    static void readConfig( const std::string &str, Configuration &cfg ) ;
    
    static void writeConfig( const std::string &str, Configuration &cfg ) ;
  };
    
}