ge211_time.hxx

#pragma once
 
#include "ge211_forward.hxx"
 
#include <chrono>
#include <ratio>
#include <thread>
 
namespace ge211 {
 
namespace detail {
 
using Clock = std::conditional_t<
        std::chrono::high_resolution_clock::is_steady,
        std::chrono::high_resolution_clock,
        std::chrono::steady_clock>;
 
} // end namespace detail
 
namespace time {
 
class Duration
{
public:
    Duration() : duration_{} {}
 
    explicit Duration(double seconds)
            : Duration{std::chrono::duration<double>{seconds}} {}
 
    double seconds() const
    {
        auto seconds =
                std::chrono::duration_cast<std::chrono::duration<double>>(
                        duration_);
        return seconds.count();
    }
 
    long milliseconds() const
    {
        auto millis =
                std::chrono::duration_cast<std::chrono::duration<long, std::milli>>(
                        duration_);
        return millis.count();
    }
 
 
    bool operator==(Duration other) const
    {
        return duration_ == other.duration_;
    }
 
    bool operator!=(Duration other) const
    {
        return duration_ != other.duration_;
    }
 
    bool operator<(Duration other) const
    {
        return duration_ < other.duration_;
    }
 
    bool operator<=(Duration other) const
    {
        return duration_ <= other.duration_;
    }
 
    bool operator>(Duration other) const
    {
        return duration_ > other.duration_;
    }
 
    bool operator>=(Duration other) const
    {
        return duration_ >= other.duration_;
    }
 
 
 
    Duration operator+(Duration other) const
    {
        return {duration_ + other.duration_};
    }
 
    Duration operator-(Duration other) const
    {
        return {duration_ - other.duration_};
    }
 
    Duration operator*(double factor) const
    {
        return {duration_ * factor};
    }
 
    Duration operator/(double factor) const
    {
        return {duration_ / factor};
    }
 
    Duration& operator+=(Duration other)
    {
        return *this = *this + other;
    }
 
    Duration& operator-=(Duration other)
    {
        return *this = *this - other;
    }
 
    Duration& operator*=(double factor)
    {
        return *this = *this * factor;
    }
 
    Duration& operator/=(double factor)
    {
        return *this = *this / factor;
    }
 
 
private:
    friend Time_point;
    friend class detail::Engine;
 
    Duration(std::chrono::duration<double> duration)
            : Duration{std::chrono::duration_cast<detail::Clock::duration>
                               (duration)} {}
 
    Duration(detail::Clock::duration duration)
            : duration_{duration} {}
 
    void sleep_for() const
    {
        std::this_thread::sleep_for(duration_);
    }
 
    detail::Clock::duration duration_;
};
 
class Time_point
{
public:
    Time_point() : time_point_{} {}
 
    static Time_point now() { return Time_point(detail::Clock::now()); }
 
 
    bool operator==(Time_point other) const
    {
        return time_point_ == other.time_point_;
    }
 
    bool operator!=(Time_point other) const
    {
        return time_point_ != other.time_point_;
    }
 
    bool operator<(Time_point other) const
    {
        return time_point_ < other.time_point_;
    }
 
    bool operator<=(Time_point other) const
    {
        return time_point_ <= other.time_point_;
    }
 
    bool operator>(Time_point other) const
    {
        return time_point_ > other.time_point_;
    }
 
    bool operator>=(Time_point other) const
    {
        return time_point_ >= other.time_point_;
    }
 
 
 
    Duration operator-(Time_point other) const
    {
        return Duration{time_point_ - other.time_point_};
    }
 
    Time_point operator+(Duration duration) const
    {
        return Time_point{time_point_ + duration.duration_};
    }
 
    Time_point operator-(Duration duration) const
    {
        return Time_point{time_point_ - duration.duration_};
    }
 
    Time_point& operator+=(Duration duration)
    {
        return *this = *this + duration;
    }
 
    Time_point& operator-=(Duration duration)
    {
        return *this = *this - duration;
    }
 
 
private:
    Time_point(detail::Clock::time_point time_point)
            : time_point_{time_point} {}
 
    detail::Clock::time_point time_point_;
};
 
class Timer
{
public:
    Timer() : start_time_{now_()} {}
 
    static Timer future(Duration duration)
    {
        Timer result;
        result.start_time_ += duration;
        return result;
    }
 
    Duration reset()
    {
        Time_point previous = start_time_;
        start_time_ = now_();
        return start_time_ - previous;
    }
 
    Time_point start_time() const
    {
        return start_time_;
    }
 
    Duration elapsed_time() const
    {
        return now_() - start_time_;
    }
 
private:
    Time_point start_time_;
 
    static Time_point now_() { return Time_point::now(); }
};
 
class Pausable_timer
{
public:
    explicit Pausable_timer(bool start_paused = false)
    {
        is_paused_ = start_paused;
 
        if (is_paused_)
            elapsed_time_ = Duration{};
        else
            fake_start_time_ = now_();
    }
 
    bool is_paused() const
    {
        return is_paused_;
    }
 
    Duration elapsed_time() const
    {
        if (is_paused_) {
            return elapsed_time_;
        } else {
            return now_() - fake_start_time_;
        }
    }
 
    Duration pause()
    {
        if (!is_paused_) {
            elapsed_time_ = now_() - fake_start_time_;
            is_paused_ = true;
        }
 
        return elapsed_time_;
    }
 
    void resume()
    {
        if (is_paused_) {
            fake_start_time_ = now_() - elapsed_time_;
            is_paused_ = false;
        }
    }
 
    Duration reset()
    {
        if (is_paused_) {
            auto result = elapsed_time_;
            elapsed_time_ = Duration{};
            return result;
        } else {
            auto now = now_();
            auto result = now - fake_start_time_;
            fake_start_time_ = now;
            return result;
        }
    }
 
private:
    union
    {
        Time_point fake_start_time_;        // when not paused
        Duration elapsed_time_; // when paused
    };
    bool is_paused_;
 
    static Time_point now_() { return Time_point::now(); }
};
 
} // end namespace time
 
}