mirror of
https://github.com/EvernodeXRPL/hpcore.git
synced 2026-04-29 15:37:59 +00:00
2f5d95ae7a
* Saving raw inputs in the ledger. * Store full history in separate folder. * Moved full history fb structs to a seperate fbs file * Removed raw_inputs from the proposal * Fixed code comments * Saving raw user input string * Code refactoring * Resolved PR comments
2191 lines
85 KiB
C++
2191 lines
85 KiB
C++
// automatically generated by the FlatBuffers compiler, do not modify
|
|
|
|
|
|
#ifndef FLATBUFFERS_GENERATED_P2PMSGCONTENT_MSG_FBUF_P2PMSG_H_
|
|
#define FLATBUFFERS_GENERATED_P2PMSGCONTENT_MSG_FBUF_P2PMSG_H_
|
|
|
|
#include "flatbuffers/flatbuffers.h"
|
|
|
|
#include "common_schema_generated.h"
|
|
|
|
namespace msg {
|
|
namespace fbuf {
|
|
namespace p2pmsg {
|
|
|
|
struct Peer_Challenge_Message;
|
|
struct Peer_Challenge_MessageBuilder;
|
|
|
|
struct Peer_Challenge_Response_Message;
|
|
struct Peer_Challenge_Response_MessageBuilder;
|
|
|
|
struct UserInput;
|
|
struct UserInputBuilder;
|
|
|
|
struct UserInputGroup;
|
|
struct UserInputGroupBuilder;
|
|
|
|
struct Content;
|
|
struct ContentBuilder;
|
|
|
|
struct NonUnl_Proposal_Message;
|
|
struct NonUnl_Proposal_MessageBuilder;
|
|
|
|
struct Proposal_Message;
|
|
struct Proposal_MessageBuilder;
|
|
|
|
struct Npl_Message;
|
|
struct Npl_MessageBuilder;
|
|
|
|
struct History_Request_Message;
|
|
struct History_Request_MessageBuilder;
|
|
|
|
struct History_Response_Message;
|
|
struct History_Response_MessageBuilder;
|
|
|
|
struct HistoryLedgerBlockPair;
|
|
struct HistoryLedgerBlockPairBuilder;
|
|
|
|
struct HistoryLedgerBlock;
|
|
struct HistoryLedgerBlockBuilder;
|
|
|
|
struct State_Request_Message;
|
|
struct State_Request_MessageBuilder;
|
|
|
|
struct State_Response_Message;
|
|
struct State_Response_MessageBuilder;
|
|
|
|
struct Fs_Entry_Response;
|
|
struct Fs_Entry_ResponseBuilder;
|
|
|
|
struct File_HashMap_Response;
|
|
struct File_HashMap_ResponseBuilder;
|
|
|
|
struct Block_Response;
|
|
struct Block_ResponseBuilder;
|
|
|
|
struct State_FS_Hash_Entry;
|
|
struct State_FS_Hash_EntryBuilder;
|
|
|
|
struct Peer_Requirement_Announcement_Message;
|
|
struct Peer_Requirement_Announcement_MessageBuilder;
|
|
|
|
struct Available_Capacity_Announcement_Message;
|
|
struct Available_Capacity_Announcement_MessageBuilder;
|
|
|
|
struct Peer_List_Request_Message;
|
|
struct Peer_List_Request_MessageBuilder;
|
|
|
|
struct Peer_List_Response_Message;
|
|
struct Peer_List_Response_MessageBuilder;
|
|
|
|
struct Peer_Properties;
|
|
struct Peer_PropertiesBuilder;
|
|
|
|
enum Message {
|
|
Message_NONE = 0,
|
|
Message_Peer_Challenge_Response_Message = 1,
|
|
Message_Peer_Challenge_Message = 2,
|
|
Message_NonUnl_Proposal_Message = 3,
|
|
Message_Proposal_Message = 4,
|
|
Message_Npl_Message = 5,
|
|
Message_State_Request_Message = 6,
|
|
Message_State_Response_Message = 7,
|
|
Message_History_Request_Message = 8,
|
|
Message_History_Response_Message = 9,
|
|
Message_Peer_Requirement_Announcement_Message = 10,
|
|
Message_Peer_List_Request_Message = 11,
|
|
Message_Peer_List_Response_Message = 12,
|
|
Message_Available_Capacity_Announcement_Message = 13,
|
|
Message_MIN = Message_NONE,
|
|
Message_MAX = Message_Available_Capacity_Announcement_Message
|
|
};
|
|
|
|
inline const Message (&EnumValuesMessage())[14] {
|
|
static const Message values[] = {
|
|
Message_NONE,
|
|
Message_Peer_Challenge_Response_Message,
|
|
Message_Peer_Challenge_Message,
|
|
Message_NonUnl_Proposal_Message,
|
|
Message_Proposal_Message,
|
|
Message_Npl_Message,
|
|
Message_State_Request_Message,
|
|
Message_State_Response_Message,
|
|
Message_History_Request_Message,
|
|
Message_History_Response_Message,
|
|
Message_Peer_Requirement_Announcement_Message,
|
|
Message_Peer_List_Request_Message,
|
|
Message_Peer_List_Response_Message,
|
|
Message_Available_Capacity_Announcement_Message
|
|
};
|
|
return values;
|
|
}
|
|
|
|
inline const char * const *EnumNamesMessage() {
|
|
static const char * const names[15] = {
|
|
"NONE",
|
|
"Peer_Challenge_Response_Message",
|
|
"Peer_Challenge_Message",
|
|
"NonUnl_Proposal_Message",
|
|
"Proposal_Message",
|
|
"Npl_Message",
|
|
"State_Request_Message",
|
|
"State_Response_Message",
|
|
"History_Request_Message",
|
|
"History_Response_Message",
|
|
"Peer_Requirement_Announcement_Message",
|
|
"Peer_List_Request_Message",
|
|
"Peer_List_Response_Message",
|
|
"Available_Capacity_Announcement_Message",
|
|
nullptr
|
|
};
|
|
return names;
|
|
}
|
|
|
|
inline const char *EnumNameMessage(Message e) {
|
|
if (flatbuffers::IsOutRange(e, Message_NONE, Message_Available_Capacity_Announcement_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<msg::fbuf::p2pmsg::Peer_Challenge_Response_Message> {
|
|
static const Message enum_value = Message_Peer_Challenge_Response_Message;
|
|
};
|
|
|
|
template<> struct MessageTraits<msg::fbuf::p2pmsg::Peer_Challenge_Message> {
|
|
static const Message enum_value = Message_Peer_Challenge_Message;
|
|
};
|
|
|
|
template<> struct MessageTraits<msg::fbuf::p2pmsg::NonUnl_Proposal_Message> {
|
|
static const Message enum_value = Message_NonUnl_Proposal_Message;
|
|
};
|
|
|
|
template<> struct MessageTraits<msg::fbuf::p2pmsg::Proposal_Message> {
|
|
static const Message enum_value = Message_Proposal_Message;
|
|
};
|
|
|
|
template<> struct MessageTraits<msg::fbuf::p2pmsg::Npl_Message> {
|
|
static const Message enum_value = Message_Npl_Message;
|
|
};
|
|
|
|
template<> struct MessageTraits<msg::fbuf::p2pmsg::State_Request_Message> {
|
|
static const Message enum_value = Message_State_Request_Message;
|
|
};
|
|
|
|
template<> struct MessageTraits<msg::fbuf::p2pmsg::State_Response_Message> {
|
|
static const Message enum_value = Message_State_Response_Message;
|
|
};
|
|
|
|
template<> struct MessageTraits<msg::fbuf::p2pmsg::History_Request_Message> {
|
|
static const Message enum_value = Message_History_Request_Message;
|
|
};
|
|
|
|
template<> struct MessageTraits<msg::fbuf::p2pmsg::History_Response_Message> {
|
|
static const Message enum_value = Message_History_Response_Message;
|
|
};
|
|
|
|
template<> struct MessageTraits<msg::fbuf::p2pmsg::Peer_Requirement_Announcement_Message> {
|
|
static const Message enum_value = Message_Peer_Requirement_Announcement_Message;
|
|
};
|
|
|
|
template<> struct MessageTraits<msg::fbuf::p2pmsg::Peer_List_Request_Message> {
|
|
static const Message enum_value = Message_Peer_List_Request_Message;
|
|
};
|
|
|
|
template<> struct MessageTraits<msg::fbuf::p2pmsg::Peer_List_Response_Message> {
|
|
static const Message enum_value = Message_Peer_List_Response_Message;
|
|
};
|
|
|
|
template<> struct MessageTraits<msg::fbuf::p2pmsg::Available_Capacity_Announcement_Message> {
|
|
static const Message enum_value = Message_Available_Capacity_Announcement_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);
|
|
|
|
enum Ledger_Response_Error {
|
|
Ledger_Response_Error_None = 0,
|
|
Ledger_Response_Error_Invalid_Min_Ledger = 1,
|
|
Ledger_Response_Error_Req_Ledger_Not_Found = 2,
|
|
Ledger_Response_Error_MIN = Ledger_Response_Error_None,
|
|
Ledger_Response_Error_MAX = Ledger_Response_Error_Req_Ledger_Not_Found
|
|
};
|
|
|
|
inline const Ledger_Response_Error (&EnumValuesLedger_Response_Error())[3] {
|
|
static const Ledger_Response_Error values[] = {
|
|
Ledger_Response_Error_None,
|
|
Ledger_Response_Error_Invalid_Min_Ledger,
|
|
Ledger_Response_Error_Req_Ledger_Not_Found
|
|
};
|
|
return values;
|
|
}
|
|
|
|
inline const char * const *EnumNamesLedger_Response_Error() {
|
|
static const char * const names[4] = {
|
|
"None",
|
|
"Invalid_Min_Ledger",
|
|
"Req_Ledger_Not_Found",
|
|
nullptr
|
|
};
|
|
return names;
|
|
}
|
|
|
|
inline const char *EnumNameLedger_Response_Error(Ledger_Response_Error e) {
|
|
if (flatbuffers::IsOutRange(e, Ledger_Response_Error_None, Ledger_Response_Error_Req_Ledger_Not_Found)) return "";
|
|
const size_t index = static_cast<size_t>(e);
|
|
return EnumNamesLedger_Response_Error()[index];
|
|
}
|
|
|
|
enum State_Response {
|
|
State_Response_NONE = 0,
|
|
State_Response_File_HashMap_Response = 1,
|
|
State_Response_Block_Response = 2,
|
|
State_Response_Fs_Entry_Response = 3,
|
|
State_Response_MIN = State_Response_NONE,
|
|
State_Response_MAX = State_Response_Fs_Entry_Response
|
|
};
|
|
|
|
inline const State_Response (&EnumValuesState_Response())[4] {
|
|
static const State_Response values[] = {
|
|
State_Response_NONE,
|
|
State_Response_File_HashMap_Response,
|
|
State_Response_Block_Response,
|
|
State_Response_Fs_Entry_Response
|
|
};
|
|
return values;
|
|
}
|
|
|
|
inline const char * const *EnumNamesState_Response() {
|
|
static const char * const names[5] = {
|
|
"NONE",
|
|
"File_HashMap_Response",
|
|
"Block_Response",
|
|
"Fs_Entry_Response",
|
|
nullptr
|
|
};
|
|
return names;
|
|
}
|
|
|
|
inline const char *EnumNameState_Response(State_Response e) {
|
|
if (flatbuffers::IsOutRange(e, State_Response_NONE, State_Response_Fs_Entry_Response)) return "";
|
|
const size_t index = static_cast<size_t>(e);
|
|
return EnumNamesState_Response()[index];
|
|
}
|
|
|
|
template<typename T> struct State_ResponseTraits {
|
|
static const State_Response enum_value = State_Response_NONE;
|
|
};
|
|
|
|
template<> struct State_ResponseTraits<msg::fbuf::p2pmsg::File_HashMap_Response> {
|
|
static const State_Response enum_value = State_Response_File_HashMap_Response;
|
|
};
|
|
|
|
template<> struct State_ResponseTraits<msg::fbuf::p2pmsg::Block_Response> {
|
|
static const State_Response enum_value = State_Response_Block_Response;
|
|
};
|
|
|
|
template<> struct State_ResponseTraits<msg::fbuf::p2pmsg::Fs_Entry_Response> {
|
|
static const State_Response enum_value = State_Response_Fs_Entry_Response;
|
|
};
|
|
|
|
bool VerifyState_Response(flatbuffers::Verifier &verifier, const void *obj, State_Response type);
|
|
bool VerifyState_ResponseVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
|
|
|
|
struct Peer_Challenge_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
|
typedef Peer_Challenge_MessageBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_CHALLENGE = 4
|
|
};
|
|
const flatbuffers::Vector<uint8_t> *challenge() const {
|
|
return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_CHALLENGE);
|
|
}
|
|
flatbuffers::Vector<uint8_t> *mutable_challenge() {
|
|
return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_CHALLENGE);
|
|
}
|
|
bool Verify(flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_CHALLENGE) &&
|
|
verifier.VerifyVector(challenge()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct Peer_Challenge_MessageBuilder {
|
|
typedef Peer_Challenge_Message Table;
|
|
flatbuffers::FlatBufferBuilder &fbb_;
|
|
flatbuffers::uoffset_t start_;
|
|
void add_challenge(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> challenge) {
|
|
fbb_.AddOffset(Peer_Challenge_Message::VT_CHALLENGE, challenge);
|
|
}
|
|
explicit Peer_Challenge_MessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
flatbuffers::Offset<Peer_Challenge_Message> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = flatbuffers::Offset<Peer_Challenge_Message>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline flatbuffers::Offset<Peer_Challenge_Message> CreatePeer_Challenge_Message(
|
|
flatbuffers::FlatBufferBuilder &_fbb,
|
|
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> challenge = 0) {
|
|
Peer_Challenge_MessageBuilder builder_(_fbb);
|
|
builder_.add_challenge(challenge);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline flatbuffers::Offset<Peer_Challenge_Message> CreatePeer_Challenge_MessageDirect(
|
|
flatbuffers::FlatBufferBuilder &_fbb,
|
|
const std::vector<uint8_t> *challenge = nullptr) {
|
|
auto challenge__ = challenge ? _fbb.CreateVector<uint8_t>(*challenge) : 0;
|
|
return msg::fbuf::p2pmsg::CreatePeer_Challenge_Message(
|
|
_fbb,
|
|
challenge__);
|
|
}
|
|
|
|
struct Peer_Challenge_Response_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
|
typedef Peer_Challenge_Response_MessageBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_CHALLENGE = 4,
|
|
VT_SIG = 6
|
|
};
|
|
const flatbuffers::Vector<uint8_t> *challenge() const {
|
|
return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_CHALLENGE);
|
|
}
|
|
flatbuffers::Vector<uint8_t> *mutable_challenge() {
|
|
return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_CHALLENGE);
|
|
}
|
|
const flatbuffers::Vector<uint8_t> *sig() const {
|
|
return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_SIG);
|
|
}
|
|
flatbuffers::Vector<uint8_t> *mutable_sig() {
|
|
return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_SIG);
|
|
}
|
|
bool Verify(flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_CHALLENGE) &&
|
|
verifier.VerifyVector(challenge()) &&
|
|
VerifyOffset(verifier, VT_SIG) &&
|
|
verifier.VerifyVector(sig()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct Peer_Challenge_Response_MessageBuilder {
|
|
typedef Peer_Challenge_Response_Message Table;
|
|
flatbuffers::FlatBufferBuilder &fbb_;
|
|
flatbuffers::uoffset_t start_;
|
|
void add_challenge(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> challenge) {
|
|
fbb_.AddOffset(Peer_Challenge_Response_Message::VT_CHALLENGE, challenge);
|
|
}
|
|
void add_sig(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> sig) {
|
|
fbb_.AddOffset(Peer_Challenge_Response_Message::VT_SIG, sig);
|
|
}
|
|
explicit Peer_Challenge_Response_MessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
flatbuffers::Offset<Peer_Challenge_Response_Message> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = flatbuffers::Offset<Peer_Challenge_Response_Message>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline flatbuffers::Offset<Peer_Challenge_Response_Message> CreatePeer_Challenge_Response_Message(
|
|
flatbuffers::FlatBufferBuilder &_fbb,
|
|
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> challenge = 0,
|
|
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> sig = 0) {
|
|
Peer_Challenge_Response_MessageBuilder builder_(_fbb);
|
|
builder_.add_sig(sig);
|
|
builder_.add_challenge(challenge);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline flatbuffers::Offset<Peer_Challenge_Response_Message> CreatePeer_Challenge_Response_MessageDirect(
|
|
flatbuffers::FlatBufferBuilder &_fbb,
|
|
const std::vector<uint8_t> *challenge = nullptr,
|
|
const std::vector<uint8_t> *sig = nullptr) {
|
|
auto challenge__ = challenge ? _fbb.CreateVector<uint8_t>(*challenge) : 0;
|
|
auto sig__ = sig ? _fbb.CreateVector<uint8_t>(*sig) : 0;
|
|
return msg::fbuf::p2pmsg::CreatePeer_Challenge_Response_Message(
|
|
_fbb,
|
|
challenge__,
|
|
sig__);
|
|
}
|
|
|
|
struct UserInput FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
|
typedef UserInputBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_INPUT_CONTAINER = 4,
|
|
VT_SIGNATURE = 6,
|
|
VT_PROTOCOL = 8
|
|
};
|
|
const flatbuffers::Vector<uint8_t> *input_container() const {
|
|
return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_INPUT_CONTAINER);
|
|
}
|
|
flatbuffers::Vector<uint8_t> *mutable_input_container() {
|
|
return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_INPUT_CONTAINER);
|
|
}
|
|
const flatbuffers::Vector<uint8_t> *signature() const {
|
|
return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_SIGNATURE);
|
|
}
|
|
flatbuffers::Vector<uint8_t> *mutable_signature() {
|
|
return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_SIGNATURE);
|
|
}
|
|
uint8_t protocol() const {
|
|
return GetField<uint8_t>(VT_PROTOCOL, 0);
|
|
}
|
|
bool mutate_protocol(uint8_t _protocol) {
|
|
return SetField<uint8_t>(VT_PROTOCOL, _protocol, 0);
|
|
}
|
|
bool Verify(flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_INPUT_CONTAINER) &&
|
|
verifier.VerifyVector(input_container()) &&
|
|
VerifyOffset(verifier, VT_SIGNATURE) &&
|
|
verifier.VerifyVector(signature()) &&
|
|
VerifyField<uint8_t>(verifier, VT_PROTOCOL) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct UserInputBuilder {
|
|
typedef UserInput Table;
|
|
flatbuffers::FlatBufferBuilder &fbb_;
|
|
flatbuffers::uoffset_t start_;
|
|
void add_input_container(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> input_container) {
|
|
fbb_.AddOffset(UserInput::VT_INPUT_CONTAINER, input_container);
|
|
}
|
|
void add_signature(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> signature) {
|
|
fbb_.AddOffset(UserInput::VT_SIGNATURE, signature);
|
|
}
|
|
void add_protocol(uint8_t protocol) {
|
|
fbb_.AddElement<uint8_t>(UserInput::VT_PROTOCOL, protocol, 0);
|
|
}
|
|
explicit UserInputBuilder(flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
flatbuffers::Offset<UserInput> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = flatbuffers::Offset<UserInput>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline flatbuffers::Offset<UserInput> CreateUserInput(
|
|
flatbuffers::FlatBufferBuilder &_fbb,
|
|
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> input_container = 0,
|
|
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> signature = 0,
|
|
uint8_t protocol = 0) {
|
|
UserInputBuilder builder_(_fbb);
|
|
builder_.add_signature(signature);
|
|
builder_.add_input_container(input_container);
|
|
builder_.add_protocol(protocol);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline flatbuffers::Offset<UserInput> CreateUserInputDirect(
|
|
flatbuffers::FlatBufferBuilder &_fbb,
|
|
const std::vector<uint8_t> *input_container = nullptr,
|
|
const std::vector<uint8_t> *signature = nullptr,
|
|
uint8_t protocol = 0) {
|
|
auto input_container__ = input_container ? _fbb.CreateVector<uint8_t>(*input_container) : 0;
|
|
auto signature__ = signature ? _fbb.CreateVector<uint8_t>(*signature) : 0;
|
|
return msg::fbuf::p2pmsg::CreateUserInput(
|
|
_fbb,
|
|
input_container__,
|
|
signature__,
|
|
protocol);
|
|
}
|
|
|
|
struct UserInputGroup FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
|
typedef UserInputGroupBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_PUBKEY = 4,
|
|
VT_MESSAGES = 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<msg::fbuf::p2pmsg::UserInput>> *messages() const {
|
|
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::p2pmsg::UserInput>> *>(VT_MESSAGES);
|
|
}
|
|
flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::p2pmsg::UserInput>> *mutable_messages() {
|
|
return GetPointer<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::p2pmsg::UserInput>> *>(VT_MESSAGES);
|
|
}
|
|
bool Verify(flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_PUBKEY) &&
|
|
verifier.VerifyVector(pubkey()) &&
|
|
VerifyOffset(verifier, VT_MESSAGES) &&
|
|
verifier.VerifyVector(messages()) &&
|
|
verifier.VerifyVectorOfTables(messages()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct UserInputGroupBuilder {
|
|
typedef UserInputGroup Table;
|
|
flatbuffers::FlatBufferBuilder &fbb_;
|
|
flatbuffers::uoffset_t start_;
|
|
void add_pubkey(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> pubkey) {
|
|
fbb_.AddOffset(UserInputGroup::VT_PUBKEY, pubkey);
|
|
}
|
|
void add_messages(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::p2pmsg::UserInput>>> messages) {
|
|
fbb_.AddOffset(UserInputGroup::VT_MESSAGES, messages);
|
|
}
|
|
explicit UserInputGroupBuilder(flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
flatbuffers::Offset<UserInputGroup> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = flatbuffers::Offset<UserInputGroup>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline flatbuffers::Offset<UserInputGroup> CreateUserInputGroup(
|
|
flatbuffers::FlatBufferBuilder &_fbb,
|
|
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> pubkey = 0,
|
|
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::p2pmsg::UserInput>>> messages = 0) {
|
|
UserInputGroupBuilder builder_(_fbb);
|
|
builder_.add_messages(messages);
|
|
builder_.add_pubkey(pubkey);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline flatbuffers::Offset<UserInputGroup> CreateUserInputGroupDirect(
|
|
flatbuffers::FlatBufferBuilder &_fbb,
|
|
const std::vector<uint8_t> *pubkey = nullptr,
|
|
const std::vector<flatbuffers::Offset<msg::fbuf::p2pmsg::UserInput>> *messages = nullptr) {
|
|
auto pubkey__ = pubkey ? _fbb.CreateVector<uint8_t>(*pubkey) : 0;
|
|
auto messages__ = messages ? _fbb.CreateVector<flatbuffers::Offset<msg::fbuf::p2pmsg::UserInput>>(*messages) : 0;
|
|
return msg::fbuf::p2pmsg::CreateUserInputGroup(
|
|
_fbb,
|
|
pubkey__,
|
|
messages__);
|
|
}
|
|
|
|
struct Content FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
|
typedef ContentBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_MESSAGE_TYPE = 4,
|
|
VT_MESSAGE = 6
|
|
};
|
|
msg::fbuf::p2pmsg::Message message_type() const {
|
|
return static_cast<msg::fbuf::p2pmsg::Message>(GetField<uint8_t>(VT_MESSAGE_TYPE, 0));
|
|
}
|
|
const void *message() const {
|
|
return GetPointer<const void *>(VT_MESSAGE);
|
|
}
|
|
template<typename T> const T *message_as() const;
|
|
const msg::fbuf::p2pmsg::Peer_Challenge_Response_Message *message_as_Peer_Challenge_Response_Message() const {
|
|
return message_type() == msg::fbuf::p2pmsg::Message_Peer_Challenge_Response_Message ? static_cast<const msg::fbuf::p2pmsg::Peer_Challenge_Response_Message *>(message()) : nullptr;
|
|
}
|
|
const msg::fbuf::p2pmsg::Peer_Challenge_Message *message_as_Peer_Challenge_Message() const {
|
|
return message_type() == msg::fbuf::p2pmsg::Message_Peer_Challenge_Message ? static_cast<const msg::fbuf::p2pmsg::Peer_Challenge_Message *>(message()) : nullptr;
|
|
}
|
|
const msg::fbuf::p2pmsg::NonUnl_Proposal_Message *message_as_NonUnl_Proposal_Message() const {
|
|
return message_type() == msg::fbuf::p2pmsg::Message_NonUnl_Proposal_Message ? static_cast<const msg::fbuf::p2pmsg::NonUnl_Proposal_Message *>(message()) : nullptr;
|
|
}
|
|
const msg::fbuf::p2pmsg::Proposal_Message *message_as_Proposal_Message() const {
|
|
return message_type() == msg::fbuf::p2pmsg::Message_Proposal_Message ? static_cast<const msg::fbuf::p2pmsg::Proposal_Message *>(message()) : nullptr;
|
|
}
|
|
const msg::fbuf::p2pmsg::Npl_Message *message_as_Npl_Message() const {
|
|
return message_type() == msg::fbuf::p2pmsg::Message_Npl_Message ? static_cast<const msg::fbuf::p2pmsg::Npl_Message *>(message()) : nullptr;
|
|
}
|
|
const msg::fbuf::p2pmsg::State_Request_Message *message_as_State_Request_Message() const {
|
|
return message_type() == msg::fbuf::p2pmsg::Message_State_Request_Message ? static_cast<const msg::fbuf::p2pmsg::State_Request_Message *>(message()) : nullptr;
|
|
}
|
|
const msg::fbuf::p2pmsg::State_Response_Message *message_as_State_Response_Message() const {
|
|
return message_type() == msg::fbuf::p2pmsg::Message_State_Response_Message ? static_cast<const msg::fbuf::p2pmsg::State_Response_Message *>(message()) : nullptr;
|
|
}
|
|
const msg::fbuf::p2pmsg::History_Request_Message *message_as_History_Request_Message() const {
|
|
return message_type() == msg::fbuf::p2pmsg::Message_History_Request_Message ? static_cast<const msg::fbuf::p2pmsg::History_Request_Message *>(message()) : nullptr;
|
|
}
|
|
const msg::fbuf::p2pmsg::History_Response_Message *message_as_History_Response_Message() const {
|
|
return message_type() == msg::fbuf::p2pmsg::Message_History_Response_Message ? static_cast<const msg::fbuf::p2pmsg::History_Response_Message *>(message()) : nullptr;
|
|
}
|
|
const msg::fbuf::p2pmsg::Peer_Requirement_Announcement_Message *message_as_Peer_Requirement_Announcement_Message() const {
|
|
return message_type() == msg::fbuf::p2pmsg::Message_Peer_Requirement_Announcement_Message ? static_cast<const msg::fbuf::p2pmsg::Peer_Requirement_Announcement_Message *>(message()) : nullptr;
|
|
}
|
|
const msg::fbuf::p2pmsg::Peer_List_Request_Message *message_as_Peer_List_Request_Message() const {
|
|
return message_type() == msg::fbuf::p2pmsg::Message_Peer_List_Request_Message ? static_cast<const msg::fbuf::p2pmsg::Peer_List_Request_Message *>(message()) : nullptr;
|
|
}
|
|
const msg::fbuf::p2pmsg::Peer_List_Response_Message *message_as_Peer_List_Response_Message() const {
|
|
return message_type() == msg::fbuf::p2pmsg::Message_Peer_List_Response_Message ? static_cast<const msg::fbuf::p2pmsg::Peer_List_Response_Message *>(message()) : nullptr;
|
|
}
|
|
const msg::fbuf::p2pmsg::Available_Capacity_Announcement_Message *message_as_Available_Capacity_Announcement_Message() const {
|
|
return message_type() == msg::fbuf::p2pmsg::Message_Available_Capacity_Announcement_Message ? static_cast<const msg::fbuf::p2pmsg::Available_Capacity_Announcement_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 msg::fbuf::p2pmsg::Peer_Challenge_Response_Message *Content::message_as<msg::fbuf::p2pmsg::Peer_Challenge_Response_Message>() const {
|
|
return message_as_Peer_Challenge_Response_Message();
|
|
}
|
|
|
|
template<> inline const msg::fbuf::p2pmsg::Peer_Challenge_Message *Content::message_as<msg::fbuf::p2pmsg::Peer_Challenge_Message>() const {
|
|
return message_as_Peer_Challenge_Message();
|
|
}
|
|
|
|
template<> inline const msg::fbuf::p2pmsg::NonUnl_Proposal_Message *Content::message_as<msg::fbuf::p2pmsg::NonUnl_Proposal_Message>() const {
|
|
return message_as_NonUnl_Proposal_Message();
|
|
}
|
|
|
|
template<> inline const msg::fbuf::p2pmsg::Proposal_Message *Content::message_as<msg::fbuf::p2pmsg::Proposal_Message>() const {
|
|
return message_as_Proposal_Message();
|
|
}
|
|
|
|
template<> inline const msg::fbuf::p2pmsg::Npl_Message *Content::message_as<msg::fbuf::p2pmsg::Npl_Message>() const {
|
|
return message_as_Npl_Message();
|
|
}
|
|
|
|
template<> inline const msg::fbuf::p2pmsg::State_Request_Message *Content::message_as<msg::fbuf::p2pmsg::State_Request_Message>() const {
|
|
return message_as_State_Request_Message();
|
|
}
|
|
|
|
template<> inline const msg::fbuf::p2pmsg::State_Response_Message *Content::message_as<msg::fbuf::p2pmsg::State_Response_Message>() const {
|
|
return message_as_State_Response_Message();
|
|
}
|
|
|
|
template<> inline const msg::fbuf::p2pmsg::History_Request_Message *Content::message_as<msg::fbuf::p2pmsg::History_Request_Message>() const {
|
|
return message_as_History_Request_Message();
|
|
}
|
|
|
|
template<> inline const msg::fbuf::p2pmsg::History_Response_Message *Content::message_as<msg::fbuf::p2pmsg::History_Response_Message>() const {
|
|
return message_as_History_Response_Message();
|
|
}
|
|
|
|
template<> inline const msg::fbuf::p2pmsg::Peer_Requirement_Announcement_Message *Content::message_as<msg::fbuf::p2pmsg::Peer_Requirement_Announcement_Message>() const {
|
|
return message_as_Peer_Requirement_Announcement_Message();
|
|
}
|
|
|
|
template<> inline const msg::fbuf::p2pmsg::Peer_List_Request_Message *Content::message_as<msg::fbuf::p2pmsg::Peer_List_Request_Message>() const {
|
|
return message_as_Peer_List_Request_Message();
|
|
}
|
|
|
|
template<> inline const msg::fbuf::p2pmsg::Peer_List_Response_Message *Content::message_as<msg::fbuf::p2pmsg::Peer_List_Response_Message>() const {
|
|
return message_as_Peer_List_Response_Message();
|
|
}
|
|
|
|
template<> inline const msg::fbuf::p2pmsg::Available_Capacity_Announcement_Message *Content::message_as<msg::fbuf::p2pmsg::Available_Capacity_Announcement_Message>() const {
|
|
return message_as_Available_Capacity_Announcement_Message();
|
|
}
|
|
|
|
struct ContentBuilder {
|
|
typedef Content Table;
|
|
flatbuffers::FlatBufferBuilder &fbb_;
|
|
flatbuffers::uoffset_t start_;
|
|
void add_message_type(msg::fbuf::p2pmsg::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();
|
|
}
|
|
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,
|
|
msg::fbuf::p2pmsg::Message message_type = msg::fbuf::p2pmsg::Message_NONE,
|
|
flatbuffers::Offset<void> message = 0) {
|
|
ContentBuilder builder_(_fbb);
|
|
builder_.add_message(message);
|
|
builder_.add_message_type(message_type);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
struct NonUnl_Proposal_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
|
typedef NonUnl_Proposal_MessageBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_USER_INPUTS = 4
|
|
};
|
|
const flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::p2pmsg::UserInputGroup>> *user_inputs() const {
|
|
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::p2pmsg::UserInputGroup>> *>(VT_USER_INPUTS);
|
|
}
|
|
flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::p2pmsg::UserInputGroup>> *mutable_user_inputs() {
|
|
return GetPointer<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::p2pmsg::UserInputGroup>> *>(VT_USER_INPUTS);
|
|
}
|
|
bool Verify(flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_USER_INPUTS) &&
|
|
verifier.VerifyVector(user_inputs()) &&
|
|
verifier.VerifyVectorOfTables(user_inputs()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct NonUnl_Proposal_MessageBuilder {
|
|
typedef NonUnl_Proposal_Message Table;
|
|
flatbuffers::FlatBufferBuilder &fbb_;
|
|
flatbuffers::uoffset_t start_;
|
|
void add_user_inputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::p2pmsg::UserInputGroup>>> user_inputs) {
|
|
fbb_.AddOffset(NonUnl_Proposal_Message::VT_USER_INPUTS, user_inputs);
|
|
}
|
|
explicit NonUnl_Proposal_MessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
flatbuffers::Offset<NonUnl_Proposal_Message> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = flatbuffers::Offset<NonUnl_Proposal_Message>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline flatbuffers::Offset<NonUnl_Proposal_Message> CreateNonUnl_Proposal_Message(
|
|
flatbuffers::FlatBufferBuilder &_fbb,
|
|
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::p2pmsg::UserInputGroup>>> user_inputs = 0) {
|
|
NonUnl_Proposal_MessageBuilder builder_(_fbb);
|
|
builder_.add_user_inputs(user_inputs);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline flatbuffers::Offset<NonUnl_Proposal_Message> CreateNonUnl_Proposal_MessageDirect(
|
|
flatbuffers::FlatBufferBuilder &_fbb,
|
|
const std::vector<flatbuffers::Offset<msg::fbuf::p2pmsg::UserInputGroup>> *user_inputs = nullptr) {
|
|
auto user_inputs__ = user_inputs ? _fbb.CreateVector<flatbuffers::Offset<msg::fbuf::p2pmsg::UserInputGroup>>(*user_inputs) : 0;
|
|
return msg::fbuf::p2pmsg::CreateNonUnl_Proposal_Message(
|
|
_fbb,
|
|
user_inputs__);
|
|
}
|
|
|
|
struct Proposal_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
|
typedef Proposal_MessageBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_STAGE = 4,
|
|
VT_TIME = 6,
|
|
VT_NONCE = 8,
|
|
VT_USERS = 10,
|
|
VT_HASH_INPUTS = 12,
|
|
VT_HASH_OUTPUTS = 14,
|
|
VT_STATE = 16
|
|
};
|
|
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> *nonce() const {
|
|
return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_NONCE);
|
|
}
|
|
flatbuffers::Vector<uint8_t> *mutable_nonce() {
|
|
return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_NONCE);
|
|
}
|
|
const flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *users() const {
|
|
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *>(VT_USERS);
|
|
}
|
|
flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *mutable_users() {
|
|
return GetPointer<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *>(VT_USERS);
|
|
}
|
|
const flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *hash_inputs() const {
|
|
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *>(VT_HASH_INPUTS);
|
|
}
|
|
flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *mutable_hash_inputs() {
|
|
return GetPointer<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *>(VT_HASH_INPUTS);
|
|
}
|
|
const flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *hash_outputs() const {
|
|
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *>(VT_HASH_OUTPUTS);
|
|
}
|
|
flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *mutable_hash_outputs() {
|
|
return GetPointer<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *>(VT_HASH_OUTPUTS);
|
|
}
|
|
const flatbuffers::Vector<uint8_t> *state() const {
|
|
return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_STATE);
|
|
}
|
|
flatbuffers::Vector<uint8_t> *mutable_state() {
|
|
return GetPointer<flatbuffers::Vector<uint8_t> *>(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_NONCE) &&
|
|
verifier.VerifyVector(nonce()) &&
|
|
VerifyOffset(verifier, VT_USERS) &&
|
|
verifier.VerifyVector(users()) &&
|
|
verifier.VerifyVectorOfTables(users()) &&
|
|
VerifyOffset(verifier, VT_HASH_INPUTS) &&
|
|
verifier.VerifyVector(hash_inputs()) &&
|
|
verifier.VerifyVectorOfTables(hash_inputs()) &&
|
|
VerifyOffset(verifier, VT_HASH_OUTPUTS) &&
|
|
verifier.VerifyVector(hash_outputs()) &&
|
|
verifier.VerifyVectorOfTables(hash_outputs()) &&
|
|
VerifyOffset(verifier, VT_STATE) &&
|
|
verifier.VerifyVector(state()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct Proposal_MessageBuilder {
|
|
typedef Proposal_Message Table;
|
|
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_nonce(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> nonce) {
|
|
fbb_.AddOffset(Proposal_Message::VT_NONCE, nonce);
|
|
}
|
|
void add_users(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>>> users) {
|
|
fbb_.AddOffset(Proposal_Message::VT_USERS, users);
|
|
}
|
|
void add_hash_inputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>>> hash_inputs) {
|
|
fbb_.AddOffset(Proposal_Message::VT_HASH_INPUTS, hash_inputs);
|
|
}
|
|
void add_hash_outputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>>> hash_outputs) {
|
|
fbb_.AddOffset(Proposal_Message::VT_HASH_OUTPUTS, hash_outputs);
|
|
}
|
|
void add_state(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> state) {
|
|
fbb_.AddOffset(Proposal_Message::VT_STATE, state);
|
|
}
|
|
explicit Proposal_MessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
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>> nonce = 0,
|
|
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>>> users = 0,
|
|
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>>> hash_inputs = 0,
|
|
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>>> hash_outputs = 0,
|
|
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> state = 0) {
|
|
Proposal_MessageBuilder builder_(_fbb);
|
|
builder_.add_time(time);
|
|
builder_.add_state(state);
|
|
builder_.add_hash_outputs(hash_outputs);
|
|
builder_.add_hash_inputs(hash_inputs);
|
|
builder_.add_users(users);
|
|
builder_.add_nonce(nonce);
|
|
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> *nonce = nullptr,
|
|
const std::vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *users = nullptr,
|
|
const std::vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *hash_inputs = nullptr,
|
|
const std::vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *hash_outputs = nullptr,
|
|
const std::vector<uint8_t> *state = nullptr) {
|
|
auto nonce__ = nonce ? _fbb.CreateVector<uint8_t>(*nonce) : 0;
|
|
auto users__ = users ? _fbb.CreateVector<flatbuffers::Offset<msg::fbuf::ByteArray>>(*users) : 0;
|
|
auto hash_inputs__ = hash_inputs ? _fbb.CreateVector<flatbuffers::Offset<msg::fbuf::ByteArray>>(*hash_inputs) : 0;
|
|
auto hash_outputs__ = hash_outputs ? _fbb.CreateVector<flatbuffers::Offset<msg::fbuf::ByteArray>>(*hash_outputs) : 0;
|
|
auto state__ = state ? _fbb.CreateVector<uint8_t>(*state) : 0;
|
|
return msg::fbuf::p2pmsg::CreateProposal_Message(
|
|
_fbb,
|
|
stage,
|
|
time,
|
|
nonce__,
|
|
users__,
|
|
hash_inputs__,
|
|
hash_outputs__,
|
|
state__);
|
|
}
|
|
|
|
struct Npl_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
|
typedef Npl_MessageBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_DATA = 4
|
|
};
|
|
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);
|
|
}
|
|
bool Verify(flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_DATA) &&
|
|
verifier.VerifyVector(data()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct Npl_MessageBuilder {
|
|
typedef Npl_Message Table;
|
|
flatbuffers::FlatBufferBuilder &fbb_;
|
|
flatbuffers::uoffset_t start_;
|
|
void add_data(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data) {
|
|
fbb_.AddOffset(Npl_Message::VT_DATA, data);
|
|
}
|
|
explicit Npl_MessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
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>> data = 0) {
|
|
Npl_MessageBuilder builder_(_fbb);
|
|
builder_.add_data(data);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline flatbuffers::Offset<Npl_Message> CreateNpl_MessageDirect(
|
|
flatbuffers::FlatBufferBuilder &_fbb,
|
|
const std::vector<uint8_t> *data = nullptr) {
|
|
auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
|
|
return msg::fbuf::p2pmsg::CreateNpl_Message(
|
|
_fbb,
|
|
data__);
|
|
}
|
|
|
|
struct History_Request_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
|
typedef History_Request_MessageBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_REQUIRED_LCL = 4
|
|
};
|
|
const flatbuffers::Vector<uint8_t> *required_lcl() const {
|
|
return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_REQUIRED_LCL);
|
|
}
|
|
flatbuffers::Vector<uint8_t> *mutable_required_lcl() {
|
|
return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_REQUIRED_LCL);
|
|
}
|
|
bool Verify(flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_REQUIRED_LCL) &&
|
|
verifier.VerifyVector(required_lcl()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct History_Request_MessageBuilder {
|
|
typedef History_Request_Message Table;
|
|
flatbuffers::FlatBufferBuilder &fbb_;
|
|
flatbuffers::uoffset_t start_;
|
|
void add_required_lcl(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> required_lcl) {
|
|
fbb_.AddOffset(History_Request_Message::VT_REQUIRED_LCL, required_lcl);
|
|
}
|
|
explicit History_Request_MessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
flatbuffers::Offset<History_Request_Message> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = flatbuffers::Offset<History_Request_Message>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline flatbuffers::Offset<History_Request_Message> CreateHistory_Request_Message(
|
|
flatbuffers::FlatBufferBuilder &_fbb,
|
|
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> required_lcl = 0) {
|
|
History_Request_MessageBuilder builder_(_fbb);
|
|
builder_.add_required_lcl(required_lcl);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline flatbuffers::Offset<History_Request_Message> CreateHistory_Request_MessageDirect(
|
|
flatbuffers::FlatBufferBuilder &_fbb,
|
|
const std::vector<uint8_t> *required_lcl = nullptr) {
|
|
auto required_lcl__ = required_lcl ? _fbb.CreateVector<uint8_t>(*required_lcl) : 0;
|
|
return msg::fbuf::p2pmsg::CreateHistory_Request_Message(
|
|
_fbb,
|
|
required_lcl__);
|
|
}
|
|
|
|
struct History_Response_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
|
typedef History_Response_MessageBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_REQUESTER_LCL = 4,
|
|
VT_HIST_LEDGER_BLOCKS = 6,
|
|
VT_ERROR = 8
|
|
};
|
|
const flatbuffers::Vector<uint8_t> *requester_lcl() const {
|
|
return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_REQUESTER_LCL);
|
|
}
|
|
flatbuffers::Vector<uint8_t> *mutable_requester_lcl() {
|
|
return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_REQUESTER_LCL);
|
|
}
|
|
const flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::p2pmsg::HistoryLedgerBlockPair>> *hist_ledger_blocks() const {
|
|
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::p2pmsg::HistoryLedgerBlockPair>> *>(VT_HIST_LEDGER_BLOCKS);
|
|
}
|
|
flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::p2pmsg::HistoryLedgerBlockPair>> *mutable_hist_ledger_blocks() {
|
|
return GetPointer<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::p2pmsg::HistoryLedgerBlockPair>> *>(VT_HIST_LEDGER_BLOCKS);
|
|
}
|
|
msg::fbuf::p2pmsg::Ledger_Response_Error error() const {
|
|
return static_cast<msg::fbuf::p2pmsg::Ledger_Response_Error>(GetField<uint8_t>(VT_ERROR, 0));
|
|
}
|
|
bool mutate_error(msg::fbuf::p2pmsg::Ledger_Response_Error _error) {
|
|
return SetField<uint8_t>(VT_ERROR, static_cast<uint8_t>(_error), 0);
|
|
}
|
|
bool Verify(flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_REQUESTER_LCL) &&
|
|
verifier.VerifyVector(requester_lcl()) &&
|
|
VerifyOffset(verifier, VT_HIST_LEDGER_BLOCKS) &&
|
|
verifier.VerifyVector(hist_ledger_blocks()) &&
|
|
verifier.VerifyVectorOfTables(hist_ledger_blocks()) &&
|
|
VerifyField<uint8_t>(verifier, VT_ERROR) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct History_Response_MessageBuilder {
|
|
typedef History_Response_Message Table;
|
|
flatbuffers::FlatBufferBuilder &fbb_;
|
|
flatbuffers::uoffset_t start_;
|
|
void add_requester_lcl(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> requester_lcl) {
|
|
fbb_.AddOffset(History_Response_Message::VT_REQUESTER_LCL, requester_lcl);
|
|
}
|
|
void add_hist_ledger_blocks(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::p2pmsg::HistoryLedgerBlockPair>>> hist_ledger_blocks) {
|
|
fbb_.AddOffset(History_Response_Message::VT_HIST_LEDGER_BLOCKS, hist_ledger_blocks);
|
|
}
|
|
void add_error(msg::fbuf::p2pmsg::Ledger_Response_Error error) {
|
|
fbb_.AddElement<uint8_t>(History_Response_Message::VT_ERROR, static_cast<uint8_t>(error), 0);
|
|
}
|
|
explicit History_Response_MessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
flatbuffers::Offset<History_Response_Message> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = flatbuffers::Offset<History_Response_Message>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline flatbuffers::Offset<History_Response_Message> CreateHistory_Response_Message(
|
|
flatbuffers::FlatBufferBuilder &_fbb,
|
|
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> requester_lcl = 0,
|
|
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::p2pmsg::HistoryLedgerBlockPair>>> hist_ledger_blocks = 0,
|
|
msg::fbuf::p2pmsg::Ledger_Response_Error error = msg::fbuf::p2pmsg::Ledger_Response_Error_None) {
|
|
History_Response_MessageBuilder builder_(_fbb);
|
|
builder_.add_hist_ledger_blocks(hist_ledger_blocks);
|
|
builder_.add_requester_lcl(requester_lcl);
|
|
builder_.add_error(error);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline flatbuffers::Offset<History_Response_Message> CreateHistory_Response_MessageDirect(
|
|
flatbuffers::FlatBufferBuilder &_fbb,
|
|
const std::vector<uint8_t> *requester_lcl = nullptr,
|
|
const std::vector<flatbuffers::Offset<msg::fbuf::p2pmsg::HistoryLedgerBlockPair>> *hist_ledger_blocks = nullptr,
|
|
msg::fbuf::p2pmsg::Ledger_Response_Error error = msg::fbuf::p2pmsg::Ledger_Response_Error_None) {
|
|
auto requester_lcl__ = requester_lcl ? _fbb.CreateVector<uint8_t>(*requester_lcl) : 0;
|
|
auto hist_ledger_blocks__ = hist_ledger_blocks ? _fbb.CreateVector<flatbuffers::Offset<msg::fbuf::p2pmsg::HistoryLedgerBlockPair>>(*hist_ledger_blocks) : 0;
|
|
return msg::fbuf::p2pmsg::CreateHistory_Response_Message(
|
|
_fbb,
|
|
requester_lcl__,
|
|
hist_ledger_blocks__,
|
|
error);
|
|
}
|
|
|
|
struct HistoryLedgerBlockPair FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
|
typedef HistoryLedgerBlockPairBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_SEQ_NO = 4,
|
|
VT_LEDGER = 6
|
|
};
|
|
uint64_t seq_no() const {
|
|
return GetField<uint64_t>(VT_SEQ_NO, 0);
|
|
}
|
|
bool mutate_seq_no(uint64_t _seq_no) {
|
|
return SetField<uint64_t>(VT_SEQ_NO, _seq_no, 0);
|
|
}
|
|
const msg::fbuf::p2pmsg::HistoryLedgerBlock *ledger() const {
|
|
return GetPointer<const msg::fbuf::p2pmsg::HistoryLedgerBlock *>(VT_LEDGER);
|
|
}
|
|
msg::fbuf::p2pmsg::HistoryLedgerBlock *mutable_ledger() {
|
|
return GetPointer<msg::fbuf::p2pmsg::HistoryLedgerBlock *>(VT_LEDGER);
|
|
}
|
|
bool Verify(flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<uint64_t>(verifier, VT_SEQ_NO) &&
|
|
VerifyOffset(verifier, VT_LEDGER) &&
|
|
verifier.VerifyTable(ledger()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct HistoryLedgerBlockPairBuilder {
|
|
typedef HistoryLedgerBlockPair Table;
|
|
flatbuffers::FlatBufferBuilder &fbb_;
|
|
flatbuffers::uoffset_t start_;
|
|
void add_seq_no(uint64_t seq_no) {
|
|
fbb_.AddElement<uint64_t>(HistoryLedgerBlockPair::VT_SEQ_NO, seq_no, 0);
|
|
}
|
|
void add_ledger(flatbuffers::Offset<msg::fbuf::p2pmsg::HistoryLedgerBlock> ledger) {
|
|
fbb_.AddOffset(HistoryLedgerBlockPair::VT_LEDGER, ledger);
|
|
}
|
|
explicit HistoryLedgerBlockPairBuilder(flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
flatbuffers::Offset<HistoryLedgerBlockPair> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = flatbuffers::Offset<HistoryLedgerBlockPair>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline flatbuffers::Offset<HistoryLedgerBlockPair> CreateHistoryLedgerBlockPair(
|
|
flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint64_t seq_no = 0,
|
|
flatbuffers::Offset<msg::fbuf::p2pmsg::HistoryLedgerBlock> ledger = 0) {
|
|
HistoryLedgerBlockPairBuilder builder_(_fbb);
|
|
builder_.add_seq_no(seq_no);
|
|
builder_.add_ledger(ledger);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
struct HistoryLedgerBlock FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
|
typedef HistoryLedgerBlockBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_LCL = 4,
|
|
VT_BLOCK_BUFFER = 6
|
|
};
|
|
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<uint8_t> *block_buffer() const {
|
|
return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_BLOCK_BUFFER);
|
|
}
|
|
flatbuffers::Vector<uint8_t> *mutable_block_buffer() {
|
|
return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_BLOCK_BUFFER);
|
|
}
|
|
bool Verify(flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_LCL) &&
|
|
verifier.VerifyVector(lcl()) &&
|
|
VerifyOffset(verifier, VT_BLOCK_BUFFER) &&
|
|
verifier.VerifyVector(block_buffer()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct HistoryLedgerBlockBuilder {
|
|
typedef HistoryLedgerBlock Table;
|
|
flatbuffers::FlatBufferBuilder &fbb_;
|
|
flatbuffers::uoffset_t start_;
|
|
void add_lcl(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> lcl) {
|
|
fbb_.AddOffset(HistoryLedgerBlock::VT_LCL, lcl);
|
|
}
|
|
void add_block_buffer(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> block_buffer) {
|
|
fbb_.AddOffset(HistoryLedgerBlock::VT_BLOCK_BUFFER, block_buffer);
|
|
}
|
|
explicit HistoryLedgerBlockBuilder(flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
flatbuffers::Offset<HistoryLedgerBlock> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = flatbuffers::Offset<HistoryLedgerBlock>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline flatbuffers::Offset<HistoryLedgerBlock> CreateHistoryLedgerBlock(
|
|
flatbuffers::FlatBufferBuilder &_fbb,
|
|
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> lcl = 0,
|
|
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> block_buffer = 0) {
|
|
HistoryLedgerBlockBuilder builder_(_fbb);
|
|
builder_.add_block_buffer(block_buffer);
|
|
builder_.add_lcl(lcl);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline flatbuffers::Offset<HistoryLedgerBlock> CreateHistoryLedgerBlockDirect(
|
|
flatbuffers::FlatBufferBuilder &_fbb,
|
|
const std::vector<uint8_t> *lcl = nullptr,
|
|
const std::vector<uint8_t> *block_buffer = nullptr) {
|
|
auto lcl__ = lcl ? _fbb.CreateVector<uint8_t>(*lcl) : 0;
|
|
auto block_buffer__ = block_buffer ? _fbb.CreateVector<uint8_t>(*block_buffer) : 0;
|
|
return msg::fbuf::p2pmsg::CreateHistoryLedgerBlock(
|
|
_fbb,
|
|
lcl__,
|
|
block_buffer__);
|
|
}
|
|
|
|
struct State_Request_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
|
typedef State_Request_MessageBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_PARENT_PATH = 4,
|
|
VT_IS_FILE = 6,
|
|
VT_BLOCK_ID = 8,
|
|
VT_EXPECTED_HASH = 10
|
|
};
|
|
const flatbuffers::String *parent_path() const {
|
|
return GetPointer<const flatbuffers::String *>(VT_PARENT_PATH);
|
|
}
|
|
flatbuffers::String *mutable_parent_path() {
|
|
return GetPointer<flatbuffers::String *>(VT_PARENT_PATH);
|
|
}
|
|
bool is_file() const {
|
|
return GetField<uint8_t>(VT_IS_FILE, 0) != 0;
|
|
}
|
|
bool mutate_is_file(bool _is_file) {
|
|
return SetField<uint8_t>(VT_IS_FILE, static_cast<uint8_t>(_is_file), 0);
|
|
}
|
|
int32_t block_id() const {
|
|
return GetField<int32_t>(VT_BLOCK_ID, 0);
|
|
}
|
|
bool mutate_block_id(int32_t _block_id) {
|
|
return SetField<int32_t>(VT_BLOCK_ID, _block_id, 0);
|
|
}
|
|
const flatbuffers::Vector<uint8_t> *expected_hash() const {
|
|
return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_EXPECTED_HASH);
|
|
}
|
|
flatbuffers::Vector<uint8_t> *mutable_expected_hash() {
|
|
return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_EXPECTED_HASH);
|
|
}
|
|
bool Verify(flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_PARENT_PATH) &&
|
|
verifier.VerifyString(parent_path()) &&
|
|
VerifyField<uint8_t>(verifier, VT_IS_FILE) &&
|
|
VerifyField<int32_t>(verifier, VT_BLOCK_ID) &&
|
|
VerifyOffset(verifier, VT_EXPECTED_HASH) &&
|
|
verifier.VerifyVector(expected_hash()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct State_Request_MessageBuilder {
|
|
typedef State_Request_Message Table;
|
|
flatbuffers::FlatBufferBuilder &fbb_;
|
|
flatbuffers::uoffset_t start_;
|
|
void add_parent_path(flatbuffers::Offset<flatbuffers::String> parent_path) {
|
|
fbb_.AddOffset(State_Request_Message::VT_PARENT_PATH, parent_path);
|
|
}
|
|
void add_is_file(bool is_file) {
|
|
fbb_.AddElement<uint8_t>(State_Request_Message::VT_IS_FILE, static_cast<uint8_t>(is_file), 0);
|
|
}
|
|
void add_block_id(int32_t block_id) {
|
|
fbb_.AddElement<int32_t>(State_Request_Message::VT_BLOCK_ID, block_id, 0);
|
|
}
|
|
void add_expected_hash(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> expected_hash) {
|
|
fbb_.AddOffset(State_Request_Message::VT_EXPECTED_HASH, expected_hash);
|
|
}
|
|
explicit State_Request_MessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
flatbuffers::Offset<State_Request_Message> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = flatbuffers::Offset<State_Request_Message>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline flatbuffers::Offset<State_Request_Message> CreateState_Request_Message(
|
|
flatbuffers::FlatBufferBuilder &_fbb,
|
|
flatbuffers::Offset<flatbuffers::String> parent_path = 0,
|
|
bool is_file = false,
|
|
int32_t block_id = 0,
|
|
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> expected_hash = 0) {
|
|
State_Request_MessageBuilder builder_(_fbb);
|
|
builder_.add_expected_hash(expected_hash);
|
|
builder_.add_block_id(block_id);
|
|
builder_.add_parent_path(parent_path);
|
|
builder_.add_is_file(is_file);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline flatbuffers::Offset<State_Request_Message> CreateState_Request_MessageDirect(
|
|
flatbuffers::FlatBufferBuilder &_fbb,
|
|
const char *parent_path = nullptr,
|
|
bool is_file = false,
|
|
int32_t block_id = 0,
|
|
const std::vector<uint8_t> *expected_hash = nullptr) {
|
|
auto parent_path__ = parent_path ? _fbb.CreateString(parent_path) : 0;
|
|
auto expected_hash__ = expected_hash ? _fbb.CreateVector<uint8_t>(*expected_hash) : 0;
|
|
return msg::fbuf::p2pmsg::CreateState_Request_Message(
|
|
_fbb,
|
|
parent_path__,
|
|
is_file,
|
|
block_id,
|
|
expected_hash__);
|
|
}
|
|
|
|
struct State_Response_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
|
typedef State_Response_MessageBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_STATE_RESPONSE_TYPE = 4,
|
|
VT_STATE_RESPONSE = 6,
|
|
VT_HASH = 8,
|
|
VT_PATH = 10
|
|
};
|
|
msg::fbuf::p2pmsg::State_Response state_response_type() const {
|
|
return static_cast<msg::fbuf::p2pmsg::State_Response>(GetField<uint8_t>(VT_STATE_RESPONSE_TYPE, 0));
|
|
}
|
|
const void *state_response() const {
|
|
return GetPointer<const void *>(VT_STATE_RESPONSE);
|
|
}
|
|
template<typename T> const T *state_response_as() const;
|
|
const msg::fbuf::p2pmsg::File_HashMap_Response *state_response_as_File_HashMap_Response() const {
|
|
return state_response_type() == msg::fbuf::p2pmsg::State_Response_File_HashMap_Response ? static_cast<const msg::fbuf::p2pmsg::File_HashMap_Response *>(state_response()) : nullptr;
|
|
}
|
|
const msg::fbuf::p2pmsg::Block_Response *state_response_as_Block_Response() const {
|
|
return state_response_type() == msg::fbuf::p2pmsg::State_Response_Block_Response ? static_cast<const msg::fbuf::p2pmsg::Block_Response *>(state_response()) : nullptr;
|
|
}
|
|
const msg::fbuf::p2pmsg::Fs_Entry_Response *state_response_as_Fs_Entry_Response() const {
|
|
return state_response_type() == msg::fbuf::p2pmsg::State_Response_Fs_Entry_Response ? static_cast<const msg::fbuf::p2pmsg::Fs_Entry_Response *>(state_response()) : nullptr;
|
|
}
|
|
void *mutable_state_response() {
|
|
return GetPointer<void *>(VT_STATE_RESPONSE);
|
|
}
|
|
const flatbuffers::Vector<uint8_t> *hash() const {
|
|
return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_HASH);
|
|
}
|
|
flatbuffers::Vector<uint8_t> *mutable_hash() {
|
|
return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_HASH);
|
|
}
|
|
const flatbuffers::String *path() const {
|
|
return GetPointer<const flatbuffers::String *>(VT_PATH);
|
|
}
|
|
flatbuffers::String *mutable_path() {
|
|
return GetPointer<flatbuffers::String *>(VT_PATH);
|
|
}
|
|
bool Verify(flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<uint8_t>(verifier, VT_STATE_RESPONSE_TYPE) &&
|
|
VerifyOffset(verifier, VT_STATE_RESPONSE) &&
|
|
VerifyState_Response(verifier, state_response(), state_response_type()) &&
|
|
VerifyOffset(verifier, VT_HASH) &&
|
|
verifier.VerifyVector(hash()) &&
|
|
VerifyOffset(verifier, VT_PATH) &&
|
|
verifier.VerifyString(path()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
template<> inline const msg::fbuf::p2pmsg::File_HashMap_Response *State_Response_Message::state_response_as<msg::fbuf::p2pmsg::File_HashMap_Response>() const {
|
|
return state_response_as_File_HashMap_Response();
|
|
}
|
|
|
|
template<> inline const msg::fbuf::p2pmsg::Block_Response *State_Response_Message::state_response_as<msg::fbuf::p2pmsg::Block_Response>() const {
|
|
return state_response_as_Block_Response();
|
|
}
|
|
|
|
template<> inline const msg::fbuf::p2pmsg::Fs_Entry_Response *State_Response_Message::state_response_as<msg::fbuf::p2pmsg::Fs_Entry_Response>() const {
|
|
return state_response_as_Fs_Entry_Response();
|
|
}
|
|
|
|
struct State_Response_MessageBuilder {
|
|
typedef State_Response_Message Table;
|
|
flatbuffers::FlatBufferBuilder &fbb_;
|
|
flatbuffers::uoffset_t start_;
|
|
void add_state_response_type(msg::fbuf::p2pmsg::State_Response state_response_type) {
|
|
fbb_.AddElement<uint8_t>(State_Response_Message::VT_STATE_RESPONSE_TYPE, static_cast<uint8_t>(state_response_type), 0);
|
|
}
|
|
void add_state_response(flatbuffers::Offset<void> state_response) {
|
|
fbb_.AddOffset(State_Response_Message::VT_STATE_RESPONSE, state_response);
|
|
}
|
|
void add_hash(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> hash) {
|
|
fbb_.AddOffset(State_Response_Message::VT_HASH, hash);
|
|
}
|
|
void add_path(flatbuffers::Offset<flatbuffers::String> path) {
|
|
fbb_.AddOffset(State_Response_Message::VT_PATH, path);
|
|
}
|
|
explicit State_Response_MessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
flatbuffers::Offset<State_Response_Message> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = flatbuffers::Offset<State_Response_Message>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline flatbuffers::Offset<State_Response_Message> CreateState_Response_Message(
|
|
flatbuffers::FlatBufferBuilder &_fbb,
|
|
msg::fbuf::p2pmsg::State_Response state_response_type = msg::fbuf::p2pmsg::State_Response_NONE,
|
|
flatbuffers::Offset<void> state_response = 0,
|
|
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> hash = 0,
|
|
flatbuffers::Offset<flatbuffers::String> path = 0) {
|
|
State_Response_MessageBuilder builder_(_fbb);
|
|
builder_.add_path(path);
|
|
builder_.add_hash(hash);
|
|
builder_.add_state_response(state_response);
|
|
builder_.add_state_response_type(state_response_type);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline flatbuffers::Offset<State_Response_Message> CreateState_Response_MessageDirect(
|
|
flatbuffers::FlatBufferBuilder &_fbb,
|
|
msg::fbuf::p2pmsg::State_Response state_response_type = msg::fbuf::p2pmsg::State_Response_NONE,
|
|
flatbuffers::Offset<void> state_response = 0,
|
|
const std::vector<uint8_t> *hash = nullptr,
|
|
const char *path = nullptr) {
|
|
auto hash__ = hash ? _fbb.CreateVector<uint8_t>(*hash) : 0;
|
|
auto path__ = path ? _fbb.CreateString(path) : 0;
|
|
return msg::fbuf::p2pmsg::CreateState_Response_Message(
|
|
_fbb,
|
|
state_response_type,
|
|
state_response,
|
|
hash__,
|
|
path__);
|
|
}
|
|
|
|
struct Fs_Entry_Response FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
|
typedef Fs_Entry_ResponseBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_ENTRIES = 4
|
|
};
|
|
const flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::p2pmsg::State_FS_Hash_Entry>> *entries() const {
|
|
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::p2pmsg::State_FS_Hash_Entry>> *>(VT_ENTRIES);
|
|
}
|
|
flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::p2pmsg::State_FS_Hash_Entry>> *mutable_entries() {
|
|
return GetPointer<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::p2pmsg::State_FS_Hash_Entry>> *>(VT_ENTRIES);
|
|
}
|
|
bool Verify(flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_ENTRIES) &&
|
|
verifier.VerifyVector(entries()) &&
|
|
verifier.VerifyVectorOfTables(entries()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct Fs_Entry_ResponseBuilder {
|
|
typedef Fs_Entry_Response Table;
|
|
flatbuffers::FlatBufferBuilder &fbb_;
|
|
flatbuffers::uoffset_t start_;
|
|
void add_entries(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::p2pmsg::State_FS_Hash_Entry>>> entries) {
|
|
fbb_.AddOffset(Fs_Entry_Response::VT_ENTRIES, entries);
|
|
}
|
|
explicit Fs_Entry_ResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
flatbuffers::Offset<Fs_Entry_Response> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = flatbuffers::Offset<Fs_Entry_Response>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline flatbuffers::Offset<Fs_Entry_Response> CreateFs_Entry_Response(
|
|
flatbuffers::FlatBufferBuilder &_fbb,
|
|
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::p2pmsg::State_FS_Hash_Entry>>> entries = 0) {
|
|
Fs_Entry_ResponseBuilder builder_(_fbb);
|
|
builder_.add_entries(entries);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline flatbuffers::Offset<Fs_Entry_Response> CreateFs_Entry_ResponseDirect(
|
|
flatbuffers::FlatBufferBuilder &_fbb,
|
|
const std::vector<flatbuffers::Offset<msg::fbuf::p2pmsg::State_FS_Hash_Entry>> *entries = nullptr) {
|
|
auto entries__ = entries ? _fbb.CreateVector<flatbuffers::Offset<msg::fbuf::p2pmsg::State_FS_Hash_Entry>>(*entries) : 0;
|
|
return msg::fbuf::p2pmsg::CreateFs_Entry_Response(
|
|
_fbb,
|
|
entries__);
|
|
}
|
|
|
|
struct File_HashMap_Response FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
|
typedef File_HashMap_ResponseBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_FILE_LENGTH = 4,
|
|
VT_HASH_MAP = 6
|
|
};
|
|
uint64_t file_length() const {
|
|
return GetField<uint64_t>(VT_FILE_LENGTH, 0);
|
|
}
|
|
bool mutate_file_length(uint64_t _file_length) {
|
|
return SetField<uint64_t>(VT_FILE_LENGTH, _file_length, 0);
|
|
}
|
|
const flatbuffers::Vector<uint8_t> *hash_map() const {
|
|
return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_HASH_MAP);
|
|
}
|
|
flatbuffers::Vector<uint8_t> *mutable_hash_map() {
|
|
return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_HASH_MAP);
|
|
}
|
|
bool Verify(flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<uint64_t>(verifier, VT_FILE_LENGTH) &&
|
|
VerifyOffset(verifier, VT_HASH_MAP) &&
|
|
verifier.VerifyVector(hash_map()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct File_HashMap_ResponseBuilder {
|
|
typedef File_HashMap_Response Table;
|
|
flatbuffers::FlatBufferBuilder &fbb_;
|
|
flatbuffers::uoffset_t start_;
|
|
void add_file_length(uint64_t file_length) {
|
|
fbb_.AddElement<uint64_t>(File_HashMap_Response::VT_FILE_LENGTH, file_length, 0);
|
|
}
|
|
void add_hash_map(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> hash_map) {
|
|
fbb_.AddOffset(File_HashMap_Response::VT_HASH_MAP, hash_map);
|
|
}
|
|
explicit File_HashMap_ResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
flatbuffers::Offset<File_HashMap_Response> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = flatbuffers::Offset<File_HashMap_Response>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline flatbuffers::Offset<File_HashMap_Response> CreateFile_HashMap_Response(
|
|
flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint64_t file_length = 0,
|
|
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> hash_map = 0) {
|
|
File_HashMap_ResponseBuilder builder_(_fbb);
|
|
builder_.add_file_length(file_length);
|
|
builder_.add_hash_map(hash_map);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline flatbuffers::Offset<File_HashMap_Response> CreateFile_HashMap_ResponseDirect(
|
|
flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint64_t file_length = 0,
|
|
const std::vector<uint8_t> *hash_map = nullptr) {
|
|
auto hash_map__ = hash_map ? _fbb.CreateVector<uint8_t>(*hash_map) : 0;
|
|
return msg::fbuf::p2pmsg::CreateFile_HashMap_Response(
|
|
_fbb,
|
|
file_length,
|
|
hash_map__);
|
|
}
|
|
|
|
struct Block_Response FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
|
typedef Block_ResponseBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_BLOCK_ID = 4,
|
|
VT_DATA = 6
|
|
};
|
|
uint32_t block_id() const {
|
|
return GetField<uint32_t>(VT_BLOCK_ID, 0);
|
|
}
|
|
bool mutate_block_id(uint32_t _block_id) {
|
|
return SetField<uint32_t>(VT_BLOCK_ID, _block_id, 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);
|
|
}
|
|
bool Verify(flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<uint32_t>(verifier, VT_BLOCK_ID) &&
|
|
VerifyOffset(verifier, VT_DATA) &&
|
|
verifier.VerifyVector(data()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct Block_ResponseBuilder {
|
|
typedef Block_Response Table;
|
|
flatbuffers::FlatBufferBuilder &fbb_;
|
|
flatbuffers::uoffset_t start_;
|
|
void add_block_id(uint32_t block_id) {
|
|
fbb_.AddElement<uint32_t>(Block_Response::VT_BLOCK_ID, block_id, 0);
|
|
}
|
|
void add_data(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data) {
|
|
fbb_.AddOffset(Block_Response::VT_DATA, data);
|
|
}
|
|
explicit Block_ResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
flatbuffers::Offset<Block_Response> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = flatbuffers::Offset<Block_Response>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline flatbuffers::Offset<Block_Response> CreateBlock_Response(
|
|
flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint32_t block_id = 0,
|
|
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data = 0) {
|
|
Block_ResponseBuilder builder_(_fbb);
|
|
builder_.add_data(data);
|
|
builder_.add_block_id(block_id);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline flatbuffers::Offset<Block_Response> CreateBlock_ResponseDirect(
|
|
flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint32_t block_id = 0,
|
|
const std::vector<uint8_t> *data = nullptr) {
|
|
auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
|
|
return msg::fbuf::p2pmsg::CreateBlock_Response(
|
|
_fbb,
|
|
block_id,
|
|
data__);
|
|
}
|
|
|
|
struct State_FS_Hash_Entry FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
|
typedef State_FS_Hash_EntryBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_NAME = 4,
|
|
VT_IS_FILE = 6,
|
|
VT_HASH = 8
|
|
};
|
|
const flatbuffers::String *name() const {
|
|
return GetPointer<const flatbuffers::String *>(VT_NAME);
|
|
}
|
|
flatbuffers::String *mutable_name() {
|
|
return GetPointer<flatbuffers::String *>(VT_NAME);
|
|
}
|
|
bool is_file() const {
|
|
return GetField<uint8_t>(VT_IS_FILE, 0) != 0;
|
|
}
|
|
bool mutate_is_file(bool _is_file) {
|
|
return SetField<uint8_t>(VT_IS_FILE, static_cast<uint8_t>(_is_file), 0);
|
|
}
|
|
const flatbuffers::Vector<uint8_t> *hash() const {
|
|
return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_HASH);
|
|
}
|
|
flatbuffers::Vector<uint8_t> *mutable_hash() {
|
|
return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_HASH);
|
|
}
|
|
bool Verify(flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_NAME) &&
|
|
verifier.VerifyString(name()) &&
|
|
VerifyField<uint8_t>(verifier, VT_IS_FILE) &&
|
|
VerifyOffset(verifier, VT_HASH) &&
|
|
verifier.VerifyVector(hash()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct State_FS_Hash_EntryBuilder {
|
|
typedef State_FS_Hash_Entry Table;
|
|
flatbuffers::FlatBufferBuilder &fbb_;
|
|
flatbuffers::uoffset_t start_;
|
|
void add_name(flatbuffers::Offset<flatbuffers::String> name) {
|
|
fbb_.AddOffset(State_FS_Hash_Entry::VT_NAME, name);
|
|
}
|
|
void add_is_file(bool is_file) {
|
|
fbb_.AddElement<uint8_t>(State_FS_Hash_Entry::VT_IS_FILE, static_cast<uint8_t>(is_file), 0);
|
|
}
|
|
void add_hash(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> hash) {
|
|
fbb_.AddOffset(State_FS_Hash_Entry::VT_HASH, hash);
|
|
}
|
|
explicit State_FS_Hash_EntryBuilder(flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
flatbuffers::Offset<State_FS_Hash_Entry> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = flatbuffers::Offset<State_FS_Hash_Entry>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline flatbuffers::Offset<State_FS_Hash_Entry> CreateState_FS_Hash_Entry(
|
|
flatbuffers::FlatBufferBuilder &_fbb,
|
|
flatbuffers::Offset<flatbuffers::String> name = 0,
|
|
bool is_file = false,
|
|
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> hash = 0) {
|
|
State_FS_Hash_EntryBuilder builder_(_fbb);
|
|
builder_.add_hash(hash);
|
|
builder_.add_name(name);
|
|
builder_.add_is_file(is_file);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline flatbuffers::Offset<State_FS_Hash_Entry> CreateState_FS_Hash_EntryDirect(
|
|
flatbuffers::FlatBufferBuilder &_fbb,
|
|
const char *name = nullptr,
|
|
bool is_file = false,
|
|
const std::vector<uint8_t> *hash = nullptr) {
|
|
auto name__ = name ? _fbb.CreateString(name) : 0;
|
|
auto hash__ = hash ? _fbb.CreateVector<uint8_t>(*hash) : 0;
|
|
return msg::fbuf::p2pmsg::CreateState_FS_Hash_Entry(
|
|
_fbb,
|
|
name__,
|
|
is_file,
|
|
hash__);
|
|
}
|
|
|
|
struct Peer_Requirement_Announcement_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
|
typedef Peer_Requirement_Announcement_MessageBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_NEED_CONSENSUS_MSG_FORWARDING = 4
|
|
};
|
|
bool need_consensus_msg_forwarding() const {
|
|
return GetField<uint8_t>(VT_NEED_CONSENSUS_MSG_FORWARDING, 0) != 0;
|
|
}
|
|
bool mutate_need_consensus_msg_forwarding(bool _need_consensus_msg_forwarding) {
|
|
return SetField<uint8_t>(VT_NEED_CONSENSUS_MSG_FORWARDING, static_cast<uint8_t>(_need_consensus_msg_forwarding), 0);
|
|
}
|
|
bool Verify(flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<uint8_t>(verifier, VT_NEED_CONSENSUS_MSG_FORWARDING) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct Peer_Requirement_Announcement_MessageBuilder {
|
|
typedef Peer_Requirement_Announcement_Message Table;
|
|
flatbuffers::FlatBufferBuilder &fbb_;
|
|
flatbuffers::uoffset_t start_;
|
|
void add_need_consensus_msg_forwarding(bool need_consensus_msg_forwarding) {
|
|
fbb_.AddElement<uint8_t>(Peer_Requirement_Announcement_Message::VT_NEED_CONSENSUS_MSG_FORWARDING, static_cast<uint8_t>(need_consensus_msg_forwarding), 0);
|
|
}
|
|
explicit Peer_Requirement_Announcement_MessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
flatbuffers::Offset<Peer_Requirement_Announcement_Message> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = flatbuffers::Offset<Peer_Requirement_Announcement_Message>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline flatbuffers::Offset<Peer_Requirement_Announcement_Message> CreatePeer_Requirement_Announcement_Message(
|
|
flatbuffers::FlatBufferBuilder &_fbb,
|
|
bool need_consensus_msg_forwarding = false) {
|
|
Peer_Requirement_Announcement_MessageBuilder builder_(_fbb);
|
|
builder_.add_need_consensus_msg_forwarding(need_consensus_msg_forwarding);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
struct Available_Capacity_Announcement_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
|
typedef Available_Capacity_Announcement_MessageBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_AVAILABLE_CAPACITY = 4,
|
|
VT_TIMESTAMP = 6
|
|
};
|
|
int16_t available_capacity() const {
|
|
return GetField<int16_t>(VT_AVAILABLE_CAPACITY, 0);
|
|
}
|
|
bool mutate_available_capacity(int16_t _available_capacity) {
|
|
return SetField<int16_t>(VT_AVAILABLE_CAPACITY, _available_capacity, 0);
|
|
}
|
|
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);
|
|
}
|
|
bool Verify(flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<int16_t>(verifier, VT_AVAILABLE_CAPACITY) &&
|
|
VerifyField<uint64_t>(verifier, VT_TIMESTAMP) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct Available_Capacity_Announcement_MessageBuilder {
|
|
typedef Available_Capacity_Announcement_Message Table;
|
|
flatbuffers::FlatBufferBuilder &fbb_;
|
|
flatbuffers::uoffset_t start_;
|
|
void add_available_capacity(int16_t available_capacity) {
|
|
fbb_.AddElement<int16_t>(Available_Capacity_Announcement_Message::VT_AVAILABLE_CAPACITY, available_capacity, 0);
|
|
}
|
|
void add_timestamp(uint64_t timestamp) {
|
|
fbb_.AddElement<uint64_t>(Available_Capacity_Announcement_Message::VT_TIMESTAMP, timestamp, 0);
|
|
}
|
|
explicit Available_Capacity_Announcement_MessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
flatbuffers::Offset<Available_Capacity_Announcement_Message> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = flatbuffers::Offset<Available_Capacity_Announcement_Message>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline flatbuffers::Offset<Available_Capacity_Announcement_Message> CreateAvailable_Capacity_Announcement_Message(
|
|
flatbuffers::FlatBufferBuilder &_fbb,
|
|
int16_t available_capacity = 0,
|
|
uint64_t timestamp = 0) {
|
|
Available_Capacity_Announcement_MessageBuilder builder_(_fbb);
|
|
builder_.add_timestamp(timestamp);
|
|
builder_.add_available_capacity(available_capacity);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
struct Peer_List_Request_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
|
typedef Peer_List_Request_MessageBuilder Builder;
|
|
bool Verify(flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct Peer_List_Request_MessageBuilder {
|
|
typedef Peer_List_Request_Message Table;
|
|
flatbuffers::FlatBufferBuilder &fbb_;
|
|
flatbuffers::uoffset_t start_;
|
|
explicit Peer_List_Request_MessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
flatbuffers::Offset<Peer_List_Request_Message> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = flatbuffers::Offset<Peer_List_Request_Message>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline flatbuffers::Offset<Peer_List_Request_Message> CreatePeer_List_Request_Message(
|
|
flatbuffers::FlatBufferBuilder &_fbb) {
|
|
Peer_List_Request_MessageBuilder builder_(_fbb);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
struct Peer_List_Response_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
|
typedef Peer_List_Response_MessageBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_PEER_LIST = 4
|
|
};
|
|
const flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::p2pmsg::Peer_Properties>> *peer_list() const {
|
|
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::p2pmsg::Peer_Properties>> *>(VT_PEER_LIST);
|
|
}
|
|
flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::p2pmsg::Peer_Properties>> *mutable_peer_list() {
|
|
return GetPointer<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::p2pmsg::Peer_Properties>> *>(VT_PEER_LIST);
|
|
}
|
|
bool Verify(flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_PEER_LIST) &&
|
|
verifier.VerifyVector(peer_list()) &&
|
|
verifier.VerifyVectorOfTables(peer_list()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct Peer_List_Response_MessageBuilder {
|
|
typedef Peer_List_Response_Message Table;
|
|
flatbuffers::FlatBufferBuilder &fbb_;
|
|
flatbuffers::uoffset_t start_;
|
|
void add_peer_list(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::p2pmsg::Peer_Properties>>> peer_list) {
|
|
fbb_.AddOffset(Peer_List_Response_Message::VT_PEER_LIST, peer_list);
|
|
}
|
|
explicit Peer_List_Response_MessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
flatbuffers::Offset<Peer_List_Response_Message> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = flatbuffers::Offset<Peer_List_Response_Message>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline flatbuffers::Offset<Peer_List_Response_Message> CreatePeer_List_Response_Message(
|
|
flatbuffers::FlatBufferBuilder &_fbb,
|
|
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::p2pmsg::Peer_Properties>>> peer_list = 0) {
|
|
Peer_List_Response_MessageBuilder builder_(_fbb);
|
|
builder_.add_peer_list(peer_list);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline flatbuffers::Offset<Peer_List_Response_Message> CreatePeer_List_Response_MessageDirect(
|
|
flatbuffers::FlatBufferBuilder &_fbb,
|
|
const std::vector<flatbuffers::Offset<msg::fbuf::p2pmsg::Peer_Properties>> *peer_list = nullptr) {
|
|
auto peer_list__ = peer_list ? _fbb.CreateVector<flatbuffers::Offset<msg::fbuf::p2pmsg::Peer_Properties>>(*peer_list) : 0;
|
|
return msg::fbuf::p2pmsg::CreatePeer_List_Response_Message(
|
|
_fbb,
|
|
peer_list__);
|
|
}
|
|
|
|
struct Peer_Properties FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
|
typedef Peer_PropertiesBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_HOST_ADDRESS = 4,
|
|
VT_PORT = 6,
|
|
VT_AVAILABLE_CAPACITY = 8,
|
|
VT_TIMESTAMP = 10
|
|
};
|
|
const flatbuffers::String *host_address() const {
|
|
return GetPointer<const flatbuffers::String *>(VT_HOST_ADDRESS);
|
|
}
|
|
flatbuffers::String *mutable_host_address() {
|
|
return GetPointer<flatbuffers::String *>(VT_HOST_ADDRESS);
|
|
}
|
|
uint16_t port() const {
|
|
return GetField<uint16_t>(VT_PORT, 0);
|
|
}
|
|
bool mutate_port(uint16_t _port) {
|
|
return SetField<uint16_t>(VT_PORT, _port, 0);
|
|
}
|
|
int16_t available_capacity() const {
|
|
return GetField<int16_t>(VT_AVAILABLE_CAPACITY, 0);
|
|
}
|
|
bool mutate_available_capacity(int16_t _available_capacity) {
|
|
return SetField<int16_t>(VT_AVAILABLE_CAPACITY, _available_capacity, 0);
|
|
}
|
|
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);
|
|
}
|
|
bool Verify(flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_HOST_ADDRESS) &&
|
|
verifier.VerifyString(host_address()) &&
|
|
VerifyField<uint16_t>(verifier, VT_PORT) &&
|
|
VerifyField<int16_t>(verifier, VT_AVAILABLE_CAPACITY) &&
|
|
VerifyField<uint64_t>(verifier, VT_TIMESTAMP) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct Peer_PropertiesBuilder {
|
|
typedef Peer_Properties Table;
|
|
flatbuffers::FlatBufferBuilder &fbb_;
|
|
flatbuffers::uoffset_t start_;
|
|
void add_host_address(flatbuffers::Offset<flatbuffers::String> host_address) {
|
|
fbb_.AddOffset(Peer_Properties::VT_HOST_ADDRESS, host_address);
|
|
}
|
|
void add_port(uint16_t port) {
|
|
fbb_.AddElement<uint16_t>(Peer_Properties::VT_PORT, port, 0);
|
|
}
|
|
void add_available_capacity(int16_t available_capacity) {
|
|
fbb_.AddElement<int16_t>(Peer_Properties::VT_AVAILABLE_CAPACITY, available_capacity, 0);
|
|
}
|
|
void add_timestamp(uint64_t timestamp) {
|
|
fbb_.AddElement<uint64_t>(Peer_Properties::VT_TIMESTAMP, timestamp, 0);
|
|
}
|
|
explicit Peer_PropertiesBuilder(flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
flatbuffers::Offset<Peer_Properties> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = flatbuffers::Offset<Peer_Properties>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline flatbuffers::Offset<Peer_Properties> CreatePeer_Properties(
|
|
flatbuffers::FlatBufferBuilder &_fbb,
|
|
flatbuffers::Offset<flatbuffers::String> host_address = 0,
|
|
uint16_t port = 0,
|
|
int16_t available_capacity = 0,
|
|
uint64_t timestamp = 0) {
|
|
Peer_PropertiesBuilder builder_(_fbb);
|
|
builder_.add_timestamp(timestamp);
|
|
builder_.add_host_address(host_address);
|
|
builder_.add_available_capacity(available_capacity);
|
|
builder_.add_port(port);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline flatbuffers::Offset<Peer_Properties> CreatePeer_PropertiesDirect(
|
|
flatbuffers::FlatBufferBuilder &_fbb,
|
|
const char *host_address = nullptr,
|
|
uint16_t port = 0,
|
|
int16_t available_capacity = 0,
|
|
uint64_t timestamp = 0) {
|
|
auto host_address__ = host_address ? _fbb.CreateString(host_address) : 0;
|
|
return msg::fbuf::p2pmsg::CreatePeer_Properties(
|
|
_fbb,
|
|
host_address__,
|
|
port,
|
|
available_capacity,
|
|
timestamp);
|
|
}
|
|
|
|
inline bool VerifyMessage(flatbuffers::Verifier &verifier, const void *obj, Message type) {
|
|
switch (type) {
|
|
case Message_NONE: {
|
|
return true;
|
|
}
|
|
case Message_Peer_Challenge_Response_Message: {
|
|
auto ptr = reinterpret_cast<const msg::fbuf::p2pmsg::Peer_Challenge_Response_Message *>(obj);
|
|
return verifier.VerifyTable(ptr);
|
|
}
|
|
case Message_Peer_Challenge_Message: {
|
|
auto ptr = reinterpret_cast<const msg::fbuf::p2pmsg::Peer_Challenge_Message *>(obj);
|
|
return verifier.VerifyTable(ptr);
|
|
}
|
|
case Message_NonUnl_Proposal_Message: {
|
|
auto ptr = reinterpret_cast<const msg::fbuf::p2pmsg::NonUnl_Proposal_Message *>(obj);
|
|
return verifier.VerifyTable(ptr);
|
|
}
|
|
case Message_Proposal_Message: {
|
|
auto ptr = reinterpret_cast<const msg::fbuf::p2pmsg::Proposal_Message *>(obj);
|
|
return verifier.VerifyTable(ptr);
|
|
}
|
|
case Message_Npl_Message: {
|
|
auto ptr = reinterpret_cast<const msg::fbuf::p2pmsg::Npl_Message *>(obj);
|
|
return verifier.VerifyTable(ptr);
|
|
}
|
|
case Message_State_Request_Message: {
|
|
auto ptr = reinterpret_cast<const msg::fbuf::p2pmsg::State_Request_Message *>(obj);
|
|
return verifier.VerifyTable(ptr);
|
|
}
|
|
case Message_State_Response_Message: {
|
|
auto ptr = reinterpret_cast<const msg::fbuf::p2pmsg::State_Response_Message *>(obj);
|
|
return verifier.VerifyTable(ptr);
|
|
}
|
|
case Message_History_Request_Message: {
|
|
auto ptr = reinterpret_cast<const msg::fbuf::p2pmsg::History_Request_Message *>(obj);
|
|
return verifier.VerifyTable(ptr);
|
|
}
|
|
case Message_History_Response_Message: {
|
|
auto ptr = reinterpret_cast<const msg::fbuf::p2pmsg::History_Response_Message *>(obj);
|
|
return verifier.VerifyTable(ptr);
|
|
}
|
|
case Message_Peer_Requirement_Announcement_Message: {
|
|
auto ptr = reinterpret_cast<const msg::fbuf::p2pmsg::Peer_Requirement_Announcement_Message *>(obj);
|
|
return verifier.VerifyTable(ptr);
|
|
}
|
|
case Message_Peer_List_Request_Message: {
|
|
auto ptr = reinterpret_cast<const msg::fbuf::p2pmsg::Peer_List_Request_Message *>(obj);
|
|
return verifier.VerifyTable(ptr);
|
|
}
|
|
case Message_Peer_List_Response_Message: {
|
|
auto ptr = reinterpret_cast<const msg::fbuf::p2pmsg::Peer_List_Response_Message *>(obj);
|
|
return verifier.VerifyTable(ptr);
|
|
}
|
|
case Message_Available_Capacity_Announcement_Message: {
|
|
auto ptr = reinterpret_cast<const msg::fbuf::p2pmsg::Available_Capacity_Announcement_Message *>(obj);
|
|
return verifier.VerifyTable(ptr);
|
|
}
|
|
default: return true;
|
|
}
|
|
}
|
|
|
|
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 bool VerifyState_Response(flatbuffers::Verifier &verifier, const void *obj, State_Response type) {
|
|
switch (type) {
|
|
case State_Response_NONE: {
|
|
return true;
|
|
}
|
|
case State_Response_File_HashMap_Response: {
|
|
auto ptr = reinterpret_cast<const msg::fbuf::p2pmsg::File_HashMap_Response *>(obj);
|
|
return verifier.VerifyTable(ptr);
|
|
}
|
|
case State_Response_Block_Response: {
|
|
auto ptr = reinterpret_cast<const msg::fbuf::p2pmsg::Block_Response *>(obj);
|
|
return verifier.VerifyTable(ptr);
|
|
}
|
|
case State_Response_Fs_Entry_Response: {
|
|
auto ptr = reinterpret_cast<const msg::fbuf::p2pmsg::Fs_Entry_Response *>(obj);
|
|
return verifier.VerifyTable(ptr);
|
|
}
|
|
default: return true;
|
|
}
|
|
}
|
|
|
|
inline bool VerifyState_ResponseVector(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 (!VerifyState_Response(
|
|
verifier, values->Get(i), types->GetEnum<State_Response>(i))) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
inline const msg::fbuf::p2pmsg::Content *GetContent(const void *buf) {
|
|
return flatbuffers::GetRoot<msg::fbuf::p2pmsg::Content>(buf);
|
|
}
|
|
|
|
inline const msg::fbuf::p2pmsg::Content *GetSizePrefixedContent(const void *buf) {
|
|
return flatbuffers::GetSizePrefixedRoot<msg::fbuf::p2pmsg::Content>(buf);
|
|
}
|
|
|
|
inline Content *GetMutableContent(void *buf) {
|
|
return flatbuffers::GetMutableRoot<Content>(buf);
|
|
}
|
|
|
|
inline bool VerifyContentBuffer(
|
|
flatbuffers::Verifier &verifier) {
|
|
return verifier.VerifyBuffer<msg::fbuf::p2pmsg::Content>(nullptr);
|
|
}
|
|
|
|
inline bool VerifySizePrefixedContentBuffer(
|
|
flatbuffers::Verifier &verifier) {
|
|
return verifier.VerifySizePrefixedBuffer<msg::fbuf::p2pmsg::Content>(nullptr);
|
|
}
|
|
|
|
inline void FinishContentBuffer(
|
|
flatbuffers::FlatBufferBuilder &fbb,
|
|
flatbuffers::Offset<msg::fbuf::p2pmsg::Content> root) {
|
|
fbb.Finish(root);
|
|
}
|
|
|
|
inline void FinishSizePrefixedContentBuffer(
|
|
flatbuffers::FlatBufferBuilder &fbb,
|
|
flatbuffers::Offset<msg::fbuf::p2pmsg::Content> root) {
|
|
fbb.FinishSizePrefixed(root);
|
|
}
|
|
|
|
} // namespace p2pmsg
|
|
} // namespace fbuf
|
|
} // namespace msg
|
|
|
|
#endif // FLATBUFFERS_GENERATED_P2PMSGCONTENT_MSG_FBUF_P2PMSG_H_
|