#pragma once
class SCDateTime;
#define SCDATETIME_SUPPORT_CHRONO 1
#ifdef SCDATETIME_SUPPORT_CHRONO
#include <chrono>
#endif
#include <cstdint>
#include <math.h>
#include <string.h>
#include <time.h>
#define SHOW_WARNING_IF_DEPRECATED 0
#if SHOW_WARNING_IF_DEPRECATED
# define DEPRECATED(MESSAGE) __declspec(deprecated(MESSAGE))
# pragma warning(push)
# pragma warning(disable: 4996)
#else
# define DEPRECATED(MESSAGE)
#endif
typedef int t_SCDate;
typedef int t_SCTime;
enum MonthEnum
{ JANUARY = 1
, FEBRUARY = 2
, MARCH = 3
, APRIL = 4
, MAY = 5
, JUNE = 6
, JULY = 7
, AUGUST = 8
, SEPTEMBER = 9
, OCTOBER = 10
, NOVEMBER = 11
, DECEMBER = 12
};
static const char* FULL_NAME_FOR_MONTH[13] = {"", "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"};
static const char* SHORT_NAME_FOR_MONTH[13] = {"", "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
static const int DAYS_IN_MONTH[13] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
static const int DAYS_IN_YEAR_AT_MONTH_END[13] = {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365};
static const char FUTURES_CODE_FOR_MONTH[13] = {'\0', 'F', 'G', 'H', 'J', 'K', 'M', 'N', 'Q', 'U', 'V', 'X', 'Z'};
enum DayOfWeekEnum
{ DAY_OF_WEEK_NOT_SET = -1
, SUNDAY = 0
, MONDAY = 1
, TUESDAY = 2
, WEDNESDAY = 3
, THURSDAY = 4
, FRIDAY = 5
, SATURDAY = 6
};
enum DayOfWeekMondayBasedEnum
{ DAY_OF_WEEK_MONDAY_BASED_NOT_SET = -1
, MONDAY_MONDAY_BASED = 0
, TUESDAY_MONDAY_BASED = 1
, WEDNESDAY_MONDAY_BASED = 2
, THURSDAY_MONDAY_BASED = 3
, FRIDAY_MONDAY_BASED = 4
, SATURDAY_MONDAY_BASED = 5
, SUNDAY_MONDAY_BASED = 6
};
const double DATETIME_UNSET_DOUBLE = 0;
const int64_t DATETIME_UNSET = 0;
static const char* FULL_NAME_FOR_DAY_OF_WEEK[7] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};
static const char* SHORT_NAME_FOR_DAY_OF_WEEK[7] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
static const char* TWO_CHAR_NAME_FOR_DAY_OF_WEEK[7] = {"Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"};
static const int32_t DAYS_IN_YEAR = 365;
static const int MONTHS_PER_YEAR = 12;
static const int DAYS_PER_WEEK = 7;
static const int HOURS_PER_DAY = 24;
static const int MINUTES_PER_HOUR = 60;
static const int SECONDS_PER_MINUTE = 60;
static const int MILLISECONDS_PER_SECOND = 1000;
static const std::int64_t MICROSECONDS_PER_MILLISECOND = 1000;
static const int NANOSECONDS_PER_MICROSECOND = 1000;
static const int MINUTES_PER_DAY = MINUTES_PER_HOUR*HOURS_PER_DAY;
static const int SECONDS_PER_DAY = SECONDS_PER_MINUTE*MINUTES_PER_DAY;
static const int SECONDS_PER_HOUR = SECONDS_PER_MINUTE*MINUTES_PER_HOUR;
static const int MILLISECONDS_PER_DAY = MILLISECONDS_PER_SECOND*SECONDS_PER_DAY;
static const int MILLISECONDS_PER_HOUR = MILLISECONDS_PER_SECOND*SECONDS_PER_HOUR;
static const int MILLISECONDS_PER_MINUTE = MILLISECONDS_PER_SECOND*SECONDS_PER_MINUTE;
static const std::int64_t MICROSECONDS_PER_DAY = MICROSECONDS_PER_MILLISECOND*MILLISECONDS_PER_DAY;
static const std::int64_t MICROSECONDS_PER_HOUR = MICROSECONDS_PER_MILLISECOND*MILLISECONDS_PER_HOUR;
static const std::int64_t MICROSECONDS_PER_MINUTE = MICROSECONDS_PER_MILLISECOND*MILLISECONDS_PER_MINUTE;
static const std::int64_t MICROSECONDS_PER_SECOND = MICROSECONDS_PER_MILLISECOND*MILLISECONDS_PER_SECOND;
static const std::int64_t NANOSECONDS_PER_DAY = NANOSECONDS_PER_MICROSECOND*MICROSECONDS_PER_DAY;
static const std::int64_t NANOSECONDS_PER_SECOND = NANOSECONDS_PER_MICROSECOND*MICROSECONDS_PER_SECOND;
static const std::int64_t NANOSECONDS_PER_MILLISECOND = NANOSECONDS_PER_MICROSECOND*MICROSECONDS_PER_MILLISECOND;
static const int EPOCH_YEAR = 1899;
static const int EPOCH_MONTH = 12;
static const int EPOCH_DAY = 30;
static const int SCDATETIME_UNIX_EPOCH_DATE = 25569;
static const double SCDATETIME_UNIX_EPOCH = 25569.0;
#ifdef SCDATETIME_SUPPORT_CHRONO
static const auto SCDATETIME_EPOCH_SYSTEM_CLOCK
= std::chrono::system_clock::from_time_t(-25569ll * 86400ll);
#endif
inline int DaysSince1Jan0AtYearBeginning(const int Year)
{
return Year * 365 + Year / 4 - Year / 100 + Year / 400;
}
static const int DAYS_BEFORE_UNIX_EPOCH = DaysSince1Jan0AtYearBeginning(1970) + 1;
static const int DAYS_BEFORE_SC_EPOCH = DaysSince1Jan0AtYearBeginning(1900) - 1;
int64_t SCDateTimeDoubleToSCDateTime(const double DateTime);
DEPRECATED("The IS_UNSET is deprecated. Use portable SCDateTime::IsUnset() instead.")
inline bool IS_UNSET(const double DateTime)
{
return DateTime == DATETIME_UNSET_DOUBLE;
}
DEPRECATED("The IS_UNSET is deprecated. Use portable SCDateTime::IsUnset() instead.")
inline bool IS_UNSET(const int64_t DateTime)
{
return DateTime == DATETIME_UNSET;
}
inline int64_t ADJUST(const int64_t Value, const int64_t Epsilon)
{
if (Value < 0)
return Value - Epsilon;
else
return Value + Epsilon;
}
inline double ADJUST(const double Value, const double Epsilon = 0.5)
{
if (Value < 0)
return Value - Epsilon;
else
return Value + Epsilon;
}
DEPRECATED("The ROUND_US is private and deprecated.")
inline double ROUND_US(const double DateTime)
{
return ADJUST(DateTime, 1.0 / MICROSECONDS_PER_DAY / 2);
}
DEPRECATED("The ADJUST_ROUND_SECOND is private and deprecated.")
inline int64_t ADJUST_ROUND_SECOND(int64_t DateTime)
{
return ADJUST(DateTime, MICROSECONDS_PER_SECOND / 2);
}
DEPRECATED("The ADJUST_ROUND_MS is private and deprecated.")
inline int64_t ADJUST_ROUND_MS(int64_t DateTime)
{
return ADJUST(DateTime, MICROSECONDS_PER_MILLISECOND / 2);
}
DEPRECATED("The DATE_PART is deprecated. Use portable SCDateTime::GetDate() instead.")
inline int DATE_PART(const int64_t DateTime)
{
return static_cast<int>(ADJUST_ROUND_SECOND(DateTime) / MICROSECONDS_PER_DAY);
}
DEPRECATED("Usage of DATE_PART is deprecated. Use portable SCDateTime::GetDate() instead.")
inline int DATE_PART(double DateTimeDouble)
{
const int64_t DateTime = SCDateTimeDoubleToSCDateTime(DateTimeDouble);
return DATE_PART(DateTime);
}
DEPRECATED("Usage of TIME_PART is deprecated. Use portable SCDateTime::GetTime() instead.")
inline int TIME_PART(const int64_t DateTime)
{
int64_t DateTimeAdjusted = ADJUST_ROUND_SECOND(DateTime);
DateTimeAdjusted %= MICROSECONDS_PER_DAY;
int64_t TimeInSeconds = DateTimeAdjusted / MICROSECONDS_PER_SECOND;
if (TimeInSeconds >= SECONDS_PER_DAY)
TimeInSeconds = 0;
return static_cast<int>(TimeInSeconds);
}
DEPRECATED("Usage of TIME_PART is deprecated. Use portable SCDateTime::GetTime() instead.")
inline int TIME_PART(double DateTimeDouble)
{
const int64_t DateTime = SCDateTimeDoubleToSCDateTime(DateTimeDouble);
return TIME_PART(DateTime);
}
DEPRECATED("Usage of DATE_PART_MS is deprecated. Use portable SCDateTime::GetDateMS() instead.")
inline int DATE_PART_MS(const int64_t DateTime)
{
return static_cast<int>(DateTime / MICROSECONDS_PER_DAY);
}
DEPRECATED("Usage of DATE_PART_MS is deprecated. Use portable SCDateTime::GetDateMS() instead.")
inline int DATE_PART_MS(double DateTimeDouble)
{
const int64_t DateTime = SCDateTimeDoubleToSCDateTime(DateTimeDouble);
return DATE_PART_MS(DateTime);
}
DEPRECATED("Usage of TIME_PART_MS is deprecated. Use portable SCDateTime::GetTime() instead.")
inline int TIME_PART_MS(const int64_t DateTime)
{
int64_t TimeOnly = DateTime;
TimeOnly %= MICROSECONDS_PER_DAY;
int64_t TimeInSeconds = TimeOnly / MICROSECONDS_PER_SECOND;
if (TimeInSeconds >= SECONDS_PER_DAY)
TimeInSeconds = 0;
return static_cast<int>(TimeInSeconds);
}
DEPRECATED("Usage of TIME_PART_MS is deprecated. Use portable SCDateTime::GetTime() instead.")
inline int TIME_PART_MS(double DateTimeDouble)
{
const int64_t DateTime = SCDateTimeDoubleToSCDateTime(DateTimeDouble);
return TIME_PART_MS(DateTime);
}
DEPRECATED("The SECONDS_PART is deprecated. Use portable SCDateTime::GetSecond() instead.")
inline int SECONDS_PART(const int64_t DateTime)
{
const int64_t DateTimeAdjusted = ADJUST_ROUND_SECOND(DateTime);
int SecondsPart = (DateTimeAdjusted / MICROSECONDS_PER_SECOND) % SECONDS_PER_MINUTE;
if (DateTime < 0)
SecondsPart = -SecondsPart;
return SecondsPart;
}
DEPRECATED("The SECONDS_PART is deprecated. Use portable SCDateTime::GetSecond() instead.")
inline int SECONDS_PART(double DateTimeDouble)
{
const int64_t DateTime = SCDateTimeDoubleToSCDateTime(DateTimeDouble);
return SECONDS_PART(DateTime);
}
DEPRECATED("The MS_PART is deprecated. Use portable SCDateTime::GetMillisecond() instead.")
inline int MS_PART(const int64_t DateTime)
{
const int MillisecondsPart = (DateTime / MICROSECONDS_PER_MILLISECOND) % MILLISECONDS_PER_SECOND;
return MillisecondsPart;
}
DEPRECATED("The MS_PART is deprecated. Use portable SCDateTime::GetMillisecond() instead.")
inline int MS_PART(double DateTimeDouble)
{
const int64_t DateTime = SCDateTimeDoubleToSCDateTime(DateTimeDouble);
return MS_PART(DateTime);
}
DEPRECATED("The COMBINE_DATE_TIME is deprecated. Use SCDateTime::SCDateTime(int Date, int TimeInSeconds) constructor instead.")
inline double COMBINE_DATE_TIME(int Date, int Time)
{
return (Date) + Time / static_cast<double>(SECONDS_PER_DAY);
}
DEPRECATED("The COMBINE_DATE_TIME is deprecated. Use SCDateTime::SCDateTime(int Date, int TimeInSeconds) constructor instead.")
inline int64_t COMBINE_DATE_TIME_US(int Date, int Time)
{
return (Date)* MICROSECONDS_PER_DAY + Time * MICROSECONDS_PER_SECOND;
}
DEPRECATED("The DAY_OF_WEEK is deprecated. Use SCDateTime::GetDayOfWeek() instead.")
inline DayOfWeekEnum DAY_OF_WEEK(int Date)
{
Date -= 1;
if (Date < 0)
Date = Date % DAYS_PER_WEEK + DAYS_PER_WEEK;
return static_cast<DayOfWeekEnum>(Date % DAYS_PER_WEEK);
}
DEPRECATED("The DAY_OF_WEEK is deprecated. Use SCDateTime::GetDayOfWeek() instead.")
inline DayOfWeekEnum DAY_OF_WEEK(double DateTime)
{
return DAY_OF_WEEK(DATE_PART(DateTime));
}
DEPRECATED("The DAY_OF_WEEK_MONDAY_BASED is deprecated. Use SCDateTime::GetDayOfWeekMondayBased() instead.")
inline DayOfWeekMondayBasedEnum DAY_OF_WEEK_MONDAY_BASED(int Date)
{
Date -= 2;
if (Date < 0)
Date = DAYS_PER_WEEK + Date % DAYS_PER_WEEK ;
return static_cast<DayOfWeekMondayBasedEnum>(Date % DAYS_PER_WEEK);
}
inline const char* GetFullNameForMonth(int Month)
{
if (Month < JANUARY || Month > DECEMBER)
return FULL_NAME_FOR_MONTH[0];
return FULL_NAME_FOR_MONTH[Month];
}
inline const char* GetShortNameForMonth(int Month)
{
if (Month < JANUARY || Month > DECEMBER)
return SHORT_NAME_FOR_MONTH[0];
return SHORT_NAME_FOR_MONTH[Month];
}
inline int GetMonthFromShortName(const char* ShortName)
{
if (ShortName == NULL)
return 0;
for (int Month = JANUARY; Month <= DECEMBER; ++Month)
{
#if _MSC_VER >= 1400
if (_stricmp(ShortName, SHORT_NAME_FOR_MONTH[Month]) == 0)
#elif __linux__
if (strcasecmp(ShortName, SHORT_NAME_FOR_MONTH[Month]) == 0)
#else
if (stricmp(ShortName, SHORT_NAME_FOR_MONTH[Month]) == 0)
#endif
return Month;
}
return 0;
}
inline int GetMonthFromFuturesCode(char MonthCode)
{
if (MonthCode >= 'a' && MonthCode <= 'z')
MonthCode += 'A' - 'a';
for (int Month = JANUARY; Month <= DECEMBER; ++Month)
{
if (MonthCode == FUTURES_CODE_FOR_MONTH[Month])
return Month;
}
return 0;
}
inline bool IsValidFuturesMonthCode(char MonthCode)
{
return (GetMonthFromFuturesCode(MonthCode) != 0);
}
inline const char* GetFullNameForDayOfWeek(int DayOfWeek)
{
if (DayOfWeek < SUNDAY || DayOfWeek > SATURDAY)
return "";
return FULL_NAME_FOR_DAY_OF_WEEK[DayOfWeek];
}
inline const char* GetShortNameForDayOfWeek(int DayOfWeek)
{
if (DayOfWeek < SUNDAY || DayOfWeek > SATURDAY)
return "";
return SHORT_NAME_FOR_DAY_OF_WEEK[DayOfWeek];
}
inline const char* GetTwoCharNameForDayOfWeek(int DayOfWeek)
{
if (DayOfWeek < SUNDAY || DayOfWeek > SATURDAY)
return "";
return TWO_CHAR_NAME_FOR_DAY_OF_WEEK[DayOfWeek];
}
inline DayOfWeekEnum GetDayOfWeekFromInt(int DayOfWeek)
{
if (DayOfWeek < SUNDAY || DayOfWeek > SATURDAY)
return DAY_OF_WEEK_NOT_SET;
return static_cast<DayOfWeekEnum>(DayOfWeek);
}
inline DayOfWeekEnum GetDayOfWeekFromFullName(const char* FullName)
{
if (FullName == NULL)
return DAY_OF_WEEK_NOT_SET;
for (int DayOfWeek = SUNDAY; DayOfWeek <= SATURDAY; ++DayOfWeek)
{
#if _MSC_VER >= 1400
if (_stricmp(FullName, FULL_NAME_FOR_DAY_OF_WEEK[DayOfWeek]) == 0)
#elif __linux__
if (strcasecmp(FullName, FULL_NAME_FOR_DAY_OF_WEEK[DayOfWeek]) == 0)
#else
if (stricmp(FullName, FULL_NAME_FOR_DAY_OF_WEEK[DayOfWeek]) == 0)
#endif
return static_cast<DayOfWeekEnum>(DayOfWeek);
}
return DAY_OF_WEEK_NOT_SET;
}
inline DayOfWeekEnum GetDayOfWeekFromShortName(const char* ShortName)
{
if (ShortName == NULL)
return DAY_OF_WEEK_NOT_SET;
for (int DayOfWeek = SUNDAY; DayOfWeek <= SATURDAY; ++DayOfWeek)
{
#if _MSC_VER >= 1400
if (_stricmp(ShortName, SHORT_NAME_FOR_DAY_OF_WEEK[DayOfWeek]) == 0)
#elif __linux__
if (strcasecmp(ShortName, SHORT_NAME_FOR_DAY_OF_WEEK[DayOfWeek]) == 0)
#else
if (stricmp(ShortName, SHORT_NAME_FOR_DAY_OF_WEEK[DayOfWeek]) == 0)
#endif
return static_cast<DayOfWeekEnum>(DayOfWeek);
}
return DAY_OF_WEEK_NOT_SET;
}
DEPRECATED("The IsSaturday is deprecated. Use SCDateTime::IsSaturday() instead.")
inline bool IsSaturday(int Date)
{
return (DAY_OF_WEEK(Date) == SATURDAY);
}
DEPRECATED("The IsSaturday is deprecated. Use SCDateTime::IsSaturday() instead.")
inline bool IsSaturday(double DateTime)
{
return (DAY_OF_WEEK(DateTime) == SATURDAY);
}
DEPRECATED("The IsSunday is deprecated. Use SCDateTime::IsSunday() instead.")
inline bool IsSunday(int Date)
{
return (DAY_OF_WEEK(Date) == SUNDAY);
}
DEPRECATED("The IsSunday is deprecated. Use SCDateTime::IsSunday() instead.")
inline bool IsSunday(double DateTime)
{
return (DAY_OF_WEEK(DateTime) == SUNDAY);
}
DEPRECATED("The IsWeekend is deprecated. Use SCDateTime::IsWeekend() instead.")
inline bool IsWeekend(int Date)
{
const int DayOfWeek = DAY_OF_WEEK(Date);
return (DayOfWeek == SUNDAY || DayOfWeek == SATURDAY);
}
DEPRECATED("The IsWeekend is deprecated. Use SCDateTime::IsWeekend() instead.")
inline bool IsWeekend(double DateTime)
{
const int DayOfWeek = DAY_OF_WEEK(DateTime);
return (DayOfWeek == SUNDAY || DayOfWeek == SATURDAY);
}
inline bool IsWeekend(int Date, bool UseSaturdayData)
{
const int DayOfWeek = DAY_OF_WEEK(Date);
return (DayOfWeek == SUNDAY || (!UseSaturdayData && DayOfWeek == SATURDAY));
}
inline bool IsWeekend(double DateTime, bool UseSaturdayData)
{
const int DayOfWeek = DAY_OF_WEEK(DateTime);
return (DayOfWeek == SUNDAY || (!UseSaturdayData && DayOfWeek == SATURDAY));
}
inline bool IsBusinessDay(int Date)
{
return !IsWeekend(Date);
}
inline bool IsLeapYear(int Year)
{
return ((Year & 3) == 0) && ((Year % 100) != 0 || (Year % 400) == 0);
}
inline int GetDaysInMonth(int Month, int Year)
{
if (Month < JANUARY || Month > DECEMBER)
return 0;
if (Month == FEBRUARY && IsLeapYear(Year))
return DAYS_IN_MONTH[Month] + 1;
else
return DAYS_IN_MONTH[Month];
}
inline int DaysInDateSpanNotIncludingWeekends(int FirstDate, int LastDate)
{
if (FirstDate > LastDate)
{
const int EarlierDate = LastDate;
LastDate = FirstDate;
FirstDate = EarlierDate;
}
const int SpanDifference = LastDate - FirstDate;
const int FirstDayOfWeek = DAY_OF_WEEK(FirstDate);
const int SundayBasedSpan = SpanDifference + FirstDayOfWeek;
int NumSaturdays;
if (SundayBasedSpan - SATURDAY < 0)
NumSaturdays = 0;
else
NumSaturdays = (SundayBasedSpan - SATURDAY) / DAYS_PER_WEEK + 1;
int NumSundays = SundayBasedSpan / DAYS_PER_WEEK;
if (FirstDayOfWeek == SUNDAY)
++NumSundays;
return SpanDifference + 1 - NumSaturdays - NumSundays;
}
DEPRECATED("The SCDateTimeDoubleToUNIXTime is deprecated. Use SCDateTime::ToUNIXTime() instead.")
inline time_t SCDateTimeDoubleToUNIXTime(double DateTimeDouble)
{
if (IS_UNSET(DateTimeDouble))
return 0;
return (time_t)ADJUST((DateTimeDouble - SCDATETIME_UNIX_EPOCH) * SECONDS_PER_DAY);
}
DEPRECATED("The SCDateTimeToFloatUNIXTime is deprecated. Use SCDateTime::ToFloatUNIXTime() instead.")
inline double SCDateTimeToFloatUNIXTime(double DateTimeDouble)
{
if (IS_UNSET(DateTimeDouble))
return DATETIME_UNSET_DOUBLE;
return ((DateTimeDouble - SCDATETIME_UNIX_EPOCH) * SECONDS_PER_DAY);
}
DEPRECATED("The SCDateTimeDoubleToSCDateTime is private and deprecated")
inline int64_t SCDateTimeDoubleToSCDateTime(const double DateTime)
{
if (IS_UNSET(DateTime))
return DATETIME_UNSET;
return static_cast<int64_t>(ADJUST(DateTime * MICROSECONDS_PER_DAY));
}
inline double SCUNIXTimeToSCDateTime(const int64_t SCUnixTime)
{
return double(SCUnixTime) / MICROSECONDS_PER_DAY;
}
DEPRECATED("The UNIXTimeToSCDateTime is deprecated. Use SCDateTime::SetUNIXTime() instead.")
inline double UNIXTimeToSCDateTime(time_t UnixTime)
{
if (UnixTime == 0)
return DATETIME_UNSET_DOUBLE;
return (UnixTime) / static_cast<double>(SECONDS_PER_DAY) + SCDATETIME_UNIX_EPOCH;
}
DEPRECATED("The UNIXTimeToSCDateTimeUNIX is deprecated. Use SCDateTime::SetUNIXTime() instead.")
inline int64_t UNIXTimeToSCDateTimeUNIX(time_t UnixTime)
{
if (UnixTime == 0)
return DATETIME_UNSET;
return UnixTime * MICROSECONDS_PER_SECOND + SCDATETIME_UNIX_EPOCH_DATE * MICROSECONDS_PER_DAY;
}
DEPRECATED("The UNIXTimeWithMillisecondsToSCDateTime is deprecated. Use SCDateTime::SetUNIXTimeWithMilliseconds() instead.")
inline double UNIXTimeWithMillisecondsToSCDateTime(double UnixTimeWithMilliseconds)
{
if (UnixTimeWithMilliseconds == 0.0)
return DATETIME_UNSET_DOUBLE;
return UnixTimeWithMilliseconds / SECONDS_PER_DAY + SCDATETIME_UNIX_EPOCH;
}
DEPRECATED("The UNIXTimeWithMillisecondsToSCDateTimeUNIX is deprecated. Use SCDateTime::SetUNIXTimeWithMilliseconds() instead.")
inline int64_t UNIXTimeWithMillisecondsToSCDateTimeUNIX(double UnixTimeWithMilliseconds)
{
if (UnixTimeWithMilliseconds == 0.0)
return DATETIME_UNSET;
return static_cast<int64_t>(ADJUST(UnixTimeWithMilliseconds * MICROSECONDS_PER_SECOND)) + SCDATETIME_UNIX_EPOCH_DATE * MICROSECONDS_PER_DAY;
}
inline int64_t HMS_MS_DATETIME(int Hour, int Minute, int Second, int Millisecond)
{
return Hour * MICROSECONDS_PER_HOUR
+ Minute * MICROSECONDS_PER_MINUTE
+ Second * MICROSECONDS_PER_SECOND
+ Millisecond * MICROSECONDS_PER_MILLISECOND;
}
inline int64_t YMDHMS_MS_DATETIME(int Year, int Month, int Day, int Hour, int Minute, int Second, int Millisecond)
{
if (Year > 9999 || Year < -9999 || Month < 1 || Month > 12)
return DATETIME_UNSET;
const bool bLeapYear = IsLeapYear(Year);
const int nDaysInMonth
= DAYS_IN_YEAR_AT_MONTH_END[Month] - DAYS_IN_YEAR_AT_MONTH_END[Month - 1]
+ ((bLeapYear && Day == 29 && Month == 2) ? 1 : 0);
if ( Day < 1 || Day > nDaysInMonth
)
{
return DATETIME_UNSET;
}
int nDate = DaysSince1Jan0AtYearBeginning(Year)
+ DAYS_IN_YEAR_AT_MONTH_END[Month - 1]
+ Day;
if (Month <= 2 && bLeapYear)
--nDate;
nDate -= DAYS_BEFORE_SC_EPOCH;
const int64_t Time = HMS_MS_DATETIME(Hour, Minute, Second, Millisecond);
return nDate * MICROSECONDS_PER_DAY + ((nDate >= 0) ? Time : -Time);
}
DEPRECATED("The YMDHMS_DATETIME is deprecated. Use SCDateTime::GetDateYMD() instead.")
inline int64_t YMDHMS_DATETIME(int Year, int Month, int Day, int Hour, int Minute, int Second)
{
return YMDHMS_MS_DATETIME(Year, Month, Day, Hour, Minute, Second, 0);
}
inline void DATETIME_TO_YMDHMS_MS(int64_t DateTime, int& Year, int& Month, int& Day, int& Hour, int& Minute, int& Second, int& MillisecondOrMicrosecond, const bool GetMicroseconds = false)
{
Year = Month = Day = Hour = Minute = Second = 0;
int n400Years;
int n400Century;
int n4Years;
int n4Day;
int n4Yr;
int bLeap4 = 1;
int64_t TempDateTime = DateTime;
if (DateTime != DATETIME_UNSET)
{
if (MillisecondOrMicrosecond != -1)
{
if (!GetMicroseconds)
{
TempDateTime = ADJUST_ROUND_MS(DateTime);
}
}
else
{
TempDateTime = ADJUST_ROUND_SECOND(DateTime);
}
}
MillisecondOrMicrosecond = 0;
const int nAllDays = static_cast<int>(TempDateTime / MICROSECONDS_PER_DAY);
int nDaysAbsolute = nAllDays + DAYS_BEFORE_SC_EPOCH;
TempDateTime = abs(TempDateTime);
int64_t Time = TempDateTime % MICROSECONDS_PER_DAY;
const int NumberOfDaysin400Years = DaysSince1Jan0AtYearBeginning(400);
n400Years = nDaysAbsolute / NumberOfDaysin400Years;
nDaysAbsolute %= NumberOfDaysin400Years;
n400Century = ((nDaysAbsolute - 1) / 36524);
if (n400Century != 0)
{
nDaysAbsolute = (nDaysAbsolute - 1) % 36524;
n4Years = ((nDaysAbsolute + 1) / 1461);
if (n4Years != 0)
n4Day = ((nDaysAbsolute + 1) % 1461);
else
{
bLeap4 = 0;
n4Day = nDaysAbsolute;
}
}
else
{
n4Years = nDaysAbsolute / 1461;
n4Day = nDaysAbsolute % 1461;
}
if (bLeap4)
{
n4Yr = (n4Day - 1) / 365;
if (n4Yr != 0)
n4Day = (n4Day - 1) % 365;
}
else
{
n4Yr = n4Day / 365;
n4Day %= 365;
}
Year = n400Years * 400 + n400Century * 100 + n4Years * 4 + n4Yr;
do
{
if (n4Yr == 0 && bLeap4)
{
if (n4Day == 59)
{
Month = 2;
Day = 29;
break;
}
if (n4Day >= 60)
--n4Day;
}
++n4Day;
for (Month = (n4Day >> 5) + 1;
n4Day > DAYS_IN_YEAR_AT_MONTH_END[Month]; Month++);
Day = (n4Day - DAYS_IN_YEAR_AT_MONTH_END[Month - 1]);
} while (false);
if (Time != 0)
{
Hour = static_cast<int>(Time / MICROSECONDS_PER_HOUR);
Time -= Hour * MICROSECONDS_PER_HOUR;
Minute = static_cast<int>(Time / MICROSECONDS_PER_MINUTE);
Time -= Minute * MICROSECONDS_PER_MINUTE;
Second = static_cast<int>(Time / MICROSECONDS_PER_SECOND);
Time -= Second * MICROSECONDS_PER_SECOND;
if (GetMicroseconds)
MillisecondOrMicrosecond = static_cast<int>(Time);
else
MillisecondOrMicrosecond = static_cast<int>(Time / MICROSECONDS_PER_MILLISECOND);
}
}
DEPRECATED("The DATETIME_TO_YMDHMS is deprecated. Use SCDateTime::GetDateTimeYMDHMS() instead.")
inline void DATETIME_TO_YMDHMS(int64_t DateTime, int& Year, int& Month, int& Day, int& Hour, int& Minute, int& Second)
{
int Millisecond = -1;
DATETIME_TO_YMDHMS_MS(DateTime, Year, Month, Day, Hour, Minute, Second, Millisecond);
}
DEPRECATED("The DATETIME_TO_YMDHMS is deprecated. Use SCDateTime::GetDateTimeYMDHMS() instead.")
inline void DATETIME_TO_YMDHMS(double DateTime, int& Year, int& Month, int& Day, int& Hour, int& Minute, int& Second)
{
DATETIME_TO_YMDHMS(SCDateTimeDoubleToSCDateTime(DateTime), Year, Month, Day, Hour, Minute, Second);
}
DEPRECATED("The YMD_DATE is deprecated. Use SCDateTime::SCDateTime(int Year, int Month, int Day, int Hour, int Minute, int Second).GetDate() instead.")
inline int YMD_DATE(int Year, int Month, int Day)
{
return static_cast<int>(YMDHMS_DATETIME(Year, Month, Day, 0, 0, 0) / MICROSECONDS_PER_DAY);
}
DEPRECATED("The DATE_TO_YMD is deprecated. Use SCDateTime::GetDateYMD() instead.")
inline void DATE_TO_YMD(int Date, int& Year, int& Month, int& Day)
{
int Hour, Minute, Second;
DATETIME_TO_YMDHMS(Date * MICROSECONDS_PER_DAY, Year, Month, Day, Hour, Minute, Second);
}
DEPRECATED("The HMS_TIME is deprecated. Use SCDateTime(int Hour, int Minute, int Second, int Millisecond).GetTime() instead.")
inline int HMS_TIME(int Hour, int Minute, int Second)
{
return (Hour * SECONDS_PER_HOUR + Minute * SECONDS_PER_MINUTE + Second);
}
inline int HMS_TIME_WITH_VALIDATION(int Hour, int Minute, int Second)
{
if (Hour < 0 || Hour > 23 || Minute < 0 || Minute > 59 || Second < 0 || Second > 59)
return 0;
return HMS_TIME(Hour, Minute, Second);
}
inline int HOUR_OF_TIME(int Time)
{
return ((Time / SECONDS_PER_HOUR) % HOURS_PER_DAY);
}
inline int MINUTE_OF_TIME(int Time)
{
return ((Time / SECONDS_PER_MINUTE) % MINUTES_PER_HOUR);
}
inline int SECOND_OF_TIME(int Time)
{
return (Time % SECONDS_PER_MINUTE);
}
DEPRECATED("The TIME_TO_HMS is deprecated. Use SCDateTime::GetTimeHMS() instead.")
inline void TIME_TO_HMS(int Time, int& Hour, int& Minute, int& Second)
{
Hour = HOUR_OF_TIME(Time);
Minute = MINUTE_OF_TIME(Time);
Second = SECOND_OF_TIME(Time);
}
class SCDateTime
{
private:
int64_t m_dt;
public:
SCDateTime();
#ifdef SCDATETIME_SUPPORT_CHRONO
template<typename t_Rep, typename t_Period>
SCDateTime(const std::chrono::duration<t_Rep, t_Period> Duration);
SCDateTime(const std::chrono::system_clock::time_point TimePoint);
#endif
SCDateTime(double DateTime);
SCDateTime(const SCDateTime& DateTime);
SCDateTime(int Date, int TimeInSeconds);
SCDateTime(int Hour, int Minute, int Second, int Millisecond);
SCDateTime(int Year, int Month, int Day, int Hour, int Minute, int Second);
SCDateTime(int Year, int Month, int Day, int Hour, int Minute, int Second, int Millisecond);
void ValidateAsCorrectDateTime();
const SCDateTime& operator = (double dt);
const SCDateTime& operator = (const SCDateTime& DateTime);
const SCDateTime& operator += (double dt);
const SCDateTime& operator += (const SCDateTime& DateTime);
const SCDateTime& operator -= (double dt);
const SCDateTime& operator -= (const SCDateTime& DateTime);
bool operator == (int Date) const;
bool operator != (int Date) const;
bool operator < (int Date) const;
bool operator <= (int Date) const;
bool operator > (int Date) const;
bool operator >= (int Date) const;
bool operator == (double dt) const;
bool operator != (double dt) const;
bool operator < (double dt) const;
bool operator <= (double dt) const;
bool operator > (double dt) const;
bool operator >= (double dt) const;
bool operator == (const SCDateTime& DateTime) const;
bool operator != (const SCDateTime& DateTime) const;
bool operator < (const SCDateTime& DateTime) const;
bool operator <= (const SCDateTime& DateTime) const;
bool operator > (const SCDateTime& DateTime) const;
bool operator >= (const SCDateTime& DateTime) const;
void Clear();
void SetToMaximum();
bool IsMaximum() const;
bool IsUnset() const;
bool IsDateSet() const;
bool IsTimeAtMidnight() const;
void ClearDate();
void SetAsNegative();
int GetDate() const;
int GetDateMS() const;
int GetDateUS() const;
SCDateTime GetDateAsSCDateTime() const;
int GetDays() const;
int GetTime() const;
int GetTimeInSeconds() const;
int GetTimeInMilliseconds() const;
int GetTimeInSecondsWithoutMilliseconds() const;
SCDateTime GetTimeAsSCDateTime() const;
SCDateTime GetTimeAsSCDateTimeMS() const;
double GetTimeAsDouble() const;
SCDateTime GetDateTimeRoundedToSeconds() const;
void GetDateYMD(int& Year, int& Month, int& Day) const;
void GetTimeHMS(int& Hour, int& Minute, int& Second) const;
void GetDateTimeYMDHMS(int& Year, int& Month, int& Day, int& Hour, int& Minute, int& Second) const;
void GetDateTimeYMDHMS_MS(int& Year, int& Month, int& Day, int& Hour, int& Minute, int& Second, int& Millisecond) const;
void GetDateTimeYMDHMS_US(int& Year, int& Month, int& Day, int& Hour, int& Minute, int& Second, int& Microsecond) const;
int GetYear() const;
int GetMonth() const;
int GetDay() const;
int GetHour() const;
int GetMinute() const;
int GetSecond() const;
int GetMicrosecond() const;
int GetMillisecond() const;
int GetDayOfWeek() const;
int GetDayOfWeekMondayBased() const;
SCDateTime& SetToPriorSundayForDateTime(const SCDateTime& OriginalDateTime);
std::int64_t AsMicrosecondsSinceBaseDate() const;
std::int64_t AsMillisecondsSinceBaseDate() const;
std::int64_t AsSecondsSinceBaseDate() const;
std::int64_t GetMillisecondsSinceBaseDate() const;
std::int64_t GetSecondsSinceBaseDate() const;
int GetMinutesSinceBaseDate() const;
int GetHoursSinceBaseDate() const;
int GetDaysSinceBaseDate() const;
int GetWeeksSinceBaseDate() const;
int GetYearsSinceBaseDate() const;
double GetFloatMillisecondsSinceBaseDate() const;
double GetFloatSecondsSinceBaseDate() const;
double GetFloatMinutesSinceBaseDate() const;
double GetFloatHoursSinceBaseDate() const;
double GetFloatDaysSinceBaseDate() const;
double GetFloatWeeksSinceBaseDate() const;
double GetFloatYearsSinceBaseDate() const;
int GetDateDifferenceInDays(const SCDateTime& DateTime) const;
bool IsNegative() const;
SCDateTime GetAbsoluteValue() const;
double GetAsDouble() const;
bool IsWeekend(const bool UseSaturdayData = false) const;
bool IsSaturday() const;
bool IsSunday() const;
bool IsMonday() const;
bool IsGivenTimeWithinGivenTimeRange(const SCDateTime& DateTimeToCompareTo, const SCDateTime& TimeWithin);
int GetBusinessDaysBetweenDates(const SCDateTime& FutureDate) const;
bool IsSameDate(const SCDateTime& DateTime) const;
bool IsSameTimeToHour(const SCDateTime& DateTime) const;
bool IsSameTimeToMinute(const SCDateTime& DateTime) const;
bool IsSameTimeToSecond(const SCDateTime& DateTime) const;
bool IsSameTimeToMillisecond(const SCDateTime& DateTime) const;
void RoundDateTimeDownToMinute();
void RoundDateTimeDownToSecond();
void RoundDateTimeDownToMillisecond();
void RoundToNearestSecond();
void RoundToNearestMillisecond();
SCDateTime& SetDateTimeAsDouble(double DateTime);
SCDateTime& SetDateTime(int Date, int Time);
SCDateTime& SetDate(int Date);
SCDateTime& SetDate(const SCDateTime& Date);
SCDateTime& SetTime(int Time);
SCDateTime& SetTimeFromSCDateTime(const SCDateTime& Time);
SCDateTime& SetDateYMD(int Year, int Month, int Day);
SCDateTime& SetTimeHMS(int Hour, int Minute, int Second);
SCDateTime& SetTimeHMS_MS(int Hour, int Minute, int Second, int Millisecond);
SCDateTime& SetTimeHMS_US(int Hour, int Minute, int Second, int Microsecond);
SCDateTime& SetDateTimeYMDHMS(int Year, int Month, int Day, int Hour, int Minute, int Second);
SCDateTime& SetDateTimeYMDHMS_MS(int Year, int Month, int Day, int Hour, int Minute, int Second, int Millisecond);
SCDateTime& SetDateTimeYMDHMS_US(int Year, int Month, int Day, int Hour, int Minute, int Second, int Microsecond);
SCDateTime& SetFromUNIXTimeInSeconds(time_t UNIXTime);
SCDateTime& SetUNIXTimeWithMilliseconds(double UNIXTime);
SCDateTime& AddNanoseconds(const std::uint64_t Nanoseconds);
SCDateTime& AddMicroseconds(int64_t Microseconds);
SCDateTime& SubtractMicroseconds(int Microseconds);
SCDateTime& AddMilliseconds(int Milliseconds);
SCDateTime& SubtractMilliseconds(int Milliseconds);
SCDateTime& AddSeconds(int Seconds);
SCDateTime& SubtractSeconds(int Seconds);
SCDateTime& AddMinutes(int Minutes);
SCDateTime& SubtractMinutes(int Minutes);
SCDateTime& AddHours(int Hours);
SCDateTime& SubtractHours(int Hours);
SCDateTime& AddDays(int Days);
SCDateTime& SubtractDays(int Days);
SCDateTime& AddYears(int Years);
SCDateTime& SubtractYears(int Years);
SCDateTime& SetDayToLastDayInMonth();
SCDateTime& MultiplyTime(float Multiplier);
time_t ToUNIXTime() const;
double ToFloatUNIXTime() const;
int64_t ToUNIXTimeInMilliseconds() const;
int64_t ToUNIXTimeInMicroseconds() const;
double ToUNIXTimeWithMillisecondsFraction() const;
void SetFromUNIXTimeMilliseconds(int64_t UNIXTimeMilliseconds);
void SetFromUNIXTimeMicroseconds(int64_t UNIXTimeMicroseconds);
void SetFromUnixTimeInDays(const int Days);
void SetFromUNIXTimeMillisecondsFraction(double UNIXTimeMillisecondsFraction);
static SCDateTime GetMinimumDate();
static SCDateTime GetMaximumDate();
static inline SCDateTime YEARS(const int Years)
{
SCDateTime DT;
DT.GetInternalDateTime() = static_cast<int64_t>(ROUND_US(Years * 365.25 * MICROSECONDS_PER_DAY));
return DT;
}
static inline SCDateTime WEEKS(const int Weeks)
{
return DAYS(Weeks * DAYS_PER_WEEK);
}
static inline SCDateTime DAYS(const int Days)
{
SCDateTime DT;
DT.GetInternalDateTime() = Days * MICROSECONDS_PER_DAY;
return DT;
}
static inline SCDateTime HOURS(const int Hours)
{
SCDateTime DT;
DT.GetInternalDateTime() = Hours * MICROSECONDS_PER_HOUR;
return DT;
}
static inline SCDateTime MINUTES(const int Minutes)
{
SCDateTime DT;
DT.GetInternalDateTime() = Minutes * MICROSECONDS_PER_MINUTE;
return DT;
}
static inline SCDateTime SECONDS(const int Seconds)
{
SCDateTime DT;
DT.GetInternalDateTime() = Seconds * MICROSECONDS_PER_SECOND;
return DT;
}
static inline SCDateTime SECONDS_Fraction(const double Seconds)
{
SCDateTime DT;
DT.GetInternalDateTime() = static_cast<int64_t>(ROUND_US(Seconds * MICROSECONDS_PER_SECOND));
return DT;
}
static inline SCDateTime MILLISECONDS(const int Milliseconds)
{
SCDateTime DT;
DT.GetInternalDateTime() = Milliseconds * MICROSECONDS_PER_MILLISECOND;
return DT;
}
static inline SCDateTime MICROSECONDS(const int64_t Microseconds)
{
SCDateTime DT;
DT.GetInternalDateTime() = Microseconds;
return DT;
}
static inline SCDateTime NANOSECONDS(const int64_t Nanoseconds)
{
SCDateTime DT;
DT.GetInternalDateTime() = Nanoseconds / 1000;
return DT;
}
protected:
inline int64_t& GetInternalDateTime()
{
return m_dt;
}
public:
inline int64_t GetInternalDateTime() const
{
return m_dt;
}
inline void SetInternalDateTime(int64_t InternalDateTimeValue)
{
m_dt = InternalDateTimeValue;
}
};
typedef SCDateTime SCDateTimeMS;
inline SCDateTime::SCDateTime()
: m_dt(DATETIME_UNSET)
{
}
#ifdef SCDATETIME_SUPPORT_CHRONO
template<typename t_Rep, typename t_Period>
inline SCDateTime::SCDateTime
( const std::chrono::duration<t_Rep, t_Period> Duration
)
: m_dt(std::chrono::duration_cast<std::chrono::microseconds>(Duration).count())
{
}
inline SCDateTime::SCDateTime
( const std::chrono::system_clock::time_point TimePoint
)
: SCDateTime(TimePoint - SCDATETIME_EPOCH_SYSTEM_CLOCK)
{
}
#endif
inline SCDateTime::SCDateTime(double DateTime)
: m_dt(SCDateTimeDoubleToSCDateTime(DateTime))
{
}
inline SCDateTime::SCDateTime(const SCDateTime& DateTime)
: m_dt(DateTime.m_dt)
{
}
inline SCDateTime::SCDateTime(int Date, int TimeInSeconds)
: m_dt(COMBINE_DATE_TIME_US(Date, TimeInSeconds))
{
}
inline SCDateTime::SCDateTime(int Year, int Month, int Day, int Hour, int Minute, int Second)
: m_dt(YMDHMS_DATETIME(Year, Month, Day, Hour, Minute, Second))
{
}
inline SCDateTime::SCDateTime(int Year, int Month, int Day, int Hour, int Minute, int Second, int Millisecond)
: m_dt(YMDHMS_MS_DATETIME(Year, Month, Day, Hour, Minute, Second, Millisecond))
{
}
inline SCDateTime::SCDateTime(int Hour, int Minute, int Second, int Millisecond)
: m_dt(DATETIME_UNSET)
{
SetTimeHMS_MS(Hour, Minute, Second, Millisecond);
}
inline void SCDateTime::ValidateAsCorrectDateTime()
{
if (IsUnset())
return;
const char UpperByte = (m_dt >> (sizeof(m_dt) - 1) * 8) & 0xFF;
if ((0x3E <= UpperByte && UpperByte <= 0x41) || (-67 <= UpperByte && UpperByte <= -63))
{
*this = SCDateTime(*reinterpret_cast<double*>(&m_dt));
RoundToNearestMillisecond();
}
}
inline const SCDateTime& SCDateTime::operator = (double dt)
{
*this = SCDateTime(dt);
return *this;
}
inline const SCDateTime& SCDateTime::operator = (const SCDateTime& DateTime)
{
m_dt = DateTime.m_dt;
return *this;
}
inline const SCDateTime& SCDateTime::operator += (double dt)
{
*this += SCDateTime(dt);
return *this;
}
inline const SCDateTime& SCDateTime::operator += (const SCDateTime& DateTime)
{
m_dt += DateTime.m_dt;
return *this;
}
inline const SCDateTime& SCDateTime::operator -= (double dt)
{
*this -= SCDateTime(dt);
return *this;
}
inline const SCDateTime& SCDateTime::operator -= (const SCDateTime& DateTime)
{
m_dt -= DateTime.m_dt;
return *this;
}
inline bool SCDateTime::operator == (int Date) const
{
return *this == SCDateTime(Date, 0);
}
inline bool SCDateTime::operator != (int Date) const
{
return *this != SCDateTime(Date, 0);
}
inline bool SCDateTime::operator < (int Date) const
{
return *this < SCDateTime(Date, 0);
}
inline bool SCDateTime::operator <= (int Date) const
{
return *this <= SCDateTime(Date, 0);
}
inline bool SCDateTime::operator > (int Date) const
{
return *this > SCDateTime(Date, 0);
}
inline bool SCDateTime::operator >= (int Date) const
{
return *this >= SCDateTime(Date, 0);
}
inline bool SCDateTime::operator == (double dt) const
{
return *this == SCDateTime(dt);
}
inline bool SCDateTime::operator != (double dt) const
{
return *this != SCDateTime(dt);
}
inline bool SCDateTime::operator < (double dt) const
{
return *this < SCDateTime(dt);
}
inline bool SCDateTime::operator <= (double dt) const
{
return *this <= SCDateTime(dt);
}
inline bool SCDateTime::operator > (double dt) const
{
return *this > SCDateTime(dt);
}
inline bool SCDateTime::operator >= (double dt) const
{
return *this >= SCDateTime(dt);
}
inline bool SCDateTime::operator == (const SCDateTime& DateTime) const
{
return GetInternalDateTime() == DateTime.GetInternalDateTime();
}
inline bool SCDateTime::operator != (const SCDateTime& DateTime) const
{
return !this->operator ==(DateTime);
}
inline bool SCDateTime::operator < (const SCDateTime& DateTime) const
{
return GetInternalDateTime() < DateTime.GetInternalDateTime();
}
inline bool SCDateTime::operator <= (const SCDateTime& DateTime) const
{
return !this->operator >(DateTime);
}
inline bool SCDateTime::operator > (const SCDateTime& DateTime) const
{
return GetInternalDateTime() > DateTime.GetInternalDateTime();
}
inline bool SCDateTime::operator >= (const SCDateTime& DateTime) const
{
return !this->operator <(DateTime);
}
inline void SCDateTime::Clear()
{
m_dt = DATETIME_UNSET;
}
inline void SCDateTime::SetToMaximum()
{
*this = GetMaximumDate();
}
inline bool SCDateTime::IsMaximum() const
{
return GetInternalDateTime() == GetMaximumDate().GetInternalDateTime();
}
inline bool SCDateTime::IsUnset() const
{
return m_dt == DATETIME_UNSET;
}
inline bool SCDateTime::IsDateSet() const
{
return (GetDate() > 0);
}
inline bool SCDateTime::IsTimeAtMidnight() const
{
return GetTimeInSeconds() == 0;
}
inline void SCDateTime::ClearDate()
{
m_dt %= MICROSECONDS_PER_DAY;
}
inline void SCDateTime::SetAsNegative()
{
if (m_dt <= 0)
return;
m_dt = -m_dt;
}
inline int SCDateTime::GetDate() const
{
return DATE_PART_MS(GetInternalDateTime());
}
inline int SCDateTime::GetDateMS() const
{
return DATE_PART_MS(GetInternalDateTime());
}
inline int SCDateTime::GetDateUS() const
{
return static_cast<int>(GetInternalDateTime() / MICROSECONDS_PER_DAY);
}
inline SCDateTime SCDateTime::GetDateAsSCDateTime() const
{
return SCDateTime(GetDate(), 0);
}
inline int SCDateTime::GetDays() const
{
return GetDate();
}
inline int SCDateTime::GetTime() const
{
return TIME_PART_MS(GetInternalDateTime());
}
inline int SCDateTime::GetTimeInSeconds() const
{
return GetTime();
}
inline int SCDateTime::GetTimeInMilliseconds() const
{
int64_t TimeInMilliseconds = 0;
int64_t DateTime = ADJUST_ROUND_MS(m_dt);
DateTime %= MICROSECONDS_PER_DAY;
TimeInMilliseconds = DateTime / MICROSECONDS_PER_MILLISECOND;
if (TimeInMilliseconds >= MILLISECONDS_PER_DAY)
TimeInMilliseconds = 0;
return static_cast<int>(TimeInMilliseconds);
}
inline int SCDateTime::GetTimeInSecondsWithoutMilliseconds() const
{
return TIME_PART_MS(GetInternalDateTime());
}
inline SCDateTime SCDateTime::GetTimeAsSCDateTime() const
{
SCDateTime DateTime = GetAbsoluteValue();
DateTime.m_dt %= MICROSECONDS_PER_DAY;
return DateTime;
}
inline SCDateTime SCDateTime::GetTimeAsSCDateTimeMS() const
{
return GetTimeAsSCDateTime();
}
inline double SCDateTime::GetTimeAsDouble() const
{
return GetTimeAsSCDateTime().GetInternalDateTime() / static_cast<double>(MICROSECONDS_PER_DAY);
}
inline SCDateTime SCDateTime::GetDateTimeRoundedToSeconds() const
{
SCDateTime RoundedDateTime(*this);
RoundedDateTime.m_dt = ADJUST_ROUND_SECOND(RoundedDateTime.m_dt);
RoundedDateTime.m_dt -= RoundedDateTime.m_dt % MICROSECONDS_PER_SECOND;
return RoundedDateTime;
}
inline void SCDateTime::GetDateYMD(int& Year, int& Month, int& Day) const
{
DATE_TO_YMD(GetDate(), Year, Month, Day);
}
inline void SCDateTime::GetTimeHMS(int& Hour, int& Minute, int& Second) const
{
TIME_TO_HMS(GetTime(), Hour, Minute, Second);
}
inline void SCDateTime::GetDateTimeYMDHMS(int& Year, int& Month, int& Day, int& Hour, int& Minute, int& Second) const
{
int Millisecond = 0;
DATETIME_TO_YMDHMS_MS(m_dt, Year, Month, Day, Hour, Minute, Second, Millisecond);
}
inline void SCDateTime::GetDateTimeYMDHMS_MS(int& Year, int& Month, int& Day, int& Hour, int& Minute, int& Second, int& Millisecond) const
{
DATETIME_TO_YMDHMS_MS(m_dt, Year, Month, Day, Hour, Minute, Second, Millisecond);
}
inline void SCDateTime::GetDateTimeYMDHMS_US(int& Year, int& Month, int& Day, int& Hour, int& Minute, int& Second, int& Microsecond) const
{
DATETIME_TO_YMDHMS_MS(m_dt, Year, Month, Day, Hour, Minute, Second, Microsecond, true);
}
inline int SCDateTime::GetYear() const
{
int Year, Month, Day;
GetDateYMD(Year, Month, Day);
return Year;
}
inline int SCDateTime::GetMonth() const
{
int Year, Month, Day;
GetDateYMD(Year, Month, Day);
return Month;
}
inline int SCDateTime::GetDay() const
{
int Year, Month, Day;
GetDateYMD(Year, Month, Day);
return Day;
}
inline int SCDateTime::GetHour() const
{
return HOUR_OF_TIME(GetTime());
}
inline int SCDateTime::GetMinute() const
{
return MINUTE_OF_TIME(GetTime());
}
inline int SCDateTime::GetSecond() const
{
return SECOND_OF_TIME(GetTime());
}
inline int SCDateTime::GetMicrosecond() const
{
return static_cast<int>(GetInternalDateTime() % MICROSECONDS_PER_MILLISECOND);
}
inline int SCDateTime::GetMillisecond() const
{
return MS_PART(GetInternalDateTime());
}
inline int SCDateTime::GetDayOfWeek() const
{
return DAY_OF_WEEK(GetDate());
}
inline int SCDateTime::GetDayOfWeekMondayBased() const
{
return DAY_OF_WEEK_MONDAY_BASED(GetDate());
}
inline SCDateTime& SCDateTime::SetToPriorSundayForDateTime(const SCDateTime& OriginalDateTime)
{
m_dt = OriginalDateTime.GetInternalDateTime();
SetTime(0);
SubtractDays(OriginalDateTime.GetDayOfWeek());
return *this;
}
inline std::int64_t SCDateTime::AsMicrosecondsSinceBaseDate() const
{
return m_dt;
}
inline std::int64_t SCDateTime::AsMillisecondsSinceBaseDate() const
{
return m_dt / MICROSECONDS_PER_MILLISECOND;
}
inline std::int64_t SCDateTime::AsSecondsSinceBaseDate() const
{
return m_dt / MICROSECONDS_PER_SECOND;
}
inline std::int64_t SCDateTime::GetMillisecondsSinceBaseDate() const
{
return static_cast<int64_t>(ADJUST(GetFloatMillisecondsSinceBaseDate()));
}
inline std::int64_t SCDateTime::GetSecondsSinceBaseDate() const
{
return static_cast<int64_t>(ADJUST(GetFloatSecondsSinceBaseDate()));
}
inline int SCDateTime::GetMinutesSinceBaseDate() const
{
return static_cast<int>(ADJUST(GetFloatMinutesSinceBaseDate()));
}
inline int SCDateTime::GetHoursSinceBaseDate() const
{
return static_cast<int>(ADJUST(GetFloatHoursSinceBaseDate()));
}
inline int SCDateTime::GetDaysSinceBaseDate() const
{
return static_cast<int>(ADJUST(GetFloatDaysSinceBaseDate()));
}
inline int SCDateTime::GetWeeksSinceBaseDate() const
{
return static_cast<int>(ADJUST(GetFloatWeeksSinceBaseDate()));
}
inline int SCDateTime::GetYearsSinceBaseDate() const
{
return static_cast<int>(ADJUST(GetFloatYearsSinceBaseDate()));
}
inline double SCDateTime::GetFloatMillisecondsSinceBaseDate() const
{
return static_cast<double>(GetInternalDateTime()) / MICROSECONDS_PER_MILLISECOND;
}
inline double SCDateTime::GetFloatSecondsSinceBaseDate() const
{
return static_cast<double>(GetInternalDateTime()) / MICROSECONDS_PER_SECOND;
}
inline double SCDateTime::GetFloatMinutesSinceBaseDate() const
{
return static_cast<double>(GetInternalDateTime()) / MICROSECONDS_PER_MINUTE;
}
inline double SCDateTime::GetFloatHoursSinceBaseDate() const
{
return static_cast<double>(GetInternalDateTime()) / MICROSECONDS_PER_HOUR;
}
inline double SCDateTime::GetFloatDaysSinceBaseDate() const
{
return static_cast<double>(GetInternalDateTime()) / MICROSECONDS_PER_DAY;
}
inline double SCDateTime::GetFloatWeeksSinceBaseDate() const
{
return static_cast<double>(GetInternalDateTime()) / MICROSECONDS_PER_DAY / DAYS_PER_WEEK;
}
inline double SCDateTime::GetFloatYearsSinceBaseDate() const
{
return static_cast<double>(GetInternalDateTime()) / MICROSECONDS_PER_DAY / DAYS_IN_YEAR;
}
inline int SCDateTime::GetDateDifferenceInDays(const SCDateTime& DateTime) const
{
return GetDate() - DateTime.GetDate();
}
inline bool SCDateTime::IsNegative() const
{
return m_dt < 0;
}
inline SCDateTime SCDateTime::GetAbsoluteValue() const
{
SCDateTime DateTime = *this;
DateTime.m_dt = abs(DateTime.m_dt);
return DateTime;
}
inline double SCDateTime::GetAsDouble() const
{
return SCUNIXTimeToSCDateTime(m_dt);
}
inline bool SCDateTime::IsWeekend(const bool UseSaturdayData) const
{
const int DayOfWeek = GetDayOfWeek();
return ((!UseSaturdayData && DayOfWeek == SATURDAY) || DayOfWeek == SUNDAY);
}
inline bool SCDateTime::IsSaturday() const
{
return (GetDayOfWeek() == SATURDAY);
}
inline bool SCDateTime::IsSunday() const
{
return (GetDayOfWeek() == SUNDAY);
}
inline bool SCDateTime::IsMonday() const
{
return (GetDayOfWeek() == MONDAY);
}
inline bool SCDateTime::IsGivenTimeWithinGivenTimeRange(const SCDateTime& DateTimeToCompareTo, const SCDateTime& TimeWithin)
{
return abs(GetInternalDateTime() - DateTimeToCompareTo.GetInternalDateTime()) <= TimeWithin.GetInternalDateTime();
}
inline int SCDateTime::GetBusinessDaysBetweenDates(const SCDateTime& FutureDate) const
{
if (*this >= FutureDate)
return 0;
int NumberOfBusinessDays = 0;
const int StartDate = GetDate();
const int EndDate = FutureDate.GetDate();
for (int DateValue = StartDate; DateValue < EndDate; DateValue++)
{
const SCDateTime BusinessDayCheck(DateValue, 0);
if (BusinessDayCheck.IsWeekend())
continue;
NumberOfBusinessDays++;
}
return NumberOfBusinessDays;
}
inline bool SCDateTime::IsSameDate(const SCDateTime& DateTime) const
{
return GetDate() == DateTime.GetDate();
}
inline bool SCDateTime::IsSameTimeToHour(const SCDateTime& DateTime) const
{
const int64_t ThisHour = GetInternalDateTime() / MICROSECONDS_PER_HOUR;
const int64_t ThatHour = DateTime.GetInternalDateTime() / MICROSECONDS_PER_HOUR;
return (ThatHour == ThisHour);
}
inline bool SCDateTime::IsSameTimeToMinute(const SCDateTime& DateTime) const
{
const int64_t ThisMinute = GetInternalDateTime() / MICROSECONDS_PER_MINUTE;
const int64_t ThatMinute = DateTime.GetInternalDateTime() / MICROSECONDS_PER_MINUTE;
return (ThatMinute == ThisMinute);
}
inline bool SCDateTime::IsSameTimeToSecond(const SCDateTime& DateTime) const
{
const int64_t ThisSecond = GetInternalDateTime() / MICROSECONDS_PER_SECOND;
const int64_t ThatSecond = DateTime.GetInternalDateTime() / MICROSECONDS_PER_SECOND;
return (ThatSecond == ThisSecond);
}
inline bool SCDateTime::IsSameTimeToMillisecond(const SCDateTime& DateTime) const
{
const int64_t ThisMillisecond = GetInternalDateTime() / MICROSECONDS_PER_MILLISECOND;
const int64_t ThatMillisecond = DateTime.GetInternalDateTime() / MICROSECONDS_PER_MILLISECOND;
return (ThatMillisecond == ThisMillisecond);
}
inline void SCDateTime::RoundDateTimeDownToMinute()
{
m_dt -= m_dt % MICROSECONDS_PER_MINUTE;
}
inline void SCDateTime::RoundDateTimeDownToSecond()
{
m_dt -= m_dt % MICROSECONDS_PER_SECOND;
}
inline void SCDateTime::RoundDateTimeDownToMillisecond()
{
m_dt -= m_dt % MICROSECONDS_PER_MILLISECOND;
}
inline void SCDateTime::RoundToNearestSecond()
{
m_dt = ADJUST_ROUND_SECOND(GetInternalDateTime());
m_dt -= m_dt % MICROSECONDS_PER_SECOND;
}
inline void SCDateTime::RoundToNearestMillisecond()
{
m_dt = ADJUST_ROUND_MS(GetInternalDateTime());
m_dt -= m_dt % MICROSECONDS_PER_MILLISECOND;
}
inline SCDateTime& SCDateTime::SetDateTimeAsDouble(double DateTime)
{
m_dt = SCDateTimeDoubleToSCDateTime(DateTime);
return *this;
}
inline SCDateTime& SCDateTime::SetDateTime(int Date, int Time)
{
m_dt = Date * MICROSECONDS_PER_DAY + Time * MICROSECONDS_PER_SECOND;
return *this;
}
inline SCDateTime& SCDateTime::SetDate(int Date)
{
m_dt %= MICROSECONDS_PER_DAY;
m_dt += Date * MICROSECONDS_PER_DAY;
return *this;
}
inline SCDateTime& SCDateTime::SetDate(const SCDateTime& Date)
{
m_dt %= MICROSECONDS_PER_DAY;
m_dt += Date.m_dt - Date.m_dt % MICROSECONDS_PER_DAY;
return *this;
}
inline SCDateTime& SCDateTime::SetTime(int Time)
{
m_dt += Time * MICROSECONDS_PER_SECOND - m_dt % MICROSECONDS_PER_DAY;
return *this;
}
inline SCDateTime& SCDateTime::SetTimeFromSCDateTime(const SCDateTime& Time)
{
m_dt += Time.m_dt % MICROSECONDS_PER_DAY - m_dt % MICROSECONDS_PER_DAY;
return *this;
}
inline SCDateTime& SCDateTime::SetDateYMD(int Year, int Month, int Day)
{
return SetDate(YMD_DATE(Year, Month, Day));
}
inline SCDateTime& SCDateTime::SetTimeHMS(int Hour, int Minute, int Second)
{
return SetTime(HMS_TIME(Hour, Minute, Second));
}
inline SCDateTime& SCDateTime::SetTimeHMS_MS(int Hour, int Minute, int Second, int Millisecond)
{
SetTimeHMS(Hour, Minute, Second);
m_dt += (Millisecond * MICROSECONDS_PER_MILLISECOND);
return *this;
}
inline SCDateTime& SCDateTime::SetTimeHMS_US(int Hour, int Minute, int Second, int Microsecond)
{
SetTimeHMS(Hour, Minute, Second);
AddMicroseconds(Microsecond);
return *this;
}
inline SCDateTime& SCDateTime::SetDateTimeYMDHMS(int Year, int Month, int Day, int Hour, int Minute, int Second)
{
m_dt = YMDHMS_DATETIME(Year, Month, Day, Hour, Minute, Second);
return *this;
}
inline SCDateTime& SCDateTime::SetDateTimeYMDHMS_MS(int Year, int Month, int Day, int Hour, int Minute, int Second, int Millisecond)
{
m_dt = YMDHMS_MS_DATETIME(Year, Month, Day, Hour, Minute, Second, Millisecond);
return *this;
}
inline SCDateTime& SCDateTime::SetDateTimeYMDHMS_US(int Year, int Month, int Day, int Hour, int Minute, int Second, int Microsecond)
{
m_dt = YMDHMS_DATETIME(Year, Month, Day, Hour, Minute, Second);
AddMicroseconds(Microsecond);
return *this;
}
inline SCDateTime& SCDateTime::SetFromUNIXTimeInSeconds(time_t UNIXTime)
{
m_dt = UNIXTimeToSCDateTimeUNIX(UNIXTime);
return *this;
}
inline SCDateTime& SCDateTime::SetUNIXTimeWithMilliseconds(double UNIXTimeWithMilliseconds)
{
m_dt = UNIXTimeWithMillisecondsToSCDateTimeUNIX(UNIXTimeWithMilliseconds);
return *this;
}
inline SCDateTime& SCDateTime::AddMicroseconds(int64_t Microseconds)
{
m_dt += Microseconds;
return *this;
}
inline SCDateTime& SCDateTime::SubtractMicroseconds(int Microseconds)
{
m_dt -= Microseconds;
return *this;
}
inline SCDateTime& SCDateTime::AddMilliseconds(int Milliseconds)
{
m_dt += Milliseconds * MICROSECONDS_PER_MILLISECOND;
return *this;
}
inline SCDateTime& SCDateTime::SubtractMilliseconds(int Milliseconds)
{
m_dt -= Milliseconds * MICROSECONDS_PER_MILLISECOND;
return *this;
}
inline SCDateTime& SCDateTime::AddSeconds(int Seconds)
{
m_dt += Seconds * MICROSECONDS_PER_SECOND;
return *this;
}
inline SCDateTime& SCDateTime::SubtractSeconds(int Seconds)
{
m_dt -= Seconds * MICROSECONDS_PER_SECOND;
return *this;
}
inline SCDateTime& SCDateTime::AddMinutes(int Minutes)
{
m_dt += Minutes * MICROSECONDS_PER_MINUTE;
return *this;
}
inline SCDateTime& SCDateTime::SubtractMinutes(int Minutes)
{
m_dt -= Minutes * MICROSECONDS_PER_MINUTE;
return *this;
}
inline SCDateTime& SCDateTime::AddHours(int Hours)
{
m_dt += Hours * MICROSECONDS_PER_HOUR;
return *this;
}
inline SCDateTime& SCDateTime::SubtractHours(int Hours)
{
m_dt -= Hours * MICROSECONDS_PER_HOUR;
return *this;
}
inline SCDateTime& SCDateTime::AddDays(int Days)
{
m_dt += Days * MICROSECONDS_PER_DAY;
return *this;
}
inline SCDateTime& SCDateTime::SubtractDays(int Days)
{
m_dt -= Days * MICROSECONDS_PER_DAY;
return *this;
}
inline SCDateTime& SCDateTime::AddYears(int Years)
{
int CurrentYear = 0;
int CurrentMonth = 0;
int CurrentDay = 0;
int CurrentHour = 0;
int CurrentMinute = 0;
int CurrentSecond = 0;
int CurrentMicrosecond = 0;
GetDateTimeYMDHMS_US(CurrentYear, CurrentMonth, CurrentDay, CurrentHour, CurrentMinute, CurrentSecond, CurrentMicrosecond);
CurrentYear += Years;
SetDateTimeYMDHMS_US(CurrentYear, CurrentMonth, CurrentDay, CurrentHour, CurrentMinute, CurrentSecond, CurrentMicrosecond);
return *this;
}
inline SCDateTime& SCDateTime::SubtractYears(int Years)
{
return AddYears(-Years);
}
inline SCDateTime& SCDateTime::SetDayToLastDayInMonth()
{
int Year, Month, Day;
GetDateYMD(Year, Month, Day);
Day = GetDaysInMonth(Month, Year);
SetDateYMD(Year, Month, Day);
return *this;
}
inline SCDateTime& SCDateTime::MultiplyTime(float Multiplier)
{
m_dt = static_cast<int64_t>(ADJUST(m_dt * static_cast<double>(Multiplier)));
return *this;
}
inline time_t SCDateTime::ToUNIXTime() const
{
if (IsUnset())
return 0;
return (time_t)ADJUST(ToFloatUNIXTime());
}
inline double SCDateTime::ToFloatUNIXTime() const
{
if (IsUnset())
return 0.0;
return (m_dt - SCDATETIME_UNIX_EPOCH_DATE * MICROSECONDS_PER_DAY) / static_cast<double>(MICROSECONDS_PER_SECOND);
}
inline int64_t SCDateTime::ToUNIXTimeInMilliseconds() const
{
if (IsUnset())
return 0;
return static_cast<int64_t>(ADJUST((m_dt - SCDATETIME_UNIX_EPOCH_DATE * MICROSECONDS_PER_DAY) / static_cast<double>(MICROSECONDS_PER_MILLISECOND)));
}
inline int64_t SCDateTime::ToUNIXTimeInMicroseconds() const
{
if (IsUnset())
return DATETIME_UNSET;
return m_dt - SCDATETIME_UNIX_EPOCH_DATE * MICROSECONDS_PER_DAY;
}
inline double SCDateTime::ToUNIXTimeWithMillisecondsFraction() const
{
if (IsUnset())
return DATETIME_UNSET_DOUBLE;
return ToUNIXTimeInMilliseconds() / static_cast<double>(MILLISECONDS_PER_SECOND);
}
inline void SCDateTime::SetFromUNIXTimeMilliseconds(int64_t UNIXTimeMilliseconds)
{
if (IS_UNSET(UNIXTimeMilliseconds))
m_dt = DATETIME_UNSET;
else
m_dt = UNIXTimeMilliseconds * MICROSECONDS_PER_MILLISECOND + SCDATETIME_UNIX_EPOCH_DATE * MICROSECONDS_PER_DAY;
}
inline void SCDateTime::SetFromUNIXTimeMicroseconds(int64_t UNIXTimeMicroseconds)
{
if (IS_UNSET(UNIXTimeMicroseconds))
m_dt = DATETIME_UNSET;
else
m_dt = UNIXTimeMicroseconds + SCDATETIME_UNIX_EPOCH_DATE * MICROSECONDS_PER_DAY;
}
inline void SCDateTime::SetFromUnixTimeInDays(const int Days)
{
if (Days != 0)
m_dt = Days * MICROSECONDS_PER_DAY + SCDATETIME_UNIX_EPOCH_DATE * MICROSECONDS_PER_DAY;
else
m_dt = 0;
}
inline void SCDateTime::SetFromUNIXTimeMillisecondsFraction(double UNIXTimeMillisecondsFraction)
{
if (UNIXTimeMillisecondsFraction == 0)
{
m_dt = DATETIME_UNSET;
return;
}
m_dt = static_cast<int64_t>(ADJUST(UNIXTimeMillisecondsFraction * MILLISECONDS_PER_SECOND)) * MICROSECONDS_PER_MILLISECOND + SCDATETIME_UNIX_EPOCH_DATE * MICROSECONDS_PER_DAY;
}
inline SCDateTime SCDateTime::GetMinimumDate()
{
return -0x7FFFFFFFFFFFFFFF / MICROSECONDS_PER_DAY;
}
inline SCDateTime SCDateTime::GetMaximumDate()
{
return 0x7FFFFFFFFFFFFFFF / MICROSECONDS_PER_DAY;
}
inline std::int64_t SCDateTimeToUNIXTimeRemoveMilliseconds(SCDateTime DateTime)
{
DateTime.RoundDateTimeDownToSecond();
return DateTime.ToUNIXTimeInMicroseconds() / MICROSECONDS_PER_SECOND;
}
inline SCDateTime operator + (const SCDateTime& DateTimeA, const SCDateTime& DateTimeB)
{
SCDateTime Result = DateTimeA;
Result += DateTimeB;
return Result;
}
inline SCDateTime operator - (const SCDateTime& DateTimeA, const SCDateTime& DateTimeB)
{
SCDateTime Result = DateTimeA;
Result -= DateTimeB;
return Result;
}
inline bool operator == (int IntDateTime, const SCDateTime& DateTime)
{
return SCDateTime(IntDateTime, 0) == DateTime;
}
inline bool operator != (int IntDateTime, const SCDateTime& DateTime)
{
return SCDateTime(IntDateTime, 0) != DateTime;
}
inline bool operator < (int IntDateTime, const SCDateTime& DateTime)
{
return SCDateTime(IntDateTime, 0) < DateTime;
}
inline bool operator <= (int IntDateTime, const SCDateTime& DateTime)
{
return SCDateTime(IntDateTime, 0) <= DateTime;
}
inline bool operator > (int IntDateTime, const SCDateTime& DateTime)
{
return SCDateTime(IntDateTime, 0) > DateTime;
}
inline bool operator >= (int IntDateTime, const SCDateTime& DateTime)
{
return SCDateTime(IntDateTime, 0) >= DateTime;
}
inline bool operator == (double dt, const SCDateTime& DateTime)
{
return SCDateTime(dt) == DateTime;
}
inline bool operator != (double dt, const SCDateTime& DateTime)
{
return SCDateTime(dt) != DateTime;
}
inline bool operator < (double dt, const SCDateTime& DateTime)
{
return SCDateTime(dt) < DateTime;
}
inline bool operator <= (double dt, const SCDateTime& DateTime)
{
return SCDateTime(dt) <= DateTime;
}
inline bool operator > (double dt, const SCDateTime& DateTime)
{
return SCDateTime(dt) > DateTime;
}
inline bool operator >= (double dt, const SCDateTime& DateTime)
{
return SCDateTime(dt) >= DateTime;
}
inline SCDateTime GetNextMillisecondForSameSecondDateTime(const SCDateTime& PreviousDateTime, SCDateTime NextDateTime)
{
const SCDateTime PreviousDateTimeCopy(PreviousDateTime);
if (PreviousDateTimeCopy.IsSameTimeToSecond(NextDateTime))
{
const int Milliseconds = PreviousDateTimeCopy.GetMillisecond();
if (Milliseconds >= MILLISECONDS_PER_SECOND - 1)
NextDateTime = PreviousDateTimeCopy;
else
NextDateTime = PreviousDateTimeCopy + SCDateTime::MILLISECONDS(1);
}
return NextDateTime;
}
inline SCDateTime GetNextMicrosecondForSameMillisecondDateTime_AllowSkippedMicroseconds(const SCDateTime PreviousDateTime, SCDateTime NextDateTime)
{
if (PreviousDateTime.IsSameTimeToMillisecond(NextDateTime)
&& NextDateTime <= PreviousDateTime)
{
const int Microseconds = PreviousDateTime.GetMicrosecond();
if (Microseconds >= MICROSECONDS_PER_MILLISECOND - 1)
NextDateTime = PreviousDateTime;
else
NextDateTime = PreviousDateTime + SCDateTime::MICROSECONDS(1);
}
return NextDateTime;
}
inline SCDateTime GetNextMicrosecondForSameMillisecondDateTime(const SCDateTime& PreviousDateTime, SCDateTime NextDateTime)
{
if (PreviousDateTime.IsSameTimeToMillisecond(NextDateTime))
{
NextDateTime = PreviousDateTime;
const int Microseconds = PreviousDateTime.GetMicrosecond();
if (Microseconds < MICROSECONDS_PER_MILLISECOND - 1)
NextDateTime.AddMicroseconds(1);
}
return NextDateTime;
}
class SCDateTimeSpan
{
public:
SCDateTime m_TimeSpan;
SCDateTimeSpan SetTimeSpan(const SCDateTime& FirstDateTime, const SCDateTime& SecondDateTime)
{
m_TimeSpan = FirstDateTime;
m_TimeSpan -= SecondDateTime;
return *this;
}
SCDateTime GetTimeSpan() const
{
return m_TimeSpan;
}
SCDateTimeSpan& operator = (double TimeSpan)
{
m_TimeSpan = TimeSpan;
return *this;
}
};
#if SHOW_WARNING_IF_DEPRECATED
# pragma warning(pop)
#endif