cel_time.h

Go to the documentation of this file.

//----------------------------------------------------------------------------
//
// (C) 2003-2006 Celartem Technology Inc. All rights reserved.
//----------------------------------------------------------------------------

#ifndef _cel_time_h_
#define _cel_time_h_

#include "cel_types.h"
#include "cel_memory.h"
#include "cel_string.h"
#include "cel_exception.h"
#include "cel_datatraits.h"
#include <ctime>

#if CEL_ENV_WINDOWS
struct _FILETIME;
struct _SYSTEMTIME;
#endif

namespace Celartem
{
    class Stream;

    struct Time
    {
        std::time_t t;

        Time(std::time_t _t = 0) : t(_t) {}

        Time(const Time& _time) : t(_time.t) {}

        Time(const String& time) {parseDateString(time);}

        Time(const std::tm *_tm) {*this = mktime(_tm);}

        Time(
            size_t year, size_t month, size_t day,
            size_t hour = 0, size_t minute = 0, size_t seconds = 0,
            bool isUTC = false)
        {
            *this = createTime(year, month, day, hour, minute, seconds, isUTC);
        }

        Time& operator=(std::time_t _t)
        {
            t = _t;
            return *this;
        }

        Time& operator=(const Time& _time)
        {
            t = _time.t;
            return *this;
        }

        Time& operator=(const std::tm *_tm)
        {
            *this = mktime(_tm);
            return *this;
        }

        Time& operator=(const String& time)
        {
            parseDateString(time);
            return *this;
        }

        void gmtime(std::tm *out_tm) const;

        void localtime(std::tm *out_tm) const;

        String strftime(const String& format) const;

        bool operator<(const Time& r) const {return (t < r.t);}

        bool operator<=(const Time& r) const {return (t <= r.t);}

        bool operator>(const Time& r) const {return (t > r.t);}

        bool operator>=(const Time& r) const {return (t >= r.t);}

        bool operator==(const Time& r) const {return (t == r.t);}

        bool operator!=(const Time& r) const {return (t != r.t);}

        ssize_t operator-(const Time& r) const;

        Time operator+(ssize_t diff) const {return Time(t + diff);}

        String ctime() const;

        String getRFC822timeString(bool isLocalTime = true) const;

        static Time getCurrentTime();

        static Time mktime(const std::tm *_tm);

        static Time timelocal(const std::tm *_tm) {return mktime(_tm);}

        static Time timegm(const std::tm *_tm);

        static Time createTime(
            size_t year, size_t month, size_t day,
            size_t hour = 0, size_t minute = 0, size_t seconds = 0,
            bool isUTC = false);
        
        void parseDateString(const String& inDateString);

        void serialize(
            Stream *inStream, size_t inLevel, Endian inEndian) const;

        void deserialize(Stream *inStream, size_t inLevel, Endian inEndian);
        
        String toGMTStr() const;
        
        static Time fromGMTStr(const String& inGMTStr);

#if CEL_ENV_WINDOWS

        Time(const _FILETIME& inFileTime);

        Time(const _SYSTEMTIME& inSystemTime);
        
        Time& operator=(const _FILETIME& inFileTime);
        
        Time& operator=(const _SYSTEMTIME& inSystemTime);
        
        operator _FILETIME() const;
        
        operator _SYSTEMTIME() const;
#endif


    };

    struct TimeSpan
    {
        Time from; //<! The time something starts from.
        Time to;   //<! The time something continues to.

        ssize_t span() const {return from - to;}

        bool intersectsWith(const Time& t) const
        {
            if(from <= t && t < to)
                return true;
            return false;
        }

        bool intersectsWith(const TimeSpan& ts) const
        {
            if(from <= ts.from && ts.from < to)
                return true;
            if(from <= ts.to && ts.to < to)
                return true;
            return false;
        }

        void serialize(
            Stream *inStream, size_t inLevel, Endian inEndian) const;

        void deserialize(
            Stream *inStream, size_t inLevel, Endian inEndian);
    };

    CEL_DEFINE_DATATRAITS(Time, byConstructor, byClassMethods);
    CEL_DEFINE_DATATRAITS(TimeSpan, byConstructor, byClassMethods);
    
    struct TimeUtils
    {
        static u64 getTick();

        static u64 getTicksPerSecond();
    };

    class DebugTimer
    {
    public:
        DebugTimer(const String& label)
        {
            startMilestone(label);
        }
        
        void milestone(const String& label)
        {
            finishMilestone();
            startMilestone(label);
        }
        
        ~DebugTimer()
        {
            finishMilestone();
        }
    
    private:
        String m_label;
        u64 m_tick;
        
        void startMilestone(const String& label);
        void finishMilestone();
    };
    
}  // namespace Celartem

#endif // _cel_time_h_

---

This document is automatically generated using doxygen 1.5.4 at Fri Jun 27 18:21:55 2008.