mn_timespan.hpp

Go to the documentation of this file.

 
#ifndef _MINLIB_b7a90cc_ab5c_11eb_aa97_e9108ec71670_H__
#define _MINLIB_b7a90cc_ab5c_11eb_aa97_e9108ec71670_H__
 
#include "mn_config.hpp"
 
#include <stdint.h>
#include <time.h>
 
#include "mn_algorithm.hpp"
 
 
namespace mn {
 
    class basic_timespan {
    public:
        using time_type = int64_t;
        using int_type= uint64_t;
        using self_type = basic_timespan;
 
        basic_timespan();
 
        basic_timespan(time_type ms);
 
        basic_timespan(struct timeval& val);
 
        basic_timespan(uint16_t days, uint8_t hours, uint8_t minutes, uint8_t seconds, uint16_t microSeconds = 0);
 
        basic_timespan(const self_type& other);
 
 
        uint16_t get_days() const;
 
        uint8_t get_hours() const;
 
        uint8_t get_minutes() const;
 
        uint8_t get_seconds() const;
 
        uint16_t get_milliseconds() const;
 
        int_type get_microseconds() const;
 
 
        int_type get_total_hours() const;
 
        int_type get_total_minutes() const;
 
        int_type get_total_seconds() const;
 
        int_type get_total_milliseconds() const;
 
        int_type get_total_microseconds() const;
 
 
        self_type& operator = (const self_type& timespan);
 
        self_type& operator = (time_type microseconds);
 
        self_type& operator = (struct timeval val);
 
 
        bool operator == (const self_type& ts) const
            { return m_timeSpan == ts.m_timeSpan; }
 
        bool operator == (time_type microSeconds) const
            { return m_timeSpan == microSeconds; }
 
        bool operator != (const self_type& ts) const
            { return m_timeSpan != ts.m_timeSpan; }
 
        bool operator != (time_type microSeconds) const
            { return m_timeSpan != microSeconds; }
 
 
        bool operator >  (const self_type& ts) const
            { return m_timeSpan > ts.m_timeSpan; }
 
        bool operator >  (time_type microSeconds) const
            { return m_timeSpan > microSeconds; }
 
        bool operator >= (const self_type& ts) const
            { return m_timeSpan >= ts.m_timeSpan; }
 
        bool operator >= (time_type microSeconds) const
            { return m_timeSpan >= microSeconds; }
 
        bool operator <  (const self_type& ts) const
            { return m_timeSpan < ts.m_timeSpan; }
 
        bool operator <  (time_type microSeconds) const
            { return m_timeSpan < microSeconds; }
 
        bool operator <= (const self_type& ts) const
            { return m_timeSpan <= ts.m_timeSpan; }
 
        bool operator <= (time_type microSeconds) const
            { return m_timeSpan <= microSeconds; }
 
 
        self_type& operator += (const self_type& other)
            { m_timeSpan += other.m_timeSpan; return *this; }
 
        self_type& operator += (time_type ms)
            { m_timeSpan += ms; return *this; }
 
        self_type& operator -= (const self_type& other)
            { m_timeSpan -= other.m_timeSpan; return *this; }
 
        self_type& operator -= (time_type ms)
            { m_timeSpan -= ms; return *this; }
 
        self_type operator + (const self_type& other) const
            { return self_type(m_timeSpan + other.m_timeSpan); }
 
        self_type operator - (const self_type& other) const
            { return self_type(m_timeSpan - other.m_timeSpan); }
 
        self_type operator + (time_type ms) const
            { return self_type(m_timeSpan + ms); }
 
        self_type operator - (time_type ms) const
            { return self_type(m_timeSpan - ms); }
 
        static basic_timespan now();
    public:
        void swap(self_type& other) {
            mn::swap(m_timeSpan, other.m_timeSpan);
        }
 
        self_type& assign(uint16_t days, uint8_t hours, uint8_t minutes, uint8_t seconds, uint16_t microSeconds);
 
        self_type& assign(struct timeval val);
    public:
        static basic_timespan from_ticks(const unsigned int& ticks);
        time_type to_ticks() const;
    private:
        time_type m_timeSpan;
    };
 
    using timespan_t = basic_timespan;
 
    inline void swap(timespan_t& s1, timespan_t& s2) {
        s1.swap(s2);
    }
}
 
#endif // _MINLIB_b7a90cc_ab5c_11eb_aa97_e9108ec71670_H__