An ATL replacement for COleDateTime

Environment: ******–>

Use this in place of COleDateTime when using ATL. No MFC required.

Header file:


// DateTime.h: interface for the CDateTime class.
//
//////////////////////////////////////////////////////////////////////

#ifndef AFX_DATETIME_H__A3E968D9_455B_11D2_9288_00E02921E6D0__INCLUDED_
#define AFX_DATETIME_H__A3E968D9_455B_11D2_9288_00E02921E6D0__INCLUDED_

#if _MSC_VER >= 1000
#pragma once
#endif // _MSC_VER >= 1000

#include
#include

#include

class CDateTime;
class CDateTimeSpan;
////////////////////////////////////////////////////////////////////////////

// CDateTime class helpers

#define AFX_OLE_DATETIME_ERROR (-1)

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

// CDateTime class

class CDateTime
{
// Constructors
public:
static CDateTime PASCAL GetCurrentTime();

CDateTime();

CDateTime(const CDateTime& dateSrc);
CDateTime(const VARIANT& varSrc);
CDateTime(DATE dtSrc);

CDateTime(time_t& timeSrc);
CDateTime(const SYSTEMTIME& systimeSrc);
CDateTime(const FILETIME& filetimeSrc);

CDateTime(int nYear, int nMonth, int nDay,
int nHour, int nMin, int nSec);
CDateTime(WORD wDosDate, WORD wDosTime);

// 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) { m_status=status;}
DateTimeStatus GetStatus() const { return m_status;}

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

// Operations
public:
const CDateTime& operator=(const CDateTime& dateSrc);
const CDateTime& operator=(const VARIANT& varSrc);
const CDateTime& operator=(DATE dtSrc);

const CDateTime& operator=(const time_t& timeSrc);
const CDateTime& operator=(const SYSTEMTIME& systimeSrc);
const CDateTime& operator=(const FILETIME& filetimeSrc);

BOOL operator==(const CDateTime& date) const;
BOOL operator!=(const CDateTime& date) const;
BOOL operator<(const CDateTime& date) const; BOOL operator>(const CDateTime& date) const;
BOOL operator<=(const CDateTime& date) const; BOOL operator>=(const CDateTime& date) const;

// DateTime math
CDateTime operator+(const CDateTimeSpan& dateSpan) const;
CDateTime operator-(const CDateTimeSpan& dateSpan) const;
const CDateTime& operator+=(const CDateTimeSpan dateSpan);
const CDateTime& operator-=(const CDateTimeSpan dateSpan);

// DateTimeSpan math
CDateTimeSpan operator-(const CDateTime& date) const;

operator DATE() const;
int SetDateTime(int nYear, int nMonth, int nDay,
int nHour, int nMin, int nSec);
int SetDate(int nYear, int nMonth, int nDay);
int SetTime(int nHour, int nMin, int nSec);
BOOL ParseDateTime(LPCTSTR lpszDate, DWORD dwFlags = 0,
LCID lcid = LANG_USER_DEFAULT);

// formatting
_bstr_t Format(DWORD dwFlags = 0, LCID lcid = LANG_USER_DEFAULT) const;

_bstr_t Format(LPCTSTR lpszFormat) const;
//CComString Format(UINT nFormatID) const;

// Implementation
protected:
void CheckRange();
friend CDateTimeSpan;
};

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

// CDateTimeSpan class
class CDateTimeSpan
{
// Constructors
public:
CDateTimeSpan();

CDateTimeSpan(double dblSpanSrc);
CDateTimeSpan(const CDateTimeSpan& dateSpanSrc);
CDateTimeSpan(long lDays, int nHours, int nMins, int nSecs);

// 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) { m_status=status;}
DateTimeSpanStatus GetStatus() const { return m_status;}

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 CDateTimeSpan& operator=(double dblSpanSrc);
const CDateTimeSpan& operator=(const CDateTimeSpan& dateSpanSrc);

BOOL operator==(const CDateTimeSpan& dateSpan) const;
BOOL operator!=(const CDateTimeSpan& dateSpan) const;
BOOL operator<(const CDateTimeSpan& dateSpan) const; BOOL operator>(const CDateTimeSpan& dateSpan) const;
BOOL operator<=(const CDateTimeSpan& dateSpan) const; BOOL operator>=(const CDateTimeSpan& dateSpan) const;

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

operator double() const;

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

// formatting
_bstr_t Format(LPCTSTR pFormat) const;
//CComString Format(UINT nID) const;

// Implementation
public:
void CheckRange();
friend CDateTime;
};

