hpcore/src/fbschema/p2pmsg_content_generated.h

// automatically generated by the FlatBuffers compiler, do not modify


#ifndef FLATBUFFERS_GENERATED_P2PMSGCONTENT_FBSCHEMA_P2PMSG_
#define FLATBUFFERS_GENERATED_P2PMSGCONTENT_FBSCHEMA_P2PMSG_

#include "flatbuffers/flatbuffers.h"

#include "common_schema_generated.h"

namespace fbschema {
namespace p2pmsg {

struct RawInputList;

struct RawOutput;

struct Content;

struct Proposal_Message;

struct Npl_Message;

struct StateDifference;

struct State;

enum Message {
  Message_NONE = 0,
  Message_Proposal_Message = 1,
  Message_Npl_Message = 2,
  Message_MIN = Message_NONE,
  Message_MAX = Message_Npl_Message
};

inline const Message (&EnumValuesMessage())[3] {
  static const Message values[] = {
    Message_NONE,
    Message_Proposal_Message,
    Message_Npl_Message
  };
  return values;
}

inline const char * const *EnumNamesMessage() {
  static const char * const names[] = {
    "NONE",
    "Proposal_Message",
    "Npl_Message",
    nullptr
  };
  return names;
}

inline const char *EnumNameMessage(Message e) {
  if (e < Message_NONE || e > Message_Npl_Message) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesMessage()[index];
}

template<typename T> struct MessageTraits {
  static const Message enum_value = Message_NONE;
};

template<> struct MessageTraits<Proposal_Message> {
  static const Message enum_value = Message_Proposal_Message;
};

template<> struct MessageTraits<Npl_Message> {
  static const Message enum_value = Message_Npl_Message;
};

bool VerifyMessage(flatbuffers::Verifier &verifier, const void *obj, Message type);
bool VerifyMessageVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);

struct RawInputList FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_PUBKEY = 4,
    VT_INPUTS = 6
  };
  const flatbuffers::Vector<uint8_t> *pubkey() const {
    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_PUBKEY);
  }
  flatbuffers::Vector<uint8_t> *mutable_pubkey() {
    return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_PUBKEY);
  }
  const flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>> *inputs() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>> *>(VT_INPUTS);
  }
  flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>> *mutable_inputs() {
    return GetPointer<flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>> *>(VT_INPUTS);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_PUBKEY) &&
           verifier.VerifyVector(pubkey()) &&
           VerifyOffset(verifier, VT_INPUTS) &&
           verifier.VerifyVector(inputs()) &&
           verifier.VerifyVectorOfTables(inputs()) &&
           verifier.EndTable();
  }
};

struct RawInputListBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_pubkey(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> pubkey) {
    fbb_.AddOffset(RawInputList::VT_PUBKEY, pubkey);
  }
  void add_inputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>>> inputs) {
    fbb_.AddOffset(RawInputList::VT_INPUTS, inputs);
  }
  explicit RawInputListBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  RawInputListBuilder &operator=(const RawInputListBuilder &);
  flatbuffers::Offset<RawInputList> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<RawInputList>(end);
    return o;
  }
};

inline flatbuffers::Offset<RawInputList> CreateRawInputList(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> pubkey = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>>> inputs = 0) {
  RawInputListBuilder builder_(_fbb);
  builder_.add_inputs(inputs);
  builder_.add_pubkey(pubkey);
  return builder_.Finish();
}

inline flatbuffers::Offset<RawInputList> CreateRawInputListDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<uint8_t> *pubkey = nullptr,
    const std::vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>> *inputs = nullptr) {
  auto pubkey__ = pubkey ? _fbb.CreateVector<uint8_t>(*pubkey) : 0;
  auto inputs__ = inputs ? _fbb.CreateVector<flatbuffers::Offset<fbschema::BytesKeyValuePair>>(*inputs) : 0;
  return fbschema::p2pmsg::CreateRawInputList(
      _fbb,
      pubkey__,
      inputs__);
}

