Data conversions solving time limitations of object-oriented software programs

Abstract

A method, apparatus, and article of manufacture for converting dates in object-oriented software programs utilizing time classes covering limited periods of time is provided. A conversion object identifies a target year in which an application program should execute. If the target year falls outside of the limited period of time, the conversion object converts the target year into a base year which falls within the limited time period and a corresponding offset. The application program is then executed with the target year, and if the target year is needed by the application program, it can be reconstructed by adding the base year and corresponding offset.

Claims

What is claimed is:

1. A method of converting date data in a computer system, the method comprising the steps of:

providing a conversion class that encapsulates a time class, wherein the time class covers a limited time period;

generating a conversion object from the conversion class;

when the conversion object is invoked,

identifying a target date;

determining whether the target date falls outside of the limited time period; and

when the target date falls outside of the limited time period, converting the target date to one that falls within the limited time period,

wherein the target date comprises a target year and converting the target date comprises:

determining a base year; and

calculating a resulting offset as a difference between the target year and the base year; and

wherein the base year is assigned a value of 1970 if the target year is less than 1970.

2. A method of converting date data in a computer system, the method comprising the steps of:

providing a conversion class that encapsulates a time class, wherein the time class covers a limited time period;

generating a conversion object from the conversion class;

when the conversion object is invoked,

identifying a target date;

determining whether the target date falls outside of the limited time period; and

when the target date falls outside of the limited time period, converting the target date to one that falls within the limited time period,

wherein the target date comprises a target year and converting the target date comprises:

determining a base year; and

calculating a resulting offset as a difference between the target year and the base year; and

wherein the base year is assigned a value of 2037 if the target year is greater than 2037.

3. An apparatus for converting date data in a computer system, comprising:

a computer having a clock and a data storage device storing data files connected thereto; and

one or more programs, performed by the computer, for providing a conversion class that encapsulates a time class wherein the time class covers a limited time period; for generating a conversion object from the conversion class; and for, when the conversion object is invoked, identifying the target date, determining whether the target date is outside of the limited time period, and, when the target date falls outside of the limited time period, converting the target date to one that falls within the limited time period,

wherein the target date comprises a target year and converting the target date comprises:

determining a base year; and

calculating a resulting offset as a difference between the base year and the target year, and

wherein the base year is assigned a value of 1970 if the target year is less than 1970.

4. An apparatus for converting date data in a computer system, comprising:

a computer having a clock and a data storage device storing data files connected thereto; and

one or more programs, performed by the computer, for providing a conversion class that encapsulates a time class wherein the time class covers a limited time period; for generating a conversion object from the conversion class; and for, when the conversion object is invoked, identifying the target date, determining whether the target date is outside of the limited time period, and, when the target date falls outside of the limited time period, converting the target date to one that falls within the limited time period,

wherein the target date comprises a target year and converting the target date comprises:

determining a base year; and

calculating a resulting offset as a difference between the base year and the target year, and

wherein the base year is assigned a value of 2037 if the target year is greater than 2037.

5. An article of manufacture comprising a computer program carrier readable by a computer having a clock, a data file, and an application program and embodying one or more instructions executable by the computer to perform method steps for converting date data in the computer, the method comprising the steps of:

providing a conversion class that encapsulates a time class, wherein the time class covers a limited time period;

generating a conversion object from the conversion class;

when the conversion object is invoked,

identifying a target date;

determining whether the target date falls outside of the limited time period; and

when the target date falls outside of the limited time period, converting the target date to one that falls within the limited time period,

wherein the target date comprises a target year and converting the target year comprises:

determining a base year; and

calculating a resulting offset as a difference between the target year and the base year; and

wherein the base year is assigned a value of 1970 if the target year is less than 1970.

6. An article of manufacture comprising a computer program carrier readable by a computer having a clock, a data file, and an application program and embodying one or more instructions executable by the computer to perform method steps for converting date data in the computer, the method comprising the steps of:

providing a conversion class that encapsulates a time class, wherein the time class covers a limited time period;

generating a conversion object from the conversion class;

when the conversion object is invoked,

identifying a target date;

determining whether the target date falls outside of the limited time period; and

when the target date falls outside of the limited time period, converting the target date to one that falls within the limited time period,

wherein the target date comprises a target year and converting the target year comprises:

determining a base year; and

calculating a resulting offset as a difference between the target year and the base year; and

wherein the base year is assigned a value of 2037 if the target year is greater than 2037.

Description

BACKGROUND OF THE INVENTION

1. Field of the Invention

