VC知识库BLOG-大浪淘沙

#ifndef AS_TIME_H
#define AS_TIME_H

#include "astype.h"

AS_SPACE
///////////////////////////////////////////////////////////////////////////////

typedef enum en_weekday
{
?Sunday = 0,
?Monday,
?Tuesday,
?Wednesday,
?Thursday,
?Friday,
?Saturday
} t_weekday;

typedef enum en_month
{
?January = 1,
?February,
?March,
?April,
?May,
?June,
?July,
?August,
?September,
?October,
?November,
?December
} t_month;

#define AS_TM_SECMS??(1000)
#define AS_TM_MINMS??(60 * (t_lint)AS_TM_SECMS)
#define AS_TM_HOURMS?(60 * (t_lint)AS_TM_MINMS)
#define AS_TM_DAYMS??(24 * (t_int64)AS_TM_HOURMS)
#define AS_TM_WEEKMS?(7 * AS_TM_DAYMS)

class Time
{
public:
?Time(){ m_ms = 0; }
?Time(t_int year, t_int month, t_int monthday, t_int hour, t_int minute,
?? t_int second, t_int millisec)
???{ SetTime(year, month, monthday, hour, minute, second, millisec); }
?Time(t_int64 days, t_int64 hours, t_int64 minutes, t_int64 seconds, t_int64 millisecs)
???{ SetElapse(days, hours, minutes, seconds, millisecs); }
?explicit Time(t_int64 ms): m_ms(ms){}
?~Time(){}
?Time(const Time &t);
?Time & operator=(const Time &t);
public:
?void Current();
?void SetTime(t_int year, t_int month, t_int monthday, t_int hour,
???? t_int minute, t_int second, t_int millisec);
?void SetElapse(?t_int64 days, t_int64 hours, t_int64 minutes, t_int64 seconds,
?????t_int64 millisecs);
public:
?t_int GetYear() const;
?t_bool IsLeepYear() const????{ return IsLeepYear(GetYear()); }
?t_int GetMonth() const;
?t_int GetYearDay() const;
?t_int GetMonthDay() const;
?t_int GetWeekDay() const????{ return t_weekday((GetDaysElapse() + 1) % 7); }
?t_int GetHour() const?????{ return t_int(GetHoursElapse() % 24); }
?t_int GetMinute() const?????{ return t_int(GetMinutesElapse() % 60); }
?t_int GetSecond() const?????{ return t_int(GetSecondsElapse() % 60); }
?t_int GetMillisecond() const???{ return t_int(m_ms % 1000); }
public:
?t_int64 GetWeeksElapse() const???{ return m_ms / AS_TM_WEEKMS; }
?t_int64 GetDaysElapse() const???{ return m_ms / AS_TM_DAYMS; }
?t_int64 GetHoursElapse() const???{ return m_ms / AS_TM_HOURMS; }
?t_int64 GetMinutesElapse() const??{ return m_ms / AS_TM_MINMS; }
?t_int64 GetSecondsElapse() const??{ return m_ms / AS_TM_SECMS; }
?t_int64 GetMillisecondsElapse() const?{ return m_ms; }
public:
?operator t_int64() const????{ return m_ms; }
?operator t_int64 &()?????{ return m_ms; }
private:
?t_int64 m_ms;
public:
?static t_bool IsLeepYear(t_int year);
?static t_int GetYearDay(t_int year, t_int month, t_int monthday);
private:
?static t_int64 GetDaysElapseBeforeYear(t_int year);
};

///////////////////////////////////////////////////////////////////////////////
AS_SPACE_END
#endif
// ! astime.h

#include "../include/astime.h"
#include "../include/asassert.h"
#include

AS_SPACE
///////////////////////////////////////////////////////////////////////////////

const t_int g_melapse[] = { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 };

void Time::Current()
{
?time_t t;
?time(&t);
?struct tm *ptm = localtime(&t);
?SetTime(ptm->tm_year + 1900, ptm->tm_mon + 1, ptm->tm_mday, ptm->tm_hour,
???ptm->tm_min, ptm->tm_sec, 0);
}

void Time::SetTime(t_int year, t_int month, t_int monthday, t_int hour,
?????? t_int minute, t_int second, t_int millisec)
{
?SetElapse(GetDaysElapseBeforeYear(year) + GetYearDay(year, month, monthday) - 1,
???? hour, minute, second, millisec);
}

void Time::SetElapse(t_int64 days, t_int64 hours, t_int64 minutes, t_int64 seconds,
????? t_int64 millisecs)
{
?m_ms = millisecs;
?m_ms += seconds * AS_TM_SECMS;
?m_ms += minutes * AS_TM_MINMS;
?m_ms += hours * AS_TM_HOURMS;
?m_ms += days * AS_TM_DAYMS;
}

t_int Time::GetYear() const
{
?t_int64 days = GetDaysElapse();
?t_int year = t_int(days / 365 + 1);
?while(GetDaysElapseBeforeYear(year) > days)
??year--;
?return year;
}

t_int Time::GetYearDay() const
{
?return t_int(GetDaysElapse() - GetDaysElapseBeforeYear(GetYear()));
}

t_int Time::GetMonth() const
{
?t_int64 yday = GetYearDay();
?if(365 == yday)
??return 12;
?for(t_int month = 11; month > 0 && g_melapse[month] > yday; month--);
?if(yday == g_melapse[month] && 2 <= month && IsLeepYear())
??return month;
?else
??return ++month;
}

t_int Time::GetMonthDay() const
{
?t_int yday = GetYearDay();
?t_int month = GetMonth();
?if(2 < month && IsLeepYear())
??yday--;
?return yday - g_melapse[--month] + 1;
}

///////////////////////////////////////////////////////////////////////////////

t_bool Time::IsLeepYear(t_int year)
{
?AS_ASSERT(0 < year);
?return AS_BOOL(0 == year % 4 && 0 != year % 100 || 0 == year % 400);
}

t_int Time::GetYearDay(t_int year, t_int month, t_int monthday)
{
?AS_ASSERT(0 < year);
?AS_ASSERT(1 <= month && month <= 12);
?AS_ASSERT(0 < monthday && monthday < 32);

?if(2 < month && IsLeepYear(year))
??monthday++;
?return monthday + g_melapse[--month];
}

t_int64 Time::GetDaysElapseBeforeYear(t_int year)
{
?AS_ASSERT(0 < year);
?t_int64 days = t_int64(--year) * 365;
?days += year / 4;
?days -= year / 100;
?days += year / 400;
?return days;
}

///////////////////////////////////////////////////////////////////////////////
AS_SPACE_END
// ! astime.cpp

--------------------next---------------------