---

Date.h

Go to the documentation of this file.

/* SimData: Data Infrastructure for Simulations
 * Copyright (C) 2002, 2003 Mark Rose <tm2@stm.lbl.gov>
 * 
 * This file is part of SimData.
 * 
 * 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 program 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 General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */


#ifndef __SIMDATA_DATE_H__
#define __SIMDATA_DATE_H__

#include <SimData/Archive.h>
#include <SimData/Exception.h>
#include <SimData/BaseType.h>



NAMESPACE_SIMDATA


#define SIMDATA_F1p0_60p0      0.016666666666666667L
#define SIMDATA_F1p0_24p0      0.041666666666666667L
#define SIMDATA_F1p0_36525p0   0.000027378507871321L
#define SIMDATA_F1p0_86400p0   0.000011574074074074L


typedef double radian_t;
typedef double degree_t;


// 'fast' timing routines (1-2 msec accuracy)

typedef double timing_t;

void tstart(void);

void tend(void);

double tval();

timing_t get_realtime();


// end of timing routines



// TODO: please merge these with global type definitions
typedef int sint32;
typedef short sint16;
typedef unsigned char uint08;


SIMDATA_EXCEPTION(InvalidDate);

class SIMDATA_EXPORT Date {
public:
        typedef sint32 julian_t;
        typedef uint08 day_t;
        typedef uint08 weekday_t;
        typedef uint08 month_t;
        typedef sint16 year_t;

        typedef enum {
                MONDAY       = 1,
                TUESDAY      = 2,
                WEDNESDAY    = 3,
                THURSDAY     = 4,
                FRIDAY       = 5,
                SATURDAY     = 6,
                SUNDAY       = 7
        } WEEKDAY;

        typedef enum {
                JANUARY   = 1,
                FEBRUARY  = 2,
                MARCH     = 3,
                APRIL     = 4,
                MAY       = 5,
                JUNE      = 6,
                JULY      = 7,
                AUGUST    = 8,
                SEPTEMBER = 9,
                OCTOBER   = 10,
                NOVEMBER  = 11,
                DECEMBER  = 12
        } MONTH;

        Date() {
                m_julian = 0;
                _updateYMD();
        }

        Date(year_t year, month_t month, day_t day);
        
        Date(julian_t julian) {
                m_julian = julian;
                _updateYMD();
        }

        Date(const Date &d) {
                *this = d;
        }

#ifndef SWIG

        const Date &operator=(const Date &d) {
                m_year = d.m_year;
                m_month = d.m_month;
                m_day = d.m_day;
                m_julian = d.m_julian;
                return *this;
        }
#endif // SWIG

        static bool validYMD(year_t year, month_t month, day_t day) {
                if (month < 1 || month > 12 || day < 1) return false;
                return (day <= (isLeap(year) ? 
                           days_in_months[1][month] : days_in_months[0][month]));
        }

        bool isLeap() const {
                return isLeap(m_year);
        }

        static bool isLeap(year_t year) {
                return ( (((year % 4) == 0) && ((year % 100) != 0)) || (year % 400) == 0 );
        }
        
        weekday_t getWeekday() const {
                return ((m_julian) % 7) + 1;
        }

        month_t getMonth() const {
                return m_month;
        }
        
        month_t getDay() const {
                return m_day;
        }
        
        year_t getYear() const {
                return m_year;
        }

        julian_t getJulian() const {
                return m_julian;
        }

        const char *getMonthName() const;

        const char *getMonthShortName() const;
        
        const char *getWeekdayName() const;
        
        const char *getWeekdayShortName() const;

        void setJulian(julian_t j) {
                *this = Date(j);
        }

        int getDayOfYear() const {
                int index;
                index = isLeap() ? 1 : 0;
                return (days_in_year[index][m_month] + m_day);
        }

        int getMondayWeekOfYear() const;

        int getSundayWeekOfYear() const;
        
        bool isFirstOfMonth() const {
                return (m_day == 1);
        }

