timestamp.h

Go to the documentation of this file.

 
#ifndef FEATURES_TIMESTAMP_H
#define FEATURES_TIMESTAMP_H
 
#include <chrono>
#include <cstdint>
#include <ratio>
#include <string>
#include <string_view>
#include <type_traits>
#include <utility>
#include <iomanip>
#include <array>
#include <optional>
#include <functional>
#include <thread>
 
#if defined(__APPLE__)
#include <mach/mach.h>
#include <mach/mach_time.h>
#include <sys/time.h>
#elif defined(_WIN32) || defined(_WIN64)
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif
#ifndef NOMINMAX
#define NOMINMAX
#endif
#include <windows.h>
#endif
 
#include <qb/io.h>
 
// Forward declarations
namespace qb {
class Duration;
class TimePoint;
 
// Specialized time points
class UtcTimePoint;
class LocalTimePoint;
class HighResTimePoint;
class TscTimePoint;  // TSC = Time Stamp Counter (formerly RDTS)
}
 
namespace qb {
 

class Duration {
public:
    using rep = int64_t;
    
    using chrono_duration = std::chrono::duration<rep, std::nano>;
    
    static constexpr Duration zero() noexcept { return Duration(0); }
    
    constexpr Duration() noexcept = default;
    
    constexpr explicit Duration(rep nanoseconds) noexcept
        : _duration(nanoseconds) {}
    
    template <typename Rep, typename Period>
    constexpr explicit Duration(const std::chrono::duration<Rep, Period>& duration) noexcept
        : _duration(std::chrono::duration_cast<chrono_duration>(duration).count()) {}
        
    // Standard special member functions
    constexpr Duration(const Duration&) noexcept = default;
    constexpr Duration(Duration&&) noexcept = default;
    constexpr Duration& operator=(const Duration&) noexcept = default;
    constexpr Duration& operator=(Duration&&) noexcept = default;
    ~Duration() noexcept = default;
    
    [[nodiscard]] constexpr chrono_duration to_chrono() const noexcept {
        return chrono_duration(_duration);
    }
    
    template <typename TargetDuration>
    [[nodiscard]] constexpr TargetDuration to() const noexcept {
        return std::chrono::duration_cast<TargetDuration>(to_chrono());
    }
    
    [[nodiscard]] static constexpr Duration from_days(rep days) noexcept {
        return Duration(days * 86400 * 1000000000LL);
    }
    
    [[nodiscard]] static constexpr Duration from_hours(rep hours) noexcept {
        return Duration(hours * 3600 * 1000000000LL);
    }
    
    [[nodiscard]] static constexpr Duration from_minutes(rep minutes) noexcept {
        return Duration(minutes * 60 * 1000000000LL);
    }
    
    [[nodiscard]] static constexpr Duration from_seconds(rep seconds) noexcept {
        return Duration(seconds * 1000000000LL);
    }
    
    [[nodiscard]] static constexpr Duration from_milliseconds(rep ms) noexcept {
        return Duration(ms * 1000000LL);
    }
    
    [[nodiscard]] static constexpr Duration from_microseconds(rep us) noexcept {
        return Duration(us * 1000LL);
    }
    
    [[nodiscard]] static constexpr Duration from_nanoseconds(rep ns) noexcept {
        return Duration(ns);
    }
    
    // Value accessors
    
    [[nodiscard]] constexpr rep days() const noexcept {
        return _duration / (86400 * 1000000000LL);
    }
    
    [[nodiscard]] constexpr double days_float() const noexcept {
        return static_cast<double>(_duration) / (86400.0 * 1000000000.0);
    }
    
    [[nodiscard]] constexpr rep hours() const noexcept {
        return _duration / (3600 * 1000000000LL);
    }
    
    [[nodiscard]] constexpr double hours_float() const noexcept {
        return static_cast<double>(_duration) / (3600.0 * 1000000000.0);
    }
    
