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 <basis/astring.h>
#include <basis/byte_array.h>
#include <basis/contracts.h>
//#include <basis/definitions.h>
#include <structures/object_packers.h>
 
 
 
namespace timely {
 
  typedef basis::signed_long time_number;
 
  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 time_number days_in_month[12];
  extern const time_number leap_days_in_month[12];
 
  extern const time_number julian_days_in_month[12];
  extern const time_number julian_leap_days_in_month[12];
 
  const time_number SECONDS_IN_MINUTE = 60;  
  const time_number MINUTES_IN_HOUR = 60;  
  const time_number SECONDS_IN_HOUR = 3600;  
  const time_number HOURS_IN_DAY = 24;  
  const time_number MINUTES_IN_DAY = 1440;  
  const time_number SECONDS_IN_DAY = 86400;  
  const time_number DAYS_IN_YEAR = 365;  
  const time_number 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 virtual basis::packable
  {
  public:
    time_number hour;  
    time_number minute;  
    time_number second;  
    time_number millisecond;  
    time_number microsecond;  
 
    clock_time(time_number h = 0, time_number m = 0, time_number s = 0, time_number ms = 0, time_number us = 0)
             : hour(h), minute(m), second(s), millisecond(ms),
               microsecond(us) {}
    ~clock_time() {}
 
    int packed_size() const { return 5 * structures::PACKED_SIZE_INT32; }
 
    virtual void pack(basis::byte_array &packed_form) const;
    virtual bool unpack(basis::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  
    };
 
    basis::astring text_form(int how = MERIDIAN) const;
 
    void text_form(basis::astring &to_stuff, int how = MERIDIAN) const;
 
    static time_number 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 virtual basis::packable
  {
  public:
    months month;  
    time_number day_in_month;  
    days day_of_week;  
    time_number day_of_year;  
 
    int packed_size() const { return 4 * structures::PACKED_SIZE_INT64; }
 
    day_in_year(months m = JANUARY, time_number dim = 1, days dow = SUNDAY,
            time_number day_o_year = 1) : month(m), day_in_month(dim),
            day_of_week(dow), day_of_year(day_o_year) {}
 
    virtual void pack(basis::byte_array &packed_form) const;
    virtual bool unpack(basis::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     
    };
 
    basis::astring text_form(int how = SHORT_MONTH) const;
    void text_form(basis::astring &to_stuff, int how = SHORT_MONTH) const;
 
    static time_number normalize(day_in_year &to_fix, bool leap_year = false);
 
  };
 
 
  class time_locus : public clock_time, public day_in_year,
      public virtual basis::hoople_standard
  {
  public:
    time_number year;  
 
    time_locus() : clock_time(), day_in_year(), year() {}
 
    DEFINE_CLASS_NAME("time_locus");
 
    time_locus(const clock_time &ct, const day_in_year &ytd, time_number year_in)
            : clock_time(ct), day_in_year(ytd), year(year_in) {}
 
    int packed_size() const { return clock_time::packed_size()
            + day_in_year::packed_size() + structures::PACKED_SIZE_INT32; }
 
    virtual void pack(basis::byte_array &packed_form) const;
    virtual bool unpack(basis::byte_array &packed_form);
 
    // these implement the orderable and equalizable interfaces.
    virtual bool equal_to(const basis::equalizable &s2) const;
    virtual bool less_than(const basis::orderable &s2) const;
//old    bool operator < (const time_locus &to_compare) const;
//old    bool operator == (const time_locus &to_compare) const;
 
    enum locus_formats {
      LONG_YEAR = 0x1,  
      SHORT_YEAR = 0x2  
    };
 
    // fulfills obligation for text_formable.
    virtual void text_form(basis::base_string &state_fill) const {
      state_fill.assign(text_form_long(clock_time::MERIDIAN, day_in_year::SHORT_MONTH, LONG_YEAR));
    }
 
    basis::astring text_form_long(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_long(basis::astring &to_stuff, int t = clock_time::MERIDIAN,
            int d = day_in_year::SHORT_MONTH, int y = LONG_YEAR) const;
 
    static time_number normalize(time_locus &to_fix);
//hmmm: what are rollovers measured in?
  };
 
  time_number year_now();  
  clock_time time_now();  
  day_in_year date_now();  
  time_locus now();  
  time_locus greenwich_now();  
} // namespace.
 
#endif