struct RawOutput FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_PUBKEY = 4,
    VT_OUTPUT = 6
  };
  const flatbuffers::Vector<uint8_t> *pubkey() const {
    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_PUBKEY);
  }
  flatbuffers::Vector<uint8_t> *mutable_pubkey() {
    return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_PUBKEY);
  }
  const fbschema::BytesKeyValuePair *output() const {
    return GetPointer<const fbschema::BytesKeyValuePair *>(VT_OUTPUT);
  }
  fbschema::BytesKeyValuePair *mutable_output() {
    return GetPointer<fbschema::BytesKeyValuePair *>(VT_OUTPUT);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_PUBKEY) &&
           verifier.VerifyVector(pubkey()) &&
           VerifyOffset(verifier, VT_OUTPUT) &&
           verifier.VerifyTable(output()) &&
           verifier.EndTable();
  }
};

struct RawOutputBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_pubkey(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> pubkey) {
    fbb_.AddOffset(RawOutput::VT_PUBKEY, pubkey);
  }
  void add_output(flatbuffers::Offset<fbschema::BytesKeyValuePair> output) {
    fbb_.AddOffset(RawOutput::VT_OUTPUT, output);
  }
  explicit RawOutputBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  RawOutputBuilder &operator=(const RawOutputBuilder &);
  flatbuffers::Offset<RawOutput> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<RawOutput>(end);
    return o;
  }
};

inline flatbuffers::Offset<RawOutput> CreateRawOutput(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> pubkey = 0,
    flatbuffers::Offset<fbschema::BytesKeyValuePair> output = 0) {
  RawOutputBuilder builder_(_fbb);
  builder_.add_output(output);
  builder_.add_pubkey(pubkey);
  return builder_.Finish();
}

inline flatbuffers::Offset<RawOutput> CreateRawOutputDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<uint8_t> *pubkey = nullptr,
    flatbuffers::Offset<fbschema::BytesKeyValuePair> output = 0) {
  auto pubkey__ = pubkey ? _fbb.CreateVector<uint8_t>(*pubkey) : 0;
  return fbschema::p2pmsg::CreateRawOutput(
      _fbb,
      pubkey__,
      output);
}

struct Content FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_MESSAGE_TYPE = 4,
    VT_MESSAGE = 6
  };
  Message message_type() const {
    return static_cast<Message>(GetField<uint8_t>(VT_MESSAGE_TYPE, 0));
  }
  bool mutate_message_type(Message _message_type) {
    return SetField<uint8_t>(VT_MESSAGE_TYPE, static_cast<uint8_t>(_message_type), 0);
  }
  const void *message() const {
    return GetPointer<const void *>(VT_MESSAGE);
  }
  template<typename T> const T *message_as() const;
  const Proposal_Message *message_as_Proposal_Message() const {
    return message_type() == Message_Proposal_Message ? static_cast<const Proposal_Message *>(message()) : nullptr;
  }
  const Npl_Message *message_as_Npl_Message() const {
    return message_type() == Message_Npl_Message ? static_cast<const Npl_Message *>(message()) : nullptr;
  }
  void *mutable_message() {
    return GetPointer<void *>(VT_MESSAGE);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_MESSAGE_TYPE) &&
           VerifyOffset(verifier, VT_MESSAGE) &&
           VerifyMessage(verifier, message(), message_type()) &&
           verifier.EndTable();
  }
};

template<> inline const Proposal_Message *Content::message_as<Proposal_Message>() const {
  return message_as_Proposal_Message();
}

template<> inline const Npl_Message *Content::message_as<Npl_Message>() const {
  return message_as_Npl_Message();
}

struct ContentBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_message_type(Message message_type) {
    fbb_.AddElement<uint8_t>(Content::VT_MESSAGE_TYPE, static_cast<uint8_t>(message_type), 0);
  }
  void add_message(flatbuffers::Offset<void> message) {
    fbb_.AddOffset(Content::VT_MESSAGE, message);
  }
  explicit ContentBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ContentBuilder &operator=(const ContentBuilder &);
  flatbuffers::Offset<Content> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<Content>(end);
    return o;
  }
};

inline flatbuffers::Offset<Content> CreateContent(
    flatbuffers::FlatBufferBuilder &_fbb,
    Message message_type = Message_NONE,
    flatbuffers::Offset<void> message = 0) {
  ContentBuilder builder_(_fbb);
  builder_.add_message(message);
  builder_.add_message_type(message_type);
  return builder_.Finish();
}

