TimePoint.h

Go to the documentation of this file.

// Honeycomb, Copyright (C) 2015 NewGamePlus Inc.  Distributed under the Boost Software License v1.0.
#pragma once

#include "Honey/Chrono/Duration.h"

namespace honey
{

template<class Clock_, class Dur = typename Clock_::Duration>
class TimePoint
{
    friend class TimePoint;
public:
    typedef Clock_ Clock;
    typedef Dur Duration;

    constexpr TimePoint()                                       : _dur(Duration::zero()) {}
    constexpr explicit TimePoint(const Duration& d)             : _dur(d) {}
    template<class Dur2>
    constexpr TimePoint(const TimePoint<Clock, Dur2>& t)        : _dur(t._dur) {}
    template<class Clock2, class Dur2>
    TimePoint(const TimePoint<Clock2, Dur2>& t)                 { operator=(t); }

    template<class Dur2>
    TimePoint& operator=(const TimePoint<Clock, Dur2>& rhs)     { _dur = rhs._dur; return *this; }
    template<class Clock2, class Dur2>
    TimePoint& operator=(const TimePoint<Clock2, Dur2>& rhs)    { _dur = Clock::now() + (rhs._dur - Clock2::now()); return *this; }

    TimePoint& operator+=(const Duration& rhs)                  { _dur += rhs; return *this; }
    TimePoint& operator-=(const Duration& rhs)                  { _dur -= rhs; return *this; }

    template<class Dur2>
    constexpr bool operator==(const TimePoint<Clock,Dur2>& rhs) const   { return _dur == rhs._dur; }

    template<class Dur2>
    constexpr bool operator!=(const TimePoint<Clock,Dur2>& rhs) const   { return !(*this == rhs); }

    template<class Dur2>
    constexpr bool operator<(const TimePoint<Clock,Dur2>& rhs) const    { return _dur < rhs._dur; }

    template<class Dur2>
    constexpr bool operator>(const TimePoint<Clock,Dur2>& rhs) const    { return rhs < *this; }

    template<class Dur2>
    constexpr bool operator<=(const TimePoint<Clock,Dur2>& rhs) const   { return !(rhs < *this); }
    
    template<class Dur2>
    constexpr bool operator>=(const TimePoint<Clock,Dur2>& rhs) const   { return !(*this < rhs); }

    constexpr Duration time() const                             { return _dur; }

    static constexpr TimePoint min()                            { return TimePoint(Dur(numeral<typename Dur::Rep>().min())); }
    static constexpr TimePoint max()                            { return TimePoint(Dur(numeral<typename Dur::Rep>().max())); }
    
private:
    Duration _dur;
};


template<class Clock, class Dur, class Rep, class Period,
    class TimeCommon = TimePoint<Clock, typename std::common_type<Dur, Duration<Rep,Period>>::type>>
constexpr TimeCommon operator+(const TimePoint<Clock,Dur>& lhs, const Duration<Rep,Period>& rhs)
{
    return TimeCommon(lhs.time() + rhs);
}
template<class Clock, class Dur, class Rep, class Period,
    class TimeCommon = TimePoint<Clock, typename std::common_type<Dur, Duration<Rep,Period>>::type>>
constexpr TimeCommon operator+(const Duration<Rep,Period>& lhs, const TimePoint<Clock,Dur>& rhs)
{
    return rhs + lhs;
}
template<class Clock, class Dur, class Rep, class Period,
    class TimeCommon = TimePoint<Clock, typename std::common_type<Dur, Duration<Rep,Period>>::type>>
constexpr TimeCommon operator-(const TimePoint<Clock,Dur>& lhs, const Duration<Rep,Period>& rhs)
{
    return lhs + (-rhs);
}
template<class Clock, class Dur, class Dur2,
     class DurCommon = typename std::common_type<Dur, Dur2>::type>
constexpr DurCommon operator-(const TimePoint<Clock,Dur>& lhs, const TimePoint<Clock,Dur2>& rhs)
{
    return lhs.time() - rhs.time();
}

}