CascadeTime.h

Go to the documentation of this file.

//
// CascadeTime.h - header file for class CascadeTime
//
// Copyright (c) 2002, Roku, LLC.  All rights reserved.
//

#ifndef _ROKU_INCLUDE_CASCADE_UTIL_CASCADETIME_H
#define _ROKU_INCLUDE_CASCADE_UTIL_CASCADETIME_H

#include <cascade/CascadeObject.h>
#include <cascade/util/CascadeString.h>

class CascadeTime : public CascadeObject
{
#ifndef DOXY_SKIP
public:
    struct DateStruct;
#endif

public:
        CascadeTime();
        CascadeTime(const CascadeTime & that);
        CascadeTime(const DateStruct & dateStruct);
        virtual ~CascadeTime();
        
public:
    struct TimeBase
    {
    public:
        u64 m_nUptimeNanoseconds;
        u64 m_nGMTNanosecondOffsetFrom1970;
    };
    
    struct DateStruct
    {
    public:
        u16 m_nYear;
        u16 m_nMonth;
        u16 m_nDay;
        u16 m_nHour;
        u16 m_nMinute;
        u16 m_nSecond;
        u16 m_nMilliseconds;
        u16 m_nWeekday;
    };
    
    struct TimeZone
    {
    public:
        const char * m_pZoneID;
        const char * m_pZoneData;
        const char * m_pAbbreviationSTD;
        const char * m_pAbbreviationDST;
        const char * m_pNameSTD;
        const char * m_pNameDST;
        const char * m_pNameGeneric;
        const char * m_pOlsonReferent;
        const char * m_pDescription;
    };
    
public:
    static u64 GetUptimeMilliseconds();
        // returns the number of milliseconds elapsed since system boot
    static u64 GetUptimeNanoseconds();
        // returns the number of nanoseconds elapsed since system boot
        
    static void GetSystemClockTimeBase(TimeBase & timeBaseToSet);
        // This is the time base the system clock is based on.
        // It tells you what the uptime was the last time the system clock
        // was set, and what the GMT was the last time the system clock was set
        // All time functions are based on this system clock time base.
        // NOTE: This time base doesn't actually tell you 'when' the system clock
        // what set, but rather the timebase (GMT + uptime) used to set the system clock.
    static bool SetSystemClockTimeBase(const TimeBase & timeBase);
        // Sets the system clock time base
    static void GetPresentTimeBase(TimeBase & timeBaseToSet);
        // sets timeBaseToSet with a time base containing the current uptime and
        // the current GMT calculated using the current uptime and the system clock time base
    static bool SetSystemTimeGMT(const u64 & nGMTNanosecondOffsetFrom1970);
        // makes a timebase with the current uptime and this GMT value passed in and
        // sets the system clock time base with it
    static void GetSystemTimeZoneID(CascadeString & timeZoneIDToSet);
    static bool SetSystemTimeZoneID(const char * pTimeZoneID);
    static bool GetTimeZoneFromID(const char * pTimeZoneID, TimeZone & timeZoneToSet);
    typedef bool (TimeZoneEnumProc)(const TimeZone & timeZone, void * pClientData);
    static bool EnumerateTimeZones(TimeZoneEnumProc * pEnumProc, void * pClientData);

protected:
    u64 m_nNanoseconds;
    
public:
    void GetTimeGMT();
    bool GetTimeLocal(const char * pTimeZoneID = NULL);
        
    bool GMT2Local(const char * pTimeZoneID = NULL);
    bool Local2GMT(const char * pTimeZoneID = NULL);

    void GetDateStruct(DateStruct & dateStructToSet) const;
    bool SetDateStruct(const DateStruct & dateStruct);
    
    bool IsDaylightSavingsTime(const char * pTimeZoneID = NULL) const;
        // this must represent a local time in the time zone represented
        // by pTimeZoneID
    
    inline u64  GetSeconds() const                         { return (m_nNanoseconds / (u64)1000000000); }
    inline u64  GetMilliseconds() const                    { return (m_nNanoseconds / (u64)1000000); }
    inline u64  GetMicroseconds() const                    { return (m_nNanoseconds / (u64)1000); }
    inline u64  GetNanoseconds() const                     { return m_nNanoseconds; }
    inline void SetSeconds(u64 nSeconds)                   { SetNanoseconds(nSeconds * (u64)1000000000); }
    inline void SetMilliseconds(u64 nMilliseconds)         { SetNanoseconds(nMilliseconds * (u64)1000000); }
    inline void SetMicroseconds(u64 nMicroseconds)         { SetNanoseconds(nMicroseconds * (u64)1000); }
    inline void SetNanoseconds(u64 nNanoseconds)           { m_nNanoseconds = nNanoseconds; }
    inline void AddSeconds(u64 nSeconds)                   { AddNanoseconds(nSeconds * (u64)1000000000); }
    inline void AddMilliseconds(u64 nMilliseconds)         { AddNanoseconds(nMilliseconds * (u64)1000000); }
    inline void AddMicroseconds(u64 nMicroseconds)         { AddNanoseconds(nMicroseconds * (u64)1000); }
    inline void AddNanoseconds(u64 nNanoSeconds)           { m_nNanoseconds += nNanoSeconds; }
    inline void SubtractSeconds(u64 nSeconds)              { SubtractNanoseconds(nSeconds * (u64)1000000000); }
    inline void SubtractMilliseconds(u64 nMilliseconds)    { SubtractNanoseconds(nMilliseconds * (u64)1000000); }
    inline void SubtractMicroseconds(u64 nMicroseconds)    { SubtractNanoseconds(nMicroseconds * (u64)1000); }
    inline void SubtractNanoseconds(u64 nNanoseconds)      { if (nNanoseconds <= m_nNanoseconds) m_nNanoseconds -= nNanoseconds; else m_nNanoseconds = 0; }
    inline bool operator < (const CascadeTime & that) const { return m_nNanoseconds < that.m_nNanoseconds; }
    inline bool operator > (const CascadeTime & that) const { return m_nNanoseconds > that.m_nNanoseconds; }
    inline bool operator <= (const CascadeTime & that) const { return m_nNanoseconds <= that.m_nNanoseconds; }
    inline bool operator >= (const CascadeTime & that) const { return m_nNanoseconds >= that.m_nNanoseconds; }
    inline bool operator == (const CascadeTime & that) const { return m_nNanoseconds == that.m_nNanoseconds; }
};

#endif // #ifndef _ROKU_INCLUDE_CASCADE_CASCADETIME_H

//  LOG
//  20-Dec-02   dwoodward       created
//  20-Jan-03   dwoodward       1.0 STATUS: about 50% complete - needs functions
//                          and operators
//  08-Mar-04   dwoodward   will I ever implement this class? Enquiring minds want to know.
//                          added GetUptimeMilliseconds() and GetUptimeNanoseconds()
//  27-Mar-05   dwoodward   changed GetUptimeMilliseconds to return a u64
//  18-May-05   dwoodward   enquiring minds should now be satisfied
//  01-Jun-05   dwoodward   updated struct TimeZone

---