    [[nodiscard]] constexpr rep minutes() const noexcept {
        return _duration / (60 * 1000000000LL);
    }
    
    [[nodiscard]] constexpr double minutes_float() const noexcept {
        return static_cast<double>(_duration) / (60.0 * 1000000000.0);
    }
    
    [[nodiscard]] constexpr rep seconds() const noexcept {
        return _duration / 1000000000LL;
    }
    
    [[nodiscard]] constexpr double seconds_float() const noexcept {
        return static_cast<double>(_duration) / 1000000000.0;
    }
    
    [[nodiscard]] constexpr rep milliseconds() const noexcept {
        return _duration / 1000000LL;
    }
    
    [[nodiscard]] constexpr double milliseconds_float() const noexcept {
        return static_cast<double>(_duration) / 1000000.0;
    }
    
    [[nodiscard]] constexpr rep microseconds() const noexcept {
        return _duration / 1000LL;
    }
    
    [[nodiscard]] constexpr double microseconds_float() const noexcept {
        return static_cast<double>(_duration) / 1000.0;
    }
    
    [[nodiscard]] constexpr rep nanoseconds() const noexcept {
        return _duration;
    }
    
    [[nodiscard]] constexpr double nanoseconds_float() const noexcept {
        return static_cast<double>(_duration);
    }
    
    [[nodiscard]] constexpr rep count() const noexcept {
        return _duration;
    }
    
    // Unary operators
    constexpr Duration operator+() const noexcept { return *this; }
    constexpr Duration operator-() const noexcept { return Duration(-_duration); }
    
    // Compound assignment operators
    constexpr Duration& operator+=(const Duration& other) noexcept {
        _duration += other._duration;
        return *this;
    }
    
    constexpr Duration& operator-=(const Duration& other) noexcept {
        _duration -= other._duration;
        return *this;
    }
    
    constexpr Duration& operator*=(rep multiplier) noexcept {
        _duration *= multiplier;
        return *this;
    }
    
    constexpr Duration& operator/=(rep divisor) noexcept {
        _duration /= divisor;
        return *this;
    }
    
    constexpr Duration& operator%=(const Duration& other) noexcept {
        _duration %= other._duration;
        return *this;
    }
    
    // Comparison operators
    constexpr bool operator==(const Duration& rhs) const noexcept {
        return count() == rhs.count();
    }
 
    constexpr bool operator!=(const Duration& rhs) const noexcept {
        return count() != rhs.count();
    }
 
    constexpr bool operator<(const Duration& rhs) const noexcept {
        return count() < rhs.count();
    }
 
    constexpr bool operator<=(const Duration& rhs) const noexcept {
        return count() <= rhs.count();
    }
 
    constexpr bool operator>(const Duration& rhs) const noexcept {
        return count() > rhs.count();
    }
 
    constexpr bool operator>=(const Duration& rhs) const noexcept {
        return count() >= rhs.count();
    }
    
private:
    rep _duration{0}; 
};
 
// Binary arithmetic operators for Duration
constexpr Duration operator+(const Duration& lhs, const Duration& rhs) noexcept {
    return Duration(lhs.count() + rhs.count());
}

constexpr Duration operator-(const Duration& lhs, const Duration& rhs) noexcept {
    return Duration(lhs.count() - rhs.count());
}

constexpr Duration operator*(const Duration& lhs, Duration::rep rhs) noexcept {
    return Duration(lhs.count() * rhs);
}

constexpr Duration operator*(Duration::rep lhs, const Duration& rhs) noexcept {
    return Duration(lhs * rhs.count());
}

constexpr Duration operator/(const Duration& lhs, Duration::rep rhs) noexcept {
    return Duration(lhs.count() / rhs);
}

constexpr Duration::rep operator/(const Duration& lhs, const Duration& rhs) noexcept {
    return lhs.count() / rhs.count();
}

constexpr Duration operator%(const Duration& lhs, Duration::rep rhs) noexcept {
    return Duration(lhs.count() % rhs);
}

constexpr Duration operator%(const Duration& lhs, const Duration& rhs) noexcept {
    return Duration(lhs.count() % rhs.count());
}
 
// Literal operators for convenient duration creation
namespace literals {
    constexpr Duration operator""_d(unsigned long long days) noexcept {
        return Duration::from_days(days);
    }
    