        bool isLastOfMonth() const {
                int index = isLeap() ? 1 : 0;
                return m_day == days_in_months[index][m_month];
        }
        
        void addDays(int ndays) {
                m_julian += ndays;
                _updateYMD();
        }
        
        void subtractDays(int ndays) {
                m_julian -= ndays;
                _updateYMD();
        }

        void addMonths(int nmonths);
        
        void subtractMonths(int nmonths);

        void addYears(int nyears);

        void subtractYears(int nyears);

        static int getDaysInMonth(month_t month, year_t year);

        static int getWeeksInYear(year_t year);
        
        static int getSundayWeeksInYear(year_t year);

        static int compare(const Date &a, const Date &b);
        
        virtual int compare(const Date &other) const { 
                return compare(*this, other); 
        }

        void convert(struct tm *tm) const;

        std::string formatString(const char *format) const;

        virtual std::string asString() const {
                return formatString("%Y/%m/%d");
        }

        virtual std::string typeString() const { return "type::Date"; }
        
private:
        static const day_t days_in_months[2][13];
        static const int days_in_year[2][14];

        julian_t m_julian;
        day_t m_day;
        month_t m_month;
        year_t m_year;

        void _updateJulian();
        void _updateYMD();

        bool validYMD() const {
                return validYMD(m_year, m_month, m_day);
        }
};



class SIMDATA_EXPORT Zulu {

public:
        typedef double time_t;

        Zulu() {
                m_time = 0;
                m_tz = 0;
        }
        
        Zulu(int hour, int minute, time_t second, int tz=0) {
                m_time = hour*3600.0 + minute*60.0 + second;
                m_tz = tz;
        }
        
        Zulu(time_t second, int tz=0) {
                m_time = second;
                m_tz = tz;
        }
        
        Zulu(const Zulu &z) {
                *this = z;
        }
        
#ifndef SWIG

        const Zulu &operator=(const Zulu &z) {
                m_time = z.m_time;
                m_tz = z.m_tz;
                return *this;
        }
#endif // SWIG

        void setTZ(int tz) {
                m_tz = tz;
        }

        int getTZ() const {
                return m_tz;
        }
        
        int reduce();
        
        time_t getTime(bool local=false) const { 
                return m_time + (local ? (m_tz * 3600.0) : 0.0);
        }
        
        bool overflow() const {
                return m_time >= 86400.0f;
        }
        
        int getHour(bool local=false) const {
                int adjust = local ? m_tz : 0;
                return ((((int)m_time) / 3600) + adjust) % 24;
        }
        
        int getMinute() const {
                return (((int)m_time) / 60) % 60;
        }
        
        int getSecond() const {
                return ((int)m_time) % 60;
        }

        int rollover() {
                int days = 0;
                if (overflow()) {
                        days = (int) (m_time * 0.00001157407407407407);
                        if (m_time < 0.0) days--;
                        m_time -= days * 86400.0f;
                }
                return days;
        }
        
        int addTime(time_t dt) {
                m_time += dt;
                return rollover();
        }
        
        int setTime(time_t t, bool local=false) {
                if (local) t -= m_tz * 3600.0;
                m_time = t;
                return rollover();
        }

        void convert(struct tm *tm, bool local=false) const;
        
        std::string formatString(const char *format, bool local=false) const;
        
        
        virtual std::string asString() const {
                return formatString("%H:%M:%Sz");
        }

        virtual std::string typeString() const { return "type::Zulu"; }

private:
        time_t m_time;
        int m_tz;
};



class SIMDATA_EXPORT DateZulu: public Date, public Zulu {


public:

        DateZulu(): Date(), Zulu() {}

        DateZulu(year_t year, month_t month, day_t day, int hour, int minute, time_t second):
                Date(year, month, day),
                Zulu(hour, minute, second) {
                addDays(reduce());
        }

        DateZulu(julian_t julian, int hour, int minute, time_t second):
                Date(julian),
                Zulu(hour, minute, second) {
                addDays(reduce());
        }

