---

lkdatetime.h

/* liblookdb: lkdatetime.h - Date, Time, Date-Time classes
    Copyright (C) 1998-2001 LOOK Systems

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/
#ifndef LIBLOOKDB_LKDATETIME_H
#define LIBLOOKDB_LKDATETIME_H

// $Id: lkdatetime.h,v 1.5 2001/07/04 15:53:17 clive Exp $

/* Date class (julian dates) Time class (secs since midnight) Date-Time (both)
*/

#include "looktypes.h"
#include "lktypebase.h"

#include "lkstring.h"

namespace look {

// *****************************************************
// LookDateTime class
// *****************************************************


class LOOKTYPES_DLL LookDate : public LookTypeBase
{
public:

// Constructors.
        LookDate( unsigned long julianDate = 0UL );
        LookDate( const LookDate& theOther );

        LookDate( unsigned int theDay, unsigned int theMonth, unsigned int theYear );
        LookDate( unsigned int theDay, const LookString& theMonth, unsigned int theYear );

        ~LookDate( void );

// get a copy
        LookTypeBase* GetNewCopy( void ) const;

// get my id
        long GetTypeID( void ) const;

// arithmetic operators
// these are all changes in days
        LookDate& operator++();
        LookDate operator++( int );

        LookDate& operator--();
        LookDate operator--( int );

        LookDate& operator+=( long theDays );
        LookDate operator+( long theDays ) const;

        LookDate& operator-=( long theDays );
        LookDate operator-( long theDays ) const;
// this one is the exception - you can get ndays from two dates
        long operator-( const LookDate& theDate ) const;

        // add months like ingres does
        // we can take + or - months
        void AddMonths( int theMonths );

// comparison
        bool operator==( const LookDate& theOther ) const;
        bool operator!=( const LookDate& theOther ) const;
        bool operator<( const LookDate& theOther ) const;
        bool operator>( const LookDate& theOther ) const;
        bool operator<=( const LookDate& theOther ) const;
        bool operator>=( const LookDate& theOther ) const;

// is this date valid?
        bool IsSet( void ) const;

// various day, month, week, year queries
        unsigned int DayOfMonth( void ) const;
        unsigned int Month( void ) const;       // 1-12
        unsigned int Year( void ) const;        // no BC support

        unsigned int DayOfYear( void ) const;

        // day of week is 1 = Monday, 7 = Sunday, just like RW.
        // people seem to do it many ways, so i've stuck with what i'm replacing
        unsigned int DayOfWeek( void ) const;

        // convenience methods
        LookString DayName( void ) const;
        LookString MonthName( void ) const;

// the previous method (get the previous monday or whatever)
// and next
        LookDate Previous( unsigned int dayNumber ) const;
        LookDate Next( unsigned int dayNumber ) const;

// are we a leap year?
// (notice the static one too)
        bool IsLeap( void ) const;

// string access
        bool Set( LookString theDateString );

// set format is one of these
// also is the getstring parameters
//                separator  order    monthnum   yeardigits
// dd-mmm-yyyy     -          dmy       true        4
// dd/mm/yy        /          dmy       false       2
// yymmdd          '\0'       ymd       true        2
// yyyy-mm-dd      -          ymd       true        4
// dd.mm.yyyy      .          dmy       true        4
// yyyy-mmm-dd     -          ymd       false       4
// dd-mmm-yyyy     -          dmy       false       4
// mmm-dd-yyyy     -          mdy       false       4
// dd/mm/yyyy      /          dmy       true        4

        // this one is easiest to program
        LookString GetString( const LookString& theSeparator = "/",
                const LookString& theOrder = "dmy", 
                bool monthIsNumber = true,
                int yearDigits = 4 ) const;

// static methods
// today
        static LookDate Now( void );

// conversions. fromstring takes short or long form
        static unsigned int DayFromName( LookString theDayName );
        static LookString NameFromDay( unsigned int theDayNumber );
        static LookString ShortNameFromDay( unsigned int theDayNumber );

        static unsigned int MonthFromName( LookString theMonthName );
        static LookString NameFromMonth( unsigned int theMonthNumber );
        static LookString ShortNameFromMonth( unsigned int theMonthNumber );

        static unsigned int DaysInMonth( unsigned int theMonthNumber,
                unsigned int theYear );

        static bool IsLeap( unsigned int theYear );

        static void ConvertFromJulian( unsigned long theJulianDate,
                unsigned int& year, unsigned int& month, unsigned int& day ); 

        static unsigned long ConvertToJulian( unsigned int year,
                unsigned int month, unsigned int day ); 

