earth_time.h

Go to the documentation of this file.

#ifndef EARTH_TIME_GROUP
#define EARTH_TIME_GROUP

/*****************************************************************************\
*                                                                             *
*  Name   : earth_time                                                        *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 1999-$now By Author.  This program is free software; you can  *
* redistribute it and/or modify it under the terms of the GNU General Public  *
* License as published by the Free Software Foundation; either version 2 of   *
* the License or (at your option) any later version.  This is online at:      *
*     http://www.fsf.org/copyleft/gpl.html                                    *
* Please send any updates to: fred@gruntose.com                               *
\*****************************************************************************/

#include "packable.h"


namespace earth_time {

  enum days { SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY };

  days day_now();  

  const char *day_name(days to_name);

  enum months { JANUARY, FEBRUARY, MARCH, APRIL, MAY, JUNE, JULY, AUGUST,
      SEPTEMBER, OCTOBER, NOVEMBER, DECEMBER };

  months month_now();  

  const char *month_name(months to_name);
  const char *short_month_name(months to_name);

  extern const int days_in_month[12];
  extern const int leap_days_in_month[12];

  extern const int julian_days_in_month[12];
  extern const int julian_leap_days_in_month[12];

  const int SECONDS_IN_MINUTE = 60;  
  const int MINUTES_IN_HOUR = 60;  
  const int HOURS_IN_DAY = 24;  
  const int DAYS_IN_YEAR = 365;  
  const int LEAP_DAYS_IN_YEAR = 366;  
  const double APPROX_DAYS_IN_YEAR = 365.2424;


  enum time_zones {
    LOCAL_ZONE,      
    GREENWICH_ZONE   
  };

  // now some structures for representing time...

  class clock_time : public packable
  {
  public:
    int hour;  
    int minute;  
    int second;  
    int millisecond;  
    int microsecond;  

    clock_time(int h = 0, int m = 0, int s = 0, int ms = 0, int us = 0)
             : hour(h), minute(m), second(s), millisecond(ms),
               microsecond(us) {}

    virtual void pack(byte_array &packed_form) const;
    virtual bool unpack(byte_array &packed_form);

    bool operator < (const clock_time &to_compare) const;
    bool operator == (const clock_time &to_compare) const;

    enum time_formats {
      MERIDIAN = 0x1,  
      MILITARY = 0x2,  
      NO_AM_PM = 0x4,  
      SECONDS = 0x8,   
      MILLISECONDS = 0x10  
    };

    istring text_form(int how = MERIDIAN) const;

    void text_form(istring &to_stuff, int how = MERIDIAN) const;

    static int normalize(clock_time &to_fix);
      // ensures that the units in each field are in the proper range by
      // promoting them upwards.  if the clock_time goes above the maximum hour,
      // then it rolls around.  zero is returned for no rollover or a positive
      // integer is returned for the number of rollovers that occurred.  if
      // there are any negative fields, they are rolled backwards.
      // the returned rollovers are measured in days.
  };

  class day_in_year : public packable
  {
  public:
    months month;  
    int day_in_month;  
    days day_of_week;  
    int day_of_year;  

    day_in_year(months m = JANUARY, int dim = 1, days dow = SUNDAY,
            int day_o_year = 1) : month(m), day_in_month(dim),
            day_of_week(dow), day_of_year(day_o_year) {}

    virtual void pack(byte_array &packed_form) const;
    virtual bool unpack(byte_array &packed_form);

    bool operator < (const day_in_year &to_compare) const;

    bool operator == (const day_in_year &to_compare) const;


    enum date_formats {
      // note: these classes may need to be revised in the year 9999.
      SHORT_MONTH = 0x1,    
      LONG_MONTH = 0x2,     
      INCLUDE_DAY = 0x4     
    };

    istring text_form(int how = SHORT_MONTH) const;
    void text_form(istring &to_stuff, int how = SHORT_MONTH) const;

    static int normalize(day_in_year &to_fix, bool leap_year = false);

  };


  class time_locus : public clock_time, public day_in_year
  {
  public:
    int year;  

    time_locus(const clock_time &ct = clock_time(),
            const day_in_year &ytd = day_in_year(), int year_in = 0)
            : clock_time(ct), day_in_year(ytd), year(year_in) {}

    virtual void pack(byte_array &packed_form) const;
    virtual bool unpack(byte_array &packed_form);

    bool operator < (const time_locus &to_compare) const;
    bool operator == (const time_locus &to_compare) const;

    enum locus_formats {
      LONG_YEAR = 0x1,  
      SHORT_YEAR = 0x2  
    };

    istring text_form(int t = clock_time::MERIDIAN,
            int d = day_in_year::SHORT_MONTH, int y = LONG_YEAR) const;
      /*< "t" is a combination of time_formats, "d" is a combination of
      date_formats and "y" is a combination of locus_formats. */
    void text_form(istring &to_stuff, int t = clock_time::MERIDIAN,
            int d = day_in_year::SHORT_MONTH, int y = LONG_YEAR) const;

    static int normalize(time_locus &to_fix);
//hmmm: what are rollovers measured in?
  };

  int year_now();  
  clock_time time_now();  
  day_in_year date_now();  
  time_locus now();  
  time_locus greenwich_now();  

  bool set_time(const time_locus &new_time);

} // namespace.

#endif

---