struct Proposal_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_STAGE = 4,
    VT_TIME = 6,
    VT_LCL = 8,
    VT_USERS = 10,
    VT_RAW_INPUTS = 12,
    VT_HASH_INPUTS = 14,
    VT_RAW_OUTPUTS = 16,
    VT_HASH_OUTPUTS = 18,
    VT_STATE = 20
  };
  uint8_t stage() const {
    return GetField<uint8_t>(VT_STAGE, 0);
  }
  bool mutate_stage(uint8_t _stage) {
    return SetField<uint8_t>(VT_STAGE, _stage, 0);
  }
  uint64_t time() const {
    return GetField<uint64_t>(VT_TIME, 0);
  }
  bool mutate_time(uint64_t _time) {
    return SetField<uint64_t>(VT_TIME, _time, 0);
  }
  const flatbuffers::Vector<uint8_t> *lcl() const {
    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_LCL);
  }
  flatbuffers::Vector<uint8_t> *mutable_lcl() {
    return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_LCL);
  }
  const flatbuffers::Vector<flatbuffers::Offset<fbschema::ByteArray>> *users() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<fbschema::ByteArray>> *>(VT_USERS);
  }
  flatbuffers::Vector<flatbuffers::Offset<fbschema::ByteArray>> *mutable_users() {
    return GetPointer<flatbuffers::Vector<flatbuffers::Offset<fbschema::ByteArray>> *>(VT_USERS);
  }
  const flatbuffers::Vector<flatbuffers::Offset<RawInputList>> *raw_inputs() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<RawInputList>> *>(VT_RAW_INPUTS);
  }
  flatbuffers::Vector<flatbuffers::Offset<RawInputList>> *mutable_raw_inputs() {
    return GetPointer<flatbuffers::Vector<flatbuffers::Offset<RawInputList>> *>(VT_RAW_INPUTS);
  }
  const flatbuffers::Vector<flatbuffers::Offset<fbschema::ByteArray>> *hash_inputs() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<fbschema::ByteArray>> *>(VT_HASH_INPUTS);
  }
  flatbuffers::Vector<flatbuffers::Offset<fbschema::ByteArray>> *mutable_hash_inputs() {
    return GetPointer<flatbuffers::Vector<flatbuffers::Offset<fbschema::ByteArray>> *>(VT_HASH_INPUTS);
  }
  const flatbuffers::Vector<flatbuffers::Offset<RawOutput>> *raw_outputs() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<RawOutput>> *>(VT_RAW_OUTPUTS);
  }
  flatbuffers::Vector<flatbuffers::Offset<RawOutput>> *mutable_raw_outputs() {
    return GetPointer<flatbuffers::Vector<flatbuffers::Offset<RawOutput>> *>(VT_RAW_OUTPUTS);
  }
  const flatbuffers::Vector<flatbuffers::Offset<fbschema::ByteArray>> *hash_outputs() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<fbschema::ByteArray>> *>(VT_HASH_OUTPUTS);
  }
  flatbuffers::Vector<flatbuffers::Offset<fbschema::ByteArray>> *mutable_hash_outputs() {
    return GetPointer<flatbuffers::Vector<flatbuffers::Offset<fbschema::ByteArray>> *>(VT_HASH_OUTPUTS);
  }
  const State *state() const {
    return GetPointer<const State *>(VT_STATE);
  }
  State *mutable_state() {
    return GetPointer<State *>(VT_STATE);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_STAGE) &&
           VerifyField<uint64_t>(verifier, VT_TIME) &&
           VerifyOffset(verifier, VT_LCL) &&
           verifier.VerifyVector(lcl()) &&
           VerifyOffset(verifier, VT_USERS) &&
           verifier.VerifyVector(users()) &&
           verifier.VerifyVectorOfTables(users()) &&
           VerifyOffset(verifier, VT_RAW_INPUTS) &&
           verifier.VerifyVector(raw_inputs()) &&
           verifier.VerifyVectorOfTables(raw_inputs()) &&
           VerifyOffset(verifier, VT_HASH_INPUTS) &&
           verifier.VerifyVector(hash_inputs()) &&
           verifier.VerifyVectorOfTables(hash_inputs()) &&
           VerifyOffset(verifier, VT_RAW_OUTPUTS) &&
           verifier.VerifyVector(raw_outputs()) &&
           verifier.VerifyVectorOfTables(raw_outputs()) &&
           VerifyOffset(verifier, VT_HASH_OUTPUTS) &&
           verifier.VerifyVector(hash_outputs()) &&
           verifier.VerifyVectorOfTables(hash_outputs()) &&
           VerifyOffset(verifier, VT_STATE) &&
           verifier.VerifyTable(state()) &&
           verifier.EndTable();
  }
};

