Time.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "../Foundation/PrimitiveTypes.h"
 
namespace SC
{
namespace Time
{
struct Absolute;
struct Relative;
struct HighResolutionCounter;
 
struct Milliseconds;
struct Seconds;
} // namespace Time
} // namespace SC
 
 
 
 
struct SC::Time::Milliseconds
{
    constexpr Milliseconds() : ms(0) {}
    constexpr explicit Milliseconds(int64_t ms) : ms(ms){};
    int64_t ms;
 
    bool operator>(const Milliseconds other) const { return ms > other.ms; }
    bool operator<(const Milliseconds other) const { return ms < other.ms; }
};
 
struct SC::Time::Seconds
{
    constexpr Seconds() : sec(0) {}
    constexpr explicit Seconds(int64_t sec) : sec(sec){};
 
    constexpr operator Milliseconds() { return Milliseconds(sec * 1000); }
    int64_t   sec;
};
 
struct SC::Time::Relative
{
    Relative() : floatingSeconds(0.0) {}
 
    static Relative fromSeconds(double seconds) { return Relative(seconds); }
 
    Milliseconds inRoundedUpperMilliseconds() const
    {
        return Milliseconds(static_cast<int64_t>(floatingSeconds * 1000.0 + 0.5f));
    }
    Seconds inSeconds() const { return Seconds(static_cast<int64_t>(floatingSeconds)); }
 
  private:
    Relative(double floatingSeconds) : floatingSeconds(floatingSeconds) {}
    double floatingSeconds = 0;
};
 
struct SC::Time::Absolute
{
  private:
    struct Internal;
    int64_t millisecondsSinceEpoch;
 
  public:
    Absolute(int64_t millisecondsSinceEpoch) : millisecondsSinceEpoch(millisecondsSinceEpoch) {}
 
    [[nodiscard]] static Absolute now();
 
    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]] Relative subtract(Absolute other);
 
    [[nodiscard]] int64_t getMillisecondsSinceEpoch() const { return millisecondsSinceEpoch; }
};
 
struct SC::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;
 
    int64_t part1;
    int64_t part2;
 
  private:
    struct Internal;
};