Date.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 DATE_H
#define DATE_H
 
#include <meteoio/IOExceptions.h>
 
#include <string>
#include <map>
 
//uncomment below to support negative julian dates
//#define NEGATIVE_JULIAN
 
namespace mio {
 
class Date {
        public:
                typedef enum {
                        ISO, 
                        ISO_TZ, 
                        ISO_Z, 
                        FULL, 
                        NUM, 
                        DIN, 
                        ISO_WEEK, 
                        ISO_DATE 
                } FORMATS;
 
                typedef enum RND_TYPE {
                        UP, 
                        DOWN, 
                        CLOSEST 
                } RND;
 
                static const double DST_shift;
                static const double MJD_offset;
                static const double RFC868_offset;
                static const double Unix_offset;
                static const double Excel_offset;
                static const double Matlab_offset;
                static const double epsilon_sec;
 
                Date();
                Date(const double& in_timezone);
                Date(const double& julian_in, const double& in_timezone);
                Date(const int& year, const int& month, const int& day, const int& hour, const int& minute, const double& in_timezone);
                Date(const int& year, const int& month, const int& day, const int& hour, const int& minute, const int& second, const double& in_timezone);
                Date(const int& year, const int& month, const int& day, const int& hour, const int& minute, const double& second, const double& in_timezone);
                Date(const time_t&);
                Date(const int& year, const double& jdn, const double& in_timezone);
 
                void setFromSys();
                void setTimeZone(const double& in_timezone);
                void setDate(const Date& in_date);
                void setDate(const double& julian_in, const double& in_timezone);
                void setDate(const int& year, const int& month, const int& day, const int& hour, const int& minute, const double& in_timezone);
                void setDate(const int& year, const int& month, const int& day, const int& hour, const int& minute, const int& second, const double& in_timezone);
                void setDate(const int& year, const int& month, const int& day, const int& hour, const int& minute, const double& second, const double& in_timezone);
                void setDate(const int& year, const unsigned int& month, const unsigned int& day, const unsigned int& hour, const unsigned int& minute, const double& in_timezone);
                void setDate(const int& year, const unsigned int& month, const unsigned int& day, const unsigned int& hour, const unsigned int& minute, const unsigned int& second, const double& in_timezone);
                void setDate(const int& year, const unsigned int& month, const unsigned int& day, const unsigned int& hour, const unsigned int& minute, const double& second, const double& in_timezone);
                void setDate(const int& year, const double& jdn, const double& in_timezone);
                void setDate(const time_t& in_time);
                void setModifiedJulianDate(const double& julian_in, const double& in_timezone);
                void setRFC868Date(const double& julian_in, const double& in_timezone);
                void setUnixDate(const time_t& in_time);
                void setExcelDate(const double excel_in, const double& in_timezone);
                void setMatlabDate(const double matlab_in, const double& in_timezone);
                void setUndef(const bool& flag=true);
 
                bool isUndef() const {return undef;}
                double getTimeZone() const;
                double getJulian(const bool& gmt=false) const;
                double getModifiedJulianDate(const bool& gmt=false) const;
                double getTruncatedJulianDate(const bool& gmt=false) const;
                double getRFC868Date(const bool& gmt=false) const;
                time_t getUnixDate() const;
                double getExcelDate(const bool& gmt=false) const;
                double getMatlabDate(const bool& gmt=false) const;
 
                void getDate(double& julian_out, const bool& gmt=false) const;
                void getDate(int& year, int& month, int& day, const bool& gmt=false) const;
                void getDate(int& year, int& month, int& day, int& hour, const bool& gmt=false) const;
                void getDate(int& year, int& month, int& day, int& hour, int& minute, const bool& gmt=false) const;
                void getDate(int& year, int& month, int& day, int& hour, int& minute, double& second, const bool& gmt=false) const;
                void getDate(int& year, int& month, int& day, int& hour, int& minute, int& second, const bool& gmt=false) const;
                void getTime(int& hour_out, int& minute_out, const bool& gmt=false) const;
                void getTime(int& hour_out, int& minute_out, double& second_out, const bool& gmt=false) const;
                int getYear(const bool& gmt=false) const;
 
                unsigned short getDayOfWeek(const bool& gmt=false) const;
                unsigned short getISOWeekNr(const bool& gmt=false) const;
                unsigned short getISOWeekNr(int &ISO_year, const bool& gmt=false) const;
                static int getNumberOfDaysInMonth(const int &ISO_year, const int &month);
                int getJulianDayNumber(const bool& gmt=false) const;
                bool isLeapYear() const;
 
                static unsigned int mod(const double& julian, const unsigned int& seconds);
                static unsigned int mod(const Date& indate, const unsigned int& seconds);
                static double rnd(const double& julian, const double& precision, const RND& type=CLOSEST);
                void rnd(const double& precision, const RND& type=CLOSEST);
                static const Date rnd(const Date& indate, const double& precision, const RND& type=CLOSEST);
                static double parseTimeZone(const std::string& timezone_iso);
 
