FrameSerializer.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cstddef>
#include <cstring>
#include <span>
#include <vector>
 
#include <vulcan/core/VulcanError.hpp>
#include <vulcan/io/Frame.hpp>
#include <vulcan/io/TelemetrySchema.hpp>
 
namespace vulcan::io {

class FrameSerializer {
  public:
    explicit FrameSerializer(const TelemetrySchema &schema)
        : schema_(schema),
          dynamic_buffer_(8 + schema.dynamic_frame_size_bytes()),
          static_buffer_(schema.static_frame_size_bytes()) {
        // Build offset maps for dynamic and static signals
        size_t dynamic_offset = 8; // After time
        size_t static_offset = 0;
 
        for (const auto &sig : schema.signals()) {
            if (sig.lifecycle == SignalLifecycle::Dynamic) {
                dynamic_offsets_.push_back({sig.offset, dynamic_offset});
                dynamic_offset += 8;
            } else {
                static_offsets_.push_back({sig.offset, static_offset});
                static_offset += 8;
            }
        }
    }

    std::span<const std::byte> serialize(const Frame &frame) {
        // Write time
        double time = frame.time();
        std::memcpy(dynamic_buffer_.data(), &time, sizeof(double));
 
        // Write dynamic signals
        for (const auto &[src_offset, dst_offset] : dynamic_offsets_) {
            std::memcpy(dynamic_buffer_.data() + dst_offset,
                        frame.data() + src_offset, 8);
        }
 
        return std::span<const std::byte>(dynamic_buffer_);
    }

    std::span<const std::byte> serialize_statics(const Frame &frame) {
        for (const auto &[src_offset, dst_offset] : static_offsets_) {
            std::memcpy(static_buffer_.data() + dst_offset,
                        frame.data() + src_offset, 8);
        }
        return std::span<const std::byte>(static_buffer_);
    }

    void deserialize(std::span<const std::byte> data, Frame &frame) {
        if (data.size() < 8) {
            throw vulcan::SignalError("Invalid frame data: too small");
        }
 
        // Read time
        double time;
        std::memcpy(&time, data.data(), sizeof(double));
        frame.set_time(time);
 
        // Read dynamic signals
        for (const auto &[src_offset, dst_offset] : dynamic_offsets_) {
            if (dst_offset + 8 > data.size()) {
                throw vulcan::SignalError(
                    "Invalid frame data: incomplete signal data");
            }
            std::memcpy(frame.data() + src_offset, data.data() + dst_offset, 8);
        }
    }

    void deserialize_statics(std::span<const std::byte> data, Frame &frame) {
        for (const auto &[src_offset, dst_offset] : static_offsets_) {
            if (dst_offset + 8 > data.size()) {
                throw vulcan::SignalError(
                    "Invalid static data: incomplete signal data");
            }
            std::memcpy(frame.data() + src_offset, data.data() + dst_offset, 8);
        }
    }

    size_t dynamic_size_bytes() const { return dynamic_buffer_.size(); }

    size_t static_size_bytes() const { return static_buffer_.size(); }

    const TelemetrySchema &schema() const { return schema_; }
 
  private:
    TelemetrySchema schema_;
    std::vector<std::byte> dynamic_buffer_;
    std::vector<std::byte> static_buffer_;
 
    // Maps: (frame buffer offset, serialized buffer offset)
    std::vector<std::pair<size_t, size_t>> dynamic_offsets_;
    std::vector<std::pair<size_t, size_t>> static_offsets_;
};
 
} // namespace vulcan::io