struct Proposal_MessageBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_stage(uint8_t stage) {
    fbb_.AddElement<uint8_t>(Proposal_Message::VT_STAGE, stage, 0);
  }
  void add_time(uint64_t time) {
    fbb_.AddElement<uint64_t>(Proposal_Message::VT_TIME, time, 0);
  }
  void add_lcl(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> lcl) {
    fbb_.AddOffset(Proposal_Message::VT_LCL, lcl);
  }
  void add_users(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<fbschema::ByteArray>>> users) {
    fbb_.AddOffset(Proposal_Message::VT_USERS, users);
  }
  void add_raw_inputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<RawInputList>>> raw_inputs) {
    fbb_.AddOffset(Proposal_Message::VT_RAW_INPUTS, raw_inputs);
  }
  void add_hash_inputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<fbschema::ByteArray>>> hash_inputs) {
    fbb_.AddOffset(Proposal_Message::VT_HASH_INPUTS, hash_inputs);
  }
  void add_raw_outputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<RawOutput>>> raw_outputs) {
    fbb_.AddOffset(Proposal_Message::VT_RAW_OUTPUTS, raw_outputs);
  }
  void add_hash_outputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<fbschema::ByteArray>>> hash_outputs) {
    fbb_.AddOffset(Proposal_Message::VT_HASH_OUTPUTS, hash_outputs);
  }
  void add_state(flatbuffers::Offset<State> state) {
    fbb_.AddOffset(Proposal_Message::VT_STATE, state);
  }
  explicit Proposal_MessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  Proposal_MessageBuilder &operator=(const Proposal_MessageBuilder &);
  flatbuffers::Offset<Proposal_Message> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<Proposal_Message>(end);
    return o;
  }
};

inline flatbuffers::Offset<Proposal_Message> CreateProposal_Message(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint8_t stage = 0,
    uint64_t time = 0,
    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> lcl = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<fbschema::ByteArray>>> users = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<RawInputList>>> raw_inputs = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<fbschema::ByteArray>>> hash_inputs = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<RawOutput>>> raw_outputs = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<fbschema::ByteArray>>> hash_outputs = 0,
    flatbuffers::Offset<State> state = 0) {
  Proposal_MessageBuilder builder_(_fbb);
  builder_.add_time(time);
  builder_.add_state(state);
  builder_.add_hash_outputs(hash_outputs);
  builder_.add_raw_outputs(raw_outputs);
  builder_.add_hash_inputs(hash_inputs);
  builder_.add_raw_inputs(raw_inputs);
  builder_.add_users(users);
  builder_.add_lcl(lcl);
  builder_.add_stage(stage);
  return builder_.Finish();
}

inline flatbuffers::Offset<Proposal_Message> CreateProposal_MessageDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint8_t stage = 0,
    uint64_t time = 0,
    const std::vector<uint8_t> *lcl = nullptr,
    const std::vector<flatbuffers::Offset<fbschema::ByteArray>> *users = nullptr,
    const std::vector<flatbuffers::Offset<RawInputList>> *raw_inputs = nullptr,
    const std::vector<flatbuffers::Offset<fbschema::ByteArray>> *hash_inputs = nullptr,
    const std::vector<flatbuffers::Offset<RawOutput>> *raw_outputs = nullptr,
    const std::vector<flatbuffers::Offset<fbschema::ByteArray>> *hash_outputs = nullptr,
    flatbuffers::Offset<State> state = 0) {
  auto lcl__ = lcl ? _fbb.CreateVector<uint8_t>(*lcl) : 0;
  auto users__ = users ? _fbb.CreateVector<flatbuffers::Offset<fbschema::ByteArray>>(*users) : 0;
  auto raw_inputs__ = raw_inputs ? _fbb.CreateVector<flatbuffers::Offset<RawInputList>>(*raw_inputs) : 0;
  auto hash_inputs__ = hash_inputs ? _fbb.CreateVector<flatbuffers::Offset<fbschema::ByteArray>>(*hash_inputs) : 0;
  auto raw_outputs__ = raw_outputs ? _fbb.CreateVector<flatbuffers::Offset<RawOutput>>(*raw_outputs) : 0;
  auto hash_outputs__ = hash_outputs ? _fbb.CreateVector<flatbuffers::Offset<fbschema::ByteArray>>(*hash_outputs) : 0;
  return fbschema::p2pmsg::CreateProposal_Message(
      _fbb,
      stage,
      time,
      lcl__,
      users__,
      raw_inputs__,
      hash_inputs__,
      raw_outputs__,
      hash_outputs__,
      state);
}