    constexpr Duration operator""_h(unsigned long long hours) noexcept {
        return Duration::from_hours(hours);
    }
    
    constexpr Duration operator""_min(unsigned long long minutes) noexcept {
        return Duration::from_minutes(minutes);
    }
    
    constexpr Duration operator""_s(unsigned long long seconds) noexcept {
        return Duration::from_seconds(seconds);
    }
    
    constexpr Duration operator""_ms(unsigned long long milliseconds) noexcept {
        return Duration::from_milliseconds(milliseconds);
    }
    
    constexpr Duration operator""_us(unsigned long long microseconds) noexcept {
        return Duration::from_microseconds(microseconds);
    }
    
    constexpr Duration operator""_ns(unsigned long long nanoseconds) noexcept {
        return Duration::from_nanoseconds(nanoseconds);
    }
}

class TimePoint {
public:
    using rep = uint64_t;
    
    using chrono_time_point = std::chrono::time_point<std::chrono::system_clock, 
                                                      std::chrono::duration<rep, std::nano>>;
                                                      
    static constexpr TimePoint epoch() noexcept { return TimePoint(0); }
    
    constexpr TimePoint() noexcept = default;
    
    constexpr explicit TimePoint(rep nanoseconds) noexcept
        : _time_since_epoch(nanoseconds) {}
        
    template <typename Clock, typename ChronoDuration>
    explicit TimePoint(const std::chrono::time_point<Clock, ChronoDuration>& time_point) noexcept
        : _time_since_epoch(std::chrono::duration_cast<std::chrono::nanoseconds>(
              time_point.time_since_epoch()).count()) {}
              
    // Standard special member functions
    constexpr TimePoint(const TimePoint&) noexcept = default;
    constexpr TimePoint(TimePoint&&) noexcept = default;
    constexpr TimePoint& operator=(const TimePoint&) noexcept = default;
    constexpr TimePoint& operator=(TimePoint&&) noexcept = default;
    ~TimePoint() noexcept = default;
    
    static TimePoint now() noexcept {
        // Use the combination of system clock (for absolute time) and 
        // steady clock (for monotonic time between calls)
        static const auto system_start = std::chrono::system_clock::now();
        static const auto steady_start = std::chrono::steady_clock::now();
        
        auto steady_now = std::chrono::steady_clock::now();
        auto delta = steady_now - steady_start;
        auto result = system_start + delta;
        
        return TimePoint(result);
    }
    
    [[nodiscard]] chrono_time_point to_chrono() const noexcept {
        return std::chrono::time_point<std::chrono::system_clock>() + 
               std::chrono::nanoseconds(_time_since_epoch);
    }
    
    template <typename Clock, typename ChronoDuration = typename Clock::duration>
    [[nodiscard]] std::chrono::time_point<Clock, ChronoDuration> 
    to() const noexcept {
        using target_tp = std::chrono::time_point<Clock, ChronoDuration>;
        return std::chrono::time_point_cast<ChronoDuration>(
            target_tp(std::chrono::duration_cast<ChronoDuration>(
                std::chrono::nanoseconds(_time_since_epoch))));
    }
    
    [[nodiscard]] static constexpr TimePoint from_days(int64_t days) noexcept {
        return TimePoint(days * 86400ULL * 1000000000ULL);
    }
    
    [[nodiscard]] static constexpr TimePoint from_hours(int64_t hours) noexcept {
        return TimePoint(hours * 3600ULL * 1000000000ULL);
    }
    
    [[nodiscard]] static constexpr TimePoint from_minutes(int64_t minutes) noexcept {
        return TimePoint(minutes * 60ULL * 1000000000ULL);
    }
    
