Deliver/include/Log4CPP/Common.Include/DDateTime.hpp

#pragma once


#include <locale>


typedef double DATE;


#include "String.DString.hpp"
#include "String.WString.hpp"
using namespace eSTR::Literals;



#ifndef DATETIME_EXPORTS
#define _DateTime_API	_declspec(dllimport)
#else
#define _DateTime_API	_declspec(dllexport)
#endif




#ifndef DATETIME_EXPORTS

#ifdef _WIN64

#ifdef _DEBUG
#pragma comment (lib, "ECOM.Utility.DateTime64D.lib") 
#else
#pragma comment (lib, "ECOM.Utility.DateTime64.lib") 
#endif

#else	//	X86

#ifdef _DEBUG
#pragma comment (lib, "ECOM.Utility.DateTimeD.lib") 
#else
#pragma comment (lib, "ECOM.Utility.DateTime.lib") 
#endif

#endif

#endif  //  DATETIME_EXPORTS



//-----------------------------------------------------------------------------
//		DDateTime class helpers
//-----------------------------------------------------------------------------

#define DDATETIME_ERROR (-1)
#define DDATETIME_HALFSECOND (1.0 / (2.0 * (60.0 * 60.0 * 24.0)))


namespace ECOM::Utility
{

	class DDateTimeSpan;


	//-----------------------------------------------------------------------------
	//		DDateTime
	//-----------------------------------------------------------------------------

	class _DateTime_API DDateTime
	{
	// Constructors
	public:
		static DDateTime Current ();

	public:
		DDateTime ();
		DDateTime (const DDateTime & dateSrc);
		DDateTime (DATE dtSrc);
		DDateTime (time_t timeSrc);
		DDateTime (int nYear, int nMonth, int nDay, int nHour, int nMin, int nSec);
		DDateTime (CV_String & strDate, CV_String & strTime);
		DDateTime (CV_String & strDateTime);
		DDateTime (WORD wDosDate, WORD wDosTime, int nDST);

	// Attributes
	public:
		enum DateTimeStatus
		{
			valid = 0,
			invalid = 1,    // Invalid date (out of range, etc.)
			null = 2,       // Literally has no value
		};

		DATE m_dt;
		DateTimeStatus m_status;

		void SetStatus (DateTimeStatus status);
		DateTimeStatus GetStatus () const;

	// Operations
	public:
		const DDateTime & operator = (const DDateTime & dateSrc);
		const DDateTime & operator = (DATE dtSrc);
		const DDateTime & operator = (const time_t & timeSrc);

		bool operator == (const DDateTime & date) const;
		bool operator != (const DDateTime & date) const;
		bool operator <  (const DDateTime & date) const;
		bool operator >  (const DDateTime & date) const;
		bool operator <= (const DDateTime & date) const;
		bool operator >= (const DDateTime & date) const;

	public:
		// DateTime math
		DDateTime operator + (const DDateTimeSpan & dateSpan) const;
		DDateTime operator - (const DDateTimeSpan & dateSpan) const;
		const DDateTime & operator += (const DDateTimeSpan dateSpan);
		const DDateTime & operator -= (const DDateTimeSpan dateSpan);

		// DateTimeSpan math
		DDateTimeSpan operator - (const DDateTime & date) const;

		operator DATE () const;

	public:
		bool IsSunday ()	const { return (GetDayOfWeek () == 1); }
		bool IsMonday ()	const { return (GetDayOfWeek () == 2); }
		bool IsTuesday ()	const { return (GetDayOfWeek () == 3); }
		bool IsWednesday () const { return (GetDayOfWeek () == 4); }
		bool IsThursday ()	const { return (GetDayOfWeek () == 5); }
		bool IsFriday ()	const { return (GetDayOfWeek () == 6); }
		bool IsSaturday ()	const { return (GetDayOfWeek () == 7); }

	public:
		int  SetDate (int nYear, int nMonth, int nDay);
		int  SetTime (int nHour, int nMin, int nSec);

		//	保留时间不变,但是日期用 DateStr 中的日期
		int  SetDate (CV_String & DateStr);
		//	保留日期不变,但是时间设置为 TimeStr 中的日期
		int  SetTime (CV_String & TimeStr);

		int  SetDateTime (CV_String & DateStr, CV_String & TimeStr);

		//	 各个参数的值的范围, 与下面的 GetXX () 相同: 注意只有 月份是从 1 开始的
		int  SetDateTime (int nYear, int nMonth, int nDay, int nHour, int nMin, int nSec);

	public:
		int  GetYear		()	const;
		int  GetMonth		()	const;		// month of year (1 = Jan)
		int  GetDay			()	const;		// day of month (0-31)
		int  GetHour		()	const;		// hour in day (0-23)
		int  GetMinute		()	const;		// minute in hour (0-59)
		int  GetSecond		()	const;		// second in minute (0-59)
		int  GetDayOfWeek	()  const;		// 1=Sun, 2=Mon, ..., 7=Sat
		int  GetDayOfYear	()  const;		// days since start of year, Jan 1 = 1

