Time.h

Go to the documentation of this file.

/* \todo Finish implementing the rest of the time representatins.
*/

#ifndef __SSF_TIME_H__
#define __SSF_TIME_H__
#include "MathUtils.h"
#include <time.h>
#include <sys/time.h>
#include <math.h>
#include <iostream.h>
#include <iomanip.h>
namespace O_SESSAME {

typedef double ssfSeconds;      /*< Simulation representation of seconds \ingroup Utilities*/
typedef double ssfJulianDate;   /*< Simulation representation of Julian Dates \ingroup Utilities */

#define TIME_PRECISION 15       /*< Precision of time output when outputting seconds */

class ssfTime;

class ssfTime
{
public:
    ssfTime()                           
        {Set(ssfSeconds(0)); SetEpoch(ssfSeconds(0));};
    ssfTime(tm _Time)                   
        {Set(_Time);};
    ssfTime(timeval _Time)                      
        {Set(_Time);};
    ssfTime(ssfSeconds _Time)           
        {Set(_Time);};
    
    ssfTime(int year, int month, int day, int hour, int minute, double seconds)         
        {Set(year, month, day, hour, minute, seconds);};
    
    void Set(tm _newTime)               
        {Set(static_cast<ssfSeconds>(timegm(&_newTime)));};
    
    void Set(timeval _Time)                     
        {Set(_Time.tv_sec + _Time.tv_usec/1000000.);};
        
    void Set(ssfSeconds _newTime)       
        {m_StoredTime = _newTime;};
    
    void SetJulianDate(ssfJulianDate _newJD);
        
    void SetEpochJulianDate(ssfJulianDate _newJD);
    
    void Set(int year, int month, int day, int hour, int minute, double seconds);
        
    void SetTimeAfterEpoch(ssfSeconds _timeAfter)       
        {Set(m_EpochTime + _timeAfter);}; 
    
    void SetEpoch(ssfSeconds _newEpochTime)     
        {m_EpochTime = _newEpochTime;};
    
    void SetEpoch(tm _newEpochTime)     
        {SetEpoch(static_cast<ssfSeconds>(timegm(&_newEpochTime)));};
        
    void SetEpoch(const timeval &_Time)                         
        {SetEpoch(_Time.tv_sec + _Time.tv_usec/1000000.);};
    
    void SetEpoch(int year, int month, int day, int hour, int minute, double seconds);
    
    ssfSeconds GetSeconds()  const      
        {return m_StoredTime;};

    tm GetDateTime()  const     
        {time_t t = static_cast<time_t>(floor(m_StoredTime));return *gmtime(&t);};
    
    tm GetEpochDateTime()  const        
        {time_t t = static_cast<time_t>(floor(m_EpochTime));return *gmtime(&t);};
        
    ssfSeconds GetEpoch() const 
        {return m_EpochTime;};
        
        
    ssfJulianDate GetJulianDate() const;
    
    ssfJulianDate GetEpochJulianDate() const;
    
        
    Angle GetGreenwichMeanSiderealTime() const;
    
    Angle GetEpochGreenwichMeanSiderealTime() const;

//    tm GetEpoch() const 
  //      {return *gmtime(&m_EpochTime);};
    
    ssfSeconds SecondsSinceEpoch() const
        {return static_cast<ssfSeconds>(m_StoredTime - m_EpochTime);};
    
    ssfTime operator+ (const int& rhsSeconds) const
        {return operator+(static_cast<ssfSeconds>(rhsSeconds));};
    
    ssfTime operator+= (const int& rhsSeconds)
        {return operator+=(static_cast<ssfSeconds>(rhsSeconds));};       

    ssfTime operator+ (const long& rhsSeconds) const
        {return operator+(static_cast<ssfSeconds>(rhsSeconds));};

    ssfTime operator+= (const long& rhsSeconds)
        {return operator+=(static_cast<ssfSeconds>(rhsSeconds));}; 
    
    ssfTime operator+ (const ssfSeconds& rhsSeconds) const
        {return ssfTime(m_StoredTime + rhsSeconds);};
    
