DTime++ v3.32

DTime+, A collection of Date and Time Classes for C++

Version 3.32

Copyright (c) 1995 - 2023 PJ Naughter

DTime+ is a collection of classes & functions designed to ease the C++ programmers’ burden when handling date and time values. If like me, having taken a look at the built in MFC classes CTime and CTimeSpan or the OLE based COleDateTime and COleDateTimeSpan classes in Visual Studio, you decided they did not meet your requirements, and you decided to write your own super-duper date and time classes, but deadlines were looming, then look no further. The original basis of the algorithms for conversion from the Julian and Gregorian calendar to the underlying storage was adopted from an article by Peter J.G. Meyer for the March 1993 issue of Dr Dobbs Journal. You can find the article online at http://www.drdobbs.com/cpp/julian-and-gregorian-calendars/184408959. As of v3.21, the code for the Julian and Gregorian calendar has been reworked to now be based on Howard Hinnant's algorithms at http://howardhinnant.github.io/date_algorithms.html . The algorithm used to determine the date of Easter Sunday is taken from the book ‘Astronomical Algorithms’ by Jean Meeus. The algorithms for the Moslem (Islamic) and Hebrew calendar are provided by the book "Calendrical Calculations, The Millenium Edition" by Edward M. Reingold and Nachum Dershowitz. Calendrical Calculations has always been a favourite topic of the author and was in fact some of the first code which I published on the web back in the mid 90's. Originally the code was shareware but I've now decided to make it freeware in the hope that more people will find it useful in their day to day projects. As of v3.20, the classes are fully supported on non Windows platforms. All the code has been carefully reviewed and reworked to support this. The code has been tested on VC 2017/2019 & 2022 on Windows and on Ubuntu using gcc, cmake and Code::Blocks.

Sections in this Document

Structures used by the classes

UI Support

Contacting the Author

Copyright

You are allowed to include the source code in any product (commercial, shareware, freeware or otherwise) when your product is released in binary form.
You are allowed to modify the source code in any way you want except you cannot modify the copyright details at the top of each module.
If you want to distribute source code with your application, then you are only allowed to distribute versions released by the author. This is to maintain a single distribution point for the source code.

Features

The classes provided are implemented as a C++ template based class framework.
The code fully supports the Gregorian, Julian and Moslem (Islamic) and Hebrew calendars. DTime+ also supports proleptic versions of all of these calendars. You can also easily convert between all the calendar types. The 4 most common forms of the Moslem Arithmetic calendar are supported namely the 15th and 16th year leap year rules as well as the Civil Epoch (16 July 622 C.E. O.S) and the Astronomical Epoch (15 July 622 C.E. O.S).
As of v3.23, the classes are fully supported on non Windows platforms. All the code has been carefully reviewed and reworked to support this. For this release the code has been tested on VC 2017 on Windows and on Ubuntu 18.04.1 LTS using gcc 6.2.0, cmake 3.5.2 and Code::Blocks 16.01.
When compiling for desktop environments on Visual Studio, the classes stick very closely to the MFC class structures and provide routines to map from CTime, COleDateTime, COleDateTimeSpan and CTimeSpan. Mappings are also available to convert to and from Win32 SDK date and time structures.
The classes do not rely on the ‘C’ runtime library like the way CTime does. The classes only use the 'C' runtime to get the current UTC and local times and nothing else. The classes use of UTC / Local is much less vague than CTime which performs automatic mappings which can confuse even the most experienced developer.
A number of date / time classes are provided namely CDate, CLTimeSpan, CLLTimeSpan, CLTimeOfDay, CLLTimeOfDay, CLDate & CLLDate.
Methods are provided to integrate with the date time UI controls on Windows.
Includes comprehensive support for Holidays, Christian Saints Days, National Holidays, US Specific Holidays, Christian Feast Days, Moslem and Hebrew holidays.
Tight integration with the Win32 NLSAPI when compiled for desktop environments on Visual Studio. For example all the day of week and month strings are taken from Win32. This means that if DTime+ is used on an international version of Windows, the days of week etc. will be in the local language.
Format functions with a superset of the functionality provided by CTime/CTimeSpan::Format.
When compiled for desktop environments on Visual Studio, the Format functions are also able to display a date or time according to display characteristics as specified in the Windows Control Panel.
The CDate class provides a resolution of 1 day and uses a int32_t to represent the count of days. Its range is valid for roughly the whole range of a int32_t i.e. +/- 2 billion days (or just under 5.5 million years!) from the current era.
The CLTimeOfDay class represents a time of day i.e. 00:00:00 to 23:59:60 and provides a resolution of 1 second.
The CLLTimeOfDay class represents a time of day i.e. 00:00:00 to 23:59:60 and uses a double for storage.
The CLTimeSpan class represents the time interval between two CLDate instances and provides a resolution of 1 second.
The CLLTimeSpan class represents the time interval between two CLLDate instances and uses a double for storage.
The CLDate class represents the composite of a date and a time of day together and provides a granularity of 1 second. As with CDate, the full range of a int32_t is valid i.e. +/- 5.5 million years. This is ‘quite’ larger than the roughly 60-year time span for CTime (assuming you are not using the 64 bit CTime data type available in Visual Studio 2005) and the 100 CE - 9999CE time span for COleDateTime. Using CLDate means that you can represent +/- 5.5 million years from the current era with a resolution of 1 second.
The CLLDate class represents the composite of a date and a time of day together and stores a count of seconds as a double thus providing sub-second accuracy. For the year range -2000000 to 2000000, the worst case resolution is 0.008 seconds. The change in resolution depending on what year you are representing occurs due to how a double is represented using IEEE 754 floating point format.
All classes are fully Unicode enabled and Unicode build configurations are provided in the sample apps provided.
All classes and defines are declared in a C++ namespace called DTimePlus. This helps reduce pollution of the C++ global namespace.
If using Visual Studio as your development environment, then the classes are only supported on VC 2017 or later. On non Windows platforms, any recent copy of GCC should do.

History

v3.32 (30 October 2023)

Made the operator- methods of CLDate const.
Made the operator- methods of CLLDate const.
Made CLDate::GetAsTM const.

v3.31 (3 June 2023)

Updated copyright details.
Updated module to indicate that it needs to be compiled using /std:c++17. Thanks to Martin Richter for reporting this issue.

v3.30 (22 May 2022)

Updated copyright details.
Updated the code to use C++ uniform initialization for all variable declarations.

v3.29 (29 December 2021)

Updated copyright details
Fixed more Clang-Tidy static code analysis warnings in the code.

v3.28 (21 May 2020)

Fixed a bug in CLTimeSpan::Format where a break statement was placed in the wrong location.

v3.27 (16 May 2020)

Updated copyright details
Fixed Clang-Tidy static code analysis warnings in the code.

v3.26 (17 December 2019)

Fixed various Clang-Tidy static code analysis warnings in the code.
Updated initialization of various structs to use C++ 11 list initialization.

v3.25 (13 October 2019)

Fixed a number of compiler warnings when the code is compiled with VS 2019 Preview

v3.24 (8 June 2019)

Updated copyright details
Updated the code to clean compile on VC 2019

v3.23 (13 November 2018)

Fixed a number of C++ core guidelines compiler warnings. These changes mean that the code will now only compile on VC 2017 or later on Windows.
Replaced enum with enum class throughout the codebase.
The code now allows construction of a CLTimeOfDay and CLLTimeOfDay which represents a time of day of 23:59:60 which occurs when a UTC leap second occurs. Please note that if your OS exposes the concept of a leap second, then DTime+ will be able to accept this value, but roundtripping back to hours, minutes and seconds will give back midnight for the next day. Also note that timespan calculations will ignore leap seconds. If you would like to accurately calculate timespans taking into account leap seconds, then please see the author's AA+ framework at http://www.naughter.com/aa.html

v3.22 (2 January 2018)

Updated copyright details
Fix compile problems in CLTimeOfDay::GetWindowsFormatString in VC 2017
Removed defunct dmod method.
Fixed a bug in CDate::GetWindowsFormatString where it was calling a non existent String::GetLength method
Made CLDate::GetWindowsFormatString method publicly accessible
Made layout of CLTimeSpan::GetWindowsFormatString parameters consistent with the other GetWindowsFormatString implementations.
Fixed a bug in CLTimeSpan::GetWindowsFormatString related to leading zeros for the hour value.
Replaced GetLocaleInfo Win32 API call with GetLocaleInfoEx.
Replaced GetDateFormat Win32 API call with GetDateFormatEx.
Replaced GetTimeFormat Win32 API call with GetTimeFormatEx.
Introduced a new CLLTimeOfDay class which represents a time of day as a double.
Introduced a new CLLDate class which represents a time stamp as a double. This provides a sub second accuracy unlike CLDate which only provides an accuracy of 1 second.
Introduced a new CLLTimeSpan class which represents the time difference between two CLLDate instances.

v3.21 (20 December 2016)

Optimized the CGregorianLeapFunctor::operator() method per the information at https://howardhinnant.github.io/date_algorithms.html#is_leap.
Optimized the CGregorianLeapFunctor::operator() method per the information at https://howardhinnant.github.io/date_algorithms.html#is_leap.
Removed the weekday & wYearday variables from the DateS struct. The DateS struct now contains just the Year, Month & Day triplet.
Renamed the GetDate method to "NumToDMY"
Reimplemented the CJulianGregorianCalendar::DaysInMonth method per the information at https://howardhinnant.github.io/date_algorithms.html#last_day_of_month.
Reimplemented the CGregorianCalendar::DMYToNum method per the information at https://howardhinnant.github.io/date_algorithms.html#days_from_civil.
Reimplemented the CGregorianCalendar::NumToDMY method per the information at https://howardhinnant.github.io/date_algorithms.html#civil_from_days.
Following all the optimizations in this release, the time taken to round trip one Gregorian date has been reduced from 60ns to 35ns on my 3.2 Ghz CoreI7 965 processor. This corresponds to a 70% speedup compared to v3.20.
Following all the optimizations in this release, the time taken to round trip one Julian date has been reduced from 49ns to 28ns on my 3.2 Ghz CoreI7 965 processor. This corresponds to a 75% speedup compared to v3.20.
Fixed an integer overflow bug in the CMoslemCalendar*::NumToDMY methods. This bug was found while testing moslem dates from the year -2000000 to 2000000 in the updated test app. In fact the Gregorian, Julian, Moslem & Hebrew calendars are now exercised from years -2000000 to 2000000 by the test app.

v3.20 (6 December 2016)

Updated copyright details
Removed all usage of CString from the code and replaced with std::[w]string.
Replaced all occurrences of WORD with uint16_t throughout the code
Replaced all occurrences of DWORD with uint32_t throughout the code
Replaced all occurrences of ASSERT, AFXASSUME, TRACE & VERIFY with non MFC dependent implementations
Replaced all occurrences of long with int32_t throughout the code
Renamed the DMYToLong method to "DMYToNum"
Optimized the elements of the static lookup tables in CJulianCalendar::DMYToNum & CJulianCalendar::GetDate
Replaced all occurrences of NULL with nullptr throughout the code. This does mean that the classes now require at least VC 2010 if you are going to use a Microsoft compiler.
Reimplemented CDate::CurrentSystemDate to just use the C runtime.
Reimplemented CDate::CurrentLocalDate to just use the C runtime.
Optimized the CDate::Set method which takes a COleDateTime parameter
Optimized the CLDate::Set method which takes a COleDateTime parameter
Fixed a bug in the validation code of the CDate::Set method which takes a "WeekOfMonth" parameter.
Fixed a bug in CJulianGregorianHolidays::EasterMonday where it returned EasterSaturday by mistake
Fixed all typos of "occurrences" throughout code and documentation
Optimized the CDate::Set method which takes a CTime parameter
Optimized the CLDate::Set method which takes a CTime parameter

v3.10 (26 October 2014)