#endif // AFX_DATETIME_H__A3E968D9_455B_11D2_9288_00E02921E6D0__INCLUDED_

Source file:

// DateTime.cpp: implementation of the CDateTime class.
//
//////////////////////////////////////////////////////////////////////

#include “stdafx.h”
#include “DateTime.h”

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#endif

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

// CDateTime class HELPER definitions

// Verifies will fail if the needed buffer size is too large
#define MAX_TIME_BUFFER_SIZE 128 // matches that in
timecore.cpp
#define MIN_DATE (-657434L) // about year 100
#define MAX_DATE 2958465L // about year 9999

// Half a second, expressed in days
#define HALF_SECOND (1.0/172800.0)

// One-based array of days in year at month start
static int rgMonthDays[13] =
{0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365};

static BOOL OleDateFromTm(WORD wYear, WORD wMonth, WORD wDay,
WORD wHour, WORD wMinute, WORD wSecond, DATE& dtDest);
static BOOL TmFromOleDate(DATE dtSrc, struct tm& tmDest);
static void TmConvertToStandardFormat(struct tm& tmSrc);
static double DoubleFromDate(DATE dt);
static DATE DateFromDouble(double dbl);

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

// CDateTime class
CDateTime::CDateTime()
{
m_dt=0;
SetStatus(invalid);
}

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

CDateTime::CDateTime(const VARIANT& varSrc)
{
if (varSrc.vt != VT_DATE)
{

_variant_t varTemp(varSrc);
varTemp.ChangeType(VT_DATE);
m_dt = varTemp.date;
}
else
{
m_dt = varSrc.date;
SetStatus(valid);
}

}

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

CDateTime::CDateTime(time_t& timeSrc)
{
// Convert time_t to struct tm
tm *ptm = localtime(&timeSrc);

if (ptm != NULL)
{
m_status = OleDateFromTm((WORD)(ptm->tm_year + 1900),
(WORD)(ptm->tm_mon + 1), (WORD)ptm->tm_mday,
(WORD)ptm->tm_hour, (WORD)ptm->tm_min,
(WORD)ptm->tm_sec, m_dt) ? valid : invalid;
}
else
{
// Local time must have failed (timsSrc before 1/1/70 12am)
m_dt=0;
SetStatus(invalid);
}

}

CDateTime::CDateTime(const SYSTEMTIME& systimeSrc)
{
m_status = OleDateFromTm(systimeSrc.wYear, systimeSrc.wMonth,
systimeSrc.wDay, systimeSrc.wHour, systimeSrc.wMinute,
systimeSrc.wSecond, m_dt) ? valid : invalid;

}

CDateTime::CDateTime(const FILETIME& filetimeSrc)
{
// Assume UTC FILETIME, so convert to LOCALTIME
FILETIME filetimeLocal;
if (!FileTimeToLocalFileTime( &filetimeSrc, &filetimeLocal))
{
m_status = invalid;
}
else
{
// Take advantage of SYSTEMTIME -> FILETIME conversion
SYSTEMTIME systime;
m_status = FileTimeToSystemTime(&filetimeLocal, &systime) ?
valid : invalid;

// At this point systime should always be valid, but…
if (GetStatus() == valid)
{
m_status = OleDateFromTm(systime.wYear, systime.wMonth,
systime.wDay, systime.wHour, systime.wMinute,
systime.wSecond, m_dt) ? valid : invalid;
}
}

}

/////

CDateTime PASCAL CDateTime::GetCurrentTime()
{
return CDateTime(::time(NULL));
}

int CDateTime::GetYear() const
{
struct tm tmTemp;

if (GetStatus() == valid && TmFromOleDate(m_dt, tmTemp))
return tmTemp.tm_year;
else
return AFX_OLE_DATETIME_ERROR;
}

int CDateTime::GetMonth() const
{
struct tm tmTemp;

if (GetStatus() == valid && TmFromOleDate(m_dt, tmTemp))
return tmTemp.tm_mon;
else
return AFX_OLE_DATETIME_ERROR;
}

int CDateTime::GetDay() const
{
struct tm tmTemp;

if (GetStatus() == valid && TmFromOleDate(m_dt, tmTemp))
return tmTemp.tm_mday;
else
return AFX_OLE_DATETIME_ERROR;
}

