xdatetime.cpp

BCB的学习资料

//---------------------------------------------------------------------------


#pragma hdrstop

#include "XDateTime.h"
#include <XExcepMsg.h>
//---------------------------------------------------------------------------
#pragma package(smart_init)
namespace zdhsoft
{

//定义常量
const int   MAX_MILLIS_PRE_DAY   = 86400000;
const XLong MAX_MILLIS_PRE_DAY64 = 86400000i64;
const XInt  MAX_DAYS             = 3652060;
//const XLong MAX_MILLIS           = 315537984000000i64;
const int   MILLIS_PRE_HOUR      = 3600000;
const int   MILLIS_PRE_MINUTE    = 60000;
const int   MILLIS_PRE_SECOND    = 1000;

//全部函数　
bool IsRawYear(int aYear)
{
    if( aYear<0 || aYear > 9999 )
    {
        throw XEDateTimeError(DATETIME_INVALIDATION_YEAR,aYear);
    }
    bool bFlag=false;
    if( aYear%4==0 ) {
        bFlag=true; //如果被4整除,是闰年
        if( aYear%100==0 ){
            bFlag=false; //如果被4整除且被100整除,不是闰年
            if( aYear%400==0 ){
                bFlag=true; //如果被4整除且被100整除，但又被400整除,是闰年
            }
        }
    }
    return bFlag;
}
int GetMonthDays(int aYear,int aMonth)
{
    static int MonthDays[] = {31,28,31,30,31,30,31,31,30,31,30,31};
    if( aMonth == 2 ){
        if( IsRawYear(aYear) ) return MonthDays[1]+1;
        else return MonthDays[1];
    }
    else return MonthDays[aMonth-1];
}
//如果是无效的年月日，则返回-1
int GetDays(int aYear,int aMonth,int aDay)
{
    if( aYear<1 || aYear > 9999 ) return -1;
    if( aMonth<1 || aMonth > 12 ) return -1;
    int aMonthDay = GetMonthDays( aYear, aMonth );
    if( aDay <1 || aDay > aMonthDay ) return -1;
    int Days=0;
    for(int i=1;i<aMonth;i++)
    {
        Days += GetMonthDays(aYear,i);
    }
    aYear--;
    Days += ( (aYear*365) + (aYear/4) - (aYear/100) + (aYear/400));
    Days += aDay;
    return Days;
}
//------------------------------------------------------------------------------
void XTime::SetHour(int v)
{
    if( v < 0 || v > 23 )  throw XEDateTimeError(DATETIME_INVALIDATION_HOUR,v);
    m_Hour = (XByte)v;
}
void XTime::SetMinute(int v)
{
    if( v < 0 || v > 59 ) throw XEDateTimeError(DATETIME_INVALIDATION_MINUTE,v);
    m_Minute = (XByte)v;
}
void XTime::SetSecond(int v)
{
    if( v < 0 || v > 59 ) throw XEDateTimeError(DATETIME_INVALIDATION_SECOND,v);
    m_Second = (XByte)v;
}
void XTime::SetMillis(int v)
{
    if( v < 0 || v > 999 ) throw XEDateTimeError(DATETIME_INVALIDATION_MILLIS,v);
    m_Millis = (XWord)v;
}
XTime::XTime(const XTime &aTime)
    :m_Hour(aTime.m_Hour),
     m_Minute(aTime.m_Minute),
     m_Second(aTime.m_Second),
     m_Millis(aTime.m_Millis)
{
}
XTime::XTime(const XLongTime & aTime)
{
    aTime.Decode( *this );
}
XTime::XTime(const XDateTime & aDateTime)
{
    aDateTime.DecodeTime( *this );
}
XTime::XTime(int aHour,int aMinute,int aSecond,int aMillis)
{
    SetTime(aHour,aMinute,aSecond,aMillis);
}
XTime::XTime(const TDateTime & aDateTime)
{
    XWord aHour,aMinute,aSecond,aMillis;
    aDateTime.DecodeTime( &aHour,&aMinute,&aSecond,&aMillis);
    m_Hour   = (XByte)aHour;
    m_Minute = (XByte)aMinute;
    m_Second = (XByte)aSecond;
    m_Millis = aMillis;
}
XTime::~XTime()
{
}
XTime & XTime::operator=(const XTime &aTime)
{
    m_Hour = aTime.m_Hour;
    m_Minute = aTime.m_Minute;
    m_Second = aTime.m_Second;
    m_Millis = aTime.m_Millis;
    return *this;
}
void XTime::SetTime(int aHour,int aMinute,int aSecond,int aMillis)
{
    if( aHour < 0 || aHour > 23 )       throw XEDateTimeError(DATETIME_INVALIDATION_HOUR,aHour);
    if( aMinute < 0 || aMinute > 59 )   throw XEDateTimeError(DATETIME_INVALIDATION_MINUTE,aMinute);
    if( aSecond < 0 || aSecond > 59 )   throw XEDateTimeError(DATETIME_INVALIDATION_SECOND,aSecond);
    if( aMillis < 0 || aMillis > 999 )  throw XEDateTimeError(DATETIME_INVALIDATION_MILLIS,aMillis);
    m_Hour = (XByte)aHour;
    m_Minute = (XByte)aMinute;
    m_Second = (XByte)aSecond;
    m_Millis = (XWord)aMillis;
}
void XTime::SetTime(const XTime & aTime)
{
    m_Hour = aTime.m_Hour;
    m_Minute = aTime.m_Minute;
    m_Second = aTime.m_Second;
    m_Millis = aTime.m_Millis;
}
void XTime::SetTime(const XLongTime & aLongTime)
{
    aLongTime.Decode( *this );
}
void XTime::SetTime(const XDateTime & aDateTime)
{
    aDateTime.DecodeTime( *this );
}
void XTime::SetTime(const TDateTime & aDateTime)
{
    XWord aHour,aMinute,aSecond,aMillis;
    aDateTime.DecodeTime( &aHour, &aMinute, &aSecond, &aMillis );
    m_Hour   = aHour;
    m_Minute = aMinute;
    m_Second = aSecond;
    m_Millis = aMillis;
}
AnsiString XTime::ToString() const
{
    AnsiString strTime;
    strTime.printf("%02d:%02d:%02d.%03d",GetHour(),GetMinute(),GetSecond(),GetMillis());
    return strTime;
}
//---------------------------------------------------------------------------
XLongTime::XLongTime(XInt aLongTime )
    :m_LongTime(RoundTime(aLongTime))
{}
XLongTime::XLongTime(int aHour,int aMinute,int aSecond,int aMillis)
    :m_LongTime( CalcLongTime(aHour,aMinute,aSecond,aMillis) )
{}
XLongTime::XLongTime(const XTime & aTime)
    :m_LongTime(CalcLongTime(aTime))
{}
XLongTime::XLongTime(const XLongTime & aLongTime)
    :m_LongTime(aLongTime.m_LongTime)
{
}
XLongTime::XLongTime(const XDateTime & aDateTime)
    :m_LongTime(CalcLongTime( aDateTime ))
{}
XLongTime::XLongTime(const TDateTime & aDateTime)
    :m_LongTime(CalcLongTime( aDateTime ))
{}
XLongTime::~XLongTime()
{
}
XInt XLongTime::RoundTime(XInt aLongTime) //OK
{
    XInt tmp = aLongTime % MAX_MILLIS_PRE_DAY;
    if( tmp < 0 ) tmp += MAX_MILLIS_PRE_DAY;
    return tmp;
}
XInt XLongTime::CalcLongTime(const XTime & aTime) //OK
{
    return ((aTime.GetHour() * 60 + aTime.GetMinute()) * 60 + aTime.GetSecond()) * 1000 + aTime.GetMillis();
}
XInt XLongTime::CalcLongTime(const TDateTime & aDateTime) //OK
{
    XWord aHour,aMinute,aSecond,aMillis;
    aDateTime.DecodeTime(&aHour,&aMinute,&aSecond,&aMillis);
    return ((aHour * 60 + aMinute) * 60 + aSecond) * 1000 + aMillis;
}
XInt XLongTime::CalcLongTime(int aHour,int aMinute,int aSecond,int aMillis) //OK
{
    if( aHour < 0 || aHour > 23 )       throw XEDateTimeError(DATETIME_INVALIDATION_HOUR,aHour);
    if( aMinute < 0 || aMinute > 59 )   throw XEDateTimeError(DATETIME_INVALIDATION_MINUTE,aMinute);
    if( aSecond < 0 || aSecond > 59 )   throw XEDateTimeError(DATETIME_INVALIDATION_SECOND,aSecond);
    if( aMillis < 0 || aMillis > 999 )  throw XEDateTimeError(DATETIME_INVALIDATION_MILLIS,aMillis);
    return ((aHour * 60 + aMinute) * 60 + aSecond) * 1000 + aMillis;
}
XInt XLongTime::CalcLongTime(const XDateTime & aDateTime)
{
    return (XInt)(aDateTime.GetDateTime() % MAX_MILLIS_PRE_DAY64);
}

XLongTime & XLongTime::operator=(const XTime & aTime)
{
    SetLongTime( aTime );
    return *this;
}
XLongTime & XLongTime::operator=(const XLongTime & aLongTime)
{
    SetLongTime( aLongTime );
    return *this;
}
XLongTime & XLongTime::operator=(const XDateTime & aDateTime)
{
    SetLongTime( aDateTime );
    return *this;
}
XLongTime & XLongTime::operator=(const TDateTime & aDateTime)
{
    SetLongTime( aDateTime );
    return *this;
}
XLongTime & XLongTime::operator=(const XInt & aLongTime)
{
    SetLongTime( aLongTime );
    return *this;
}

XLongTime & XLongTime::operator++()
{
    m_LongTime = RoundTime( m_LongTime + 1 );
    return *this;
}
XLongTime XLongTime::operator++(int)
{
    XLongTime aLongTime(*this);
    m_LongTime = RoundTime( m_LongTime + 1 );
    return aLongTime;
}
//operator--
XLongTime & XLongTime::operator--()
{
    m_LongTime = RoundTime( m_LongTime - 1 );
    return *this;
}
XLongTime XLongTime::operator--(int)
{
    XLongTime aLongTime(*this);
    m_LongTime = RoundTime( m_LongTime - 1 );
    return aLongTime;
}

XLongTime XLongTime::operator-(const XLongTime & aLongTime) const
{
    return XLongTime( m_LongTime - aLongTime.m_LongTime );
}
XLongTime XLongTime::operator-(XInt aLongTime) const
{
    return XLongTime( m_LongTime - aLongTime );
}
XLongTime XLongTime::operator-(const XTime &aTime) const
{
    return XLongTime( m_LongTime - CalcLongTime(aTime) );
}
XLongTime XLongTime::operator-(const XDateTime &aDateTime) const
{
    return XLongTime( m_LongTime - CalcLongTime(aDateTime) );
}
XLongTime XLongTime::operator-(const TDateTime &aDateTime) const
{
    return XLongTime( m_LongTime - CalcLongTime(aDateTime) );
}

XLongTime XLongTime::operator+(const XLongTime & aLongTime) const
{
    return XLongTime( m_LongTime + aLongTime.m_LongTime );
}
XLongTime XLongTime::operator+(XInt aLongTime) const
{
    return XLongTime( m_LongTime + aLongTime );
}
XLongTime XLongTime::operator+(const XTime &aTime) const
{
    return XLongTime( m_LongTime + CalcLongTime(aTime) );
}
XLongTime XLongTime::operator+(const XDateTime &aDateTime) const
{
    return XLongTime( m_LongTime + CalcLongTime(aDateTime) );
}
XLongTime XLongTime::operator+(const TDateTime &aDateTime) const
{
    return XLongTime( m_LongTime + CalcLongTime(aDateTime) );
}
XLongTime & XLongTime::operator+= (const XLongTime & aLongTime)
{
    m_LongTime = RoundTime( m_LongTime + aLongTime.m_LongTime );
    return *this;
}
XLongTime & XLongTime::operator+= (XInt aLongTime)
{
    m_LongTime = RoundTime( m_LongTime + aLongTime );
    return *this;
}
XLongTime & XLongTime::operator+= (const XDateTime &aDateTime)
{
    m_LongTime = RoundTime( m_LongTime + CalcLongTime(aDateTime) );
    return *this;
}
XLongTime & XLongTime::operator+= (const TDateTime &aDateTime)
{
    m_LongTime = RoundTime( m_LongTime + CalcLongTime(aDateTime) );
    return *this;
}
XLongTime & XLongTime::operator+= (const XTime &aTime)
{
    m_LongTime = RoundTime( m_LongTime + CalcLongTime(aTime) );
    return *this;
}
//operator-=
XLongTime & XLongTime::operator-= (const XLongTime & aLongTime)
{
    m_LongTime = RoundTime( m_LongTime - aLongTime.m_LongTime );
    return *this;
}
XLongTime & XLongTime::operator-= (XInt aLongTime)
{
    m_LongTime = RoundTime( m_LongTime - aLongTime );
    return *this;
}
XLongTime & XLongTime::operator-= (const XDateTime &aDateTime)
{
    m_LongTime = RoundTime( m_LongTime - CalcLongTime(aDateTime) );
    return *this;
}
XLongTime & XLongTime::operator-= (const TDateTime &aDateTime)
{
    m_LongTime = RoundTime( m_LongTime - CalcLongTime(aDateTime) );
    return *this;
}
XLongTime & XLongTime::operator-= (const XTime &aTime)
{
    m_LongTime = RoundTime( m_LongTime - CalcLongTime(aTime) );
    return *this;
}
//operator==
bool XLongTime::operator==(const XLongTime & aLongTime) const
{
    return m_LongTime == aLongTime.m_LongTime;
}
bool XLongTime::operator==(XInt aLongTime) const
{
    return m_LongTime == RoundTime(aLongTime);
}
bool XLongTime::operator==(const XDateTime &aDateTime) const
{
    return m_LongTime == CalcLongTime(aDateTime);
}
bool XLongTime::operator==(const TDateTime &aDateTime) const
{
    return m_LongTime == CalcLongTime(aDateTime);
}
bool XLongTime::operator==(const XTime &aTime) const
{
    return m_LongTime == CalcLongTime(aTime);
}
//operator!=
bool XLongTime::operator!=(const XLongTime & aLongTime) const
{
    return m_LongTime != aLongTime.m_LongTime;
}
bool XLongTime::operator!=(XInt aLongTime) const
{
    return m_LongTime != RoundTime(aLongTime);
}
bool XLongTime::operator!=(const XDateTime &aDateTime) const
{
    return m_LongTime != CalcLongTime(aDateTime);
}
bool XLongTime::operator!=(const TDateTime &aDateTime) const
{
    return m_LongTime != CalcLongTime(aDateTime);
}
bool XLongTime::operator!=(const XTime &aTime) const
{
    return m_LongTime != CalcLongTime(aTime);
}
//operator>=
bool XLongTime::operator>=(XInt aLongTime) const
{
    return m_LongTime >= RoundTime(aLongTime);
}
bool XLongTime::operator>=(const XLongTime & aLongTime) const
{
    return m_LongTime >= aLongTime.m_LongTime;
}
bool XLongTime::operator>=(const XDateTime &aDateTime) const
{
    return m_LongTime >= CalcLongTime(aDateTime);
}
bool XLongTime::operator>=(const TDateTime &aDateTime) const
{
    return m_LongTime >= CalcLongTime(aDateTime);
}
bool XLongTime::operator>=(const XTime &aTime) const
{
    return m_LongTime >= CalcLongTime(aTime);
}
//operator<=
bool XLongTime::operator<=(const XLongTime & aLongTime) const
{
    return m_LongTime <= aLongTime.m_LongTime;
}
bool XLongTime::operator<=(XInt aLongTime) const
{
    return m_LongTime <= RoundTime(aLongTime);
}
bool XLongTime::operator<=(const XDateTime &aDateTime) const
{
    return m_LongTime <= CalcLongTime(aDateTime);
}
bool XLongTime::operator<=(const TDateTime &aDateTime) const
{
    return m_LongTime <= CalcLongTime(aDateTime);
}
bool XLongTime::operator<=(const XTime &aTime) const
{