	public:
		void SetYear	(int v)	;
		void SetMonth	(int v)	;		// month of year (1 = Jan)
		void SetDay		(int v)	;		// day of month (0-31)
		void SetHour	(int v)	;		// hour in day (0-23)
		void SetMinute	(int v)	;		// minute in hour (0-59)
		void SetSecond	(int v)	;		// second in minute (0-59)

	public:
		// formatting
		eSTR::DString Format (CV_String & szFormat) const;
		eSTR::DString dtFormat (CV_String & szFormat) const { return Format (szFormat); }

	//	接受这种格式 yyyy-mm-dd, HH:MM::SS
		eSTR::DString ToString (CV_String & szFormat) const;

		eSTR::DString FormatDate (void) const;
		eSTR::DString FormatTime (void) const;
		eSTR::DString FormatDateTime (void) const;

		eSTR::WString ToLocalString (_locale_t loc, CV_WString & szFormat) const;

	// Implementation
	protected:
		void CheckRange ();
		friend class DDateTimeSpan;
	};


	//-----------------------------------------------------------------------------
	//		DDateTimeSpan
	//-----------------------------------------------------------------------------

	class _DateTime_API DDateTimeSpan
	{
	// Constructors
	public:
		DDateTimeSpan ();

		DDateTimeSpan (double dblSpanSrc);
		DDateTimeSpan (const DDateTimeSpan & dateSpanSrc);
		DDateTimeSpan (long lDays, int nHours, int nMins, int nSecs);
		DDateTimeSpan (CV_String & SpanString);

	// Attributes
	public:
		enum DateTimeSpanStatus
		{
			valid = 0,
			invalid = 1,    // Invalid span (out of range, etc.)
			null = 2,       // Literally has no value
		};

		double m_span;
		DateTimeSpanStatus m_status;

		void SetStatus (DateTimeSpanStatus status);
		DateTimeSpanStatus GetStatus () const;

		double GetTotalDays () const;    // span in days (about -3.65e6 to 3.65e6)
		double GetTotalHours () const;   // span in hours (about -8.77e7 to 8.77e6)
		double GetTotalMinutes () const; // span in minutes (about -5.26e9 to 5.26e9)
		double GetTotalSeconds () const; // span in seconds (about -3.16e11 to 3.16e11)

		long GetDays ()    const;		// component days in span
		long GetHours ()   const;		// component hours in span (-23 to 23)
		long GetMinutes () const;		// component minutes in span (-59 to 59)
		long GetSeconds () const;		// component seconds in span (-59 to 59)

	// Operations
	public:
		const DDateTimeSpan & operator = (double dblSpanSrc);
		const DDateTimeSpan & operator = (const DDateTimeSpan & dateSpanSrc);

		bool operator == (const DDateTimeSpan & dateSpan) const;
		bool operator != (const DDateTimeSpan & dateSpan) const;
		bool operator <  (const DDateTimeSpan & dateSpan) const;
		bool operator >  (const DDateTimeSpan & dateSpan) const;
		bool operator <= (const DDateTimeSpan & dateSpan) const;
		bool operator >= (const DDateTimeSpan & dateSpan) const;

		// DateTimeSpan math
		DDateTimeSpan operator + (const DDateTimeSpan & dateSpan) const;
		DDateTimeSpan operator - (const DDateTimeSpan & dateSpan) const;
		const DDateTimeSpan & operator += (const DDateTimeSpan dateSpan);
		const DDateTimeSpan & operator -= (const DDateTimeSpan dateSpan);
		DDateTimeSpan operator - () const;

		operator double () const;

		void SetDateTimeSpan (long lDays, int nHours, int nMins, int nSecs);

		// formatting
		eSTR::DString Format   (CV_String & szFormat) const;
		eSTR::DString ToString (CV_String & szFormat) const
		{
			return Format (szFormat);
		}

	// Implementation
	public:
		void CheckRange ();
		friend class DDateTime;
	};


	// DDateTime
	__inline DDateTime::DDateTime ()
		{ m_dt = 0; SetStatus (valid); }

	__inline DDateTime::DDateTime (const DDateTime & dateSrc)
		{ m_dt = dateSrc.m_dt; m_status = dateSrc.m_status; }

	__inline DDateTime::DDateTime (DATE dtSrc)
		{ m_dt = dtSrc; SetStatus (valid); }

	__inline DDateTime::DDateTime (time_t timeSrc)
		{ *this = timeSrc; }

	__inline DDateTime::DDateTime (int nYear, int nMonth, int nDay, int nHour, int nMin, int nSec)
		{ SetDateTime (nYear, nMonth, nDay, nHour, nMin, nSec); }

	__inline const DDateTime& DDateTime::operator = (const DDateTime& dateSrc)
		{ m_dt = dateSrc.m_dt; m_status = dateSrc.m_status; return *this; }

	__inline DDateTime::DateTimeStatus DDateTime::GetStatus () const
		{ return m_status; }

	__inline void DDateTime::SetStatus (DateTimeStatus status)
		{ m_status = status; }