    [[nodiscard]] static constexpr TimePoint from_seconds(int64_t seconds) noexcept {
        return TimePoint(seconds * 1000000000ULL);
    }
    
    [[nodiscard]] static constexpr TimePoint from_milliseconds(int64_t ms) noexcept {
        return TimePoint(ms * 1000000ULL);
    }
    
    [[nodiscard]] static constexpr TimePoint from_microseconds(int64_t us) noexcept {
        return TimePoint(us * 1000ULL);
    }
    
    [[nodiscard]] static constexpr TimePoint from_nanoseconds(int64_t ns) noexcept {
        return TimePoint(ns);
    }
    
    [[nodiscard]] static std::optional<TimePoint> from_iso8601(std::string_view iso8601) noexcept {
        try {
            std::tm tm = {};
            std::string str_iso8601(iso8601);
            std::istringstream iss(str_iso8601);
            iss >> std::get_time(&tm, "%Y-%m-%dT%H:%M:%SZ");
            if (iss.fail()) {
                return std::nullopt;
            }
            const auto time_since_epoch = std::mktime(&tm);
            if (time_since_epoch == -1) {
                return std::nullopt;
            }
            return TimePoint(static_cast<rep>(time_since_epoch) * 1000000000ULL);
        } catch (...) {
            return std::nullopt;
        }
    }
    
    [[nodiscard]] static std::optional<TimePoint> parse(
        std::string_view time_string, std::string_view format) noexcept {
        try {
            std::tm tm = {};
            std::string str_time_string(time_string);
            std::istringstream iss(str_time_string);
            iss >> std::get_time(&tm, format.data());
            if (iss.fail()) {
                return std::nullopt;
            }
            const auto time_since_epoch = std::mktime(&tm);
            if (time_since_epoch == -1) {
                return std::nullopt;
            }
            return TimePoint(static_cast<rep>(time_since_epoch) * 1000000000ULL);
        } catch (...) {
            return std::nullopt;
        }
    }
    
    // Value accessors
    
    [[nodiscard]] constexpr rep days() const noexcept {
        return _time_since_epoch / (86400ULL * 1000000000ULL);
    }
    
    [[nodiscard]] constexpr double days_float() const noexcept {
        return static_cast<double>(_time_since_epoch) / (86400.0 * 1000000000.0);
    }
    
    [[nodiscard]] constexpr rep hours() const noexcept {
        return _time_since_epoch / (3600ULL * 1000000000ULL);
    }
    
    [[nodiscard]] constexpr double hours_float() const noexcept {
        return static_cast<double>(_time_since_epoch) / (3600.0 * 1000000000.0);
    }
    
    [[nodiscard]] constexpr rep minutes() const noexcept {
        return _time_since_epoch / (60ULL * 1000000000ULL);
    }
    
    [[nodiscard]] constexpr double minutes_float() const noexcept {
        return static_cast<double>(_time_since_epoch) / (60.0 * 1000000000.0);
    }
    
    [[nodiscard]] constexpr rep seconds() const noexcept {
        return _time_since_epoch / 1000000000ULL;
    }
    
    [[nodiscard]] constexpr double seconds_float() const noexcept {
        return static_cast<double>(_time_since_epoch) / 1000000000.0;
    }
    
    [[nodiscard]] constexpr rep milliseconds() const noexcept {
        return _time_since_epoch / 1000000ULL;
    }
    
    [[nodiscard]] constexpr double milliseconds_float() const noexcept {
        return static_cast<double>(_time_since_epoch) / 1000000.0;
    }
    
    [[nodiscard]] constexpr rep microseconds() const noexcept {
        return _time_since_epoch / 1000ULL;
    }
    
    [[nodiscard]] constexpr double microseconds_float() const noexcept {
        return static_cast<double>(_time_since_epoch) / 1000.0;
    }
    