Updated copyright details.
The classes and test app have been updated to require VC 2008 or later.
Fix arithmetic bugs in a number of the CLDate::Set methods related to the calculation of m_nSeconds.
Updated code to clean compile with /analyze.
CJulianGregorianHolidays::StStephensDays has been renamed to StStephensDay.
Made improvements to the HewbrewOccurencesInGregorianYear method including use of std::vector for collection array.
Made improvements to the MoslemOccurencesInGregorianYear method including use of std::vector for collection array.
Addition of a number of new methods in the CJulianGregorianHolidays class including CanadaThanksgivingDay & EasterMonday.
Updated the test app to run more tests on the various DTime+ classes.
Fixed a bug in CLTimeOfDay::GetAMPMString related to when PM kicks in.
Fix arithmetic bugs in CLDate::GetCDate. Thanks to Zhen-dong Chen for reporting these issues.
Fix arithmetic bugs in CLDate::GetCLTimeOfDay. Thanks to Zhen-dong Chen for reporting these issues.
The sample app now generates the file for testing MFC persistence in the temp directory to avoid UAC access denied issues on the root directory of the C drive.

v3.09 (13 April 2007)

Updated copyright details.
Updated sample apps to clean compile on VC 2005
Fixed a bug in CDate::Set(const CTime& ctime, ...) and CLDate& CLDate::Set which incorrectly used GetGmtTm instead of GetLocalTm. Thanks to Martin Copland for reporting this bug.

v3.08 (2 July 2006)

Updated the code to clean compile on VC 2005
Code now uses new C++ style casts rather than old style C casts where necessary.

v3.07 (30 May 2006)

Added support for Rosh HaShanah 2
Renamed CSimhatTorahFunctor to CCSimhatTorahOutsideIsraelFunctor
Renamed CPassoverFunctor to CPesachFunctor
Renamed CEndingOfPassoverFunctor to CShviiPesachFunctor
Added support for Yom Ha'atzmaut
Added support for Erev Pesach
Added support for Ta'anit Bechorim
Added support for Pesach Shenni
Added support for Yom Yerushalaiym
Renamed to CHoshahaRabbaFunctor to CHoshanahRabahFunctor. All of these updates for the Hebrew calendar for v3.07 are thanks to Itamar Syn-Hershko.

v3.06 (29 May 2006)

Further performance optimizations for the core CJulianCalendar algorithms. There is a 3% increase in performance compared to v3.05. On my Quad Opteron system, the round trip tests for 1000 years of Julian dates takes just 48 ms.
Further performance optimizations for the core CGregorianCalendar algorithms. There is a 3% increase in performance compared to v3.05. On my Quad Opteron system, the round trip tests for 1000 years of Gregorian dates takes just 79 ms.
Now includes comprehensive support for Holidays, Christian Saints Days, National Holidays, US Specific Holidays, and Christian Feast Days via the new class CJulianGregorianHolidays.
Updated the month enum name and month strings for Moslem month "Ramadan".
Now includes comprehensive support for Moslem Holidays via the new module DTime+MoslemHolidays.h. Also you can determine Moslem holidays occurring in a Gregorian year via MoslemOccurrencesInGregorianYear.
Now includes comprehensive support for Hebrew Holidays via the new module DTime+HebrewHolidays.h. Also you can determine Hebrew holidays occurring in a Gregorian year via HewbrewOccurrencesInGregorianYear.
Removed the now unnecessary defines DTIMEPLUS_EXT_CLASS and DTIMEPLUS_EXT_API. These are no longer required because DTime+ is template based.

v3.05 (27 May 2006)

Renamed the CHebrewCalendar::LongMarheshvan function to LongCheshvan.
Renamed the CHebrewCalendar::ShortMarheshvan function to ShortCheshvan.
Reworked Hebrew algorithms to support dates before the Hebrew epoch i.e. a proleptic Hebrew calendar.
Reworked Moslem algorithms to support dates before the Moslem epoch i.e. a proleptic Moslem calendar.
Updated the month enum names and month strings for the Moslem calendar.
Updated the weekday strings for the Moslem calendar.
Removed the need for the function DTimePlus::WeekOfDaysModulo.

v3.04 (25 May 2006)

Updated the string and enums for the 7th month in the Hebrew calendar to be "Tishrei". Thanks to Itamar Syn-Hershko for reporting this issue.
Updated the string and enums for the first month in the Hebrew calendar to be "Nissan". Thanks to Itamar Syn-Hershko for reporting this issue.
Updated the string and enums for the 8th month in the Hebrew calendar to be "Cheshvan". Thanks to Itamar Syn-Hershko for reporting this issue.
Now includes spaces in the strings returned for AdarI and AdarII (the 12th and 13th month of the Hebrew calendar).
Fixed a typo in the string and enums for the 11th month in the Hebrew calendar "Shevat". Thanks to Itamar Syn-Hershko for reporting this issue.
Optimized the code in CJulianGregorianCalendar::DaysInMonth.
Optimized the DTimePlus::WeekOfDayModulo and DTimePlus::lfloor functions. This results in a 2 fold increase in the speed of the key algorithms for the Julian and Gregorian calendars.
made all the functions in CJulianGregorianCalendar inline.
Optimized the CBaseMoslemCalendar::DaysInMonth code.
Made some Moslem functions inline to aid optimization. These tweaks to the Moslem algorithms result in a c. 40% speed improvement
Made some Hebrew functions inline to aid optimization.

v3.03 (22 May 2006)

Fixed a compile issue in VC 2003 with the multiplication operator for CLTimeSpan. The issue was related to the tighter ISO conformance of the compiler. Thanks to Itamar Syn-Hershko for reporting this issue.

v3.02 (20 May 2006)

Canonical DaysInMonth method now takes a Year and a Month parameter instead of a month and a leap year boolean. This is required for support of the Hebrew calendar where knowing whether a year is a leap year or not is not good enough to determine the number of days in any month. This is because of the more complex nature of the Hebrew calendar and its' postponement rules for the Hebrew New Year (Rosh ha-Shannah). Please note that this means you should examine all calls to this method in client code to ensure it is updated correctly.
Canonical DaysInYear method layout has been updated to take a year instead of a leap year boolean. The reason is as for item one above. Again you should examine all calls to this method in client code to ensure it is updated correctly.
Canonical DaysSinceEndPreviousYear and DaysSinceFirstOfYear parameter layout has been updated. Both now take a year, month and day value. The reason is as for item one above. Again you should examine all calls to this method in client code to ensure it is updated correctly.
Moslem classes now uses functors for leap year functionality. This does not affect client code in any way.
CJulianCalendar now uses functors for leap year calculations. This does not affect client code in any way.
CGregorianCalendar now uses functors for leap year calculations. This does not affect client code in any way.
Now includes comprehensive support for the Hebrew calendar. The algorithms are taken from the book "Calendrical Calculations, The Millenium Edition" by Edward M. Reingold and Nachum Dershowitz. For example to create a date which represents the date of Passover in 922 C.E., that is Nisan 15 A.M. 4682, you would use:

DTimePlus::CDate<CHebrewCalendar> Passover(4682, Nisan, 15);

The Hebrew month's are defined as a standard enum in the DTimePlus namespace just like you can use the Julian / Gregorian month names. Also various helper functions are provided in the class CHebrewCalendar to handle the various intricacies of this calendar.
Addition of a AsHebrewCDate method to CDate class.
Addition of a constructor and Set method to CLDate which allows construction from a floating point days value.
Updated the sample app, to verify the algorithms produce monotonically increasing day counts for all Calendars (Gregorian, Julian, 4 flavours of the Moslem calendar and Hebrew).
Updated the sample app to widen the verification years for the algorithms to cover the span -100,000 to 100,000 C.E.
Updated the sample app to report the relative speeds of the various calendar algorithms.

v3.01 (1 May 2006)

Reworked the CDate and CLDate classes to use templates to specify the calendar type to use (Julian, Gregorian or Moslem). By making these classes template based, we have dispensed with a bool member variable in each instance, thereby reducing the per instance memory size of each of these classes. It also means that the serialized size for both of these classes has shrunk by 1 byte. By also making the classes template based, the code should also have a better chance of being optimized by the compiler. An example of the changes this implies to client code is as follows:

CDate x(1990, CDate::March, 4, CDate::Gregorian) -> DTimePlus::CDate<CGregorianCalendar>(1990, March, 4) and

CDate x(1990, CDate::March, 4, CDate::Julian) -> DTimePlus::CDate<CJulianCalendar>(1990, March, 4)
Because of the move to templates, I had a problem getting CLTimeSpan and CLTimeOfDay to compile because there is a circular dependence between these two classes. When you make a class template based, using forward class references to resolve these issues now no longer works. Instead the CLTimeOfDay is now also template based which works around the circular reference issue. An example of the change this implies to client code is as follows:

CLTimeOfDay y(10, 12, 14) -> DTimePlus::CLTimeOfDay<> y(10, 12, 14);
Moved all the classes and methods out of the global namespace and into a namespace called "DTimePlus"
Implemented extensive support for the Moslem Calendar. The algorithms are taken from the book "Calendrical Calculations, The Millenium Edition" by Edward M. Reingold and Nachum Dershowitz. The 4 most common forms of the Moslem Arithmetic calendar are supported namely the 15th and 16th year leap year rules as well as the Civil Epoch (16 July 622 C.E. O.S) and the Astronomical Epoch (15 July 622 C.E. O.S). These are implemented by the template classes CMoslemCalendarCivil16, CMoslemCalendarCivil15, CMoslemCalendarAstronomical16 and finally CMoslemCalendarAstronomical15. For example to create a date which represents Muharram 1, A.H. 1 using the Civil epoch and the 16th year leap rule you would use:

DTimePlus::CDate<CMoslemCalendarCivil16> FirstDayOfMoslemEpoch(1, Muharram, 1);

The Moslem month's are defined as a standard enum in the DTimePlus namespace just like you can use the Julian / Gregorian month names.
Optimized the operation of the various Format methods.

v3.0 (22 April 2006)

Following a long term of hibernation, DTime is now back. It is now freeware as opposed to Shareware, has been extensively reworked and has been renamed to DTime+.
Updated copyright details.
Classes are no longer derived from CObject as this was not really necessary.
Reworked the layout of the directories to ship as a more standard collection of standard C++ modules. Like other code provided by the author. the code now does not ship pre-built as an extension dll, instead it is provided as a pure source code library. You are of course free to include DTime+ in an extension dll if you so desire.
Removed the timeframe concept from CLDate instance data.
Removed support for ET and DeltaT. If you would like support for this please check out the author's AA+ class framework at http://www.naughter.com/aa.html.
Integrating the concept of a Windows locale (LCID) into all functions which return strings. This allows the code to easily mix and match calendar strings from multiple languages in the one program.
Because the code now tightly integrates with the Win32 NLS API's, DTime+ now does not need to carry around any resources of its own.
Removed all virtual functions from all DTime+ classes.
Removed the need to use friend classes.
Updated the references to where the basic algorithms used by DTime+ are based on. See the comments in the CDate::Set() method.
Provided updated UI support via the standard Windows date / time controls.
Updated the code to ensure relatively clean compiles using Visual Studio 2003 and 2005 (Still warnings in 2005 with calling the so called unsafe "C" runtime functions).
Did a full spell check and update of the documentation.

11 April 2000

Refresh of the code following the creation of my new site http://www.naughter.com.

v2.22 (14 May 1999)

Updated 4 files for DTime. This fixes a number of problems DTime was having when compiled with Visual C++ 6, Just copy the three cpp files into your DTime "SRC" and the one h file into your DTime "Include" directory over the existing files of the same name. 4 files are included in total (1 file which was modified in v2.21) meaning that you do not need to apply the v2.21 patch as the v2.22 patch includes all of the changes since the v2.2 main release.

v2.21 (17 July 1998)

Updated 2 files for DTime which fixes a problem with usage of DTime in a multithreading application. Basically it boiled down to code in DTime which was making changes to a global array "MonthLength" from two threads. Now a local array is used, thus preventing the problem. Just copy the two files into your DTime "SRC" directory over the existing files of the same name.

