message_serializer.h

Go to the documentation of this file.

// Copyright (c) Space-ng, inc. All rights reserved.
 
#pragma once
 
#include "sol3/core/file_identifier.h"
#include "sol3/core/message_spec.h"
#include "sol3/core/msg/message_header.h"
 
#include <type_traits>
 
namespace sol3::core {
 
class MessageHeaderSerializer {
 public:
  MessageHeaderSerializer() = default;
 
  explicit MessageHeaderSerializer(MessagePort port);
 
  void setPort(MessagePort const& port);
 
  MessagePort const& port() const;
 
  msg::MessageHeaderT const& header() const;
 
  void addStamp(msg::Stamp const& stamp);
 
  flatbuffers::span<uint8_t const> headerSpan() const;
 
  size_t finishHeaderFromPayloadBuffer(
      flatbuffers::span<uint8_t const> payload_span, msg::Stamp stamp);
 
 private:
  void validatePayloadIdentifier(
      flatbuffers::span<uint8_t const> payload_span) const;
  size_t finishHeaderForPayloadSize(size_t payload_size, msg::Stamp stamp);
 
  MessagePort port_;
  flatbuffers::FlatBufferBuilder header_builder_;
  msg::MessageHeaderT header_;
};
 
class MessageSerializer {
 public:
  explicit MessageSerializer(MessagePort port);
 
  MessagePort const& port() const { return header_serializer_.port(); }
 
  msg::MessageHeaderT const& header() const {
    return header_serializer_.header();
  }
 
  void addStamp(msg::Stamp const& stamp) { header_serializer_.addStamp(stamp); }
 
  flatbuffers::span<uint8_t const> headerSpan() const {
    return header_serializer_.headerSpan();
  }
 
  size_t finishHeaderFromPayloadBuffer(
      flatbuffers::span<uint8_t const> payload_span, msg::Stamp stamp) {
    return header_serializer_.finishHeaderFromPayloadBuffer(
        payload_span, stamp);
  }
 
  flatbuffers::span<uint8_t const> payloadSpan() const;
 
  template <typename TTableType, typename TBuilderFunction>
  size_t finishPayload(TBuilderFunction&& builder_function, msg::Stamp stamp) {
    using NativeTableType = typename TTableType::NativeTableType;
    static_assert(
        std::is_invocable_r_v<
            flatbuffers::Offset<TTableType>,
            TBuilderFunction,
            flatbuffers::FlatBufferBuilder&>,
        "finishPayload requires a callable with signature "
        "(flatbuffers::FlatBufferBuilder&) -> flatbuffers::Offset<TTableType>");
    if (makeFileIdentifier<typename TTableType::NativeTableType>() !=
        port().payloadType()) {
      throw std::invalid_argument("Invalid payload type.");
    }
    payload_builder_.Clear();
    // We want 64 bit alignment of our buffer.
    payload_builder_.PreAlign<uint64_t>(sizeof(uint64_t));
    payload_builder_.FinishSizePrefixed(
        std::forward<TBuilderFunction>(builder_function)(payload_builder_),
        NativeTableType::GetIdentifier());
    return finishHeaderFromPayloadBuffer(payloadSpan(), stamp);
  }
 
  template <typename TNativeTableType>
  size_t finishPayload(TNativeTableType const& payload, msg::Stamp stamp) {
    using TableType = typename TNativeTableType::TableType;
    return finishPayload<TableType>(
        [&payload](flatbuffers::FlatBufferBuilder& builder) {
          return TableType::Pack(builder, &payload);
        },
        stamp);
  }
 
 private:
  MessageHeaderSerializer header_serializer_;
  flatbuffers::FlatBufferBuilder payload_builder_;
};
 
}  // namespace sol3::core