IOInterface.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 IOINTERFACE_H
#define IOINTERFACE_H
 
#include <meteoio/Config.h> //so the plugins can get access to Config for their constructor
#include <meteoio/dataClasses/Array2D.h>
#include <meteoio/dataClasses/DEMObject.h>
#include <meteoio/dataClasses/Grid2DObject.h>
#include <meteoio/dataClasses/Grid3DObject.h>
#include <meteoio/dataClasses/MeteoData.h>
 
#include <vector>
#include <string>
 
namespace mio {
 
class LinesRange {
        public:
                LinesRange() : start(), end() {}
                LinesRange(const size_t& l1, const size_t& l2) : start(l1), end(l2) {}
 
                bool in(const size_t& ll) const {
                        return (ll >= start && ll <= end);
                }
 
                bool operator<(const size_t& ll) const {
                        return end < ll;
                }
 
                bool operator>(const size_t& ll) const {
                        return start > ll;
                }
 
                bool operator<(const LinesRange& ll) const { //needed for "sort"
                        if (start==ll.start) return end < ll.end;
                        return start < ll.start;
                }
 
                bool operator==(const LinesRange& ll) const { //needed to check for uniqueness
                        return (start==ll.start) && (end==ll.end);
                }
 
 
                static std::vector< LinesRange > getLinesRestrictions(const std::string& args, const std::string& where, const bool& negate);
 
                const std::string toString() const {std::ostringstream os; os << "[" << start << " - " << end << "]"; return os.str();}
 
                size_t start, end;
        private:
                static void mergeLinesRanges(std::vector< LinesRange >& lines_specs);
};
 
class IOInterface {
        public:
                virtual ~IOInterface() {}
 
                virtual bool list2DGrids(const Date& start, const Date& end, std::map<Date, std::set<size_t> >& list);
 
                virtual void read2DGrid(Grid2DObject& grid_out, const std::string& parameter="");
 
                virtual void read2DGrid(Grid2DObject& grid_out, const MeteoGrids::Parameters& parameter, const Date& date);
 
                virtual void readPointsIn2DGrid(std::vector<double>& data, const MeteoGrids::Parameters& parameter, const Date& date, const std::vector< std::pair<size_t, size_t> >& Pts);
 
                virtual void read3DGrid(Grid3DObject& grid_out, const std::string& parameter="");
 
                virtual void read3DGrid(Grid3DObject& grid_out, const MeteoGrids::Parameters& parameter, const Date& date);
 
                virtual void readDEM(DEMObject& dem_out);
 
                virtual void readLanduse(Grid2DObject& landuse_out);
 
                virtual void readGlacier(Grid2DObject& glacier_out);
 
                virtual void readStationData(const Date& date, std::vector<StationData>& vecStation);
 
                virtual void readMeteoData(const Date& dateStart, const Date& dateEnd,
                                           std::vector< std::vector<MeteoData> >& vecMeteo);
 
                virtual void writeMeteoData(const std::vector< std::vector<MeteoData> >& vecMeteo,
                                            const std::string& name="");
 
                virtual void readAssimilationData(const Date& date_in, Grid2DObject& da_out);
 
                virtual void readPOI(std::vector<Coords>& pts);
 
                virtual void write2DGrid(const Grid2DObject& grid_out, const std::string& options="");
 
                virtual void write2DGrid(const Grid2DObject& grid_out, const MeteoGrids::Parameters& parameter, const Date& date);
 
                virtual void write3DGrid(const Grid3DObject& grid_out, const std::string& options="");
 
                virtual void write3DGrid(const Grid3DObject& grid_out, const MeteoGrids::Parameters& parameter, const Date& date);
 
                static void set2DGridLatLon(Grid2DObject &grid, const double& i_ur_lat, const double& i_ur_lon);
                static double computeGridXYCellsize(const std::vector<double>& vecX, const std::vector<double>& vecY);
 
        protected:
                //this enum defines the different options to add some version information into a file name
                typedef enum VERSIONING_TYPE {
                            NO_VERSIONING, 
                                        STRING, 
                            NOW, 
                            DATA_START, 
                            DATA_END, 
                            DATA_YEARS 
                } VersioningType;
 
                static std::string buildVersionString(const VersioningType& versioning, const std::vector< std::vector<MeteoData> >& vecMeteo, const double& tz, const std::string& versioning_str);
 
                static std::string buildVersionString(const VersioningType& versioning, const std::vector<MeteoData>& vecMeteo, const double& tz, const std::string& versioning_str);
 
                static std::string datesVersionStr(const VersioningType& versioning, const Date& start_dt, const Date& end_dt);
 
};
 
} //end namespace
 
#endif