timestamp.hpp

/*
 * Copyright (c) 2024 Abdullatif Kalla.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE.txt file in the root directory of this source tree.
 */
 
#ifndef XCLOX_TIMESTAMP_HPP
#define XCLOX_TIMESTAMP_HPP
 
#include <chrono>
 
namespace xclox {
 
namespace ntp {
 
    namespace internal {
        constexpr std::chrono::seconds EpochDeltaSeconds { 0x83AA7E80 };
    }
 
    class Timestamp {
    public:
        explicit Timestamp(uint64_t value = 0)
            : m_data(value)
        {
        }
 
        explicit Timestamp(uint32_t seconds, uint32_t fraction)
            : m_data((static_cast<uint64_t>(seconds) << 32) | fraction)
        {
        }
 
        explicit Timestamp(std::chrono::system_clock::duration duration)
            : m_data(durationToValue(duration))
        {
        }
 
        explicit Timestamp(std::chrono::system_clock::time_point timePoint)
            : m_data(durationToValue(timePoint.time_since_epoch() + internal::EpochDeltaSeconds))
        {
        }
 
        uint32_t seconds() const
        {
            return static_cast<uint32_t>(m_data >> 32);
        }
 
        uint32_t fraction() const
        {
            return static_cast<uint32_t>(m_data);
        }
 
        uint64_t value() const
        {
            return m_data;
        }
 
        std::chrono::system_clock::duration duration() const
        {
            return std::chrono::seconds(seconds()) + std::chrono::system_clock::duration(static_cast<int>(DurationRange * fraction() / FractionRange));
        }
 
        bool operator==(const Timestamp& other) const
        {
            return m_data == other.m_data;
        }
 
        bool operator!=(const Timestamp& other) const
        {
            return !operator==(other);
        }
 
        std::chrono::system_clock::duration operator-(const Timestamp& other) const
        {
            return duration() - other.duration();
        }
 
    private:
        static constexpr auto FractionRange { std::numeric_limits<uint32_t>::max() + 1.0 };
        static constexpr auto DurationRange { static_cast<double>(std::chrono::system_clock::period::den) };
        static constexpr uint64_t durationToValue(const std::chrono::system_clock::duration& duration)
        {
            return static_cast<uint64_t>(std::chrono::duration_cast<std::chrono::seconds>(duration).count()) << 32
                | static_cast<uint32_t>(FractionRange * static_cast<double>((duration % std::chrono::seconds(1)).count()) / DurationRange);
        }
 
        uint64_t m_data;
    };
 
} // namespace ntp
 
} // namespace xclox
 
#endif // XCLOX_TIMESTAMP_HPP