Time.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "../Foundation/PrimitiveTypes.h"
 
namespace SC
{
namespace Time
{
struct Absolute;
struct Monotonic;
struct Realtime;
struct Relative;
struct HighResolutionCounter;
 
struct Milliseconds;
struct Nanoseconds;
struct Seconds;
} // namespace Time
 
 
 
 
struct Time::Nanoseconds
{
    constexpr Nanoseconds() : ns(0) {}
    constexpr explicit Nanoseconds(int64_t ns) : ns(ns) {};
    int64_t ns;
 
    [[nodiscard]] bool operator>(const Nanoseconds other) const { return ns > other.ns; }
    [[nodiscard]] bool operator<(const Nanoseconds other) const { return ns < other.ns; }
    [[nodiscard]] bool operator==(const Nanoseconds other) const { return ns == other.ns; }
};
 
struct Time::Milliseconds
{
    constexpr Milliseconds() : ms(0) {}
    constexpr explicit Milliseconds(int64_t ms) : ms(ms) {};
    int64_t ms;
 
    [[nodiscard]] bool operator>(const Milliseconds other) const { return ms > other.ms; }
    [[nodiscard]] bool operator<(const Milliseconds other) const { return ms < other.ms; }
    [[nodiscard]] bool operator==(const Milliseconds other) const { return ms == other.ms; }
};
 
struct Time::Seconds
{
    constexpr Seconds() : sec(0) {}
    constexpr explicit Seconds(int64_t sec) : sec(sec) {};
    int64_t sec;
 
    [[nodiscard]] bool operator>(const Seconds other) const { return sec > other.sec; }
    [[nodiscard]] bool operator<(const Seconds other) const { return sec < other.sec; }
    [[nodiscard]] bool operator==(const Seconds other) const { return sec == other.sec; }
 
    constexpr operator Milliseconds() { return Milliseconds(sec * 1000); }
};
 
struct Time::Relative
{
    Relative() : seconds(0.0) {}
 
    Relative(Milliseconds time) : seconds(static_cast<double>(time.ms / 1e3)) {}
 
    Relative(Nanoseconds time) : seconds(static_cast<double>(time.ns / 1e9)) {}
 
    Relative(Seconds time) : seconds(static_cast<double>(time.sec)) {}
 
    static Relative fromSeconds(double seconds) { return Relative(seconds); }
 
    [[nodiscard]] bool operator>(const Relative other) const { return seconds > other.seconds; }
    [[nodiscard]] bool operator<(const Relative other) const { return seconds < other.seconds; }
    [[nodiscard]] bool operator==(const Relative other) const { return toNanoseconds() == other.toNanoseconds(); }
 
    Seconds      toSeconds() const { return Seconds(static_cast<int64_t>(seconds + 0.5)); }
    Nanoseconds  toNanoseconds() const { return Nanoseconds(static_cast<int64_t>(seconds * 1e9 + 0.5)); }
    Milliseconds toMilliseconds() const { return Milliseconds(static_cast<int64_t>(seconds * 1e3 + 0.5)); }
 
  private:
    Relative(double seconds) : seconds(seconds) {}
    double seconds = 0;
};
 
// User defined literals
// Using "unsigned long long int" instead of int64_t because it's mandated by the standard.
// clang-format off
inline Time::Nanoseconds  operator""_ns(unsigned long long int ns) { return Time::Nanoseconds(static_cast<int64_t>(ns)); }
inline Time::Milliseconds operator""_ms(unsigned long long int ms) { return Time::Milliseconds(static_cast<int64_t>(ms)); }
inline Time::Seconds      operator""_sec(unsigned long long int sec) { return Time::Seconds(static_cast<int64_t>(sec)); }
// clang-format on
 
struct Time::Absolute : public TimeMs
{
  protected:
    struct Internal;
 
  public:
    Absolute() = default;
 
    Absolute(int64_t milliseconds) : TimeMs{milliseconds} {}
 
    Absolute(TimeMs time) : TimeMs{time} {}
 
    struct ParseResult
    {
        uint16_t year       = 0;
        uint8_t  month      = 0;
        uint8_t  dayOfMonth = 0;
        uint8_t  dayOfWeek  = 0;
        uint8_t  dayOfYear  = 0;
        uint8_t  hour       = 0;
        uint8_t  minutes    = 0;
        uint8_t  seconds    = 0;
 
        const char* getMonth() const;
        const char* getDay() const;
        bool        isDaylightSaving = false;
 
      private:
        friend struct Internal;
        char monthName[16];
        char dayName[16];
    };
 
    [[nodiscard]] bool parseLocal(ParseResult& result) const;
 
    [[nodiscard]] bool parseUTC(ParseResult& result) const;
 
    [[nodiscard]] bool isLaterThanOrEqualTo(Absolute other) const;
 
    [[nodiscard]] bool isLaterThan(Absolute other) const;
 
    [[nodiscard]] Milliseconds subtractExact(Absolute other) const;
 
    [[nodiscard]] Absolute offsetBy(Milliseconds other) const;
};
 
struct Time::Monotonic : public Absolute
{
    using Absolute::Absolute;
 
    [[nodiscard]] static Monotonic now();
 
    [[nodiscard]] int64_t getMonotonicMilliseconds() const { return milliseconds; }
};
 
struct Time::Realtime : public Absolute
{
    using Absolute::Absolute;
 
    [[nodiscard]] static Realtime now();
 
    [[nodiscard]] int64_t getMillisecondsSinceEpoch() const { return milliseconds; }
};
 
struct Time::HighResolutionCounter
{
    HighResolutionCounter();
 
    HighResolutionCounter& snap();
 
    [[nodiscard]] HighResolutionCounter offsetBy(Milliseconds ms) const;
 
    [[nodiscard]] bool isLaterThanOrEqualTo(HighResolutionCounter other) const;
 
    [[nodiscard]] Relative subtractApproximate(HighResolutionCounter other) const;
 
    [[nodiscard]] HighResolutionCounter subtractExact(HighResolutionCounter other) const;
 
    Relative getRelative() const;
 
    Nanoseconds toNanoseconds() const;
 
    Milliseconds toMilliseconds() const;
 
    Seconds toSeconds() const;
 
  private:
    int64_t part1;
    int64_t part2;
 
    struct Internal;
};
 
} // namespace SC