    [[nodiscard]] constexpr rep nanoseconds() const noexcept {
        return _time_since_epoch;
    }
    
    [[nodiscard]] constexpr double nanoseconds_float() const noexcept {
        return static_cast<double>(_time_since_epoch);
    }
    
    [[nodiscard]] Duration time_since_epoch() const noexcept {
        return Duration(static_cast<Duration::rep>(_time_since_epoch));
    }
    
    [[nodiscard]] constexpr rep count() const noexcept {
        return _time_since_epoch;
    }
    
    [[nodiscard]] std::string format(std::string_view format) const {
        const auto time_t_value = static_cast<std::time_t>(seconds());
        std::tm tm = {};
        
#if defined(_MSC_VER)
        gmtime_s(&tm, &time_t_value);
#else
        tm = *std::gmtime(&time_t_value);
#endif
        
        std::array<char, 128> buffer{};
        const auto result = std::strftime(buffer.data(), buffer.size(), format.data(), &tm);
        
        if (result == 0) {
            return {};
        }
        
        return std::string(buffer.data(), result);
    }
    
    [[nodiscard]] std::string to_iso8601() const {
        return format("%Y-%m-%dT%H:%M:%SZ");
    }
    
    static uint64_t read_tsc() noexcept {
#if defined(_MSC_VER)
        return __rdtsc();
#elif defined(__i386__)
        uint64_t x;
        __asm__ volatile(".byte 0x0f, 0x31" : "=A"(x));
        return x;
#elif defined(__x86_64__)
        unsigned hi, lo;
        __asm__ __volatile__("rdtsc" : "=a"(lo), "=d"(hi));
        return ((uint64_t)lo) | (((uint64_t)hi) << 32ULL);
#else
        // Fallback to high-resolution clock on platforms without rdtsc
        const auto now = std::chrono::high_resolution_clock::now();
        return std::chrono::duration_cast<std::chrono::nanoseconds>(
            now.time_since_epoch()).count();
#endif
    }
    
    TimePoint& operator+=(const Duration& duration) noexcept {
        _time_since_epoch += static_cast<rep>(duration.count());
        return *this;
    }
    
    TimePoint& operator-=(const Duration& duration) noexcept {
        _time_since_epoch -= static_cast<rep>(duration.count());
        return *this;
    }

    static uint64_t nano() noexcept {
        return now().count();
    }
 
protected:
    rep _time_since_epoch{0}; 
};
 
// Binary arithmetic operators for TimePoint and Duration
inline TimePoint operator+(const TimePoint& lhs, const Duration& rhs) noexcept {
    TimePoint result(lhs);
    result += rhs;
    return result;
}

inline TimePoint operator+(const Duration& lhs, const TimePoint& rhs) noexcept {
    return rhs + lhs;
}

inline TimePoint operator-(const TimePoint& lhs, const Duration& rhs) noexcept {
    TimePoint result(lhs);
    result -= rhs;
    return result;
}

inline Duration operator-(const TimePoint& lhs, const TimePoint& rhs) noexcept {
    return Duration(static_cast<Duration::rep>(lhs.count() - rhs.count()));
}
 
// Comparison operators for TimePoint
constexpr bool operator==(const TimePoint& lhs, const TimePoint& rhs) noexcept {
    return lhs.count() == rhs.count();
}

constexpr bool operator!=(const TimePoint& lhs, const TimePoint& rhs) noexcept {
    return lhs.count() != rhs.count();
}

constexpr bool operator<(const TimePoint& lhs, const TimePoint& rhs) noexcept {
    return lhs.count() < rhs.count();
}

constexpr bool operator<=(const TimePoint& lhs, const TimePoint& rhs) noexcept {
    return lhs.count() <= rhs.count();
}

constexpr bool operator>(const TimePoint& lhs, const TimePoint& rhs) noexcept {
    return lhs.count() > rhs.count();
}

constexpr bool operator>=(const TimePoint& lhs, const TimePoint& rhs) noexcept {
    return lhs.count() >= rhs.count();
}
 
// Backward compatibility typedefs
using Timespan = Duration;

using Timestamp = TimePoint;

class UtcTimePoint : public TimePoint {
public:
    using TimePoint::TimePoint;
    
