DateTime::DateTime(int year, int month, int day, int hour,
int minute, int second, int millisecond, int microsecond)
: m_year(year)
, m_month(month)
, m_day(day)
, m_hour(hour)
, m_minute(minute)
, m_second(second)
, m_millisecond(millisecond)
, m_microsecond(microsecond)
{
FIRTEX_ASSERT2(year >= 0 && year <= 9999);
FIRTEX_ASSERT2(month >= 1 && month <= 12);
FIRTEX_ASSERT2(day >= 1 && day <= daysOfMonth(year, month));
FIRTEX_ASSERT2(hour >= 0 && hour <= 23);
FIRTEX_ASSERT2(minute >= 0 && minute <= 59);
FIRTEX_ASSERT2(second >= 0 && second <= 59);
FIRTEX_ASSERT2(millisecond >= 0 && millisecond <= 999);
FIRTEX_ASSERT2(microsecond >= 0 && microsecond <= 999);
m_utcTime = toUtcTime(toJulianDay(year, month, day)) +
10*(hour*Timespan::HOURS + minute*Timespan::MINUTES +
second*Timespan::SECONDS +
millisecond*Timespan::MILLISECONDS + microsecond);
}
DateTime& DateTime::assign(int year, int month, int day, int hour,
int minute, int second, int millisecond,
int microsecond)
{
FIRTEX_ASSERT2(year >= 0 && year <= 9999);
FIRTEX_ASSERT2(month >= 1 && month <= 12);
FIRTEX_ASSERT2(day >= 1 && day <= daysOfMonth(year, month));
FIRTEX_ASSERT2(hour >= 0 && hour <= 23);
FIRTEX_ASSERT2(minute >= 0 && minute <= 59);
FIRTEX_ASSERT2(second >= 0 && second <= 59);
FIRTEX_ASSERT2(millisecond >= 0 && millisecond <= 999);
FIRTEX_ASSERT2(microsecond >= 0 && microsecond <= 999);
m_utcTime = toUtcTime(toJulianDay(year, month, day)) +
10*(hour*Timespan::HOURS + minute*Timespan::MINUTES +
second*Timespan::SECONDS +
millisecond*Timespan::MILLISECONDS + microsecond);
m_year = year;
m_month = month;
m_day = day;
m_hour = hour;
m_minute = minute;
m_second = second;
m_millisecond = millisecond;
m_microsecond = microsecond;
return *this;
}
int DateTime::dayOfYear() const
{
int doy = 0;
for (int month = 1; month < _month; ++month)
doy += daysOfMonth(_year, month);
doy += _day;
return doy;
}
void DateTime::normalize()
{
checkLimit(_microsecond, _millisecond, 999);
checkLimit(_millisecond, _second, 999);
checkLimit(_second, _minute, 59);
checkLimit(_minute, _hour, 59);
checkLimit(_hour, _day, 23);
if (_day > daysOfMonth(_year, _month))
{
_day -= daysOfMonth(_year, _month);
if (++_month > 12)
{
++_year;
_month -= 12;
}
}
}
void DateTime::normalize()
{
checkLimit(m_microsecond, m_millisecond, 1000);
checkLimit(m_millisecond, m_second, 1000);
checkLimit(m_second, m_minute, 60);
checkLimit(m_minute, m_hour, 60);
checkLimit(m_hour, m_day, 24);
if (m_day > daysOfMonth(m_year, m_month))
{
m_day -= daysOfMonth(m_year, m_month);
if (++m_month > 12)
{
++m_year;
m_month -= 12;
}
}
}
bool Date::isValid(Date date) {
if (date.year_ > 9999 || date.year_ <1000) return false;
bool judge = isLeapYear(date.year_);
if (date.month_ > 12 || date.month_ < 1) return false;
if (date.day_ > daysOfMonth(date.month_, judge) ||
date.day_ < 1) return false;
if (date.hour_ > 23 || date.hour_ < 0) return false;
if (date.minute_ > 59 || date.minute_ < 0) return false;
return true;
}
bool DateTime::isValid(int year, int month, int day, int hour, int minute, int second, int millisecond, int microsecond)
{
return
(year >= 0 && year <= 9999) &&
(month >= 1 && month <= 12) &&
(day >= 1 && day <= daysOfMonth(year, month)) &&
(hour >= 0 && hour <= 23) &&
(minute >= 0 && minute <= 59) &&
(second >= 0 && second <= 59) &&
(millisecond >= 0 && millisecond <= 999) &&
(microsecond >= 0 && microsecond <= 999);
}
void DateTime::computeDaytime()
{
Timespan span(_utcTime/10);
int hour = int((span/HOURS) % 24);
// Due to double rounding issues, the previous call to computeGregorian()
// may have crossed into the next or previous day. We need to correct that.
if (hour == 23 && _hour == 0)
{
_day--;
if (_day == 0)
{
_month--;
if (_month == 0)
{
_month = 12;
_year--;
}
_day = daysOfMonth(_year, _month);
}
}
else if (hour == 0 && _hour == 23)
{
_day++;
if (_day > daysOfMonth(_year, _month))
{
_month++;
if (_month > 12)
{
_month = 1;
_year++;
}
_day = 1;
}
}
_hour = hour;
_minute = short((span/MINUTES) % 60);
_second = short((span/SECONDS) % 60);
_millisecond = short((span/MILLISECONDS) % 1000);
_microsecond = short(span/1000);
}
uint8_t tick(uint8_t val)
{
uint8_t save_t = false;
uint8_t ret = 0;
switch (val)
{
case second:
date.second++;
ret = date.second;
if (date.second >= 60)
{
date.second = 0;
case minute:
date.minute++;
save_t = true;
ret = date.second;
if (date.minute >= 60)
{
date.minute = 0;
case hour:
date.hour++;
checkDST();
ret = date.hour;
if (date.hour >= 24)
{
date.hour = 0;
case day:
date.day++;
ret = date.hour;
if (date.day >= daysOfMonth(date.month, date.year))
{
date.day = 1;
case month:
date.month++;
ret = date.hour;
if (++date.month > 12)
{
date.month = 1;
case year:
++date.year;
}
}
}
}
}
}
if (save_t)
{
saveTime(date);
}
return ret;
}
void DateTime::computeGregorian(double julianDay)
{
double z = std::floor(julianDay - 1721118.5);
double r = julianDay - 1721118.5 - z;
double g = z - 0.25;
double a = std::floor(g / 36524.25);
double b = a - std::floor(a/4);
_year = short(std::floor((b + g)/365.25));
double c = b + z - std::floor(365.25*_year);
_month = short(std::floor((5*c + 456)/153));
double dday = c - std::floor((153.0*_month - 457)/5) + r;
_day = short(dday);
if (_month > 12)
{
++_year;
_month -= 12;
}
r *= 24;
_hour = short(std::floor(r));
r -= std::floor(r);
r *= 60;
_minute = short(std::floor(r));
r -= std::floor(r);
r *= 60;
_second = short(std::floor(r));
r -= std::floor(r);
r *= 1000;
_millisecond = short(std::floor(r));
r -= std::floor(r);
r *= 1000;
_microsecond = short(r + 0.5);
normalize();
poco_assert_dbg (_month >= 1 && _month <= 12);
poco_assert_dbg (_day >= 1 && _day <= daysOfMonth(_year, _month));
poco_assert_dbg (_hour >= 0 && _hour <= 23);
poco_assert_dbg (_minute >= 0 && _minute <= 59);
poco_assert_dbg (_second >= 0 && _second <= 59);
poco_assert_dbg (_millisecond >= 0 && _millisecond <= 999);
poco_assert_dbg (_microsecond >= 0 && _microsecond <= 999);
}
DateTime::DateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, int microsecond):
_year(year),
_month(month),
_day(day),
_hour(hour),
_minute(minute),
_second(second),
_millisecond(millisecond),
_microsecond(microsecond)
{
poco_assert (year >= 0 && year <= 9999);
poco_assert (month >= 1 && month <= 12);
poco_assert (day >= 1 && day <= daysOfMonth(year, month));
poco_assert (hour >= 0 && hour <= 23);
poco_assert (minute >= 0 && minute <= 59);
poco_assert (second >= 0 && second <= 59);
poco_assert (millisecond >= 0 && millisecond <= 999);
poco_assert (microsecond >= 0 && microsecond <= 999);
_utcTime = toUtcTime(toJulianDay(year, month, day)) + 10*(hour*Timespan::HOURS + minute*Timespan::MINUTES + second*Timespan::SECONDS + millisecond*Timespan::MILLISECONDS + microsecond);
}
DateTime& DateTime::assign(int year, int month, int day, int hour, int minute, int second, int millisecond, int microsecond)
{
pi_assert_dbg (year >= 0 && year <= 9999);
pi_assert_dbg (month >= 1 && month <= 12);
pi_assert_dbg (day >= 1 && day <= daysOfMonth(year, month));
pi_assert_dbg (hour >= 0 && hour <= 23);
pi_assert_dbg (minute >= 0 && minute <= 59);
pi_assert_dbg (second >= 0 && second <= 59);
pi_assert_dbg (millisecond >= 0 && millisecond <= 999);
pi_assert_dbg (microsecond >= 0 && microsecond <= 999);
_utcTime = toUtcTime(toJulianDay(year, month, day)) +
10*(hour*HOURS + minute*MINUTES + second*SECONDS + millisecond*MILLISECONDS + microsecond);
_year = year;
_month = month;
_day = day;
_hour = hour;
_minute = minute;
_second = second;
_millisecond = millisecond;
_microsecond = microsecond;
return *this;
}