v2.2

Modification to serialize functions to save space on disk.
Replaced use of AFX_EXT_API and AFX_EXT_CLASS to allow use of DTime in another extension dll.
Added support for using the DTime source code directly in your application instead of through an Extension DLL.
Added a DTIME_NO_OLE_SUPPORT macro which removes the dependency of DTime on the MFC OLE dlls. Note that this can only be used if you include the DTime source code directly in your application.
Changed the load address of all variants of the DTime dll. This reduces the occurrences of dll collisions at process load up time.
Made DTime and its sample programs compatible with VC++ 5.0.
Added support in DTime for Proleptic Julian and Gregorian Calendars.
Added support for converting from a CLDate to a COleDateTime.
Removed the ‘Apply Now’ buttons from the data entry dialogs.
Major revamp of the install program to give it a more professional look.
Major update to the help file. Includes changes suggested by customers such as making its look and feel more consistent with VC++ books online and Windows 95 Help. Also fixed a number of mistakes which were in the 2.1 version of the help file.

v2.1

v2.0 translation to German.
Addition of extra CDate and CLDate functions to interact with SYSTEMTIME and FILETIME SDK structures.
Addition of extra CDate, CLTimeOfDay and CLDate functions which return a tm struct.
Major modification to CLDate::SetTimeFrame function to correctly handle time zones other than GMT correctly.
Number of other minor tweaks and bug fixes following feedback from customers.
Fixed a number of anomalies in the help file dating back to v1.1.
Enhanced the data entry methods DTime supports. It now allows a Julian Day to be entered. Also additional flags have been added to control how the data entry operates.
All the arithmetic operators have been enhanced to handle invalid state of their operands, instead of just asserting when an invalid operand is found.

v2.0

Tighter integration with Win32 NLSAPI.
Provision of a real control panel applet.
Enhanced data entry routines.
Numerous bug fixes.
Removal of OS detection routine to separate package.
Removal of Pushpin class to separate package.
Removal of DOS and Win16 code no longer used.
DTime has dropped support for millisecond fields in the CLTimeOfDay, CLTimeSpan and CLDate classes. You will need to check code that was used with DTime v1.x to make sure the correct constructors are being called. This functionality was removed following customer feedback about its usefulness. The extra fields required to support milliseconds also introduced a number of subtle bugs that were discovered during testing of v2.0.

v1.11

v1.0 translation to German.

v1.1

Port to Win16 and DOS.
Implementation of a comprehensive OS detection routine.
A number of classes and functions to make code portable across OS platforms.
Addition of a number of member functions to return a C runtime tm struct version.
TermDTime added and InitDTimeDll now renamed to InitDTime.
‘printf’ like function made available under Win16.
A CStringEx class which provides a Format method under Win16 and DOS and a LoadString method under DOS.

v1.0

Initial public Win32 release.

How to use

As DTime+ is provided as a C++ template class library, you simple need to #include the relevant header files (e.g. DTime+.h) in your project. You can also reference individual DTime+ headers also if you want. For example if you want to use the UI support for DTime+, you can include DTime+UI.h. On Windows you will need at least Visual C++ 2017 and compiled using /std:c++17, while on non-Windows platforms any recent copy of gcc should do.

CDate Index

Construction

CDate

Setting

Set

Static Constructors

Static Operations

DaysSinceEndPreviousYear

GetFullStringDayOfWeek

GetAbrStringDayOfWeek

GetFullStringMonth

GetAbrStringMonth

Operations

DaysSinceFirstOfYear

DaysSinceEndPreviousYear

GetFullStringDayOfWeek

GetAbrStringDayOfWeek

Construction based on this instance

Overloaded Arithmetic Operators

Display

GetWindowsFormatString

Serialization

CDate::CDate

CDate();

CDate(int32_t Year, uint16_t month, uint16_t Day, bool bDoAssert = true);

CDate(const SYSTEMTIME& SystemTime, bool bDoAssert = true);

CDate(const FILETIME& FileTime, bool bDoAssert = true);

CDate(int32_t Year, uint16_t month, uint16_t WeekOfMonth, DayOfWeek dow, bool bDoAssert = true);

CDate(int32_t Days, DateEpoch e, bool bDoAssert = true);

CDate(const CDate& d);

CDate(const CTime& ctime, bool bDoAssert = true);

CDate(const COleDateTime& oleTime, bool bDoAssert = true);

CDate(const String& sDate, const String& sFormat, bool bDoAssert = true);

Parameters

Year, Month, Day Indicates a year, month and day.

SystemTime A Win32 SDK SYSTEMTIME struct.

FileTime A Win32 SDK FILETIME struct.

d Indicates a CDate object that already exists.

ctime Indicates a CTime object that already exists.

WeekOfMonth The week of the month (1 - 5).

DayOfWeek The day of the week e.g. Sunday.

oleTime An OLE Date.

sDate A string representation of the date to construct

sFormat The format that the string date uses

bDoAsserts If set, the constructors will assert in debug mode if any of the parameters are invalid

Remarks

The default constructor creates an invalid CDate
if WeekOfMonth is 5 then it means the last week in the month. This is similar to the way the Win32 SDK operates.
Only the day, month and year values in the SYSTEMTIME structure and CTime class are used.
See the Structures used by the classes for the definition of the enums used to represent the day of week.
sDate is a legal date string as defined by sFormat
sFormat is a 5 character string where the first 3 indicate the order of the month/day/year, the fourth character indicates the length of the year, and the fifth character indicates the separator. For example:

sFormat sDate Result

‘dmy2/’ ‘20/03/96’ 20th March 1996

‘mdy4-’ ‘03-28-1996’ 28th March 1996

This feature allows for the creation of CDate's from a string as entered in a masked edit field or from a parsed report.

CDate::Set

CDate& Set();

CDate& Set(int32_t Year, uint16_t month, uint16_t Day, bool bDoAssert = true);

CDate& Set(const SYSTEMTIME& SystemTime, bool bDoAssert = true);

CDate& Set(const FILETIME& FileTime, bool bDoAssert = true);

CDate& Set(int32_t Year, uint16_t month, uint16_t WeekOfMonth, DayOfWeek dow, bool bDoAssert = true);

CDate& Set(int32_t Days, CDate::DateEpoch e, bool bDoAssert = true);

CDate& Set(const CTime& ctime, bool bDoAssert = true);

CDate& Set(const COleDateTime& oleTime);

CDate& Set(const String& sDate, const String& sFormat, bool bDoAssert = true);

Parameters

See CDate Constructors

Remarks

These functions are actually called by the constructors. They allow a CDate’s value to be modified even after construction.

static CDate::CurrentSystemDate(bool bDoAssert = true);

Returns a CDate which represents the current UTC date as taken from the system clock.

static CDate::CurrentLocalDate(bool bDoAssert = true);

Returns a CDate which represents the current local date as taken from the system clock.

static CDate CDate::JDEpoch();

Returns a CDate which represents Julian Day Epoch i.e. 1st January -4712 (when specified in the Julian calendar)

static CDate CDate::MJDEpoch();

Returns a CDate which represents 1st January -4712 + 2400000 Days (which corresponds to 17 November 1858 in the Gregorian calendar)

static CDate CDate::Epoch1900();

Returns a CDate which represents 1st January 1900

static CDate CDate::Epoch1950();

Returns a CDate which represents 1st January 1950

static CDate CDate::EpochCTime();

Returns a CDate which represents a CTime of 0 seconds (i.e. 1st January 1970)

static CDate CDate::Epoch2000();

Returns a CDate which represents 1st January 2000

static CDate CDate::GregorianEpoch();

Returns a CDate which represents when the change from the Julian to Gregorian calendar occurred.

static bool CDate::IsLeap(int32_t Year);

returns true if the year is leap otherwise false.

Remarks

The routine correctly allows for the exception whereby dates in the Gregorian calendar are leap (or bissextile) if divisible by 4 with the following exception: the centurial years that are not divisible by 400, such as 1700, 1800, 1900, and 2100, are not leap years. The other century years, which are divisible by 400, are leap years, for instance 1600, 2000 and 2400. If we have instantiated for the Julian Calendars, then the simpler 4 year leap year rule is applied. If we have instantiated the CDate for the Moslem or Hebrew calendars, then their specific leap year / leap month rules will be applied.

static uint16_t CDate::DaysInYear(int32_t Year);

Returns the number of days in a year i.e. 366 if the year is leap otherwise 365, assuming we have instantiated the CDate class using the Gregorian or Julian Calendars. If instantiated for the Moslem or Hebrew calendars, then their specific leap year / leap month rules will be applied. In the Moslem calendar, a year can contain 354 or 355 days. In the Hebrew calendar, a year can contain 353, 354, 355, 383, 384 or 385 days.

static uint16_t CDate::DaysInMonth(int32_t Year, uint16_t month);

Returns the number of days in a month e.g. 31 for January, 28 for a common February, 29 for a leap February etc, assuming we have instantiated the CDate class using the Gregorian or Julian Calendars. If instantiated for the Moslem or Hebrew calendars, then their specific leap year / leap month rules will be applied.

static uint16_t CDate::DaysSinceFirstOfYear(int32_t Year, uint16_t month, uint16_t Day);

Returns the number of days since 1st of January. If the CDate class has been instantiated using the Moslem calendar, then the first of the year will correspond to the 1st day of the Moslem month Muharram. If the CDate class has been instantiated using the Hebrew calendar, then it returns the number of days since 1st day of Tishri. Note this function does not return the number of days since 1st of Nisan which is the 1st month in the Hebrew calendar because Hebrew New Year is 1st of Tishri which is the 7th month.

static uint16_t CDate::DaysSinceEndPreviousYear(int32_t Year, uint16_t month, uint16_t Day);

Returns the number of days since 0th of January (previous 31st December). If the CDate class has been instantiated using the Moslem calendar, then the end of the previous year will correspond to the 29th or 30th of the Moslem month Dhu al-Hijja. If the CDate class has been instantiated using the Hebrew calendar, then it returns the number of days since 0th of Tishri (previous 29th of Elul). Note this function does not return the number of days since the last day of Adar I or Adar II (if it is a leap year) because Hebrew New Year is 1st of Tishri which is the 7th month.

static String CDate::GetFullStringDayOfWeek();

Returns a representation of the day of week parameter as a String, returning for example ‘Sunday’, ‘Monday’ etc assuming you have constructed the CDate instance using the Julian or Gregorian calendar.

Remarks

The Locale value controls which windows locale and hence language should be used to return the string in.
The value is interpreted as defined in the Set functions.

See Also

CDate::GetAbrStringDayOfWeek

static String CDate::GetAbrStringDayOfWeek();

Returns an abbreviated representation for the day of week parameter as a String, returning for example ‘Sun’, ‘Mon’ etc assuming you have constructed the CDate instance using the Julian or Gregorian calendar.

Remarks

The Locale value controls which windows locale and hence language should be used to return the string in.
The value is interpreted as defined in the Set methods.

See Also

CDate::GetFullStringDayOfWeek

static String CDate::GetFullStringMonth();

Returns a String representation for the month parameter, returning for example ‘January’, ‘February’ etc assuming you have constructed the CDate instance using the Julian or Gregorian calendar.

See Also

CDate::GetAbrStringMonth

static String CDate::GetAbrStringMonth();

Returns a String representation for the month parameter, returning for example ‘Jan’, ‘Feb’ etc assuming you have constructed the CDate instance using the Julian or Gregorian calendar.

See Also

CDate::GetFullStringMonth

uint16_t CDate::DaysSinceFirstOfYear() const;

Returns the number of days since 1st of January for this instance. If the CDate class has been instantiated using the Moslem calendar, then the first of the year will correspond to the 1st day of the Moslem month Muharram.

uint16_t CDate::DaysSinceEndPreviousYear() const;