struct Npl_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_PUBKEY = 4,
    VT_TIMESTAMP = 6,
    VT_DATA = 8,
    VT_LCL = 10
  };
  const flatbuffers::Vector<uint8_t> *pubkey() const {
    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_PUBKEY);
  }
  flatbuffers::Vector<uint8_t> *mutable_pubkey() {
    return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_PUBKEY);
  }
  uint64_t timestamp() const {
    return GetField<uint64_t>(VT_TIMESTAMP, 0);
  }
  bool mutate_timestamp(uint64_t _timestamp) {
    return SetField<uint64_t>(VT_TIMESTAMP, _timestamp, 0);
  }
  const flatbuffers::Vector<uint8_t> *data() const {
    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_DATA);
  }
  flatbuffers::Vector<uint8_t> *mutable_data() {
    return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_DATA);
  }
  const flatbuffers::Vector<uint8_t> *lcl() const {
    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_LCL);
  }
  flatbuffers::Vector<uint8_t> *mutable_lcl() {
    return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_LCL);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_PUBKEY) &&
           verifier.VerifyVector(pubkey()) &&
           VerifyField<uint64_t>(verifier, VT_TIMESTAMP) &&
           VerifyOffset(verifier, VT_DATA) &&
           verifier.VerifyVector(data()) &&
           VerifyOffset(verifier, VT_LCL) &&
           verifier.VerifyVector(lcl()) &&
           verifier.EndTable();
  }
};

struct Npl_MessageBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_pubkey(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> pubkey) {
    fbb_.AddOffset(Npl_Message::VT_PUBKEY, pubkey);
  }
  void add_timestamp(uint64_t timestamp) {
    fbb_.AddElement<uint64_t>(Npl_Message::VT_TIMESTAMP, timestamp, 0);
  }
  void add_data(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data) {
    fbb_.AddOffset(Npl_Message::VT_DATA, data);
  }
  void add_lcl(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> lcl) {
    fbb_.AddOffset(Npl_Message::VT_LCL, lcl);
  }
  explicit Npl_MessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  Npl_MessageBuilder &operator=(const Npl_MessageBuilder &);
  flatbuffers::Offset<Npl_Message> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<Npl_Message>(end);
    return o;
  }
};

inline flatbuffers::Offset<Npl_Message> CreateNpl_Message(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> pubkey = 0,
    uint64_t timestamp = 0,
    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data = 0,
    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> lcl = 0) {
  Npl_MessageBuilder builder_(_fbb);
  builder_.add_timestamp(timestamp);
  builder_.add_lcl(lcl);
  builder_.add_data(data);
  builder_.add_pubkey(pubkey);
  return builder_.Finish();
}

inline flatbuffers::Offset<Npl_Message> CreateNpl_MessageDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<uint8_t> *pubkey = nullptr,
    uint64_t timestamp = 0,
    const std::vector<uint8_t> *data = nullptr,
    const std::vector<uint8_t> *lcl = nullptr) {
  auto pubkey__ = pubkey ? _fbb.CreateVector<uint8_t>(*pubkey) : 0;
  auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
  auto lcl__ = lcl ? _fbb.CreateVector<uint8_t>(*lcl) : 0;
  return fbschema::p2pmsg::CreateNpl_Message(
      _fbb,
      pubkey__,
      timestamp,
      data__,
      lcl__);
}