    UtcTimePoint() : TimePoint(TimePoint::now()) {}
    
    static UtcTimePoint now() noexcept {
        auto tp = TimePoint::now();
        UtcTimePoint result;
        // Convert timepoint to epoch value and construct UtcTimePoint with it
        result = UtcTimePoint(tp.count());
        return result;
    }
};

class LocalTimePoint : public TimePoint {
public:
    using TimePoint::TimePoint;
    
    LocalTimePoint() : TimePoint(TimePoint::now()) {}
    
    static LocalTimePoint now() noexcept {
        auto tp = TimePoint::now();
        LocalTimePoint result;
        // Convert timepoint to epoch value and construct LocalTimePoint with it
        result = LocalTimePoint(tp.count());
        return result;
    }
    
    [[nodiscard]] std::string format_local(std::string_view format) const {
        const auto time_t_value = static_cast<std::time_t>(seconds());
        std::tm tm = {};
        
#if defined(_MSC_VER)
        localtime_s(&tm, &time_t_value);
#else
        tm = *std::localtime(&time_t_value);
#endif
        
        std::array<char, 128> buffer{};
        const auto result = std::strftime(buffer.data(), buffer.size(), format.data(), &tm);
        
        if (result == 0) {
            return {};
        }
        
        return std::string(buffer.data(), result);
    }
};

class HighResTimePoint : public TimePoint {
public:
    using TimePoint::TimePoint;
    
    HighResTimePoint() : TimePoint(TimePoint::now()) {}
    
    static HighResTimePoint now() noexcept {
        auto tp = TimePoint::now();
        HighResTimePoint result;
        // Convert timepoint to epoch value and construct HighResTimePoint with it
        result = HighResTimePoint(tp.count());
        return result;
    }
};

class TscTimePoint : public TimePoint {
public:
    using TimePoint::TimePoint;
    
    TscTimePoint() : TimePoint(now().count()) {}
    
    static TscTimePoint now() noexcept {
        static const auto system_time_at_init = TimePoint::now();
        static const auto tsc_at_init = TimePoint::read_tsc();
        static const auto tsc_frequency = calibrate_tsc_frequency();
        
        const auto tsc_elapsed = TimePoint::read_tsc() - tsc_at_init;
        const auto seconds_elapsed = static_cast<double>(tsc_elapsed) / tsc_frequency;
        const auto nanoseconds_elapsed = static_cast<uint64_t>(seconds_elapsed * 1e9);
        
        return TscTimePoint(system_time_at_init.count() + nanoseconds_elapsed);
    }
    
private:
    static double calibrate_tsc_frequency() noexcept {
        const auto start_time = TimePoint::now();
        const auto start_tsc = TimePoint::read_tsc();
        
        // Sleep for a short time to get a measurement
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
        
        const auto end_time = TimePoint::now();
        const auto end_tsc = TimePoint::read_tsc();
        
        const auto time_diff_ns = end_time.count() - start_time.count();
        const auto tsc_diff = end_tsc - start_tsc;
        
        return static_cast<double>(tsc_diff) * 1e9 / static_cast<double>(time_diff_ns);
    }
};

using UtcTimestamp = UtcTimePoint;

using LocalTimestamp = LocalTimePoint;

using NanoTimestamp = HighResTimePoint;

using RdtsTimestamp = TscTimePoint;

class ScopedTimer {
public:
    using TimerCallback = std::function<void(Duration)>;
    
    explicit ScopedTimer(TimerCallback callback)
        : _start_time(HighResTimePoint::now())
        , _callback(std::move(callback))
        , _active(true) {}
        
    ~ScopedTimer() {
        stop();
    }
    