Returns the number of days since 0th of January (previous 31st December) for this instance. If the CDate class has been instantiated using the Moslem calendar, then the end of the previous year will correspond to 29th or 30th of the Moslem month Dhu al-Hijja.

CDate::DateS CDate::GetDate() const;

Returns a DateS structure for this instance.

uint16_t CDate::GetDay() const;

Returns the Day of the month for this instance (1 - 31).

uint16_t CDate::GetMonth() const;

Returns the Month enum for this instance (January(1) - December (12)).

int32_t CDate::GetYear() const;

Returns the Year for this instance.

int32_t CDate::GetCEBCEYear(bool& IsCE) const;

Returns the Current Epoch / Before Current Epoch year for this instance.

e.g.

bool bIsCE;

CDate<CGregorianCalendar> x(1990, January, 32);

int32_t y = x.GetCEBCEYear(bIsCE); //y will be 1990, bIsCE will be true

x.Set(-1990, January, 32);

y = x.GetCEBCEYear(bIsCE); //y will be 1989, bIsCE will be false

int32_t CDate::Get2DigitYear() const;

Returns the last 2 digits of the year.

e.g.

CDate<CGregorianCalendar> x(1995, January, 15);

int32_t y = x.Get2DigitYear();

assert(y == 95);

int32_t CDate::GDN() const;

Returns the number of days for this instance since the Gregorian Epoch.

int32_t CDate::JD() const;

Returns the Julian Day or number of days for this instance since 1st January -4712.

bool CDate::IsLeap() const;

Returns true if the year for this instance is leap otherwise false.

uint16_t CDate::DaysInYear() const;

Returns the number of days for this instance’s year.

uint16_t CDate::DaysInMonth() const;

Returns the number of days for this instance’s month.

void CDate::AddYear(int Years = 1);

Adds a number of years to this instance.

void CDate::AddMonth(int Months = 1);

Adds a number of months to this instance.

Remarks

Invalid Day of Months are always rounded down and will not overflow into subsequent months. e.g. if you add 1 month to March 31 you will get April 30.

void CDate::AddWeek(int Weeks = 1);

Adds a number of weeks i.e. 7 days to this instance.

uint16_t CDate::GetDayOfWeek() const;

Returns the day of week for this instance. (1 for Sunday, 2 for Monday, and so forth).

Remarks

See the Structures used by the classes for the enums compatible with how the day of week is returned from this member function.

String CDate::GetFullStringDayOfWeek() const;

Returns the day of week for this instance as a String. e.g. 'Sunday', 'Monday' etc assuming you have constructed a Julian or Gregorian CDate instance.

See Also

CDate::GetAbrStringDayOfWeek

String CDate::GetAbrStringDayOfWeek() const;

Returns an abbreviated String version for the day of week for this instance. e.g. ‘Sun’, ‘Mon’ etc assuming you have constructed a Julian or Gregorian CDate instance.

See Also

CDate::GetFullStringDayOfWeek

String CDate::GetFullStringMonth() const;

Returns the full String version for the month for this instance. e.g. ‘January’, ‘February’ etc assuming you have constructed a Julian or Gregorian CDate instance.

See Also

CDate::GetAbrStringMonth

String CDate::GetAbrStringMonth() const;

Returns an abbreviated String version for the month for this instance. e.g. ‘Jan’, ‘Feb’ etc assuming you have constructed a Julian or Gregorian CDate instance.

See Also

CDate::GetFullStringMonth

bool CDate::GetAsSystemTime(SYSTEMTIME& SystemTime) const;

Returns a Win32 SDK SYSTEMTIME struct version of this instance if this method succeeds by returning true.

Remarks

If the date is outside of the allowable range which a SYSTEMTIME struct can hold or the CDate instance is invalid, then the method will return false.

bool CDate::GetAsFileTime(FILETIME& FileTime) const;

Returns a Win32 SDK FILETIME struct version of this instance if this method succeeds by returning true.

Remarks

If the date is outside of the allowable range which a FILETIME struct can hold or the CDate is invalid, then the method will return false.

bool CDate::GetAsTM(tm& time) const;

Returns a ‘C’ runtime tm struct version of this instance if this method succeeds by returning true.

uint16_t CDate::GetWeekOfYear() const;

Returns the week of the year for this instance. As an example of how this is determined:

Suppose the 1^st of January occurred on a Thursday and the day of week considered the beginning of the week is Monday as specified by the locale value 'Locale'. The following results would then be obtained:

Date GetWeekOfYear() return value

Thursday 1^st 0

Friday 2^nd 0

Saturday 3^rd 0

Sunday 4^th 0

Monday 5^th 1

Tuesday 6^th 1

Monday 12^th 2

uint16_t CDate::GetWeekOfMonth() const;

Returns the week of the month for this instance. As an example of how this is determined:

Suppose the 1^st of the month occurred on a Thursday and the day of week considered the beginning of the week is Monday as specified by the locale value 'Locale', The following results would then be obtained:

Date GetWeekOfMonth() return value

Thursday 1^st 0

Friday 2^nd 0

Saturday 3^rd 0

Sunday 4^th 0

Monday 5^th 1

Tuesday 6^th 1

Monday 12^th 2

bool CDate::IsValid() const;

Returns true if this instance is valid otherwise false.

e.g. CDate<CGregorianCalendar> Inval(1990, January, 33, false); //an invalid day of month

assert(IsValid(Inval) == false);

int32_t CDate::Collate() const;

Returns a int32_t which can be used in a date collation purposes i.e. the year value is stored as units of 10000, the month value is stored as units of 100 and the day value as units of 1.

ee.g. CDate<CGregorianCalendar> x(1978, March, 3);

assert(x.Collate() = 19780403L);/p>

CDate CDate::FirstThisMonth();

Returns a CDate for the first of the month for this instance

e.g. CDate<CGregorianCalendar> x(1990, March, 4);

CDate<CGregorianCalendar> f(x.FirstThisMonth());