This invention generally relates to date-year conversions in computer software programs, and in particular, to date-year conversions in object-oriented software programs utilizing classes which limit the time that computer applications may be utilized.

2. Background of the Invention

The Y2K (i.e., the year 2000) bug has had a profound impact on everyday life of almost each individual. Computer systems used in various processing applications, such as, for example, processing insurance, account, inventory, investment, and retirement information, as well as many other applications, often operate with records and data containing date-dependent information. In many computing systems, date information relating to years has typically been represented in two-digit year formats, where two digits represent a year between 1900 and 1999. Thus, for example, the two digits "97" would represent the year 1997. Popular usage of this simplified date information format throughout the computer industry has resulted in an industry-recognized problem, often referred to as "the year 2000 problem."

More specifically, as a result of this simplification of date information, upon the turn of the century (i.e., upon the year 2000), two-digit year information intended to represent a year within the 21st century will, instead, be indistinguishable by computer systems from a year within the 20th century (i.e., between 1900 and 1999). Thus, for example, a two-digit year value of "08" which is intended to represent the year 2008 will be indistinguishable from the year 1908 by such computer systems.

In preparing for the turn ofthe century, substantial time and resources have been invested to insure that computer systems will continue to operate past the year 2000. Based on their experience with the Y2K problem, the public, the government, businesses, financial institutions, and computer companies are keenly aware of the costly effects of correcting date and year restrictions within computer systems.

Additionally, Microsoft Foundation Class (MFC), a popular object-oriented toolkit for developing Windows-based C++ applications, has a well-known date conversion problem, even with the recent focus on date-year restrictions in software programs. The date conversion problem arises because MFC-based applications are capable of representing dates only from 1970 to 2038. While this date problem may not be as critical as the Y2K problem, it is severe enough to jeopardize the normal execution of a business application. The implication of this problem is significant for mission critical MFC-based business software, and if this problem is not addressed properly, the "Year 2038" bug will surface for MFC-based C++ applications.

In object-oriented software programs, the term "object-oriented" refers to a software design method which uses "classes" and "objects" to model abstract or real objects. An "object" is the main building block of object-oriented programming, and is a programming unit which has both data and functionality (i.e., "methods"). A "class" defines the implementation of a particular kind of object, the variables and methods it uses, and the parent class to which it belongs.

The problem in MFC-based C++ applications is related to the CTime class. CTime is defined in terms of a variable called "time_t". The variable time_t is a variation of the original UNIX time variable which is defined according to American National Standards Institute (ANSI) standards. The first version of UNIX was developed in 1969 and became effective in 1970. The UNIX time variable, like time_t, counts the number of seconds that have elapsed since Jan. 1, 1970.

The variable time_t is a 32-bit signed long integer representing 2,147,483,647 positive time values and measuring the number of seconds that have elapsed since Jan. 1, 1970. Since there are 86,400 seconds in a day (approximately 31,557,600 seconds in a year based on 365.25 days in a year), the maximum time value that may be represented after Jan. 1, 1970 is approximately 68 years. Thus, time_t is only capable of representing dates from 1970+68 years, i.e., from years 1970 to 2038. More specifically, time_t can calculate time from Jan. 1, 1970, 24:00 hours to Jan. 18, 2038, 19:14:07 hours. After Jan. 18, 2038, 19:14:07 hours, time_t rolls over to a negative number and no longer counts the number of seconds that have elapsed since Jan. 1, 1970.

Consequently, any application program utilizing software based on time_t, including software based on the CTime class of MFC, can not maintain accurate dates and times before Jan. 1, 1970 or after Jan. 18, 2038. This bug exists in each and every object-oriented application utilizing CTime--the problem does not depend on which type of program is utilized or which company developed the program. A number of solutions to solve this problem have been proposed. However, all of these potential solutions have significant shortcomings.

One potential solution is to rewrite the CTime class to accommodate dates before 1970 and after 2038. This approach, however, would require investment of substantial time and money to modify the class and related programs. Furthermore, any modifications to CTime may introduce potential defects into the program. Thus, this solution does not adequately address the problem based on the required time and money required to implement the modifications and resulting defects.

A second potential solution to the year 2038 problem is to rewrite application programs to represent dates beyond the year 2038. This solution, however, is not practical since it requires computer code modifications to not only the application programs, but also to date dependent data files generated by these programs. Modifying data files is likely to be even more costly than modifying application programs simply based on the large number of data files. Thus, this approach does not adequately address the problem.

