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 <map>
#include <vector>
 
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(const std::string& key, const bool& provide_default=false);
                
        private:
                enum VarType {
                        ROOT,   
                        ENV,    
                        EXPR,   
                        REF             
                };
                
                typedef struct VARIABLE {
                        VARIABLE() : value(), children_idx(), children_not_ready(0), parent_idx(IOUtils::npos), pos_start(std::string::npos), pos_end(std::string::npos), type(REF), isExpanded(false) {}
                        VARIABLE(const size_t& i_pos_start, const VarType& i_type) : value(), children_idx(), children_not_ready(0), parent_idx(IOUtils::npos), pos_start(i_pos_start), pos_end(std::string::npos), type(i_type), isExpanded(false) {}
                        VARIABLE(const std::string& i_value, const size_t& i_pos_start, const size_t& i_pos_end, const VarType& i_type) : value(i_value), children_idx(), children_not_ready(0), parent_idx(IOUtils::npos), pos_start(i_pos_start), pos_end(i_pos_end), type(i_type), isExpanded(false) {}
                        
                        void finalize(const std::string& i_value, const size_t& i_pos_end) {value=i_value; pos_end=i_pos_end;}
                        void setParent(const size_t& idx) {parent_idx=idx;}
                        void setChild(const size_t& idx) {children_idx.insert(idx); children_not_ready++;}
                        
                        std::string toString() const {std::ostringstream os; os << "<Variable>" << (type==EXPR?"expr":(type==ENV?"env":"ref")) << " @[" << pos_start << ","; if(pos_end!=IOUtils::npos) os << pos_end; else os << "-"; os << "]" << " is '" << value << "'"; if(parent_idx!=IOUtils::npos) os << " parent: " << parent_idx; if(!children_idx.empty()){ os << " children: "; for(const auto& val : children_idx) os << val << " ";}; os << " children_not_ready=" << children_not_ready << " "; os << "</variable>"; return os.str();}
                        
                        std::string value;                              
                        std::set<size_t> children_idx;  
                        size_t children_not_ready;              
                        size_t parent_idx;                              
                        size_t pos_start, pos_end;              
                        VarType type;                                   
                        bool isExpanded;                                
                } variable;
 
                typedef struct FILE_PPT {
                        FILE_PPT() : original_name(), restrict_section(), clean_name() {}
                        FILE_PPT(const std::string& filename, const std::string& ini_sourcename);
 
                        std::string toString() const {std::ostringstream os; os << "<INI file>" << original_name << ", cleaned as " << clean_name; if (!restrict_section.empty()) os << ", restricted to [" << restrict_section << "]"; os << "</INI file>"; return os.str();}
                        
                        bool operator<(const FILE_PPT& a) const { //needed for "sort"
                                if (original_name<a.original_name) return true;
                                if (original_name>a.original_name) return false;
                                if (clean_name<a.clean_name) return true;
                                if (clean_name>a.clean_name) return false;
                                return restrict_section < a.restrict_section;
                        }
                        bool operator==(const FILE_PPT& a) const { //needed to check for uniqueness
                                return (original_name==a.original_name) && (restrict_section==a.restrict_section) && (clean_name==a.clean_name);
                        }
 
                        std::string original_name;              
                        std::string restrict_section;   
                        std::string clean_name;                 
                } fileProperties;
                
                static std::vector<ConfigParser::variable> parseVariable(const std::string &value);
                bool expandVar(const variable& var, const std::string& section, std::string &replacement) const;
                bool expandVarsForKey(std::vector<variable>& vecVars, const std::string& section, bool& hasSomeSuccesses);
                
                void parseFile(const fileProperties& iniFile);
                void parseLine(const unsigned int& linenr, const std::string& restrict_section, std::vector< fileProperties > &import_after, bool &accept_import_before, std::string line, std::string &section);
                
                static bool onlyOneEqual(const std::string& str);
                bool processSectionHeader(const std::string& line, std::string &section, const unsigned int& linenr);
                bool processImports(const std::string& key, const std::string& value, std::vector< fileProperties > &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< fileProperties > imported; 
                std::set<std::string> sections; 
                std::map<std::string, std::vector<variable> > vars; 
                std::string sourcename; 
};
 
} //end namespace mio
 
#endif