int CDateTime::GetHour() const
{
struct tm tmTemp;

if (GetStatus() == valid && TmFromOleDate(m_dt, tmTemp))
return tmTemp.tm_hour;

else
return AFX_OLE_DATETIME_ERROR;
}

int CDateTime::GetMinute() const
{
struct tm tmTemp;

if (GetStatus() == valid && TmFromOleDate(m_dt, tmTemp))
return tmTemp.tm_min;
else
return AFX_OLE_DATETIME_ERROR;
}

int CDateTime::GetSecond() const
{
struct tm tmTemp;

if (GetStatus() == valid && TmFromOleDate(m_dt, tmTemp))
return tmTemp.tm_sec;
else
return AFX_OLE_DATETIME_ERROR;
}

int CDateTime::GetDayOfWeek() const
{
struct tm tmTemp;

if (GetStatus() == valid && TmFromOleDate(m_dt, tmTemp))
return tmTemp.tm_wday;
else
return AFX_OLE_DATETIME_ERROR;
}

int CDateTime::GetDayOfYear() const
{
struct tm tmTemp;

if (GetStatus() == valid && TmFromOleDate(m_dt, tmTemp))
return tmTemp.tm_yday;
else
return AFX_OLE_DATETIME_ERROR;
}

const CDateTime& CDateTime::operator=(const VARIANT& varSrc)
{
if (varSrc.vt != VT_DATE)
{

_variant_t varTemp(varSrc);
varTemp.ChangeType(VT_DATE);
m_dt = varTemp.date;
}
else
{
m_dt = varSrc.date;
SetStatus(valid);
}

return *this;
}

const CDateTime& CDateTime::operator=(DATE dtSrc)
{
m_dt = dtSrc;
SetStatus(valid);

return *this;
}

const CDateTime& CDateTime::operator=(const time_t& timeSrc)
{
// Convert time_t to struct tm
tm *ptm = localtime(&timeSrc);

if (ptm != NULL)
{
m_status = OleDateFromTm((WORD)(ptm->tm_year + 1900),
(WORD)(ptm->tm_mon + 1), (WORD)ptm->tm_mday,
(WORD)ptm->tm_hour, (WORD)ptm->tm_min,
(WORD)ptm->tm_sec, m_dt) ? valid : invalid;
}
else
{
// Local time must have failed (timsSrc before 1/1/70 12am)
}

return *this;
}

const CDateTime& CDateTime::operator=(const SYSTEMTIME& systimeSrc)
{
m_status = OleDateFromTm(systimeSrc.wYear, systimeSrc.wMonth,
systimeSrc.wDay, systimeSrc.wHour, systimeSrc.wMinute,
systimeSrc.wSecond, m_dt) ? valid : invalid;

return *this;
}

const CDateTime& CDateTime::operator=(const FILETIME& filetimeSrc)
{
// Assume UTC FILETIME, so convert to LOCALTIME
FILETIME filetimeLocal;
if (!FileTimeToLocalFileTime( &filetimeSrc, &filetimeLocal))
{
m_status = invalid;
}
else
{
// Take advantage of SYSTEMTIME -> FILETIME conversion
SYSTEMTIME systime;
m_status = FileTimeToSystemTime(&filetimeLocal, &systime) ?
valid : invalid;

// At this point systime should always be valid, but…
if (GetStatus() == valid)
{
m_status = OleDateFromTm(systime.wYear, systime.wMonth,
systime.wDay, systime.wHour, systime.wMinute,
systime.wSecond, m_dt) ? valid : invalid;
}
}

return *this;
}

