IOUtils.h

Go to the documentation of this file.

// SPDX-License-Identifier: LGPL-3.0-or-later
/***********************************************************************************/
/*  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 IOUTILS_H
#define IOUTILS_H
 
#include <iostream>
#include <string>
#include <map>
#include <vector>
#include <set>
#include <cstdlib>
#include <limits>
#include <cmath>
 
#include <meteoio/dataClasses/Coords.h>
#include <meteoio/dataClasses/Date.h>
#include <meteoio/IOExceptions.h>
#include <meteoio/meteoLaws/Meteoconst.h>
 
namespace mio {
 
#ifdef _MSC_VER
double round(const double& x);
#endif
 
class MeteoData;
class Coords;
class Config;
 
std::string getLibVersion(const bool& short_version=false);
 
namespace IOUtils {
        enum ProcessingLevel {
                raw           = 1,
                filtered      = 1 << 1,
                resampled     = 1 << 2,
                generated     = 1 << 3,
                num_of_levels = 1 << 4
        };
 
        enum OperationMode {
                STD, 
                VSTATIONS, 
                GRID_1DINTERPOLATE,  
                GRID_EXTRACT, 
                GRID_EXTRACT_PTS, 
                GRID_SMART, 
                GRID_ALL, 
                GRID_RESAMPLE 
        };
 
        enum ThrowOptions { dothrow, nothrow };
        const double nodata = -999.0; 
        const unsigned int unodata = static_cast<unsigned int>(-1);
        const int inodata = -999;
        const short int snodata = -999;
        const char cnodata = std::numeric_limits<char>::max();
        const size_t npos = static_cast<size_t>(-1);  
 
        const double grid_epsilon = 5.; 
        const double lon_epsilon = grid_epsilon / Cst::earth_R0 *  Cst::to_deg; 
        const double lat_epsilon = lon_epsilon; 
 
        inline double C_TO_K(const double& T) {return ((T==nodata)? T : T + Cst::t_water_freezing_pt);}
        inline double K_TO_C(const double& T) {return ((T==nodata)? T : T - Cst::t_water_freezing_pt);}
 
        inline double UV_TO_DW(const double& U, const double& V) {return ((U==nodata || V==nodata)? nodata : fmod(atan2(U, V) * Cst::to_deg + 180., 360.));}
 
        inline double VWDW_TO_U(const double& VW, const double& DW) {return ((VW==nodata || DW==nodata)? nodata : (- VW * sin(DW*Cst::to_rad)));}
 
        inline double VWDW_TO_V(const double& VW, const double& DW) {return ((VW==nodata || DW==nodata)? nodata : (- VW * cos(DW*Cst::to_rad)));}
 
        inline bool checkEpsilonEquality(const double& val1, const double& val2, const double& epsilon) {return (std::abs(val1-val2) < epsilon);}
 
        size_t seek(const Date& soughtdate, const std::vector<MeteoData>& vecM, const bool& exactmatch=true);
 
        double bearing_to_angle(const double& bearing);
        double angle_to_bearing(const double& angle);
        double bearing(std::string bearing_str);
        std::string bearing(double bearing);
 
        std::string getLogName();
        
        std::string getHostName();
        
        std::string getDomainName();
 
        void trim(std::string &s);
 
        std::string trim(const std::string &s);
 
        void stripComments(std::string& str);
        
        void stripComments(std::string& str, const char& comment_mk);
 
        void cleanEscapedCharacters(std::string& str, const std::vector<char>& escaped_chars);
        
        void replace_all(std::string &input, const std::string& search, const std::string& format);
 
        void removeDuplicateWhitespaces(std::string& line);
 
        void replaceWhitespaces(std::string& line, const char& rep = '\0');
 
        void replaceInvalidChars(std::string& line, const char& rep = '\0');
 
        void removeQuotes(std::string& line);
        
        void removeChars(std::string& line, const std::set<char>& specialChars);
 
        void cleanFieldName(std::string& field, const bool& clean_whitespaces = true, const char& rep = '-');
 
        size_t count(const std::string &input, const std::string& search);
        
        size_t FNV_hash(const std::string& text);
        
        bool readKeyValuePair(const std::string& in_line, const std::string& delimiter,
                              std::string &key, std::string &value, const bool& setToUpperCase=false);
 
        void toUpper(std::string& str);
        std::string strToUpper(std::string str);
        void toLower(std::string& str);
        std::string strToLower(std::string str);
        bool isNumeric(std::string input, const unsigned int& nBase=10);
        size_t readLineToVec(const std::string& line_in, std::vector<double>& vec_data);
        size_t readLineToSet(const std::string& line_in, std::set<std::string>& setString);
        size_t readLineToVec(const std::string& line_in, std::vector<std::string>& vecString);
        size_t readLineToVec(const std::string& line_in, std::vector<std::string>& vecString, const char& delim);
        size_t readLineToVec(const std::string& line_in, std::vector<double>& vecRet, const char& delim);
        
        std::vector<std::string> split(const std::string& str, char delim);
        std::vector<std::string> split(const std::string& str, std::string delim);
 
        template <class T> std::string toString(const T& t) {
                std::ostringstream os;
                os << t;
                return os.str();
        }
 
        template <class T> bool convertString(T& t, std::string str, std::ios_base& (*f)(std::ios_base&) = std::dec) {
                trim(str); //delete trailing and leading whitespaces and tabs
                if (str.empty()) {
                        t = static_cast<T>(nodata);
                        return true;
                } else {
                        std::istringstream iss(str);
                        iss.setf(std::ios::fixed);
                        iss.precision(std::numeric_limits<double>::digits10); //try to read values with maximum precision
                        iss >> f >> t; //Convert first part of stream with the formatter (e.g. std::dec, std::oct)
                        if (iss.fail()) {
                                //Conversion failed
                                return false;
                        }
                        std::string tmp;
                        getline(iss,  tmp); //get rest of line, if any
                        trim(tmp);
                        if (!tmp.empty() && tmp[0] != '#' && tmp[0] != ';') {
                                //if line holds more than one value it's invalid
                                return false;
                        }
                        return true;
                }
        }
        // fully specialized template functions (implementation must not be in header)
        template<> bool convertString<double>(double& t, std::string str, std::ios_base& (*f)(std::ios_base&));
        template<> bool convertString<std::string>(std::string& t, std::string str, std::ios_base& (*f)(std::ios_base&));
        template<> bool convertString<bool>(bool& t, std::string str, std::ios_base& (*f)(std::ios_base&));
        template<> bool convertString<char>(char& t, std::string str, std::ios_base& (*f)(std::ios_base&));
        template<> bool convertString<unsigned int>(unsigned int& t, std::string str, std::ios_base& (*f)(std::ios_base&));
        template<> bool convertString<Coords>(Coords& t, std::string str, std::ios_base& (*f)(std::ios_base&));
 
        bool convertString(Date& t, std::string str, const double& time_zone, std::ios_base& (*f)(std::ios_base&) = std::dec);
 
        template <class T> void getValueForKey(const std::map<std::string,std::string>& properties,
                                               const std::string& key, T& t, const ThrowOptions& options=IOUtils::dothrow) {
                if (key.empty() && options!=IOUtils::nothrow)
                        throw InvalidArgumentException("Empty key", AT);
 
                const std::map<std::string, std::string>::const_iterator it( properties.find(key) );
                if (it == properties.end()){
                        if (options == IOUtils::nothrow)
                                return;
                        else
                                throw UnknownValueException("No value for key " + key, AT);
                }
                const std::string& value = it->second;
 
                if (!convertString<T>(t, value, std::dec) && options!=IOUtils::nothrow) {
                        std::cerr << "[E] When reading \"" << key << "\" = \"" << t << "\"\n";
                        throw ConversionFailedException(value, AT);
                }
        }
 
        template <class T> void getValueForKey(const std::map<std::string,std::string>& properties,
                                               const std::string& key, std::vector<T>& vecT, const ThrowOptions& options=IOUtils::dothrow)
        {
                if (key.empty() && options!=IOUtils::nothrow)
                        throw InvalidArgumentException("Empty key", AT);
 
                const std::map<std::string, std::string>::const_iterator it( properties.find(key) );
                if (it == properties.end()) {
                        if (options == IOUtils::nothrow) {
                                return;
                        } else {
                                throw UnknownValueException("No value for key " + key, AT);
                        }
                }
                const std::string& value = it->second;
 
                //split value string
                std::vector<std::string> vecUnconvertedValues;
                const size_t counter = readLineToVec(value, vecUnconvertedValues);
                vecT.resize( counter );
                for (size_t ii=0; ii<counter; ii++){
                        T myvar;
                        if (!convertString<T>(myvar, vecUnconvertedValues.at(ii), std::dec) && options!=IOUtils::nothrow){
                                std::cerr << "[E] When reading \"" << key << "\" = \"" << myvar << "\"\n";
                                throw ConversionFailedException(vecUnconvertedValues.at(ii), AT);
                        }
                        vecT[ii] = myvar;
                }
        }
 
        template <class T> T standardizeNodata(const T& value, const double& plugin_nodata) {
                if (value==plugin_nodata) return static_cast<T> (nodata);
                else return value;
        }
 
        template <class T> static void parseArg(const std::pair< std::string, std::string>& arg, const std::string& algo, T& val) {
                        if (!IOUtils::convertString(val, arg.second))
                                throw InvalidArgumentException("Can not parse argument '"+arg.first+"::"+arg.second+"' for " + algo, AT);
                }
 
        void getProjectionParameters(const Config& cfg, std::string& coordin, std::string& coordinparam,
                                     std::string& coordout, std::string& coordoutparam);
        
        void getProjectionParameters(const Config& cfg, std::string& coordin, std::string& coordinparam);
 
        void getTimeZoneParameters(const Config& cfg, double& tz_in, double& tz_out);
 
        double unitsPrefix(const char& prefix);
 
        double unitsConversion(const double& val, std::string unitIn, std::string unitOut);
} //end namespace IOUtils
 
} //end namespace mio
 
#endif