Time.hpp

Go to the documentation of this file.

#ifndef DONUT_TIME_HPP
#define DONUT_TIME_HPP
 
#include <donut/math.hpp>
 
#include <chrono>       // std::chrono::...
#include <cstddef>      // std::size_t
#include <fmt/format.h> // fmt::formatter, fmt::format_to
#include <ratio>        // std::ratio
 
namespace donut {
 
template <typename T, typename Period = std::ratio<1>>
class Time {
public:
    using Duration = std::chrono::duration<T, Period>;
 
    constexpr Time() noexcept = default;
 
    constexpr Time(Duration duration) noexcept
        : duration(duration) {}
 
    constexpr Time(std::chrono::seconds seconds) noexcept
        : duration(duration_cast<Duration>(seconds)) {}
 
    constexpr Time(std::chrono::milliseconds milliseconds) noexcept
        : duration(duration_cast<Duration>(milliseconds)) {}
 
    constexpr Time(std::chrono::microseconds microseconds) noexcept
        : duration(duration_cast<Duration>(microseconds)) {}
 
    constexpr Time(std::chrono::nanoseconds nanoseconds) noexcept
        : duration(duration_cast<Duration>(nanoseconds)) {}
 
    constexpr Time(std::chrono::minutes minutes) noexcept
        : duration(duration_cast<Duration>(minutes)) {}
 
    constexpr Time(std::chrono::hours hours) noexcept
        : duration(duration_cast<Duration>(hours)) {}
 
    constexpr operator Duration() const noexcept {
        return duration;
    }
 
    constexpr operator T() const noexcept {
        return duration.count();
    }
 
    [[nodiscard]] friend constexpr bool operator==(const Time& a, const Time& b) noexcept {
        return a.duration == b.duration;
    }
 
    [[nodiscard]] friend constexpr bool operator!=(const Time& a, const Time& b) noexcept {
        return a.duration != b.duration;
    }
 
    [[nodiscard]] friend constexpr bool operator<(const Time& a, const Time& b) noexcept {
        return a.duration < b.duration;
    }
 
    [[nodiscard]] friend constexpr bool operator<=(const Time& a, const Time& b) noexcept {
        return a.duration <= b.duration;
    }
 
    [[nodiscard]] friend constexpr bool operator>(const Time& a, const Time& b) noexcept {
        return a.duration > b.duration;
    }
 
    [[nodiscard]] friend constexpr bool operator>=(const Time& a, const Time& b) noexcept {
        return a.duration >= b.duration;
    }
 
    constexpr Time& operator+=(Time deltaTime) noexcept {
        duration += deltaTime;
        return *this;
    }
 
    constexpr Time& operator-=(Time deltaTime) noexcept {
        duration -= deltaTime;
        return *this;
    }
 
    friend constexpr Time operator+(Time a) noexcept {
        return Time{+a.duration};
    }
 
    friend constexpr Time operator-(Time a) noexcept {
        return Time{-a.duration};
    }
 
    friend constexpr Time operator+(Time a, Time b) noexcept {
        a += b;
        return a;
    }
 
    friend constexpr Time operator-(Time a, Time b) noexcept {
        a -= b;
        return a;
    }
 
    constexpr bool countDown(Time deltaTime, Time targetTime = Duration{}) noexcept {
        duration -= deltaTime;
        if (duration <= targetTime) {
            duration = targetTime;
            return true;
        }
        return false;
    }
 
    constexpr bool countUp(Time deltaTime, Time targetTime) noexcept {
        duration += deltaTime;
        if (duration >= targetTime) {
            duration = targetTime;
            return true;
        }
        return false;
    }
 
    [[nodiscard]] constexpr std::size_t countDownLoop(Time deltaTime, Time interval) noexcept {
        if (interval <= Time{}) {
            duration = Time{};
            return 1;
        }
        std::size_t ticks = 0;
        duration -= deltaTime;
        while (duration <= Time{}) {
            duration += interval;
            ++ticks;
        }
        return ticks;
    }
 
    [[nodiscard]] constexpr std::size_t countUpLoop(Time deltaTime, Time interval) noexcept {
        if (interval <= Time{}) {
            duration = Time{};
            return 1;
        }
        std::size_t ticks = 0;
        duration += deltaTime;
        while (duration >= interval) {
            duration -= interval;
            ++ticks;
        }
        return ticks;
    }
 
    [[nodiscard]] constexpr std::size_t countDownLoop(Time deltaTime, Time interval, bool active) noexcept {
        if (active) {
            return countDownLoop(deltaTime, interval);
        }
        countDown(deltaTime);
        return 0;
    }
 
    [[nodiscard]] constexpr std::size_t countUpLoop(Time deltaTime, Time interval, bool active) noexcept {
        if (active) {
            return countUpLoop(deltaTime, interval);
        }
        *this = Time{};
        return 0;
    }
 
private:
    Duration duration{};
};
 
template <typename T, typename Period>
[[nodiscard]] constexpr Time<T, Period> operator*(Time<T, Period> a, T b) noexcept {
    return static_cast<typename Time<T, Period>::Duration>(a) * b;
}
 
template <typename T, typename Period>
[[nodiscard]] constexpr Time<T, Period> operator*(T a, Time<T, Period> b) noexcept {
    return a * static_cast<typename Time<T, Period>::Duration>(b);
}
 
template <typename T, typename Period>
[[nodiscard]] constexpr Time<T, Period> operator/(Time<T, Period> a, T b) noexcept {
    return static_cast<typename Time<T, Period>::Duration>(a) / b;
}
 
template <length_t L, typename T, typename Period>
[[nodiscard]] constexpr vec<L, T> operator*(vec<L, T> a, Time<T, Period> b) noexcept {
    return a * static_cast<T>(b);
}
 
template <length_t L, typename T, typename Period>
[[nodiscard]] constexpr vec<L, T> operator*(Time<T, Period> a, vec<L, T> b) noexcept {
    return static_cast<T>(a) * b;
}
 
template <length_t L, typename T, typename Period>
[[nodiscard]] constexpr vec<L, T> operator/(vec<L, T> a, Time<T, Period> b) noexcept {
    return a / static_cast<T>(b);
}
 
template <length_t L, typename T, typename Period>
[[nodiscard]] constexpr vec<L, T> operator/(Time<T, Period> a, vec<L, T> b) noexcept {
    return static_cast<T>(a) / b;
}
 
} // namespace donut
 
template <typename T, typename Period, typename CharT>
struct fmt::formatter<donut::Time<T, Period>, CharT> {
    constexpr auto parse(auto& pc) {
        return pc.begin();
    }
 
    auto format(const donut::Time<T, Period>& time, auto& fc) const {
        return fmt::format_to(fc.out(), "{}", static_cast<typename donut::Time<T, Period>::Duration>(time));
    }
};
 
#endif