1257 lines
27 KiB
C++
1257 lines
27 KiB
C++
/*
|
|
* This file is a part of PikoTools
|
|
* and is distributed under the 2-Clause BSD licence.
|
|
* Author: Tomasz Sowa <t.sowa@ttmath.org>
|
|
*/
|
|
|
|
/*
|
|
* Copyright (c) 2012-2022, Tomasz Sowa
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright notice,
|
|
* this list of conditions and the following disclaimer.
|
|
*
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
|
|
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
*/
|
|
|
|
#ifndef headerfile_pikotools_src_date_date
|
|
#define headerfile_pikotools_src_date_date
|
|
|
|
#include <ctime>
|
|
#include <string>
|
|
#include "convert/inttostr.h"
|
|
|
|
|
|
|
|
namespace pt
|
|
{
|
|
|
|
|
|
/*
|
|
this class represents a Date (year, month, day, hour, min, sec)
|
|
it has O(1) algorithm when converting from/to time_t (seconds from the Unix Epoch)
|
|
|
|
algorithm description:
|
|
http://alcor.concordia.ca/~gpkatch/gdate-algorithm.html
|
|
http://alcor.concordia.ca/~gpkatch/gdate-method.html
|
|
|
|
current limitation:
|
|
we do not support leap seconds
|
|
*/
|
|
class Date
|
|
{
|
|
public:
|
|
|
|
|
|
/*
|
|
the date
|
|
*/
|
|
int year; // 1970 - 10000
|
|
int month; // 1 - 12
|
|
int day; // 1 - 31
|
|
int hour; // 0 - 23
|
|
int min; // 0 - 59
|
|
int sec; // 0 - 59
|
|
|
|
|
|
|
|
/*
|
|
default c-ctor sets the Unix Epoch (Clear method): 1970.01.01 00:00:00
|
|
*/
|
|
Date();
|
|
|
|
|
|
/*
|
|
converting from Date, time_t (seconds from the Unix Epoch), tm structure, and strings
|
|
*/
|
|
Date(const Date & d);
|
|
Date(time_t t);
|
|
Date(const tm & t);
|
|
Date(const char * str);
|
|
Date(const wchar_t * str);
|
|
Date(const std::string & str);
|
|
Date(const std::wstring & str);
|
|
|
|
Date & operator=(const Date & d);
|
|
Date & operator=(time_t t);
|
|
Date & operator=(const tm & t);
|
|
Date & operator=(const char * str);
|
|
Date & operator=(const wchar_t * str);
|
|
Date & operator=(const std::string & str);
|
|
Date & operator=(const std::wstring & str);
|
|
|
|
|
|
|
|
/*
|
|
adding/subtracting time_t (seconds from the Unix Epoch)
|
|
*/
|
|
Date operator+(time_t t) const;
|
|
Date operator-(time_t t) const;
|
|
Date & operator+=(time_t t);
|
|
Date & operator-=(time_t t);
|
|
|
|
|
|
/*
|
|
swapping the contents of *this with date
|
|
*/
|
|
void Swap(Date & date);
|
|
|
|
|
|
/*
|
|
converts time_t in seconds (from the Unix Epoch) to this object
|
|
*/
|
|
void FromTime(time_t t);
|
|
|
|
|
|
/*
|
|
converts tm structure to this object
|
|
*/
|
|
void FromTm(const tm & t);
|
|
|
|
|
|
/*
|
|
returns time_t (in seconds from the Unix Epoch)
|
|
*/
|
|
time_t ToTime() const;
|
|
|
|
|
|
/*
|
|
return tm structure
|
|
only tm_year, tm_mon, tm_mday, tm_hour, tm_min, tm_sec fields are set
|
|
the rest is equal to zero
|
|
*/
|
|
tm ToTm() const;
|
|
|
|
|
|
/*
|
|
getting/setting the number of days from 0000:03:01 (year 0, month 3 - March, day 1)
|
|
(ToDays() and FromDays() can work even with a year less than 1970)
|
|
*/
|
|
long long ToDays() const;
|
|
void FromDays(long long g);
|
|
|
|
|
|
/*
|
|
returns a difference in second between two dates
|
|
(always a value greater than zero)
|
|
*/
|
|
time_t operator-(const Date & d) const;
|
|
|
|
|
|
/*
|
|
'Compare' returns zero if this and d are equal
|
|
return value less than zero if this is lower than d
|
|
and a value greater than zero if this is greater than d
|
|
*/
|
|
int Compare(const Date & d) const;
|
|
|
|
|
|
/*
|
|
returns true if year, month and day are the same
|
|
*/
|
|
bool IsTheSameDay(const Date & d) const;
|
|
|
|
|
|
/*
|
|
returns true if hour, min and sec are the same
|
|
*/
|
|
bool IsTheSameHour(const Date & d) const;
|
|
|
|
|
|
/*
|
|
operators for comparing
|
|
*/
|
|
bool operator==(const Date & d) const;
|
|
bool operator!=(const Date & d) const;
|
|
bool operator>(const Date & d) const;
|
|
bool operator>=(const Date & d) const;
|
|
bool operator<(const Date & d) const;
|
|
bool operator<=(const Date & d) const;
|
|
|
|
|
|
/*
|
|
set the date to: 1970-01-01
|
|
the time is not changed
|
|
*/
|
|
void ClearDate();
|
|
|
|
|
|
/*
|
|
set the time to 00:00:00
|
|
the date is not changed
|
|
*/
|
|
void ClearTime();
|
|
|
|
|
|
/*
|
|
set the Unix Epoch: 1970-01-01 00:00:00
|
|
*/
|
|
void Clear();
|
|
|
|
|
|
/*
|
|
assert a correct date (values will be from the correct range)
|
|
year: 1970 - 10000
|
|
month: 1 - 12
|
|
day: 1 - MonthLen
|
|
hour: 0 - 23
|
|
min: 0 - 59
|
|
sec: 0 - 59
|
|
*/
|
|
void AssertCorrectDate();
|
|
|
|
|
|
/*
|
|
return true if values are from the correct range
|
|
year: 1970 - 10000
|
|
month: 1 - 12
|
|
day: 1 - MonthLen
|
|
hour: 0 - 23
|
|
min: 0 - 59
|
|
sec: 0 - 59
|
|
*/
|
|
bool IsCorrectDate();
|
|
|
|
|
|
/*
|
|
returns how many days there is in a month
|
|
y - year 1970 - ...
|
|
m - month 1-12
|
|
*/
|
|
static int MonthLen(int y, int m);
|
|
|
|
|
|
/*
|
|
returns true if 'y' is a leap year
|
|
leap year has one additional day (in february) - so the year lasts 366 days
|
|
*/
|
|
static bool IsYearLeap(int y);
|
|
|
|
|
|
/*
|
|
returns true if the currecn year is a leap year
|
|
*/
|
|
bool IsYearLeap() const;
|
|
|
|
|
|
/*
|
|
returns a day index from a week
|
|
sunday - 0
|
|
monday - 1
|
|
...
|
|
saturday - 6
|
|
*/
|
|
int WeekDay() const;
|
|
|
|
|
|
/*
|
|
this method outputs to the given stream the number of a month in Roman numerals
|
|
e.g: if month is equal to 3 then III will be put to 'out'
|
|
month should be in the range [1,12]
|
|
*/
|
|
template<class Stream>
|
|
static void SerializeMonthAsRoman(Stream & out, int month);
|
|
|
|
|
|
/*
|
|
this method outputs to the given stream: YYYY-MM-DD, eg. 1990-02-12
|
|
ISO 8601 format
|
|
*/
|
|
template<class Stream>
|
|
void SerializeYearMonthDay(Stream & out, bool roman_month = false) const;
|
|
|
|
|
|
/*
|
|
this method outputs to the given stream: HH:MM:SS, eg: 13:05:39
|
|
ISO 8601 format
|
|
*/
|
|
template<class Stream>
|
|
void SerializeHourMinSec(Stream & out) const;
|
|
|
|
|
|
/*
|
|
this method outputs to the given stream: MM-DD, eg. 02-12 (02 month, 12 day)
|
|
*/
|
|
template<class Stream>
|
|
void SerializeMonthDay(Stream & out, bool roman_month = false) const;
|
|
|
|
|
|
/*
|
|
this method outputs to the given stream: HH:MM, eg: 13:05
|
|
*/
|
|
template<class Stream>
|
|
void SerializeHourMin(Stream & out) const;
|
|
|
|
|
|
/*
|
|
this method outputs to the given stream: YYYY-MM-DD HH:MM:SS, eg: 1990-02-12 13:05:39
|
|
ISO 8601 format
|
|
*/
|
|
template<class Stream>
|
|
void Serialize(Stream & out, bool roman_month = false, bool with_seconds = true) const;
|
|
|
|
|
|
/*
|
|
this method outputs to the given stream: YYYY-MM-DDTHH:MM:SSZ, eg: 1990-02-12T13:05:39Z
|
|
ISO 8601 format
|
|
*/
|
|
template<class Stream>
|
|
void SerializeISO(Stream & out) const;
|
|
|
|
|
|
/*
|
|
parsing day month and year
|
|
the input string can be as follows:
|
|
"12-10-2008"
|
|
|
|
white characters are ommited and the method stops after reading the year
|
|
so the input string can be:
|
|
" 12 - 10 - 2008some text "
|
|
a white character means a space or a tab
|
|
|
|
as a separator can be '-' '/' or '.'
|
|
so below strings have the same meaning:
|
|
" 12.10.2008 "
|
|
" 12/10 / 2008 "
|
|
|
|
this method doesn't test if the values are correct
|
|
use IsCorrectDate() to check
|
|
*/
|
|
template<class CStringType>
|
|
bool ParseDayMonthYear(const CStringType * str, const CStringType ** str_after = nullptr);
|
|
|
|
template<class StringType>
|
|
bool ParseDayMonthYear(const StringType & str);
|
|
|
|
|
|
/*
|
|
parsing year month and day
|
|
the input string can be as follows:
|
|
"2008-10-12"
|
|
|
|
white characters are ommited and the method stops after reading the day
|
|
so the input string can be:
|
|
" 2008 - 10 - 12some text "
|
|
a white character means a space or a tab
|
|
|
|
as a separator can be '-' '/' or '.'
|
|
so below strings have the same meaning:
|
|
" 2008.10.12 "
|
|
" 2008/10 / 12 "
|
|
|
|
this method doesn't test if the values are correct
|
|
use IsCorrectDate() to check
|
|
*/
|
|
template<class CStringType>
|
|
bool ParseYearMonthDay(const CStringType * str, const CStringType ** str_after = nullptr);
|
|
|
|
template<class StringType>
|
|
bool ParseYearMonthDay(const StringType & str);
|
|
|
|
|
|
/*
|
|
parsing month and day
|
|
the input string can be as follows:
|
|
"10-12" (month: 10, day: 12)
|
|
|
|
white characters are ommited and the method stops after reading the day
|
|
so the input string can be:
|
|
" 10 - 12some text "
|
|
a white character means a space or a tab
|
|
|
|
as a separator can be '-' '/' or '.'
|
|
so below strings have the same meaning:
|
|
" 10.12 "
|
|
" 10 / 12 "
|
|
|
|
this method doesn't test if the values are correct
|
|
use IsCorrectDate() to check
|
|
*/
|
|
template<class CStringType>
|
|
bool ParseMonthDay(const CStringType * str, const CStringType ** str_after = nullptr);
|
|
|
|
template<class StringType>
|
|
bool ParseMonthDay(const StringType & str);
|
|
|
|
|
|
/*
|
|
parsing hour minutes and seconds
|
|
the input string can be as follows:
|
|
"14:10:35"
|
|
|
|
white characters are ommited and the method stops after reading seconds
|
|
so the input string can be:
|
|
" 14 : 10 : 35some text "
|
|
a white character means a space or a tab
|
|
|
|
a separator is only the ':' character
|
|
|
|
this method doesn't test if the values are correct
|
|
use IsCorrectDate() to check
|
|
*/
|
|
template<class CStringType>
|
|
bool ParseHourMinSec(const CStringType * str, const CStringType ** str_after = nullptr);
|
|
|
|
template<class StringType>
|
|
bool ParseHourMinSec(const StringType & str);
|
|
|
|
|
|
/*
|
|
parsing hour and minutes
|
|
the input string can be as follows:
|
|
"14:10"
|
|
|
|
white characters are ommited and the method stops after reading minutes
|
|
so the input string can be:
|
|
" 14 : 10some text "
|
|
a white character means a space or a tab
|
|
|
|
a separator is only the ':' character
|
|
|
|
this method doesn't test if the values are correct
|
|
use IsCorrectDate() to check
|
|
*/
|
|
template<class CStringType>
|
|
bool ParseHourMin(const CStringType * str, const CStringType ** str_after = nullptr);
|
|
|
|
template<class StringType>
|
|
bool ParseHourMin(const StringType & str);
|
|
|
|
template<class CStringType>
|
|
bool ParseZoneOffset(const CStringType * str, const CStringType ** str_after = nullptr);
|
|
|
|
template<class StringType>
|
|
bool ParseZoneOffset(const StringType & str);
|
|
|
|
/*
|
|
parsing a year and a month (if exists) and a day (if exists)
|
|
|
|
the input string can be as follows: YYYY[sep]MM[sep]DD
|
|
the separator is optional, it can be: '.', '-', '/' or just white characters
|
|
(white characters before and after a separator are skipped)
|
|
|
|
sample valid dates:
|
|
"2022"
|
|
" 2022"
|
|
"202212"
|
|
" 2022 12"
|
|
"2022-12"
|
|
" 2022 - 12"
|
|
"20221222"
|
|
" 20221222 "
|
|
" 2022 12 22 "
|
|
" 2022 12 22 "
|
|
"2022-12-22"
|
|
" 2022-12-22"
|
|
" 2022 - 12 - 22 "
|
|
|
|
if the month is not provided then it is set to 01,
|
|
if the day is not provided then it is set to 01 too
|
|
|
|
this method doesn't test if the values are correct
|
|
use IsCorrectDate() to check
|
|
*/
|
|
template<class CStringType>
|
|
bool ParseDate(const CStringType * str, const CStringType ** str_after = nullptr);
|
|
|
|
template<class StringType>
|
|
bool ParseDate(const StringType & str);
|
|
|
|
|
|
/*
|
|
parsing an hour and minutes (if exists) and seconds (if exists)
|
|
the input string can be as follows: HH[sep]MM[sep]SS
|
|
|
|
separator is optional, it can be ':' or just white characters
|
|
(white characters before and after a separator are skipped)
|
|
|
|
"14" -- only an hour given (min and sec will be zero)
|
|
"14:10" -- hour with minutes (sec will be zero)
|
|
"1410" -- the same as above
|
|
"14:10:35" -- hour, minutes and seconds
|
|
"141035" -- the same as above
|
|
"14 10 35" -- the same as above
|
|
|
|
white characters are ommited so these are valid strings too:
|
|
" 14 : 10 : 35 "
|
|
" 14 : 10 : 35some text "
|
|
a white character means a space or a tab
|
|
|
|
a decimal fraction may be added to the lowest order time element present, e.g:
|
|
"14.500" = 14:30:00
|
|
"14:10.500" = 14:10:30
|
|
"14:10:35.500" = 14:10:35 (the seconds' fraction is skipped)
|
|
instead of dot you can use a comma too,
|
|
the fraction part can be from 1 to 9 digits
|
|
|
|
this method doesn't test if the values are correct
|
|
use IsCorrectDate() to check
|
|
*/
|
|
template<class CStringType>
|
|
bool ParseTime(const CStringType * str, const CStringType ** str_after = nullptr);
|
|
|
|
template<class StringType>
|
|
bool ParseTime(const StringType & str);
|
|
|
|
|
|
/*
|
|
parsing month, day, hour and minutes (if exists) and seconds (if exists)
|
|
the input string can be as follows:
|
|
"10-23 14" -- only month, day and hour given (min and sec will be zero)
|
|
"10-23 14:10" -- month, day and hour with minutes (sec will be zero)
|
|
"10-23 14:10:35" -- month, day, hour, minutes and seconds
|
|
|
|
white characters are ommited so these are valid strings too:
|
|
" 10 - 23 14 : 10 : 35 "
|
|
" 10 - 23 14 : 10 : 35some text "
|
|
a white character means a space or a tab
|
|
|
|
this method doesn't test if the values are correct
|
|
use IsCorrectDate() to check
|
|
|
|
the time is parsed with ParseTime() method, look there for an additional description about available time strings
|
|
*/
|
|
template<class CStringType>
|
|
bool ParseMonthDayTime(const CStringType * str, const CStringType ** str_after = nullptr);
|
|
|
|
template<class StringType>
|
|
bool ParseMonthDayTime(const StringType & str);
|
|
|
|
|
|
/*
|
|
parsing year/month/day hour:min:sec
|
|
the input strings can be as follows:
|
|
"20081012 141035"
|
|
"20081012T141035"
|
|
"20081012141035"
|
|
"2008-10-12 14:10:35"
|
|
"2008/10/12 14:10:35"
|
|
"2008.10.12 14:10:35"
|
|
"2008-10/12 14:10:35"
|
|
"2008-10-12 14:10:35.500"
|
|
"2008-10-12 14:10.500"
|
|
"2008-10-12 14.500"
|
|
"2008-10-12 14"
|
|
"2008-10 14"
|
|
"2008 14"
|
|
|
|
months and days can be omitted - in such a case 01 is set,
|
|
similar min and sec can be omitted (they are assumed to be 00 in such a case)
|
|
|
|
white characters are ommited
|
|
so the input string can be:
|
|
" 2008 - 10 / 12 14 : 10 : 35 "
|
|
a white character means a space or a tab
|
|
|
|
as an optional separator for the date can be '-' '/' or '.'
|
|
as an optional separator for the time is the ':' character
|
|
|
|
at the and of the string there can be defined a time zone in the form of "+01:00", e.g:
|
|
"2008-10-12 14:10:35+01:00"
|
|
"2008-10-12 14:10:35-02:00"
|
|
or without a separator:
|
|
"2008-10-12 14:10:35+0100"
|
|
"2008-10-12 14:10:35-0200"
|
|
or just a 'Z' character indicating 00:00 zone
|
|
"2008-10-12 14:10:35Z"
|
|
|
|
at the end the method checks if the values are correct
|
|
(by using IsCorrectDate())
|
|
|
|
the format is similar to ISO 8601
|
|
https://en.wikipedia.org/wiki/ISO_8601
|
|
at the moment there is no support for week dates e.g. "2008-W01-3" and ordinal dates e.g. "2008-010" formats
|
|
|
|
see ParseDate() and ParseTime for more examples
|
|
*/
|
|
template<class CStringType>
|
|
bool Parse(const CStringType * str, const CStringType ** str_after, bool check_time_zone = true);
|
|
|
|
template<class CStringType>
|
|
bool Parse(const CStringType * str, bool check_time_zone = true);
|
|
|
|
template<class StringType>
|
|
bool Parse(const StringType & str, bool check_time_zone = true);
|
|
|
|
|
|
private:
|
|
|
|
void AssertRange(int & val, int val_min, int val_max);
|
|
|
|
template<class Stream>
|
|
void SerializeInt(Stream & out, int val, size_t min_width) const;
|
|
|
|
template<class Stream>
|
|
void SerializeInt(Stream & out, int val) const;
|
|
|
|
template<class CStringType>
|
|
void SetAfter(const CStringType * str, const CStringType ** str_after);
|
|
|
|
template<class CStringType>
|
|
void SkipWhite(const CStringType * & str);
|
|
|
|
template<class CStringType>
|
|
bool IsDigit(const CStringType * str);
|
|
|
|
template<class CStringType>
|
|
bool ReadInt(const CStringType * & str, int & result, size_t max_digits = 0, size_t * digits_read = nullptr, int * digits_base = nullptr);
|
|
|
|
template<class CStringType>
|
|
bool ReadCommaInt(const CStringType * & str, bool & was_comma, int & result, size_t max_digits = 0, size_t * digits_read = nullptr, int * base = nullptr);
|
|
|
|
template<class CStringType>
|
|
bool ParseTimeValue(const CStringType * & str, int & value, bool & has_fraction, int & fraction, int * fraction_base);
|
|
|
|
template<class CStringType>
|
|
bool SkipSeparator(const CStringType * & str, int separator, int separator2 = -1, int separator3 = -1);
|
|
|
|
};
|
|
|
|
|
|
|
|
template<class Stream>
|
|
void Date::SerializeInt(Stream & out, int val, size_t min_width) const
|
|
{
|
|
char buf[64];
|
|
size_t len;
|
|
|
|
if( Toa(val, buf, sizeof(buf) / sizeof(char), 10, &len) )
|
|
{
|
|
for(size_t i = len ; i < min_width ; ++i)
|
|
{
|
|
out << '0';
|
|
}
|
|
|
|
out << buf;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
template<class Stream>
|
|
void Date::SerializeInt(Stream & out, int val) const
|
|
{
|
|
SerializeInt(out, val, 2);
|
|
}
|
|
|
|
|
|
template<class Stream>
|
|
void Date::SerializeMonthAsRoman(Stream & out, int month)
|
|
{
|
|
const char * month_roman[] = { "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX", "X", "XI", "XII" };
|
|
|
|
if( month >= 1 && month <= 12 )
|
|
{
|
|
const char * month_str = month_roman[month - 1];
|
|
|
|
for( ; *month_str ; ++month_str)
|
|
out << *month_str;
|
|
}
|
|
}
|
|
|
|
|
|
template<class Stream>
|
|
void Date::SerializeYearMonthDay(Stream & out, bool roman_month) const
|
|
{
|
|
SerializeInt(out, year, 4);
|
|
out << '-';
|
|
|
|
if( roman_month )
|
|
SerializeMonthAsRoman(out, month);
|
|
else
|
|
SerializeInt(out, month);
|
|
|
|
out << '-';
|
|
SerializeInt(out, day);
|
|
}
|
|
|
|
|
|
template<class Stream>
|
|
void Date::SerializeHourMinSec(Stream & out) const
|
|
{
|
|
SerializeInt(out, hour);
|
|
out << ':';
|
|
SerializeInt(out, min);
|
|
out << ':';
|
|
SerializeInt(out, sec);
|
|
}
|
|
|
|
|
|
template<class Stream>
|
|
void Date::SerializeMonthDay(Stream & out, bool roman_month) const
|
|
{
|
|
if( roman_month )
|
|
SerializeMonthAsRoman(out, month);
|
|
else
|
|
SerializeInt(out, month);
|
|
|
|
out << '-';
|
|
SerializeInt(out, day);
|
|
}
|
|
|
|
|
|
template<class Stream>
|
|
void Date::SerializeHourMin(Stream & out) const
|
|
{
|
|
SerializeInt(out, hour);
|
|
out << ':';
|
|
SerializeInt(out, min);
|
|
}
|
|
|
|
|
|
template<class Stream>
|
|
void Date::Serialize(Stream & out, bool roman_month, bool with_seconds) const
|
|
{
|
|
SerializeYearMonthDay(out, roman_month);
|
|
out << ' ';
|
|
|
|
if( with_seconds )
|
|
SerializeHourMinSec(out);
|
|
else
|
|
SerializeHourMin(out);
|
|
}
|
|
|
|
|
|
template<class Stream>
|
|
void Date::SerializeISO(Stream & out) const
|
|
{
|
|
SerializeYearMonthDay(out, false);
|
|
out << 'T';
|
|
SerializeHourMinSec(out);
|
|
out << 'Z';
|
|
}
|
|
|
|
|
|
template<class CStringType>
|
|
bool Date::ParseDayMonthYear(const CStringType * str, const CStringType ** str_after)
|
|
{
|
|
bool result = false;
|
|
|
|
if( ReadInt(str, day) && SkipSeparator(str, '.', '-', '/') )
|
|
if( ReadInt(str, month) && SkipSeparator(str, '.', '-', '/') )
|
|
if( ReadInt(str, year) )
|
|
result = true;
|
|
|
|
SetAfter(str, str_after);
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
template<class StringType>
|
|
bool Date::ParseDayMonthYear(const StringType & str)
|
|
{
|
|
return ParseDayMonthYear(str.c_str());
|
|
}
|
|
|
|
|
|
|
|
|
|
template<class CStringType>
|
|
bool Date::ParseYearMonthDay(const CStringType * str, const CStringType ** str_after)
|
|
{
|
|
bool result = false;
|
|
|
|
if( ReadInt(str, year) && SkipSeparator(str, '.', '-', '/') )
|
|
if( ReadInt(str, month) && SkipSeparator(str, '.', '-', '/') )
|
|
if( ReadInt(str, day) )
|
|
result = true;
|
|
|
|
SetAfter(str, str_after);
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
template<class StringType>
|
|
bool Date::ParseYearMonthDay(const StringType & str)
|
|
{
|
|
return ParseYearMonthDay(str.c_str());
|
|
}
|
|
|
|
|
|
|
|
|
|
template<class CStringType>
|
|
bool Date::ParseMonthDay(const CStringType * str, const CStringType ** str_after)
|
|
{
|
|
bool result = false;
|
|
|
|
if( ReadInt(str, month) && SkipSeparator(str, '.', '-', '/') )
|
|
if( ReadInt(str, day) )
|
|
result = true;
|
|
|
|
SetAfter(str, str_after);
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
template<class StringType>
|
|
bool Date::ParseMonthDay(const StringType & str)
|
|
{
|
|
return ParseMonthDay(str.c_str());
|
|
}
|
|
|
|
|
|
template<class CStringType>
|
|
bool Date::ParseHourMinSec(const CStringType * str, const CStringType ** str_after)
|
|
{
|
|
bool result = false;
|
|
|
|
if( ReadInt(str, hour) && SkipSeparator(str, ':') )
|
|
if( ReadInt(str, min) && SkipSeparator(str, ':') )
|
|
if( ReadInt(str, sec) )
|
|
result = true;
|
|
|
|
SetAfter(str, str_after);
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
template<class StringType>
|
|
bool Date::ParseHourMinSec(const StringType & str)
|
|
{
|
|
return ParseHourMinSec(str.c_str());
|
|
}
|
|
|
|
|
|
|
|
template<class CStringType>
|
|
bool Date::ParseHourMin(const CStringType * str, const CStringType ** str_after)
|
|
{
|
|
bool result = false;
|
|
|
|
if( ReadInt(str, hour) && SkipSeparator(str, ':') )
|
|
if( ReadInt(str, min) )
|
|
result = true;
|
|
|
|
SetAfter(str, str_after);
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
template<class StringType>
|
|
bool Date::ParseHourMin(const StringType & str)
|
|
{
|
|
return ParseHourMin(str.c_str());
|
|
}
|
|
|
|
|
|
template<class CStringType>
|
|
bool Date::ParseZoneOffset(const CStringType * str, const CStringType ** str_after)
|
|
{
|
|
bool result = false;
|
|
bool is_sign = false;
|
|
int offset_hour = 0;
|
|
int offset_min = 0;
|
|
|
|
SkipWhite(str);
|
|
|
|
if( *str == '-' || *str == '+' )
|
|
{
|
|
if( *str == '-' )
|
|
is_sign = true;
|
|
|
|
str += 1;
|
|
result = true; // if there are no digits we return true
|
|
|
|
if( IsDigit(str) )
|
|
{
|
|
result = ReadInt(str, offset_hour, 2) && offset_hour >= -12 && offset_hour <= 14;
|
|
|
|
if( result )
|
|
{
|
|
SkipSeparator(str, ':');
|
|
|
|
if( IsDigit(str) )
|
|
{
|
|
// offset_min is optional
|
|
result = ReadInt(str, offset_min, 2) && offset_min > -60 && offset_min < 60;
|
|
}
|
|
|
|
if( result )
|
|
{
|
|
time_t offset = (time_t)offset_hour * 60 * 60 + (time_t)offset_min * 60;
|
|
|
|
if( is_sign )
|
|
offset = -offset;
|
|
|
|
FromTime(ToTime() - offset);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
SetAfter(str, str_after);
|
|
return result;
|
|
}
|
|
|
|
|
|
template<class StringType>
|
|
bool Date::ParseZoneOffset(const StringType & str)
|
|
{
|
|
return ParseZoneOffset(str.c_str());
|
|
}
|
|
|
|
|
|
|
|
template<class CStringType>
|
|
bool Date::ParseDate(const CStringType * str, const CStringType ** str_after)
|
|
{
|
|
bool status = false;
|
|
ClearDate();
|
|
|
|
if( ReadInt(str, year, 4) )
|
|
{
|
|
status = true;
|
|
SkipSeparator(str, '.', '-', '/');
|
|
|
|
if( IsDigit(str) )
|
|
{
|
|
status = ReadInt(str, month, 2);
|
|
SkipSeparator(str, '.', '-', '/');
|
|
|
|
if( status && IsDigit(str) )
|
|
{
|
|
status = ReadInt(str, day, 2);
|
|
}
|
|
}
|
|
}
|
|
|
|
SetAfter(str, str_after);
|
|
return status;
|
|
}
|
|
|
|
|
|
template<class StringType>
|
|
bool Date::ParseDate(const StringType & str)
|
|
{
|
|
return ParseDate(str.c_str());
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
template<class CStringType>
|
|
bool Date::ParseTimeValue(const CStringType * & str, int & value, bool & has_fraction, int & fraction, int * fraction_base)
|
|
{
|
|
bool status = false;
|
|
size_t digits_read = 0;
|
|
bool was_comma = false;
|
|
has_fraction = false;
|
|
fraction = 0;
|
|
*fraction_base = 1;
|
|
|
|
if( ReadInt(str, value, 2) )
|
|
{
|
|
status = ReadCommaInt(str, was_comma, fraction, 0, &digits_read, fraction_base);
|
|
|
|
if( status )
|
|
{
|
|
if( was_comma )
|
|
has_fraction = true;
|
|
|
|
SkipSeparator(str, ':');
|
|
}
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
|
|
template<class CStringType>
|
|
bool Date::ParseTime(const CStringType * str, const CStringType ** str_after)
|
|
{
|
|
bool status = false;
|
|
bool has_fraction = false;
|
|
int fraction = 0;
|
|
int fraction_base = 0;
|
|
|
|
ClearTime();
|
|
|
|
if( ParseTimeValue(str, hour, has_fraction, fraction, &fraction_base) )
|
|
{
|
|
status = true;
|
|
|
|
if( has_fraction )
|
|
{
|
|
min = (60L * fraction) / (long)(fraction_base);
|
|
int min_rem = (60L * fraction) % (long)(fraction_base);
|
|
sec = (min_rem * 60L) / (long)fraction_base;
|
|
}
|
|
else
|
|
if( IsDigit(str) )
|
|
{
|
|
status = ParseTimeValue(str, min, has_fraction, fraction, &fraction_base);
|
|
|
|
if( status )
|
|
{
|
|
if( has_fraction )
|
|
{
|
|
sec = (60L * fraction) / (long)(fraction_base);
|
|
}
|
|
else
|
|
if( IsDigit(str) )
|
|
{
|
|
status = ParseTimeValue(str, sec, has_fraction, fraction, &fraction_base);
|
|
// ignore the seconds fraction if exists
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
SetAfter(str, str_after);
|
|
return status;
|
|
}
|
|
|
|
|
|
template<class StringType>
|
|
bool Date::ParseTime(const StringType & str)
|
|
{
|
|
return ParseTime(str.c_str());
|
|
}
|
|
|
|
|
|
|
|
template<class CStringType>
|
|
bool Date::ParseMonthDayTime(const CStringType * str, const CStringType ** str_after)
|
|
{
|
|
const CStringType * after;
|
|
bool result = false;
|
|
|
|
if( ParseMonthDay(str, &after) )
|
|
if( ParseTime(after, &after) )
|
|
result = true;
|
|
|
|
SetAfter(after, str_after);
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
template<class StringType>
|
|
bool Date::ParseMonthDayTime(const StringType & str)
|
|
{
|
|
return ParseMonthDayTime(str.c_str());
|
|
}
|
|
|
|
|
|
|
|
|
|
template<class CStringType>
|
|
bool Date::Parse(const CStringType * str, const CStringType ** str_after, bool check_time_zone)
|
|
{
|
|
const CStringType * after;
|
|
bool result = false;
|
|
Clear();
|
|
|
|
if( ParseDate(str, &after) )
|
|
{
|
|
result = true;
|
|
SkipWhite(after);
|
|
|
|
if( *after == 'T' )
|
|
{
|
|
after += 1;
|
|
SkipWhite(after);
|
|
}
|
|
|
|
if( IsDigit(after) )
|
|
{
|
|
result = ParseTime(after, &after);
|
|
|
|
if( result && check_time_zone )
|
|
{
|
|
SkipWhite(after);
|
|
|
|
if( *after == 'Z' )
|
|
{
|
|
after += 1;
|
|
}
|
|
else
|
|
if( *after == '-' || *after == '+' )
|
|
{
|
|
result = ParseZoneOffset(after, &after);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
SetAfter(after, str_after);
|
|
|
|
if( result )
|
|
result = IsCorrectDate();
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
template<class CStringType>
|
|
bool Date::Parse(const CStringType * str, bool check_time_zone)
|
|
{
|
|
const CStringType * str_after = nullptr;
|
|
return Parse(str, &str_after, check_time_zone);
|
|
}
|
|
|
|
|
|
template<class StringType>
|
|
bool Date::Parse(const StringType & str, bool check_time_zone)
|
|
{
|
|
const typename StringType::value_type * after_string = nullptr;
|
|
return Parse(str.c_str(), &after_string, check_time_zone);
|
|
}
|
|
|
|
|
|
|
|
|
|
template<class CStringType>
|
|
void Date::SetAfter(const CStringType * str, const CStringType ** str_after)
|
|
{
|
|
if( str_after )
|
|
*str_after = str;
|
|
}
|
|
|
|
|
|
|
|
template<class CStringType>
|
|
void Date::SkipWhite(const CStringType * & str)
|
|
{
|
|
while( *str==' ' || *str=='\t' )
|
|
str += 1;
|
|
}
|
|
|
|
|
|
template<class CStringType>
|
|
bool Date::IsDigit(const CStringType * str)
|
|
{
|
|
return (*str >= '0' && *str <= '9');
|
|
}
|
|
|
|
|
|
template<class CStringType>
|
|
bool Date::ReadInt(const CStringType * & str, int & result, size_t max_digits, size_t * digits_read, int * digits_base)
|
|
{
|
|
SkipWhite(str);
|
|
result = 0;
|
|
size_t read_chars = 0;
|
|
int base = 1;
|
|
bool skip_last_digits = false;
|
|
|
|
if( max_digits == 0 )
|
|
skip_last_digits = true;
|
|
|
|
if( max_digits == 0 || max_digits > 9 )
|
|
max_digits = 9;
|
|
|
|
while( IsDigit(str) && read_chars < max_digits )
|
|
{
|
|
result = result * 10 + (*str - '0');
|
|
base = base * 10;
|
|
str += 1;
|
|
read_chars += 1;
|
|
}
|
|
|
|
if( skip_last_digits )
|
|
{
|
|
while( IsDigit(str) )
|
|
{
|
|
str += 1;
|
|
read_chars += 1;
|
|
}
|
|
}
|
|
|
|
if( digits_read )
|
|
*digits_read = read_chars;
|
|
|
|
if( digits_base )
|
|
*digits_base = base;
|
|
|
|
return read_chars > 0 && read_chars <= max_digits;
|
|
}
|
|
|
|
|
|
template<class CStringType>
|
|
bool Date::ReadCommaInt(const CStringType * & str, bool & was_comma, int & result, size_t max_digits, size_t * digits_read, int * base)
|
|
{
|
|
bool status = true; // the comma is optional so we return true if it not exists
|
|
result = 0;
|
|
was_comma = false;
|
|
|
|
if( digits_read )
|
|
*digits_read = 0;
|
|
|
|
if( base )
|
|
*base = 1;
|
|
|
|
if( *str == '.' || *str == ',' )
|
|
{
|
|
str += 1;
|
|
was_comma = true;
|
|
|
|
if( IsDigit(str) )
|
|
status = ReadInt(str, result, max_digits, digits_read, base);
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
|
|
template<class CStringType>
|
|
bool Date::SkipSeparator(const CStringType * & str, int separator, int separator2, int separator3)
|
|
{
|
|
SkipWhite(str);
|
|
|
|
if( *str == separator )
|
|
{
|
|
str += 1;
|
|
SkipWhite(str);
|
|
return true;
|
|
}
|
|
|
|
if( separator2 != -1 && *str == separator2 )
|
|
{
|
|
str += 1;
|
|
SkipWhite(str);
|
|
return true;
|
|
}
|
|
|
|
if( separator3 != -1 && *str == separator3 )
|
|
{
|
|
str += 1;
|
|
SkipWhite(str);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
} // namespace
|
|
|
|
#endif
|