assert(f = CDate<CGregorianCalendar>(1990, March, 1);

See Also

CDate::LastThisMonth

CDate CDate::LastThisMonth();

Returns a CDate for the last of the month for this instance

e.g. CDate<CGregorianCalendar> x(1990, March, 4);

CDate<CGregorianCalendar> f(x.LastThisMonth());

assert(f = CDate<CGregorianCalendar>(1990, CDate::March, 31);

See Also

CDate::FirstThisMonth

CDate CDate::FirstThisYear();

Returns a CDate for the 1st January for this instance

e.g. CDate<CGregorianCalendar> x(1990, March, 4);

CDate<CGregorianCalendar> f(x.FirstThisYear());

assert(f = CDate<CGregorianCalendar>(1990, January, 1);

See Also

CDate::LastThisYear

CDate CDate::LastThisYear();

Returns a CDate for the 31st December for this instance

e.g. CDate<CGregorianCalendar> x(1990, March, 4);

CDate<CGregorianCalendar> f(x.LastThisYear());

assert(f = CDate<CGregorianCalendar>(1990, December, 31);

See Also

CDate::FirstThisYear

CDate& CDate::operator=(const CDate& d);

Copies a CDate into this CDate and returns a reference to this instance

CDate CDate::operator+(int32_t Days) const;

CDate CDate::operator-(int32_t Days) const;

Standard arithmetic operators to add and subtracts a number of days.

e.g. CDate<CGregorianCalendar> Tomorrow(CDate<CGregorianCalendar>::CurrentLocalDate()) + 1;

int32_t OneMonth = CDate<CGregorianCalendar>(1990, March, 4) - CDate<CGregorianCalendar>(1990, February, 4);

CDate<CGregorianCalendar> Yesterday(CDate<CGregorianCalendar>::GetLocalDate()) - 1;

CDate& CDate::operator+=(int32_t Days);

CDate& CDate::operator-=(int32_t Days);

Standard arithmetic increment and decrement operators

e.g. CDate<CGregorianCalendar> x(1990, January, 1);

x += 7;

assert(x == CDate<CGregorianCalendar>(1990, January, 8));

x -= 7;

assert(x == CDate<CGregorianCalendar>(1990, January, 1));

CDate& CDate::operator++();

Standard arithmetic increment operator. Adds one day to this instance

CDate& CDate::operator--();

Standard arithmetic decrement operator. Subtracts one day from this instance.

bool CDate::operator==(const CDate& d) const;

bool CDate::operator>(const CDate& d) const;

bool CDate::operator>=(const CDate& d) const;

bool CDate operator<(const CDate& d) const;

bool CDate operator<=(const CDate& d) const;

bool CDate operator!=(const CDate& d) const;

Standard arithmetic equality operators.

String CDate::GetWindowsFormatString(LPCWSTR lpLocaleName = LOCALE_NAME_USER_DEFAULT)

Returns a CDate::Format string appropriate for the specified windows locale as specified by 'lpLocaleName'

See Also

CDate::Format

String CDate::Format(const String& sFormat) const;

Generates a formatted string that corresponds to this CDate object.

The sFormat string supports the following replaceable parameters:

%a Abbreviated weekday name
%A Full weekday name
%b Abbreviated month name
%B Full month name
%d Day of month as decimal number (01 - 31)
%j Day of year as decimal number (001 - 366)
%m Month as decimal number (01 - 12)
%U Week of year as decimal number
%w Weekday as decimal number (1 - 7; Sunday is 1)
%x Short date representation, appropriate to current locale
%y Year without century, as decimal number (00 - 99)
%Y Year with century, as decimal number
%#x long date representation, appropriate to current locale
%#d, %#j, %#m, %#U, %#y Remove leading zeros (if any)

Remarks

If the CDate is invalid then an empty string will be returned.

See Also

CDate::GetWindowsFormatString

void CDate::Serialize(CArchive& ar);

Standard MFC override to allow streaming of this CDate to and from an archive. The space taken is 6 bytes (4 data bytes + 2 schema bytes).

Remarks

As of v3 of DTime+, the serialization is not backward compatible with earlier versions.

friend CArchive& operator<<(CArchive& ar, CDate& Date);

Simply calls the Serialize method of ‘Date’, asserting that the archive ‘ar’ is storing.

friend CArchive& operator>>(CArchive& ar, CDate& Date);

Simply calls the Serialize method of ‘Date’, asserting that the archive ‘ar’ is loading.

CLTimeSpan Index

Construction

CLTimeSpan

Setting

Set

Static Constructors

Operations

Overloaded Arithmetic Operators

Overloaded Equality Operators

Display

Serialization

CLTimeSpan Constructors

CLTimeSpan();

CLTimeSpan(int32_t Day, uint16_t Hour, uint16_t Minute, uint16_t Second);

CLTimeSpan(const CLTimeSpan& lts);

CLTimeSpan(const CTimeSpan& ts);

CLTimeSpan(const CLTimeOfDay& tod);

CLTimeSpan(const COleDateTimeSpan& oleTimeSpan);

CLTimeSpan(const int64_t& Seconds);

Parameters

Day, Hour, Minute, Second Indicates a count of day, hour, minute and second values.

lts Indicates a CLTimeSpan object that already exists.

ts Indicates a CTimeSpan object that already exists.

tod Indicates a CLTimeOfDay object that already exists.

Seconds Indicates a count of seconds as a 64 bit integer.

oleTime An OLE time span.

Remarks

The default constructor creates an invalid CLTimeSpan

CLTimeSpan Set functions

CLTimeSpan& Set();

CLTimeSpan& Set(int32_t Day, uint16_t Hour, uint16_t Minute, uint16_t Second);

CLTimeSpan& Set(const CTimeSpan& ts);

CLTimeSpan& Set(const CLTimeOfDay& tod);

CLTimeSpan& Set(const COleDateTimeSpan& oleTimeSpan);

CLTimeSpan& Set(const int64_t& Seconds);

Parameters

See CLTimeSpan Constructors

Remarks

These functions are actually called by the constructors. They allow a CLTimeSpan’s value to be modified even after construction.

static CLTimeSpan CLTimeSpan::OneDay();

Returns a CLTimeSpan which represents one day.

static CLTimeSpan CLTimeSpan::OneHour();

Returns a CLTimeSpan that represents one hour.

static CLTimeSpan CLTimeSpan::OneMinute();

Returns a CLTimeSpan that represents one minute.

static CLTimeSpan CLTimeSpan::OneSecond();

Returns a CLTimeSpan that represents one second.

int32_t CLTimeSpan::GetTotalDays() const;

Returns the total number of days this CLTimeSpan contains.

e.g. CLTimeSpan x(10, 12 , 13, 14)

assert(x.GetTotalDays() == 10);

uint16_t CLTimeSpan::GetHours() const;

Returns the number of hours this CLTimeSpan contains.

e.g. CLTimeSpan x(10, 12 , 13, 14)

assert(x.GetHours() == 12);

uint16_t CLTimeSpan::GetMinutes() const;

Returns the number of minutes this CLTimeSpan contains.

e.g. CLTimeSpan x(10, 12 , 13, 14)

assert(x.GetMinutes() == 13);

uint16_t CLTimeSpan::GetSeconds() const;

Returns the number of seconds this CLTimeSpan contains.

e.g. CLTimeSpan x(10, 12 , 13, 14)

assert(x.GetSeconds() == 14);

bool CLTimeSpan::IsValid() const;

Returns true if this instance is valid otherwise false.

e.g. CLTimeSpan Inval;

assert(IsValid(Inval) == false);

CLTimeSpan& CLTimeSpan::Negate();

Negates this CLTimeSpan instance and returns a reference to it.

e.g. CLTimeSpan x(10, 12 , 13, 14)

x.Negate();

assert(x == CLTimeSpan(-10, 12, 13, 14);

bool CLTimeSpan::IsPositiveSpan() const;

Returns true if this CLTimeSpan represents a positive time span (value >= 0 seconds) else false is returned.

e.g. CLTimeSpan x(-10, 12 , 13, 14)

assert(!x.IsPositiveSpan());

double CLTimeSpan::SecondsAsDouble() const;

Returns the underlying number of seconds this CLTimeSpan contains as a double.

CLTimeSpan& CLTimeSpan::operator=(const CLTimeSpan& TimeSpan)

Copies a CLTimeSpan into this CLTimeSpan and returns a reference to this instance

CLTimeSpan CLTimeSpan::operator+(const CLTimeSpan& TimeSpan) const;

CLTimeSpan CLTimeSpan::operator-(const CLTimeSpan& TimeSpan) const;

Standard arithmetic operators to add and subtracts CLTimeSpan’s.

CLTimeSpan& CLTimeSpan::operator+=(const CLTimeSpan& TimeSpan);

CLTimeSpan& CLTimeSpan::operator-=(const CLTimeSpan& TimeSpan);

Standard arithmetic auto increment and decrement operators.

CLTimeSpan CLTimeSpan::operator*(uint16_t Multiplier) const;

CLTimeSpan operator*(uint16_t Multiplier, const CLTimeSpan& TimeSpan);

CLTimeSpan CLTimeSpan::operator/(uint16_t divisor) const;

Standard arithmetic operators to multiply and divide CLTimeSpan’s.

CLTimeSpan& CLTimeSpan::operator*=(uint16_t Multiplier);

CLTimeSpan& CLTimeSpan::operator/=(uint16_t Divisor);

Standard arithmetic auto multiply and divide operators.

bool CLTimeSpan::operator==(const CLTimeSpan& TimeSpan) const;

bool CLTimeSpan::operator>(const CLTimeSpan& TimeSpan) const;

bool CLTimeSpan::operator>=(const CLTimeSpan& TimeSpan) const;

bool CLTimeSpan::operator<(const CLTimeSpan& TimeSpan) const;

bool CLTimeSpan::operator<=(const CLTimeSpan& TimeSpan) const;

bool CLTimeSpan::operator!=(const CLTimeSpan& TimeSpan) const;

Standard arithmetic equality operators.

String CLTimeSpan::GetWindowsFormatString(LPCWSTR lpLocaleName = LOCALE_NAME_USER_DEFAULT)

Returns a CLTimeSpan::Format string appropriate appropriate for the specified windows locale as specified by 'lpLocaleName'.

See Also

CLTimeSpan::Format

String CLTimeSpan::Format(const String& sFormat) const;

Generates a formatted string that corresponds to this CLTimeSpan object.

The sFormat string supports the following replaceable parameters:

%D Total days in this CLTimeSpan
%H Hours in this CLTimeSpan (00 - 23)
%M Minutes in the current hour in this CLTimeSpan (00 - 59)
%S Seconds in the current minute in this CLTimeSpan (00 - 59)
%% Percent sign
%#H, %#M, %#S Remove leading zeros (if any).

Remarks

If the CLTimeSpan is invalid then an empty string will be returned

See Also

CLTimeSpan::GetWindowsFormatString

void CLTimeSpan::Serialize(CArchive& ar);

Standard MFC override to allow streaming of this CLTimeSpan to and from an archive. The space taken is 10 bytes (8 data bytes + 2 schema bytes).

Remarks

As of v3 of DTime+, the serialization is not backward compatible with earlier versions.

friend CArchive& operator<<(CArchive& ar, CLTimeSpan& TimeSpan);

Simply calls the Serialize method of ‘TimeSpan’, asserting that the archive ‘ar’ is storing.

friend CArchive& operator>>(CArchive& ar, CLTimeSpan& TimeSpan);

Simply calls the Serialize method of ‘TimeSpan’, asserting that the archive ‘ar’ is loading.

CLLTimeSpan Index

Construction

CLLTimeSpan

Setting

Set

Static Constructors

Operations

Overloaded Arithmetic Operators

Overloaded Equality Operators

Display

Serialization

CLLTimeSpan Constructors

CLLTimeSpan();

CLLTimeSpan(int32_t Day, uint16_t Hour, uint16_t Minute, double Second);

CLLTimeSpan(const CLLTimeSpan& lts);

CLLTimeSpan(const CTimeSpan& ts);

CLLTimeSpan(const COleDateTimeSpan& oleTimeSpan);

CLLTimeSpan(const double& Seconds);

Parameters

Day, Hour, Minute, Second Indicates a count of day, hour, minute and second values.

lts Indicates a CLTimeSpan object that already exists.

ts Indicates a CTimeSpan object that already exists.

Seconds Indicates a count of seconds as a 64 bit integer.

oleTime An OLE time span.

Remarks

The default constructor creates an invalid CLLTimeSpan

CLLTimeSpan Set functions

CLLTimeSpan& Set();

CLLTimeSpan& Set(int32_t Day, uint16_t Hour, uint16_t Minute, double Second);

CLLTimeSpan& Set(const CTimeSpan& ts);

CLLTimeSpan& Set(const COleDateTimeSpan& oleTimeSpan);

CLLTimeSpan& Set(const int64_t& Seconds);

Parameters

See CLLTimeSpan Constructors

Remarks

These functions are actually called by the constructors. They allow a CLLTimeSpan’s value to be modified even after construction.

static CLLTimeSpan CLTimeSpan::OneDay();

Returns a CLTimeSpan which represents one day.

static CLLTimeSpan CLTimeSpan::OneHour();

Returns a CLTimeSpan that represents one hour.

static CLLTimeSpan CLTimeSpan::OneMinute();

Returns a CLTimeSpan that represents one minute.

static CLLTimeSpan CLTimeSpan::OneSecond();

Returns a CLTimeSpan that represents one second.

int32_t CLLTimeSpan::GetTotalDays() const;

Returns the total number of days this CLTimeSpan contains.

e.g. CLTimeSpan x(10, 12 , 13, 14)

assert(x.GetTotalDays() == 10);

uint16_t CLLTimeSpan::GetHours() const;

Returns the number of hours this CLTimeSpan contains.

e.g. CLTimeSpan x(10, 12 , 13, 14)

assert(x.GetHours() == 12);

uint16_t CLLTimeSpan::GetMinutes() const;

Returns the number of minutes this CLTimeSpan contains.

e.g. CLTimeSpan x(10, 12 , 13, 14)

assert(x.GetMinutes() == 13);

double CLLTimeSpan::GetSeconds() const;

Returns the number of seconds this CLTimeSpan contains.

e.g. CLTimeSpan x(10, 12 , 13, 14)

assert(x.GetSeconds() == 14);

bool CLLTimeSpan::IsValid() const;

Returns true if this instance is valid otherwise false.

e.g. CLTimeSpan Inval;

assert(IsValid(Inval) == false);

CLTimeSpan& CLLTimeSpan::Negate();

Negates this CLTimeSpan instance and returns a reference to it.

e.g. CLTimeSpan x(10, 12 , 13, 14)

x.Negate();

assert(x == CLTimeSpan(-10, 12, 13, 14);

bool CLLTimeSpan::IsPositiveSpan() const;

Returns true if this CLTimeSpan represents a positive time span (value >= 0 seconds) else false is returned.

e.g. CLTimeSpan x(-10, 12 , 13, 14)

assert(!x.IsPositiveSpan());

CLLTimeSpan& CLLTimeSpan::operator=(const CLLTimeSpan& TimeSpan)

Copies a CLLTimeSpan into this CLLTimeSpan and returns a reference to this instance

CLLTimeSpan CLLTimeSpan::operator+(const CLLTimeSpan& TimeSpan) const;

CLLTimeSpan CLLTimeSpan::operator-(const CLLTimeSpan& TimeSpan) const;

Standard arithmetic operators to add and subtracts CLTimeSpan’s.

CLLTimeSpan& CLLTimeSpan::operator+=(const CLLTimeSpan& TimeSpan);

CLLTimeSpan& CLLTimeSpan::operator-=(const CLLTimeSpan& TimeSpan);

Standard arithmetic auto increment and decrement operators.

CLLTimeSpan CLLTimeSpan::operator*(double Multiplier) const;

CLLTimeSpan operator*(double Multiplier, const CLTimeSpan& TimeSpan);

CLLTimeSpan CLTimeSpan::operator/(double divisor) const;

Standard arithmetic operators to multiply and divide CLLTimeSpan’s.

CLLTimeSpan& CLLTimeSpan::operator*=(double Multiplier);

CLLTimeSpan& CLLTimeSpan::operator/=(double Divisor);

Standard arithmetic auto multiply and divide operators.

bool CLLTimeSpan::operator==(const CLLTimeSpan& TimeSpan) const;

bool CLLTimeSpan::operator>(const CLLTimeSpan& TimeSpan) const;

bool CLLTimeSpan::operator>=(const CLLTimeSpan& TimeSpan) const;

bool CLLTimeSpan::operator<(const CLLTimeSpan& TimeSpan) const;

bool CLLTimeSpan::operator<=(const CLLTimeSpan& TimeSpan) const;

bool CLLTimeSpan::operator!=(const CLLTimeSpan& TimeSpan) const;

Standard arithmetic equality operators.

String CLLTimeSpan::Format(const String& sFormat) const;

Generates a formatted string that corresponds to this CLLTimeSpan object.

The sFormat string supports the following replaceable parameters:

%D Total days in this CLLTimeSpan
%H Hours in this CLLTimeSpan (00 - 23)
%M Minutes in the current hour in this CLTimeSpan (00 - 59)
%S Seconds in the current minute in this CLTimeSpan (00 - 59.999...)
%% Percent sign
%#H, %#M, %#S Remove leading zeros (if any).

Remarks

If the CLLTimeSpan is invalid then an empty string will be returned

void CLLTimeSpan::Serialize(CArchive& ar);

Standard MFC override to allow streaming of this CLTimeSpan to and from an archive. The space taken is 10 bytes (8 data bytes + 2 schema bytes).

Remarks

As of v3 of DTime+, the serialization is not backward compatible with earlier versions.

friend CArchive& operator<<(CArchive& ar, CLLTimeSpan& TimeSpan);

Simply calls the Serialize method of ‘TimeSpan’, asserting that the archive ‘ar’ is storing.

friend CArchive& operator>>(CArchive& ar, CLLTimeSpan& TimeSpan);

Simply calls the Serialize method of ‘TimeSpan’, asserting that the archive ‘ar’ is loading.

CLTimeOfDay Index

Constructors

CLTimeOfDay

Setting

Set

Static Constructors

Static Operations

Operations

Overloaded Arithmetic Operators

operator=

operator+,-

operator+=.-=

Overloaded Equality Operators

operator==, > etc.

Display

GetWindowsFormatString

Serialization

CLTimeOfDay Constructors

CLTimeOfDay();

CLTimeOfDay(uint16_t Hour, uint16_t Minute, uint16_t Second, bool bDoAssert = true);

CLTimeOfDay(const SYSTEMTIME& st, bool bDoAssert = true);

CLTimeOfDay(const CLTimeOfDay& ltod);

CLTimeOfDay(uint32_t TotalSeconds, bool bDoAssert = true);

Parameters

Hour, Minute, Second Indicates a hour, minute and second values.

st A Win32 SYSTEMTIME structure.

ltod Indicates an existing CLTimeOfDay instance.

TotalSeconds Indicates a accumulated number of seconds.

bDoAsserts if set, the constructors will assert in debug mode if any of the parameters are invalid

Remarks

The default constructor creates an invalid CLTimeOfDay

CLTimeOfDay Set functions

CLTimeOfDay& Set();

CLTimeOfDay& Set(uint16_t Hour, uint16_t Minute, uint16_t Second, bool bDoAssert = true);

CLTimeOfDay& Set(const SYSTEMTIME& st, bool bDoAssert = true);

CLTimeOfDay& Set(uint32_t TotalSeconds, bool bDoAssert = true);

Parameters

See CLTimeOfDay Constructors

Remarks

These methods are actually called by the constructors. They allow a CLTimeOfDay’s value to be modified even after construction

static CLTimeOfDay CLTimeOfDay::CurrentSystemTime();

Returns a CLTimeOfDay which represents the current UTC time of day as taken from the system clock.

static CLTimeOfDay CLTimeOfDay::CurrentLocalTime();

Returns a CLTimeOfDay which represents the current Local time of day as taken from the system clock.

static CLTimeOfDay CLTimeOfDay::Midnight();

Returns a CLTimeOfDay that represents midnight.

static CLTimeOfDay CLTimeOfDay::Midday();

Returns a CLTimeOfDay that represents midday.

static String CLTimeOfDay::GetAMString();

Returns the string to used for the 'AM' indicator for the current user locale.

static String CLTimeOfDay::GetPMString();

Returns the string to used for the 'PM' indicator for the current user locale.

uint16_t CLTimeOfDay::GetHours() const;

Returns the number of hours this CLTimeOfDay contains.

e.g. CLTimeOfDay<> x(12 , 13, 14, 15)

assert(x.GetHours() == 12);

uint16_t CLTimeOfDay::GetMinutes() const;

Returns the number of minutes this CLTimeOfDay contains.

e.g. CLTimeOfDay<> x(12 , 13, 14, 15)

assert(x.GetMinutes() == 13);

uint16_t CLTimeOfDay::GetSeconds() const;

Returns the number of seconds this CLTimeOfDay contains.

e.g. CLTimeOfDay<> x(12 , 13, 14, 15)

assert(x.GetSeconds() == 14);

uint32_t CLTimeOfDay::GetTotalSeconds() const;

Returns the total number of seconds this CLTimeOfDay contains.

e.g. CLTimeOfDay<> x(0 , 1, 14, 15)

assert(x.GetTotalSeconds() == 74);

uint16_t CLTimeOfDay::GetAMPMHours() const;

Returns the 12 hour version of the hour this CLTimeOfDay represents.

e.g. CLTimeOfDay<> x(17 , 13, 14, 15)

assert(x.GetAMPMHour() == 5);

String CLTimeOfDay::GetAMPMString() const;

Returns the string to used for the 'AM'or 'PM' indicator for the current user locale for this instance's hour value.

bool CLTimeOfDay::IsValid() const;

Returns true if this instance is valid otherwise false.

e.g. CLTimeOfDay<> Inval;

assert(IsValid(Inval) == false);

uint32_t CLTimeOfDay::Collate() const;

Returns a uint32_t which can be used for time collation purposes i.e. the hours value is stored as units of 10000, the minutes value is stored as units of 100 and the seconds value as units of 1.

e.g. CLTimeOfDay<> x(13, 12, 11);

assert(x.Collate() = 131211L);

bool CLTimeOfDay::GetAsSystemTime(SYSTEMTIME& SystemTime) const;

Returns a SYSTEMTIME structure representing this CLTimeOfDay

Remarks

Only the wHour, wMinute, wSecond parameters of the SYSTEMTIME struct are filled in. All the other values are set to 0.

bool CLTimeOfDay::GetAsTM(tm& time) const;

Returns a ‘C’ runtime tm struct version of this instance.

CLTimeOfDay& CLTimeOfDay::operator=(const CLTimeOfDay& Tod);

Copies a CLTimeOfDay into this CLTimeOfDay instance and returns a reference to this instance.

CLTimeOfDay CLTimeOfDay::operator+(const CLTimeSpan& TimeSpan) const;

CLTimeOfDay CLTimeOfDay::operator-(const CLTimeSpan& TimeSpan) const;

Standard arithmetic operators to add and subtracts CLTimeOfDay’s.

CLTimeOfDay& CLTimeOfDay::operator+=(const CLTimeSpan& TimeSpan);

CLTimeSpan& CLTimeOfDay::operator-=(CLTimeSpan& TimeSpan);

Standard arithmetic auto increment and decrement operators.

bool CLTimeOfDay::operator==(const CLTimeOfDay& Tod) const;

bool CLTimeOfDay::operator>(const CLTimeOfDay& Tod) const;

bool CLTimeOfDay::operator>=(const CLTimeOfDay& Tod) const;

bool CLTimeOfDay::operator<(const CLTimeOfDay& Tod) const;

bool CLTimeOfDay::operator<=(const CLTimeOfDay& Tod) const;

bool CLTimeOfDay::operator!=(const CLTimeOfDay& Tod) const;

Standard arithmetic equality operators.

String CLTimeOfDay::GetWindowsFormatString(LPCWSTR lpLocaleName = LOCALE_NAME_USER_DEFAULT)

Returns a CLTimeOfDay::Format string appropriate for the specified windows locale as specified by 'lpLocaleName'

See Also

CLTimeOfDay::Format

String CLTimeOfDay::Format(const String& sFormat) const;

Generates a formatted string that corresponds to this CLTimeOfDay object.

The sFormat string supports the following replaceable parameters:

%H Hours in the current day
%M Minutes in the current hour
%h 12 Hour format Hours in this CLTimeSpan (00 - 12)
%P AM / PM indicator for the current user locale
%S Seconds in the current minute
%% Percent sign
%x Time Of Day representation for the current user locale
%#H, %#h, %#M, %#S Remove leading zeros (if any).

Remarks

If the CLTimeOfDay is invalid then an empty string will be returned

See Also

CLTimeOfDay::GetWindowsFormatString

void CLTimeOfDay::Serialize(CArchive& ar);

Standard MFC override to allow streaming of this CLTimeOfDay to archive. The space taken is exactly 6 bytes (4 data bytes + 2 schema bytes).

Remarks

As of v3 of DTime+, the serialization is not backward compatible with earlier versions.

friend CArchive& operator<<(CArchive& ar, CLTimeSpan& Tod);

Simply calls the Serialize method of ‘Tod’, asserting that the archive ‘ar’ is storing.

friend CArchive& operator>>(CArchive& ar, CLTimeSpan& Tod);

Simply calls the Serialize method of ‘Tod’, asserting that the archive ‘ar’ is loading.

CLLTimeOfDay Index

Constructors

CLLTimeOfDay

Setting

Set

Static Constructors

Static Operations

Operations

Overloaded Arithmetic Operators

operator=

operator+,-

operator+=.-=

Overloaded Equality Operators

Display

Serialization

CLLTimeOfDay Constructors

CLLTimeOfDay();

CLLTimeOfDay(uint16_t Hour, uint16_t Minute, double Second, bool bDoAssert = true);

CLLTimeOfDay(const SYSTEMTIME& st, bool bDoAssert = true);

CLLTimeOfDay(const CLLTimeOfDay& ltod);

CLLTimeOfDay(double TotalSeconds, bool bDoAssert = true);

Parameters

Hour, Minute, Second Indicates a hour, minute and second values.

st A Win32 SYSTEMTIME structure.

ltod Indicates an existing CLLTimeOfDay instance.

TotalSeconds Indicates a accumulated number of seconds.

bDoAsserts if set, the constructors will assert in debug mode if any of the parameters are invalid

Remarks

The default constructor creates an invalid CLLTimeOfDay

CLLTimeOfDay Set functions

CLLTimeOfDay& Set();

CLLTimeOfDay& Set(uint16_t Hour, uint16_t Minute, double Second, bool bDoAssert = true);

CLLTimeOfDay& Set(const SYSTEMTIME& st, bool bDoAssert = true);

CLLTimeOfDay& Set(double TotalSeconds, bool bDoAssert = true);

Parameters

See CLLTimeOfDay Constructors

Remarks

These methods are actually called by the constructors. They allow a CLLTimeOfDay’s value to be modified even after construction

static CLLTimeOfDay CLLTimeOfDay::CurrentSystemTime();

Returns a CLLTimeOfDay which represents the current UTC time of day as taken from the system clock.

static CLLTimeOfDay CLLTimeOfDay::CurrentLocalTime();

Returns a CLLTimeOfDay which represents the current Local time of day as taken from the system clock.

static CLLTimeOfDay CLLTimeOfDay::Midnight();

Returns a CLLTimeOfDay that represents midnight.

static CLLTimeOfDay CLLTimeOfDay::Midday();

Returns a CLLTimeOfDay that represents midday.

static String CLLTimeOfDay::GetAMString();

Returns the string to used for the 'AM' indicator for the current user locale.

static String CLLTimeOfDay::GetPMString();

Returns the string to used for the 'PM' indicator for the current user locale.

uint16_t CLLTimeOfDay::GetHours() const;

Returns the number of hours this CLLTimeOfDay contains.

e.g. CLLTimeOfDay<> x(12 , 13, 14, 15)

assert(x.GetHours() == 12);

uint16_t CLLTimeOfDay::GetMinutes() const;

Returns the number of minutes this CLLTimeOfDay contains.

e.g. CLLTimeOfDay<> x(12 , 13, 14, 15)

assert(x.GetMinutes() == 13);

double CLLTimeOfDay::GetSeconds() const;

Returns the number of seconds this CLLTimeOfDay contains.

e.g. CLLTimeOfDay<> x(12 , 13, 14, 15)

assert(x.GetSeconds() == 14);

uint32_t CLLTimeOfDay::GetTotalSeconds() const;

Returns the total number of seconds this CLLTimeOfDay contains.

e.g. CLLTimeOfDay<> x(0 , 1, 14, 15)

assert(x.GetTotalSeconds() == 74);

uint16_t CLLTimeOfDay::GetAMPMHours() const;

Returns the 12 hour version of the hour this CLLTimeOfDay represents.

e.g. CLLTimeOfDay<> x(17 , 13, 14, 15)

assert(x.GetAMPMHour() == 5);

String CLLTimeOfDay::GetAMPMString() const;

Returns the string to used for the 'AM'or 'PM' indicator for the current user locale for this instance's hour value.

bool CLLTimeOfDay::IsValid() const;

Returns true if this instance is valid otherwise false.

e.g. CLLTimeOfDay<> Inval;

assert(IsValid(Inval) == false);

bool CLLTimeOfDay::GetAsSystemTime(SYSTEMTIME& SystemTime) const;

Returns a SYSTEMTIME structure representing this CLLTimeOfDay

Remarks

Only the wHour, wMinute, wSecond parameters of the SYSTEMTIME struct are filled in. All the other values are set to 0.

CLLTimeOfDay& CLLTimeOfDay::operator=(const CLLTimeOfDay& Tod);

Copies a CLLTimeOfDay into this CLLTimeOfDay instance and returns a reference to this instance.

CLLTimeOfDay CLLTimeOfDay::operator+(const CLLTimeSpan& TimeSpan) const;

CLLTimeOfDay CLLTimeOfDay::operator-(const CLLTimeSpan& TimeSpan) const;

Standard arithmetic operators to add and subtracts CLLTimeOfDay’s.

CLLTimeOfDay& CLLTimeOfDay::operator+=(const CLLTimeSpan& TimeSpan);

CLTimeSpan& CLLTimeOfDay::operator-=(CLLTimeSpan& TimeSpan);

Standard arithmetic auto increment and decrement operators.

bool CLLTimeOfDay::operator==(const CLLTimeOfDay& Tod) const;

bool CLLTimeOfDay::operator>(const CLLTimeOfDay& Tod) const;

bool CLLTimeOfDay::operator>=(const CLLTimeOfDay& Tod) const;

bool CLLTimeOfDay::operator<(const CLLTimeOfDay& Tod) const;

bool CLLTimeOfDay::operator<=(const CLLTimeOfDay& Tod) const;

bool CLLTimeOfDay::operator!=(const CLLTimeOfDay& Tod) const;

Standard arithmetic equality operators.

String CLLTimeOfDay::Format(const String& sFormat) const;

Generates a formatted string that corresponds to this CLLTimeOfDay object.

The sFormat string supports the following replaceable parameters:

%H Hours in the current day
%M Minutes in the current hour
%h 12 Hour format Hours in this CLTimeSpan (00 - 12)
%P AM / PM indicator for the current user locale
%S Seconds in the current minute
%% Percent sign
%x Time Of Day representation for the current user locale
%#H, %#h, %#M, %#S Remove leading zeros (if any).

Remarks

If the CLLTimeOfDay is invalid then an empty string will be returned

void CLLTimeOfDay::Serialize(CArchive& ar);

Standard MFC override to allow streaming of this CLLTimeOfDay to archive. The space taken is exactly 10 bytes (8 data bytes + 2 schema bytes).

friend CArchive& operator<<(CArchive& ar, CLLTimeSpan& Tod);

Simply calls the Serialize method of ‘Tod’, asserting that the archive ‘ar’ is storing.

friend CArchive& operator>>(CArchive& ar, CLLTimeSpan& Tod);

Simply calls the Serialize method of ‘Tod’, asserting that the archive ‘ar’ is loading.

CLDate Index

Constructors

CCLDate

Setting

Set

Static Constructors

Operations

Overloaded Arithmetic Operators

Overloaded Equality Operators

operator==, > etc.

Display

GetWindowsFormatString

Format

Serialization

Serialize

operator<<

CLDate Constructors

CLDate();

CLDate(int32_t Year, uint16_t month, uint16_t Day, uint16_t Hour, uint16_t Minute, uint16_t Second, bool bDoAssert = true);

CLDate(const SYSTEMTIME& SystemTime, bool bDoAssert = true);

CLDate(const FILETIME& FileTime, bool bDoAssert = true);

CLDate(int32_t Year, uint16_t month, uint16_t WeekOfMonth, DayOfWeek dow, uint16_t Hour, uint16_t Minute, uint16_t Second, bool bDoAssert = true);

CLDate(int32_t Days, CDate::DateEpoch e, uint16_t Hour, uint16_t Minute, uint16_t Second, bool bDoAssert = true);

CLDate(const CLDate& ld);

CLDate(const CTime& ctime, bool bDoAssert = true);

CLDate(const CDate<TCALENDAR>& Date, const CLTimeOfDay& Tod);

CLDate(const COleDateTime& oleTime, bool bDoAssert = true);

Parameters

Year, Month, Day Indicates a year, month and day.

Hour, Minute, Second Indicates a hour, minute and second values.

SystemTime A Win32 SDK SYSTEMTIME structure.

FileTime A Win32 SDK FILETIME structure.

ld Indicates a CLDate object that already exists.

ctime Indicates a CTime object that already exists.

WeekOfMonth The week of the month (0 - 5).

DayOfWeek The day of the week e.g. CDate::Sunday.

oleTime An OLE Date.

bDoAsserts if set, the constructors will assert in debug mode if any of the parameters are invalid

Remarks

The default constructor creates an invalid CLDate
if WeekOfMonth is 5 then it means the last week in the month. This is similar to the way the Win32 SDK operates.
See the Structures used by the classes for the definition of the enums used to represent the day of week.

CLDate Set functions

CLDate& Set();

CLDate& Set(int32_t Year, uint16_t month, uint16_t Day, uint16_t Hour, uint16_t Minute, uint16_t Second, bool bDoAssert = true);

CLDate& Set(const SYSTEMTIME& st, bool bDoAssert = true);

CLDate& Set(const FILETIME& FileTime, bool bDoAssert = true);

CLDate& Set(int32_t Year, uint16_t month, uint16_t WeekOfMonth, DayOfWeek dow, uint16_t Hour, uint16_t Minute, uint16_t Second, bool bDoAssert = true);

CLDate& Set(int32_t Days, CDate::DateEpoch e, uint16_t Hour, uint16_t Minute, uint16_t Second, bool bDoAssert = true);

CLDate& Set(const CTime& ctime, bool bDoAssert = true);

CLDate& Set(const CDate<TCALENDAR>& Date, const CLTimeOfDay& Tod);

CLDate& Set(const COleDateTime& oleTime, bool bDoAssert = true);

Parameters

See CLDate Constructors

Remarks

These functions are actually called by the constructors. They allow a CLDate’s value to be modified even after construction.

static CLDate CLDate::CurrentSystemTime(bool bDoAssert = true);

Returns a CLDate which represents the current UTC date as taken from the system clock.

static CLDate CLDate::CurrentLocalTime(bool bDoAssert = true);

Returns a CLDate which represents the current local date as taken from the system clock.

CDate<TCALENDAR> CLDate::GetCDate() const;

Returns a CDate that represents the date part of this instance. Allows co-ordinated access to all the range of CDate functions.

Remarks

As a copy is returned and not a reference changes to the returned CDate are not reflected in the underlying CLDate.

CLTimeOfDay<> CLDate::GetCLTimeOfDay() const;

Returns a CLTimeOfDay that represents the time of day part of this long date. Allows co-ordinated access to all the range of CLTimeOfDay functions.

Remarks

As a copy is returned and not a reference changes to the returned CLTimeOfDay are not reflected in the underlying CLDate.

DateLS CLDate::GetDate() const;

Returns a DateLS structure for this instance.

bool CLDate::GetAsSystemTime(SYSTEMTIME& SystemTime) const;

Returns a Win32 SDK SYSTEMTIME struct version of this instance if this method succeeds by returning true.

Remarks

The wDayOfWeek parameter of SYSTEMTIME is 0 based i.e. Sunday = 0, Monday = 1, and so on. This is unlike the value returned from CDate::GetDayOfWeek method.

bool CLDate::GetAsFileTime(FILETIME& FileTime) const;

Returns a Win32 SDK FILETIME struct version of this instance if this method succeeds by returning true.

bool CLDate::GetAsCOleDateTime(COleDateTime& OleDateTime) const;

Returns a COleDateTime representation of this instance if this method succeeds by returning true. This may prove useful in environments where you have to integrate with VB, ODBC or DAO.

bool CLDate::GetAsTM(tm& time);

Returns a ‘C’ runtime tm struct version of this instance if this method succeeds by returning true.

void CLDate::AddYear(int Years = 1);

Adds a number of years to this instance.

void CLDate::AddMonth(int Months = 1);

Adds a number of months to this instance.

Remarks

Invalid Day of Months are always rounded down and will not overflow into subsequent months. e.g. if you add 1 month to March 31 you will get April 30.

void CLDate::AddWeek(int Weeks = 1);

Adds a number of weeks i.e. 7 days to this instance.

bool CLDate::IsValid() const;

Returns true if this instance is valid otherwise false.

e.g. CLDate Inval;

assert(IsValid(Inval) == false);

CLDate& CLDate::operator=(const CLDate& ld);

Copies a CLDate into this CLDate and returns a reference to this instance.

CLDate CLDate::operator+(const CLTimeSpan& ts);

CLTimeSpan CLDate::operator-(const CLDate& ld);

CLDate CLDate::operator-(const CLTimeSpan& ts);

Standard arithmetic operators to add and subtracts CLDate’s.

CLDate& CLDate::operator+=(const CLTimeSpan& ts);

CLDate& CLDate::operator-=(const CLTimeSpan& ts);

Standard auto increment and decrement operators.

CLDate& CLDate::operator++();

Standard arithmetic increment operator. Adds one day to this instance

CLDate& CLDate::operator--();

Standard arithmetic decrement operator. Subtracts one day from this instance.

bool CLDate::operator==(const CLDate& ld);

bool CLDate::operator>(const CLDate& ld);

bool CLDate::operator>=(const CLDate& ld);

bool CLDate operator<(const CLDate& ld);

bool CLDate operator<=(const CLDate& ld);

bool CLDate operator!=(const CLDate& ld);

Standard arithmetic equality operators.

String CLDate::GetWindowsFormatString(LPCWSTR lpLocaleName = LOCALE_NAME_USER_DEFAULT)

Returns a CLDate::Format string appropriate for the specified windows locale as specified by 'lpLocaleName'

See Also

CLDate::Format

String CLDate::Format(const String& sFormat) const;

Generates a formatted string that corresponds to this CLDate object.

The sFormat string supports the following replaceable parameters:

%a Abbreviated weekday name
%A Full weekday name
%b Abbreviated month name
%B Full month name
%d Day of month as decimal number (01 - 31)
%j Day of year as decimal number (001 - 366)
%m Month as decimal number (01 - 12)
%P AM / PM indicator
%U Week of year as decimal number
%w Weekday as decimal number (1 - 7; Sunday is 1)
%x Windows short date representation, namely Date representation + ‘ ‘ + Time Representation for the current user locale
%y Year without century, as decimal number (00 - 99)
%Y Year with century, as decimal number
%H Hours in the day
%h 12 Hour format Hours in (00 - 12)
%M Minutes in the hour
%S Seconds in the minute
%% Percent sign
%#x Windows long date representation, namely long Date representation + ‘ ‘ + Time Representation for the current user locale
%#d, %#j, %#m, %#U, %#w, %#y, %#H, %#h, %#M, %#S Remove leading zeros (if any).

Remarks

If the CLDate is invalid then an empty string will be returned.

See Also

CLDate::GetWindowsFormatString

void CLDate::Serialize(CArchive& ar);

Standard MFC override to allow streaming of this CLDate to archive. The space taken is exactly 11 bytes (9 data bytes + 2 schema bytes).

Remarks

As of v3 of DTime+, the serialization is not backward compatible with earlier versions.

friend CArchive& operator<<(CArchive& ar, CLDate& ld);

Simply calls the Serialize method of ‘ld’, asserting that the archive ‘ar’ is storing.

friend CArchive& operator>>(CArchive& ar, CLDate& ld);

Simply calls the Serialize method of ‘ld’, asserting that the archive ‘ar’ is loading.

CLLDate Index

Constructors

CCLLDate

Setting

Set

Static Constructors

Operations

Overloaded Arithmetic Operators

Overloaded Equality Operators

operator==, > etc.

Display

GetWindowsFormatString

Format

Serialization

Serialize

operator<<

CLLDate Constructors

CLLDate();

CLLDate(int32_t Year, uint16_t month, uint16_t Day, uint16_t Hour, uint16_t Minute, double Second, bool bDoAssert = true);

CLLDate(const SYSTEMTIME& SystemTime, bool bDoAssert = true);

CLLDate(const FILETIME& FileTime, bool bDoAssert = true);

CLLDate(int32_t Year, uint16_t month, uint16_t WeekOfMonth, DayOfWeek dow, uint16_t Hour, uint16_t Minute, double Second, bool bDoAssert = true);

CLLDate(int32_t Days, CDate::DateEpoch e, uint16_t Hour, uint16_t Minute, double Second, bool bDoAssert = true);

CLLDate(const CLLDate& ld);

CLLDate(const CTime& ctime, bool bDoAssert = true);

CLLDate(const CDate<TCALENDAR>& Date, const CLLTimeOfDay& Tod);

CLLDate(const COleDateTime& oleTime, bool bDoAssert = true);

Parameters

Year, Month, Day Indicates a year, month and day.

Hour, Minute, Second Indicates a hour, minute and second values.

SystemTime A Win32 SDK SYSTEMTIME structure.

FileTime A Win32 SDK FILETIME structure.

ld Indicates a CLLDate object that already exists.

ctime Indicates a CTime object that already exists.

WeekOfMonth The week of the month (0 - 5).

DayOfWeek The day of the week e.g. CDate::Sunday.

oleTime An OLE Date.

bDoAsserts if set, the constructors will assert in debug mode if any of the parameters are invalid

Remarks

The default constructor creates an invalid CLLDate
if WeekOfMonth is 5 then it means the last week in the month. This is similar to the way the Win32 SDK operates.
See the Structures used by the classes for the definition of the enums used to represent the day of week.

CLLDate Set functions

CLLDate& Set();

CLLDate& Set(int32_t Year, uint16_t month, uint16_t Day, uint16_t Hour, uint16_t Minute, double Second, bool bDoAssert = true);

CLLDate& Set(const SYSTEMTIME& st, bool bDoAssert = true);

CLLDate& Set(const FILETIME& FileTime, bool bDoAssert = true);

CLLDate& Set(int32_t Year, uint16_t month, uint16_t WeekOfMonth, DayOfWeek dow, uint16_t Hour, uint16_t Minute, double Second, bool bDoAssert = true);

CLLDate& Set(int32_t Days, CDate::DateEpoch e, uint16_t Hour, uint16_t Minute, double Second, bool bDoAssert = true);

CLLDate& Set(const CTime& ctime, bool bDoAssert = true);

CLLDate& Set(const CDate<TCALENDAR>& Date, const CLLTimeOfDay& Tod);

CLLDate& Set(const COleDateTime& oleTime, bool bDoAssert = true);

Parameters

See CLLDate Constructors

Remarks

These functions are actually called by the constructors. They allow a CLLDate’s value to be modified even after construction.

static CLLDate CLLDate::CurrentSystemTime(bool bDoAssert = true);

Returns a CLLDate which represents the current UTC date as taken from the system clock.

static CLLDate CLLDate::CurrentLocalTime(bool bDoAssert = true);

Returns a CLLDate which represents the current local date as taken from the system clock.

CDate<TCALENDAR> CLLDate::GetCDate() const;

Returns a CDate that represents the date part of this instance. Allows co-ordinated access to all the range of CDate functions.

Remarks

As a copy is returned and not a reference changes to the returned CDate are not reflected in the underlying CLLDate.

CLLTimeOfDay<> CLLDate::GetCLLTimeOfDay() const;

Returns a CLLTimeOfDay that represents the time of day part of this long date. Allows co-ordinated access to all the range of CLTimeOfDay functions.

Remarks

As a copy is returned and not a reference changes to the returned CLTimeOfDay are not reflected in the underlying CLLDate.

DateLLS CLLDate::GetDate() const;

Returns a DateLLS structure for this instance.

bool CLLDate::GetAsSystemTime(SYSTEMTIME& SystemTime) const;

Returns a Win32 SDK SYSTEMTIME struct version of this instance if this method succeeds by returning true.

Remarks

The wDayOfWeek parameter of SYSTEMTIME is 0 based i.e. Sunday = 0, Monday = 1, and so on. This is unlike the value returned from CDate::GetDayOfWeek method.

bool CLLDate::GetAsFileTime(FILETIME& FileTime) const;

Returns a Win32 SDK FILETIME struct version of this instance if this method succeeds by returning true.

bool CLLDate::GetAsCOleDateTime(COleDateTime& OleDateTime) const;

Returns a COleDateTime representation of this instance if this method succeeds by returning true. This may prove useful in environments where you have to integrate with VB, ODBC or DAO.

void CLLDate::AddYear(int Years = 1);

Adds a number of years to this instance.

void CLLDate::AddMonth(int Months = 1);

Adds a number of months to this instance.

Remarks

Invalid Day of Months are always rounded down and will not overflow into subsequent months. e.g. if you add 1 month to March 31 you will get April 30.

void CLLDate::AddWeek(int Weeks = 1);

Adds a number of weeks i.e. 7 days to this instance.

bool CLLDate::IsValid() const;

Returns true if this instance is valid otherwise false.

e.g. CLLDate Inval;

assert(IsValid(Inval) == false);

CLLDate& CLLDate::operator=(const CLLDate& ld);

Copies a CLLDate into this CLLDate and returns a reference to this instance.

CLLDate CLLDate::operator+(const CLTimeSpan& ts);

CLTimeSpan CLLDate::operator-(const CLLDate& ld);

CLLDate CLLDate::operator-(const CLTimeSpan& ts);

Standard arithmetic operators to add and subtracts CLLDate’s.

CLLDate& CLLDate::operator+=(const CLTimeSpan& ts);

CLLDate& CLLDate::operator-=(const CLTimeSpan& ts);

Standard auto increment and decrement operators.

CLLDate& CLLDate::operator++();

Standard arithmetic increment operator. Adds one day to this instance

CLLDate& CLLDate::operator--();

Standard arithmetic decrement operator. Subtracts one day from this instance.

bool CLLDate::operator==(const CLLDate& ld);

bool CLLDate::operator>(const CLLDate& ld);

bool CLLDate::operator>=(const CLLDate& ld);

bool CLLDate operator<(const CLLDate& ld);

bool CLLDate operator<=(const CLLDate& ld);

bool CLLDate operator!=(const CLLDate& ld);

Standard arithmetic equality operators.

String CLLDate::GetWindowsFormatString(LPCWSTR lpLocaleName = LOCALE_NAME_USER_DEFAULT)

Returns a CLLDate::Format string appropriate for the specified windows locale as specified by 'lpLocaleName'

See Also

CLLDate::Format

String CLLDate::Format(const String& sFormat) const;

Generates a formatted string that corresponds to this CLLDate object.

The sFormat string supports the following replaceable parameters:

%a Abbreviated weekday name
%A Full weekday name
%b Abbreviated month name
%B Full month name
%d Day of month as decimal number (01 - 31)
%j Day of year as decimal number (001 - 366)
%m Month as decimal number (01 - 12)
%P AM / PM indicator
%U Week of year as decimal number
%w Weekday as decimal number (1 - 7; Sunday is 1)
%x Windows short date representation, namely Date representation + ‘ ‘ + Time Representation for the current user locale
%y Year without century, as decimal number (00 - 99)
%Y Year with century, as decimal number
%H Hours in the day
%h 12 Hour format Hours in (00 - 12)
%M Minutes in the hour
%S Seconds in the minute
%% Percent sign
%#x Windows long date representation, namely long Date representation + ‘ ‘ + Time Representation for the current user locale
%#d, %#j, %#m, %#U, %#w, %#y, %#H, %#h, %#M, %#S Remove leading zeros (if any).

Remarks

If the CLLDate is invalid then an empty string will be returned.

See Also

CLLDate::GetWindowsFormatString

void CLLDate::Serialize(CArchive& ar);

Standard MFC override to allow streaming of this CLLDate to archive. The space taken is exactly 11 bytes (9 data bytes + 2 schema bytes).

friend CArchive& operator<<(CArchive& ar, CLLDate& ld);

Simply calls the Serialize method of ‘ld’, asserting that the archive ‘ar’ is storing.

friend CArchive& operator>>(CArchive& ar, CLLDate& ld);

Simply calls the Serialize method of ‘ld’, asserting that the archive ‘ar’ is loading.

Structures / Enums / Consts used by the Classes

namespace DTimePlus
{
enum Month
{
January = 1,
February = 2,
March = 3,
April = 4,
May = 5,
June = 6,
July = 7,
August = 8,
September = 9,
October = 10,
November = 11,
December = 12
};

enum MoslemMonth
{
Muharram = 1,
Safar = 2,
Rabi_Al_Awwal = 3,
Rabi_Ath_Thani = 4,
Jumada_l_Ula = 5,
Jumada_Ath_Tania = 6,
Rajab = 7,
Sha_ban = 8,
Ramdadan = 9,
Shawwal = 10,
Dhu_l_Qa_da = 11,
Dhu_l_Hijja = 12
};

enum DayOfWeek
{
Sunday = 1,
Monday = 2,
Tuesday = 3,
Wednesday = 4,
Thursday = 5,
Friday = 6,
Saturday = 7,
FirstDayOfWeek = Sunday,
LastDayOfWeek = Saturday
};

enum DateEpoch
{
EPOCH_JD = 0,
EPOCH_MJD = 1,
EPOCH_1900 = 2,
EPOCH_1950 = 3,
EPOCH_CTIME = 4,
EPOCH_2000 = 5,
EPOCH_GREG = 6
};

struct DateS
{
int32_t Year;
uint16_t Month;
uint16_t Day;
};

struct DateLS
{
int32_t Year;
uint16_t Month;
uint16_t Day;
uint16_t Hour;
uint16_t Minute;
uint16_t Second;
};

struct DateLLS
{
int32_t Year;
uint16_t Month;
uint16_t Day;
uint16_t Hour;
uint16_t Minute;
double Second;
};

}; //namespace DTimePlus

Remarks

The Year value is interpreted as in CDate::GetYear
The Month value is interpreted as in CDate::GetMonth
The Day is interpreted as in CDate::GetDay

The hour is interpreted as in CLTimeOfDay::GetHours
The minute is interpreted as in CLTimeOfDay::GetMinutes
The second is interpreted as in CLTimeOfDay::GetSeconds or CLLTimeOfDay::GetSeconds

UI Support

The UI support for DTime+ is provided by the DTime+UI.h module. This support is currently limited to MFC on Visual C compilers. This provides a collection of standard DDX functions to allow a date to be mapped to a CDate<CGregorianCalendar> instance and a time of day to be mapped to a CLTimeOfDay instance. To provide data entry for CLDate, you should provide 2 UI controls, one for the CDate component and another for the CLTimeOfDay component. Note that no UI support is currently provided for the CLTimeSpan class or the Julian or Moslem calendars. For this you will need to roll your own by using something like a standard edit control or a masked edit control. The UI used for both of these DDX functions uses the standard Date Time control as provided by Windows (and as wrapped by MFC with CDateTimeCtrl).

Usage of the Data entry Routines

Place a standard date time control on your dialog / form where you want the control to be using your resource editor. Set the 'Format' style of it as appropriate to 'Short Date or 'Long Date' to present a CDate instance or 'Time' for a CLTimeOfDay instance.
Call the appropriate DDX routine for the value you want to allow to be edited via the control.

Methods

DDX_DateTimeCtrl

void DDX_DateTimeCtrl(CDataExchange* pDX, int nIDC, DTimePlus::CDate<CGregorianCalendar>& value);

void DDX_DateTimeCtrl(CDataExchange* pDX, int nIDC, DTimePlus::CLTimeOfDay<>& value);

Depending on the overloaded function called, it transfers a CDate or CLTimeOfDay to and from the screen. This function would normally be called in your classes DoDataExchange function

Parameters

pDX Standard MFC data exchange class.

nIDC The resource ID of the date and time picker control associated with the member variable.

value Value to retrieve/set in the UI.

Remarks

See the DTimeUITest Demo project included in the DTime+ workspace provided in the download for a concrete example on using theses functions.

Contacting the Author

PJ Naughter
Email: pjna@naughter.com
Web: http://www.naughter.com
30 October 2023