libsmet.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 LIBSMET_H
#define LIBSMET_H
 
#include <meteoio/FileUtils.h>
#include <meteoio/FStream.h>
#include <meteoio/plugins/libacdd.h>
 
#include <string>
#include <iostream>
#include <vector>
#include <set>
#include <map>
 
#define SMET_STRINGIFY(x) #x
#define SMET_TOSTRING(x) SMET_STRINGIFY(x)
#define SMET_AT __FILE__ ":" SMET_TOSTRING(__LINE__)
 
namespace smet {
 
enum SMETType {ASCII, BINARY};
enum LocationType {WGS84, EPSG};
 
class SMETException : public std::exception {
        public:
                SMETException(const std::string& message="SMETException occured", const std::string& position="");
                const char* what() const noexcept;
 
        protected:
                std::string msg;
};
 
class SMETCommon {
        public:
                static bool validFileAndPath(const std::string& filename);
                static void copy_file(const std::string& src, const std::string& dest);
                static bool fileExists(const std::string& filename);
                static std::string strToLower(std::string str);
                static double convert_to_double(const std::string& in_string);
                static int convert_to_int(const std::string& in_string);
                static char convert_to_char(const std::string& in_string);
                static void stripComments(std::string& str);
                static char getEoln(std::istream& fin);
                static void trim(std::string& str);
                static void toUpper(std::string& str);
                static bool readKeyValuePair(const std::string& in_line, const std::string& delimiter,
                                             std::map<std::string,std::string>& out_map);
                static size_t readLineToVec(const std::string& line_in, std::vector<std::string>& vecString);
                static size_t readLineToVec(const std::string& line_in, std::vector<std::string>& vecString, const char& delim);
                static bool is_decimal(const std::string& value);
 
        public:
                static std::set<std::string> all_optional_header_keys;
                static std::set<std::string> all_decimal_header_values;
                static std::set<std::string> all_mandatory_header_keys;
                static const char* smet_version;
 
        private:
                static const bool __init;     
                static bool initStaticData(); 
};
 
class SMETWriter {
        public:
                SMETWriter(const std::string& in_filename, const SMETType& in_type=ASCII);
                
                SMETWriter(const std::string& in_filename, const std::string& in_fields, const double& in_nodata);
                
                void set_header_value(const std::string& key, const std::string& value);
 
                void set_header_value(const std::string& key, const double& value);
 
                void write(const std::vector<std::string>& vec_timestamp, const std::vector<double>& data, const mio::ACDD& acdd);
 
                void write(const std::vector<double>& data, const mio::ACDD& acdd);
 
                void set_precision(const std::vector<int>& vec_precision);
 
                void set_width(const std::vector<int>& vec_width);
                
                void set_separator(const char& i_separator);
                
                void set_commented_headers(const bool& flag) {comment_headers=flag;}
 
                const std::string toString() const;
                
        private:
                void setAppendMode(std::vector<std::string> vecFields);
                void print_if_exists(const std::string& header_field, const std::string& prefix, mio::ofilestream& fout) const;
                void printACDD(mio::ofilestream& fout, const std::string& prefix, const mio::ACDD& acdd) const;
                void write_header(mio::ofilestream& fout, const mio::ACDD& acdd); //only writes when all necessary header values are set
                void write_data_line_ascii(const std::string& timestamp, const std::vector<double>& data, mio::ofilestream& fout);
                void write_data_line_binary(const std::vector<double>& data, mio::ofilestream& fout);
                bool check_fields(const std::string& key, const std::string& value);
                void check_formatting();
                bool valid_header_pair(const std::string& key, const std::string& value);
                bool valid_header();
 
                std::vector<std::string> other_header_keys; //this vector is used to preserve the sequence of header keys
                std::vector<int> ascii_precision, ascii_width;
                std::map< std::string, std::string > header;
                std::set<std::string> mandatory_header_keys;
 
                std::string filename;
                std::string nodata_string;
                SMETType smet_type;
                double nodata_value;
                size_t nr_of_fields, julian_field, timestamp_field;
                char location_wgs84, location_epsg;
                char separator;
                bool location_in_header, location_in_data_wgs84, location_in_data_epsg;
                bool timestamp_present, julian_present;
                bool file_is_binary, append_mode, append_possible, comment_headers;
};
 
class SMETReader {
        public:
                friend class SMETWriter; //so the writer can call the reader for handling append mode
                
                SMETReader(const std::string& in_fname);
 
                void read(const std::string& timestamp_start, const std::string& timestamp_end,
                          std::vector<std::string>& vec_timestamp, std::vector<double>& vec_data);
 
                void read(const double& julian_start, const double& julian_end, std::vector<double>& vec_data);
 
                void read(std::vector<std::string>& vec_timestamp, std::vector<double>& vec_data);
 
                void read(std::vector<double>& vec_data);
 
                std::string get_header_value(const std::string& key) const;
 
                double get_header_doublevalue(const std::string& key) const;
 
                int get_header_intvalue(const std::string& key) const;
 
                bool contains_timestamp() const;
 
                std::string get_field_name(const size_t& nr_of_field);
 
                bool location_in_header(const LocationType& type) const;
 
                bool location_in_data(const LocationType& type) const;
 
                size_t get_nr_of_fields() const;
 
                void get_units_conversion(std::vector<double>& offset, std::vector<double>& multiplier) const;
 
                void convert_to_MKSA(const bool& in_mksa);
 
                std::string get_filename() const;
                
        private:
                void truncate_file(const std::string& date_stop) const;
                void copy_file_header(std::ifstream& fin, mio::ofilestream& fout) const;
                void copy_file_data(const std::string& date_stop, std::ifstream& fin, mio::ofilestream& fout) const;
                std::string getLastTimestamp() const;
                void read_data_ascii(std::ifstream& fin, std::vector<std::string>& vec_timestamp, std::vector<double>& vec_data);
                void read_data_binary(std::ifstream& fin, std::vector<double>& vec_data);
                void cleanup(std::ifstream& fin) noexcept;
                void checkSignature(const std::vector<std::string>& vecSignature, bool& o_isAscii);
                void read_header(std::ifstream& fin);
                void process_header();
 
                std::streampos data_start_fpointer;
 
                std::vector<double> vec_offset;              //an offset for every column, except timestamp
                std::vector<double> vec_multiplier;          //a multiplier for every column, except timestamp
                std::vector<std::string> vec_fieldnames;     //holds the column names, except for timestamp column
                std::map< std::string, std::string > header; //holds the header
                mio::FileUtils::FileIndexer indexer; //in order to save file pointers
 
                std::string filename;
                std::string timestamp_start, timestamp_end; //the beginning and end date of the current timestamp_interval
                double nodata_value; //The nodata value as seen in the header section of the SMET file
                double julian_start, julian_end; //the beginning and end date of the current julian_interval
                static const size_t streampos_every_n_lines; //save current stream pos every n lines of data
                size_t nr_of_fields; //is always the number of fields minus the timestamp field, if present
                size_t timestamp_field, julian_field; //index of the timestamp and julian column, if present
                char location_wgs84, location_epsg, location_data_wgs84, location_data_epsg;
                char eoln; //end of line character for this file
                char separator; //column separator
                bool timestamp_present, julian_present;
                bool isAscii; //true if the file is in SMET ASCII format, false if it is in binary format
                bool mksa; //true if MKSA converted values have to be returned
                bool timestamp_interval, julian_interval; //true if data shall only be read for a time interval
};
 
}
 
#endif