ntptime.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_NETWORK
#include <chrono>
#include <cstdint>
#include <promeki/duration.h>
#include <promeki/namespace.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class NtpTime {
        public:
                static constexpr uint64_t UnixEpochOffsetSeconds = 2208988800ULL;
 
                NtpTime() = default;
 
                NtpTime(uint32_t sec, uint32_t frac) : _seconds(sec), _fraction(frac) {}
 
                static NtpTime now() { return fromSystemClock(std::chrono::system_clock::now()); }
 
                static NtpTime fromSystemClock(std::chrono::system_clock::time_point tp) {
                        // system_clock has implementation-defined epoch
                        // (Unix 1970-01-01 on every platform we ship to).
                        // Bridge to NTP via the constant above.
                        const auto nsSinceUnix =
                                std::chrono::duration_cast<std::chrono::nanoseconds>(tp.time_since_epoch()).count();
                        // Negative inputs (pre-1970) clamp to NTP epoch
                        // because NtpTime is unsigned.
                        if (nsSinceUnix < 0) return NtpTime(0, 0);
                        const uint64_t totalNs = static_cast<uint64_t>(nsSinceUnix) +
                                                 (UnixEpochOffsetSeconds * 1'000'000'000ULL);
                        const uint64_t secs = totalNs / 1'000'000'000ULL;
                        const uint64_t remNs = totalNs % 1'000'000'000ULL;
                        // fraction = remNs * 2^32 / 1e9.  Compute with
                        // 64-bit intermediate so the 2^32 multiply
                        // doesn't overflow.
                        const uint64_t frac = (remNs << 32) / 1'000'000'000ULL;
                        return NtpTime(static_cast<uint32_t>(secs & 0xFFFFFFFFu),
                                       static_cast<uint32_t>(frac & 0xFFFFFFFFu));
                }
 
                uint32_t seconds() const { return _seconds; }
 
                uint32_t fraction() const { return _fraction; }
 
                uint64_t toUint64() const {
                        return (static_cast<uint64_t>(_seconds) << 32) | static_cast<uint64_t>(_fraction);
                }
 
                uint32_t toCompact32() const { return ((_seconds & 0xFFFFu) << 16) | (_fraction >> 16); }
 
                bool isValid() const { return _seconds != 0 || _fraction != 0; }
 
                bool operator==(const NtpTime &o) const { return _seconds == o._seconds && _fraction == o._fraction; }
                bool operator!=(const NtpTime &o) const { return !(*this == o); }
 
                NtpTime operator+(const Duration &d) const {
                        const int64_t  ns = d.nanoseconds();
                        const uint64_t packed = (static_cast<uint64_t>(_seconds) << 32) |
                                                static_cast<uint64_t>(_fraction);
                        // Split the offset into whole-seconds + sub-
                        // second nanoseconds.  Each piece converts to
                        // the 1/2^32-second packed representation
                        // independently, so the intermediate never
                        // overflows 64 bits even when the user hands
                        // us a multi-day duration:
                        //   * wholeSec contributes wholeSec << 32.
                        //   * subNs ∈ (-1e9, +1e9) maps via
                        //     subNs * 2^32 / 1e9 — and 1e9 * 2^32 fits
                        //     in 63 bits (≈ 4.29e18 < 2^63).
                        // Sums happen in uint64_t (well-defined modular
                        // arithmetic) — overflow at the 2^64 boundary
                        // wraps the same way NTP receivers handle
                        // wraparound across the 2^32-second epoch.
                        const int64_t  wholeSec = ns / 1'000'000'000;
                        const int64_t  subNs    = ns % 1'000'000'000;
                        const int64_t  subFrac  = (subNs << 32) / 1'000'000'000;
                        const uint64_t deltaPacked =
                                (static_cast<uint64_t>(wholeSec) << 32) + static_cast<uint64_t>(subFrac);
                        const uint64_t result = packed + deltaPacked;
                        return NtpTime(static_cast<uint32_t>(result >> 32) & 0xFFFFFFFFu,
                                       static_cast<uint32_t>(result & 0xFFFFFFFFu));
                }
 
                NtpTime operator-(const Duration &d) const { return *this + (-d); }
 
        private:
                uint32_t _seconds = 0;
                uint32_t _fraction = 0;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_NETWORK