TimeBase.hxx

Go to the documentation of this file.

 
#ifndef _UTILS_TIMEBASE_HXX_
#define _UTILS_TIMEBASE_HXX_
 
#include <time.h>
#include "os/OS.hxx"
 
class TimeBase : protected Atomic
{
public:
    TimeBase()
        : started_(false)
    { }
 
    void sync(const TimeBase &other)
    {
        timestamp_ = other.timestamp_;
        seconds_ = other.seconds_;
        rate_ = other.rate_;
        started_ = other.started_;
    }
 
    std::pair<time_t, int16_t> time_and_rate_quarters()
    {
        AtomicHolder h(this);
        return std::make_pair(time(), rate_);
    }
 
    time_t compare_realtime(time_t t1, time_t t2)
    {
        int rate = rate_;
        if (rate == 0)
        {
            // avoid divid by zero error
            rate = 4;
        }
        return ((t1 - t2) * 4) / rate;
    }
 
    time_t time()
    {
        AtomicHolder h(this);
        if (started_)
        {
            long long elapsed = OSTime::get_monotonic() - timestamp_;
            elapsed = ((elapsed * std::abs(rate_)) + 2) / 4;
 
            time_t diff = (time_t)NSEC_TO_SEC_ROUNDED(elapsed);
            return (rate_ < 0) ? seconds_ - diff : seconds_ + diff;
        }
        else
        {
            // clock is stopped, time is not progressing
            return seconds_;
        }
    }
 
    struct tm *gmtime_r(struct tm *result)
    {
        time_t now = time();
        return ::gmtime_r(&now, result);
    }
 
    int date(int *month, int *day)
    {
        struct tm tm;
        if (gmtime_r(&tm) == nullptr)
        {
            return -1;
        }
        *month = tm.tm_mon + 1;
        *day = tm.tm_mday;
        return 0;
    }
 
    int day_of_week()
    {
        struct tm tm;
        if (gmtime_r(&tm) == nullptr)
        {
            return -1;
        }
        return tm.tm_wday;
    }
 
    int day_of_year()
    {
        struct tm tm;
        if (gmtime_r(&tm) == nullptr)
        {
            return -1;
        }
        return tm.tm_yday;
    }
 
    int year()
    {
        struct tm tm;
        if (gmtime_r(&tm) == nullptr)
        {
            return -1;
        }
        return tm.tm_year + 1900;
    }
 
    int16_t get_rate_quarters()
    {
        return rate_;
    }
 
    bool is_running()
    {
        AtomicHolder h(this);
        return rate_ != 0 && started_;
    }
 
    bool is_started()
    {
        return started_;
    }
 
    bool fast_sec_to_real_nsec_period(
        int16_t rate, time_t fast_sec, long long *real_nsec)
    {
        if (rate != 0 && rate >= -2048 && rate <= 2047)
        {
            *real_nsec =
                ((SEC_TO_NSEC(std::abs(fast_sec)) * 4) + (std::abs(rate) / 2)) /
                rate;
            if (fast_sec < 0)
            {
                *real_nsec = -(*real_nsec);
            }
            return true;
        }
        else
        {
            return false;
        }
    }
 
    bool real_nsec_to_fast_sec_period(
        int16_t rate, long long real_nsec, time_t *fast_sec)
    {
        if (rate != 0 && rate >= -2048 && rate <= 2047)
        {
            *fast_sec = (std::abs(NSEC_TO_SEC(real_nsec * rate)) + 2) / 4;
            if ((real_nsec < 0 && rate > 0) || (real_nsec >= 0 && rate < 0))
            {
                *fast_sec = -(*fast_sec);
            }
            return true;
        }
        else
        {
            return false;
        }
    }
 
    bool real_nsec_until_fast_time_abs(time_t fast_sec, long long *real_nsec)
    {
        if (fast_sec_to_real_nsec_period_abs(fast_sec - seconds_, real_nsec))
        {
            *real_nsec += timestamp_;
            long long monotonic = OSTime::get_monotonic();
            *real_nsec -= monotonic;
            return true;
        }
        else
        {
            return false;
        }
    }
 
    bool fast_sec_to_real_nsec_period_abs(time_t fast_sec, long long *real_nsec)
    {
        if (fast_sec_to_real_nsec_period(rate_, fast_sec, real_nsec))
        {
            *real_nsec = std::abs(*real_nsec);
            return true;
        }
        else
        {
            return false;
        }
    }
 
protected:
    long long timestamp_ {OSTime::get_monotonic()};
    time_t seconds_ {0};
    int16_t rate_ {0};        
 
    uint16_t started_ : 1; 
};
 
#endif // _UTILS_TIMEBASE_HXX_