message_generated.h

Go to the documentation of this file.

// automatically generated by the FlatBuffers compiler, do not modify
 
 
#ifndef FLATBUFFERS_GENERATED_MESSAGE_ENCRYPTO_MOTION_COMMUNICATION_H_
#define FLATBUFFERS_GENERATED_MESSAGE_ENCRYPTO_MOTION_COMMUNICATION_H_
 
#include "flatbuffers/flatbuffers.h"
 
namespace encrypto {
namespace motion {
namespace communication {
 
struct Message;
struct MessageBuilder;
 
enum class MessageType : uint8_t {
  kHelloMessage = 0,
  kOutputMessage = 1,
  kTerminationMessage = 2,
  kSynchronizationMessage = 3,
  kBaseROtMessageSender = 4,
  kBaseROtMessageReceiver = 5,
  kOtExtensionReceiverMasks = 6,
  kOtExtensionReceiverCorrections = 7,
  kOtExtensionSender = 8,
  kBmrInputGate0 = 9,
  kBmrInputGate1 = 10,
  kBmrAndGate = 11,
  kSharedBitsMask = 12,
  kSharedBitsReconstruct = 13,
  MIN = kHelloMessage,
  MAX = kSharedBitsReconstruct
};
 
inline const MessageType (&EnumValuesMessageType())[14] {
  static const MessageType values[] = {
    MessageType::kHelloMessage,
    MessageType::kOutputMessage,
    MessageType::kTerminationMessage,
    MessageType::kSynchronizationMessage,
    MessageType::kBaseROtMessageSender,
    MessageType::kBaseROtMessageReceiver,
    MessageType::kOtExtensionReceiverMasks,
    MessageType::kOtExtensionReceiverCorrections,
    MessageType::kOtExtensionSender,
    MessageType::kBmrInputGate0,
    MessageType::kBmrInputGate1,
    MessageType::kBmrAndGate,
    MessageType::kSharedBitsMask,
    MessageType::kSharedBitsReconstruct
  };
  return values;
}
 
inline const char * const *EnumNamesMessageType() {
  static const char * const names[15] = {
    "kHelloMessage",
    "kOutputMessage",
    "kTerminationMessage",
    "kSynchronizationMessage",
    "kBaseROtMessageSender",
    "kBaseROtMessageReceiver",
    "kOtExtensionReceiverMasks",
    "kOtExtensionReceiverCorrections",
    "kOtExtensionSender",
    "kBmrInputGate0",
    "kBmrInputGate1",
    "kBmrAndGate",
    "kSharedBitsMask",
    "kSharedBitsReconstruct",
    nullptr
  };
  return names;
}
 
inline const char *EnumNameMessageType(MessageType e) {
  if (flatbuffers::IsOutRange(e, MessageType::kHelloMessage, MessageType::kSharedBitsReconstruct)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesMessageType()[index];
}
 
struct Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef MessageBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_MESSAGE_TYPE = 4,
    VT_PAYLOAD = 6
  };
  encrypto::motion::communication::MessageType message_type() const {
    return static_cast<encrypto::motion::communication::MessageType>(GetField<uint8_t>(VT_MESSAGE_TYPE, 0));
  }
  const flatbuffers::Vector<uint8_t> *payload() const {
    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_PAYLOAD);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_MESSAGE_TYPE) &&
           VerifyOffset(verifier, VT_PAYLOAD) &&
           verifier.VerifyVector(payload()) &&
           verifier.EndTable();
  }
};
 
struct MessageBuilder {
  typedef Message Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_message_type(encrypto::motion::communication::MessageType message_type) {
    fbb_.AddElement<uint8_t>(Message::VT_MESSAGE_TYPE, static_cast<uint8_t>(message_type), 0);
  }
  void add_payload(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> payload) {
    fbb_.AddOffset(Message::VT_PAYLOAD, payload);
  }
  explicit MessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  MessageBuilder &operator=(const MessageBuilder &);
  flatbuffers::Offset<Message> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<Message>(end);
    return o;
  }
};
 
inline flatbuffers::Offset<Message> CreateMessage(
    flatbuffers::FlatBufferBuilder &_fbb,
    encrypto::motion::communication::MessageType message_type = encrypto::motion::communication::MessageType::kHelloMessage,
    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> payload = 0) {
  MessageBuilder builder_(_fbb);
  builder_.add_payload(payload);
  builder_.add_message_type(message_type);
  return builder_.Finish();
}
 
inline flatbuffers::Offset<Message> CreateMessageDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    encrypto::motion::communication::MessageType message_type = encrypto::motion::communication::MessageType::kHelloMessage,
    const std::vector<uint8_t> *payload = nullptr) {
  auto payload__ = payload ? _fbb.CreateVector<uint8_t>(*payload) : 0;
  return encrypto::motion::communication::CreateMessage(
      _fbb,
      message_type,
      payload__);
}
 
inline const encrypto::motion::communication::Message *GetMessage(const void *buf) {
  return flatbuffers::GetRoot<encrypto::motion::communication::Message>(buf);
}
 
inline const encrypto::motion::communication::Message *GetSizePrefixedMessage(const void *buf) {
  return flatbuffers::GetSizePrefixedRoot<encrypto::motion::communication::Message>(buf);
}
 
inline bool VerifyMessageBuffer(
    flatbuffers::Verifier &verifier) {
  return verifier.VerifyBuffer<encrypto::motion::communication::Message>(nullptr);
}
 
inline bool VerifySizePrefixedMessageBuffer(
    flatbuffers::Verifier &verifier) {
  return verifier.VerifySizePrefixedBuffer<encrypto::motion::communication::Message>(nullptr);
}
 
inline void FinishMessageBuffer(
    flatbuffers::FlatBufferBuilder &fbb,
    flatbuffers::Offset<encrypto::motion::communication::Message> root) {
  fbb.Finish(root);
}
 
inline void FinishSizePrefixedMessageBuffer(
    flatbuffers::FlatBufferBuilder &fbb,
    flatbuffers::Offset<encrypto::motion::communication::Message> root) {
  fbb.FinishSizePrefixed(root);
}
 
}  // namespace communication
}  // namespace motion
}  // namespace encrypto
 
#endif  // FLATBUFFERS_GENERATED_MESSAGE_ENCRYPTO_MOTION_COMMUNICATION_H_