Third, it has been proposed that the system clock be reset when the year 2038 arrives. This solution, however, is not practical since making changes to the system clock would necessarily result in changes to date dependent data fields. Further, files that were created on two different dates would be assigned the same date. Thus, even if the clock is reset, users would still need to reformat date-year dependent data files.

A final approach to solving the year 2038 problem is to use different time classes within MFC. Utilizing other MFC time classes, however, does not adequately address this problem. One problem associated with other MFC time classes is that all of the years from year 1 to 9999 can not be represented. Rather, other MFC time classes can only represent years 100 to 9999. A second problem with these alternate MFC classes is that they are not as accurate as CTime. CTime can represent time and dates very accurately--in increments of hours, minutes, and seconds. Other MFC time classes, however, are only capable of representing time increments in days. A third shortcoming of other MFC time classes is that users are subjected to unnecessary inconvenience. Implementing other time classes in application programs currently utilizing CTime requires users to modify their application program to terminate CTime and to initiate the other time class. These modifications are necessary because other MFC date-related classes do not derive from the CTime class and do not have a CTime constructor. A final problem with other MFC date related classes is that once a user converts to an alternate MFC time class, the user is essentially prevented from converting back to CTime. Users can convert back to CTime if the desired year falls within the range of 1970-2038. However, converting back to CTime within this time period is not particularly useful since CTime and the other date-related classes operate within this time frame. Thus, the user is essentially prevented from converting back to CTime for the problem years outside the range of 1970-2038. Based on these shortcomings, other MFC time classes do not adequately address the 2038 bug based on the required modifications and user inconvenience.

Accordingly, there is a need in the art for a program that converts date-year data in object-oriented software programs created with the CTime class of MFC to insure that systems based on CTime will operate well past the year 2038. This program should convert dates without inconveniencing system users while providing detailed time, date and year information spanning all of the years from 1 to 9999. Further, this program should convert dates without modifying application programs, related data, and system clocks.

SUMMARY OF THE INVENTION

To overcome the limitations in the prior art described above, and to overcome other limitations that will become apparent upon reading and understanding the present specification, the present invention discloses a method, apparatus, and article of manufacture for solving date-year restrictions in object-oriented software programs.

In accordance with the present invention, a technique for converting dates in object-oriented software programs is provided. Initially, a conversion class encapsulates a time class that covers a limited time period. A conversion object is then generated from the conversion class, and when the conversion object is invoked, a target year in which an application program should execute is identified. If that target year is outside of a limited time period, the target year is converted to one that falls within the limited time period.

BRIEF DESCRIPTION OF THE DRAWINGS

Referring now to the drawings in which like reference numbers represent corresponding parts throughout:

FIG. 1 schematically illustrates the hardware environment of a preferred embodiment of the present invention, and more particularly, illustrates a typical distributed computer system.

FIG. 2 is a flow diagram illustrating the date conversion program.

FIG. 3 is a flow diagram illustrating the initial identification of a target year.

FIG. 4 is a flow diagram illustrating the designation of a base year and resulting offset based on the target year.

FIG. 5 is a flow diagram illustrating the storage of the base year and resulting offset.

FIG. 6 is a flow diagram illustrating the conversion of the base year and offset back to the target year.

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENT

In the following description of the preferred embodiment, reference is made to the accompanying drawings which form a part hereof, and which is shown by way of illustration a specific embodiment in which the invention may be practiced. It is to be understood that other embodiments may be utilized as structural changes may be made without departing from the scope of the present invention. Further, the sample class structure and objects provided below are in the C++ programming language, but one skilled in the art will recognize that Java, ActiveX or another programming language with suitable object-oriented programming capabilities may likewise be utilized.

Hardware Environment

FIG. 1 is a hardware environment used to implement an embodiment of the invention. The present invention is typically implemented using a computer 10, which generally includes, inter alia, a processor 20, random access memory (RAM) 30, data storage devices 40 (e.g., hard, floppy, and/or CD-ROM disk drives, etc.), data communications devices 50 (e.g., modems, network interfaces, etc.), display device 60 (e.g., CRT, LCD display, etc.), and input devices 70 (e.g., mouse pointing device and keyboard). It is envisioned that attached to the computer 10 may be other devices, such as read only memory (ROM), a video card, bus interface, printers, etc. Those skilled in the art will recognize that any combination of the above components, or any number of different components, peripherals, and other devices, may be used with the computer 10.

The computer 10 operates under the control of an operating system (OS) 32. The OS 32 is booted into memory 30 ofthe computer 10 for execution when the computer 10 is powered-on or reset. In turn, the OS 32 then controls the execution of one or more computer programs 33, such as relational database management system (RDBMS) software 35 or a storage and retrieval system 36. The present invention is generally implemented in these computer programs 33, which execute under the control of the OS 32 and cause the computer 10 to perform the desired functions as described herein.

