diff options
Diffstat (limited to 'debian/htdig/htdig-3.2.0b6/htlib/HtDateTime.h')
| -rw-r--r-- | debian/htdig/htdig-3.2.0b6/htlib/HtDateTime.h | 533 |
1 files changed, 533 insertions, 0 deletions
diff --git a/debian/htdig/htdig-3.2.0b6/htlib/HtDateTime.h b/debian/htdig/htdig-3.2.0b6/htlib/HtDateTime.h new file mode 100644 index 00000000..c212b49a --- /dev/null +++ b/debian/htdig/htdig-3.2.0b6/htlib/HtDateTime.h @@ -0,0 +1,533 @@ +// +// HtDateTime.h +// +// HtDateTime: Parse, split, compare and format dates and times. +// Uses locale. +// +// Part of the ht://Dig package <http://www.htdig.org/> +// Copyright (c) 1999-2004 The ht://Dig Group +// For copyright details, see the file COPYING in your distribution +// or the GNU Library General Public License (LGPL) version 2 or later +// <http://www.gnu.org/copyleft/lgpl.html> +// +// $Id: HtDateTime.h,v 1.19 2004/05/28 13:15:20 lha Exp $ + +/////// + // Class for Date and Time + // Gabriele Bartolini - Prato - Italia + // Started: 22.04.1999 +/////// + +// Version: 1.0 +// Release date: 07.05.1999 + +// +// General purpose of HtDateTime +// The general purpose of this class, is to provide an interface for +// date and time managing, and to unload the programmer to manage +// time_t, struct tm, time system functions and other related procedures +// locally ... Everything regarding time and date must be put here. +// D'you agree with me? Well, here is a summary of the class capabilities. + +// Attributes of the class: +// +// HtDateTime class has only 2 member attributes +// - time_t Ht_t +// - bool local_time +// +// Obviously Ht_t contains the most important piece of information. +// local_time assumes a true value if we wanna consider the date and +// time information as local. False means that our object value is +// referred to the Greenwich Meridian time. + +// Interface provided: +// +// Construction: +// - Default: set the date time value to now +// - By passing a time_t value or pointer: Set to it +// - By passing a struct tm value or pointer: Set to it +// The last one could be useful sometimes. But it had better not to +// be used. +// +// Parsing interface: +// Not yet implemented ... :-) +// +// Setting Interface: +// - from time_t: copy the time_t value into the object +// - from struct tm: set the object's time_t value by converting +// the value from the struct tm. If local_time is set to true, +// converts it with mktime, else uses HtTimeGM. +// - set to now +// - from a string, by passing the input format: the method uses +// strptime syntax (and invokes Htstrptime). For now, timezone +// is ignored, and so data are stored as a GM date time value. +// - from an int series, by specifying all the information (year, +// month, day, hour, minute and second). It's all stored as +// GM value. +// - from various standard formats, such as C asctime, RFC 1123, +// RFC 850 (these 3 types are suggested by the HTTP/1.1 standard), +// ISO 8601, date and time default representation for the locale. +// This list could get longer ... It all depends on us. +// - setting the date and time to be represented in a local value +// or universal (GM) one. +// +// Getting Interface +// - in a personalized output format, by passing a string with +// strftime values. +// - in various standard formats, like C asctime, RFC 1123, +// RFC 850, ISO 8601 (short too), date and time default +// representation for the locale. +// - getting the time_t value +// - queries the local time status +// - getting specific piece of information of both the date and the +// the time, like the year, the month, the day of the week, of +// the year or of the month, ... In short, every kind of thing +// a tm structure is able to store ... +// +// Operator overloading +// - Copy +// - Every kind of logical comparison between 2 objects +// +// Comparison interface +// This is divided in 2 sections. +// - Static section: +// comparison are made on a 2 struct tm values basis. +// It's possible to compare the whole date time value, or +// simply the date or the time value. +// - Member functions section: +// comparison are made between 2 HtDateTime objects. +// You can compare either the whole date time, or the date, or the +// time, both as they are or referring their values to the GM value. +// +// System functions interface +// They are all done with previous "configure" checks +// - for strptime +// - for timegm +// +// Static methods +// - check for a leap year +// - check for a valid year number (according with time_t capabilities) +// - check for a valid month number +// - check for a valid day +// - converts a 2 digits year number into a 4 digits one: from 1970 to 2069. +// - converts a 4 digits year number into a 2 digits one. +// - retrieve the difference in seconds between 2 HtDateTime objs +// +// Test Interface (only by defining TEST_HTDATETIME directive). +// + + +#ifndef _HTDATETIME_H +#define _HTDATETIME_H + +#ifdef HAVE_CONFIG_H +# include "htconfig.h" +#endif + +#if TIME_WITH_SYS_TIME +#include <sys/time.h> +#include <time.h> +#else +# if HAVE_SYS_TIME_H +# include <sys/time.h> +# else +# include <time.h> +# endif +#endif + +#include "htString.h" + +// If you wanna do some tests +#define TEST_HTDATETIME + + +class HtDateTime +{ +public: + +/////// + // Construction +/////// + + // Default: now and local + HtDateTime() {SettoNow(); ToLocalTime();} + + // From an integer (seconds from epoc) +// Causes ambiguity in systems with time_t an integer... +// HtDateTime(const int i) {SetDateTime((time_t)i); ToLocalTime();} + + // From a time_t value and pointer + HtDateTime(time_t &t) {SetDateTime(t); ToLocalTime();} + HtDateTime(time_t *t) {SetDateTime(t); ToLocalTime();} + + // From a struct tm value and pointer + HtDateTime(struct tm &t) {SetDateTime(t); ToLocalTime();} + HtDateTime(struct tm *t) {SetDateTime(t); ToLocalTime();} + + // Copy constructor + inline HtDateTime(const HtDateTime& rhs); + +/////// + // Interface methods +/////// + +/////// + // "Parsing" interface +/////// + + int Parse(const char *); // It looks for the similar format + // then sets the date by invoking + // right method + + +/////// + // "Setting" interface +/////// + + // Setting from a time_t value + void SetDateTime(const time_t &t) { Ht_t = t; } // by reference + void SetDateTime(const time_t *t) { Ht_t = *t; } // by pointer + + // Set object time_t value from a struct tm + void SetDateTime(struct tm *); // by pointer + inline void SetDateTime(struct tm &t) { SetDateTime(&t);} // by reference + + // Set GM Time from single values input + // Return true if it all went good, false else + bool SetGMDateTime( int year, int mon, int mday, + int hour=0, int min=0, int sec=0); + + // Set to Now + void SettoNow(); + + // Parsing various input string format + // It ignores time Zone value - always stores as GM + char *SetFTime(const char *, const char *); // as strptime + + void SetAscTime(char *); // Sun Nov 6 08:49:37 1994 + void SetRFC1123(char *); // Sun, 06 Nov 1994 08:49:37 GMT + void SetRFC850(char *); // Sunday, 06-Nov-94 08:49:37 GMT + void SetISO8601(char *); // 1994-11-06 08:49:37 GMT + void SetTimeStamp(char *); // 19941106084937 + + void SetDateTimeDefault(char *); // Default date and time representation + // for the locale + + /////// + // Methods for setting Local and GM time formats (Switches) + /////// + + void ToLocalTime() {local_time=true;} + void ToGMTime() {local_time=false;} + + +/////// + // "Getting" interface +/////// + + + /////// + // Output formats + /////// + + // Personalized output + char *GetFTime(const char *format) const; // as strftime + size_t GetFTime(char *, size_t, const char *) const; // as strftime + + char *GetAscTime() const; // Sun Nov 6 08:49:37 1994 + char *GetRFC1123() const; // Sun, 06 Nov 1994 08:49:37 GMT + char *GetRFC850() const; // Sunday, 06-Nov-94 08:49:37 GMT + char *GetISO8601() const; // 1994-11-06 08:49:37 GMT + char *GetTimeStamp() const; // 19941106084937 + + char *GetDateTimeDefault() const; // Default date and time representation + // for the locale + + // Partial (only date or only time) + char *GetShortISO8601() const; // 1994-11-06 + char *GetDateDefault() const; // Default date form for the locale + char *GetTimeDefault() const; // Default time form for the locale + + + /////// + // Gets the time_t value + /////// + + time_t GetTime_t() const {return Ht_t;} + + + /////// + // Gets specific date and time values (from a struct tm) + /////// + + // Gets the year + int GetYear() const { return ( GetStructTM().tm_year + 1900) ;} + + // Gets the month + int GetMonth() const { return (GetStructTM().tm_mon + 1);} + + // Gets the day of the week (since Sunday) + int GetWDay() const { return (GetStructTM().tm_wday + 1);} + + // Gets the day of the month + int GetMDay() const { return GetStructTM().tm_mday;} + + // Gets the day since january 1 + int GetYDay() const { return (GetStructTM().tm_yday + 1);} + + // Gets the hour + int GetHour() const { return GetStructTM().tm_hour;} + + // Gets the minute + int GetMinute() const { return GetStructTM().tm_min;} + + // Gets the second + int GetSecond() const { return GetStructTM().tm_sec;} + + // Daylight saving time is in effect at that time? + int GetIsDst() const { return GetStructTM().tm_isdst;} + + + /////// + // Methods for querying localtime status + /////// + + bool isLocalTime() const {return local_time;} + bool isGMTime() const {return !local_time;} + + + +/////// + // Methods for comparison +/////// + + // Returns 0 if equal, -1 if tm1 is lower than tm2, 1 if tm1 is greater than tm2 + + int DateTimeCompare (const HtDateTime &) const; // Compares both date and time + + int DateCompare (const HtDateTime &) const; // Compares the date + int TimeCompare (const HtDateTime &) const; // Compares the time + + // Refers the date and the time to a GM value, then compares + int GMDateTimeCompare (const HtDateTime &) const; // Compares both date and time + int GMDateCompare (const HtDateTime &) const; // Compares the date + int GMTimeCompare (const HtDateTime &) const; // Compares the time + + +/////// + // Operator overloading +/////// + + // For comparisons - between objects of the same class + + inline bool operator==(const HtDateTime &right) const; + inline bool operator<(const HtDateTime &right) const; + + bool operator!=(const HtDateTime &right) const + {return !( *this == right );} + + bool operator>=(const HtDateTime &right) const + {return !( *this < right);} + + bool operator<=(const HtDateTime &right) const + {return !( right < *this);} + + bool operator>(const HtDateTime &right) const + {return right < *this; } + + + // For comparisons - between HtDateTime objects and int + + bool operator==(const int right) const // with an int + {return ( Ht_t == (time_t) right );} + + bool operator<(const int right) const // with an int + {return ( Ht_t < (time_t) right );} + + bool operator!=(const int right) const // with an int + {return !( *this == right );} + + bool operator>=(const int right) const // with an int + {return !( *this < right);} + + bool operator<=(const int right) const // with an int + {return !( *this > right);} + + bool operator>(const int right) const // with an int + {return (Ht_t > (time_t) right); } + + + // For Copy + + inline HtDateTime &operator=(const HtDateTime &right); + inline HtDateTime &operator=(const int right); + + + + +/////// // STATIC METHODS // /////// + + // Here we can add static methods as we want more :-) + // Then invoke them with HtDateTime::MethodXXX () + + + inline static bool LeapYear(int); // Is a leap year? + + // These checks are made for time_t compatibility + inline static bool isAValidYear(int); // Is a valid year number + + inline static bool isAValidMonth(int); // Is a valid month number + inline static bool isAValidDay(int, int, int); // Is a valid day + + + // Converts a 2 digits year in a 4 one - with no checks + static int Year_From2To4digits (int y) + { + if ( y >= 70 ) return y+1900; + else return y+2000; + } + + // Converts a 4 digits year in a 2 one - with no checks + static int Year_From4To2digits (int y) + { + if ( y >= 2000 ) return y - 2000; + else return y - 1900; + } + + static int GetDiff(const HtDateTime &, const HtDateTime &); + + // Check equality from 2 struct tm pointers + // Returns 0 if equal, -1 if tm1 is lower than tm2, 1 if tm1 is greater than tm2 + + // Compares the whole time information (both date and time) + static int DateTimeCompare(const struct tm *tm1, + const struct tm *tm2); + + // Compares only date + static int DateCompare(const struct tm *tm1, + const struct tm *tm2); + + // Compares only time + static int TimeCompare(const struct tm *tm1, + const struct tm *tm2); + + + +/////// // HIDDEN ATTRIBUTES & METHODS // /////// + +protected: // to permit inheritance + + time_t Ht_t; + bool local_time; + + static const int days[]; + +/////// + // Sets and gets the struct tm depending on local_time status +/////// + + void RefreshStructTM() const; // Refresh its content + struct tm &GetStructTM() const; // gets it + void GetStructTM(struct tm & t) const { t=GetStructTM(); } // Gets and copy + + +/////// + // Gets the struct tm ignoring local_time status +/////// + + struct tm &GetGMStructTM() const; // gets it + void GetGMStructTM(struct tm &) const; // Gets and copy + + +/////// + // Interface for system functions +/////// + + // Interface for timegm + static time_t HtTimeGM (struct tm*); + + +#ifdef TEST_HTDATETIME + +/////// + // Only for debug: view of struct tm fields +/////// + +public: + + static void ViewStructTM(struct tm *); // view of struct tm fields + virtual void ViewStructTM(); // view of struct tm fields + void ViewFormats(); // View of various formats + + void ComparisonTest (const HtDateTime &) const; // comparison + + + // Test of the class + static int Test(void); + static int Test(char **test_dates, const char *format); + +#endif + +}; + + +/////// + // Copy constructor +/////// + +inline +HtDateTime::HtDateTime (const HtDateTime& rhs) +{ + // Copy the contents + Ht_t = rhs.Ht_t; + local_time = rhs.local_time; +} + +/////// + // Operator overloading +/////// + +inline +bool HtDateTime::operator==(const HtDateTime &right) const +{ + if(Ht_t==right.Ht_t) + return true; + else + return false; +} + +inline +bool HtDateTime::operator<(const HtDateTime &right) const +{ + if(Ht_t < right.Ht_t) return true; + else return false; +} + +/////// + // Copy +/////// + +inline +HtDateTime &HtDateTime::operator=(const HtDateTime &right) +{ + if (this != &right) + { + Ht_t=right.Ht_t; // Copy the time_t value + local_time=right.local_time; // Copy the local_time flag + } + + return *this; +} + +inline +HtDateTime &HtDateTime::operator=(const int right) +{ + Ht_t=(time_t)right; // Copy the int as a time_t value + ToLocalTime(); + return *this; +} + + + + +#endif |