    ssfTime operator+= (const ssfSeconds& rhsSeconds)
        {m_StoredTime += rhsSeconds; return *this;}; 
        
    ssfSeconds operator- (const ssfTime &rhs) const
        {return (m_StoredTime - rhs.GetSeconds());};
        
    bool operator> (const ssfTime &rhs) const
        {return (m_StoredTime > rhs.GetSeconds());};
        
    bool operator>= (const ssfTime &rhs) const
        {return (m_StoredTime >= rhs.GetSeconds());};

    bool operator< (const ssfTime &rhs) const
        {return (m_StoredTime < rhs.GetSeconds());};
        
    bool operator<= (const ssfTime &rhs) const
        {return (m_StoredTime <= rhs.GetSeconds());};
                
    bool operator== (const ssfTime &rhs) const
        {return (m_StoredTime == rhs.GetSeconds());};
   
    bool operator!= (const ssfTime &rhs) const
        {return (m_StoredTime != rhs.GetSeconds());};
                
    friend ostream & operator << (ostream& s, ssfTime& t);
private:
    ssfSeconds m_StoredTime; 
    ssfSeconds m_EpochTime;  
};

    static const ssfTime c_GreenwichSiderealEpochTime = ssfTime(1970,1,1,0,0,0);
    static const Angle c_GreenwichSiderealTimeAtEpoch = 1.74933340; 
    
inline ssfSeconds Now()                 
        {timeval tv; gettimeofday(&tv, NULL); return (tv.tv_sec + tv.tv_usec/1000000.);}
       // {return time((time_t *)0);}; 
        

static ssfTime tickTime(-1); /*< global variable used to store the initial tick() time */
static ssfTime tockTime(-1); /*< global variable used to store the ending tock() time */

inline void tick()
{
    tickTime.Set(Now());
    return;
}
inline ssfSeconds tock()
{
    if(tickTime.GetSeconds() > -1)
    {
        tockTime.Set(Now());
        return tockTime-tickTime;
    }
    else
        return -1;
}

void DayofYear2YMD(int _dayOfYear, int _year, int &_month, int &_day);

} // close namespace O_SESSAME

#endif 

// Do not change the comments below - they will be added automatically by CVS
/*****************************************************************************
*       $Log: Time.h,v $
*       Revision 1.13  2003/06/11 14:22:34  nilspace
*       Added comments to GetDateTime() and GetEpochDateTime()
*       
*       Revision 1.12  2003/06/10 01:11:46  nilspace
*       Fixed Time to build correctly (changed Greenwich epoch time to object instead of pointer)
*       
*       Revision 1.11  2003/06/09 19:41:30  nilspace
*       Added SetEpoch(year,month,day,hour,minute,second)
*       
*       Revision 1.10  2003/06/06 00:34:47  nilspace
*       ?
*       
*       Revision 1.9  2003/05/21 03:57:52  nilspace
*       Added GetEpochJulianDate and comments to JulianDate conversion function.
*       
*       Revision 1.8  2003/05/19 21:19:49  nilspace
*       Made calls to overloaded Set() and SetEpoch() functions recursive calls to Set(ssfSeconds) and SetEpoch(ssfSeconds)
*       
*       Revision 1.7  2003/05/19 19:21:37  nilspace
*       Added #include<sys/time.h>
*       
*       Revision 1.6  2003/05/16 14:01:24  nilspace
*       Called gettimeofday(timeval*) to have Now(), and tick/tock return seconds with subsecond decimal parts.
*       
*       Revision 1.5  2003/05/09 23:44:29  nilspace
*       Added operator!=()
*       
*       Revision 1.4  2003/04/30 16:32:48  nilspace
*       Added operator== to ssfTime
*       
*       Revision 1.3  2003/04/27 22:04:34  nilspace
*       Created the namespace O_SESSAME.
*       
*       Revision 1.2  2003/04/25 13:45:56  nilspace
*       const'd Get() functions.
*       
*       Revision 1.1  2003/04/23 14:14:45  nilspace
*       New simulation time.
*       
*
******************************************************************************/

---