struct StateDifference FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_CREATED = 4,
    VT_UPDATED = 6,
    VT_DELETED = 8
  };
  const flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>> *created() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>> *>(VT_CREATED);
  }
  flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>> *mutable_created() {
    return GetPointer<flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>> *>(VT_CREATED);
  }
  const flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>> *updated() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>> *>(VT_UPDATED);
  }
  flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>> *mutable_updated() {
    return GetPointer<flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>> *>(VT_UPDATED);
  }
  const flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>> *deleted() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>> *>(VT_DELETED);
  }
  flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>> *mutable_deleted() {
    return GetPointer<flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>> *>(VT_DELETED);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_CREATED) &&
           verifier.VerifyVector(created()) &&
           verifier.VerifyVectorOfTables(created()) &&
           VerifyOffset(verifier, VT_UPDATED) &&
           verifier.VerifyVector(updated()) &&
           verifier.VerifyVectorOfTables(updated()) &&
           VerifyOffset(verifier, VT_DELETED) &&
           verifier.VerifyVector(deleted()) &&
           verifier.VerifyVectorOfTables(deleted()) &&
           verifier.EndTable();
  }
};

struct StateDifferenceBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_created(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>>> created) {
    fbb_.AddOffset(StateDifference::VT_CREATED, created);
  }
  void add_updated(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>>> updated) {
    fbb_.AddOffset(StateDifference::VT_UPDATED, updated);
  }
  void add_deleted(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>>> deleted) {
    fbb_.AddOffset(StateDifference::VT_DELETED, deleted);
  }
  explicit StateDifferenceBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  StateDifferenceBuilder &operator=(const StateDifferenceBuilder &);
  flatbuffers::Offset<StateDifference> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<StateDifference>(end);
    return o;
  }
};

inline flatbuffers::Offset<StateDifference> CreateStateDifference(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>>> created = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>>> updated = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>>> deleted = 0) {
  StateDifferenceBuilder builder_(_fbb);
  builder_.add_deleted(deleted);
  builder_.add_updated(updated);
  builder_.add_created(created);
  return builder_.Finish();
}

inline flatbuffers::Offset<StateDifference> CreateStateDifferenceDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>> *created = nullptr,
    const std::vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>> *updated = nullptr,
    const std::vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>> *deleted = nullptr) {
  auto created__ = created ? _fbb.CreateVector<flatbuffers::Offset<fbschema::BytesKeyValuePair>>(*created) : 0;
  auto updated__ = updated ? _fbb.CreateVector<flatbuffers::Offset<fbschema::BytesKeyValuePair>>(*updated) : 0;
  auto deleted__ = deleted ? _fbb.CreateVector<flatbuffers::Offset<fbschema::BytesKeyValuePair>>(*deleted) : 0;
  return fbschema::p2pmsg::CreateStateDifference(
      _fbb,
      created__,
      updated__,
      deleted__);
}

struct State FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_PREVIOUS = 4,
    VT_CURRENT = 6,
    VT_DIFFERENCE = 8,
    VT_PATCH = 10
  };
  const flatbuffers::Vector<uint8_t> *previous() const {
    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_PREVIOUS);
  }
  flatbuffers::Vector<uint8_t> *mutable_previous() {
    return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_PREVIOUS);
  }
  const flatbuffers::Vector<uint8_t> *current() const {
    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_CURRENT);
  }
  flatbuffers::Vector<uint8_t> *mutable_current() {
    return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_CURRENT);
  }
  const StateDifference *difference() const {
    return GetPointer<const StateDifference *>(VT_DIFFERENCE);
  }
  StateDifference *mutable_difference() {
    return GetPointer<StateDifference *>(VT_DIFFERENCE);
  }
  const flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>> *patch() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>> *>(VT_PATCH);
  }
  flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>> *mutable_patch() {
    return GetPointer<flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>> *>(VT_PATCH);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_PREVIOUS) &&
           verifier.VerifyVector(previous()) &&
           VerifyOffset(verifier, VT_CURRENT) &&
           verifier.VerifyVector(current()) &&
           VerifyOffset(verifier, VT_DIFFERENCE) &&
           verifier.VerifyTable(difference()) &&
           VerifyOffset(verifier, VT_PATCH) &&
           verifier.VerifyVector(patch()) &&
           verifier.VerifyVectorOfTables(patch()) &&
           verifier.EndTable();
  }
};

