CCSDateTime& CCSDateTime::Assign( int year, int month, int day, int hour /*= 0*/, int minute /*= 0*/, int second /*= 0*/, int milliscond /*= 0*/, int microseccond /*= 0 */ )
{
assert (year >= 0 && year <= 9999);
assert (month >= 1 && month <= 12);
assert (day >= 1 && day <= DaysOfMonth(year, month));
assert (hour >= 0 && hour <= 23);
assert (minute >= 0 && minute <= 59);
assert (second >= 0 && second <= 59);
assert (milliscond >= 0 && milliscond <= 999);
assert (microseccond >= 0 && microseccond <= 999);
m_ts = ToUtcTime( ToJulianDay( year, month, day, hour) +
10 * ( hour * CCSTimeSpan::HOURS + minute * CCSTimeSpan::MINUTES + second * CCSTimeSpan::SECONDS + milliscond * CCSTimeSpan::MILLISECONDS + microseccond ));
m_year = year;
m_month = month;
m_day = day;
m_hour = hour;
m_minute = minute;
m_second = second;
m_millisecond = milliscond;
m_microsecond = microseccond;
return (*this);
}
void CCSDateTime::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 CheckDate ()
{
if(_year < 1900
||(_month < 1 || _month > 12)
||(_day < 1 || _day > DaysOfMonth(_year, _month)))
return false;
else
return true;
}
bool CCSDateTime::IsValid( int year, int month, int day, int hour /*= 0*/, int minute /*= 0*/, int second /*= 0*/, int millisecond /*= 0*/, int microsecond /*= 0*/ )
{
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);
}
int CCSDateTime::DayOfYear() const
{
int doy = 0;
for ( int month = 1; month < m_month; ++month )
{
doy += DaysOfMonth( m_year, month );
}
doy += m_day;
return doy;
}
VOID
CalculateNextStartTime(PJOB pJob)
{
SYSTEMTIME StartTime;
FILETIME FileTime;
DWORD_PTR Now;
TRACE("CalculateNextStartTime(%p)\n", pJob);
GetLocalTime(&StartTime);
Now = (DWORD_PTR)StartTime.wHour * 3600000 +
(DWORD_PTR)StartTime.wMinute * 60000;
StartTime.wMilliseconds = 0;
StartTime.wSecond = 0;
StartTime.wHour = (WORD)(pJob->JobTime / 3600000);
StartTime.wMinute = (WORD)((pJob->JobTime % 3600000) / 60000);
/* Start the job tomorrow */
if (Now > pJob->JobTime)
{
if (StartTime.wDay + 1 > DaysOfMonth(StartTime.wMonth, StartTime.wYear))
{
if (StartTime.wMonth == 12)
{
StartTime.wDay = 1;
StartTime.wMonth = 1;
StartTime.wYear++;
}
else
{
StartTime.wDay = 1;
StartTime.wMonth++;
}
}
else
{
StartTime.wDay++;
}
}
TRACE("Next start: %02hu:%02hu %02hu.%02hu.%hu\n", StartTime.wHour,
StartTime.wMinute, StartTime.wDay, StartTime.wMonth, StartTime.wYear);
SystemTimeToFileTime(&StartTime, &FileTime);
pJob->StartTime.u.LowPart = FileTime.dwLowDateTime;
pJob->StartTime.u.HighPart = FileTime.dwHighDateTime;
}
void CCSDateTime::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);
m_year = short( std::floor(( b + a ) / 365.25));
double c = b + z - std::floor(365.25*m_year);
m_month = short( std::floor((5*c + 456)/153) );
double dday = c - std::floor((153.0*m_month - 457)/5) + r;
m_day = short( dday );
if (m_month > 12)
{
++m_year;
m_month -= 12;
}
r *= 24;
m_hour = short(std::floor(r));
r -= std::floor(r);
r *= 60;
m_minute = short(std::floor(r));
r -= std::floor(r);
r *= 60;
m_second = short(std::floor(r));
r -= std::floor(r);
r *= 1000;
m_millisecond = short(std::floor(r));
r -= std::floor(r);
r *= 1000;
m_microsecond = short(r + 0.5);
Normalize();
assert (m_month >= 1 && m_month <= 12);
assert (m_day >= 1 && m_day <= DaysOfMonth(m_year, m_month));
assert (m_hour >= 0 && m_hour <= 23);
assert (m_minute >= 0 && m_minute <= 59);
assert (m_second >= 0 && m_second <= 59);
assert (m_millisecond >= 0 && m_millisecond <= 999);
assert (m_microsecond >= 0 && m_microsecond <= 999);
}
CCSDateTime::CCSDateTime( int year, int month, int day, int hour /*= 0*/, int minutes /*= 0*/, int seconds /*= 0*/, int milliseconds /*= 0*/, int microseconds /*= 0 */ )
: m_year( year )
, m_month( month )
, m_day( day )
, m_hour( hour )
, m_minute( minutes )
, m_second( seconds )
, m_millisecond( milliseconds )
, m_microsecond( microseconds )
{
assert(year >= 0 && year <= 9999);
assert (month >= 1 && month <= 12);
assert (day >= 1 && day <= DaysOfMonth(year, month));
assert (hour >= 0 && hour <= 23);
assert (minutes >= 0 && minutes <= 59);
assert (seconds >= 0 && seconds <= 59);
assert (milliseconds >= 0 && milliseconds <= 999);
assert (microseconds >= 0 && microseconds <= 999);
m_ts = ToUtcTime( ToJulianDay( year, month, day, hour) +
10 * ( hour * CCSTimeSpan::HOURS + minutes * CCSTimeSpan::MINUTES + seconds * CCSTimeSpan::SECONDS + milliseconds * CCSTimeSpan::MILLISECONDS + microseconds ));
}
days += g_monoff[tm.tm_mon];
if (tm.tm_mon > 1 && IsLeapYear(year))
++days;
days += tm.tm_mday - 1;
hours = days * 24 + tm.tm_hour;
minutes = hours * 60 + tm.tm_min;
seconds = minutes * 60 + tm.tm_sec;
return my::SecondsSinceEpochToTimeT(seconds);
}
time_t TimeGM(int year, int month, int day, int hour, int min, int sec)
{
ASSERT_GREATER_OR_EQUAL(month, 1, ());
ASSERT_LESS_OR_EQUAL(month, 12, ());
ASSERT_GREATER_OR_EQUAL(day, 1, ());
ASSERT_LESS_OR_EQUAL(day, DaysOfMonth(year, month), ());
tm t = {};
t.tm_year = year - 1900;
t.tm_mon = month - 1;
t.tm_mday = day;
t.tm_hour = hour;
t.tm_min = min;
t.tm_sec = sec;
return TimeGM(t);
}
} // namespace base
