mn_timestamp.hpp

Go to the documentation of this file.

 
#ifndef _MINLIB_BASIC_TIMESTAMP_H__
#define _MINLIB_BASIC_TIMESTAMP_H__
 
#include "mn_config.hpp"
 
#include "mn_limits.hpp"
#include "mn_timespan.hpp"
 
#define MINILIB_TIMESTAMP_RESELUTION    1000000
 
#define MINILIB_TIMESTAMP_TIME_TYPE     typename basic_timespan::time_type
#define MINILIB_TIMESTAMP_MIN           mn::numeric_limits<MINILIB_TIMESTAMP_TIME_TYPE>::min()
#define MINILIB_TIMESTAMP_MAX           mn::numeric_limits<MINILIB_TIMESTAMP_TIME_TYPE>::max()
 
namespace mn {
    class basic_timestamp {
    public:
        using time_type = MINILIB_TIMESTAMP_TIME_TYPE;
        using self_type = basic_timestamp;
 
        basic_timestamp();
 
        basic_timestamp(time_type tv);
 
        basic_timestamp(const self_type& other);
 
        void update();
        void swap(self_type& time);
 
        static self_type from_epoch(const mn::time_t t);
 
        static self_type from_utc(const time_type val);
 
        mn::time_t get_epoch() const
            { return mn::time_t(m_time / MINILIB_TIMESTAMP_RESELUTION); }
 
        time_type get_utc() const
            { return m_time * 10 + (time_type(0x01b21dd2) << 32) + 0x13814000; }
 
        time_type get_microseconds() const
            { return m_time; }
 
        time_type get_elapsed() const
            { self_type now; return now - *this; }
 
 
        bool is_elapsed(time_type interval) const
            { return get_elapsed() >= interval; }
 
        bool operator == (const self_type& ts) const
            { return m_time == ts.m_time; }
 
        bool operator != (const self_type& ts) const
            { return m_time != ts.m_time; }
 
        bool operator >= (const self_type& ts) const
            { return m_time >= ts.m_time; }
 
        bool operator <= (const self_type& ts) const
            { return m_time <= ts.m_time; }
 
        bool operator <  (const self_type& ts) const
            { return m_time < ts.m_time; }
 
        bool operator >  (const self_type& ts) const
            { return m_time > ts.m_time; }
 
        time_type operator -  (const self_type& ts) const
            { return m_time - ts.m_time; }
 
        time_type operator +  (const self_type& ts) const
            { return m_time + ts.m_time; }
 
        self_type  operator +  (time_type d) const
            { return self_type(m_time + d); }
 
        self_type  operator -  (time_type d) const
            { return self_type(m_time - d); }
 
        self_type& operator += (time_type d)
            { m_time += d; return *this; }
 
        self_type& operator -= (time_type d)
            { m_time -= d; return *this; }
 
        self_type  operator +  (const basic_timespan& span) const {
            return self_type(m_time + span.get_total_microseconds());
        }
        self_type  operator -  (const basic_timespan& span) const {
            return self_type(m_time - span.get_total_microseconds());
        }
        self_type& operator += (const basic_timespan& span) {
            m_time += span.get_total_microseconds(); return *this;
        }
        self_type& operator -= (const basic_timespan& span) {
            m_time -= span.get_total_microseconds(); return *this;
        }
        self_type& operator = (const self_type& other) {
            m_time = other.m_time; return *this;
        }
        self_type& operator = (time_type tv) {
            m_time = tv; return *this;
        }
 
    private:
        time_type m_time;
    };
 
    void swap(basic_timestamp a, basic_timestamp b) {
        a.swap(b);
    }
 
    using timestamp_t = basic_timestamp;
}
#endif // _MINLIB_BASIC_TIMESTAMP_H__