    Duration stop() {
        if (!_active) {
            return _elapsed;
        }
        
        _active = false;
        _elapsed = HighResTimePoint::now() - _start_time;
        
        if (_callback) {
            _callback(_elapsed);
        }
        
        return _elapsed;
    }
    
    void restart() {
        _start_time = HighResTimePoint::now();
        _active = true;
    }
    
    Duration elapsed() const {
        if (!_active) {
            return _elapsed;
        }
        
        return HighResTimePoint::now() - _start_time;
    }
    
    // Deleted copy/move operations to prevent double-stopping
    ScopedTimer(const ScopedTimer&) = delete;
    ScopedTimer& operator=(const ScopedTimer&) = delete;
    ScopedTimer(ScopedTimer&&) = delete;
    ScopedTimer& operator=(ScopedTimer&&) = delete;
    
private:
    HighResTimePoint _start_time;
    TimerCallback _callback;
    Duration _elapsed{0};
    bool _active;
};

class LogTimer {
public:
    explicit LogTimer(std::string reason)
        : _reason(std::move(reason))
        , _timer([this](Duration duration) {
              qb::io::cout() << _reason << ": " << duration.microseconds() << "us" << std::endl;
          }) {}
          
    Duration elapsed() const {
        return _timer.elapsed();
    }
    
private:
    std::string _reason;
    ScopedTimer _timer;
};
 
} // namespace qb
 
// Stream operators
inline std::ostream& operator<<(std::ostream& os, const qb::TimePoint& tp) {
    return os << tp.to_iso8601();
}

inline std::ostream& operator<<(std::ostream& os, const qb::Duration& d) {
    auto seconds = d.seconds();
    auto nanoseconds = d.nanoseconds() % 1000000000LL;
    
    if (nanoseconds == 0) {
        return os << seconds << "s";
    } else if (nanoseconds % 1000000LL == 0) {
        return os << seconds << "s " << (nanoseconds / 1000000LL) << "ms";
    } else if (nanoseconds % 1000LL == 0) {
        return os << seconds << "s " << (nanoseconds / 1000LL) << "us";
    } else {
        return os << seconds << "s " << nanoseconds << "ns";
    }
}
 
// Hash support for unordered containers
namespace std {
    template<>
    struct hash<qb::Duration> {
        size_t operator()(const qb::Duration& duration) const noexcept {
            return std::hash<int64_t>{}(duration.count());
        }
    };
    
    template<>
    struct hash<qb::TimePoint> {
        size_t operator()(const qb::TimePoint& time_point) const noexcept {
            return std::hash<uint64_t>{}(time_point.count());
        }
    };
}
 
// std::formatter support (C++20)
#if __cplusplus >= 202002L
namespace std {
    template<>
    struct formatter<qb::TimePoint> {
        constexpr auto parse(format_parse_context& ctx) {
            return ctx.begin();
        }
        
        auto format(const qb::TimePoint& tp, format_context& ctx) const {
            return format_to(ctx.out(), "{}", tp.to_iso8601());
        }
    };
    
    template<>
    struct formatter<qb::Duration> {
        constexpr auto parse(format_parse_context& ctx) {
            return ctx.begin();
        }
        
        auto format(const qb::Duration& d, format_context& ctx) const {
            auto seconds = d.seconds();
            auto nanoseconds = d.nanoseconds() % 1000000000LL;
            
            if (nanoseconds == 0) {
                return format_to(ctx.out(), "{}s", seconds);
            } else if (nanoseconds % 1000000LL == 0) {
                return format_to(ctx.out(), "{}s {}ms", seconds, nanoseconds / 1000000LL);
            } else if (nanoseconds % 1000LL == 0) {
                return format_to(ctx.out(), "{}s {}us", seconds, nanoseconds / 1000LL);
            } else {
                return format_to(ctx.out(), "{}s {}ns", seconds, nanoseconds);
            }
        }
    };
}
#endif
 
#endif // FEATURES_TIMESTAMP_H