Additionally, the present invention works with RDBMS software 35, such as the DB2 product sold by IBM Corporation, although it may be implemented with any database management system (DBMS) software. The RDBMS software 35 receives commands from users for performing various search and retrieval functions, termed queries, against one or more databases stored in the data storage devices 40. In an embodiment, these queries conform to the Structured Query Language (SQL) standard, although other types of queries could also be used without departing from the scope of the invention.

The OS 32 and computer programs 33 are comprised of instructions which, when read and executed by the computer 10, causes the computer 10 to implement and/or use the present invention 100. Generally, the OS 32 and/or computer programs 33 are tangibly embodied in and/or readable from a device, carrier, or media, such as memory 30, data storage devices 40, and/or data communications devices 50. Under control of the OS 32, the computer programs 33 may be loaded from the memory 30, data storage devices 40, and/or data communications devices 50 into memory 30 of the computer 10 for use during actual operations.

Thus, the present invention may be implemented as a method, apparatus, or article of manufacture using standard programming and/or engineering techniques to produce software, firmware, hardware, or any combination thereof. The term "article of manufacture" (or alternatively, "computer program product") as used herein is intended to encompass a computer program accessible from any computer-readable device, carrier, or media Of course, those skilled in the art will recognize many modifications may be made to this configuration without departing from the scope of the present invention.

Those skilled in the art will also recognize that the environment illustrated in FIG. 1 is not intended to limit the present invention. Indeed, those skilled in the art will recognize that other alternative hardware environments may be used without departing from the scope of the present invention.

Referring to FIG. 1, the present invention converts dates in a computer system 10 having a processor 20 with a clock 22, memory 30 for storing data files 34, an operating system 32, computer programs 33 such as application programs (e.g., database retrieval programs or programs related to Internet searches) 37 created with the Microsoft Foundation Class (MFC) object-oriented programming toolkits utilizing a CTime time class 38, and a conversion or wrapper class 39. In addition, the system 10 may have data storage devices 40 for storing other data files 42.

Data Conversions Solving Time Limitations of Object-oriented Software Proprams

Referring to FIG. 2, a flow diagram ofthe present conversion invention 100, illustrates how certain dates are converted and application programs 37 are executed by encapsulating a time class with a conversion class (block 110); generating a conversion object from the conversion class (block 120); invoking the conversion object (block 130); identifying a target year (block 140); converting the target year (block 150); storing the base year and resulting offset (block 160), executing the application program with the target year (block 170), and after the program 37 has executed, converting the base year back to the target year (block 180). Following is a more detailed description of the present invention 100.

1. Encapsulating a Time Class

Referring to FIG. 2, a conversion or wrapper class encapsulates the CTime class (block 110). One embodiment ofthe invention provides two conversion classes 39 to perform this function: DKDate and DKTimestamp. Within the Windows NT platform, the DKDate and DKTimestamp classes are implemented utilizing the CTime class 38 of MFC.

1A. Definition of DKDate Conversion Class

