gTime.hpp

/****************************************************************************
 * Name: gTime.hpp
 *
 * Description: gTime y gTimeSpan classes declaration.
 *       This classes implement the method and operators to manage
 *       calculation over dates and timestamps.
 *
 *
 ***************************************************************************/

/***************************************************************************
 *   Copyright (C) 2006 by J. L. Canales                                   *
 *   jlcanales@users.sourceforge.net                                       *
 *                                                                         *
 *   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.,                                       *
 *   51 Franklin Street, Suite 500, Boston, MA  02110-1335, USA.             *
 ***************************************************************************/

// gTimeSpan and gTime
#ifndef _GTIME_HPP_
#define _GTIME_HPP_ 1

#include <time.h>
#include <iostream> // for operator<<(), see below

static const double JDAY_JAN1_00H_1900 = 2415019.5; // Jan 1.0 1900 = Jan 1 1900 00h UTC
static const double JDAY_JAN1_12H_1900 = 2415020.0; // Jan 1.5 1900 = Jan 1 1900 12h UTC
static const double JDAY_JAN1_12H_2000 = 2451545.0; // Jan 1.5 2000 = Jan 1 2000 12h UTC
static const double JDAY_JAN1_00H_1970 = 2440587.5;

static const double OMEGA_E = 1.002737909350795; // earth rotation per sideral day

static const int KSEC_PER_MIN = 60;
static const int KSEC_PER_HR  = 3600;
static const int KSEC_PER_DAY = 86400;
static const int KMIN_PER_HR  = 60;
static const int KMIN_PER_DAY = 1440;
static const int KHR_PER_DAY  = 60;

class gTimeSpan
{
public:
    // Constructors
    gTimeSpan(double timeSpanSrc = 0); // timeSpanSrc is mesured in days and fraction of day
    gTimeSpan(long lDays, int nHours, int nMins, double nSecs);

    gTimeSpan(const gTimeSpan& timeSpanSrc);
    const gTimeSpan& operator=(const gTimeSpan& timeSpanSrc);

    // Equal to time in Julian Days
    const gTimeSpan& operator=(const double& timeSpanSrc)
    {
        m_timeSpan=timeSpanSrc*KSEC_PER_DAY;
        return *this;
    }

    // Attributes
    // extract parts

    long  getDays() const;

    int   getHours() const;

    int   getMinutes() const;

    int   getSeconds() const;

    double getDblSeconds() const;


    double getDblDays() const;
    // Operations

    // TimeSpan Object Math operations
    gTimeSpan operator-(gTimeSpan timeSpan) const;
    gTimeSpan operator+(gTimeSpan timeSpan) const;
    const gTimeSpan& operator+=(gTimeSpan timeSpan);
    const gTimeSpan& operator-=(gTimeSpan timeSpan);
    bool operator==(gTimeSpan timeSpan) const;
    bool operator!=(gTimeSpan timeSpan) const;
    bool operator<(gTimeSpan timeSpan) const;
    bool operator>(gTimeSpan timeSpan) const;
    bool operator<=(gTimeSpan timeSpan) const;
    bool operator>=(gTimeSpan timeSpan) const;

private:
    double m_timeSpan; //time span in julian days

};






class gTime
{
public:

    // Constructors
    gTime(double ai_jDays = 0);
    gTime(int year, double day);
    gTime(int nYear, int nMonth, int nDay, int nHour, int nMin, double nSec);
    gTime(struct tm ai_timestruct);

    // copy constructor
    gTime(const gTime& timeSrc);

    // Time Object setting operations

    // Operation setTime
    void setTime(int year, double day);

    // Operation operator=
    const gTime& operator=(const gTime& timeSrc);

    // Operation operator=
    const gTime& operator=(time_t t);


    // Operation operator=
    const gTime& operator=(double t)
    {
        m_time = t;
        return *this;
    }



    // Time Machine getting operations

    // Operation  getCurrentTime();
    static gTime     getCurrentTime();

    // Operation  getTimeToUTC();
    static gTimeSpan getTimeToUTC();

    // Operation: isLeapYear
    static bool isLeapYear(int ai_year)
    {
        return (ai_year % 4 == 0 && ai_year % 100 != 0) || (ai_year % 400 == 0);
    }


    // Time Object getting operations

    // Operation:  getGmtTm();
    double getGmtTm() const;

    // Operation:  getLocalTm();
    double getLocalTm() const;


    // Time Object Converting operations

    // Operation:  toTime();
    time_t toTime() const;


    void toCalendarDate(int *pYear, int *pMonth , double *pDom) const;

    double toJCenturies() const;

    // Operation:  toThetaGMST();
    double toThetaGMST() const;

    // Operation:  toThetaLMST();
    double toThetaLMST(double longitude) const;


    // Time Object Math operations

    gTimeSpan operator-(gTime time)         const;
    gTime operator- (gTimeSpan timeSpan) const;
    gTime operator+ (gTimeSpan timeSpan) const;
    const gTime& operator+= (gTimeSpan timeSpan);
    const gTime& operator-= (gTimeSpan timeSpan);
    bool operator== (gTime time)         const;
    bool operator!= (gTime time)         const;
    bool operator< (gTime time)         const;
    bool operator> (gTime time)         const;
    bool operator<= (gTime time)         const;
    bool operator>= (gTime time)         const;

private:
    double m_time; //Time in Julian Days

};



inline std::ostream& operator<<(std::ostream& s, gTime& ai_gTime)
{
    int    year, month;
    double Dom;

    ai_gTime.toCalendarDate(&year, &month , &Dom);

    s << "GMT " << year <<" " << month <<":"<<Dom;
    return s;
}

inline std::ostream& operator<<(std::ostream& s, gTimeSpan& ai_gTimeSpan)
{
    s << "D " <<ai_gTimeSpan.getDays()<<" "<<ai_gTimeSpan.getHours()<<":"<<ai_gTimeSpan.getMinutes()<<":"<<ai_gTimeSpan.getSeconds()<<std::endl;
    return s;
}


#endif // _GTIME_HPP_