	__inline bool DDateTime::operator == (const DDateTime& date) const
		{ return (m_status == date.m_status && m_dt == date.m_dt); }

	__inline bool DDateTime::operator != (const DDateTime& date) const
		{ return (m_status != date.m_status || m_dt != date.m_dt); }

	__inline const DDateTime & DDateTime::operator += (const DDateTimeSpan dateSpan)
		{ *this = *this + dateSpan; return *this; }

	__inline const DDateTime & DDateTime::operator -= (const DDateTimeSpan dateSpan)
		{ *this = *this - dateSpan; return *this; }

	__inline DDateTime::operator DATE () const
		{ return m_dt; }

	__inline int DDateTime::SetDate (int nYear, int nMonth, int nDay)
		{ return SetDateTime (nYear, nMonth, nDay, 0, 0, 0); }

	__inline int DDateTime::SetTime (int nHour, int nMin, int nSec)
		// Set date to zero date - 12/30/1899
		{ return SetDateTime (1899, 12, 30, nHour, nMin, nSec); }

	// DDateTimeSpan
	__inline DDateTimeSpan::DDateTimeSpan ()
		{ m_span = 0; SetStatus (valid); }

	__inline DDateTimeSpan::DDateTimeSpan (double dblSpanSrc)
		{ m_span = dblSpanSrc; SetStatus (valid); }

	__inline DDateTimeSpan::DDateTimeSpan (const DDateTimeSpan& dateSpanSrc)
		{ m_span = dateSpanSrc.m_span; m_status = dateSpanSrc.m_status; }

	__inline DDateTimeSpan::DDateTimeSpan (long lDays, int nHours, int nMins, int nSecs)
		{ SetDateTimeSpan (lDays, nHours, nMins, nSecs); }

	__inline DDateTimeSpan::DateTimeSpanStatus DDateTimeSpan::GetStatus () const
		{ return m_status; }

	__inline void DDateTimeSpan::SetStatus (DateTimeSpanStatus status)
		{ m_status = status; }

	__inline double DDateTimeSpan::GetTotalDays () const
		{ 
	//		ASSERT (GetStatus () == valid); 
			return m_span;
		}

	__inline double DDateTimeSpan::GetTotalHours () const
		{
	//		ASSERT (GetStatus () == valid);
			long lReturns = (long) (m_span * 24 + DDATETIME_HALFSECOND);
			return lReturns;
		}

	__inline double DDateTimeSpan::GetTotalMinutes () const
		{ 
	//		ASSERT (GetStatus () == valid);
			long lReturns = (long) (m_span * 24 * 60 + DDATETIME_HALFSECOND);
			return lReturns;
		}

	__inline double DDateTimeSpan::GetTotalSeconds () const
		{ 
	//		ASSERT (GetStatus () == valid);
			long lReturns = (long) (m_span * 24 * 60 * 60 + DDATETIME_HALFSECOND);
			return lReturns;
		}

	__inline long DDateTimeSpan::GetDays () const
		{ 
	//		ASSERT (GetStatus () == valid); 
			return (long)m_span; 
		}

	__inline bool DDateTimeSpan::operator == (const DDateTimeSpan& dateSpan) const
		{ return (m_status == dateSpan.m_status && m_span == dateSpan.m_span); }

	__inline bool DDateTimeSpan::operator != (const DDateTimeSpan& dateSpan) const
		{ return (m_status != dateSpan.m_status || m_span != dateSpan.m_span); }

	__inline bool DDateTimeSpan::operator < (const DDateTimeSpan& dateSpan) const
		{
	//		ASSERT (GetStatus () == valid);
	//		ASSERT (dateSpan.GetStatus () == valid);
			return m_span < dateSpan.m_span; 
		}

	__inline bool DDateTimeSpan::operator > (const DDateTimeSpan& dateSpan) const
		{
	//		ASSERT (GetStatus () == valid);
	//		ASSERT (dateSpan.GetStatus () == valid);
			return m_span > dateSpan.m_span; 
		}

	__inline bool DDateTimeSpan::operator <= (const DDateTimeSpan& dateSpan) const
		{
	//		ASSERT (GetStatus () == valid);
	//		ASSERT (dateSpan.GetStatus () == valid);
			return m_span <= dateSpan.m_span; 
		}

	__inline bool DDateTimeSpan::operator >= (const DDateTimeSpan& dateSpan) const
		{
	//		ASSERT (GetStatus () == valid);
	//		ASSERT (dateSpan.GetStatus () == valid);
			return m_span >= dateSpan.m_span; 
		}

	__inline const DDateTimeSpan& DDateTimeSpan::operator += (const DDateTimeSpan dateSpan)
		{ *this = *this + dateSpan; return *this; }

	__inline const DDateTimeSpan& DDateTimeSpan::operator -= (const DDateTimeSpan dateSpan)
		{ *this = *this - dateSpan; return *this; }

	__inline DDateTimeSpan DDateTimeSpan::operator - () const
		{ return -this->m_span; }

	__inline DDateTimeSpan::operator double () const
		{ return m_span; }



}