        static void SetCenturyBoundary( int theBoundary );
        static int GetCenturyBoundary( void );

protected:

        unsigned long itsJulianDate;


        static unsigned int itsCenturyBoundary;
};

// ===========================================================
// time
// ===========================================================

class LOOKTYPES_DLL LookTime : public LookTypeBase
{
public:
// Constructors.
        LookTime( unsigned int theTime = 0 );

        LookTime( unsigned int theHours, unsigned int theMinutes,
                unsigned int theSeconds = 0 );

        LookTime( bool isPM, unsigned int theHours, unsigned int theMinutes = 0,
                unsigned int theSeconds = 0 );

        LookTime( const LookTime& theOther );

        ~LookTime();

        // get a copy
        LookTypeBase* GetNewCopy( void ) const;

// get my id
        long GetTypeID( void ) const;

        LookTime& operator=( const LookTime& theOther );

        // comparison
        bool operator==( const LookTime& theOther ) const;
        bool operator!=( const LookTime& theOther ) const;
        bool operator<( const LookTime& theOther ) const;
        bool operator>( const LookTime& theOther ) const;
        bool operator<=( const LookTime& theOther ) const;
        bool operator>=( const LookTime& theOther ) const;

        // differences are always in seconds
        LookTime& operator+=( int theChange );
        LookTime operator+( int theChange ) const;

        // difference between two times is in seconds
        int operator-( LookTime& theOther ) const;

        // difference between a time and some seconds is a time
        LookTime operator-( int theChange ) const;
        LookTime& operator-=( int theChange );

        // normalise us to a time of day, returning the change in days
        // if if itsTime = 100000, normalise will set time to
        // 13600 and return 1
        // -100000 -> 72800, -2 days
        int Normalise( void );

        bool Set( LookString theTimeString );

        // precision is 3 for hms, 2 for hm and 1 for h
        LookString GetString( const LookString& theSeparator = ":",
                int thePrecision = 3,
                bool hours24 = true ) const;

        // if the time is -ve these won't work
        unsigned int Hours( void ) const;
        unsigned int Hours12( void ) const;
        unsigned int Minutes( void ) const;
        unsigned int Seconds( void ) const;
        bool isPM( void ) const;

        void SetTime( unsigned int theTime )
        {
                itsTime = theTime;
        }

        unsigned int GetTime( void ) const
        {
                return itsTime;
        }

        // get current date/time
        static LookTime Now( void );

protected:

        // allowed to be negative before normalising if you _really_ want
        int itsTime;
};

// ===========================================================
// date/time
// ===========================================================

class LOOKTYPES_DLL LookDateTime : public LookTypeBase
{
public:
// Constructors.
        LookDateTime();
        LookDateTime( const LookDate& theDate, const LookTime& theTime = 0 );

        LookDateTime( const LookDateTime& theOther );

        // destructor
        ~LookDateTime();

// get a copy
        LookTypeBase* GetNewCopy( void ) const;

// get my id
        long GetTypeID( void ) const;

        LookDateTime& operator=( const LookDateTime& theOther );

        // comparison
        bool operator==( const LookDateTime& theOther ) const;
        bool operator!=( const LookDateTime& theOther ) const;
        bool operator<( const LookDateTime& theOther ) const;
        bool operator>( const LookDateTime& theOther ) const;
        bool operator<=( const LookDateTime& theOther ) const;
        bool operator>=( const LookDateTime& theOther ) const;

        // differences are always in seconds
        LookDateTime& operator+=( long theChange );
        LookDateTime operator+( long theChange ) const;

        // difference between two dates is in seconds
        long operator-( LookDateTime& theOther ) const;

        // difference between a date and some seconds is a date
        LookDateTime& operator-=( long theChange );
        LookDateTime operator-( long theChange ) const;

        // get/set date/time
        void SetTime( const LookTime& theTime );
        void SetDate( const LookDate& theDate );

        LookTime GetTime( void ) const;
        LookDate GetDate( void ) const;

        bool Set( const LookString& theDateTimeString );

        // see GetString for lookDate for first 4 params
        // timeprecision is 3 for hms, 2 for hm and 1 for h
        LookString GetString( const LookString& theDateSeparator = "/",
                const LookString& theOrder = "dmy", 
                bool monthIsNumber = true,
                int yearDigits = 4,             
                const LookString& theTimeSeparator = ":",
                int theTimePrecision = 3,
                bool hours24 = true ) const;
        
        // get current date/time
        static LookDateTime Now( void );

protected:

        void Normalise( void );

        LookDate itsDate;
        LookTime itsTime;
};


} // end of "look" namespace
#endif 

---