message_output.h

Go to the documentation of this file.

// Copyright (c) Space-ng, inc. All rights reserved.
#pragma once
 
#include "sol3/core/any_message_output.h"
#include "sol3/core/message_serializer.h"
#include "sol3/core/message_spec.h"
#include "sol3/core/time.h"
 
#include <utility>
 
namespace sol3::core {
 
template <typename TMessageSpec>
class MessageOutput : public AnyMessageOutput {
  static_assert(
      is_message_spec<TMessageSpec>::value,
      "TMessageSpec must be sol3::core::MessageSpec<...>");
 
 public:
  using TableType = typename TMessageSpec::TableType;
  using NativeTableType = typename TableType::NativeTableType;
  using Builder = typename TableType::Builder;
 
  MessageOutput(
      IBufferExchange& exchange,
      uint32_t component_id,
      size_t slot_count,
      size_t slot_size)
      : sol3::core::AnyMessageOutput(
            exchange,
            TMessageSpec::makeMessagePort(component_id),
            MessageSchema(
                NativeTableType::GetSchemaData(),
                MessageSchema::EvolutionPolicy::FORWARDS_COMPATIBLE),
            slot_count,
            slot_size),
        serializer_(port()) {}
 
  msg::MessageHeaderT const& header() const { return serializer_.header(); }
 
  NativeTableType& payload() { return payload_; }
  NativeTableType const& payload() const { return payload_; }
 
  // This points to the serialized payload root inside of the last written to
  // slot in shared memory.
  TableType const* payloadRoot() const {
    return AnyMessageOutput::payloadRoot<TableType>();
  }
 
  void addStamp(msg::Stamp const& stamp) { serializer_.addStamp(stamp); }
 
  uint64_t write() {
    stage();
    return writeStaged();
  }
 
  size_t stage() { return serializer_.finishPayload(payload_, sendStampNow()); }
 
  uint64_t writeStaged() {
    return AnyMessageOutput::write(
        serializer_.headerSpan(), serializer_.payloadSpan());
  }
 
  //    (flatbuffers::FlatBufferBuilder& fbb) -> flatbuffers::Offset<TableType>
  template <typename TBuilderFunction>
  uint64_t write(TBuilderFunction&& builder_function) {
    stage(std::forward<TBuilderFunction>(builder_function));
    return writeStaged();
  }
 
  template <typename TBuilderFunction>
  size_t stage(TBuilderFunction&& builder_function) {
    return serializer_.finishPayload<TableType, TBuilderFunction>(
        std::forward<TBuilderFunction>(builder_function), sendStampNow());
  }
 
 private:
  MessageSerializer serializer_;
  NativeTableType payload_;
};
 
}  // namespace sol3::core