packet.hpp

Go to the documentation of this file.

#pragma once
#include "../common.hpp"
#include <cereal/archives/portable_binary.hpp>
#include <cereal/types/map.hpp>
#include <cereal/types/vector.hpp>
#include <cereal/types/string.hpp>
namespace mal_packet_weaver
{
    class Packet;
 
    using PacketSubsystemID = uint16_t;  
    using PacketID = uint16_t;           
 
    using UniquePacketID = uint32_t;
 
    using PacketDeserializeFunc = std::function<std::unique_ptr<Packet>(const ByteView)>;
 
    constexpr uint32_t PacketSubsystemIDToUint32(PacketSubsystemID subsystem_type) noexcept
    {
        return static_cast<uint32_t>(subsystem_type) << 16;
    }
 
    constexpr PacketSubsystemID UniquePacketIDToPacketSubsystemID(UniquePacketID subsystem_type) noexcept
    {
        return static_cast<PacketSubsystemID>((subsystem_type & 0xFFFF0000) >> 16);
    }
 
    constexpr PacketID UniquePacketIDToPacketID(UniquePacketID subsystem_type) noexcept
    {
        return static_cast<PacketID>(subsystem_type & 0xFFFF);
    }
 
    constexpr UniquePacketID CreatePacketID(PacketSubsystemID subsystem_id, PacketID packet_id) noexcept
    {
        return (static_cast<UniquePacketID>(subsystem_id) << 16) | packet_id;
    }
 
    class Packet : public non_copyable
    {
    private:
        static Measurer<std::chrono::steady_clock> measurer;  
    public:
        explicit Packet(const UniquePacketID type, const float time_to_live)
            : type(type), time_to_live(time_to_live), timestamp_{ measurer.elapsed() }
        {
        }
 
        Packet(Packet &&) = default;
        Packet &operator=(Packet &&) = default;
 
 
        virtual ~Packet() = default;
 
        virtual const char* packet_name() const = 0;
 
        virtual void serialize_to_bytearray(ByteArray &buffer) const = 0;
 
        [[nodiscard]] float timestamp() const noexcept { return timestamp_; }
 
        [[nodiscard]] float get_packet_time_alive() const noexcept { return measurer.elapsed() - timestamp_; }
 
        [[nodiscard]] bool expired() const noexcept { return get_packet_time_alive() > time_to_live; }
 
        const UniquePacketID type;  
        const float time_to_live;   
        const float timestamp_;     
 
    private:
        friend class cereal::access;
        // Base serialize method for classes.
        // This may be used for empty packets, so there's minimum boilerplate in packets.
        // This will just return an empty payload.
        template <class Archive>
        void serialize(Archive &, const unsigned int)
        {
        }
    };
 
    template <typename PacketType>
    class DerivedPacket : public Packet
    {
    public:
        DerivedPacket() : Packet(PacketType::static_unique_id, PacketType::time_to_live) {}
 
        virtual ~DerivedPacket() = default;
 
        void serialize_to_bytearray(ByteArray &buffer) const override
        {
            std::ostringstream oss(std::ios::out | std::ios::binary);
            cereal::PortableBinaryOutputArchive oa(oss);
            oa << static_cast<const PacketType &>(*this);
            std::string const &s = oss.str();
            buffer.append(s);
        }
 
        [[nodiscard]] static std::unique_ptr<Packet> deserialize(const ByteView buffer)
        {
            const auto char_view = buffer.as<char>();
            const std::string s(char_view, buffer.size());
            std::istringstream iss(s, std::ios::in | std::ios::binary);
            cereal::PortableBinaryInputArchive ia(iss);
            std::unique_ptr<PacketType> derived_packet = std::make_unique<PacketType>();
            ia >> *derived_packet;
            return derived_packet;
        }
    };
 
    template <typename T>
    concept IsPacket = requires(T packet)
    {
        std::is_final_v<T>;
        std::is_base_of_v<DerivedPacket<T>, T>;
        std::same_as<std::decay_t<decltype(T::static_unique_id)>, UniquePacketID>;
        std::same_as<std::decay_t<decltype(T::time_to_live)>, float>;
    };
}  // namespace mal_packet_weaver