packet.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_PACKET_HPP
#define XCLOX_PACKET_HPP
 
#include "coder.hpp"
#include "timestamp.hpp"
 
#include <algorithm>
#include <array>
#include <memory>
 
namespace xclox {
 
namespace ntp {
 
    namespace internal {
        using DataType = std::array<uint8_t, 48>;
 
        inline bool isZeroed(const DataType& data)
        {
            return !std::any_of(data.cbegin(), data.cend(), [](int x) { return x; });
        }
 
        inline std::shared_ptr<const DataType> pointerize(const DataType& data)
        {
            return isZeroed(data) ? nullptr : std::make_shared<const DataType>(data);
        }
    }
 
    class Packet {
    public:
        using DataType = internal::DataType; 
 
        explicit Packet(uint8_t leap, uint8_t version, uint8_t mode, uint8_t stratum, int8_t poll, int8_t precision, uint32_t rootDelay, uint32_t rootDispersion, uint32_t referenceID, uint64_t referenceTimestamp, uint64_t originTimestamp, uint64_t receiveTimestamp, uint64_t transmitTimestamp)
        {
            DataType d;
            Coder::serialize<uint8_t>(static_cast<uint8_t>(leap << 6 | version << 3 | mode), &d[0]);
            Coder::serialize<uint8_t>(stratum, &d[1]);
            Coder::serialize<uint8_t>(static_cast<uint8_t>(poll), &d[2]);
            Coder::serialize<uint8_t>(static_cast<uint8_t>(precision), &d[3]);
            Coder::serialize<uint32_t>(rootDelay, &d[4]);
            Coder::serialize<uint32_t>(rootDispersion, &d[8]);
            Coder::serialize<uint32_t>(referenceID, &d[12]);
            Coder::serialize<uint64_t>(referenceTimestamp, &d[16]);
            Coder::serialize<uint64_t>(originTimestamp, &d[24]);
            Coder::serialize<uint64_t>(receiveTimestamp, &d[32]);
            Coder::serialize<uint64_t>(transmitTimestamp, &d[40]);
            m_data = internal::pointerize(d);
        }
 
        explicit Packet(const DataType& data)
            : m_data(internal::pointerize(data))
        {
        }
 
        Packet() = default;
 
        ~Packet() = default;
 
        Packet(const Packet&) = default;
 
        Packet(Packet&&) = default;
 
        Packet& operator=(const Packet&) = delete;
 
        Packet& operator=(Packet&&) = delete;
 
        bool operator==(const Packet& other) const
        {
            return m_data && other.m_data ? *m_data == *other.m_data : isNull() && other.isNull();
        }
 
        bool operator!=(const Packet& other) const
        {
            return !operator==(other);
        }
 
        DataType data() const
        {
            return m_data ? *m_data : DataType {};
        }
 
        bool isNull() const
        {
            return !m_data || internal::isZeroed(*m_data);
        }
 
        uint8_t leap() const
        {
            return static_cast<uint8_t>(m_data ? m_data->at(0) >> 6 : 0);
        }
 
        uint8_t version() const
        {
            return static_cast<uint8_t>(m_data ? m_data->at(0) >> 3 & 7 : 0);
        }
 
        uint8_t mode() const
        {
            return static_cast<uint8_t>(m_data ? m_data->at(0) & 7 : 0);
        }
 
        uint8_t stratum() const
        {
            return static_cast<uint8_t>(m_data ? m_data->at(1) : 0);
        }
 
        int8_t poll() const
        {
            return m_data ? static_cast<int8_t>(m_data->at(2)) : 0;
        }
 
        int8_t precision() const
        {
            return m_data ? static_cast<int8_t>(m_data->at(3)) : 0;
        }
 
        uint32_t rootDelay() const
        {
            return m_data ? Coder::deserialize<uint32_t>(&m_data->at(4)) : 0;
        }
 
        uint32_t rootDispersion() const
        {
            return m_data ? Coder::deserialize<uint32_t>(&m_data->at(8)) : 0;
        }
 
        uint32_t referenceID() const
        {
            return m_data ? Coder::deserialize<uint32_t>(&m_data->at(12)) : 0;
        }
 
        uint64_t referenceTimestamp() const
        {
            return m_data ? Coder::deserialize<uint64_t>(&m_data->at(16)) : 0;
        }
 
        uint64_t originTimestamp() const
        {
            return m_data ? Coder::deserialize<uint64_t>(&m_data->at(24)) : 0;
        }
 
        uint64_t receiveTimestamp() const
        {
            return m_data ? Coder::deserialize<uint64_t>(&m_data->at(32)) : 0;
        }
 
        uint64_t transmitTimestamp() const
        {
            return m_data ? Coder::deserialize<uint64_t>(&m_data->at(40)) : 0;
        }
 
        std::chrono::system_clock::duration delay(uint64_t destination) const
        {
            return (Timestamp(destination - originTimestamp())) - (Timestamp(transmitTimestamp() - receiveTimestamp()));
        }
 
        std::chrono::system_clock::duration offset(uint64_t destination) const
        {
            return ((Timestamp(receiveTimestamp()) - Timestamp(originTimestamp())) + (Timestamp(transmitTimestamp()) - Timestamp(destination))) / 2;
        }
 
        std::chrono::system_clock::duration offset(const std::chrono::system_clock::time_point& destination) const
        {
            const auto& rawOffset = offset(Timestamp(destination.time_since_epoch() + internal::EpochDeltaSeconds).value());
            return std::chrono::seconds(static_cast<int32_t>(std::chrono::duration_cast<std::chrono::seconds>(rawOffset).count())) + rawOffset % std::chrono::seconds(1);
        }
 
    private:
        std::shared_ptr<const internal::DataType> m_data;
    };
 
} // namespace ntp
 
} // namespace xclox
 
#endif // XCLOX_PACKET_HPP