DKDate is one conversion class 39 that encapsulates a CTime class 38. DKDate is an object-oriented representation of a date with year, month, and date data and is defined as follows:

                class DKDate
                {
                public:
                    DKDate (int nYear, int mm, int nDay);
                    DKDate ( );
                    virtual .about.DKDate ( );
                    int getYear ( ) const;
                    int getMonth ( ) const;
                    int getDay ( ) const;
                private:
                    int_diff;
                    CTime_t;
                };

    class DKTimestamp
    {
    public:
        DKTimestamp   (int nYear, int nMonth, int nDay,
                      int nHour=0, int nMin=0, int nSec=0,
                      int nNano = 0, int DST = -1);
        DKTimestamp( );
        virtual .about.DKTimestamp( );
        int getYear ( ) const;
        int getMonth ( ) const;
        int getDay ( ) const;
        int getHours ( ) const;
        int getMinutes ( ) const;
        int getSeconds ( ) const;
        int getNanos ( ) const;
    private:
        int_nanos;
        int_diff;
        CTime_t;
    };

    DKDate::DKDate (int nYear, int mm, int nDay)
    {
                _diff = 0;
                if(nYear > 2037)
                {
                    _diff = (nYear - 2037);
                    _t = CTime (2037, mm, nDay, 0, 0, 0,-1);
                }
                else if(nYear < 1970)
                {
                    _diff = (nYear - 1970);
                    _t = CTime (1970, mm, nDay, 0, 0, 0,-1);
                }
                else
                {
                    _diff = (0);
                    _t = CTime (nYear, mm, nDay, 0, 0, 0, -1);
                }
            }

    DKDate: :DKDate ( )
    {
        time_t _time;
        time_t* = pTime &_time;
        struct tm temp;
        struct tm* pTemp = &temp;
        _time = time ((time_t*)NULL);
        pTemp = localtime (pTime);
        int nSec = pTemp->tm_sec;
        int nMin = pTemp->tm_min;
        int nHour pTemp->tm_hour;
        int nDay = pTemp->tm_mday;
        int nMon = pTemp->tm_mon+1;
        int nYear = pTemp->tm_year + 1900;
        _diff =0;
        if(nYear > 2037)
        {
            _diff = (nYear - 2037);
            _t = CTime(2037, nMon, nDay, nHour, nMin, nSec, -1);
        }
        else if (nYear < 1970)
        {
            _diff = (nYear - 1970);
            _t = CTime(1970, nMon, aDay, nHour, nMin, nSec, -1);
        }
        else
        {
            _diff = (0);
            _t = CTime(nYear, nMon, NDay, nHour, nMin, nSec, -1);
        }
    }

    /* Define the implementation defined time type */
    #ifndef_TIME_T_DEFINED
    typedef long time_t;     /* time value*/
    *define_TIME_T_DEFINED /* avoid multiple definitions of time_t */
    #endif
    #ifndef_CLOCK_T_DEFINED
    typedef long clock_t;
    #define_CLOCK_T_DEFINED
    #endif
    #ifndef_SIZE_T_DEFINED
    typedef unsigned int size_t;
    #define_SIZE_T_DEFINED
    #endif

    #ifndef_TM_DEFINED
    struct tm {
    int tm_sec;          /* seconds after the minute - [0, 59] */
    int tm_min;          /* minutes after the hour - [0, 59]*/
    int tm_hour;         /* hours since midnight - [0, 23]*/
    int tm_mday;         /* day of the month - [1, 31]*/
    int tm_mon;          /* months since January - [0, 11]*/
    int tm_year;         /* years since 1900*/
    int tm_wday;         /* days since Sunday [0, 6]*/
    int tm_yday;         /* days since January 1 - [0, 365]*/
    int tm_isdst         /* daylight savings time flag*/
    }
    #define_TM_DEFINED
    #endif
    /*Clock ticks macro - ANSI version */
    #define CLOCKS_PER_SEC 1000
    /* Extern declarations for the global variables used by the CTime family
    of routines. */
    /* non-zero it daylight savings time is used */
    _CRTIMP extem int_daylight;
    /* offset for Daylight Saving Time */
    _CRTIMP extern long_dstbias;
    /*difference in seconds between GMT and local time */
    _CRTIMP extem long_timezone;
    /* standard/daylight savings time zone names */
    _CRTIMP extern char * _tzname[2];

            #ifndef           _CRTIMP
            #ifdef            _DLL
            #define           _CRTIMP_declspec (dllimport)
            #else             /* ndef_DLL */
            #define           _CRTIMP
            #endif            /* _DLL */
            #endif            /* _CRTIMP */

    /* Function prototypes */
    _CRTIMP char * _cdecl asctime (const struct tm *);
    _CRTIMP char * _cdecl ctime (const time_t *);
    _CRTIMP clock_t_cdecl clock (void);
    _CRTIMP double_cdecl difftime (time_t, time_t);
    _CRTIMP struct tm * _cdecl gmtime (const time_t *);
    _CRTIMP struct tm * _cdecl localtime (const time_t *);
    _CRTIMP time_t_cdecl mktime (struct tm *);
    _CRTIMP size_t_cdecl strftime (char * size_t const char *, const
    struct tm *);
    _CRTIMP char * _cdecl_strdate (char *);
    _CRTIMP char * _cdecl_strtime (char *);
    _CRTIMP time_t_cdecl time (time_t *);
    #ifdef  _POSIX_
    _CRTIMP void_cdecl tzset (void);
    #else
    _CRTIMP void_cdecl_tzset(void);
    #endif
    /* --------- The following functions are OBSOLETE ---------*/
    /* The Win32 API GetLocalTime, and SetLocalTime should be used
    instead. */
    unsigned_cdecl_getsystime (struct tm *);
    unsigned_cdecl_setsystime (struct tm *, unsigned);
    /* --------- The preceding functions are OBSOLETE ---------*/
    #ifndef_SIZE_T_DEFINED
    typedef unsigned int size_t;
    #define_SIZE_T_DEFNED
    #endif
    #ifndef_MAC
    #ifndef_WTIME_DEFINED
    /* wide function prototypes, also declared in wchar.h */
    _CRTIMP wchar_t * _cdecl_wasctime (const struct tm *);
    _CRTIMP wchar_t * _cdecl_wctime (const time_t *);
    _CRTIMP size_t_cdecl wcsftime (wchar_t *, size_t, const
    wchar_t*, const struct tm *);
    _CRTIMP wchar_t * _cdecl_wstrdate (wchar_t *);
    _CRTIMP wchar_t* _cdecl_wstrtime(wchar_t *);
    #define_WTIME_DEFINED
    #endif
    #endif  /* ndef _MAC */
    #if   !_STDC_ .parallel.defined (_POSIX_)
    /* Non-ANSI names for compatibility */
    #define CLK_TCK CLOCKS_PER_SEC
    _CRTIMP extern int daylight;
    _CRTIMP extern long timezone;
    _CRTIMP extern char * tzname [2];
    _CRTIMP void _cdecl tzset (void);
    #endif / * _STDC_ */
    #ifdef_cplusplus
    #ifdef _MSC_VER
    }
    #endif
    #ifdef_MSC_VER
    #pragma pack (pop)
    #endif /* _MSC_VER */
    #endif /* _INC_TIME */

            #if ( !defined (_MSC_VER) && !defined (_cdecl))
            #define_cdecl
            #endif

    int DKDate::getYear ( )        const
    {
        return (_t.GetYear ( ) + _diff);
    }
    int DKDate::getMonth ( )       const { return_t.GetMonth ( ); }
    int DKDate::getDay ( )         const { return_t.GetDay ( ); }

    DKTimestamp::DKTimestamp ( int nYear, int nMonth, int nDay,
                      int nHour, int nMin, int nSec, int nNano, int DST)
    {
        _diff = 0
        if(nYear > 2037)
        {
            _diff = (nYear - 2037);
            _t = CTime (2037, nMonth, nDay, nHour, nMin, nSec, DST);
        }
        else if (nYear < 1970)
        {
            _diff = (nYear - 1970);
            _t = CTime (1970, nMonth, nDay, nHour, aMin, nSec, DST);
        }
        else
        {
            _diff = (0);
            _t = CTime (nYear, nMonth, nDay, nHour, nMin, nSec, DST);
        }
        _nanos = nNano;
    }

    DKTimestamp::DKTimestamp ( )
    {
        time_t _time;
        time_t* pTime = &_time;
        struct tm temp;
        struct tm * pTemp = &temp;
        _time = time ((time_t*)NULL);
        pTemp = localtime (pTime);
        int nSec = pTemp->tm_sec;
        int nMin = pTemp->tm_min;
        int nHour = pTemp->tm_hour;
        int nDay = pTemp->tm_mday;
        int nMon = pTemp->tm_mon + 1;
        int nYear = pTemp->tm_year + 1900;
        _diff = 0;
        if (nYear > 2037)
        {
            _diff = (nYear - 2037);
            _t = CTime (2037, nMon, nDay, nHour, nMin, nSec, -1);
        }
        else if (nYear < 1970)
        {
            _diff = (nYear - 1970);
            _t = CTime (1970, nMon, nDay, nHour, nMin, nSec, -1);
        }
        else
        {
            _diff = (0);
            _t = CTime (nYear, nMon, nDay, nHour, nMin, nSec, -1);
        }
        _nanos = 0;
    }

    int DKTimestamp::getYear ( ) const
    {
        return (_t.GetYear ( ) + _diff);
    }
    int DKTimestamp::getMonth ( ) const { return_t.GetMonth ( );}
    int DKTimestamp::getDay ( )  const { return_t.GetDay ( );}
    int DKTimestamp::getHours ( ) const { return_t.GetHour ( );}
    int DKTimestamp::getMinutes ( ) const { return_t.GetMinute ( );}
    int DKTimestamp::getSeconds ( ) const { return_t.GetSecond ( );}
    int DKTimestamp::getNanos ( ) const { return_nanos;}

                      Base Year
    Target Year (TY)  (BY)          Offset            Offset (+/-)
    1 .ltoreq. TY < 1970 BY = 1970     Offset = TY - BY  Negative
    1970 .ltoreq. TY .ltoreq. 2037 BY = TY       Offset = TY - BY = Zero
                                    TY - TY
    2037 < TY .ltoreq. 9999 BY = 2037     Offset = TY - BY  Positive

    // Test program for DKDate and DKTimestamp
    /*
     * Filename   : Test cpp
     * Description : Test the DKDate and DKTimestamp classes
     *
     */
    #include <iostream.h>
    #include <stdio.h>
    #include <DKConstant.h>
    #include <DKDatastoreDL.hpp>
    #include <DKAccessControlDL.hpp>
    #include <DKException.hpp>
    #include <DKString.hpp>
    #include <DKEnvironment.hpp>
    #include <DKDate.hpp>
    void main(int argc, char *argv [ ])
    {
        cout << "begin . . . " << end;
        DKEnvironment::setSubSystem(DK_SS_CONSOLE);
        try {
            cout << "testing . . . " << endl;
                DKDate t = DKDate (2038, 1, 18);
                cout  << ">>>>> DKDate (2038, 1,
     18)"<<endl;
                cout  << " Year = " << t.getYear ( )
                      << " Month = " << t.getMonth ( )
                      << " Day = " << t.getDay( )
                      << " - - " << t.asString("%Y-%m-%d")
                      << endl;
                t = DKDate (2038, 1, 19);
                cout  << ">>>>> DKDate (2038, 1, 19)
     "<< endl;
                cout  << " Year = " << t.getYear ( )
                      << " Month = " << t.getMonth ( )
                      << " Day = " << t.getDay ( )
                      << " - - " << t.asString ("%Y-%m-%d")
                      << endl;
                t = DKDate (1970, 1, 1);
                cout  << ">>>>> DKDate (1970, 1,
     1)"<< endl;
                cout  << " Year = " << t.getYear ( )
                      << " Month = " << t.getMonth ( )
                      << " Day = " << t.getDay ( )
                      << " - - " << t.asString ("%Y-%m-%d")
                      << endl;
                t = DKDate (1969, 12, 31);
                cout  << ">>>>> DKDate (1969, 12,
     31)"<< endl;
                cout  << "Year = " << t.getYear ( )
                      << " Month = " << t.getMonth ( )
                      << " Day = " << t.getDay ( )
                      << " - - " << t.asString ("%Y-%m-%d")
                      << endl;
                t = DKDate(3999, 1, 1);
                cout  << ">>>>> DKDate (3999, 1,
     1)"<< endl;
                cout  << " Year = " << t.getYear ( )
                      << " Month = " << t.getMonth ( )
                      << " Day = " << t.getDay ( )
                      << " - - " <<t.asString ("%Y-%m-%d")
                      << endl;
                t = DKDate( )
                cout  << ">>>>> DKDate( )"<<endl;
                cout  << " Year = " << t.getYear ( )
                      << " Month = " << t.getMonth ( )
                      << " Day = " << t.getDay( ),
                      << " - - " << t.asString ("%Y-%m-%d")
                      << endl;
                DKTimestamp ts = DKTimestamp (1900, 1, 1, 10, 30, 59, 200, -1);
                cout  << ">>>>> DKTimestamp (1900, 1, 1,
     10, 30, 59, 200, -1)" <<
                      endl;
                cout  << " Year = " << ts.getYear ( )
                      << " Month = " << ts.getMonth ( )
                      << " Day = " << ts.getDay( )
                      << " Hours = " << ts.getHours ( )
                      << " Minutes = " << ts.getMinutes ( )
                      << " Seconds = " << ts.getSeconds ( )
                      << " Nanos = " << ts.getNanos ( )
                      << endl;
                ts = DKTimestamp (1960, 8, 27, 10, 30, 59, 200, -1);
                cout  << ">>>>> DKTimestamp (1960, 8, 27,
     10, 30, 59, 200,-1)" <<
                      endl;
                cout  << "Year = " << ts.getYear ( )
                      << " Month = " << ts.getMonth ( )
                      << " Day = " << ts.getDay( )
                      << " Hours = " << ts.getHours( )
                      << " Minutes = " << ts.getMinutes ( )
                      << " Seconds = " << ts.getSeconds ( )
                      << " Nanos = " << ts.getNanos ( )
                      << endl;
                ts = DKTimestamp (1999, 8, 27, 10, 30, 59, 200, -1);
                cout  << ">>>>> DKTimestamp (1999, 8, 27,
     10, 30, 59, 200, 1)"<<
                      endl;
                cout  << " Year = " << ts.getYear ( )
                      << " Month = " << ts.getMonth ( )
                      << " Day = " << ts.getDay ( )
                      << " Hours = " << ts.getHours ( )
                      << " Minutes = " << ts.getMinutes ( )
                      << " Seconds = " << ts.getSeconds ( )
                      << " Nanos = " << ts.getNanos ( )
                      << endl;
                ts DKTimestamp (2999, 8, 27, 10, 30, 59, 200, -1);
                cout  << ">>>>> DKTimestamp (2999, 8, 27,
     10, 30, 59, 200, -1)" <<
                      endl;
                cout  << "Year = "<< ts.getYear ( )
                      << " Month = "<< ts.getMonth ( )
                      << " Day = " << ts.getDay ( )
                      << " Hours = " << ts.getHours ( )
                      << " Minutes = " << ts.getMinutes ( )
                      << " Seconds = " << ts.getSeconds ( )
                      << " Nanos = "<< ts.getNanos ( )
                      << endl;
                ts = DKTimestamp( );
                cout  << ">>>>> DKTimestamp( )" <<
     endl;
                cout  << "Year = " << ts.getYear ( )
                      << " Month = " << ts.getMonth ( )
                      << " Day = " << ts.getDay ( )
                      << " Hours = " << ts.getHours ( )
                      << " Minutes = " << ts.getMinutes ( )
                      << " Seconds = " << ts.getSeconds ( )
                      << " Nanos = "<< ts.getNanos ( )
                      << endl;
            cout << "end of testing" << endl;
        }
        catch (DKException &exc)
        {
            cout << "Error id" << exc.errorId( ) << endl;
            for (unsigned long i = 0; i< exc.textCount( );i++)
            {
                cout << "Error text: " << exc.text(i) <<
     endl;
            }
            for (unsigned long g=0; g<exc.locationCount( );g++)
            {
                const DKExceptionLocation* p = exc.locationAtIndex(g);
                cout << "Filename: " << p->fileName( ) <<
     endl;
                cout << "Function: " << p->functionName( )
     << endl;
                cout << "LineNumber: " << p->lineNumber( )
     << endl;
            }
            cout << "Exception Class Name: " << exc.name( )
     << endl;
        }
        cout << "done . . . " << endl;
    }

    begin . . .
    testing . . .
    >>>>> DKDate (2038, 1, 18)
    Year = 2038 Month = 1 Day = 18 - - 2038-01-18
    >>>>> DKDate (2038, 1, 19)
    Year = 2038 Month = 1 Day = 19 - - 2038-01-19
    >>>>> DKDate (1970, 1, 1)
    Year = 1970 Month = 1 Day = 1 - - 1970-01-01
    >>>>> DKDate (1969, 12, 31)
    Year = 1969 Month = 12 Day 31 - - 1969-12-31
    >>>>> DKDate (3999, 1, 1)
    Year 3999 Month = 1 Day = 1 - - 3999-01-01
    >>>>> DKDate ( )
    Year = 1999 Month = 9 Day = 1 - - 1999-09-01
    >>>>> DKTimestamp (1900, 1, 1, 10, 30, 59, 200, -1)
    Year = 1900 Month = 1 Day = 1 Hours = 10 Minutes = 30 Seconds 59 Nanos =
     200
    >>>>> DKTimestamp (1960, 8, 27, 10, 30, 59, 200, -1)
    Year = 1960 Month = 8 Day = 27 Hours!= 10 Minutes = 30 Seconds 59 Nanos =
     200
    >>>>> DKTimestamp (1999, 8, 27, 10, 30, 59, 200, -1)
    Year = 1999 Month = 8 Day = 27 Hours = 10 Minutes = 30 Seconds 59 Nanos =
     200
    >>>>> DKTimestamp (2999, 8, 27, 10, 30, 59, 200, -1)
    Year = 2999 Month = 8 Day = 27 Hours 10 Minutes = 30 Seconds 59 Nanos = 200
    >>>>> DKTimestamp ( )
    Year = 1999 Month = 9 Day = 1 Hours = 11 Minutes = 46 Seconds 11 Nanos = 0
    end of testing
    done . . .

• Inventors
  Yaung, Alan Tsu-I;
• Assignee
  International Business Machines Corporation (Armonk, NY)
• Published
  Nov-4-2003
• Current US Classes:
  707/100
  707/103R
  707/103Y
• Application #
  497782
• International Classes
  G06F 017/30
• Field of Search
  707/103
• Examiner
  Robinson; Greta
• Agent
  Sughrue Mion, PLLC
• US Patent References:
  5526515
  5745796
  5758346
  5761668
  5806067
  5808889
  5812841
  5835909
  5852824
  5974569