Config.h

Go to the documentation of this file.

/***********************************************************************************/
/*  Copyright 2009 WSL Institute for Snow and Avalanche Research    SLF-DAVOS      */
/***********************************************************************************/
/* This file is part of MeteoIO.
    MeteoIO is free software: you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    MeteoIO is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License for more details.
 
    You should have received a copy of the GNU Lesser General Public License
    along with MeteoIO.  If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef CONFIGREADER_H
#define CONFIGREADER_H
 
#include <meteoio/IOUtils.h>
#include <meteoio/IOExceptions.h>
 
#include <string>
#include <sstream>
#include <map>
#include <vector>
#include <typeinfo> //for typeid()
 
namespace mio {
 
class ConfigProxy;
 
class Config {
        public:
                Config();
 
                Config(const std::string& filename_in);
 
                void write(const std::string& filename) const;
 
                void addFile(const std::string& filename_in);
 
                void addKey(std::string key, std::string section, const std::string& value);
 
                void deleteKey(std::string key, std::string section);
 
                void deleteKeys(std::string keymatch, std::string section, const bool& anywhere=false);
 
                std::string getSourceName() const {return sourcename;}
 
                std::string getConfigRootDir() const {return configRootDir;}
 
                bool keyExists(std::string key, std::string section) const;
                bool keyExistsRegex(std::string key_pattern, std::string section) const;
 
                bool sectionExists(std::string section) const;
 
                const std::string toString() const;
 
                friend std::ostream& operator<<(std::ostream& os, const Config& cfg);
                friend std::istream& operator>>(std::istream& is, Config& cfg);
 
                template <typename T> std::vector<T> getValue(const std::string& key, std::string& section,
                                                              const IOUtils::ThrowOptions& opt=IOUtils::dothrow) const
                {
                        std::vector<T> tmp;
                        getValue(key, section, tmp, opt);
                        return tmp;
                }
 
                template <typename T> void getValue(const std::string& key,
                                                    std::vector<T>& vecT,
                                                    const IOUtils::ThrowOptions& opt=IOUtils::dothrow) const
                {
                        getValue(key, "GENERAL", vecT, opt);
                }
 
                template <typename T> void getValue(std::string key, std::string section,
                                                    std::vector<T>& vecT, const IOUtils::ThrowOptions& opt=IOUtils::dothrow) const
                {
                        vecT.clear();
                        IOUtils::toUpper(key);
                        IOUtils::toUpper(section);
 
                        try {
                                IOUtils::getValueForKey<T>(properties, section + "::" + key, vecT, opt);
                        } catch(const std::exception&){
                                throw UnknownValueException("[E] Error in "+sourcename+": no value for key "+section+"::"+key, AT);
                        }
                }
 
                const ConfigProxy get(const std::string& key, const std::string& section) const;
                
                template <typename T> T get(const std::string& key, const std::string& section, const T& dflt) const;
                
                std::string get(const std::string& key, const std::string& section, const std::string& dflt) const;
                std::string get(const std::string& key, const std::string& section, const char dflt[]) const;
                double get(const std::string& key, const std::string& section, const double& dflt) const; //surprisingly, in c++11 with gcc 9.3.0 this is needed...
                bool get(const std::string& key, const std::string& section, const bool& dflt) const;
 
 
                template <typename T> void getValue(const std::string& key, T& t, const IOUtils::ThrowOptions& opt=IOUtils::dothrow) const
                {
                        getValue(key, "GENERAL", t, opt);
                }
 
                template <typename T> void getValue(std::string key, std::string section, T& t,
                                              const IOUtils::ThrowOptions& opt=IOUtils::dothrow) const
                {
                        IOUtils::toUpper(key);
                        IOUtils::toUpper(section);
 
                        try {
                                IOUtils::getValueForKey<T>(properties, section + "::" + key, t, opt);
                        } catch(const std::exception&){
                                throw UnknownValueException("[E] Error in "+sourcename+": no value for key "+section+"::"+key, AT);
                        }
                }
                
                void getValue(std::string key, std::string section, Date& t, const double& time_zone, 
                                              const IOUtils::ThrowOptions& opt=IOUtils::dothrow) const
                {
                        t.setUndef(true);
                        IOUtils::toUpper(key);
                        IOUtils::toUpper(section);
                        std::string tmp;
                        
                        try {
                                IOUtils::getValueForKey<std::string>(properties, section + "::" + key, tmp, opt);
                        } catch(const std::exception&){
                                throw UnknownValueException("[E] Error in "+sourcename+": no value for key "+section+"::"+key, AT);
                        }
                        
                        bool parse_ok = false;
                        try {
                                parse_ok = IOUtils::convertString(t, tmp, time_zone);
                        } catch(const std::exception&){
                                parse_ok = false;
                        }
                        if (!parse_ok && opt==IOUtils::dothrow)
                                throw InvalidFormatException("Could not parse date '"+tmp+"' in "+sourcename+"for key "+section+"::"+key, AT);
                }
                
                template <typename T> void getValues(std::string keymatch, std::string section, std::vector<T>& vecT) const
                {
                        vecT.clear();
                        IOUtils::toUpper(keymatch);
                        IOUtils::toUpper(section);
                        const std::vector< std::string > vecKeys( getKeys(keymatch, section) );
 
                        for (const std::string& key : vecKeys) {
                                const std::string full_key( section + "::" + key );
                                T tmp;
                                try {
                                        IOUtils::getValueForKey<T>(properties, full_key, tmp, IOUtils::dothrow);
                                } catch(const std::exception&){
                                        throw UnknownValueException("[E] Error in "+sourcename+" reading key "+full_key, AT);
                                }
                                vecT.push_back( tmp );
                        }
                }
 
                template <typename T> void getValues(std::string keymatch, std::string section, std::vector<T>& vecT, std::vector<std::string>& vecKeys) const
                {
                        vecT.clear();
                        IOUtils::toUpper(keymatch);
                        IOUtils::toUpper(section);
                        vecKeys = getKeys(keymatch, section);
 
                        for (const std::string& key : vecKeys) {
                                const std::string full_key = section + "::" + key;
                                T tmp;
                                try {
                                        IOUtils::getValueForKey<T>(properties, full_key, tmp, IOUtils::dothrow);
                                } catch(const std::exception&){
                                        throw UnknownValueException("[E] Error in "+sourcename+" reading key "+full_key, AT);
                                }
                                vecT.push_back( tmp );
                        }
                }
 
                std::vector< std::pair<std::string, std::string> > getValues(std::string keymatch, std::string section, const bool& anywhere=false) const;
                
                std::vector< std::pair<std::string, std::string> > getValuesRegex(const std::string& regex_str, std::string section) const;
 
                std::vector<std::string> getKeys(std::string keymatch, std::string section, const bool& anywhere=false) const;
                std::vector<std::string> getKeysRegex(const std::string& regex_str, std::string section) const;
                std::set<std::string> getSections() const {return sections;}
 
                void moveSection(std::string org, std::string dest, const bool& overwrite);
                
                static unsigned int getCommandNr(const std::string& section, const std::string& cmd_pattern, const std::string& cmd_key);
                
                std::vector< std::pair<std::string, std::string> > parseArgs(const std::string& section, const std::string& cmd_id, const unsigned int& cmd_nr, const std::string& arg_pattern) const;
 
                std::vector< std::pair<std::string, std::string> > getArgumentsForAlgorithm(const std::string& parname, const std::string& algorithm,
                        const std::string& section = "Interpolations1d") const;
                // overload for indexed algorith
                std::vector< std::pair<std::string, std::string> > getArgumentsForAlgorithm(const std::string& parname, const std::string& algorithm, const size_t& algo_index,
                        const std::string& section = "Interpolations1d") const;
 
 
 
        private:
                std::map<std::string, std::string> properties; 
                std::set<std::string> sections; 
                std::string sourcename; 
                std::string configRootDir; 
}; //end class definition Config
 
class ConfigProxy {
        public:
                const Config& proxycfg;
                const std::string& key;
                const std::string& section;
 
                ConfigProxy(const Config& i_cfg, const std::string& i_key,
                            const std::string& i_section)
                            : proxycfg(i_cfg), key(i_key),section(i_section) { }
 
                template<typename T> operator T() const {
                        T tmp;
                        proxycfg.getValue(key, section, tmp, IOUtils::dothrow);
                        return tmp;
                }
};
 
class ConfigParser {
        public:
                ConfigParser(const std::string& filename, std::map<std::string, std::string> &i_properties, std::set<std::string> &i_sections);
                
                static std::string extract_section(std::string key);
        private:
                void parseFile(const std::string& filename);
                void parseLine(const unsigned int& linenr, std::vector<std::string> &import_after, bool &accept_import_before, std::string &line, std::string &section);
                static bool onlyOneEqual(const std::string& str);
                static void processEnvVars(std::string& value);
                static void processExpr(std::string& value);
                bool processVars(std::string& value, const std::string& section);
                bool processSectionHeader(const std::string& line, std::string &section, const unsigned int& linenr);
                std::string clean_import_path(const std::string& in_path) const;
                bool processImports(const std::string& key, const std::string& value, std::vector<std::string> &import_after, const bool &accept_import_before);
                void handleNonKeyValue(const std::string& line_backup, const std::string& section, const unsigned int& linenr, bool &accept_import_before);
 
                std::map<std::string, std::string> properties; 
                std::set<std::string> imported; 
                std::set<std::string> sections; 
                std::set<std::string> deferred_vars; 
                std::string sourcename; 
};
 
} //end namespace mio
 
#endif