                static std::string printFractionalDay(const double& fractional);
                static std::string printISODuration(const Date& dt1, const Date& dt2);
                const std::string toString(const FORMATS& type, const bool& gmt=false) const;
                const std::string toString() const;
                friend std::ostream& operator<<(std::ostream& os, const Date& date);
                friend std::istream& operator>>(std::istream& is, Date& date);
 
                //Operator Prototypes
                bool operator==(const Date&) const;
                bool operator!=(const Date&) const;
                bool operator<(const Date&) const;
                bool operator<=(const Date&) const;
                bool operator>(const Date&) const;
                bool operator>=(const Date&) const;
 
                Date& operator+=(const Date&);
                Date& operator-=(const Date&);
                Date& operator+=(const double&);
                Date& operator-=(const double&);
                Date& operator*=(const double&);
                Date& operator/=(const double&);
 
                const Date operator+(const Date&) const;
                const Date operator-(const Date&) const;
                const Date operator+(const double&) const;
                const Date operator-(const double&) const;
                const Date operator*(const double&) const;
                const Date operator/(const double&) const;
                
                static const double epsilon;
 
        protected:
                double localToGMT(const double& in_julian) const;
                double GMTToLocal(const double& in_gmt_julian) const;
                static double calculateJulianDate(const int& in_year, const int& in_month, const int& in_day, const int& in_hour, const int& in_minute, const double& i_second);
                static void calculateDate(const double& i_julian, int& out_year, int& out_month, int& out_day);
                static void calculateTime(const double& i_julian, int& o_hour, int& o_minute, double& o_second);
                static void calculateValues(const double& i_julian, int& out_year, int& out_month, int& out_day, int& out_hour, int& out_minute, double& o_second);
                static long getJulianDayNumber(const int&, const int&, const int&);
                static bool isLeapYear(const int&);
                static void plausibilityCheck(const int& in_year, const int& in_month, const int& in_day, const int& in_hour, const int& in_minute, const double& in_second);
                static bool initStaticData();
 
                static std::map< std::string, double> TZAbbrev;
                static const int daysLeapYear[];
                static const int daysNonLeapYear[];
                static const bool __init;
                double timezone;
                double gmt_julian;
                bool undef;
};
 
class DateRange {
        public:
                DateRange() : start(), end(), isValid(false) {}
                DateRange(const Date& d1, const Date& d2) : start(d1), end(d2), isValid(false) {if (!start.isUndef() && !end.isUndef() && start<=end) isValid=true;}
                //at most daily resolution
                DateRange(const std::string& range_spec, const double& tz) : start(), end(), isValid(false) {setRange(range_spec, tz);}
                
                void setRange(const std::string& range_spec, const double& tz);
                void resetRange(const Date& i_start, const Date& i_end);
                
                bool isUndef() const {return (!isValid);}
                
                bool in(const Date& a) const {
                        if (!isValid) throw InvalidArgumentException("Date range '"+toString()+"' has not been properly initialized!", AT);
                        return (a >= start && a <= end);
                }
                
                bool hasOverlap(const Date& i_start, const Date& i_end) const;
                
                bool hasOverlap(const DateRange& i_range) const;
                
                bool operator<(const Date& a) const {
                        if (!isValid) throw InvalidArgumentException("Date range '"+toString()+"' has not been properly initialized!", AT);
                        return end < a;
                }
                
                bool operator>(const Date& a) const {
                        if (!isValid) throw InvalidArgumentException("Date range '"+toString()+"' has not been properly initialized!", AT);
                        return start > a;
                }
                
                bool operator<(const DateRange& a) const { //needed for "sort"
                        if (!isValid) throw InvalidArgumentException("Date range '"+toString()+"' has not been properly initialized!", AT);
                        if (!a.isValid) throw InvalidArgumentException("Date range '"+a.toString()+"' has not been properly initialized!", AT);
                        if (start==a.start) return end < a.end;
                        return start < a.start;
                }
                
                bool operator==(const DateRange& a) const { //needed to check for uniqueness
                        if (!isValid) throw InvalidArgumentException("Date range '"+toString()+"' has not been properly initialized!", AT);
                        if (!a.isValid) throw InvalidArgumentException("Date range '"+a.toString()+"' has not been properly initialized!", AT);
                        return (start==a.start) && (end==a.end);
                }
                
                bool operator!=(const DateRange& a) const { return !(*this==a); }
                
                const std::string toString() const;
                
                Date start, end;
                
        private:
                static Date parseDateHint(const std::string& Date_str, const double tz, const bool& early_interpretation);
                
                bool isValid;
};
 
typedef Date Duration; //so that later, we can implement a true Interval/Duration class
 
} //end namespace
 
#endif