src/date.h

   1 /**************************************************************************
   2 **  (c) Copyright 1999, Andromeda Technology & Automation
   3 ***************************************************************************
   4 ** MODULE INFORMATION *
   5 ***********************
   6 **      FILE NAME      : date.h
   7 **      SYSTEM NAME    : AXE - Andromeda X-windows Encapsulation
   8 **      VERSION NUMBER : $Revision: 1.3 $
   9 **
  10 **  DESCRIPTION      :
  11 **
  12 **  EXPORTED OBJECTS :
  13 **  LOCAL    OBJECTS :
  14 **  MODULES  USED    :
  15 ***************************************************************************
  16 **  ADMINISTRATIVE INFORMATION *
  17 ********************************
  18 **      ORIGINAL AUTHOR : Arjen Baart - arjen@andromeda.nl
  19 **      CREATION DATE   : Feb 06, 1998
  20 **      LAST UPDATE     : Oct 16, 1999
  21 **      MODIFICATIONS   :
  22 **************************************************************************/
  23
  24 /*****************************
  25    $Log: date.h,v $
  26    Revision 1.3  2002-09-28 06:58:45  arjen
  27    Bugfix: conversion of an empty string to a date or hour object
  28    now makes the values of such an object 0 (null) instead of giving
  29    a segmentation fault.
  30    The class UTC combines the date and hour classes. The most basic
  31    functions of the UTC class are now implemented.
  32    These include constructors and conversion to and from String objects.
  33    New functions: date::proper(), hour::proper() and UTC::proper().
  34    Return true if the object holds a proper clock time and/or calendar
  35    date; false if at least one value is out of range.
  36
  37    Revision 1.2  2002/09/02 06:18:20  arjen
  38    Fixed some date and time conversion functions
  39
  40    Revision 1.1  2002/07/25 08:01:26  arjen
  41    First checkin, AXE release 0.2
  42
  43 *****************************/
  44
  45 /* static const char *RCSID = "$Id: date.h,v 1.3 2002-09-28 06:58:45 arjen Exp $"; */
  46
  47 #ifndef AXE_DATE_H
  48 #define AXE_DATE_H
  49
  50 #include "String.h"
  51
  52 class date
  53 {
  54    unsigned char  month, day;
  55    short year;
  56
  57    long julian();
  58    date add(date D);
  59    date add(unsigned long days);
  60
  61    date subtract(unsigned long days);
  62
  63    friend class UTC;
  64
  65 public:
  66
  67    date()
  68    {
  69       month = 0;
  70       day   = 0;
  71       year  = 0;
  72    }
  73
  74    date(unsigned  d, unsigned  m=0, short y=0)
  75    {
  76       day   = d;
  77       month = m;
  78       year  = y;
  79    }
  80
  81    date(String s);
  82
  83    bool proper();   // Check wether this is a proper calendar date
  84
  85    friend date operator+(date, date);
  86    friend date operator+(unsigned long,  date);
  87    friend date operator+(date,  unsigned long);
  88
  89    date operator += (date D)
  90    {
  91       return add(D);
  92    }
  93
  94    date operator += (unsigned long l)
  95    {
  96       return add(l);
  97    }
  98
  99    date operator ++ ()        // prefix
 100    {
 101       return add(1);
 102    }
 103
 104    date operator ++ (int)     // postfix
 105    {
 106       return add(1);
 107    }
 108
 109    friend date operator-(unsigned long,  date);
 110    friend date operator-(date,  unsigned long);
 111    friend long operator-(date&, date&);
 112
 113    date operator -= (unsigned long l)
 114    {
 115       return subtract(l);
 116    }
 117
 118    date operator -- ()        // prefix
 119    {
 120       return subtract(1);
 121    }
 122
 123    date operator -- (int)     // postfix
 124    {
 125       return subtract(1);
 126    }
 127
 128 //   long(date);        // Calculate nr. of days since...
 129
 130    int operator==(date d)
 131    {
 132       int cm;
 133
 134       cm = this->year - d.year;
 135       cm = (cm != 0) ? cm : this->month - d.month;
 136       cm = (cm != 0) ? cm : this->day   - d.day;
 137
 138       return cm == 0;
 139    }
 140
 141    int operator!=(date d)
 142    {
 143       int cm;
 144
 145       cm = this->year - d.year;
 146       cm = (cm != 0) ? cm : this->month - d.month;
 147       cm = (cm != 0) ? cm : this->day   - d.day;
 148
 149       return cm != 0;
 150    }
 151
 152    int operator<=(date d)
 153    {
 154       int cm;
 155
 156       cm = this->year - d.year;
 157       cm = (cm != 0) ? cm : this->month - d.month;
 158       cm = (cm != 0) ? cm : this->day   - d.day;
 159
 160       return cm <= 0;
 161    }
 162
 163    int operator>=(date d)
 164    {
 165       int cm;
 166
 167       cm = this->year - d.year;
 168       cm = (cm != 0) ? cm : this->month - d.month;
 169       cm = (cm != 0) ? cm : this->day   - d.day;
 170
 171       return cm >= 0;
 172    }
 173
 174    int operator>(date d)
 175    {
 176       int cm;
 177
 178       cm = this->year - d.year;
 179       cm = (cm != 0) ? cm : this->month - d.month;
 180       cm = (cm != 0) ? cm : this->day   - d.day;
 181
 182       return cm > 0;
 183    }
 184
 185    int operator<(date d)
 186    {
 187       int cm;
 188
 189       cm = this->year - d.year;
 190       cm = (cm != 0) ? cm : this->month - d.month;
 191       cm = (cm != 0) ? cm : this->day   - d.day;
 192
 193       return cm < 0;
 194    }
 195
 196    //  Attributes.
 197
 198    unsigned Day()
 199    {
 200       return day;
 201    }
 202
 203    unsigned Month()
 204    {
 205       return month;
 206    }
 207
 208    String MonthName(void);
 209
 210    int Year()
 211    {
 212       return year;
 213    }
 214    //  Operations.
 215
 216    int Leap(void);
 217    unsigned DaysInMonth();
 218
 219 //   date operator*(double)
 220 //   date& operator*=(double)
 221 //   date operator/(double)
 222 //   date& operator/=(double)
 223
 224    friend std::ostream& operator<<(std::ostream&, const date&);
 225    friend std::istream& operator>>(std::istream&, date&);
 226
 227    String format(const char *fmt = "%F");
 228 };
 229
 230 date today(bool localtime = true);
 231
 232 class hour
 233 {
 234    int   hours;
 235    short minutes, seconds;
 236
 237    friend class UTC;
 238
 239    int compare(hour h)
 240    {
 241       int cm;
 242
 243       cm = this->hours - h.hours;
 244       cm = (cm != 0) ? cm : this->minutes - h.minutes;
 245       cm = (cm != 0) ? cm : this->seconds - h.seconds;
 246
 247       return cm;
 248    }
 249
 250    hour increase();
 251    hour decrease();
 252
 253 public:
 254
 255    hour()
 256    {
 257       hours = 0;
 258       minutes = 0;
 259       seconds = 0;
 260    }
 261
 262    hour(int hr, short minute, short sec)
 263    {
 264       hours = hr;
 265       minutes = minute;
 266       seconds = sec;
 267    }
 268
 269    hour(String s);
 270
 271    bool proper();   // Check wether this is a proper clock time
 272
 273    //  Attributes.
 274
 275    short Second()
 276    {
 277       return seconds;
 278    }
 279
 280    short Minute()
 281    {
 282       return minutes;
 283    }
 284
 285    int Hour()
 286    {
 287       return hours;
 288    }
 289
 290    bool operator==(hour h)
 291    {
 292       return compare(h) == 0;
 293    }
 294
 295    bool operator!=(hour h)
 296    {
 297       return compare(h) != 0;
 298    }
 299
 300    bool operator<(hour h)
 301    {
 302       return compare(h) < 0;
 303    }
 304
 305    bool operator>(hour h)
 306    {
 307       return compare(h) > 0;
 308    }
 309
 310    bool operator<=(hour h)
 311    {
 312       return compare(h) <= 0;
 313    }
 314
 315    bool operator>=(hour h)
 316    {
 317       return compare(h) >= 0;
 318    }
 319
 320    friend hour operator+(hour, hour);
 321    hour operator += (hour h);
 322
 323    hour operator ++ ()        // prefix
 324    {
 325       return increase();
 326    }
 327
 328    hour operator ++ (int)     // postfix
 329    {
 330       return increase();
 331    }
 332
 333    friend hour operator-(hour, hour);
 334    hour operator -= (hour h);
 335
 336    hour operator -- ()        // prefix
 337    {
 338       return decrease();
 339    }
 340
 341    hour operator -- (int)     // postfix
 342    {
 343       return decrease();
 344    }
 345
 346
 347    friend std::ostream& operator<<(std::ostream &, const hour &);
 348    friend std::istream& operator>>(std::istream &, hour &);
 349
 350    String format(const char *fmt = "%T");
 351 };
 352
 353 hour now(bool localtime = true);
 354
 355 class UTC
 356 {
 357    hour  t;
 358    date  d;
 359
 360 public:
 361
 362    UTC()
 363    {
 364       /* Leave everything to the default hour and date constructors */
 365    }
 366
 367    UTC(const String s);
 368    UTC(date dt, hour tm)
 369    {
 370       d = dt;
 371       t = tm;
 372    }
 373
 374    operator date()
 375    {
 376       return d;
 377    }
 378
 379    operator hour()
 380    {
 381       return t;
 382    }
 383
 384    bool proper()
 385    {
 386       return d.proper() && t.proper();
 387    }
 388
 389    bool operator==(UTC u)
 390    {
 391       return d == u.d && t == u.t;
 392    }
 393
 394    bool operator!=(UTC u)
 395    {
 396       return d != u.d || t != u.t;
 397    }
 398
 399    bool operator<=(UTC u)
 400    {
 401       if (d == u.d)
 402       {
 403          return t <= u.t;
 404       }
 405       else
 406       {
 407          return d <= u.d;
 408       }
 409    }
 410
 411    bool operator<(UTC u)
 412    {
 413       if (d == u.d)
 414       {
 415          return t < u.t;
 416       }
 417       else
 418       {
 419          return d < u.d;
 420       }
 421    }
 422
 423    bool operator>=(UTC u)
 424    {
 425       if (d == u.d)
 426       {
 427          return t >= u.t;
 428       }
 429       else
 430       {
 431          return d >= u.d;
 432       }
 433    }
 434
 435    bool operator>(UTC u)
 436    {
 437       if (d == u.d)
 438       {
 439          return t > u.t;
 440       }
 441       else
 442       {
 443          return d > u.d;
 444       }
 445    }
 446
 447    friend UTC operator+(UTC &, UTC &);
 448    UTC operator += (UTC h);
 449
 450    friend std::ostream& operator<<(std::ostream &, const UTC &);
 451    friend std::istream& operator>>(std::istream &, UTC &);
 452
 453    String format(const char *fmt = "%F %T");
 454 };
 455
 456 UTC Now(bool localtime = true);
 457
 458 #endif /* AXE_DATE_H */