struct StateBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_previous(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> previous) {
    fbb_.AddOffset(State::VT_PREVIOUS, previous);
  }
  void add_current(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> current) {
    fbb_.AddOffset(State::VT_CURRENT, current);
  }
  void add_difference(flatbuffers::Offset<StateDifference> difference) {
    fbb_.AddOffset(State::VT_DIFFERENCE, difference);
  }
  void add_patch(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>>> patch) {
    fbb_.AddOffset(State::VT_PATCH, patch);
  }
  explicit StateBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  StateBuilder &operator=(const StateBuilder &);
  flatbuffers::Offset<State> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = flatbuffers::Offset<State>(end);
    return o;
  }
};

inline flatbuffers::Offset<State> CreateState(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> previous = 0,
    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> current = 0,
    flatbuffers::Offset<StateDifference> difference = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>>> patch = 0) {
  StateBuilder builder_(_fbb);
  builder_.add_patch(patch);
  builder_.add_difference(difference);
  builder_.add_current(current);
  builder_.add_previous(previous);
  return builder_.Finish();
}

inline flatbuffers::Offset<State> CreateStateDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<uint8_t> *previous = nullptr,
    const std::vector<uint8_t> *current = nullptr,
    flatbuffers::Offset<StateDifference> difference = 0,
    const std::vector<flatbuffers::Offset<fbschema::BytesKeyValuePair>> *patch = nullptr) {
  auto previous__ = previous ? _fbb.CreateVector<uint8_t>(*previous) : 0;
  auto current__ = current ? _fbb.CreateVector<uint8_t>(*current) : 0;
  auto patch__ = patch ? _fbb.CreateVector<flatbuffers::Offset<fbschema::BytesKeyValuePair>>(*patch) : 0;
  return fbschema::p2pmsg::CreateState(
      _fbb,
      previous__,
      current__,
      difference,
      patch__);
}

inline bool VerifyMessage(flatbuffers::Verifier &verifier, const void *obj, Message type) {
  switch (type) {
    case Message_NONE: {
      return true;
    }
    case Message_Proposal_Message: {
      auto ptr = reinterpret_cast<const Proposal_Message *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case Message_Npl_Message: {
      auto ptr = reinterpret_cast<const Npl_Message *>(obj);
      return verifier.VerifyTable(ptr);
    }
    default: return false;
  }
}

inline bool VerifyMessageVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
  if (!values || !types) return !values && !types;
  if (values->size() != types->size()) return false;
  for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
    if (!VerifyMessage(
        verifier,  values->Get(i), types->GetEnum<Message>(i))) {
      return false;
    }
  }
  return true;
}

inline const fbschema::p2pmsg::Content *GetContent(const void *buf) {
  return flatbuffers::GetRoot<fbschema::p2pmsg::Content>(buf);
}

inline const fbschema::p2pmsg::Content *GetSizePrefixedContent(const void *buf) {
  return flatbuffers::GetSizePrefixedRoot<fbschema::p2pmsg::Content>(buf);
}

inline Content *GetMutableContent(void *buf) {
  return flatbuffers::GetMutableRoot<Content>(buf);
}

inline bool VerifyContentBuffer(
    flatbuffers::Verifier &verifier) {
  return verifier.VerifyBuffer<fbschema::p2pmsg::Content>(nullptr);
}

inline bool VerifySizePrefixedContentBuffer(
    flatbuffers::Verifier &verifier) {
  return verifier.VerifySizePrefixedBuffer<fbschema::p2pmsg::Content>(nullptr);
}

inline void FinishContentBuffer(
    flatbuffers::FlatBufferBuilder &fbb,
    flatbuffers::Offset<fbschema::p2pmsg::Content> root) {
  fbb.Finish(root);
}

inline void FinishSizePrefixedContentBuffer(
    flatbuffers::FlatBufferBuilder &fbb,
    flatbuffers::Offset<fbschema::p2pmsg::Content> root) {
  fbb.FinishSizePrefixed(root);
}

}  // namespace p2pmsg
}  // namespace fbschema

#endif  // FLATBUFFERS_GENERATED_P2PMSGCONTENT_FBSCHEMA_P2PMSG_