BOOL CDateTime::operator<(const CDateTime& date) const { //ASSERT(GetStatus() == valid); //ASSERT(date.GetStatus() == valid); // Handle negative dates return DoubleFromDate(m_dt) < DoubleFromDate(date.m_dt); } BOOL CDateTime::operator>(const CDateTime& date) const
{ //ASSERT(GetStatus() == valid);
//ASSERT(date.GetStatus() == valid);

// Handle negative dates
return DoubleFromDate(m_dt) > DoubleFromDate(date.m_dt);
}

BOOL CDateTime::operator<=(const CDateTime& date) const { //ASSERT(GetStatus() == valid); //ASSERT(date.GetStatus() == valid); // Handle negative dates return DoubleFromDate(m_dt) <= DoubleFromDate(date.m_dt); } BOOL CDateTime::operator>=(const CDateTime& date) const
{
//ASSERT(GetStatus() == valid);
//ASSERT(date.GetStatus() == valid);

// Handle negative dates
return DoubleFromDate(m_dt) >= DoubleFromDate(date.m_dt);
}

CDateTime CDateTime::operator+(const CDateTimeSpan& dateSpan) const
{
CDateTime dateResult; // Initializes m_status to valid

// If either operand NULL, result NULL
if (GetStatus() == null || dateSpan.GetStatus() == null)
{
dateResult.SetStatus(null);
return dateResult;
}

// If either operand invalid, result invalid
if (GetStatus() == invalid || dateSpan.GetStatus() == invalid)
{
dateResult.SetStatus(invalid);
return dateResult;
}

// Compute the actual date difference by adding underlying dates
dateResult = DateFromDouble(DoubleFromDate(m_dt) + dateSpan.m_span);

// Validate within range
dateResult.CheckRange();

return dateResult;
}

CDateTime CDateTime::operator-(const CDateTimeSpan& dateSpan) const
{
CDateTime dateResult; // Initializes m_status to valid

// If either operand NULL, result NULL
if (GetStatus() == null || dateSpan.GetStatus() == null)
{
dateResult.SetStatus(null);
return dateResult;
}

// If either operand invalid, result invalid
if (GetStatus() == invalid || dateSpan.GetStatus() == invalid)
{
dateResult.SetStatus(invalid);
return dateResult;
}

// Compute the actual date difference by subtracting underlying dates
dateResult = DateFromDouble(DoubleFromDate(m_dt) – dateSpan.m_span);

// Validate within range
dateResult.CheckRange();

return dateResult;
}

CDateTimeSpan CDateTime::operator-(const CDateTime& date) const
{
CDateTimeSpan spanResult;

// If either operand NULL, result NULL
if (GetStatus() == null || date.GetStatus() == null)
{
spanResult.SetStatus(CDateTimeSpan::null);
return spanResult;
}

// If either operand invalid, result invalid
if (GetStatus() == invalid || date.GetStatus() == invalid)
{
spanResult.SetStatus(CDateTimeSpan::invalid);
return spanResult;
}

// Return result (span can’t be invalid, so don’t check range)
return DoubleFromDate(m_dt) – DoubleFromDate(date.m_dt);
}

int CDateTime::SetDateTime(int nYear, int nMonth, int nDay,
int nHour, int nMin, int nSec)
{
return m_status = OleDateFromTm((WORD)nYear, (WORD)nMonth,
(WORD)nDay, (WORD)nHour, (WORD)nMin, (WORD)nSec, m_dt) ?
valid : invalid;
}

BOOL CDateTime::ParseDateTime(LPCTSTR lpszDate, DWORD dwFlags, LCID
lcid)
{
USES_CONVERSION;
//CString strDate = lpszDate;

SCODE sc;
if (FAILED(sc = VarDateFromStr((LPOLESTR)T2COLE(lpszDate), lcid,
dwFlags, &m_dt)))
{
if (sc == DISP_E_TYPEMISMATCH)
{
// Can’t convert string to date, set 0 and invalidate
m_dt = 0;
SetStatus(invalid);
return FALSE;
}
else if (sc == DISP_E_OVERFLOW)
{
// Can’t convert string to date, set -1 and invalidate
m_dt = -1;
SetStatus(invalid);
return FALSE;
}
else
{
// TRACE0(“nCDateTime VarDateFromStr call failed.nt”);
// if (sc == E_OUTOFMEMORY)
// AfxThrowMemoryException();
// else
// AfxThrowOleException(sc);
m_dt=0;
SetStatus(invalid);
return FALSE;
}

}

SetStatus(valid);
return TRUE;
}

_bstr_t CDateTime::Format(DWORD dwFlags, LCID lcid) const
{
USES_CONVERSION;
_bstr_t strDate;

// If null, return empty string
if (GetStatus() == null)
return strDate;

// If invalid, return DateTime resource string
if (GetStatus() == invalid)
{
// VERIFY(strDate.LoadString(AFX_IDS_INVALID_DATETIME));
return strDate;
}

_variant_t var;
// Don’t need to trap error. Should not fail due to type mismatch
VarBstrFromDate(m_dt, lcid, dwFlags, &V_BSTR(&var));
var.vt = VT_BSTR;
return V_BSTR(&var);
}

_bstr_t CDateTime::Format(LPCTSTR pFormat) const
{
_bstr_t strDate;
struct tm tmTemp;

// If null, return empty string
if (GetStatus() == null)
return strDate;

// If invalid, return DateTime resource string
if (GetStatus() == invalid || !TmFromOleDate(m_dt, tmTemp))
{
// VERIFY(strDate.LoadString(AFX_IDS_INVALID_DATETIME));
return strDate;
}

// Convert tm from afx internal format to standard format
TmConvertToStandardFormat(tmTemp);

// Fill in the buffer, disregard return value as it’s not necessary
LPTSTR lpszTemp = new TCHAR[MAX_TIME_BUFFER_SIZE];
_tcsftime(lpszTemp, MAX_TIME_BUFFER_SIZE , pFormat, &tmTemp);
strDate=lpszTemp;
delete [] lpszTemp;

return strDate;
}
/*
CComString CDateTime::Format(UINT nFormatID) const
{
CComString strFormat;
strFormat.LoadString(nFormatID);
return Format(strFormat);
}
*/

void CDateTime::CheckRange()
{
if (m_dt > MAX_DATE || m_dt < MIN_DATE) // about year 100 to about 9999 SetStatus(invalid); } //////////////////////////////////////////////////////////////////////////// // CDateTimeSpan class helpers #define MAX_DAYS_IN_SPAN 3615897L //////////////////////////////////////////////////////////////////////////// // CDateTimeSpan class CDateTimeSpan::CDateTimeSpan() { m_span=0; SetStatus(invalid); } CDateTimeSpan::CDateTimeSpan(double dblSpanSrc) { m_span = dblSpanSrc; SetStatus(valid); } CDateTimeSpan::CDateTimeSpan(const CDateTimeSpan& dateSpanSrc) { m_span = dateSpanSrc.m_span; m_status = dateSpanSrc.m_status; } long CDateTimeSpan::GetHours() const { // ASSERT(GetStatus() == valid); double dblTemp; // Truncate days and scale up dblTemp = modf(m_span, &dblTemp); return (long)(dblTemp * 24); } long CDateTimeSpan::GetMinutes() const { // ASSERT(GetStatus() == valid); double dblTemp; // Truncate hours and scale up dblTemp = modf(m_span * 24, &dblTemp); return (long)(dblTemp * 60); } long CDateTimeSpan::GetSeconds() const { // ASSERT(GetStatus() == valid); double dblTemp; // Truncate minutes and scale up dblTemp = modf(m_span * 24 * 60, &dblTemp); return (long)(dblTemp * 60); } const CDateTimeSpan& CDateTimeSpan::operator=(double dblSpanSrc) { m_span = dblSpanSrc; SetStatus(valid); return *this; } const CDateTimeSpan& CDateTimeSpan::operator=(const CDateTimeSpan& dateSpanSrc) { m_span = dateSpanSrc.m_span; m_status = dateSpanSrc.m_status; return *this; } CDateTimeSpan CDateTimeSpan::operator+(const CDateTimeSpan& dateSpan) const { CDateTimeSpan dateSpanTemp; // If either operand Null, result Null if (GetStatus() == null || dateSpan.GetStatus() == null) { dateSpanTemp.SetStatus(null); return dateSpanTemp; } // If either operand Invalid, result Invalid if (GetStatus() == invalid || dateSpan.GetStatus() == invalid) { dateSpanTemp.SetStatus(invalid); return dateSpanTemp; } // Add spans and validate within legal range dateSpanTemp.m_span = m_span + dateSpan.m_span; dateSpanTemp.CheckRange(); return dateSpanTemp; } CDateTimeSpan CDateTimeSpan::operator-(const CDateTimeSpan& dateSpan) const { CDateTimeSpan dateSpanTemp; // If either operand Null, result Null if (GetStatus() == null || dateSpan.GetStatus() == null) { dateSpanTemp.SetStatus(null); return dateSpanTemp; } // If either operand Invalid, result Invalid if (GetStatus() == invalid || dateSpan.GetStatus() == invalid) { dateSpanTemp.SetStatus(invalid); return dateSpanTemp; } // Subtract spans and validate within legal range dateSpanTemp.m_span = m_span - dateSpan.m_span; dateSpanTemp.CheckRange(); return dateSpanTemp; } void CDateTimeSpan::SetDateTimeSpan( long lDays, int nHours, int nMins, int nSecs) { // Set date span by breaking into fractional days (all input ranges valid) m_span = lDays + ((double)nHours)/24 + ((double)nMins)/(24*60) + ((double)nSecs)/(24*60*60); SetStatus(valid); } _bstr_t CDateTimeSpan::Format(LPCTSTR pFormat) const { _bstr_t strSpan; struct tm tmTemp; // If null, return empty string if (GetStatus() == null) return strSpan; // If invalid, return DateTimeSpan resource string if (GetStatus() == invalid || !TmFromOleDate(m_span, tmTemp)) { //VERIFY(strSpan.LoadString(AFX_IDS_INVALID_DATETIMESPAN)); return strSpan; } // Convert tm from afx internal format to standard format TmConvertToStandardFormat(tmTemp); // Fill in the buffer, disregard return value as it's not necessary LPTSTR lpszTemp = new TCHAR[MAX_TIME_BUFFER_SIZE]; _tcsftime(lpszTemp, MAX_TIME_BUFFER_SIZE, pFormat, &tmTemp); strSpan=lpszTemp; delete [] lpszTemp; return strSpan; } /* CComString CDateTimeSpan::Format(UINT nFormatID) const { CComString strFormat; strFormat.LoadString(nFormatID); return Format(strFormat); } */ void CDateTimeSpan::CheckRange() { if(m_span < -MAX_DAYS_IN_SPAN || m_span > MAX_DAYS_IN_SPAN)
SetStatus(invalid);
}

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

// CDateTime class HELPERS – implementation

BOOL OleDateFromTm(WORD wYear, WORD wMonth, WORD wDay,
WORD wHour, WORD wMinute, WORD wSecond, DATE& dtDest)
{
// Validate year and month (ignore day of week and milliseconds)
if (wYear > 9999 || wMonth < 1 || wMonth > 12)
return FALSE;

// Check for leap year and set the number of days in the month
BOOL bLeapYear = ((wYear & 3) == 0) &&
((wYear % 100) != 0 || (wYear % 400) == 0);

int nDaysInMonth =
rgMonthDays[wMonth] – rgMonthDays[wMonth-1] +
((bLeapYear && wDay == 29 && wMonth == 2) ? 1 : 0);

// Finish validating the date
if (wDay < 1 || wDay > nDaysInMonth ||
wHour > 23 || wMinute > 59 ||
wSecond > 59)
{
return FALSE;
}

// Cache the date in days and time in fractional days
long nDate;
double dblTime;

//It is a valid date; make Jan 1, 1AD be 1
nDate = wYear*365L + wYear/4 – wYear/100 + wYear/400 +

rgMonthDays[wMonth-1] + wDay;

// If leap year and it’s before March, subtract 1:
if (wMonth <= 2 && bLeapYear) --nDate; // Offset so that 12/30/1899 is 0 nDate -= 693959L; dblTime = (((long)wHour * 3600L) + // hrs in seconds ((long)wMinute * 60L) + // mins in seconds ((long)wSecond)) / 86400.; dtDest = (double) nDate + ((nDate >= 0) ? dblTime : -dblTime);

return TRUE;
}

BOOL TmFromOleDate(DATE dtSrc, struct tm& tmDest)
{
// The legal range does not actually span year 0 to 9999.
if (dtSrc > MAX_DATE || dtSrc < MIN_DATE) // about year 100 to about 9999 return FALSE; long nDays; // Number of days since Dec. 30, 1899 long nDaysAbsolute; // Number of days since 1/1/0 long nSecsInDay; // Time in seconds since midnight long nMinutesInDay; // Minutes in day long n400Years; // Number of 400 year increments since 1/1/0 long n400Century; // Century within 400 year block (0,1,2 or 3) long n4Years; // Number of 4 year increments since 1/1/0 long n4Day; // Day within 4 year block // (0 is 1/1/yr1, 1460 is 12/31/yr4) long n4Yr; // Year within 4 year block (0,1,2 or 3) BOOL bLeap4 = TRUE; // TRUE if 4 year block includes leap year double dblDate = dtSrc; // tempory serial date // If a valid date, then this conversion should not overflow nDays = (long)dblDate; // Round to the second dblDate += ((dtSrc > 0.0) ? HALF_SECOND : -HALF_SECOND);

nDaysAbsolute = (long)dblDate + 693959L; // Add days from 1/1/0 to
12/30/1899

dblDate = fabs(dblDate);
nSecsInDay = (long)((dblDate – floor(dblDate)) * 86400.);

// Calculate the day of week (sun=1, mon=2…)
// -1 because 1/1/0 is Sat. +1 because we want 1-based
tmDest.tm_wday = (int)((nDaysAbsolute – 1) % 7L) + 1;

// Leap years every 4 yrs except centuries not multiples of 400.
n400Years = (long)(nDaysAbsolute / 146097L);

// Set nDaysAbsolute to day within 400-year block
nDaysAbsolute %= 146097L;

// -1 because first century has extra day
n400Century = (long)((nDaysAbsolute – 1) / 36524L);

// Non-leap century
if (n400Century != 0)
{
// Set nDaysAbsolute to day within century
nDaysAbsolute = (nDaysAbsolute – 1) % 36524L;

// +1 because 1st 4 year increment has 1460 days
n4Years = (long)((nDaysAbsolute + 1) / 1461L);

if (n4Years != 0)
n4Day = (long)((nDaysAbsolute + 1) % 1461L);
else
{
bLeap4 = FALSE;
n4Day = (long)nDaysAbsolute;
}
}
else
{
// Leap century – not special case!
n4Years = (long)(nDaysAbsolute / 1461L);
n4Day = (long)(nDaysAbsolute % 1461L);
}

if (bLeap4)
{
// -1 because first year has 366 days
n4Yr = (n4Day – 1) / 365;

if (n4Yr != 0)
n4Day = (n4Day – 1) % 365;
}
else
{
n4Yr = n4Day / 365;
n4Day %= 365;
}

// n4Day is now 0-based day of year. Save 1-based day of year, year
number
tmDest.tm_yday = (int)n4Day + 1;
tmDest.tm_year = n400Years * 400 + n400Century * 100 + n4Years * 4 +
n4Yr;

// Handle leap year: before, on, and after Feb. 29.
if (n4Yr == 0 && bLeap4)
{
// Leap Year
if (n4Day == 59)
{
/* Feb. 29 */
tmDest.tm_mon = 2;
tmDest.tm_mday = 29;

goto DoTime;
}

// Pretend it’s not a leap year for month/day comp.
if (n4Day >= 60)
–n4Day;
}

// Make n4DaY a 1-based day of non-leap year and compute
// month/day for everything but Feb. 29.
++n4Day;

// Month number always >= n/32, so save some loop time */
for (tmDest.tm_mon = (n4Day >> 5) + 1;
n4Day > rgMonthDays[tmDest.tm_mon]; tmDest.tm_mon++);

tmDest.tm_mday = (int)(n4Day – rgMonthDays[tmDest.tm_mon-1]);

DoTime:
if (nSecsInDay == 0)
tmDest.tm_hour = tmDest.tm_min = tmDest.tm_sec = 0;
else
{
tmDest.tm_sec = (int)nSecsInDay % 60L;
nMinutesInDay = nSecsInDay / 60L;
tmDest.tm_min = (int)nMinutesInDay % 60;
tmDest.tm_hour = (int)nMinutesInDay / 60;
}

return TRUE;
}

void TmConvertToStandardFormat(struct tm& tmSrc)
{
// Convert afx internal tm to format expected by runtimes (_tcsftime,
etc)
tmSrc.tm_year -= 1900; // year is based on 1900
tmSrc.tm_mon -= 1; // month of year is 0-based
tmSrc.tm_wday -= 1; // day of week is 0-based
tmSrc.tm_yday -= 1; // day of year is 0-based
}

double DoubleFromDate(DATE dt)
{
// No problem if positive
if (dt >= 0)
return dt;

// If negative, must convert since negative dates not continuous
// (examples: -1.25 to -.75, -1.50 to -.50, -1.75 to -.25)
double temp = ceil(dt);
return temp – (dt – temp);
}

DATE DateFromDouble(double dbl)
{
// No problem if positive
if (dbl >= 0)
return dbl;

// If negative, must convert since negative dates not continuous
// (examples: -.75 to -1.25, -.50 to -1.50, -.25 to -1.75)
double temp = floor(dbl); // dbl is now whole part
return temp + (temp – dbl);
}

Download source – 6.8 Kb

More by Author

Must Read