        DateZulu(const DateZulu &dz): Date(dz), Zulu(dz) { }

#ifndef SWIG

        const DateZulu &operator=(const DateZulu &dz) {
                Date::operator=(dz);
                Zulu::operator=(dz);
                return *this;
        }
#endif // SWIG
                
        
        void convert(struct tm *tm, bool local=false) const;

        std::string formatString(const char *format, bool local=false) const;

        virtual std::string asString() const {
                return formatString("%Y/%m/%d %H:%M:%Sz");
        }

        virtual std::string typeString() const { return "type::DateZulu"; }
        
        int addTime(time_t dt) {
                int days = Zulu::addTime(dt);
                addDays(days);
                return days;
        }

        int setTime(time_t t) {
                int days = Zulu::setTime(t);
                addDays(days);
                return days;
        }

        double getJulianDate() const {
                double j = getJulian();
                double t = getTime() * SIMDATA_F1p0_86400p0 + 0.5;
                return j + t;
        }

        double getAccurateMST(radian_t longitude=0.0L) const;

        double getMST(radian_t longitude=0.0L) const;

};



typedef DateZulu::time_t SimTime;


class SIMDATA_EXPORT SimDate: public DateZulu, public BaseType {

        SimTime reference;
        SimTime pause_time;
        SimTime last_update;
        bool paused;

public:
        
        SimDate(): DateZulu(), BaseType() {
                paused = false;
                last_update = get_realtime();
                setReferenceTime(getTime());
        }

        SimDate(year_t year, month_t month, day_t day, int hour, int minute, time_t second):
                DateZulu(year, month, day, hour, minute, second),
                BaseType() {
                paused = false;
                last_update = get_realtime();
                setReferenceTime(getTime());
        }
                
        SimDate(julian_t julian, int hour, int minute, time_t second):
                DateZulu(julian, hour, minute, second),
                BaseType() {
                paused = false;
                last_update = get_realtime();
                setReferenceTime(getTime());
        }
                
        SimDate(const SimDate &d): DateZulu(d), BaseType(d) {
                paused = false;
                last_update = get_realtime();
                setReferenceTime(getTime());
        }
        
#ifndef SWIG

        const SimDate &operator=(const SimDate &d);
#endif // SWIG  

        virtual std::string asString() const {
                return formatString("%Y/%m/%d %H:%M:%Sz");
        }

        virtual std::string typeString() const { return "type::SimDate"; }
        
        static SimTime interval(SimTime a, SimTime b) {
                a -= b;
                if (a < 0.0) return a + 86400.0;
                return a;
        }

        static SimTime getSystemTime() {
                return get_realtime();
        }

        double update();

        virtual int compare(const SimDate &other) const { 
                int date_comp = Date::compare(*this, other); 
                if (date_comp != 0) return date_comp;
                if (getTime() > other.getTime()) return 1;
                if (getTime() < other.getTime()) return -1;
                return 0;
        }

        void setReferenceTime(SimTime target) {
                reference = get_realtime() - target;
        }

        void pause() {
                paused = true;
                pause_time = get_realtime();
        }

        void unpause() {
                paused = false;
                setReferenceTime(pause_time - reference);
        }

        bool isPaused() const {
                return paused;
        }

        int addTime(time_t dt) {
                int days = DateZulu::addTime(dt);
                if (days != 0) {
                        reference += days * 86400.0;
                }
                return days;
        }

        int setTime(time_t t) {
                int days = DateZulu::setTime(t);
                if (days != 0) {
                        reference += days * 86400.0;
                }
                return days;
        }

        virtual void serialize(Archive&);

        virtual void parseXML(const char* cdata);
        
}; 

NAMESPACE_SIMDATA_END

#endif // __SIMDATA_DATE_H__

---

SimData version pre-0.4.0. For more information on SimData, visit the SimData Homepage. Generated on Tue Oct 14 12:06:38 2003, using Doxygen 1.2.18.