mirror of
https://github.com/RPCS3/rpcs3.git
synced 2025-07-12 01:38:37 +12:00
7427 lines
276 KiB
C++
7427 lines
276 KiB
C++
// automatically generated by the FlatBuffers compiler, do not modify
|
|
|
|
|
|
#ifndef FLATBUFFERS_GENERATED_NP2STRUCTS_H_
|
|
#define FLATBUFFERS_GENERATED_NP2STRUCTS_H_
|
|
|
|
#include "flatbuffers/flatbuffers.h"
|
|
|
|
// Ensure the included flatbuffers.h is the same version as when this file was
|
|
// generated, otherwise it may not be compatible.
|
|
static_assert(FLATBUFFERS_VERSION_MAJOR == 24 &&
|
|
FLATBUFFERS_VERSION_MINOR == 3 &&
|
|
FLATBUFFERS_VERSION_REVISION == 25,
|
|
"Non-compatible flatbuffers version included");
|
|
|
|
struct SignalingAddr;
|
|
struct SignalingAddrBuilder;
|
|
|
|
struct MatchingSignalingInfo;
|
|
struct MatchingSignalingInfoBuilder;
|
|
|
|
struct Matching2SignalingInfo;
|
|
struct Matching2SignalingInfoBuilder;
|
|
|
|
struct BinAttr;
|
|
struct BinAttrBuilder;
|
|
|
|
struct IntAttr;
|
|
struct IntAttrBuilder;
|
|
|
|
struct RoomMemberBinAttrInternal;
|
|
struct RoomMemberBinAttrInternalBuilder;
|
|
|
|
struct BinAttrInternal;
|
|
struct BinAttrInternalBuilder;
|
|
|
|
struct OptParam;
|
|
struct OptParamBuilder;
|
|
|
|
struct GroupConfig;
|
|
struct GroupConfigBuilder;
|
|
|
|
struct UserInfo;
|
|
struct UserInfoBuilder;
|
|
|
|
struct RoomMemberDataInternal;
|
|
struct RoomMemberDataInternalBuilder;
|
|
|
|
struct RoomGroup;
|
|
struct RoomGroupBuilder;
|
|
|
|
struct RoomDataInternal;
|
|
struct RoomDataInternalBuilder;
|
|
|
|
struct RoomDataExternal;
|
|
struct RoomDataExternalBuilder;
|
|
|
|
struct IntSearchFilter;
|
|
struct IntSearchFilterBuilder;
|
|
|
|
struct BinSearchFilter;
|
|
struct BinSearchFilterBuilder;
|
|
|
|
struct PresenceOptionData;
|
|
struct PresenceOptionDataBuilder;
|
|
|
|
struct RoomGroupPasswordConfig;
|
|
struct RoomGroupPasswordConfigBuilder;
|
|
|
|
struct SearchRoomRequest;
|
|
struct SearchRoomRequestBuilder;
|
|
|
|
struct SearchRoomResponse;
|
|
struct SearchRoomResponseBuilder;
|
|
|
|
struct CreateJoinRoomRequest;
|
|
struct CreateJoinRoomRequestBuilder;
|
|
|
|
struct JoinRoomRequest;
|
|
struct JoinRoomRequestBuilder;
|
|
|
|
struct JoinRoomResponse;
|
|
struct JoinRoomResponseBuilder;
|
|
|
|
struct LeaveRoomRequest;
|
|
struct LeaveRoomRequestBuilder;
|
|
|
|
struct GetRoomDataExternalListRequest;
|
|
struct GetRoomDataExternalListRequestBuilder;
|
|
|
|
struct GetRoomDataExternalListResponse;
|
|
struct GetRoomDataExternalListResponseBuilder;
|
|
|
|
struct SetRoomDataExternalRequest;
|
|
struct SetRoomDataExternalRequestBuilder;
|
|
|
|
struct SetRoomDataInternalRequest;
|
|
struct SetRoomDataInternalRequestBuilder;
|
|
|
|
struct GetRoomMemberDataInternalRequest;
|
|
struct GetRoomMemberDataInternalRequestBuilder;
|
|
|
|
struct SetRoomMemberDataInternalRequest;
|
|
struct SetRoomMemberDataInternalRequestBuilder;
|
|
|
|
struct SetUserInfo;
|
|
struct SetUserInfoBuilder;
|
|
|
|
struct GetRoomDataInternalRequest;
|
|
struct GetRoomDataInternalRequestBuilder;
|
|
|
|
struct RoomMemberUpdateInfo;
|
|
struct RoomMemberUpdateInfoBuilder;
|
|
|
|
struct NotificationUserJoinedRoom;
|
|
struct NotificationUserJoinedRoomBuilder;
|
|
|
|
struct RoomUpdateInfo;
|
|
struct RoomUpdateInfoBuilder;
|
|
|
|
struct RoomDataInternalUpdateInfo;
|
|
struct RoomDataInternalUpdateInfoBuilder;
|
|
|
|
struct RoomMemberDataInternalUpdateInfo;
|
|
struct RoomMemberDataInternalUpdateInfoBuilder;
|
|
|
|
struct GetPingInfoResponse;
|
|
struct GetPingInfoResponseBuilder;
|
|
|
|
struct SendRoomMessageRequest;
|
|
struct SendRoomMessageRequestBuilder;
|
|
|
|
struct RoomMessageInfo;
|
|
struct RoomMessageInfoBuilder;
|
|
|
|
struct MessageDetails;
|
|
struct MessageDetailsBuilder;
|
|
|
|
struct SendMessageRequest;
|
|
struct SendMessageRequestBuilder;
|
|
|
|
struct BoardInfo;
|
|
struct BoardInfoBuilder;
|
|
|
|
struct RecordScoreRequest;
|
|
struct RecordScoreRequestBuilder;
|
|
|
|
struct GetScoreRangeRequest;
|
|
struct GetScoreRangeRequestBuilder;
|
|
|
|
struct ScoreNpIdPcId;
|
|
struct ScoreNpIdPcIdBuilder;
|
|
|
|
struct GetScoreNpIdRequest;
|
|
struct GetScoreNpIdRequestBuilder;
|
|
|
|
struct GetScoreFriendsRequest;
|
|
struct GetScoreFriendsRequestBuilder;
|
|
|
|
struct ScoreRankData;
|
|
struct ScoreRankDataBuilder;
|
|
|
|
struct ScoreInfo;
|
|
struct ScoreInfoBuilder;
|
|
|
|
struct GetScoreResponse;
|
|
struct GetScoreResponseBuilder;
|
|
|
|
struct RecordScoreGameDataRequest;
|
|
struct RecordScoreGameDataRequestBuilder;
|
|
|
|
struct GetScoreGameDataRequest;
|
|
struct GetScoreGameDataRequestBuilder;
|
|
|
|
struct TusUser;
|
|
struct TusUserBuilder;
|
|
|
|
struct TusVariable;
|
|
struct TusVariableBuilder;
|
|
|
|
struct TusVarResponse;
|
|
struct TusVarResponseBuilder;
|
|
|
|
struct TusSetMultiSlotVariableRequest;
|
|
struct TusSetMultiSlotVariableRequestBuilder;
|
|
|
|
struct TusGetMultiSlotVariableRequest;
|
|
struct TusGetMultiSlotVariableRequestBuilder;
|
|
|
|
struct TusGetMultiUserVariableRequest;
|
|
struct TusGetMultiUserVariableRequestBuilder;
|
|
|
|
struct TusGetFriendsVariableRequest;
|
|
struct TusGetFriendsVariableRequestBuilder;
|
|
|
|
struct TusAddAndGetVariableRequest;
|
|
struct TusAddAndGetVariableRequestBuilder;
|
|
|
|
struct TusTryAndSetVariableRequest;
|
|
struct TusTryAndSetVariableRequestBuilder;
|
|
|
|
struct TusDeleteMultiSlotVariableRequest;
|
|
struct TusDeleteMultiSlotVariableRequestBuilder;
|
|
|
|
struct TusSetDataRequest;
|
|
struct TusSetDataRequestBuilder;
|
|
|
|
struct TusDataStatus;
|
|
struct TusDataStatusBuilder;
|
|
|
|
struct TusData;
|
|
struct TusDataBuilder;
|
|
|
|
struct TusDataStatusResponse;
|
|
struct TusDataStatusResponseBuilder;
|
|
|
|
struct TusGetDataRequest;
|
|
struct TusGetDataRequestBuilder;
|
|
|
|
struct TusGetMultiSlotDataStatusRequest;
|
|
struct TusGetMultiSlotDataStatusRequestBuilder;
|
|
|
|
struct TusGetMultiUserDataStatusRequest;
|
|
struct TusGetMultiUserDataStatusRequestBuilder;
|
|
|
|
struct TusGetFriendsDataStatusRequest;
|
|
struct TusGetFriendsDataStatusRequestBuilder;
|
|
|
|
struct TusDeleteMultiSlotDataRequest;
|
|
struct TusDeleteMultiSlotDataRequestBuilder;
|
|
|
|
struct SetPresenceRequest;
|
|
struct SetPresenceRequestBuilder;
|
|
|
|
struct MatchingSearchCondition;
|
|
struct MatchingSearchConditionBuilder;
|
|
|
|
struct MatchingAttr;
|
|
struct MatchingAttrBuilder;
|
|
|
|
struct CreateRoomGUIRequest;
|
|
struct CreateRoomGUIRequestBuilder;
|
|
|
|
struct GUIUserInfo;
|
|
struct GUIUserInfoBuilder;
|
|
|
|
struct MatchingRoomStatus;
|
|
struct MatchingRoomStatusBuilder;
|
|
|
|
struct GetRoomListGUIRequest;
|
|
struct GetRoomListGUIRequestBuilder;
|
|
|
|
struct MatchingRoom;
|
|
struct MatchingRoomBuilder;
|
|
|
|
struct MatchingRoomList;
|
|
struct MatchingRoomListBuilder;
|
|
|
|
struct MatchingGuiRoomId;
|
|
struct MatchingGuiRoomIdBuilder;
|
|
|
|
struct SetRoomSearchFlagGUI;
|
|
struct SetRoomSearchFlagGUIBuilder;
|
|
|
|
struct QuickMatchGUIRequest;
|
|
struct QuickMatchGUIRequestBuilder;
|
|
|
|
struct SearchJoinRoomGUIRequest;
|
|
struct SearchJoinRoomGUIRequestBuilder;
|
|
|
|
struct MatchingSearchJoinRoomInfo;
|
|
struct MatchingSearchJoinRoomInfoBuilder;
|
|
|
|
struct SignalingAddr FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef SignalingAddrBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_IP = 4,
|
|
VT_PORT = 6
|
|
};
|
|
const ::flatbuffers::Vector<uint8_t> *ip() const {
|
|
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_IP);
|
|
}
|
|
uint16_t port() const {
|
|
return GetField<uint16_t>(VT_PORT, 0);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_IP) &&
|
|
verifier.VerifyVector(ip()) &&
|
|
VerifyField<uint16_t>(verifier, VT_PORT, 2) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct SignalingAddrBuilder {
|
|
typedef SignalingAddr Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_ip(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> ip) {
|
|
fbb_.AddOffset(SignalingAddr::VT_IP, ip);
|
|
}
|
|
void add_port(uint16_t port) {
|
|
fbb_.AddElement<uint16_t>(SignalingAddr::VT_PORT, port, 0);
|
|
}
|
|
explicit SignalingAddrBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<SignalingAddr> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<SignalingAddr>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<SignalingAddr> CreateSignalingAddr(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> ip = 0,
|
|
uint16_t port = 0) {
|
|
SignalingAddrBuilder builder_(_fbb);
|
|
builder_.add_ip(ip);
|
|
builder_.add_port(port);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<SignalingAddr> CreateSignalingAddrDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
const std::vector<uint8_t> *ip = nullptr,
|
|
uint16_t port = 0) {
|
|
auto ip__ = ip ? _fbb.CreateVector<uint8_t>(*ip) : 0;
|
|
return CreateSignalingAddr(
|
|
_fbb,
|
|
ip__,
|
|
port);
|
|
}
|
|
|
|
struct MatchingSignalingInfo FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef MatchingSignalingInfoBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_NPID = 4,
|
|
VT_ADDR = 6
|
|
};
|
|
const ::flatbuffers::String *npid() const {
|
|
return GetPointer<const ::flatbuffers::String *>(VT_NPID);
|
|
}
|
|
const SignalingAddr *addr() const {
|
|
return GetPointer<const SignalingAddr *>(VT_ADDR);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_NPID) &&
|
|
verifier.VerifyString(npid()) &&
|
|
VerifyOffset(verifier, VT_ADDR) &&
|
|
verifier.VerifyTable(addr()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct MatchingSignalingInfoBuilder {
|
|
typedef MatchingSignalingInfo Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_npid(::flatbuffers::Offset<::flatbuffers::String> npid) {
|
|
fbb_.AddOffset(MatchingSignalingInfo::VT_NPID, npid);
|
|
}
|
|
void add_addr(::flatbuffers::Offset<SignalingAddr> addr) {
|
|
fbb_.AddOffset(MatchingSignalingInfo::VT_ADDR, addr);
|
|
}
|
|
explicit MatchingSignalingInfoBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<MatchingSignalingInfo> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<MatchingSignalingInfo>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<MatchingSignalingInfo> CreateMatchingSignalingInfo(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<::flatbuffers::String> npid = 0,
|
|
::flatbuffers::Offset<SignalingAddr> addr = 0) {
|
|
MatchingSignalingInfoBuilder builder_(_fbb);
|
|
builder_.add_addr(addr);
|
|
builder_.add_npid(npid);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<MatchingSignalingInfo> CreateMatchingSignalingInfoDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
const char *npid = nullptr,
|
|
::flatbuffers::Offset<SignalingAddr> addr = 0) {
|
|
auto npid__ = npid ? _fbb.CreateString(npid) : 0;
|
|
return CreateMatchingSignalingInfo(
|
|
_fbb,
|
|
npid__,
|
|
addr);
|
|
}
|
|
|
|
struct Matching2SignalingInfo FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef Matching2SignalingInfoBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_MEMBER_ID = 4,
|
|
VT_ADDR = 6
|
|
};
|
|
uint16_t member_id() const {
|
|
return GetField<uint16_t>(VT_MEMBER_ID, 0);
|
|
}
|
|
const SignalingAddr *addr() const {
|
|
return GetPointer<const SignalingAddr *>(VT_ADDR);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<uint16_t>(verifier, VT_MEMBER_ID, 2) &&
|
|
VerifyOffset(verifier, VT_ADDR) &&
|
|
verifier.VerifyTable(addr()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct Matching2SignalingInfoBuilder {
|
|
typedef Matching2SignalingInfo Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_member_id(uint16_t member_id) {
|
|
fbb_.AddElement<uint16_t>(Matching2SignalingInfo::VT_MEMBER_ID, member_id, 0);
|
|
}
|
|
void add_addr(::flatbuffers::Offset<SignalingAddr> addr) {
|
|
fbb_.AddOffset(Matching2SignalingInfo::VT_ADDR, addr);
|
|
}
|
|
explicit Matching2SignalingInfoBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<Matching2SignalingInfo> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<Matching2SignalingInfo>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<Matching2SignalingInfo> CreateMatching2SignalingInfo(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint16_t member_id = 0,
|
|
::flatbuffers::Offset<SignalingAddr> addr = 0) {
|
|
Matching2SignalingInfoBuilder builder_(_fbb);
|
|
builder_.add_addr(addr);
|
|
builder_.add_member_id(member_id);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
struct BinAttr FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef BinAttrBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_ID = 4,
|
|
VT_DATA = 6
|
|
};
|
|
uint16_t id() const {
|
|
return GetField<uint16_t>(VT_ID, 0);
|
|
}
|
|
const ::flatbuffers::Vector<uint8_t> *data() const {
|
|
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_DATA);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<uint16_t>(verifier, VT_ID, 2) &&
|
|
VerifyOffset(verifier, VT_DATA) &&
|
|
verifier.VerifyVector(data()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct BinAttrBuilder {
|
|
typedef BinAttr Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_id(uint16_t id) {
|
|
fbb_.AddElement<uint16_t>(BinAttr::VT_ID, id, 0);
|
|
}
|
|
void add_data(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data) {
|
|
fbb_.AddOffset(BinAttr::VT_DATA, data);
|
|
}
|
|
explicit BinAttrBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<BinAttr> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<BinAttr>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<BinAttr> CreateBinAttr(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint16_t id = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data = 0) {
|
|
BinAttrBuilder builder_(_fbb);
|
|
builder_.add_data(data);
|
|
builder_.add_id(id);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<BinAttr> CreateBinAttrDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint16_t id = 0,
|
|
const std::vector<uint8_t> *data = nullptr) {
|
|
auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
|
|
return CreateBinAttr(
|
|
_fbb,
|
|
id,
|
|
data__);
|
|
}
|
|
|
|
struct IntAttr FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef IntAttrBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_ID = 4,
|
|
VT_NUM = 6
|
|
};
|
|
uint16_t id() const {
|
|
return GetField<uint16_t>(VT_ID, 0);
|
|
}
|
|
uint32_t num() const {
|
|
return GetField<uint32_t>(VT_NUM, 0);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<uint16_t>(verifier, VT_ID, 2) &&
|
|
VerifyField<uint32_t>(verifier, VT_NUM, 4) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct IntAttrBuilder {
|
|
typedef IntAttr Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_id(uint16_t id) {
|
|
fbb_.AddElement<uint16_t>(IntAttr::VT_ID, id, 0);
|
|
}
|
|
void add_num(uint32_t num) {
|
|
fbb_.AddElement<uint32_t>(IntAttr::VT_NUM, num, 0);
|
|
}
|
|
explicit IntAttrBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<IntAttr> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<IntAttr>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<IntAttr> CreateIntAttr(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint16_t id = 0,
|
|
uint32_t num = 0) {
|
|
IntAttrBuilder builder_(_fbb);
|
|
builder_.add_num(num);
|
|
builder_.add_id(id);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
struct RoomMemberBinAttrInternal FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef RoomMemberBinAttrInternalBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_UPDATEDATE = 4,
|
|
VT_DATA = 6
|
|
};
|
|
uint64_t updateDate() const {
|
|
return GetField<uint64_t>(VT_UPDATEDATE, 0);
|
|
}
|
|
const BinAttr *data() const {
|
|
return GetPointer<const BinAttr *>(VT_DATA);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<uint64_t>(verifier, VT_UPDATEDATE, 8) &&
|
|
VerifyOffset(verifier, VT_DATA) &&
|
|
verifier.VerifyTable(data()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct RoomMemberBinAttrInternalBuilder {
|
|
typedef RoomMemberBinAttrInternal Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_updateDate(uint64_t updateDate) {
|
|
fbb_.AddElement<uint64_t>(RoomMemberBinAttrInternal::VT_UPDATEDATE, updateDate, 0);
|
|
}
|
|
void add_data(::flatbuffers::Offset<BinAttr> data) {
|
|
fbb_.AddOffset(RoomMemberBinAttrInternal::VT_DATA, data);
|
|
}
|
|
explicit RoomMemberBinAttrInternalBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<RoomMemberBinAttrInternal> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<RoomMemberBinAttrInternal>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<RoomMemberBinAttrInternal> CreateRoomMemberBinAttrInternal(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint64_t updateDate = 0,
|
|
::flatbuffers::Offset<BinAttr> data = 0) {
|
|
RoomMemberBinAttrInternalBuilder builder_(_fbb);
|
|
builder_.add_updateDate(updateDate);
|
|
builder_.add_data(data);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
struct BinAttrInternal FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef BinAttrInternalBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_UPDATEDATE = 4,
|
|
VT_UPDATEMEMBERID = 6,
|
|
VT_DATA = 8
|
|
};
|
|
uint64_t updateDate() const {
|
|
return GetField<uint64_t>(VT_UPDATEDATE, 0);
|
|
}
|
|
uint16_t updateMemberId() const {
|
|
return GetField<uint16_t>(VT_UPDATEMEMBERID, 0);
|
|
}
|
|
const BinAttr *data() const {
|
|
return GetPointer<const BinAttr *>(VT_DATA);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<uint64_t>(verifier, VT_UPDATEDATE, 8) &&
|
|
VerifyField<uint16_t>(verifier, VT_UPDATEMEMBERID, 2) &&
|
|
VerifyOffset(verifier, VT_DATA) &&
|
|
verifier.VerifyTable(data()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct BinAttrInternalBuilder {
|
|
typedef BinAttrInternal Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_updateDate(uint64_t updateDate) {
|
|
fbb_.AddElement<uint64_t>(BinAttrInternal::VT_UPDATEDATE, updateDate, 0);
|
|
}
|
|
void add_updateMemberId(uint16_t updateMemberId) {
|
|
fbb_.AddElement<uint16_t>(BinAttrInternal::VT_UPDATEMEMBERID, updateMemberId, 0);
|
|
}
|
|
void add_data(::flatbuffers::Offset<BinAttr> data) {
|
|
fbb_.AddOffset(BinAttrInternal::VT_DATA, data);
|
|
}
|
|
explicit BinAttrInternalBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<BinAttrInternal> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<BinAttrInternal>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<BinAttrInternal> CreateBinAttrInternal(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint64_t updateDate = 0,
|
|
uint16_t updateMemberId = 0,
|
|
::flatbuffers::Offset<BinAttr> data = 0) {
|
|
BinAttrInternalBuilder builder_(_fbb);
|
|
builder_.add_updateDate(updateDate);
|
|
builder_.add_data(data);
|
|
builder_.add_updateMemberId(updateMemberId);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
struct OptParam FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef OptParamBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_TYPE = 4,
|
|
VT_FLAG = 6,
|
|
VT_HUBMEMBERID = 8
|
|
};
|
|
uint8_t type() const {
|
|
return GetField<uint8_t>(VT_TYPE, 0);
|
|
}
|
|
uint8_t flag() const {
|
|
return GetField<uint8_t>(VT_FLAG, 0);
|
|
}
|
|
uint16_t hubMemberId() const {
|
|
return GetField<uint16_t>(VT_HUBMEMBERID, 0);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<uint8_t>(verifier, VT_TYPE, 1) &&
|
|
VerifyField<uint8_t>(verifier, VT_FLAG, 1) &&
|
|
VerifyField<uint16_t>(verifier, VT_HUBMEMBERID, 2) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct OptParamBuilder {
|
|
typedef OptParam Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_type(uint8_t type) {
|
|
fbb_.AddElement<uint8_t>(OptParam::VT_TYPE, type, 0);
|
|
}
|
|
void add_flag(uint8_t flag) {
|
|
fbb_.AddElement<uint8_t>(OptParam::VT_FLAG, flag, 0);
|
|
}
|
|
void add_hubMemberId(uint16_t hubMemberId) {
|
|
fbb_.AddElement<uint16_t>(OptParam::VT_HUBMEMBERID, hubMemberId, 0);
|
|
}
|
|
explicit OptParamBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<OptParam> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<OptParam>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<OptParam> CreateOptParam(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint8_t type = 0,
|
|
uint8_t flag = 0,
|
|
uint16_t hubMemberId = 0) {
|
|
OptParamBuilder builder_(_fbb);
|
|
builder_.add_hubMemberId(hubMemberId);
|
|
builder_.add_flag(flag);
|
|
builder_.add_type(type);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
struct GroupConfig FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef GroupConfigBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_SLOTNUM = 4,
|
|
VT_LABEL = 6,
|
|
VT_WITHPASSWORD = 8
|
|
};
|
|
uint32_t slotNum() const {
|
|
return GetField<uint32_t>(VT_SLOTNUM, 0);
|
|
}
|
|
const ::flatbuffers::Vector<uint8_t> *label() const {
|
|
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_LABEL);
|
|
}
|
|
bool withPassword() const {
|
|
return GetField<uint8_t>(VT_WITHPASSWORD, 0) != 0;
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<uint32_t>(verifier, VT_SLOTNUM, 4) &&
|
|
VerifyOffset(verifier, VT_LABEL) &&
|
|
verifier.VerifyVector(label()) &&
|
|
VerifyField<uint8_t>(verifier, VT_WITHPASSWORD, 1) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct GroupConfigBuilder {
|
|
typedef GroupConfig Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_slotNum(uint32_t slotNum) {
|
|
fbb_.AddElement<uint32_t>(GroupConfig::VT_SLOTNUM, slotNum, 0);
|
|
}
|
|
void add_label(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> label) {
|
|
fbb_.AddOffset(GroupConfig::VT_LABEL, label);
|
|
}
|
|
void add_withPassword(bool withPassword) {
|
|
fbb_.AddElement<uint8_t>(GroupConfig::VT_WITHPASSWORD, static_cast<uint8_t>(withPassword), 0);
|
|
}
|
|
explicit GroupConfigBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<GroupConfig> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<GroupConfig>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<GroupConfig> CreateGroupConfig(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint32_t slotNum = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> label = 0,
|
|
bool withPassword = false) {
|
|
GroupConfigBuilder builder_(_fbb);
|
|
builder_.add_label(label);
|
|
builder_.add_slotNum(slotNum);
|
|
builder_.add_withPassword(withPassword);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<GroupConfig> CreateGroupConfigDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint32_t slotNum = 0,
|
|
const std::vector<uint8_t> *label = nullptr,
|
|
bool withPassword = false) {
|
|
auto label__ = label ? _fbb.CreateVector<uint8_t>(*label) : 0;
|
|
return CreateGroupConfig(
|
|
_fbb,
|
|
slotNum,
|
|
label__,
|
|
withPassword);
|
|
}
|
|
|
|
struct UserInfo FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef UserInfoBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_NPID = 4,
|
|
VT_ONLINENAME = 6,
|
|
VT_AVATARURL = 8
|
|
};
|
|
const ::flatbuffers::String *npId() const {
|
|
return GetPointer<const ::flatbuffers::String *>(VT_NPID);
|
|
}
|
|
const ::flatbuffers::String *onlineName() const {
|
|
return GetPointer<const ::flatbuffers::String *>(VT_ONLINENAME);
|
|
}
|
|
const ::flatbuffers::String *avatarUrl() const {
|
|
return GetPointer<const ::flatbuffers::String *>(VT_AVATARURL);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_NPID) &&
|
|
verifier.VerifyString(npId()) &&
|
|
VerifyOffset(verifier, VT_ONLINENAME) &&
|
|
verifier.VerifyString(onlineName()) &&
|
|
VerifyOffset(verifier, VT_AVATARURL) &&
|
|
verifier.VerifyString(avatarUrl()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct UserInfoBuilder {
|
|
typedef UserInfo Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_npId(::flatbuffers::Offset<::flatbuffers::String> npId) {
|
|
fbb_.AddOffset(UserInfo::VT_NPID, npId);
|
|
}
|
|
void add_onlineName(::flatbuffers::Offset<::flatbuffers::String> onlineName) {
|
|
fbb_.AddOffset(UserInfo::VT_ONLINENAME, onlineName);
|
|
}
|
|
void add_avatarUrl(::flatbuffers::Offset<::flatbuffers::String> avatarUrl) {
|
|
fbb_.AddOffset(UserInfo::VT_AVATARURL, avatarUrl);
|
|
}
|
|
explicit UserInfoBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<UserInfo> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<UserInfo>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<UserInfo> CreateUserInfo(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<::flatbuffers::String> npId = 0,
|
|
::flatbuffers::Offset<::flatbuffers::String> onlineName = 0,
|
|
::flatbuffers::Offset<::flatbuffers::String> avatarUrl = 0) {
|
|
UserInfoBuilder builder_(_fbb);
|
|
builder_.add_avatarUrl(avatarUrl);
|
|
builder_.add_onlineName(onlineName);
|
|
builder_.add_npId(npId);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<UserInfo> CreateUserInfoDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
const char *npId = nullptr,
|
|
const char *onlineName = nullptr,
|
|
const char *avatarUrl = nullptr) {
|
|
auto npId__ = npId ? _fbb.CreateString(npId) : 0;
|
|
auto onlineName__ = onlineName ? _fbb.CreateString(onlineName) : 0;
|
|
auto avatarUrl__ = avatarUrl ? _fbb.CreateString(avatarUrl) : 0;
|
|
return CreateUserInfo(
|
|
_fbb,
|
|
npId__,
|
|
onlineName__,
|
|
avatarUrl__);
|
|
}
|
|
|
|
struct RoomMemberDataInternal FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef RoomMemberDataInternalBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_USERINFO = 4,
|
|
VT_JOINDATE = 6,
|
|
VT_MEMBERID = 8,
|
|
VT_TEAMID = 10,
|
|
VT_ROOMGROUP = 12,
|
|
VT_NATTYPE = 14,
|
|
VT_FLAGATTR = 16,
|
|
VT_ROOMMEMBERBINATTRINTERNAL = 18
|
|
};
|
|
const UserInfo *userInfo() const {
|
|
return GetPointer<const UserInfo *>(VT_USERINFO);
|
|
}
|
|
uint64_t joinDate() const {
|
|
return GetField<uint64_t>(VT_JOINDATE, 0);
|
|
}
|
|
uint16_t memberId() const {
|
|
return GetField<uint16_t>(VT_MEMBERID, 0);
|
|
}
|
|
uint8_t teamId() const {
|
|
return GetField<uint8_t>(VT_TEAMID, 0);
|
|
}
|
|
const RoomGroup *roomGroup() const {
|
|
return GetPointer<const RoomGroup *>(VT_ROOMGROUP);
|
|
}
|
|
uint8_t natType() const {
|
|
return GetField<uint8_t>(VT_NATTYPE, 0);
|
|
}
|
|
uint32_t flagAttr() const {
|
|
return GetField<uint32_t>(VT_FLAGATTR, 0);
|
|
}
|
|
const ::flatbuffers::Vector<::flatbuffers::Offset<RoomMemberBinAttrInternal>> *roomMemberBinAttrInternal() const {
|
|
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<RoomMemberBinAttrInternal>> *>(VT_ROOMMEMBERBINATTRINTERNAL);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_USERINFO) &&
|
|
verifier.VerifyTable(userInfo()) &&
|
|
VerifyField<uint64_t>(verifier, VT_JOINDATE, 8) &&
|
|
VerifyField<uint16_t>(verifier, VT_MEMBERID, 2) &&
|
|
VerifyField<uint8_t>(verifier, VT_TEAMID, 1) &&
|
|
VerifyOffset(verifier, VT_ROOMGROUP) &&
|
|
verifier.VerifyTable(roomGroup()) &&
|
|
VerifyField<uint8_t>(verifier, VT_NATTYPE, 1) &&
|
|
VerifyField<uint32_t>(verifier, VT_FLAGATTR, 4) &&
|
|
VerifyOffset(verifier, VT_ROOMMEMBERBINATTRINTERNAL) &&
|
|
verifier.VerifyVector(roomMemberBinAttrInternal()) &&
|
|
verifier.VerifyVectorOfTables(roomMemberBinAttrInternal()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct RoomMemberDataInternalBuilder {
|
|
typedef RoomMemberDataInternal Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_userInfo(::flatbuffers::Offset<UserInfo> userInfo) {
|
|
fbb_.AddOffset(RoomMemberDataInternal::VT_USERINFO, userInfo);
|
|
}
|
|
void add_joinDate(uint64_t joinDate) {
|
|
fbb_.AddElement<uint64_t>(RoomMemberDataInternal::VT_JOINDATE, joinDate, 0);
|
|
}
|
|
void add_memberId(uint16_t memberId) {
|
|
fbb_.AddElement<uint16_t>(RoomMemberDataInternal::VT_MEMBERID, memberId, 0);
|
|
}
|
|
void add_teamId(uint8_t teamId) {
|
|
fbb_.AddElement<uint8_t>(RoomMemberDataInternal::VT_TEAMID, teamId, 0);
|
|
}
|
|
void add_roomGroup(::flatbuffers::Offset<RoomGroup> roomGroup) {
|
|
fbb_.AddOffset(RoomMemberDataInternal::VT_ROOMGROUP, roomGroup);
|
|
}
|
|
void add_natType(uint8_t natType) {
|
|
fbb_.AddElement<uint8_t>(RoomMemberDataInternal::VT_NATTYPE, natType, 0);
|
|
}
|
|
void add_flagAttr(uint32_t flagAttr) {
|
|
fbb_.AddElement<uint32_t>(RoomMemberDataInternal::VT_FLAGATTR, flagAttr, 0);
|
|
}
|
|
void add_roomMemberBinAttrInternal(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<RoomMemberBinAttrInternal>>> roomMemberBinAttrInternal) {
|
|
fbb_.AddOffset(RoomMemberDataInternal::VT_ROOMMEMBERBINATTRINTERNAL, roomMemberBinAttrInternal);
|
|
}
|
|
explicit RoomMemberDataInternalBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<RoomMemberDataInternal> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<RoomMemberDataInternal>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<RoomMemberDataInternal> CreateRoomMemberDataInternal(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<UserInfo> userInfo = 0,
|
|
uint64_t joinDate = 0,
|
|
uint16_t memberId = 0,
|
|
uint8_t teamId = 0,
|
|
::flatbuffers::Offset<RoomGroup> roomGroup = 0,
|
|
uint8_t natType = 0,
|
|
uint32_t flagAttr = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<RoomMemberBinAttrInternal>>> roomMemberBinAttrInternal = 0) {
|
|
RoomMemberDataInternalBuilder builder_(_fbb);
|
|
builder_.add_joinDate(joinDate);
|
|
builder_.add_roomMemberBinAttrInternal(roomMemberBinAttrInternal);
|
|
builder_.add_flagAttr(flagAttr);
|
|
builder_.add_roomGroup(roomGroup);
|
|
builder_.add_userInfo(userInfo);
|
|
builder_.add_memberId(memberId);
|
|
builder_.add_natType(natType);
|
|
builder_.add_teamId(teamId);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<RoomMemberDataInternal> CreateRoomMemberDataInternalDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<UserInfo> userInfo = 0,
|
|
uint64_t joinDate = 0,
|
|
uint16_t memberId = 0,
|
|
uint8_t teamId = 0,
|
|
::flatbuffers::Offset<RoomGroup> roomGroup = 0,
|
|
uint8_t natType = 0,
|
|
uint32_t flagAttr = 0,
|
|
const std::vector<::flatbuffers::Offset<RoomMemberBinAttrInternal>> *roomMemberBinAttrInternal = nullptr) {
|
|
auto roomMemberBinAttrInternal__ = roomMemberBinAttrInternal ? _fbb.CreateVector<::flatbuffers::Offset<RoomMemberBinAttrInternal>>(*roomMemberBinAttrInternal) : 0;
|
|
return CreateRoomMemberDataInternal(
|
|
_fbb,
|
|
userInfo,
|
|
joinDate,
|
|
memberId,
|
|
teamId,
|
|
roomGroup,
|
|
natType,
|
|
flagAttr,
|
|
roomMemberBinAttrInternal__);
|
|
}
|
|
|
|
struct RoomGroup FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef RoomGroupBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_GROUPID = 4,
|
|
VT_WITHPASSWORD = 6,
|
|
VT_LABEL = 8,
|
|
VT_SLOTNUM = 10,
|
|
VT_CURGROUPMEMBERNUM = 12
|
|
};
|
|
uint8_t groupId() const {
|
|
return GetField<uint8_t>(VT_GROUPID, 0);
|
|
}
|
|
bool withPassword() const {
|
|
return GetField<uint8_t>(VT_WITHPASSWORD, 0) != 0;
|
|
}
|
|
const ::flatbuffers::Vector<uint8_t> *label() const {
|
|
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_LABEL);
|
|
}
|
|
uint32_t slotNum() const {
|
|
return GetField<uint32_t>(VT_SLOTNUM, 0);
|
|
}
|
|
uint32_t curGroupMemberNum() const {
|
|
return GetField<uint32_t>(VT_CURGROUPMEMBERNUM, 0);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<uint8_t>(verifier, VT_GROUPID, 1) &&
|
|
VerifyField<uint8_t>(verifier, VT_WITHPASSWORD, 1) &&
|
|
VerifyOffset(verifier, VT_LABEL) &&
|
|
verifier.VerifyVector(label()) &&
|
|
VerifyField<uint32_t>(verifier, VT_SLOTNUM, 4) &&
|
|
VerifyField<uint32_t>(verifier, VT_CURGROUPMEMBERNUM, 4) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct RoomGroupBuilder {
|
|
typedef RoomGroup Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_groupId(uint8_t groupId) {
|
|
fbb_.AddElement<uint8_t>(RoomGroup::VT_GROUPID, groupId, 0);
|
|
}
|
|
void add_withPassword(bool withPassword) {
|
|
fbb_.AddElement<uint8_t>(RoomGroup::VT_WITHPASSWORD, static_cast<uint8_t>(withPassword), 0);
|
|
}
|
|
void add_label(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> label) {
|
|
fbb_.AddOffset(RoomGroup::VT_LABEL, label);
|
|
}
|
|
void add_slotNum(uint32_t slotNum) {
|
|
fbb_.AddElement<uint32_t>(RoomGroup::VT_SLOTNUM, slotNum, 0);
|
|
}
|
|
void add_curGroupMemberNum(uint32_t curGroupMemberNum) {
|
|
fbb_.AddElement<uint32_t>(RoomGroup::VT_CURGROUPMEMBERNUM, curGroupMemberNum, 0);
|
|
}
|
|
explicit RoomGroupBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<RoomGroup> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<RoomGroup>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<RoomGroup> CreateRoomGroup(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint8_t groupId = 0,
|
|
bool withPassword = false,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> label = 0,
|
|
uint32_t slotNum = 0,
|
|
uint32_t curGroupMemberNum = 0) {
|
|
RoomGroupBuilder builder_(_fbb);
|
|
builder_.add_curGroupMemberNum(curGroupMemberNum);
|
|
builder_.add_slotNum(slotNum);
|
|
builder_.add_label(label);
|
|
builder_.add_withPassword(withPassword);
|
|
builder_.add_groupId(groupId);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<RoomGroup> CreateRoomGroupDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint8_t groupId = 0,
|
|
bool withPassword = false,
|
|
const std::vector<uint8_t> *label = nullptr,
|
|
uint32_t slotNum = 0,
|
|
uint32_t curGroupMemberNum = 0) {
|
|
auto label__ = label ? _fbb.CreateVector<uint8_t>(*label) : 0;
|
|
return CreateRoomGroup(
|
|
_fbb,
|
|
groupId,
|
|
withPassword,
|
|
label__,
|
|
slotNum,
|
|
curGroupMemberNum);
|
|
}
|
|
|
|
struct RoomDataInternal FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef RoomDataInternalBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_SERVERID = 4,
|
|
VT_WORLDID = 6,
|
|
VT_LOBBYID = 8,
|
|
VT_ROOMID = 10,
|
|
VT_PASSWORDSLOTMASK = 12,
|
|
VT_MAXSLOT = 14,
|
|
VT_MEMBERLIST = 16,
|
|
VT_OWNERID = 18,
|
|
VT_ROOMGROUP = 20,
|
|
VT_FLAGATTR = 22,
|
|
VT_ROOMBINATTRINTERNAL = 24
|
|
};
|
|
uint16_t serverId() const {
|
|
return GetField<uint16_t>(VT_SERVERID, 0);
|
|
}
|
|
uint32_t worldId() const {
|
|
return GetField<uint32_t>(VT_WORLDID, 0);
|
|
}
|
|
uint64_t lobbyId() const {
|
|
return GetField<uint64_t>(VT_LOBBYID, 0);
|
|
}
|
|
uint64_t roomId() const {
|
|
return GetField<uint64_t>(VT_ROOMID, 0);
|
|
}
|
|
uint64_t passwordSlotMask() const {
|
|
return GetField<uint64_t>(VT_PASSWORDSLOTMASK, 0);
|
|
}
|
|
uint32_t maxSlot() const {
|
|
return GetField<uint32_t>(VT_MAXSLOT, 0);
|
|
}
|
|
const ::flatbuffers::Vector<::flatbuffers::Offset<RoomMemberDataInternal>> *memberList() const {
|
|
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<RoomMemberDataInternal>> *>(VT_MEMBERLIST);
|
|
}
|
|
uint16_t ownerId() const {
|
|
return GetField<uint16_t>(VT_OWNERID, 0);
|
|
}
|
|
const ::flatbuffers::Vector<::flatbuffers::Offset<RoomGroup>> *roomGroup() const {
|
|
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<RoomGroup>> *>(VT_ROOMGROUP);
|
|
}
|
|
uint32_t flagAttr() const {
|
|
return GetField<uint32_t>(VT_FLAGATTR, 0);
|
|
}
|
|
const ::flatbuffers::Vector<::flatbuffers::Offset<BinAttrInternal>> *roomBinAttrInternal() const {
|
|
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<BinAttrInternal>> *>(VT_ROOMBINATTRINTERNAL);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<uint16_t>(verifier, VT_SERVERID, 2) &&
|
|
VerifyField<uint32_t>(verifier, VT_WORLDID, 4) &&
|
|
VerifyField<uint64_t>(verifier, VT_LOBBYID, 8) &&
|
|
VerifyField<uint64_t>(verifier, VT_ROOMID, 8) &&
|
|
VerifyField<uint64_t>(verifier, VT_PASSWORDSLOTMASK, 8) &&
|
|
VerifyField<uint32_t>(verifier, VT_MAXSLOT, 4) &&
|
|
VerifyOffset(verifier, VT_MEMBERLIST) &&
|
|
verifier.VerifyVector(memberList()) &&
|
|
verifier.VerifyVectorOfTables(memberList()) &&
|
|
VerifyField<uint16_t>(verifier, VT_OWNERID, 2) &&
|
|
VerifyOffset(verifier, VT_ROOMGROUP) &&
|
|
verifier.VerifyVector(roomGroup()) &&
|
|
verifier.VerifyVectorOfTables(roomGroup()) &&
|
|
VerifyField<uint32_t>(verifier, VT_FLAGATTR, 4) &&
|
|
VerifyOffset(verifier, VT_ROOMBINATTRINTERNAL) &&
|
|
verifier.VerifyVector(roomBinAttrInternal()) &&
|
|
verifier.VerifyVectorOfTables(roomBinAttrInternal()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct RoomDataInternalBuilder {
|
|
typedef RoomDataInternal Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_serverId(uint16_t serverId) {
|
|
fbb_.AddElement<uint16_t>(RoomDataInternal::VT_SERVERID, serverId, 0);
|
|
}
|
|
void add_worldId(uint32_t worldId) {
|
|
fbb_.AddElement<uint32_t>(RoomDataInternal::VT_WORLDID, worldId, 0);
|
|
}
|
|
void add_lobbyId(uint64_t lobbyId) {
|
|
fbb_.AddElement<uint64_t>(RoomDataInternal::VT_LOBBYID, lobbyId, 0);
|
|
}
|
|
void add_roomId(uint64_t roomId) {
|
|
fbb_.AddElement<uint64_t>(RoomDataInternal::VT_ROOMID, roomId, 0);
|
|
}
|
|
void add_passwordSlotMask(uint64_t passwordSlotMask) {
|
|
fbb_.AddElement<uint64_t>(RoomDataInternal::VT_PASSWORDSLOTMASK, passwordSlotMask, 0);
|
|
}
|
|
void add_maxSlot(uint32_t maxSlot) {
|
|
fbb_.AddElement<uint32_t>(RoomDataInternal::VT_MAXSLOT, maxSlot, 0);
|
|
}
|
|
void add_memberList(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<RoomMemberDataInternal>>> memberList) {
|
|
fbb_.AddOffset(RoomDataInternal::VT_MEMBERLIST, memberList);
|
|
}
|
|
void add_ownerId(uint16_t ownerId) {
|
|
fbb_.AddElement<uint16_t>(RoomDataInternal::VT_OWNERID, ownerId, 0);
|
|
}
|
|
void add_roomGroup(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<RoomGroup>>> roomGroup) {
|
|
fbb_.AddOffset(RoomDataInternal::VT_ROOMGROUP, roomGroup);
|
|
}
|
|
void add_flagAttr(uint32_t flagAttr) {
|
|
fbb_.AddElement<uint32_t>(RoomDataInternal::VT_FLAGATTR, flagAttr, 0);
|
|
}
|
|
void add_roomBinAttrInternal(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinAttrInternal>>> roomBinAttrInternal) {
|
|
fbb_.AddOffset(RoomDataInternal::VT_ROOMBINATTRINTERNAL, roomBinAttrInternal);
|
|
}
|
|
explicit RoomDataInternalBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<RoomDataInternal> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<RoomDataInternal>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<RoomDataInternal> CreateRoomDataInternal(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint16_t serverId = 0,
|
|
uint32_t worldId = 0,
|
|
uint64_t lobbyId = 0,
|
|
uint64_t roomId = 0,
|
|
uint64_t passwordSlotMask = 0,
|
|
uint32_t maxSlot = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<RoomMemberDataInternal>>> memberList = 0,
|
|
uint16_t ownerId = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<RoomGroup>>> roomGroup = 0,
|
|
uint32_t flagAttr = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinAttrInternal>>> roomBinAttrInternal = 0) {
|
|
RoomDataInternalBuilder builder_(_fbb);
|
|
builder_.add_passwordSlotMask(passwordSlotMask);
|
|
builder_.add_roomId(roomId);
|
|
builder_.add_lobbyId(lobbyId);
|
|
builder_.add_roomBinAttrInternal(roomBinAttrInternal);
|
|
builder_.add_flagAttr(flagAttr);
|
|
builder_.add_roomGroup(roomGroup);
|
|
builder_.add_memberList(memberList);
|
|
builder_.add_maxSlot(maxSlot);
|
|
builder_.add_worldId(worldId);
|
|
builder_.add_ownerId(ownerId);
|
|
builder_.add_serverId(serverId);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<RoomDataInternal> CreateRoomDataInternalDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint16_t serverId = 0,
|
|
uint32_t worldId = 0,
|
|
uint64_t lobbyId = 0,
|
|
uint64_t roomId = 0,
|
|
uint64_t passwordSlotMask = 0,
|
|
uint32_t maxSlot = 0,
|
|
const std::vector<::flatbuffers::Offset<RoomMemberDataInternal>> *memberList = nullptr,
|
|
uint16_t ownerId = 0,
|
|
const std::vector<::flatbuffers::Offset<RoomGroup>> *roomGroup = nullptr,
|
|
uint32_t flagAttr = 0,
|
|
const std::vector<::flatbuffers::Offset<BinAttrInternal>> *roomBinAttrInternal = nullptr) {
|
|
auto memberList__ = memberList ? _fbb.CreateVector<::flatbuffers::Offset<RoomMemberDataInternal>>(*memberList) : 0;
|
|
auto roomGroup__ = roomGroup ? _fbb.CreateVector<::flatbuffers::Offset<RoomGroup>>(*roomGroup) : 0;
|
|
auto roomBinAttrInternal__ = roomBinAttrInternal ? _fbb.CreateVector<::flatbuffers::Offset<BinAttrInternal>>(*roomBinAttrInternal) : 0;
|
|
return CreateRoomDataInternal(
|
|
_fbb,
|
|
serverId,
|
|
worldId,
|
|
lobbyId,
|
|
roomId,
|
|
passwordSlotMask,
|
|
maxSlot,
|
|
memberList__,
|
|
ownerId,
|
|
roomGroup__,
|
|
flagAttr,
|
|
roomBinAttrInternal__);
|
|
}
|
|
|
|
struct RoomDataExternal FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef RoomDataExternalBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_SERVERID = 4,
|
|
VT_WORLDID = 6,
|
|
VT_PUBLICSLOTNUM = 8,
|
|
VT_PRIVATESLOTNUM = 10,
|
|
VT_LOBBYID = 12,
|
|
VT_ROOMID = 14,
|
|
VT_OPENPUBLICSLOTNUM = 16,
|
|
VT_MAXSLOT = 18,
|
|
VT_OPENPRIVATESLOTNUM = 20,
|
|
VT_CURMEMBERNUM = 22,
|
|
VT_PASSWORDSLOTMASK = 24,
|
|
VT_OWNER = 26,
|
|
VT_ROOMGROUP = 28,
|
|
VT_FLAGATTR = 30,
|
|
VT_ROOMSEARCHABLEINTATTREXTERNAL = 32,
|
|
VT_ROOMSEARCHABLEBINATTREXTERNAL = 34,
|
|
VT_ROOMBINATTREXTERNAL = 36
|
|
};
|
|
uint16_t serverId() const {
|
|
return GetField<uint16_t>(VT_SERVERID, 0);
|
|
}
|
|
uint32_t worldId() const {
|
|
return GetField<uint32_t>(VT_WORLDID, 0);
|
|
}
|
|
uint16_t publicSlotNum() const {
|
|
return GetField<uint16_t>(VT_PUBLICSLOTNUM, 0);
|
|
}
|
|
uint16_t privateSlotNum() const {
|
|
return GetField<uint16_t>(VT_PRIVATESLOTNUM, 0);
|
|
}
|
|
uint64_t lobbyId() const {
|
|
return GetField<uint64_t>(VT_LOBBYID, 0);
|
|
}
|
|
uint64_t roomId() const {
|
|
return GetField<uint64_t>(VT_ROOMID, 0);
|
|
}
|
|
uint16_t openPublicSlotNum() const {
|
|
return GetField<uint16_t>(VT_OPENPUBLICSLOTNUM, 0);
|
|
}
|
|
uint16_t maxSlot() const {
|
|
return GetField<uint16_t>(VT_MAXSLOT, 0);
|
|
}
|
|
uint16_t openPrivateSlotNum() const {
|
|
return GetField<uint16_t>(VT_OPENPRIVATESLOTNUM, 0);
|
|
}
|
|
uint16_t curMemberNum() const {
|
|
return GetField<uint16_t>(VT_CURMEMBERNUM, 0);
|
|
}
|
|
uint64_t passwordSlotMask() const {
|
|
return GetField<uint64_t>(VT_PASSWORDSLOTMASK, 0);
|
|
}
|
|
const UserInfo *owner() const {
|
|
return GetPointer<const UserInfo *>(VT_OWNER);
|
|
}
|
|
const ::flatbuffers::Vector<::flatbuffers::Offset<RoomGroup>> *roomGroup() const {
|
|
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<RoomGroup>> *>(VT_ROOMGROUP);
|
|
}
|
|
uint32_t flagAttr() const {
|
|
return GetField<uint32_t>(VT_FLAGATTR, 0);
|
|
}
|
|
const ::flatbuffers::Vector<::flatbuffers::Offset<IntAttr>> *roomSearchableIntAttrExternal() const {
|
|
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<IntAttr>> *>(VT_ROOMSEARCHABLEINTATTREXTERNAL);
|
|
}
|
|
const ::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>> *roomSearchableBinAttrExternal() const {
|
|
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>> *>(VT_ROOMSEARCHABLEBINATTREXTERNAL);
|
|
}
|
|
const ::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>> *roomBinAttrExternal() const {
|
|
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>> *>(VT_ROOMBINATTREXTERNAL);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<uint16_t>(verifier, VT_SERVERID, 2) &&
|
|
VerifyField<uint32_t>(verifier, VT_WORLDID, 4) &&
|
|
VerifyField<uint16_t>(verifier, VT_PUBLICSLOTNUM, 2) &&
|
|
VerifyField<uint16_t>(verifier, VT_PRIVATESLOTNUM, 2) &&
|
|
VerifyField<uint64_t>(verifier, VT_LOBBYID, 8) &&
|
|
VerifyField<uint64_t>(verifier, VT_ROOMID, 8) &&
|
|
VerifyField<uint16_t>(verifier, VT_OPENPUBLICSLOTNUM, 2) &&
|
|
VerifyField<uint16_t>(verifier, VT_MAXSLOT, 2) &&
|
|
VerifyField<uint16_t>(verifier, VT_OPENPRIVATESLOTNUM, 2) &&
|
|
VerifyField<uint16_t>(verifier, VT_CURMEMBERNUM, 2) &&
|
|
VerifyField<uint64_t>(verifier, VT_PASSWORDSLOTMASK, 8) &&
|
|
VerifyOffset(verifier, VT_OWNER) &&
|
|
verifier.VerifyTable(owner()) &&
|
|
VerifyOffset(verifier, VT_ROOMGROUP) &&
|
|
verifier.VerifyVector(roomGroup()) &&
|
|
verifier.VerifyVectorOfTables(roomGroup()) &&
|
|
VerifyField<uint32_t>(verifier, VT_FLAGATTR, 4) &&
|
|
VerifyOffset(verifier, VT_ROOMSEARCHABLEINTATTREXTERNAL) &&
|
|
verifier.VerifyVector(roomSearchableIntAttrExternal()) &&
|
|
verifier.VerifyVectorOfTables(roomSearchableIntAttrExternal()) &&
|
|
VerifyOffset(verifier, VT_ROOMSEARCHABLEBINATTREXTERNAL) &&
|
|
verifier.VerifyVector(roomSearchableBinAttrExternal()) &&
|
|
verifier.VerifyVectorOfTables(roomSearchableBinAttrExternal()) &&
|
|
VerifyOffset(verifier, VT_ROOMBINATTREXTERNAL) &&
|
|
verifier.VerifyVector(roomBinAttrExternal()) &&
|
|
verifier.VerifyVectorOfTables(roomBinAttrExternal()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct RoomDataExternalBuilder {
|
|
typedef RoomDataExternal Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_serverId(uint16_t serverId) {
|
|
fbb_.AddElement<uint16_t>(RoomDataExternal::VT_SERVERID, serverId, 0);
|
|
}
|
|
void add_worldId(uint32_t worldId) {
|
|
fbb_.AddElement<uint32_t>(RoomDataExternal::VT_WORLDID, worldId, 0);
|
|
}
|
|
void add_publicSlotNum(uint16_t publicSlotNum) {
|
|
fbb_.AddElement<uint16_t>(RoomDataExternal::VT_PUBLICSLOTNUM, publicSlotNum, 0);
|
|
}
|
|
void add_privateSlotNum(uint16_t privateSlotNum) {
|
|
fbb_.AddElement<uint16_t>(RoomDataExternal::VT_PRIVATESLOTNUM, privateSlotNum, 0);
|
|
}
|
|
void add_lobbyId(uint64_t lobbyId) {
|
|
fbb_.AddElement<uint64_t>(RoomDataExternal::VT_LOBBYID, lobbyId, 0);
|
|
}
|
|
void add_roomId(uint64_t roomId) {
|
|
fbb_.AddElement<uint64_t>(RoomDataExternal::VT_ROOMID, roomId, 0);
|
|
}
|
|
void add_openPublicSlotNum(uint16_t openPublicSlotNum) {
|
|
fbb_.AddElement<uint16_t>(RoomDataExternal::VT_OPENPUBLICSLOTNUM, openPublicSlotNum, 0);
|
|
}
|
|
void add_maxSlot(uint16_t maxSlot) {
|
|
fbb_.AddElement<uint16_t>(RoomDataExternal::VT_MAXSLOT, maxSlot, 0);
|
|
}
|
|
void add_openPrivateSlotNum(uint16_t openPrivateSlotNum) {
|
|
fbb_.AddElement<uint16_t>(RoomDataExternal::VT_OPENPRIVATESLOTNUM, openPrivateSlotNum, 0);
|
|
}
|
|
void add_curMemberNum(uint16_t curMemberNum) {
|
|
fbb_.AddElement<uint16_t>(RoomDataExternal::VT_CURMEMBERNUM, curMemberNum, 0);
|
|
}
|
|
void add_passwordSlotMask(uint64_t passwordSlotMask) {
|
|
fbb_.AddElement<uint64_t>(RoomDataExternal::VT_PASSWORDSLOTMASK, passwordSlotMask, 0);
|
|
}
|
|
void add_owner(::flatbuffers::Offset<UserInfo> owner) {
|
|
fbb_.AddOffset(RoomDataExternal::VT_OWNER, owner);
|
|
}
|
|
void add_roomGroup(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<RoomGroup>>> roomGroup) {
|
|
fbb_.AddOffset(RoomDataExternal::VT_ROOMGROUP, roomGroup);
|
|
}
|
|
void add_flagAttr(uint32_t flagAttr) {
|
|
fbb_.AddElement<uint32_t>(RoomDataExternal::VT_FLAGATTR, flagAttr, 0);
|
|
}
|
|
void add_roomSearchableIntAttrExternal(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<IntAttr>>> roomSearchableIntAttrExternal) {
|
|
fbb_.AddOffset(RoomDataExternal::VT_ROOMSEARCHABLEINTATTREXTERNAL, roomSearchableIntAttrExternal);
|
|
}
|
|
void add_roomSearchableBinAttrExternal(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>>> roomSearchableBinAttrExternal) {
|
|
fbb_.AddOffset(RoomDataExternal::VT_ROOMSEARCHABLEBINATTREXTERNAL, roomSearchableBinAttrExternal);
|
|
}
|
|
void add_roomBinAttrExternal(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>>> roomBinAttrExternal) {
|
|
fbb_.AddOffset(RoomDataExternal::VT_ROOMBINATTREXTERNAL, roomBinAttrExternal);
|
|
}
|
|
explicit RoomDataExternalBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<RoomDataExternal> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<RoomDataExternal>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<RoomDataExternal> CreateRoomDataExternal(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint16_t serverId = 0,
|
|
uint32_t worldId = 0,
|
|
uint16_t publicSlotNum = 0,
|
|
uint16_t privateSlotNum = 0,
|
|
uint64_t lobbyId = 0,
|
|
uint64_t roomId = 0,
|
|
uint16_t openPublicSlotNum = 0,
|
|
uint16_t maxSlot = 0,
|
|
uint16_t openPrivateSlotNum = 0,
|
|
uint16_t curMemberNum = 0,
|
|
uint64_t passwordSlotMask = 0,
|
|
::flatbuffers::Offset<UserInfo> owner = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<RoomGroup>>> roomGroup = 0,
|
|
uint32_t flagAttr = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<IntAttr>>> roomSearchableIntAttrExternal = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>>> roomSearchableBinAttrExternal = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>>> roomBinAttrExternal = 0) {
|
|
RoomDataExternalBuilder builder_(_fbb);
|
|
builder_.add_passwordSlotMask(passwordSlotMask);
|
|
builder_.add_roomId(roomId);
|
|
builder_.add_lobbyId(lobbyId);
|
|
builder_.add_roomBinAttrExternal(roomBinAttrExternal);
|
|
builder_.add_roomSearchableBinAttrExternal(roomSearchableBinAttrExternal);
|
|
builder_.add_roomSearchableIntAttrExternal(roomSearchableIntAttrExternal);
|
|
builder_.add_flagAttr(flagAttr);
|
|
builder_.add_roomGroup(roomGroup);
|
|
builder_.add_owner(owner);
|
|
builder_.add_worldId(worldId);
|
|
builder_.add_curMemberNum(curMemberNum);
|
|
builder_.add_openPrivateSlotNum(openPrivateSlotNum);
|
|
builder_.add_maxSlot(maxSlot);
|
|
builder_.add_openPublicSlotNum(openPublicSlotNum);
|
|
builder_.add_privateSlotNum(privateSlotNum);
|
|
builder_.add_publicSlotNum(publicSlotNum);
|
|
builder_.add_serverId(serverId);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<RoomDataExternal> CreateRoomDataExternalDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint16_t serverId = 0,
|
|
uint32_t worldId = 0,
|
|
uint16_t publicSlotNum = 0,
|
|
uint16_t privateSlotNum = 0,
|
|
uint64_t lobbyId = 0,
|
|
uint64_t roomId = 0,
|
|
uint16_t openPublicSlotNum = 0,
|
|
uint16_t maxSlot = 0,
|
|
uint16_t openPrivateSlotNum = 0,
|
|
uint16_t curMemberNum = 0,
|
|
uint64_t passwordSlotMask = 0,
|
|
::flatbuffers::Offset<UserInfo> owner = 0,
|
|
const std::vector<::flatbuffers::Offset<RoomGroup>> *roomGroup = nullptr,
|
|
uint32_t flagAttr = 0,
|
|
const std::vector<::flatbuffers::Offset<IntAttr>> *roomSearchableIntAttrExternal = nullptr,
|
|
const std::vector<::flatbuffers::Offset<BinAttr>> *roomSearchableBinAttrExternal = nullptr,
|
|
const std::vector<::flatbuffers::Offset<BinAttr>> *roomBinAttrExternal = nullptr) {
|
|
auto roomGroup__ = roomGroup ? _fbb.CreateVector<::flatbuffers::Offset<RoomGroup>>(*roomGroup) : 0;
|
|
auto roomSearchableIntAttrExternal__ = roomSearchableIntAttrExternal ? _fbb.CreateVector<::flatbuffers::Offset<IntAttr>>(*roomSearchableIntAttrExternal) : 0;
|
|
auto roomSearchableBinAttrExternal__ = roomSearchableBinAttrExternal ? _fbb.CreateVector<::flatbuffers::Offset<BinAttr>>(*roomSearchableBinAttrExternal) : 0;
|
|
auto roomBinAttrExternal__ = roomBinAttrExternal ? _fbb.CreateVector<::flatbuffers::Offset<BinAttr>>(*roomBinAttrExternal) : 0;
|
|
return CreateRoomDataExternal(
|
|
_fbb,
|
|
serverId,
|
|
worldId,
|
|
publicSlotNum,
|
|
privateSlotNum,
|
|
lobbyId,
|
|
roomId,
|
|
openPublicSlotNum,
|
|
maxSlot,
|
|
openPrivateSlotNum,
|
|
curMemberNum,
|
|
passwordSlotMask,
|
|
owner,
|
|
roomGroup__,
|
|
flagAttr,
|
|
roomSearchableIntAttrExternal__,
|
|
roomSearchableBinAttrExternal__,
|
|
roomBinAttrExternal__);
|
|
}
|
|
|
|
struct IntSearchFilter FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef IntSearchFilterBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_SEARCHOPERATOR = 4,
|
|
VT_ATTR = 6
|
|
};
|
|
uint8_t searchOperator() const {
|
|
return GetField<uint8_t>(VT_SEARCHOPERATOR, 0);
|
|
}
|
|
const IntAttr *attr() const {
|
|
return GetPointer<const IntAttr *>(VT_ATTR);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<uint8_t>(verifier, VT_SEARCHOPERATOR, 1) &&
|
|
VerifyOffset(verifier, VT_ATTR) &&
|
|
verifier.VerifyTable(attr()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct IntSearchFilterBuilder {
|
|
typedef IntSearchFilter Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_searchOperator(uint8_t searchOperator) {
|
|
fbb_.AddElement<uint8_t>(IntSearchFilter::VT_SEARCHOPERATOR, searchOperator, 0);
|
|
}
|
|
void add_attr(::flatbuffers::Offset<IntAttr> attr) {
|
|
fbb_.AddOffset(IntSearchFilter::VT_ATTR, attr);
|
|
}
|
|
explicit IntSearchFilterBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<IntSearchFilter> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<IntSearchFilter>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<IntSearchFilter> CreateIntSearchFilter(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint8_t searchOperator = 0,
|
|
::flatbuffers::Offset<IntAttr> attr = 0) {
|
|
IntSearchFilterBuilder builder_(_fbb);
|
|
builder_.add_attr(attr);
|
|
builder_.add_searchOperator(searchOperator);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
struct BinSearchFilter FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef BinSearchFilterBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_SEARCHOPERATOR = 4,
|
|
VT_ATTR = 6
|
|
};
|
|
uint8_t searchOperator() const {
|
|
return GetField<uint8_t>(VT_SEARCHOPERATOR, 0);
|
|
}
|
|
const BinAttr *attr() const {
|
|
return GetPointer<const BinAttr *>(VT_ATTR);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<uint8_t>(verifier, VT_SEARCHOPERATOR, 1) &&
|
|
VerifyOffset(verifier, VT_ATTR) &&
|
|
verifier.VerifyTable(attr()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct BinSearchFilterBuilder {
|
|
typedef BinSearchFilter Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_searchOperator(uint8_t searchOperator) {
|
|
fbb_.AddElement<uint8_t>(BinSearchFilter::VT_SEARCHOPERATOR, searchOperator, 0);
|
|
}
|
|
void add_attr(::flatbuffers::Offset<BinAttr> attr) {
|
|
fbb_.AddOffset(BinSearchFilter::VT_ATTR, attr);
|
|
}
|
|
explicit BinSearchFilterBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<BinSearchFilter> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<BinSearchFilter>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<BinSearchFilter> CreateBinSearchFilter(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint8_t searchOperator = 0,
|
|
::flatbuffers::Offset<BinAttr> attr = 0) {
|
|
BinSearchFilterBuilder builder_(_fbb);
|
|
builder_.add_attr(attr);
|
|
builder_.add_searchOperator(searchOperator);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
struct PresenceOptionData FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef PresenceOptionDataBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_DATA = 4,
|
|
VT_LEN = 6
|
|
};
|
|
const ::flatbuffers::Vector<uint8_t> *data() const {
|
|
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_DATA);
|
|
}
|
|
uint32_t len() const {
|
|
return GetField<uint32_t>(VT_LEN, 0);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_DATA) &&
|
|
verifier.VerifyVector(data()) &&
|
|
VerifyField<uint32_t>(verifier, VT_LEN, 4) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct PresenceOptionDataBuilder {
|
|
typedef PresenceOptionData Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_data(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data) {
|
|
fbb_.AddOffset(PresenceOptionData::VT_DATA, data);
|
|
}
|
|
void add_len(uint32_t len) {
|
|
fbb_.AddElement<uint32_t>(PresenceOptionData::VT_LEN, len, 0);
|
|
}
|
|
explicit PresenceOptionDataBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<PresenceOptionData> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<PresenceOptionData>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<PresenceOptionData> CreatePresenceOptionData(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data = 0,
|
|
uint32_t len = 0) {
|
|
PresenceOptionDataBuilder builder_(_fbb);
|
|
builder_.add_len(len);
|
|
builder_.add_data(data);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<PresenceOptionData> CreatePresenceOptionDataDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
const std::vector<uint8_t> *data = nullptr,
|
|
uint32_t len = 0) {
|
|
auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
|
|
return CreatePresenceOptionData(
|
|
_fbb,
|
|
data__,
|
|
len);
|
|
}
|
|
|
|
struct RoomGroupPasswordConfig FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef RoomGroupPasswordConfigBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_GROUPID = 4,
|
|
VT_WITHPASSWORD = 6
|
|
};
|
|
uint8_t groupId() const {
|
|
return GetField<uint8_t>(VT_GROUPID, 0);
|
|
}
|
|
bool withPassword() const {
|
|
return GetField<uint8_t>(VT_WITHPASSWORD, 0) != 0;
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<uint8_t>(verifier, VT_GROUPID, 1) &&
|
|
VerifyField<uint8_t>(verifier, VT_WITHPASSWORD, 1) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct RoomGroupPasswordConfigBuilder {
|
|
typedef RoomGroupPasswordConfig Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_groupId(uint8_t groupId) {
|
|
fbb_.AddElement<uint8_t>(RoomGroupPasswordConfig::VT_GROUPID, groupId, 0);
|
|
}
|
|
void add_withPassword(bool withPassword) {
|
|
fbb_.AddElement<uint8_t>(RoomGroupPasswordConfig::VT_WITHPASSWORD, static_cast<uint8_t>(withPassword), 0);
|
|
}
|
|
explicit RoomGroupPasswordConfigBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<RoomGroupPasswordConfig> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<RoomGroupPasswordConfig>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<RoomGroupPasswordConfig> CreateRoomGroupPasswordConfig(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint8_t groupId = 0,
|
|
bool withPassword = false) {
|
|
RoomGroupPasswordConfigBuilder builder_(_fbb);
|
|
builder_.add_withPassword(withPassword);
|
|
builder_.add_groupId(groupId);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
struct SearchRoomRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef SearchRoomRequestBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_OPTION = 4,
|
|
VT_WORLDID = 6,
|
|
VT_LOBBYID = 8,
|
|
VT_RANGEFILTER_STARTINDEX = 10,
|
|
VT_RANGEFILTER_MAX = 12,
|
|
VT_FLAGFILTER = 14,
|
|
VT_FLAGATTR = 16,
|
|
VT_INTFILTER = 18,
|
|
VT_BINFILTER = 20,
|
|
VT_ATTRID = 22
|
|
};
|
|
int32_t option() const {
|
|
return GetField<int32_t>(VT_OPTION, 0);
|
|
}
|
|
uint32_t worldId() const {
|
|
return GetField<uint32_t>(VT_WORLDID, 0);
|
|
}
|
|
uint64_t lobbyId() const {
|
|
return GetField<uint64_t>(VT_LOBBYID, 0);
|
|
}
|
|
uint32_t rangeFilter_startIndex() const {
|
|
return GetField<uint32_t>(VT_RANGEFILTER_STARTINDEX, 0);
|
|
}
|
|
uint32_t rangeFilter_max() const {
|
|
return GetField<uint32_t>(VT_RANGEFILTER_MAX, 0);
|
|
}
|
|
uint32_t flagFilter() const {
|
|
return GetField<uint32_t>(VT_FLAGFILTER, 0);
|
|
}
|
|
uint32_t flagAttr() const {
|
|
return GetField<uint32_t>(VT_FLAGATTR, 0);
|
|
}
|
|
const ::flatbuffers::Vector<::flatbuffers::Offset<IntSearchFilter>> *intFilter() const {
|
|
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<IntSearchFilter>> *>(VT_INTFILTER);
|
|
}
|
|
const ::flatbuffers::Vector<::flatbuffers::Offset<BinSearchFilter>> *binFilter() const {
|
|
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<BinSearchFilter>> *>(VT_BINFILTER);
|
|
}
|
|
const ::flatbuffers::Vector<uint16_t> *attrId() const {
|
|
return GetPointer<const ::flatbuffers::Vector<uint16_t> *>(VT_ATTRID);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<int32_t>(verifier, VT_OPTION, 4) &&
|
|
VerifyField<uint32_t>(verifier, VT_WORLDID, 4) &&
|
|
VerifyField<uint64_t>(verifier, VT_LOBBYID, 8) &&
|
|
VerifyField<uint32_t>(verifier, VT_RANGEFILTER_STARTINDEX, 4) &&
|
|
VerifyField<uint32_t>(verifier, VT_RANGEFILTER_MAX, 4) &&
|
|
VerifyField<uint32_t>(verifier, VT_FLAGFILTER, 4) &&
|
|
VerifyField<uint32_t>(verifier, VT_FLAGATTR, 4) &&
|
|
VerifyOffset(verifier, VT_INTFILTER) &&
|
|
verifier.VerifyVector(intFilter()) &&
|
|
verifier.VerifyVectorOfTables(intFilter()) &&
|
|
VerifyOffset(verifier, VT_BINFILTER) &&
|
|
verifier.VerifyVector(binFilter()) &&
|
|
verifier.VerifyVectorOfTables(binFilter()) &&
|
|
VerifyOffset(verifier, VT_ATTRID) &&
|
|
verifier.VerifyVector(attrId()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct SearchRoomRequestBuilder {
|
|
typedef SearchRoomRequest Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_option(int32_t option) {
|
|
fbb_.AddElement<int32_t>(SearchRoomRequest::VT_OPTION, option, 0);
|
|
}
|
|
void add_worldId(uint32_t worldId) {
|
|
fbb_.AddElement<uint32_t>(SearchRoomRequest::VT_WORLDID, worldId, 0);
|
|
}
|
|
void add_lobbyId(uint64_t lobbyId) {
|
|
fbb_.AddElement<uint64_t>(SearchRoomRequest::VT_LOBBYID, lobbyId, 0);
|
|
}
|
|
void add_rangeFilter_startIndex(uint32_t rangeFilter_startIndex) {
|
|
fbb_.AddElement<uint32_t>(SearchRoomRequest::VT_RANGEFILTER_STARTINDEX, rangeFilter_startIndex, 0);
|
|
}
|
|
void add_rangeFilter_max(uint32_t rangeFilter_max) {
|
|
fbb_.AddElement<uint32_t>(SearchRoomRequest::VT_RANGEFILTER_MAX, rangeFilter_max, 0);
|
|
}
|
|
void add_flagFilter(uint32_t flagFilter) {
|
|
fbb_.AddElement<uint32_t>(SearchRoomRequest::VT_FLAGFILTER, flagFilter, 0);
|
|
}
|
|
void add_flagAttr(uint32_t flagAttr) {
|
|
fbb_.AddElement<uint32_t>(SearchRoomRequest::VT_FLAGATTR, flagAttr, 0);
|
|
}
|
|
void add_intFilter(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<IntSearchFilter>>> intFilter) {
|
|
fbb_.AddOffset(SearchRoomRequest::VT_INTFILTER, intFilter);
|
|
}
|
|
void add_binFilter(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinSearchFilter>>> binFilter) {
|
|
fbb_.AddOffset(SearchRoomRequest::VT_BINFILTER, binFilter);
|
|
}
|
|
void add_attrId(::flatbuffers::Offset<::flatbuffers::Vector<uint16_t>> attrId) {
|
|
fbb_.AddOffset(SearchRoomRequest::VT_ATTRID, attrId);
|
|
}
|
|
explicit SearchRoomRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<SearchRoomRequest> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<SearchRoomRequest>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<SearchRoomRequest> CreateSearchRoomRequest(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
int32_t option = 0,
|
|
uint32_t worldId = 0,
|
|
uint64_t lobbyId = 0,
|
|
uint32_t rangeFilter_startIndex = 0,
|
|
uint32_t rangeFilter_max = 0,
|
|
uint32_t flagFilter = 0,
|
|
uint32_t flagAttr = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<IntSearchFilter>>> intFilter = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinSearchFilter>>> binFilter = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<uint16_t>> attrId = 0) {
|
|
SearchRoomRequestBuilder builder_(_fbb);
|
|
builder_.add_lobbyId(lobbyId);
|
|
builder_.add_attrId(attrId);
|
|
builder_.add_binFilter(binFilter);
|
|
builder_.add_intFilter(intFilter);
|
|
builder_.add_flagAttr(flagAttr);
|
|
builder_.add_flagFilter(flagFilter);
|
|
builder_.add_rangeFilter_max(rangeFilter_max);
|
|
builder_.add_rangeFilter_startIndex(rangeFilter_startIndex);
|
|
builder_.add_worldId(worldId);
|
|
builder_.add_option(option);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<SearchRoomRequest> CreateSearchRoomRequestDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
int32_t option = 0,
|
|
uint32_t worldId = 0,
|
|
uint64_t lobbyId = 0,
|
|
uint32_t rangeFilter_startIndex = 0,
|
|
uint32_t rangeFilter_max = 0,
|
|
uint32_t flagFilter = 0,
|
|
uint32_t flagAttr = 0,
|
|
const std::vector<::flatbuffers::Offset<IntSearchFilter>> *intFilter = nullptr,
|
|
const std::vector<::flatbuffers::Offset<BinSearchFilter>> *binFilter = nullptr,
|
|
const std::vector<uint16_t> *attrId = nullptr) {
|
|
auto intFilter__ = intFilter ? _fbb.CreateVector<::flatbuffers::Offset<IntSearchFilter>>(*intFilter) : 0;
|
|
auto binFilter__ = binFilter ? _fbb.CreateVector<::flatbuffers::Offset<BinSearchFilter>>(*binFilter) : 0;
|
|
auto attrId__ = attrId ? _fbb.CreateVector<uint16_t>(*attrId) : 0;
|
|
return CreateSearchRoomRequest(
|
|
_fbb,
|
|
option,
|
|
worldId,
|
|
lobbyId,
|
|
rangeFilter_startIndex,
|
|
rangeFilter_max,
|
|
flagFilter,
|
|
flagAttr,
|
|
intFilter__,
|
|
binFilter__,
|
|
attrId__);
|
|
}
|
|
|
|
struct SearchRoomResponse FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef SearchRoomResponseBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_STARTINDEX = 4,
|
|
VT_TOTAL = 6,
|
|
VT_ROOMS = 8
|
|
};
|
|
uint32_t startIndex() const {
|
|
return GetField<uint32_t>(VT_STARTINDEX, 0);
|
|
}
|
|
uint32_t total() const {
|
|
return GetField<uint32_t>(VT_TOTAL, 0);
|
|
}
|
|
const ::flatbuffers::Vector<::flatbuffers::Offset<RoomDataExternal>> *rooms() const {
|
|
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<RoomDataExternal>> *>(VT_ROOMS);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<uint32_t>(verifier, VT_STARTINDEX, 4) &&
|
|
VerifyField<uint32_t>(verifier, VT_TOTAL, 4) &&
|
|
VerifyOffset(verifier, VT_ROOMS) &&
|
|
verifier.VerifyVector(rooms()) &&
|
|
verifier.VerifyVectorOfTables(rooms()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct SearchRoomResponseBuilder {
|
|
typedef SearchRoomResponse Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_startIndex(uint32_t startIndex) {
|
|
fbb_.AddElement<uint32_t>(SearchRoomResponse::VT_STARTINDEX, startIndex, 0);
|
|
}
|
|
void add_total(uint32_t total) {
|
|
fbb_.AddElement<uint32_t>(SearchRoomResponse::VT_TOTAL, total, 0);
|
|
}
|
|
void add_rooms(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<RoomDataExternal>>> rooms) {
|
|
fbb_.AddOffset(SearchRoomResponse::VT_ROOMS, rooms);
|
|
}
|
|
explicit SearchRoomResponseBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<SearchRoomResponse> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<SearchRoomResponse>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<SearchRoomResponse> CreateSearchRoomResponse(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint32_t startIndex = 0,
|
|
uint32_t total = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<RoomDataExternal>>> rooms = 0) {
|
|
SearchRoomResponseBuilder builder_(_fbb);
|
|
builder_.add_rooms(rooms);
|
|
builder_.add_total(total);
|
|
builder_.add_startIndex(startIndex);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<SearchRoomResponse> CreateSearchRoomResponseDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint32_t startIndex = 0,
|
|
uint32_t total = 0,
|
|
const std::vector<::flatbuffers::Offset<RoomDataExternal>> *rooms = nullptr) {
|
|
auto rooms__ = rooms ? _fbb.CreateVector<::flatbuffers::Offset<RoomDataExternal>>(*rooms) : 0;
|
|
return CreateSearchRoomResponse(
|
|
_fbb,
|
|
startIndex,
|
|
total,
|
|
rooms__);
|
|
}
|
|
|
|
struct CreateJoinRoomRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef CreateJoinRoomRequestBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_WORLDID = 4,
|
|
VT_LOBBYID = 6,
|
|
VT_MAXSLOT = 8,
|
|
VT_FLAGATTR = 10,
|
|
VT_ROOMBINATTRINTERNAL = 12,
|
|
VT_ROOMSEARCHABLEINTATTREXTERNAL = 14,
|
|
VT_ROOMSEARCHABLEBINATTREXTERNAL = 16,
|
|
VT_ROOMBINATTREXTERNAL = 18,
|
|
VT_ROOMPASSWORD = 20,
|
|
VT_GROUPCONFIG = 22,
|
|
VT_PASSWORDSLOTMASK = 24,
|
|
VT_ALLOWEDUSER = 26,
|
|
VT_BLOCKEDUSER = 28,
|
|
VT_JOINROOMGROUPLABEL = 30,
|
|
VT_ROOMMEMBERBINATTRINTERNAL = 32,
|
|
VT_TEAMID = 34,
|
|
VT_SIGOPTPARAM = 36
|
|
};
|
|
uint32_t worldId() const {
|
|
return GetField<uint32_t>(VT_WORLDID, 0);
|
|
}
|
|
uint64_t lobbyId() const {
|
|
return GetField<uint64_t>(VT_LOBBYID, 0);
|
|
}
|
|
uint32_t maxSlot() const {
|
|
return GetField<uint32_t>(VT_MAXSLOT, 0);
|
|
}
|
|
uint32_t flagAttr() const {
|
|
return GetField<uint32_t>(VT_FLAGATTR, 0);
|
|
}
|
|
const ::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>> *roomBinAttrInternal() const {
|
|
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>> *>(VT_ROOMBINATTRINTERNAL);
|
|
}
|
|
const ::flatbuffers::Vector<::flatbuffers::Offset<IntAttr>> *roomSearchableIntAttrExternal() const {
|
|
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<IntAttr>> *>(VT_ROOMSEARCHABLEINTATTREXTERNAL);
|
|
}
|
|
const ::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>> *roomSearchableBinAttrExternal() const {
|
|
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>> *>(VT_ROOMSEARCHABLEBINATTREXTERNAL);
|
|
}
|
|
const ::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>> *roomBinAttrExternal() const {
|
|
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>> *>(VT_ROOMBINATTREXTERNAL);
|
|
}
|
|
const ::flatbuffers::Vector<uint8_t> *roomPassword() const {
|
|
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_ROOMPASSWORD);
|
|
}
|
|
const ::flatbuffers::Vector<::flatbuffers::Offset<GroupConfig>> *groupConfig() const {
|
|
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<GroupConfig>> *>(VT_GROUPCONFIG);
|
|
}
|
|
uint64_t passwordSlotMask() const {
|
|
return GetField<uint64_t>(VT_PASSWORDSLOTMASK, 0);
|
|
}
|
|
const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *allowedUser() const {
|
|
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_ALLOWEDUSER);
|
|
}
|
|
const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *blockedUser() const {
|
|
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_BLOCKEDUSER);
|
|
}
|
|
const ::flatbuffers::Vector<uint8_t> *joinRoomGroupLabel() const {
|
|
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_JOINROOMGROUPLABEL);
|
|
}
|
|
const ::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>> *roomMemberBinAttrInternal() const {
|
|
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>> *>(VT_ROOMMEMBERBINATTRINTERNAL);
|
|
}
|
|
uint8_t teamId() const {
|
|
return GetField<uint8_t>(VT_TEAMID, 0);
|
|
}
|
|
const OptParam *sigOptParam() const {
|
|
return GetPointer<const OptParam *>(VT_SIGOPTPARAM);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<uint32_t>(verifier, VT_WORLDID, 4) &&
|
|
VerifyField<uint64_t>(verifier, VT_LOBBYID, 8) &&
|
|
VerifyField<uint32_t>(verifier, VT_MAXSLOT, 4) &&
|
|
VerifyField<uint32_t>(verifier, VT_FLAGATTR, 4) &&
|
|
VerifyOffset(verifier, VT_ROOMBINATTRINTERNAL) &&
|
|
verifier.VerifyVector(roomBinAttrInternal()) &&
|
|
verifier.VerifyVectorOfTables(roomBinAttrInternal()) &&
|
|
VerifyOffset(verifier, VT_ROOMSEARCHABLEINTATTREXTERNAL) &&
|
|
verifier.VerifyVector(roomSearchableIntAttrExternal()) &&
|
|
verifier.VerifyVectorOfTables(roomSearchableIntAttrExternal()) &&
|
|
VerifyOffset(verifier, VT_ROOMSEARCHABLEBINATTREXTERNAL) &&
|
|
verifier.VerifyVector(roomSearchableBinAttrExternal()) &&
|
|
verifier.VerifyVectorOfTables(roomSearchableBinAttrExternal()) &&
|
|
VerifyOffset(verifier, VT_ROOMBINATTREXTERNAL) &&
|
|
verifier.VerifyVector(roomBinAttrExternal()) &&
|
|
verifier.VerifyVectorOfTables(roomBinAttrExternal()) &&
|
|
VerifyOffset(verifier, VT_ROOMPASSWORD) &&
|
|
verifier.VerifyVector(roomPassword()) &&
|
|
VerifyOffset(verifier, VT_GROUPCONFIG) &&
|
|
verifier.VerifyVector(groupConfig()) &&
|
|
verifier.VerifyVectorOfTables(groupConfig()) &&
|
|
VerifyField<uint64_t>(verifier, VT_PASSWORDSLOTMASK, 8) &&
|
|
VerifyOffset(verifier, VT_ALLOWEDUSER) &&
|
|
verifier.VerifyVector(allowedUser()) &&
|
|
verifier.VerifyVectorOfStrings(allowedUser()) &&
|
|
VerifyOffset(verifier, VT_BLOCKEDUSER) &&
|
|
verifier.VerifyVector(blockedUser()) &&
|
|
verifier.VerifyVectorOfStrings(blockedUser()) &&
|
|
VerifyOffset(verifier, VT_JOINROOMGROUPLABEL) &&
|
|
verifier.VerifyVector(joinRoomGroupLabel()) &&
|
|
VerifyOffset(verifier, VT_ROOMMEMBERBINATTRINTERNAL) &&
|
|
verifier.VerifyVector(roomMemberBinAttrInternal()) &&
|
|
verifier.VerifyVectorOfTables(roomMemberBinAttrInternal()) &&
|
|
VerifyField<uint8_t>(verifier, VT_TEAMID, 1) &&
|
|
VerifyOffset(verifier, VT_SIGOPTPARAM) &&
|
|
verifier.VerifyTable(sigOptParam()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct CreateJoinRoomRequestBuilder {
|
|
typedef CreateJoinRoomRequest Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_worldId(uint32_t worldId) {
|
|
fbb_.AddElement<uint32_t>(CreateJoinRoomRequest::VT_WORLDID, worldId, 0);
|
|
}
|
|
void add_lobbyId(uint64_t lobbyId) {
|
|
fbb_.AddElement<uint64_t>(CreateJoinRoomRequest::VT_LOBBYID, lobbyId, 0);
|
|
}
|
|
void add_maxSlot(uint32_t maxSlot) {
|
|
fbb_.AddElement<uint32_t>(CreateJoinRoomRequest::VT_MAXSLOT, maxSlot, 0);
|
|
}
|
|
void add_flagAttr(uint32_t flagAttr) {
|
|
fbb_.AddElement<uint32_t>(CreateJoinRoomRequest::VT_FLAGATTR, flagAttr, 0);
|
|
}
|
|
void add_roomBinAttrInternal(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>>> roomBinAttrInternal) {
|
|
fbb_.AddOffset(CreateJoinRoomRequest::VT_ROOMBINATTRINTERNAL, roomBinAttrInternal);
|
|
}
|
|
void add_roomSearchableIntAttrExternal(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<IntAttr>>> roomSearchableIntAttrExternal) {
|
|
fbb_.AddOffset(CreateJoinRoomRequest::VT_ROOMSEARCHABLEINTATTREXTERNAL, roomSearchableIntAttrExternal);
|
|
}
|
|
void add_roomSearchableBinAttrExternal(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>>> roomSearchableBinAttrExternal) {
|
|
fbb_.AddOffset(CreateJoinRoomRequest::VT_ROOMSEARCHABLEBINATTREXTERNAL, roomSearchableBinAttrExternal);
|
|
}
|
|
void add_roomBinAttrExternal(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>>> roomBinAttrExternal) {
|
|
fbb_.AddOffset(CreateJoinRoomRequest::VT_ROOMBINATTREXTERNAL, roomBinAttrExternal);
|
|
}
|
|
void add_roomPassword(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> roomPassword) {
|
|
fbb_.AddOffset(CreateJoinRoomRequest::VT_ROOMPASSWORD, roomPassword);
|
|
}
|
|
void add_groupConfig(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<GroupConfig>>> groupConfig) {
|
|
fbb_.AddOffset(CreateJoinRoomRequest::VT_GROUPCONFIG, groupConfig);
|
|
}
|
|
void add_passwordSlotMask(uint64_t passwordSlotMask) {
|
|
fbb_.AddElement<uint64_t>(CreateJoinRoomRequest::VT_PASSWORDSLOTMASK, passwordSlotMask, 0);
|
|
}
|
|
void add_allowedUser(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> allowedUser) {
|
|
fbb_.AddOffset(CreateJoinRoomRequest::VT_ALLOWEDUSER, allowedUser);
|
|
}
|
|
void add_blockedUser(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> blockedUser) {
|
|
fbb_.AddOffset(CreateJoinRoomRequest::VT_BLOCKEDUSER, blockedUser);
|
|
}
|
|
void add_joinRoomGroupLabel(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> joinRoomGroupLabel) {
|
|
fbb_.AddOffset(CreateJoinRoomRequest::VT_JOINROOMGROUPLABEL, joinRoomGroupLabel);
|
|
}
|
|
void add_roomMemberBinAttrInternal(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>>> roomMemberBinAttrInternal) {
|
|
fbb_.AddOffset(CreateJoinRoomRequest::VT_ROOMMEMBERBINATTRINTERNAL, roomMemberBinAttrInternal);
|
|
}
|
|
void add_teamId(uint8_t teamId) {
|
|
fbb_.AddElement<uint8_t>(CreateJoinRoomRequest::VT_TEAMID, teamId, 0);
|
|
}
|
|
void add_sigOptParam(::flatbuffers::Offset<OptParam> sigOptParam) {
|
|
fbb_.AddOffset(CreateJoinRoomRequest::VT_SIGOPTPARAM, sigOptParam);
|
|
}
|
|
explicit CreateJoinRoomRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<CreateJoinRoomRequest> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<CreateJoinRoomRequest>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<CreateJoinRoomRequest> CreateCreateJoinRoomRequest(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint32_t worldId = 0,
|
|
uint64_t lobbyId = 0,
|
|
uint32_t maxSlot = 0,
|
|
uint32_t flagAttr = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>>> roomBinAttrInternal = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<IntAttr>>> roomSearchableIntAttrExternal = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>>> roomSearchableBinAttrExternal = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>>> roomBinAttrExternal = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> roomPassword = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<GroupConfig>>> groupConfig = 0,
|
|
uint64_t passwordSlotMask = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> allowedUser = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> blockedUser = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> joinRoomGroupLabel = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>>> roomMemberBinAttrInternal = 0,
|
|
uint8_t teamId = 0,
|
|
::flatbuffers::Offset<OptParam> sigOptParam = 0) {
|
|
CreateJoinRoomRequestBuilder builder_(_fbb);
|
|
builder_.add_passwordSlotMask(passwordSlotMask);
|
|
builder_.add_lobbyId(lobbyId);
|
|
builder_.add_sigOptParam(sigOptParam);
|
|
builder_.add_roomMemberBinAttrInternal(roomMemberBinAttrInternal);
|
|
builder_.add_joinRoomGroupLabel(joinRoomGroupLabel);
|
|
builder_.add_blockedUser(blockedUser);
|
|
builder_.add_allowedUser(allowedUser);
|
|
builder_.add_groupConfig(groupConfig);
|
|
builder_.add_roomPassword(roomPassword);
|
|
builder_.add_roomBinAttrExternal(roomBinAttrExternal);
|
|
builder_.add_roomSearchableBinAttrExternal(roomSearchableBinAttrExternal);
|
|
builder_.add_roomSearchableIntAttrExternal(roomSearchableIntAttrExternal);
|
|
builder_.add_roomBinAttrInternal(roomBinAttrInternal);
|
|
builder_.add_flagAttr(flagAttr);
|
|
builder_.add_maxSlot(maxSlot);
|
|
builder_.add_worldId(worldId);
|
|
builder_.add_teamId(teamId);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<CreateJoinRoomRequest> CreateCreateJoinRoomRequestDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint32_t worldId = 0,
|
|
uint64_t lobbyId = 0,
|
|
uint32_t maxSlot = 0,
|
|
uint32_t flagAttr = 0,
|
|
const std::vector<::flatbuffers::Offset<BinAttr>> *roomBinAttrInternal = nullptr,
|
|
const std::vector<::flatbuffers::Offset<IntAttr>> *roomSearchableIntAttrExternal = nullptr,
|
|
const std::vector<::flatbuffers::Offset<BinAttr>> *roomSearchableBinAttrExternal = nullptr,
|
|
const std::vector<::flatbuffers::Offset<BinAttr>> *roomBinAttrExternal = nullptr,
|
|
const std::vector<uint8_t> *roomPassword = nullptr,
|
|
const std::vector<::flatbuffers::Offset<GroupConfig>> *groupConfig = nullptr,
|
|
uint64_t passwordSlotMask = 0,
|
|
const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *allowedUser = nullptr,
|
|
const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *blockedUser = nullptr,
|
|
const std::vector<uint8_t> *joinRoomGroupLabel = nullptr,
|
|
const std::vector<::flatbuffers::Offset<BinAttr>> *roomMemberBinAttrInternal = nullptr,
|
|
uint8_t teamId = 0,
|
|
::flatbuffers::Offset<OptParam> sigOptParam = 0) {
|
|
auto roomBinAttrInternal__ = roomBinAttrInternal ? _fbb.CreateVector<::flatbuffers::Offset<BinAttr>>(*roomBinAttrInternal) : 0;
|
|
auto roomSearchableIntAttrExternal__ = roomSearchableIntAttrExternal ? _fbb.CreateVector<::flatbuffers::Offset<IntAttr>>(*roomSearchableIntAttrExternal) : 0;
|
|
auto roomSearchableBinAttrExternal__ = roomSearchableBinAttrExternal ? _fbb.CreateVector<::flatbuffers::Offset<BinAttr>>(*roomSearchableBinAttrExternal) : 0;
|
|
auto roomBinAttrExternal__ = roomBinAttrExternal ? _fbb.CreateVector<::flatbuffers::Offset<BinAttr>>(*roomBinAttrExternal) : 0;
|
|
auto roomPassword__ = roomPassword ? _fbb.CreateVector<uint8_t>(*roomPassword) : 0;
|
|
auto groupConfig__ = groupConfig ? _fbb.CreateVector<::flatbuffers::Offset<GroupConfig>>(*groupConfig) : 0;
|
|
auto allowedUser__ = allowedUser ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*allowedUser) : 0;
|
|
auto blockedUser__ = blockedUser ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*blockedUser) : 0;
|
|
auto joinRoomGroupLabel__ = joinRoomGroupLabel ? _fbb.CreateVector<uint8_t>(*joinRoomGroupLabel) : 0;
|
|
auto roomMemberBinAttrInternal__ = roomMemberBinAttrInternal ? _fbb.CreateVector<::flatbuffers::Offset<BinAttr>>(*roomMemberBinAttrInternal) : 0;
|
|
return CreateCreateJoinRoomRequest(
|
|
_fbb,
|
|
worldId,
|
|
lobbyId,
|
|
maxSlot,
|
|
flagAttr,
|
|
roomBinAttrInternal__,
|
|
roomSearchableIntAttrExternal__,
|
|
roomSearchableBinAttrExternal__,
|
|
roomBinAttrExternal__,
|
|
roomPassword__,
|
|
groupConfig__,
|
|
passwordSlotMask,
|
|
allowedUser__,
|
|
blockedUser__,
|
|
joinRoomGroupLabel__,
|
|
roomMemberBinAttrInternal__,
|
|
teamId,
|
|
sigOptParam);
|
|
}
|
|
|
|
struct JoinRoomRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef JoinRoomRequestBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_ROOMID = 4,
|
|
VT_ROOMPASSWORD = 6,
|
|
VT_JOINROOMGROUPLABEL = 8,
|
|
VT_ROOMMEMBERBINATTRINTERNAL = 10,
|
|
VT_OPTDATA = 12,
|
|
VT_TEAMID = 14
|
|
};
|
|
uint64_t roomId() const {
|
|
return GetField<uint64_t>(VT_ROOMID, 0);
|
|
}
|
|
const ::flatbuffers::Vector<uint8_t> *roomPassword() const {
|
|
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_ROOMPASSWORD);
|
|
}
|
|
const ::flatbuffers::Vector<uint8_t> *joinRoomGroupLabel() const {
|
|
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_JOINROOMGROUPLABEL);
|
|
}
|
|
const ::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>> *roomMemberBinAttrInternal() const {
|
|
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>> *>(VT_ROOMMEMBERBINATTRINTERNAL);
|
|
}
|
|
const PresenceOptionData *optData() const {
|
|
return GetPointer<const PresenceOptionData *>(VT_OPTDATA);
|
|
}
|
|
uint8_t teamId() const {
|
|
return GetField<uint8_t>(VT_TEAMID, 0);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<uint64_t>(verifier, VT_ROOMID, 8) &&
|
|
VerifyOffset(verifier, VT_ROOMPASSWORD) &&
|
|
verifier.VerifyVector(roomPassword()) &&
|
|
VerifyOffset(verifier, VT_JOINROOMGROUPLABEL) &&
|
|
verifier.VerifyVector(joinRoomGroupLabel()) &&
|
|
VerifyOffset(verifier, VT_ROOMMEMBERBINATTRINTERNAL) &&
|
|
verifier.VerifyVector(roomMemberBinAttrInternal()) &&
|
|
verifier.VerifyVectorOfTables(roomMemberBinAttrInternal()) &&
|
|
VerifyOffset(verifier, VT_OPTDATA) &&
|
|
verifier.VerifyTable(optData()) &&
|
|
VerifyField<uint8_t>(verifier, VT_TEAMID, 1) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct JoinRoomRequestBuilder {
|
|
typedef JoinRoomRequest Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_roomId(uint64_t roomId) {
|
|
fbb_.AddElement<uint64_t>(JoinRoomRequest::VT_ROOMID, roomId, 0);
|
|
}
|
|
void add_roomPassword(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> roomPassword) {
|
|
fbb_.AddOffset(JoinRoomRequest::VT_ROOMPASSWORD, roomPassword);
|
|
}
|
|
void add_joinRoomGroupLabel(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> joinRoomGroupLabel) {
|
|
fbb_.AddOffset(JoinRoomRequest::VT_JOINROOMGROUPLABEL, joinRoomGroupLabel);
|
|
}
|
|
void add_roomMemberBinAttrInternal(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>>> roomMemberBinAttrInternal) {
|
|
fbb_.AddOffset(JoinRoomRequest::VT_ROOMMEMBERBINATTRINTERNAL, roomMemberBinAttrInternal);
|
|
}
|
|
void add_optData(::flatbuffers::Offset<PresenceOptionData> optData) {
|
|
fbb_.AddOffset(JoinRoomRequest::VT_OPTDATA, optData);
|
|
}
|
|
void add_teamId(uint8_t teamId) {
|
|
fbb_.AddElement<uint8_t>(JoinRoomRequest::VT_TEAMID, teamId, 0);
|
|
}
|
|
explicit JoinRoomRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<JoinRoomRequest> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<JoinRoomRequest>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<JoinRoomRequest> CreateJoinRoomRequest(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint64_t roomId = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> roomPassword = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> joinRoomGroupLabel = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>>> roomMemberBinAttrInternal = 0,
|
|
::flatbuffers::Offset<PresenceOptionData> optData = 0,
|
|
uint8_t teamId = 0) {
|
|
JoinRoomRequestBuilder builder_(_fbb);
|
|
builder_.add_roomId(roomId);
|
|
builder_.add_optData(optData);
|
|
builder_.add_roomMemberBinAttrInternal(roomMemberBinAttrInternal);
|
|
builder_.add_joinRoomGroupLabel(joinRoomGroupLabel);
|
|
builder_.add_roomPassword(roomPassword);
|
|
builder_.add_teamId(teamId);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<JoinRoomRequest> CreateJoinRoomRequestDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint64_t roomId = 0,
|
|
const std::vector<uint8_t> *roomPassword = nullptr,
|
|
const std::vector<uint8_t> *joinRoomGroupLabel = nullptr,
|
|
const std::vector<::flatbuffers::Offset<BinAttr>> *roomMemberBinAttrInternal = nullptr,
|
|
::flatbuffers::Offset<PresenceOptionData> optData = 0,
|
|
uint8_t teamId = 0) {
|
|
auto roomPassword__ = roomPassword ? _fbb.CreateVector<uint8_t>(*roomPassword) : 0;
|
|
auto joinRoomGroupLabel__ = joinRoomGroupLabel ? _fbb.CreateVector<uint8_t>(*joinRoomGroupLabel) : 0;
|
|
auto roomMemberBinAttrInternal__ = roomMemberBinAttrInternal ? _fbb.CreateVector<::flatbuffers::Offset<BinAttr>>(*roomMemberBinAttrInternal) : 0;
|
|
return CreateJoinRoomRequest(
|
|
_fbb,
|
|
roomId,
|
|
roomPassword__,
|
|
joinRoomGroupLabel__,
|
|
roomMemberBinAttrInternal__,
|
|
optData,
|
|
teamId);
|
|
}
|
|
|
|
struct JoinRoomResponse FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef JoinRoomResponseBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_ROOM_DATA = 4,
|
|
VT_SIGNALING_DATA = 6
|
|
};
|
|
const RoomDataInternal *room_data() const {
|
|
return GetPointer<const RoomDataInternal *>(VT_ROOM_DATA);
|
|
}
|
|
const ::flatbuffers::Vector<::flatbuffers::Offset<Matching2SignalingInfo>> *signaling_data() const {
|
|
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<Matching2SignalingInfo>> *>(VT_SIGNALING_DATA);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_ROOM_DATA) &&
|
|
verifier.VerifyTable(room_data()) &&
|
|
VerifyOffset(verifier, VT_SIGNALING_DATA) &&
|
|
verifier.VerifyVector(signaling_data()) &&
|
|
verifier.VerifyVectorOfTables(signaling_data()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct JoinRoomResponseBuilder {
|
|
typedef JoinRoomResponse Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_room_data(::flatbuffers::Offset<RoomDataInternal> room_data) {
|
|
fbb_.AddOffset(JoinRoomResponse::VT_ROOM_DATA, room_data);
|
|
}
|
|
void add_signaling_data(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<Matching2SignalingInfo>>> signaling_data) {
|
|
fbb_.AddOffset(JoinRoomResponse::VT_SIGNALING_DATA, signaling_data);
|
|
}
|
|
explicit JoinRoomResponseBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<JoinRoomResponse> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<JoinRoomResponse>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<JoinRoomResponse> CreateJoinRoomResponse(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<RoomDataInternal> room_data = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<Matching2SignalingInfo>>> signaling_data = 0) {
|
|
JoinRoomResponseBuilder builder_(_fbb);
|
|
builder_.add_signaling_data(signaling_data);
|
|
builder_.add_room_data(room_data);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<JoinRoomResponse> CreateJoinRoomResponseDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<RoomDataInternal> room_data = 0,
|
|
const std::vector<::flatbuffers::Offset<Matching2SignalingInfo>> *signaling_data = nullptr) {
|
|
auto signaling_data__ = signaling_data ? _fbb.CreateVector<::flatbuffers::Offset<Matching2SignalingInfo>>(*signaling_data) : 0;
|
|
return CreateJoinRoomResponse(
|
|
_fbb,
|
|
room_data,
|
|
signaling_data__);
|
|
}
|
|
|
|
struct LeaveRoomRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef LeaveRoomRequestBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_ROOMID = 4,
|
|
VT_OPTDATA = 6
|
|
};
|
|
uint64_t roomId() const {
|
|
return GetField<uint64_t>(VT_ROOMID, 0);
|
|
}
|
|
const PresenceOptionData *optData() const {
|
|
return GetPointer<const PresenceOptionData *>(VT_OPTDATA);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<uint64_t>(verifier, VT_ROOMID, 8) &&
|
|
VerifyOffset(verifier, VT_OPTDATA) &&
|
|
verifier.VerifyTable(optData()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct LeaveRoomRequestBuilder {
|
|
typedef LeaveRoomRequest Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_roomId(uint64_t roomId) {
|
|
fbb_.AddElement<uint64_t>(LeaveRoomRequest::VT_ROOMID, roomId, 0);
|
|
}
|
|
void add_optData(::flatbuffers::Offset<PresenceOptionData> optData) {
|
|
fbb_.AddOffset(LeaveRoomRequest::VT_OPTDATA, optData);
|
|
}
|
|
explicit LeaveRoomRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<LeaveRoomRequest> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<LeaveRoomRequest>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<LeaveRoomRequest> CreateLeaveRoomRequest(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint64_t roomId = 0,
|
|
::flatbuffers::Offset<PresenceOptionData> optData = 0) {
|
|
LeaveRoomRequestBuilder builder_(_fbb);
|
|
builder_.add_roomId(roomId);
|
|
builder_.add_optData(optData);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
struct GetRoomDataExternalListRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef GetRoomDataExternalListRequestBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_ROOMIDS = 4,
|
|
VT_ATTRIDS = 6
|
|
};
|
|
const ::flatbuffers::Vector<uint64_t> *roomIds() const {
|
|
return GetPointer<const ::flatbuffers::Vector<uint64_t> *>(VT_ROOMIDS);
|
|
}
|
|
const ::flatbuffers::Vector<uint16_t> *attrIds() const {
|
|
return GetPointer<const ::flatbuffers::Vector<uint16_t> *>(VT_ATTRIDS);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_ROOMIDS) &&
|
|
verifier.VerifyVector(roomIds()) &&
|
|
VerifyOffset(verifier, VT_ATTRIDS) &&
|
|
verifier.VerifyVector(attrIds()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct GetRoomDataExternalListRequestBuilder {
|
|
typedef GetRoomDataExternalListRequest Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_roomIds(::flatbuffers::Offset<::flatbuffers::Vector<uint64_t>> roomIds) {
|
|
fbb_.AddOffset(GetRoomDataExternalListRequest::VT_ROOMIDS, roomIds);
|
|
}
|
|
void add_attrIds(::flatbuffers::Offset<::flatbuffers::Vector<uint16_t>> attrIds) {
|
|
fbb_.AddOffset(GetRoomDataExternalListRequest::VT_ATTRIDS, attrIds);
|
|
}
|
|
explicit GetRoomDataExternalListRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<GetRoomDataExternalListRequest> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<GetRoomDataExternalListRequest>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<GetRoomDataExternalListRequest> CreateGetRoomDataExternalListRequest(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<uint64_t>> roomIds = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<uint16_t>> attrIds = 0) {
|
|
GetRoomDataExternalListRequestBuilder builder_(_fbb);
|
|
builder_.add_attrIds(attrIds);
|
|
builder_.add_roomIds(roomIds);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<GetRoomDataExternalListRequest> CreateGetRoomDataExternalListRequestDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
const std::vector<uint64_t> *roomIds = nullptr,
|
|
const std::vector<uint16_t> *attrIds = nullptr) {
|
|
auto roomIds__ = roomIds ? _fbb.CreateVector<uint64_t>(*roomIds) : 0;
|
|
auto attrIds__ = attrIds ? _fbb.CreateVector<uint16_t>(*attrIds) : 0;
|
|
return CreateGetRoomDataExternalListRequest(
|
|
_fbb,
|
|
roomIds__,
|
|
attrIds__);
|
|
}
|
|
|
|
struct GetRoomDataExternalListResponse FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef GetRoomDataExternalListResponseBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_ROOMS = 4
|
|
};
|
|
const ::flatbuffers::Vector<::flatbuffers::Offset<RoomDataExternal>> *rooms() const {
|
|
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<RoomDataExternal>> *>(VT_ROOMS);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_ROOMS) &&
|
|
verifier.VerifyVector(rooms()) &&
|
|
verifier.VerifyVectorOfTables(rooms()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct GetRoomDataExternalListResponseBuilder {
|
|
typedef GetRoomDataExternalListResponse Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_rooms(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<RoomDataExternal>>> rooms) {
|
|
fbb_.AddOffset(GetRoomDataExternalListResponse::VT_ROOMS, rooms);
|
|
}
|
|
explicit GetRoomDataExternalListResponseBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<GetRoomDataExternalListResponse> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<GetRoomDataExternalListResponse>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<GetRoomDataExternalListResponse> CreateGetRoomDataExternalListResponse(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<RoomDataExternal>>> rooms = 0) {
|
|
GetRoomDataExternalListResponseBuilder builder_(_fbb);
|
|
builder_.add_rooms(rooms);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<GetRoomDataExternalListResponse> CreateGetRoomDataExternalListResponseDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
const std::vector<::flatbuffers::Offset<RoomDataExternal>> *rooms = nullptr) {
|
|
auto rooms__ = rooms ? _fbb.CreateVector<::flatbuffers::Offset<RoomDataExternal>>(*rooms) : 0;
|
|
return CreateGetRoomDataExternalListResponse(
|
|
_fbb,
|
|
rooms__);
|
|
}
|
|
|
|
struct SetRoomDataExternalRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef SetRoomDataExternalRequestBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_ROOMID = 4,
|
|
VT_ROOMSEARCHABLEINTATTREXTERNAL = 6,
|
|
VT_ROOMSEARCHABLEBINATTREXTERNAL = 8,
|
|
VT_ROOMBINATTREXTERNAL = 10
|
|
};
|
|
uint64_t roomId() const {
|
|
return GetField<uint64_t>(VT_ROOMID, 0);
|
|
}
|
|
const ::flatbuffers::Vector<::flatbuffers::Offset<IntAttr>> *roomSearchableIntAttrExternal() const {
|
|
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<IntAttr>> *>(VT_ROOMSEARCHABLEINTATTREXTERNAL);
|
|
}
|
|
const ::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>> *roomSearchableBinAttrExternal() const {
|
|
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>> *>(VT_ROOMSEARCHABLEBINATTREXTERNAL);
|
|
}
|
|
const ::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>> *roomBinAttrExternal() const {
|
|
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>> *>(VT_ROOMBINATTREXTERNAL);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<uint64_t>(verifier, VT_ROOMID, 8) &&
|
|
VerifyOffset(verifier, VT_ROOMSEARCHABLEINTATTREXTERNAL) &&
|
|
verifier.VerifyVector(roomSearchableIntAttrExternal()) &&
|
|
verifier.VerifyVectorOfTables(roomSearchableIntAttrExternal()) &&
|
|
VerifyOffset(verifier, VT_ROOMSEARCHABLEBINATTREXTERNAL) &&
|
|
verifier.VerifyVector(roomSearchableBinAttrExternal()) &&
|
|
verifier.VerifyVectorOfTables(roomSearchableBinAttrExternal()) &&
|
|
VerifyOffset(verifier, VT_ROOMBINATTREXTERNAL) &&
|
|
verifier.VerifyVector(roomBinAttrExternal()) &&
|
|
verifier.VerifyVectorOfTables(roomBinAttrExternal()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct SetRoomDataExternalRequestBuilder {
|
|
typedef SetRoomDataExternalRequest Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_roomId(uint64_t roomId) {
|
|
fbb_.AddElement<uint64_t>(SetRoomDataExternalRequest::VT_ROOMID, roomId, 0);
|
|
}
|
|
void add_roomSearchableIntAttrExternal(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<IntAttr>>> roomSearchableIntAttrExternal) {
|
|
fbb_.AddOffset(SetRoomDataExternalRequest::VT_ROOMSEARCHABLEINTATTREXTERNAL, roomSearchableIntAttrExternal);
|
|
}
|
|
void add_roomSearchableBinAttrExternal(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>>> roomSearchableBinAttrExternal) {
|
|
fbb_.AddOffset(SetRoomDataExternalRequest::VT_ROOMSEARCHABLEBINATTREXTERNAL, roomSearchableBinAttrExternal);
|
|
}
|
|
void add_roomBinAttrExternal(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>>> roomBinAttrExternal) {
|
|
fbb_.AddOffset(SetRoomDataExternalRequest::VT_ROOMBINATTREXTERNAL, roomBinAttrExternal);
|
|
}
|
|
explicit SetRoomDataExternalRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<SetRoomDataExternalRequest> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<SetRoomDataExternalRequest>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<SetRoomDataExternalRequest> CreateSetRoomDataExternalRequest(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint64_t roomId = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<IntAttr>>> roomSearchableIntAttrExternal = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>>> roomSearchableBinAttrExternal = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>>> roomBinAttrExternal = 0) {
|
|
SetRoomDataExternalRequestBuilder builder_(_fbb);
|
|
builder_.add_roomId(roomId);
|
|
builder_.add_roomBinAttrExternal(roomBinAttrExternal);
|
|
builder_.add_roomSearchableBinAttrExternal(roomSearchableBinAttrExternal);
|
|
builder_.add_roomSearchableIntAttrExternal(roomSearchableIntAttrExternal);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<SetRoomDataExternalRequest> CreateSetRoomDataExternalRequestDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint64_t roomId = 0,
|
|
const std::vector<::flatbuffers::Offset<IntAttr>> *roomSearchableIntAttrExternal = nullptr,
|
|
const std::vector<::flatbuffers::Offset<BinAttr>> *roomSearchableBinAttrExternal = nullptr,
|
|
const std::vector<::flatbuffers::Offset<BinAttr>> *roomBinAttrExternal = nullptr) {
|
|
auto roomSearchableIntAttrExternal__ = roomSearchableIntAttrExternal ? _fbb.CreateVector<::flatbuffers::Offset<IntAttr>>(*roomSearchableIntAttrExternal) : 0;
|
|
auto roomSearchableBinAttrExternal__ = roomSearchableBinAttrExternal ? _fbb.CreateVector<::flatbuffers::Offset<BinAttr>>(*roomSearchableBinAttrExternal) : 0;
|
|
auto roomBinAttrExternal__ = roomBinAttrExternal ? _fbb.CreateVector<::flatbuffers::Offset<BinAttr>>(*roomBinAttrExternal) : 0;
|
|
return CreateSetRoomDataExternalRequest(
|
|
_fbb,
|
|
roomId,
|
|
roomSearchableIntAttrExternal__,
|
|
roomSearchableBinAttrExternal__,
|
|
roomBinAttrExternal__);
|
|
}
|
|
|
|
struct SetRoomDataInternalRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef SetRoomDataInternalRequestBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_ROOMID = 4,
|
|
VT_FLAGFILTER = 6,
|
|
VT_FLAGATTR = 8,
|
|
VT_ROOMBINATTRINTERNAL = 10,
|
|
VT_PASSWORDCONFIG = 12,
|
|
VT_PASSWORDSLOTMASK = 14,
|
|
VT_OWNERPRIVILEGERANK = 16
|
|
};
|
|
uint64_t roomId() const {
|
|
return GetField<uint64_t>(VT_ROOMID, 0);
|
|
}
|
|
uint32_t flagFilter() const {
|
|
return GetField<uint32_t>(VT_FLAGFILTER, 0);
|
|
}
|
|
uint32_t flagAttr() const {
|
|
return GetField<uint32_t>(VT_FLAGATTR, 0);
|
|
}
|
|
const ::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>> *roomBinAttrInternal() const {
|
|
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>> *>(VT_ROOMBINATTRINTERNAL);
|
|
}
|
|
const ::flatbuffers::Vector<::flatbuffers::Offset<RoomGroupPasswordConfig>> *passwordConfig() const {
|
|
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<RoomGroupPasswordConfig>> *>(VT_PASSWORDCONFIG);
|
|
}
|
|
uint64_t passwordSlotMask() const {
|
|
return GetField<uint64_t>(VT_PASSWORDSLOTMASK, 0);
|
|
}
|
|
const ::flatbuffers::Vector<uint16_t> *ownerPrivilegeRank() const {
|
|
return GetPointer<const ::flatbuffers::Vector<uint16_t> *>(VT_OWNERPRIVILEGERANK);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<uint64_t>(verifier, VT_ROOMID, 8) &&
|
|
VerifyField<uint32_t>(verifier, VT_FLAGFILTER, 4) &&
|
|
VerifyField<uint32_t>(verifier, VT_FLAGATTR, 4) &&
|
|
VerifyOffset(verifier, VT_ROOMBINATTRINTERNAL) &&
|
|
verifier.VerifyVector(roomBinAttrInternal()) &&
|
|
verifier.VerifyVectorOfTables(roomBinAttrInternal()) &&
|
|
VerifyOffset(verifier, VT_PASSWORDCONFIG) &&
|
|
verifier.VerifyVector(passwordConfig()) &&
|
|
verifier.VerifyVectorOfTables(passwordConfig()) &&
|
|
VerifyField<uint64_t>(verifier, VT_PASSWORDSLOTMASK, 8) &&
|
|
VerifyOffset(verifier, VT_OWNERPRIVILEGERANK) &&
|
|
verifier.VerifyVector(ownerPrivilegeRank()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct SetRoomDataInternalRequestBuilder {
|
|
typedef SetRoomDataInternalRequest Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_roomId(uint64_t roomId) {
|
|
fbb_.AddElement<uint64_t>(SetRoomDataInternalRequest::VT_ROOMID, roomId, 0);
|
|
}
|
|
void add_flagFilter(uint32_t flagFilter) {
|
|
fbb_.AddElement<uint32_t>(SetRoomDataInternalRequest::VT_FLAGFILTER, flagFilter, 0);
|
|
}
|
|
void add_flagAttr(uint32_t flagAttr) {
|
|
fbb_.AddElement<uint32_t>(SetRoomDataInternalRequest::VT_FLAGATTR, flagAttr, 0);
|
|
}
|
|
void add_roomBinAttrInternal(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>>> roomBinAttrInternal) {
|
|
fbb_.AddOffset(SetRoomDataInternalRequest::VT_ROOMBINATTRINTERNAL, roomBinAttrInternal);
|
|
}
|
|
void add_passwordConfig(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<RoomGroupPasswordConfig>>> passwordConfig) {
|
|
fbb_.AddOffset(SetRoomDataInternalRequest::VT_PASSWORDCONFIG, passwordConfig);
|
|
}
|
|
void add_passwordSlotMask(uint64_t passwordSlotMask) {
|
|
fbb_.AddElement<uint64_t>(SetRoomDataInternalRequest::VT_PASSWORDSLOTMASK, passwordSlotMask, 0);
|
|
}
|
|
void add_ownerPrivilegeRank(::flatbuffers::Offset<::flatbuffers::Vector<uint16_t>> ownerPrivilegeRank) {
|
|
fbb_.AddOffset(SetRoomDataInternalRequest::VT_OWNERPRIVILEGERANK, ownerPrivilegeRank);
|
|
}
|
|
explicit SetRoomDataInternalRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<SetRoomDataInternalRequest> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<SetRoomDataInternalRequest>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<SetRoomDataInternalRequest> CreateSetRoomDataInternalRequest(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint64_t roomId = 0,
|
|
uint32_t flagFilter = 0,
|
|
uint32_t flagAttr = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>>> roomBinAttrInternal = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<RoomGroupPasswordConfig>>> passwordConfig = 0,
|
|
uint64_t passwordSlotMask = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<uint16_t>> ownerPrivilegeRank = 0) {
|
|
SetRoomDataInternalRequestBuilder builder_(_fbb);
|
|
builder_.add_passwordSlotMask(passwordSlotMask);
|
|
builder_.add_roomId(roomId);
|
|
builder_.add_ownerPrivilegeRank(ownerPrivilegeRank);
|
|
builder_.add_passwordConfig(passwordConfig);
|
|
builder_.add_roomBinAttrInternal(roomBinAttrInternal);
|
|
builder_.add_flagAttr(flagAttr);
|
|
builder_.add_flagFilter(flagFilter);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<SetRoomDataInternalRequest> CreateSetRoomDataInternalRequestDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint64_t roomId = 0,
|
|
uint32_t flagFilter = 0,
|
|
uint32_t flagAttr = 0,
|
|
const std::vector<::flatbuffers::Offset<BinAttr>> *roomBinAttrInternal = nullptr,
|
|
const std::vector<::flatbuffers::Offset<RoomGroupPasswordConfig>> *passwordConfig = nullptr,
|
|
uint64_t passwordSlotMask = 0,
|
|
const std::vector<uint16_t> *ownerPrivilegeRank = nullptr) {
|
|
auto roomBinAttrInternal__ = roomBinAttrInternal ? _fbb.CreateVector<::flatbuffers::Offset<BinAttr>>(*roomBinAttrInternal) : 0;
|
|
auto passwordConfig__ = passwordConfig ? _fbb.CreateVector<::flatbuffers::Offset<RoomGroupPasswordConfig>>(*passwordConfig) : 0;
|
|
auto ownerPrivilegeRank__ = ownerPrivilegeRank ? _fbb.CreateVector<uint16_t>(*ownerPrivilegeRank) : 0;
|
|
return CreateSetRoomDataInternalRequest(
|
|
_fbb,
|
|
roomId,
|
|
flagFilter,
|
|
flagAttr,
|
|
roomBinAttrInternal__,
|
|
passwordConfig__,
|
|
passwordSlotMask,
|
|
ownerPrivilegeRank__);
|
|
}
|
|
|
|
struct GetRoomMemberDataInternalRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef GetRoomMemberDataInternalRequestBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_ROOMID = 4,
|
|
VT_MEMBERID = 6,
|
|
VT_ATTRID = 8
|
|
};
|
|
uint64_t roomId() const {
|
|
return GetField<uint64_t>(VT_ROOMID, 0);
|
|
}
|
|
uint16_t memberId() const {
|
|
return GetField<uint16_t>(VT_MEMBERID, 0);
|
|
}
|
|
const ::flatbuffers::Vector<uint16_t> *attrId() const {
|
|
return GetPointer<const ::flatbuffers::Vector<uint16_t> *>(VT_ATTRID);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<uint64_t>(verifier, VT_ROOMID, 8) &&
|
|
VerifyField<uint16_t>(verifier, VT_MEMBERID, 2) &&
|
|
VerifyOffset(verifier, VT_ATTRID) &&
|
|
verifier.VerifyVector(attrId()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct GetRoomMemberDataInternalRequestBuilder {
|
|
typedef GetRoomMemberDataInternalRequest Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_roomId(uint64_t roomId) {
|
|
fbb_.AddElement<uint64_t>(GetRoomMemberDataInternalRequest::VT_ROOMID, roomId, 0);
|
|
}
|
|
void add_memberId(uint16_t memberId) {
|
|
fbb_.AddElement<uint16_t>(GetRoomMemberDataInternalRequest::VT_MEMBERID, memberId, 0);
|
|
}
|
|
void add_attrId(::flatbuffers::Offset<::flatbuffers::Vector<uint16_t>> attrId) {
|
|
fbb_.AddOffset(GetRoomMemberDataInternalRequest::VT_ATTRID, attrId);
|
|
}
|
|
explicit GetRoomMemberDataInternalRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<GetRoomMemberDataInternalRequest> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<GetRoomMemberDataInternalRequest>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<GetRoomMemberDataInternalRequest> CreateGetRoomMemberDataInternalRequest(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint64_t roomId = 0,
|
|
uint16_t memberId = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<uint16_t>> attrId = 0) {
|
|
GetRoomMemberDataInternalRequestBuilder builder_(_fbb);
|
|
builder_.add_roomId(roomId);
|
|
builder_.add_attrId(attrId);
|
|
builder_.add_memberId(memberId);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<GetRoomMemberDataInternalRequest> CreateGetRoomMemberDataInternalRequestDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint64_t roomId = 0,
|
|
uint16_t memberId = 0,
|
|
const std::vector<uint16_t> *attrId = nullptr) {
|
|
auto attrId__ = attrId ? _fbb.CreateVector<uint16_t>(*attrId) : 0;
|
|
return CreateGetRoomMemberDataInternalRequest(
|
|
_fbb,
|
|
roomId,
|
|
memberId,
|
|
attrId__);
|
|
}
|
|
|
|
struct SetRoomMemberDataInternalRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef SetRoomMemberDataInternalRequestBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_ROOMID = 4,
|
|
VT_MEMBERID = 6,
|
|
VT_TEAMID = 8,
|
|
VT_ROOMMEMBERBINATTRINTERNAL = 10
|
|
};
|
|
uint64_t roomId() const {
|
|
return GetField<uint64_t>(VT_ROOMID, 0);
|
|
}
|
|
uint16_t memberId() const {
|
|
return GetField<uint16_t>(VT_MEMBERID, 0);
|
|
}
|
|
uint8_t teamId() const {
|
|
return GetField<uint8_t>(VT_TEAMID, 0);
|
|
}
|
|
const ::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>> *roomMemberBinAttrInternal() const {
|
|
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>> *>(VT_ROOMMEMBERBINATTRINTERNAL);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<uint64_t>(verifier, VT_ROOMID, 8) &&
|
|
VerifyField<uint16_t>(verifier, VT_MEMBERID, 2) &&
|
|
VerifyField<uint8_t>(verifier, VT_TEAMID, 1) &&
|
|
VerifyOffset(verifier, VT_ROOMMEMBERBINATTRINTERNAL) &&
|
|
verifier.VerifyVector(roomMemberBinAttrInternal()) &&
|
|
verifier.VerifyVectorOfTables(roomMemberBinAttrInternal()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct SetRoomMemberDataInternalRequestBuilder {
|
|
typedef SetRoomMemberDataInternalRequest Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_roomId(uint64_t roomId) {
|
|
fbb_.AddElement<uint64_t>(SetRoomMemberDataInternalRequest::VT_ROOMID, roomId, 0);
|
|
}
|
|
void add_memberId(uint16_t memberId) {
|
|
fbb_.AddElement<uint16_t>(SetRoomMemberDataInternalRequest::VT_MEMBERID, memberId, 0);
|
|
}
|
|
void add_teamId(uint8_t teamId) {
|
|
fbb_.AddElement<uint8_t>(SetRoomMemberDataInternalRequest::VT_TEAMID, teamId, 0);
|
|
}
|
|
void add_roomMemberBinAttrInternal(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>>> roomMemberBinAttrInternal) {
|
|
fbb_.AddOffset(SetRoomMemberDataInternalRequest::VT_ROOMMEMBERBINATTRINTERNAL, roomMemberBinAttrInternal);
|
|
}
|
|
explicit SetRoomMemberDataInternalRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<SetRoomMemberDataInternalRequest> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<SetRoomMemberDataInternalRequest>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<SetRoomMemberDataInternalRequest> CreateSetRoomMemberDataInternalRequest(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint64_t roomId = 0,
|
|
uint16_t memberId = 0,
|
|
uint8_t teamId = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>>> roomMemberBinAttrInternal = 0) {
|
|
SetRoomMemberDataInternalRequestBuilder builder_(_fbb);
|
|
builder_.add_roomId(roomId);
|
|
builder_.add_roomMemberBinAttrInternal(roomMemberBinAttrInternal);
|
|
builder_.add_memberId(memberId);
|
|
builder_.add_teamId(teamId);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<SetRoomMemberDataInternalRequest> CreateSetRoomMemberDataInternalRequestDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint64_t roomId = 0,
|
|
uint16_t memberId = 0,
|
|
uint8_t teamId = 0,
|
|
const std::vector<::flatbuffers::Offset<BinAttr>> *roomMemberBinAttrInternal = nullptr) {
|
|
auto roomMemberBinAttrInternal__ = roomMemberBinAttrInternal ? _fbb.CreateVector<::flatbuffers::Offset<BinAttr>>(*roomMemberBinAttrInternal) : 0;
|
|
return CreateSetRoomMemberDataInternalRequest(
|
|
_fbb,
|
|
roomId,
|
|
memberId,
|
|
teamId,
|
|
roomMemberBinAttrInternal__);
|
|
}
|
|
|
|
struct SetUserInfo FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef SetUserInfoBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_SERVERID = 4,
|
|
VT_USERBINATTR = 6
|
|
};
|
|
uint16_t serverId() const {
|
|
return GetField<uint16_t>(VT_SERVERID, 0);
|
|
}
|
|
const ::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>> *userBinAttr() const {
|
|
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>> *>(VT_USERBINATTR);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<uint16_t>(verifier, VT_SERVERID, 2) &&
|
|
VerifyOffset(verifier, VT_USERBINATTR) &&
|
|
verifier.VerifyVector(userBinAttr()) &&
|
|
verifier.VerifyVectorOfTables(userBinAttr()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct SetUserInfoBuilder {
|
|
typedef SetUserInfo Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_serverId(uint16_t serverId) {
|
|
fbb_.AddElement<uint16_t>(SetUserInfo::VT_SERVERID, serverId, 0);
|
|
}
|
|
void add_userBinAttr(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>>> userBinAttr) {
|
|
fbb_.AddOffset(SetUserInfo::VT_USERBINATTR, userBinAttr);
|
|
}
|
|
explicit SetUserInfoBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<SetUserInfo> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<SetUserInfo>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<SetUserInfo> CreateSetUserInfo(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint16_t serverId = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<BinAttr>>> userBinAttr = 0) {
|
|
SetUserInfoBuilder builder_(_fbb);
|
|
builder_.add_userBinAttr(userBinAttr);
|
|
builder_.add_serverId(serverId);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<SetUserInfo> CreateSetUserInfoDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint16_t serverId = 0,
|
|
const std::vector<::flatbuffers::Offset<BinAttr>> *userBinAttr = nullptr) {
|
|
auto userBinAttr__ = userBinAttr ? _fbb.CreateVector<::flatbuffers::Offset<BinAttr>>(*userBinAttr) : 0;
|
|
return CreateSetUserInfo(
|
|
_fbb,
|
|
serverId,
|
|
userBinAttr__);
|
|
}
|
|
|
|
struct GetRoomDataInternalRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef GetRoomDataInternalRequestBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_ROOMID = 4,
|
|
VT_ATTRID = 6
|
|
};
|
|
uint64_t roomId() const {
|
|
return GetField<uint64_t>(VT_ROOMID, 0);
|
|
}
|
|
const ::flatbuffers::Vector<uint16_t> *attrId() const {
|
|
return GetPointer<const ::flatbuffers::Vector<uint16_t> *>(VT_ATTRID);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<uint64_t>(verifier, VT_ROOMID, 8) &&
|
|
VerifyOffset(verifier, VT_ATTRID) &&
|
|
verifier.VerifyVector(attrId()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct GetRoomDataInternalRequestBuilder {
|
|
typedef GetRoomDataInternalRequest Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_roomId(uint64_t roomId) {
|
|
fbb_.AddElement<uint64_t>(GetRoomDataInternalRequest::VT_ROOMID, roomId, 0);
|
|
}
|
|
void add_attrId(::flatbuffers::Offset<::flatbuffers::Vector<uint16_t>> attrId) {
|
|
fbb_.AddOffset(GetRoomDataInternalRequest::VT_ATTRID, attrId);
|
|
}
|
|
explicit GetRoomDataInternalRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<GetRoomDataInternalRequest> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<GetRoomDataInternalRequest>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<GetRoomDataInternalRequest> CreateGetRoomDataInternalRequest(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint64_t roomId = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<uint16_t>> attrId = 0) {
|
|
GetRoomDataInternalRequestBuilder builder_(_fbb);
|
|
builder_.add_roomId(roomId);
|
|
builder_.add_attrId(attrId);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<GetRoomDataInternalRequest> CreateGetRoomDataInternalRequestDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint64_t roomId = 0,
|
|
const std::vector<uint16_t> *attrId = nullptr) {
|
|
auto attrId__ = attrId ? _fbb.CreateVector<uint16_t>(*attrId) : 0;
|
|
return CreateGetRoomDataInternalRequest(
|
|
_fbb,
|
|
roomId,
|
|
attrId__);
|
|
}
|
|
|
|
struct RoomMemberUpdateInfo FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef RoomMemberUpdateInfoBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_ROOMMEMBERDATAINTERNAL = 4,
|
|
VT_EVENTCAUSE = 6,
|
|
VT_OPTDATA = 8
|
|
};
|
|
const RoomMemberDataInternal *roomMemberDataInternal() const {
|
|
return GetPointer<const RoomMemberDataInternal *>(VT_ROOMMEMBERDATAINTERNAL);
|
|
}
|
|
uint8_t eventCause() const {
|
|
return GetField<uint8_t>(VT_EVENTCAUSE, 0);
|
|
}
|
|
const PresenceOptionData *optData() const {
|
|
return GetPointer<const PresenceOptionData *>(VT_OPTDATA);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_ROOMMEMBERDATAINTERNAL) &&
|
|
verifier.VerifyTable(roomMemberDataInternal()) &&
|
|
VerifyField<uint8_t>(verifier, VT_EVENTCAUSE, 1) &&
|
|
VerifyOffset(verifier, VT_OPTDATA) &&
|
|
verifier.VerifyTable(optData()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct RoomMemberUpdateInfoBuilder {
|
|
typedef RoomMemberUpdateInfo Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_roomMemberDataInternal(::flatbuffers::Offset<RoomMemberDataInternal> roomMemberDataInternal) {
|
|
fbb_.AddOffset(RoomMemberUpdateInfo::VT_ROOMMEMBERDATAINTERNAL, roomMemberDataInternal);
|
|
}
|
|
void add_eventCause(uint8_t eventCause) {
|
|
fbb_.AddElement<uint8_t>(RoomMemberUpdateInfo::VT_EVENTCAUSE, eventCause, 0);
|
|
}
|
|
void add_optData(::flatbuffers::Offset<PresenceOptionData> optData) {
|
|
fbb_.AddOffset(RoomMemberUpdateInfo::VT_OPTDATA, optData);
|
|
}
|
|
explicit RoomMemberUpdateInfoBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<RoomMemberUpdateInfo> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<RoomMemberUpdateInfo>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<RoomMemberUpdateInfo> CreateRoomMemberUpdateInfo(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<RoomMemberDataInternal> roomMemberDataInternal = 0,
|
|
uint8_t eventCause = 0,
|
|
::flatbuffers::Offset<PresenceOptionData> optData = 0) {
|
|
RoomMemberUpdateInfoBuilder builder_(_fbb);
|
|
builder_.add_optData(optData);
|
|
builder_.add_roomMemberDataInternal(roomMemberDataInternal);
|
|
builder_.add_eventCause(eventCause);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
struct NotificationUserJoinedRoom FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef NotificationUserJoinedRoomBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_ROOM_ID = 4,
|
|
VT_UPDATE_INFO = 6,
|
|
VT_SIGNALING = 8
|
|
};
|
|
uint64_t room_id() const {
|
|
return GetField<uint64_t>(VT_ROOM_ID, 0);
|
|
}
|
|
const RoomMemberUpdateInfo *update_info() const {
|
|
return GetPointer<const RoomMemberUpdateInfo *>(VT_UPDATE_INFO);
|
|
}
|
|
const SignalingAddr *signaling() const {
|
|
return GetPointer<const SignalingAddr *>(VT_SIGNALING);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<uint64_t>(verifier, VT_ROOM_ID, 8) &&
|
|
VerifyOffset(verifier, VT_UPDATE_INFO) &&
|
|
verifier.VerifyTable(update_info()) &&
|
|
VerifyOffset(verifier, VT_SIGNALING) &&
|
|
verifier.VerifyTable(signaling()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct NotificationUserJoinedRoomBuilder {
|
|
typedef NotificationUserJoinedRoom Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_room_id(uint64_t room_id) {
|
|
fbb_.AddElement<uint64_t>(NotificationUserJoinedRoom::VT_ROOM_ID, room_id, 0);
|
|
}
|
|
void add_update_info(::flatbuffers::Offset<RoomMemberUpdateInfo> update_info) {
|
|
fbb_.AddOffset(NotificationUserJoinedRoom::VT_UPDATE_INFO, update_info);
|
|
}
|
|
void add_signaling(::flatbuffers::Offset<SignalingAddr> signaling) {
|
|
fbb_.AddOffset(NotificationUserJoinedRoom::VT_SIGNALING, signaling);
|
|
}
|
|
explicit NotificationUserJoinedRoomBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<NotificationUserJoinedRoom> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<NotificationUserJoinedRoom>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<NotificationUserJoinedRoom> CreateNotificationUserJoinedRoom(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint64_t room_id = 0,
|
|
::flatbuffers::Offset<RoomMemberUpdateInfo> update_info = 0,
|
|
::flatbuffers::Offset<SignalingAddr> signaling = 0) {
|
|
NotificationUserJoinedRoomBuilder builder_(_fbb);
|
|
builder_.add_room_id(room_id);
|
|
builder_.add_signaling(signaling);
|
|
builder_.add_update_info(update_info);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
struct RoomUpdateInfo FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef RoomUpdateInfoBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_EVENTCAUSE = 4,
|
|
VT_ERRORCODE = 6,
|
|
VT_OPTDATA = 8
|
|
};
|
|
uint8_t eventCause() const {
|
|
return GetField<uint8_t>(VT_EVENTCAUSE, 0);
|
|
}
|
|
int32_t errorCode() const {
|
|
return GetField<int32_t>(VT_ERRORCODE, 0);
|
|
}
|
|
const PresenceOptionData *optData() const {
|
|
return GetPointer<const PresenceOptionData *>(VT_OPTDATA);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<uint8_t>(verifier, VT_EVENTCAUSE, 1) &&
|
|
VerifyField<int32_t>(verifier, VT_ERRORCODE, 4) &&
|
|
VerifyOffset(verifier, VT_OPTDATA) &&
|
|
verifier.VerifyTable(optData()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct RoomUpdateInfoBuilder {
|
|
typedef RoomUpdateInfo Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_eventCause(uint8_t eventCause) {
|
|
fbb_.AddElement<uint8_t>(RoomUpdateInfo::VT_EVENTCAUSE, eventCause, 0);
|
|
}
|
|
void add_errorCode(int32_t errorCode) {
|
|
fbb_.AddElement<int32_t>(RoomUpdateInfo::VT_ERRORCODE, errorCode, 0);
|
|
}
|
|
void add_optData(::flatbuffers::Offset<PresenceOptionData> optData) {
|
|
fbb_.AddOffset(RoomUpdateInfo::VT_OPTDATA, optData);
|
|
}
|
|
explicit RoomUpdateInfoBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<RoomUpdateInfo> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<RoomUpdateInfo>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<RoomUpdateInfo> CreateRoomUpdateInfo(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint8_t eventCause = 0,
|
|
int32_t errorCode = 0,
|
|
::flatbuffers::Offset<PresenceOptionData> optData = 0) {
|
|
RoomUpdateInfoBuilder builder_(_fbb);
|
|
builder_.add_optData(optData);
|
|
builder_.add_errorCode(errorCode);
|
|
builder_.add_eventCause(eventCause);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
struct RoomDataInternalUpdateInfo FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef RoomDataInternalUpdateInfoBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_NEWROOMDATAINTERNAL = 4,
|
|
VT_PREVFLAGATTR = 6,
|
|
VT_PREVROOMPASSWORDSLOTMASK = 8,
|
|
VT_NEWROOMGROUP = 10,
|
|
VT_NEWROOMBINATTRINTERNAL = 12
|
|
};
|
|
const RoomDataInternal *newRoomDataInternal() const {
|
|
return GetPointer<const RoomDataInternal *>(VT_NEWROOMDATAINTERNAL);
|
|
}
|
|
uint32_t prevFlagAttr() const {
|
|
return GetField<uint32_t>(VT_PREVFLAGATTR, 0);
|
|
}
|
|
uint64_t prevRoomPasswordSlotMask() const {
|
|
return GetField<uint64_t>(VT_PREVROOMPASSWORDSLOTMASK, 0);
|
|
}
|
|
const ::flatbuffers::Vector<uint8_t> *newRoomGroup() const {
|
|
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_NEWROOMGROUP);
|
|
}
|
|
const ::flatbuffers::Vector<uint16_t> *newRoomBinAttrInternal() const {
|
|
return GetPointer<const ::flatbuffers::Vector<uint16_t> *>(VT_NEWROOMBINATTRINTERNAL);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_NEWROOMDATAINTERNAL) &&
|
|
verifier.VerifyTable(newRoomDataInternal()) &&
|
|
VerifyField<uint32_t>(verifier, VT_PREVFLAGATTR, 4) &&
|
|
VerifyField<uint64_t>(verifier, VT_PREVROOMPASSWORDSLOTMASK, 8) &&
|
|
VerifyOffset(verifier, VT_NEWROOMGROUP) &&
|
|
verifier.VerifyVector(newRoomGroup()) &&
|
|
VerifyOffset(verifier, VT_NEWROOMBINATTRINTERNAL) &&
|
|
verifier.VerifyVector(newRoomBinAttrInternal()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct RoomDataInternalUpdateInfoBuilder {
|
|
typedef RoomDataInternalUpdateInfo Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_newRoomDataInternal(::flatbuffers::Offset<RoomDataInternal> newRoomDataInternal) {
|
|
fbb_.AddOffset(RoomDataInternalUpdateInfo::VT_NEWROOMDATAINTERNAL, newRoomDataInternal);
|
|
}
|
|
void add_prevFlagAttr(uint32_t prevFlagAttr) {
|
|
fbb_.AddElement<uint32_t>(RoomDataInternalUpdateInfo::VT_PREVFLAGATTR, prevFlagAttr, 0);
|
|
}
|
|
void add_prevRoomPasswordSlotMask(uint64_t prevRoomPasswordSlotMask) {
|
|
fbb_.AddElement<uint64_t>(RoomDataInternalUpdateInfo::VT_PREVROOMPASSWORDSLOTMASK, prevRoomPasswordSlotMask, 0);
|
|
}
|
|
void add_newRoomGroup(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> newRoomGroup) {
|
|
fbb_.AddOffset(RoomDataInternalUpdateInfo::VT_NEWROOMGROUP, newRoomGroup);
|
|
}
|
|
void add_newRoomBinAttrInternal(::flatbuffers::Offset<::flatbuffers::Vector<uint16_t>> newRoomBinAttrInternal) {
|
|
fbb_.AddOffset(RoomDataInternalUpdateInfo::VT_NEWROOMBINATTRINTERNAL, newRoomBinAttrInternal);
|
|
}
|
|
explicit RoomDataInternalUpdateInfoBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<RoomDataInternalUpdateInfo> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<RoomDataInternalUpdateInfo>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<RoomDataInternalUpdateInfo> CreateRoomDataInternalUpdateInfo(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<RoomDataInternal> newRoomDataInternal = 0,
|
|
uint32_t prevFlagAttr = 0,
|
|
uint64_t prevRoomPasswordSlotMask = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> newRoomGroup = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<uint16_t>> newRoomBinAttrInternal = 0) {
|
|
RoomDataInternalUpdateInfoBuilder builder_(_fbb);
|
|
builder_.add_prevRoomPasswordSlotMask(prevRoomPasswordSlotMask);
|
|
builder_.add_newRoomBinAttrInternal(newRoomBinAttrInternal);
|
|
builder_.add_newRoomGroup(newRoomGroup);
|
|
builder_.add_prevFlagAttr(prevFlagAttr);
|
|
builder_.add_newRoomDataInternal(newRoomDataInternal);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<RoomDataInternalUpdateInfo> CreateRoomDataInternalUpdateInfoDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<RoomDataInternal> newRoomDataInternal = 0,
|
|
uint32_t prevFlagAttr = 0,
|
|
uint64_t prevRoomPasswordSlotMask = 0,
|
|
const std::vector<uint8_t> *newRoomGroup = nullptr,
|
|
const std::vector<uint16_t> *newRoomBinAttrInternal = nullptr) {
|
|
auto newRoomGroup__ = newRoomGroup ? _fbb.CreateVector<uint8_t>(*newRoomGroup) : 0;
|
|
auto newRoomBinAttrInternal__ = newRoomBinAttrInternal ? _fbb.CreateVector<uint16_t>(*newRoomBinAttrInternal) : 0;
|
|
return CreateRoomDataInternalUpdateInfo(
|
|
_fbb,
|
|
newRoomDataInternal,
|
|
prevFlagAttr,
|
|
prevRoomPasswordSlotMask,
|
|
newRoomGroup__,
|
|
newRoomBinAttrInternal__);
|
|
}
|
|
|
|
struct RoomMemberDataInternalUpdateInfo FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef RoomMemberDataInternalUpdateInfoBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_NEWROOMMEMBERDATAINTERNAL = 4,
|
|
VT_PREVFLAGATTR = 6,
|
|
VT_PREVTEAMID = 8,
|
|
VT_NEWROOMMEMBERBINATTRINTERNAL = 10
|
|
};
|
|
const RoomMemberDataInternal *newRoomMemberDataInternal() const {
|
|
return GetPointer<const RoomMemberDataInternal *>(VT_NEWROOMMEMBERDATAINTERNAL);
|
|
}
|
|
uint32_t prevFlagAttr() const {
|
|
return GetField<uint32_t>(VT_PREVFLAGATTR, 0);
|
|
}
|
|
uint8_t prevTeamId() const {
|
|
return GetField<uint8_t>(VT_PREVTEAMID, 0);
|
|
}
|
|
const ::flatbuffers::Vector<uint16_t> *newRoomMemberBinAttrInternal() const {
|
|
return GetPointer<const ::flatbuffers::Vector<uint16_t> *>(VT_NEWROOMMEMBERBINATTRINTERNAL);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_NEWROOMMEMBERDATAINTERNAL) &&
|
|
verifier.VerifyTable(newRoomMemberDataInternal()) &&
|
|
VerifyField<uint32_t>(verifier, VT_PREVFLAGATTR, 4) &&
|
|
VerifyField<uint8_t>(verifier, VT_PREVTEAMID, 1) &&
|
|
VerifyOffset(verifier, VT_NEWROOMMEMBERBINATTRINTERNAL) &&
|
|
verifier.VerifyVector(newRoomMemberBinAttrInternal()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct RoomMemberDataInternalUpdateInfoBuilder {
|
|
typedef RoomMemberDataInternalUpdateInfo Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_newRoomMemberDataInternal(::flatbuffers::Offset<RoomMemberDataInternal> newRoomMemberDataInternal) {
|
|
fbb_.AddOffset(RoomMemberDataInternalUpdateInfo::VT_NEWROOMMEMBERDATAINTERNAL, newRoomMemberDataInternal);
|
|
}
|
|
void add_prevFlagAttr(uint32_t prevFlagAttr) {
|
|
fbb_.AddElement<uint32_t>(RoomMemberDataInternalUpdateInfo::VT_PREVFLAGATTR, prevFlagAttr, 0);
|
|
}
|
|
void add_prevTeamId(uint8_t prevTeamId) {
|
|
fbb_.AddElement<uint8_t>(RoomMemberDataInternalUpdateInfo::VT_PREVTEAMID, prevTeamId, 0);
|
|
}
|
|
void add_newRoomMemberBinAttrInternal(::flatbuffers::Offset<::flatbuffers::Vector<uint16_t>> newRoomMemberBinAttrInternal) {
|
|
fbb_.AddOffset(RoomMemberDataInternalUpdateInfo::VT_NEWROOMMEMBERBINATTRINTERNAL, newRoomMemberBinAttrInternal);
|
|
}
|
|
explicit RoomMemberDataInternalUpdateInfoBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<RoomMemberDataInternalUpdateInfo> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<RoomMemberDataInternalUpdateInfo>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<RoomMemberDataInternalUpdateInfo> CreateRoomMemberDataInternalUpdateInfo(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<RoomMemberDataInternal> newRoomMemberDataInternal = 0,
|
|
uint32_t prevFlagAttr = 0,
|
|
uint8_t prevTeamId = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<uint16_t>> newRoomMemberBinAttrInternal = 0) {
|
|
RoomMemberDataInternalUpdateInfoBuilder builder_(_fbb);
|
|
builder_.add_newRoomMemberBinAttrInternal(newRoomMemberBinAttrInternal);
|
|
builder_.add_prevFlagAttr(prevFlagAttr);
|
|
builder_.add_newRoomMemberDataInternal(newRoomMemberDataInternal);
|
|
builder_.add_prevTeamId(prevTeamId);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<RoomMemberDataInternalUpdateInfo> CreateRoomMemberDataInternalUpdateInfoDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<RoomMemberDataInternal> newRoomMemberDataInternal = 0,
|
|
uint32_t prevFlagAttr = 0,
|
|
uint8_t prevTeamId = 0,
|
|
const std::vector<uint16_t> *newRoomMemberBinAttrInternal = nullptr) {
|
|
auto newRoomMemberBinAttrInternal__ = newRoomMemberBinAttrInternal ? _fbb.CreateVector<uint16_t>(*newRoomMemberBinAttrInternal) : 0;
|
|
return CreateRoomMemberDataInternalUpdateInfo(
|
|
_fbb,
|
|
newRoomMemberDataInternal,
|
|
prevFlagAttr,
|
|
prevTeamId,
|
|
newRoomMemberBinAttrInternal__);
|
|
}
|
|
|
|
struct GetPingInfoResponse FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef GetPingInfoResponseBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_SERVERID = 4,
|
|
VT_WORLDID = 6,
|
|
VT_ROOMID = 8,
|
|
VT_RTT = 10
|
|
};
|
|
uint16_t serverId() const {
|
|
return GetField<uint16_t>(VT_SERVERID, 0);
|
|
}
|
|
uint32_t worldId() const {
|
|
return GetField<uint32_t>(VT_WORLDID, 0);
|
|
}
|
|
uint64_t roomId() const {
|
|
return GetField<uint64_t>(VT_ROOMID, 0);
|
|
}
|
|
uint32_t rtt() const {
|
|
return GetField<uint32_t>(VT_RTT, 0);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<uint16_t>(verifier, VT_SERVERID, 2) &&
|
|
VerifyField<uint32_t>(verifier, VT_WORLDID, 4) &&
|
|
VerifyField<uint64_t>(verifier, VT_ROOMID, 8) &&
|
|
VerifyField<uint32_t>(verifier, VT_RTT, 4) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct GetPingInfoResponseBuilder {
|
|
typedef GetPingInfoResponse Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_serverId(uint16_t serverId) {
|
|
fbb_.AddElement<uint16_t>(GetPingInfoResponse::VT_SERVERID, serverId, 0);
|
|
}
|
|
void add_worldId(uint32_t worldId) {
|
|
fbb_.AddElement<uint32_t>(GetPingInfoResponse::VT_WORLDID, worldId, 0);
|
|
}
|
|
void add_roomId(uint64_t roomId) {
|
|
fbb_.AddElement<uint64_t>(GetPingInfoResponse::VT_ROOMID, roomId, 0);
|
|
}
|
|
void add_rtt(uint32_t rtt) {
|
|
fbb_.AddElement<uint32_t>(GetPingInfoResponse::VT_RTT, rtt, 0);
|
|
}
|
|
explicit GetPingInfoResponseBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<GetPingInfoResponse> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<GetPingInfoResponse>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<GetPingInfoResponse> CreateGetPingInfoResponse(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint16_t serverId = 0,
|
|
uint32_t worldId = 0,
|
|
uint64_t roomId = 0,
|
|
uint32_t rtt = 0) {
|
|
GetPingInfoResponseBuilder builder_(_fbb);
|
|
builder_.add_roomId(roomId);
|
|
builder_.add_rtt(rtt);
|
|
builder_.add_worldId(worldId);
|
|
builder_.add_serverId(serverId);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
struct SendRoomMessageRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef SendRoomMessageRequestBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_ROOMID = 4,
|
|
VT_CASTTYPE = 6,
|
|
VT_DST = 8,
|
|
VT_MSG = 10,
|
|
VT_OPTION = 12
|
|
};
|
|
uint64_t roomId() const {
|
|
return GetField<uint64_t>(VT_ROOMID, 0);
|
|
}
|
|
uint8_t castType() const {
|
|
return GetField<uint8_t>(VT_CASTTYPE, 0);
|
|
}
|
|
const ::flatbuffers::Vector<uint16_t> *dst() const {
|
|
return GetPointer<const ::flatbuffers::Vector<uint16_t> *>(VT_DST);
|
|
}
|
|
const ::flatbuffers::Vector<uint8_t> *msg() const {
|
|
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_MSG);
|
|
}
|
|
uint8_t option() const {
|
|
return GetField<uint8_t>(VT_OPTION, 0);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<uint64_t>(verifier, VT_ROOMID, 8) &&
|
|
VerifyField<uint8_t>(verifier, VT_CASTTYPE, 1) &&
|
|
VerifyOffset(verifier, VT_DST) &&
|
|
verifier.VerifyVector(dst()) &&
|
|
VerifyOffset(verifier, VT_MSG) &&
|
|
verifier.VerifyVector(msg()) &&
|
|
VerifyField<uint8_t>(verifier, VT_OPTION, 1) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct SendRoomMessageRequestBuilder {
|
|
typedef SendRoomMessageRequest Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_roomId(uint64_t roomId) {
|
|
fbb_.AddElement<uint64_t>(SendRoomMessageRequest::VT_ROOMID, roomId, 0);
|
|
}
|
|
void add_castType(uint8_t castType) {
|
|
fbb_.AddElement<uint8_t>(SendRoomMessageRequest::VT_CASTTYPE, castType, 0);
|
|
}
|
|
void add_dst(::flatbuffers::Offset<::flatbuffers::Vector<uint16_t>> dst) {
|
|
fbb_.AddOffset(SendRoomMessageRequest::VT_DST, dst);
|
|
}
|
|
void add_msg(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> msg) {
|
|
fbb_.AddOffset(SendRoomMessageRequest::VT_MSG, msg);
|
|
}
|
|
void add_option(uint8_t option) {
|
|
fbb_.AddElement<uint8_t>(SendRoomMessageRequest::VT_OPTION, option, 0);
|
|
}
|
|
explicit SendRoomMessageRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<SendRoomMessageRequest> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<SendRoomMessageRequest>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<SendRoomMessageRequest> CreateSendRoomMessageRequest(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint64_t roomId = 0,
|
|
uint8_t castType = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<uint16_t>> dst = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> msg = 0,
|
|
uint8_t option = 0) {
|
|
SendRoomMessageRequestBuilder builder_(_fbb);
|
|
builder_.add_roomId(roomId);
|
|
builder_.add_msg(msg);
|
|
builder_.add_dst(dst);
|
|
builder_.add_option(option);
|
|
builder_.add_castType(castType);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<SendRoomMessageRequest> CreateSendRoomMessageRequestDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint64_t roomId = 0,
|
|
uint8_t castType = 0,
|
|
const std::vector<uint16_t> *dst = nullptr,
|
|
const std::vector<uint8_t> *msg = nullptr,
|
|
uint8_t option = 0) {
|
|
auto dst__ = dst ? _fbb.CreateVector<uint16_t>(*dst) : 0;
|
|
auto msg__ = msg ? _fbb.CreateVector<uint8_t>(*msg) : 0;
|
|
return CreateSendRoomMessageRequest(
|
|
_fbb,
|
|
roomId,
|
|
castType,
|
|
dst__,
|
|
msg__,
|
|
option);
|
|
}
|
|
|
|
struct RoomMessageInfo FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef RoomMessageInfoBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_FILTERED = 4,
|
|
VT_CASTTYPE = 6,
|
|
VT_DST = 8,
|
|
VT_SRCMEMBER = 10,
|
|
VT_MSG = 12
|
|
};
|
|
bool filtered() const {
|
|
return GetField<uint8_t>(VT_FILTERED, 0) != 0;
|
|
}
|
|
uint8_t castType() const {
|
|
return GetField<uint8_t>(VT_CASTTYPE, 0);
|
|
}
|
|
const ::flatbuffers::Vector<uint16_t> *dst() const {
|
|
return GetPointer<const ::flatbuffers::Vector<uint16_t> *>(VT_DST);
|
|
}
|
|
const UserInfo *srcMember() const {
|
|
return GetPointer<const UserInfo *>(VT_SRCMEMBER);
|
|
}
|
|
const ::flatbuffers::Vector<uint8_t> *msg() const {
|
|
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_MSG);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<uint8_t>(verifier, VT_FILTERED, 1) &&
|
|
VerifyField<uint8_t>(verifier, VT_CASTTYPE, 1) &&
|
|
VerifyOffset(verifier, VT_DST) &&
|
|
verifier.VerifyVector(dst()) &&
|
|
VerifyOffset(verifier, VT_SRCMEMBER) &&
|
|
verifier.VerifyTable(srcMember()) &&
|
|
VerifyOffset(verifier, VT_MSG) &&
|
|
verifier.VerifyVector(msg()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct RoomMessageInfoBuilder {
|
|
typedef RoomMessageInfo Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_filtered(bool filtered) {
|
|
fbb_.AddElement<uint8_t>(RoomMessageInfo::VT_FILTERED, static_cast<uint8_t>(filtered), 0);
|
|
}
|
|
void add_castType(uint8_t castType) {
|
|
fbb_.AddElement<uint8_t>(RoomMessageInfo::VT_CASTTYPE, castType, 0);
|
|
}
|
|
void add_dst(::flatbuffers::Offset<::flatbuffers::Vector<uint16_t>> dst) {
|
|
fbb_.AddOffset(RoomMessageInfo::VT_DST, dst);
|
|
}
|
|
void add_srcMember(::flatbuffers::Offset<UserInfo> srcMember) {
|
|
fbb_.AddOffset(RoomMessageInfo::VT_SRCMEMBER, srcMember);
|
|
}
|
|
void add_msg(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> msg) {
|
|
fbb_.AddOffset(RoomMessageInfo::VT_MSG, msg);
|
|
}
|
|
explicit RoomMessageInfoBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<RoomMessageInfo> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<RoomMessageInfo>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<RoomMessageInfo> CreateRoomMessageInfo(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
bool filtered = false,
|
|
uint8_t castType = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<uint16_t>> dst = 0,
|
|
::flatbuffers::Offset<UserInfo> srcMember = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> msg = 0) {
|
|
RoomMessageInfoBuilder builder_(_fbb);
|
|
builder_.add_msg(msg);
|
|
builder_.add_srcMember(srcMember);
|
|
builder_.add_dst(dst);
|
|
builder_.add_castType(castType);
|
|
builder_.add_filtered(filtered);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<RoomMessageInfo> CreateRoomMessageInfoDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
bool filtered = false,
|
|
uint8_t castType = 0,
|
|
const std::vector<uint16_t> *dst = nullptr,
|
|
::flatbuffers::Offset<UserInfo> srcMember = 0,
|
|
const std::vector<uint8_t> *msg = nullptr) {
|
|
auto dst__ = dst ? _fbb.CreateVector<uint16_t>(*dst) : 0;
|
|
auto msg__ = msg ? _fbb.CreateVector<uint8_t>(*msg) : 0;
|
|
return CreateRoomMessageInfo(
|
|
_fbb,
|
|
filtered,
|
|
castType,
|
|
dst__,
|
|
srcMember,
|
|
msg__);
|
|
}
|
|
|
|
struct MessageDetails FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef MessageDetailsBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_COMMUNICATIONID = 4,
|
|
VT_MSGID = 6,
|
|
VT_MAINTYPE = 8,
|
|
VT_SUBTYPE = 10,
|
|
VT_MSGFEATURES = 12,
|
|
VT_SUBJECT = 14,
|
|
VT_BODY = 16,
|
|
VT_DATA = 18
|
|
};
|
|
const ::flatbuffers::String *communicationId() const {
|
|
return GetPointer<const ::flatbuffers::String *>(VT_COMMUNICATIONID);
|
|
}
|
|
uint64_t msgId() const {
|
|
return GetField<uint64_t>(VT_MSGID, 0);
|
|
}
|
|
uint16_t mainType() const {
|
|
return GetField<uint16_t>(VT_MAINTYPE, 0);
|
|
}
|
|
uint16_t subType() const {
|
|
return GetField<uint16_t>(VT_SUBTYPE, 0);
|
|
}
|
|
uint32_t msgFeatures() const {
|
|
return GetField<uint32_t>(VT_MSGFEATURES, 0);
|
|
}
|
|
const ::flatbuffers::String *subject() const {
|
|
return GetPointer<const ::flatbuffers::String *>(VT_SUBJECT);
|
|
}
|
|
const ::flatbuffers::String *body() const {
|
|
return GetPointer<const ::flatbuffers::String *>(VT_BODY);
|
|
}
|
|
const ::flatbuffers::Vector<uint8_t> *data() const {
|
|
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_DATA);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_COMMUNICATIONID) &&
|
|
verifier.VerifyString(communicationId()) &&
|
|
VerifyField<uint64_t>(verifier, VT_MSGID, 8) &&
|
|
VerifyField<uint16_t>(verifier, VT_MAINTYPE, 2) &&
|
|
VerifyField<uint16_t>(verifier, VT_SUBTYPE, 2) &&
|
|
VerifyField<uint32_t>(verifier, VT_MSGFEATURES, 4) &&
|
|
VerifyOffset(verifier, VT_SUBJECT) &&
|
|
verifier.VerifyString(subject()) &&
|
|
VerifyOffset(verifier, VT_BODY) &&
|
|
verifier.VerifyString(body()) &&
|
|
VerifyOffset(verifier, VT_DATA) &&
|
|
verifier.VerifyVector(data()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct MessageDetailsBuilder {
|
|
typedef MessageDetails Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_communicationId(::flatbuffers::Offset<::flatbuffers::String> communicationId) {
|
|
fbb_.AddOffset(MessageDetails::VT_COMMUNICATIONID, communicationId);
|
|
}
|
|
void add_msgId(uint64_t msgId) {
|
|
fbb_.AddElement<uint64_t>(MessageDetails::VT_MSGID, msgId, 0);
|
|
}
|
|
void add_mainType(uint16_t mainType) {
|
|
fbb_.AddElement<uint16_t>(MessageDetails::VT_MAINTYPE, mainType, 0);
|
|
}
|
|
void add_subType(uint16_t subType) {
|
|
fbb_.AddElement<uint16_t>(MessageDetails::VT_SUBTYPE, subType, 0);
|
|
}
|
|
void add_msgFeatures(uint32_t msgFeatures) {
|
|
fbb_.AddElement<uint32_t>(MessageDetails::VT_MSGFEATURES, msgFeatures, 0);
|
|
}
|
|
void add_subject(::flatbuffers::Offset<::flatbuffers::String> subject) {
|
|
fbb_.AddOffset(MessageDetails::VT_SUBJECT, subject);
|
|
}
|
|
void add_body(::flatbuffers::Offset<::flatbuffers::String> body) {
|
|
fbb_.AddOffset(MessageDetails::VT_BODY, body);
|
|
}
|
|
void add_data(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data) {
|
|
fbb_.AddOffset(MessageDetails::VT_DATA, data);
|
|
}
|
|
explicit MessageDetailsBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<MessageDetails> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<MessageDetails>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<MessageDetails> CreateMessageDetails(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<::flatbuffers::String> communicationId = 0,
|
|
uint64_t msgId = 0,
|
|
uint16_t mainType = 0,
|
|
uint16_t subType = 0,
|
|
uint32_t msgFeatures = 0,
|
|
::flatbuffers::Offset<::flatbuffers::String> subject = 0,
|
|
::flatbuffers::Offset<::flatbuffers::String> body = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data = 0) {
|
|
MessageDetailsBuilder builder_(_fbb);
|
|
builder_.add_msgId(msgId);
|
|
builder_.add_data(data);
|
|
builder_.add_body(body);
|
|
builder_.add_subject(subject);
|
|
builder_.add_msgFeatures(msgFeatures);
|
|
builder_.add_communicationId(communicationId);
|
|
builder_.add_subType(subType);
|
|
builder_.add_mainType(mainType);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<MessageDetails> CreateMessageDetailsDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
const char *communicationId = nullptr,
|
|
uint64_t msgId = 0,
|
|
uint16_t mainType = 0,
|
|
uint16_t subType = 0,
|
|
uint32_t msgFeatures = 0,
|
|
const char *subject = nullptr,
|
|
const char *body = nullptr,
|
|
const std::vector<uint8_t> *data = nullptr) {
|
|
auto communicationId__ = communicationId ? _fbb.CreateString(communicationId) : 0;
|
|
auto subject__ = subject ? _fbb.CreateString(subject) : 0;
|
|
auto body__ = body ? _fbb.CreateString(body) : 0;
|
|
auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
|
|
return CreateMessageDetails(
|
|
_fbb,
|
|
communicationId__,
|
|
msgId,
|
|
mainType,
|
|
subType,
|
|
msgFeatures,
|
|
subject__,
|
|
body__,
|
|
data__);
|
|
}
|
|
|
|
struct SendMessageRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef SendMessageRequestBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_MESSAGE = 4,
|
|
VT_NPIDS = 6
|
|
};
|
|
const ::flatbuffers::Vector<uint8_t> *message() const {
|
|
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_MESSAGE);
|
|
}
|
|
const MessageDetails *message_nested_root() const {
|
|
const auto _f = message();
|
|
return _f ? ::flatbuffers::GetRoot<MessageDetails>(_f->Data())
|
|
: nullptr;
|
|
}
|
|
const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *npids() const {
|
|
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_NPIDS);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_MESSAGE) &&
|
|
verifier.VerifyVector(message()) &&
|
|
verifier.VerifyNestedFlatBuffer<MessageDetails>(message(), nullptr) &&
|
|
VerifyOffset(verifier, VT_NPIDS) &&
|
|
verifier.VerifyVector(npids()) &&
|
|
verifier.VerifyVectorOfStrings(npids()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct SendMessageRequestBuilder {
|
|
typedef SendMessageRequest Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_message(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> message) {
|
|
fbb_.AddOffset(SendMessageRequest::VT_MESSAGE, message);
|
|
}
|
|
void add_npids(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> npids) {
|
|
fbb_.AddOffset(SendMessageRequest::VT_NPIDS, npids);
|
|
}
|
|
explicit SendMessageRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<SendMessageRequest> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<SendMessageRequest>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<SendMessageRequest> CreateSendMessageRequest(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> message = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> npids = 0) {
|
|
SendMessageRequestBuilder builder_(_fbb);
|
|
builder_.add_npids(npids);
|
|
builder_.add_message(message);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<SendMessageRequest> CreateSendMessageRequestDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
const std::vector<uint8_t> *message = nullptr,
|
|
const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *npids = nullptr) {
|
|
auto message__ = message ? _fbb.CreateVector<uint8_t>(*message) : 0;
|
|
auto npids__ = npids ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*npids) : 0;
|
|
return CreateSendMessageRequest(
|
|
_fbb,
|
|
message__,
|
|
npids__);
|
|
}
|
|
|
|
struct BoardInfo FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef BoardInfoBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_RANKLIMIT = 4,
|
|
VT_UPDATEMODE = 6,
|
|
VT_SORTMODE = 8,
|
|
VT_UPLOADNUMLIMIT = 10,
|
|
VT_UPLOADSIZELIMIT = 12
|
|
};
|
|
uint32_t rankLimit() const {
|
|
return GetField<uint32_t>(VT_RANKLIMIT, 0);
|
|
}
|
|
uint32_t updateMode() const {
|
|
return GetField<uint32_t>(VT_UPDATEMODE, 0);
|
|
}
|
|
uint32_t sortMode() const {
|
|
return GetField<uint32_t>(VT_SORTMODE, 0);
|
|
}
|
|
uint32_t uploadNumLimit() const {
|
|
return GetField<uint32_t>(VT_UPLOADNUMLIMIT, 0);
|
|
}
|
|
uint32_t uploadSizeLimit() const {
|
|
return GetField<uint32_t>(VT_UPLOADSIZELIMIT, 0);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<uint32_t>(verifier, VT_RANKLIMIT, 4) &&
|
|
VerifyField<uint32_t>(verifier, VT_UPDATEMODE, 4) &&
|
|
VerifyField<uint32_t>(verifier, VT_SORTMODE, 4) &&
|
|
VerifyField<uint32_t>(verifier, VT_UPLOADNUMLIMIT, 4) &&
|
|
VerifyField<uint32_t>(verifier, VT_UPLOADSIZELIMIT, 4) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct BoardInfoBuilder {
|
|
typedef BoardInfo Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_rankLimit(uint32_t rankLimit) {
|
|
fbb_.AddElement<uint32_t>(BoardInfo::VT_RANKLIMIT, rankLimit, 0);
|
|
}
|
|
void add_updateMode(uint32_t updateMode) {
|
|
fbb_.AddElement<uint32_t>(BoardInfo::VT_UPDATEMODE, updateMode, 0);
|
|
}
|
|
void add_sortMode(uint32_t sortMode) {
|
|
fbb_.AddElement<uint32_t>(BoardInfo::VT_SORTMODE, sortMode, 0);
|
|
}
|
|
void add_uploadNumLimit(uint32_t uploadNumLimit) {
|
|
fbb_.AddElement<uint32_t>(BoardInfo::VT_UPLOADNUMLIMIT, uploadNumLimit, 0);
|
|
}
|
|
void add_uploadSizeLimit(uint32_t uploadSizeLimit) {
|
|
fbb_.AddElement<uint32_t>(BoardInfo::VT_UPLOADSIZELIMIT, uploadSizeLimit, 0);
|
|
}
|
|
explicit BoardInfoBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<BoardInfo> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<BoardInfo>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<BoardInfo> CreateBoardInfo(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint32_t rankLimit = 0,
|
|
uint32_t updateMode = 0,
|
|
uint32_t sortMode = 0,
|
|
uint32_t uploadNumLimit = 0,
|
|
uint32_t uploadSizeLimit = 0) {
|
|
BoardInfoBuilder builder_(_fbb);
|
|
builder_.add_uploadSizeLimit(uploadSizeLimit);
|
|
builder_.add_uploadNumLimit(uploadNumLimit);
|
|
builder_.add_sortMode(sortMode);
|
|
builder_.add_updateMode(updateMode);
|
|
builder_.add_rankLimit(rankLimit);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
struct RecordScoreRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef RecordScoreRequestBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_BOARDID = 4,
|
|
VT_PCID = 6,
|
|
VT_SCORE = 8,
|
|
VT_COMMENT = 10,
|
|
VT_DATA = 12
|
|
};
|
|
uint32_t boardId() const {
|
|
return GetField<uint32_t>(VT_BOARDID, 0);
|
|
}
|
|
int32_t pcId() const {
|
|
return GetField<int32_t>(VT_PCID, 0);
|
|
}
|
|
int64_t score() const {
|
|
return GetField<int64_t>(VT_SCORE, 0);
|
|
}
|
|
const ::flatbuffers::String *comment() const {
|
|
return GetPointer<const ::flatbuffers::String *>(VT_COMMENT);
|
|
}
|
|
const ::flatbuffers::Vector<uint8_t> *data() const {
|
|
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_DATA);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<uint32_t>(verifier, VT_BOARDID, 4) &&
|
|
VerifyField<int32_t>(verifier, VT_PCID, 4) &&
|
|
VerifyField<int64_t>(verifier, VT_SCORE, 8) &&
|
|
VerifyOffset(verifier, VT_COMMENT) &&
|
|
verifier.VerifyString(comment()) &&
|
|
VerifyOffset(verifier, VT_DATA) &&
|
|
verifier.VerifyVector(data()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct RecordScoreRequestBuilder {
|
|
typedef RecordScoreRequest Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_boardId(uint32_t boardId) {
|
|
fbb_.AddElement<uint32_t>(RecordScoreRequest::VT_BOARDID, boardId, 0);
|
|
}
|
|
void add_pcId(int32_t pcId) {
|
|
fbb_.AddElement<int32_t>(RecordScoreRequest::VT_PCID, pcId, 0);
|
|
}
|
|
void add_score(int64_t score) {
|
|
fbb_.AddElement<int64_t>(RecordScoreRequest::VT_SCORE, score, 0);
|
|
}
|
|
void add_comment(::flatbuffers::Offset<::flatbuffers::String> comment) {
|
|
fbb_.AddOffset(RecordScoreRequest::VT_COMMENT, comment);
|
|
}
|
|
void add_data(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data) {
|
|
fbb_.AddOffset(RecordScoreRequest::VT_DATA, data);
|
|
}
|
|
explicit RecordScoreRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<RecordScoreRequest> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<RecordScoreRequest>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<RecordScoreRequest> CreateRecordScoreRequest(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint32_t boardId = 0,
|
|
int32_t pcId = 0,
|
|
int64_t score = 0,
|
|
::flatbuffers::Offset<::flatbuffers::String> comment = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data = 0) {
|
|
RecordScoreRequestBuilder builder_(_fbb);
|
|
builder_.add_score(score);
|
|
builder_.add_data(data);
|
|
builder_.add_comment(comment);
|
|
builder_.add_pcId(pcId);
|
|
builder_.add_boardId(boardId);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<RecordScoreRequest> CreateRecordScoreRequestDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint32_t boardId = 0,
|
|
int32_t pcId = 0,
|
|
int64_t score = 0,
|
|
const char *comment = nullptr,
|
|
const std::vector<uint8_t> *data = nullptr) {
|
|
auto comment__ = comment ? _fbb.CreateString(comment) : 0;
|
|
auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
|
|
return CreateRecordScoreRequest(
|
|
_fbb,
|
|
boardId,
|
|
pcId,
|
|
score,
|
|
comment__,
|
|
data__);
|
|
}
|
|
|
|
struct GetScoreRangeRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef GetScoreRangeRequestBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_BOARDID = 4,
|
|
VT_STARTRANK = 6,
|
|
VT_NUMRANKS = 8,
|
|
VT_WITHCOMMENT = 10,
|
|
VT_WITHGAMEINFO = 12
|
|
};
|
|
uint32_t boardId() const {
|
|
return GetField<uint32_t>(VT_BOARDID, 0);
|
|
}
|
|
uint32_t startRank() const {
|
|
return GetField<uint32_t>(VT_STARTRANK, 0);
|
|
}
|
|
uint32_t numRanks() const {
|
|
return GetField<uint32_t>(VT_NUMRANKS, 0);
|
|
}
|
|
bool withComment() const {
|
|
return GetField<uint8_t>(VT_WITHCOMMENT, 0) != 0;
|
|
}
|
|
bool withGameInfo() const {
|
|
return GetField<uint8_t>(VT_WITHGAMEINFO, 0) != 0;
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<uint32_t>(verifier, VT_BOARDID, 4) &&
|
|
VerifyField<uint32_t>(verifier, VT_STARTRANK, 4) &&
|
|
VerifyField<uint32_t>(verifier, VT_NUMRANKS, 4) &&
|
|
VerifyField<uint8_t>(verifier, VT_WITHCOMMENT, 1) &&
|
|
VerifyField<uint8_t>(verifier, VT_WITHGAMEINFO, 1) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct GetScoreRangeRequestBuilder {
|
|
typedef GetScoreRangeRequest Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_boardId(uint32_t boardId) {
|
|
fbb_.AddElement<uint32_t>(GetScoreRangeRequest::VT_BOARDID, boardId, 0);
|
|
}
|
|
void add_startRank(uint32_t startRank) {
|
|
fbb_.AddElement<uint32_t>(GetScoreRangeRequest::VT_STARTRANK, startRank, 0);
|
|
}
|
|
void add_numRanks(uint32_t numRanks) {
|
|
fbb_.AddElement<uint32_t>(GetScoreRangeRequest::VT_NUMRANKS, numRanks, 0);
|
|
}
|
|
void add_withComment(bool withComment) {
|
|
fbb_.AddElement<uint8_t>(GetScoreRangeRequest::VT_WITHCOMMENT, static_cast<uint8_t>(withComment), 0);
|
|
}
|
|
void add_withGameInfo(bool withGameInfo) {
|
|
fbb_.AddElement<uint8_t>(GetScoreRangeRequest::VT_WITHGAMEINFO, static_cast<uint8_t>(withGameInfo), 0);
|
|
}
|
|
explicit GetScoreRangeRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<GetScoreRangeRequest> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<GetScoreRangeRequest>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<GetScoreRangeRequest> CreateGetScoreRangeRequest(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint32_t boardId = 0,
|
|
uint32_t startRank = 0,
|
|
uint32_t numRanks = 0,
|
|
bool withComment = false,
|
|
bool withGameInfo = false) {
|
|
GetScoreRangeRequestBuilder builder_(_fbb);
|
|
builder_.add_numRanks(numRanks);
|
|
builder_.add_startRank(startRank);
|
|
builder_.add_boardId(boardId);
|
|
builder_.add_withGameInfo(withGameInfo);
|
|
builder_.add_withComment(withComment);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
struct ScoreNpIdPcId FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef ScoreNpIdPcIdBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_NPID = 4,
|
|
VT_PCID = 6
|
|
};
|
|
const ::flatbuffers::String *npid() const {
|
|
return GetPointer<const ::flatbuffers::String *>(VT_NPID);
|
|
}
|
|
int32_t pcId() const {
|
|
return GetField<int32_t>(VT_PCID, 0);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_NPID) &&
|
|
verifier.VerifyString(npid()) &&
|
|
VerifyField<int32_t>(verifier, VT_PCID, 4) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct ScoreNpIdPcIdBuilder {
|
|
typedef ScoreNpIdPcId Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_npid(::flatbuffers::Offset<::flatbuffers::String> npid) {
|
|
fbb_.AddOffset(ScoreNpIdPcId::VT_NPID, npid);
|
|
}
|
|
void add_pcId(int32_t pcId) {
|
|
fbb_.AddElement<int32_t>(ScoreNpIdPcId::VT_PCID, pcId, 0);
|
|
}
|
|
explicit ScoreNpIdPcIdBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<ScoreNpIdPcId> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<ScoreNpIdPcId>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<ScoreNpIdPcId> CreateScoreNpIdPcId(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<::flatbuffers::String> npid = 0,
|
|
int32_t pcId = 0) {
|
|
ScoreNpIdPcIdBuilder builder_(_fbb);
|
|
builder_.add_pcId(pcId);
|
|
builder_.add_npid(npid);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<ScoreNpIdPcId> CreateScoreNpIdPcIdDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
const char *npid = nullptr,
|
|
int32_t pcId = 0) {
|
|
auto npid__ = npid ? _fbb.CreateString(npid) : 0;
|
|
return CreateScoreNpIdPcId(
|
|
_fbb,
|
|
npid__,
|
|
pcId);
|
|
}
|
|
|
|
struct GetScoreNpIdRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef GetScoreNpIdRequestBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_BOARDID = 4,
|
|
VT_NPIDS = 6,
|
|
VT_WITHCOMMENT = 8,
|
|
VT_WITHGAMEINFO = 10
|
|
};
|
|
uint32_t boardId() const {
|
|
return GetField<uint32_t>(VT_BOARDID, 0);
|
|
}
|
|
const ::flatbuffers::Vector<::flatbuffers::Offset<ScoreNpIdPcId>> *npids() const {
|
|
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<ScoreNpIdPcId>> *>(VT_NPIDS);
|
|
}
|
|
bool withComment() const {
|
|
return GetField<uint8_t>(VT_WITHCOMMENT, 0) != 0;
|
|
}
|
|
bool withGameInfo() const {
|
|
return GetField<uint8_t>(VT_WITHGAMEINFO, 0) != 0;
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<uint32_t>(verifier, VT_BOARDID, 4) &&
|
|
VerifyOffset(verifier, VT_NPIDS) &&
|
|
verifier.VerifyVector(npids()) &&
|
|
verifier.VerifyVectorOfTables(npids()) &&
|
|
VerifyField<uint8_t>(verifier, VT_WITHCOMMENT, 1) &&
|
|
VerifyField<uint8_t>(verifier, VT_WITHGAMEINFO, 1) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct GetScoreNpIdRequestBuilder {
|
|
typedef GetScoreNpIdRequest Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_boardId(uint32_t boardId) {
|
|
fbb_.AddElement<uint32_t>(GetScoreNpIdRequest::VT_BOARDID, boardId, 0);
|
|
}
|
|
void add_npids(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<ScoreNpIdPcId>>> npids) {
|
|
fbb_.AddOffset(GetScoreNpIdRequest::VT_NPIDS, npids);
|
|
}
|
|
void add_withComment(bool withComment) {
|
|
fbb_.AddElement<uint8_t>(GetScoreNpIdRequest::VT_WITHCOMMENT, static_cast<uint8_t>(withComment), 0);
|
|
}
|
|
void add_withGameInfo(bool withGameInfo) {
|
|
fbb_.AddElement<uint8_t>(GetScoreNpIdRequest::VT_WITHGAMEINFO, static_cast<uint8_t>(withGameInfo), 0);
|
|
}
|
|
explicit GetScoreNpIdRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<GetScoreNpIdRequest> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<GetScoreNpIdRequest>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<GetScoreNpIdRequest> CreateGetScoreNpIdRequest(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint32_t boardId = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<ScoreNpIdPcId>>> npids = 0,
|
|
bool withComment = false,
|
|
bool withGameInfo = false) {
|
|
GetScoreNpIdRequestBuilder builder_(_fbb);
|
|
builder_.add_npids(npids);
|
|
builder_.add_boardId(boardId);
|
|
builder_.add_withGameInfo(withGameInfo);
|
|
builder_.add_withComment(withComment);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<GetScoreNpIdRequest> CreateGetScoreNpIdRequestDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint32_t boardId = 0,
|
|
const std::vector<::flatbuffers::Offset<ScoreNpIdPcId>> *npids = nullptr,
|
|
bool withComment = false,
|
|
bool withGameInfo = false) {
|
|
auto npids__ = npids ? _fbb.CreateVector<::flatbuffers::Offset<ScoreNpIdPcId>>(*npids) : 0;
|
|
return CreateGetScoreNpIdRequest(
|
|
_fbb,
|
|
boardId,
|
|
npids__,
|
|
withComment,
|
|
withGameInfo);
|
|
}
|
|
|
|
struct GetScoreFriendsRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef GetScoreFriendsRequestBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_BOARDID = 4,
|
|
VT_INCLUDE_SELF = 6,
|
|
VT_MAX = 8,
|
|
VT_WITHCOMMENT = 10,
|
|
VT_WITHGAMEINFO = 12
|
|
};
|
|
uint32_t boardId() const {
|
|
return GetField<uint32_t>(VT_BOARDID, 0);
|
|
}
|
|
bool include_self() const {
|
|
return GetField<uint8_t>(VT_INCLUDE_SELF, 0) != 0;
|
|
}
|
|
uint32_t max() const {
|
|
return GetField<uint32_t>(VT_MAX, 0);
|
|
}
|
|
bool withComment() const {
|
|
return GetField<uint8_t>(VT_WITHCOMMENT, 0) != 0;
|
|
}
|
|
bool withGameInfo() const {
|
|
return GetField<uint8_t>(VT_WITHGAMEINFO, 0) != 0;
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<uint32_t>(verifier, VT_BOARDID, 4) &&
|
|
VerifyField<uint8_t>(verifier, VT_INCLUDE_SELF, 1) &&
|
|
VerifyField<uint32_t>(verifier, VT_MAX, 4) &&
|
|
VerifyField<uint8_t>(verifier, VT_WITHCOMMENT, 1) &&
|
|
VerifyField<uint8_t>(verifier, VT_WITHGAMEINFO, 1) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct GetScoreFriendsRequestBuilder {
|
|
typedef GetScoreFriendsRequest Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_boardId(uint32_t boardId) {
|
|
fbb_.AddElement<uint32_t>(GetScoreFriendsRequest::VT_BOARDID, boardId, 0);
|
|
}
|
|
void add_include_self(bool include_self) {
|
|
fbb_.AddElement<uint8_t>(GetScoreFriendsRequest::VT_INCLUDE_SELF, static_cast<uint8_t>(include_self), 0);
|
|
}
|
|
void add_max(uint32_t max) {
|
|
fbb_.AddElement<uint32_t>(GetScoreFriendsRequest::VT_MAX, max, 0);
|
|
}
|
|
void add_withComment(bool withComment) {
|
|
fbb_.AddElement<uint8_t>(GetScoreFriendsRequest::VT_WITHCOMMENT, static_cast<uint8_t>(withComment), 0);
|
|
}
|
|
void add_withGameInfo(bool withGameInfo) {
|
|
fbb_.AddElement<uint8_t>(GetScoreFriendsRequest::VT_WITHGAMEINFO, static_cast<uint8_t>(withGameInfo), 0);
|
|
}
|
|
explicit GetScoreFriendsRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<GetScoreFriendsRequest> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<GetScoreFriendsRequest>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<GetScoreFriendsRequest> CreateGetScoreFriendsRequest(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint32_t boardId = 0,
|
|
bool include_self = false,
|
|
uint32_t max = 0,
|
|
bool withComment = false,
|
|
bool withGameInfo = false) {
|
|
GetScoreFriendsRequestBuilder builder_(_fbb);
|
|
builder_.add_max(max);
|
|
builder_.add_boardId(boardId);
|
|
builder_.add_withGameInfo(withGameInfo);
|
|
builder_.add_withComment(withComment);
|
|
builder_.add_include_self(include_self);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
struct ScoreRankData FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef ScoreRankDataBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_NPID = 4,
|
|
VT_ONLINENAME = 6,
|
|
VT_PCID = 8,
|
|
VT_RANK = 10,
|
|
VT_SCORE = 12,
|
|
VT_HASGAMEDATA = 14,
|
|
VT_RECORDDATE = 16
|
|
};
|
|
const ::flatbuffers::String *npId() const {
|
|
return GetPointer<const ::flatbuffers::String *>(VT_NPID);
|
|
}
|
|
const ::flatbuffers::String *onlineName() const {
|
|
return GetPointer<const ::flatbuffers::String *>(VT_ONLINENAME);
|
|
}
|
|
int32_t pcId() const {
|
|
return GetField<int32_t>(VT_PCID, 0);
|
|
}
|
|
uint32_t rank() const {
|
|
return GetField<uint32_t>(VT_RANK, 0);
|
|
}
|
|
int64_t score() const {
|
|
return GetField<int64_t>(VT_SCORE, 0);
|
|
}
|
|
bool hasGameData() const {
|
|
return GetField<uint8_t>(VT_HASGAMEDATA, 0) != 0;
|
|
}
|
|
uint64_t recordDate() const {
|
|
return GetField<uint64_t>(VT_RECORDDATE, 0);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_NPID) &&
|
|
verifier.VerifyString(npId()) &&
|
|
VerifyOffset(verifier, VT_ONLINENAME) &&
|
|
verifier.VerifyString(onlineName()) &&
|
|
VerifyField<int32_t>(verifier, VT_PCID, 4) &&
|
|
VerifyField<uint32_t>(verifier, VT_RANK, 4) &&
|
|
VerifyField<int64_t>(verifier, VT_SCORE, 8) &&
|
|
VerifyField<uint8_t>(verifier, VT_HASGAMEDATA, 1) &&
|
|
VerifyField<uint64_t>(verifier, VT_RECORDDATE, 8) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct ScoreRankDataBuilder {
|
|
typedef ScoreRankData Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_npId(::flatbuffers::Offset<::flatbuffers::String> npId) {
|
|
fbb_.AddOffset(ScoreRankData::VT_NPID, npId);
|
|
}
|
|
void add_onlineName(::flatbuffers::Offset<::flatbuffers::String> onlineName) {
|
|
fbb_.AddOffset(ScoreRankData::VT_ONLINENAME, onlineName);
|
|
}
|
|
void add_pcId(int32_t pcId) {
|
|
fbb_.AddElement<int32_t>(ScoreRankData::VT_PCID, pcId, 0);
|
|
}
|
|
void add_rank(uint32_t rank) {
|
|
fbb_.AddElement<uint32_t>(ScoreRankData::VT_RANK, rank, 0);
|
|
}
|
|
void add_score(int64_t score) {
|
|
fbb_.AddElement<int64_t>(ScoreRankData::VT_SCORE, score, 0);
|
|
}
|
|
void add_hasGameData(bool hasGameData) {
|
|
fbb_.AddElement<uint8_t>(ScoreRankData::VT_HASGAMEDATA, static_cast<uint8_t>(hasGameData), 0);
|
|
}
|
|
void add_recordDate(uint64_t recordDate) {
|
|
fbb_.AddElement<uint64_t>(ScoreRankData::VT_RECORDDATE, recordDate, 0);
|
|
}
|
|
explicit ScoreRankDataBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<ScoreRankData> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<ScoreRankData>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<ScoreRankData> CreateScoreRankData(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<::flatbuffers::String> npId = 0,
|
|
::flatbuffers::Offset<::flatbuffers::String> onlineName = 0,
|
|
int32_t pcId = 0,
|
|
uint32_t rank = 0,
|
|
int64_t score = 0,
|
|
bool hasGameData = false,
|
|
uint64_t recordDate = 0) {
|
|
ScoreRankDataBuilder builder_(_fbb);
|
|
builder_.add_recordDate(recordDate);
|
|
builder_.add_score(score);
|
|
builder_.add_rank(rank);
|
|
builder_.add_pcId(pcId);
|
|
builder_.add_onlineName(onlineName);
|
|
builder_.add_npId(npId);
|
|
builder_.add_hasGameData(hasGameData);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<ScoreRankData> CreateScoreRankDataDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
const char *npId = nullptr,
|
|
const char *onlineName = nullptr,
|
|
int32_t pcId = 0,
|
|
uint32_t rank = 0,
|
|
int64_t score = 0,
|
|
bool hasGameData = false,
|
|
uint64_t recordDate = 0) {
|
|
auto npId__ = npId ? _fbb.CreateString(npId) : 0;
|
|
auto onlineName__ = onlineName ? _fbb.CreateString(onlineName) : 0;
|
|
return CreateScoreRankData(
|
|
_fbb,
|
|
npId__,
|
|
onlineName__,
|
|
pcId,
|
|
rank,
|
|
score,
|
|
hasGameData,
|
|
recordDate);
|
|
}
|
|
|
|
struct ScoreInfo FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef ScoreInfoBuilder 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);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_DATA) &&
|
|
verifier.VerifyVector(data()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct ScoreInfoBuilder {
|
|
typedef ScoreInfo Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_data(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data) {
|
|
fbb_.AddOffset(ScoreInfo::VT_DATA, data);
|
|
}
|
|
explicit ScoreInfoBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<ScoreInfo> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<ScoreInfo>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<ScoreInfo> CreateScoreInfo(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data = 0) {
|
|
ScoreInfoBuilder builder_(_fbb);
|
|
builder_.add_data(data);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<ScoreInfo> CreateScoreInfoDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
const std::vector<uint8_t> *data = nullptr) {
|
|
auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
|
|
return CreateScoreInfo(
|
|
_fbb,
|
|
data__);
|
|
}
|
|
|
|
struct GetScoreResponse FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef GetScoreResponseBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_RANKARRAY = 4,
|
|
VT_COMMENTARRAY = 6,
|
|
VT_INFOARRAY = 8,
|
|
VT_LASTSORTDATE = 10,
|
|
VT_TOTALRECORD = 12
|
|
};
|
|
const ::flatbuffers::Vector<::flatbuffers::Offset<ScoreRankData>> *rankArray() const {
|
|
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<ScoreRankData>> *>(VT_RANKARRAY);
|
|
}
|
|
const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *commentArray() const {
|
|
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_COMMENTARRAY);
|
|
}
|
|
const ::flatbuffers::Vector<::flatbuffers::Offset<ScoreInfo>> *infoArray() const {
|
|
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<ScoreInfo>> *>(VT_INFOARRAY);
|
|
}
|
|
uint64_t lastSortDate() const {
|
|
return GetField<uint64_t>(VT_LASTSORTDATE, 0);
|
|
}
|
|
uint32_t totalRecord() const {
|
|
return GetField<uint32_t>(VT_TOTALRECORD, 0);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_RANKARRAY) &&
|
|
verifier.VerifyVector(rankArray()) &&
|
|
verifier.VerifyVectorOfTables(rankArray()) &&
|
|
VerifyOffset(verifier, VT_COMMENTARRAY) &&
|
|
verifier.VerifyVector(commentArray()) &&
|
|
verifier.VerifyVectorOfStrings(commentArray()) &&
|
|
VerifyOffset(verifier, VT_INFOARRAY) &&
|
|
verifier.VerifyVector(infoArray()) &&
|
|
verifier.VerifyVectorOfTables(infoArray()) &&
|
|
VerifyField<uint64_t>(verifier, VT_LASTSORTDATE, 8) &&
|
|
VerifyField<uint32_t>(verifier, VT_TOTALRECORD, 4) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct GetScoreResponseBuilder {
|
|
typedef GetScoreResponse Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_rankArray(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<ScoreRankData>>> rankArray) {
|
|
fbb_.AddOffset(GetScoreResponse::VT_RANKARRAY, rankArray);
|
|
}
|
|
void add_commentArray(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> commentArray) {
|
|
fbb_.AddOffset(GetScoreResponse::VT_COMMENTARRAY, commentArray);
|
|
}
|
|
void add_infoArray(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<ScoreInfo>>> infoArray) {
|
|
fbb_.AddOffset(GetScoreResponse::VT_INFOARRAY, infoArray);
|
|
}
|
|
void add_lastSortDate(uint64_t lastSortDate) {
|
|
fbb_.AddElement<uint64_t>(GetScoreResponse::VT_LASTSORTDATE, lastSortDate, 0);
|
|
}
|
|
void add_totalRecord(uint32_t totalRecord) {
|
|
fbb_.AddElement<uint32_t>(GetScoreResponse::VT_TOTALRECORD, totalRecord, 0);
|
|
}
|
|
explicit GetScoreResponseBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<GetScoreResponse> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<GetScoreResponse>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<GetScoreResponse> CreateGetScoreResponse(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<ScoreRankData>>> rankArray = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> commentArray = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<ScoreInfo>>> infoArray = 0,
|
|
uint64_t lastSortDate = 0,
|
|
uint32_t totalRecord = 0) {
|
|
GetScoreResponseBuilder builder_(_fbb);
|
|
builder_.add_lastSortDate(lastSortDate);
|
|
builder_.add_totalRecord(totalRecord);
|
|
builder_.add_infoArray(infoArray);
|
|
builder_.add_commentArray(commentArray);
|
|
builder_.add_rankArray(rankArray);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<GetScoreResponse> CreateGetScoreResponseDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
const std::vector<::flatbuffers::Offset<ScoreRankData>> *rankArray = nullptr,
|
|
const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *commentArray = nullptr,
|
|
const std::vector<::flatbuffers::Offset<ScoreInfo>> *infoArray = nullptr,
|
|
uint64_t lastSortDate = 0,
|
|
uint32_t totalRecord = 0) {
|
|
auto rankArray__ = rankArray ? _fbb.CreateVector<::flatbuffers::Offset<ScoreRankData>>(*rankArray) : 0;
|
|
auto commentArray__ = commentArray ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*commentArray) : 0;
|
|
auto infoArray__ = infoArray ? _fbb.CreateVector<::flatbuffers::Offset<ScoreInfo>>(*infoArray) : 0;
|
|
return CreateGetScoreResponse(
|
|
_fbb,
|
|
rankArray__,
|
|
commentArray__,
|
|
infoArray__,
|
|
lastSortDate,
|
|
totalRecord);
|
|
}
|
|
|
|
struct RecordScoreGameDataRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef RecordScoreGameDataRequestBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_BOARDID = 4,
|
|
VT_PCID = 6,
|
|
VT_SCORE = 8
|
|
};
|
|
uint32_t boardId() const {
|
|
return GetField<uint32_t>(VT_BOARDID, 0);
|
|
}
|
|
int32_t pcId() const {
|
|
return GetField<int32_t>(VT_PCID, 0);
|
|
}
|
|
int64_t score() const {
|
|
return GetField<int64_t>(VT_SCORE, 0);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<uint32_t>(verifier, VT_BOARDID, 4) &&
|
|
VerifyField<int32_t>(verifier, VT_PCID, 4) &&
|
|
VerifyField<int64_t>(verifier, VT_SCORE, 8) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct RecordScoreGameDataRequestBuilder {
|
|
typedef RecordScoreGameDataRequest Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_boardId(uint32_t boardId) {
|
|
fbb_.AddElement<uint32_t>(RecordScoreGameDataRequest::VT_BOARDID, boardId, 0);
|
|
}
|
|
void add_pcId(int32_t pcId) {
|
|
fbb_.AddElement<int32_t>(RecordScoreGameDataRequest::VT_PCID, pcId, 0);
|
|
}
|
|
void add_score(int64_t score) {
|
|
fbb_.AddElement<int64_t>(RecordScoreGameDataRequest::VT_SCORE, score, 0);
|
|
}
|
|
explicit RecordScoreGameDataRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<RecordScoreGameDataRequest> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<RecordScoreGameDataRequest>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<RecordScoreGameDataRequest> CreateRecordScoreGameDataRequest(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint32_t boardId = 0,
|
|
int32_t pcId = 0,
|
|
int64_t score = 0) {
|
|
RecordScoreGameDataRequestBuilder builder_(_fbb);
|
|
builder_.add_score(score);
|
|
builder_.add_pcId(pcId);
|
|
builder_.add_boardId(boardId);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
struct GetScoreGameDataRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef GetScoreGameDataRequestBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_BOARDID = 4,
|
|
VT_NPID = 6,
|
|
VT_PCID = 8
|
|
};
|
|
uint32_t boardId() const {
|
|
return GetField<uint32_t>(VT_BOARDID, 0);
|
|
}
|
|
const ::flatbuffers::String *npId() const {
|
|
return GetPointer<const ::flatbuffers::String *>(VT_NPID);
|
|
}
|
|
int32_t pcId() const {
|
|
return GetField<int32_t>(VT_PCID, 0);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<uint32_t>(verifier, VT_BOARDID, 4) &&
|
|
VerifyOffset(verifier, VT_NPID) &&
|
|
verifier.VerifyString(npId()) &&
|
|
VerifyField<int32_t>(verifier, VT_PCID, 4) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct GetScoreGameDataRequestBuilder {
|
|
typedef GetScoreGameDataRequest Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_boardId(uint32_t boardId) {
|
|
fbb_.AddElement<uint32_t>(GetScoreGameDataRequest::VT_BOARDID, boardId, 0);
|
|
}
|
|
void add_npId(::flatbuffers::Offset<::flatbuffers::String> npId) {
|
|
fbb_.AddOffset(GetScoreGameDataRequest::VT_NPID, npId);
|
|
}
|
|
void add_pcId(int32_t pcId) {
|
|
fbb_.AddElement<int32_t>(GetScoreGameDataRequest::VT_PCID, pcId, 0);
|
|
}
|
|
explicit GetScoreGameDataRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<GetScoreGameDataRequest> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<GetScoreGameDataRequest>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<GetScoreGameDataRequest> CreateGetScoreGameDataRequest(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint32_t boardId = 0,
|
|
::flatbuffers::Offset<::flatbuffers::String> npId = 0,
|
|
int32_t pcId = 0) {
|
|
GetScoreGameDataRequestBuilder builder_(_fbb);
|
|
builder_.add_pcId(pcId);
|
|
builder_.add_npId(npId);
|
|
builder_.add_boardId(boardId);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<GetScoreGameDataRequest> CreateGetScoreGameDataRequestDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint32_t boardId = 0,
|
|
const char *npId = nullptr,
|
|
int32_t pcId = 0) {
|
|
auto npId__ = npId ? _fbb.CreateString(npId) : 0;
|
|
return CreateGetScoreGameDataRequest(
|
|
_fbb,
|
|
boardId,
|
|
npId__,
|
|
pcId);
|
|
}
|
|
|
|
struct TusUser FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef TusUserBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_VUSER = 4,
|
|
VT_NPID = 6
|
|
};
|
|
bool vuser() const {
|
|
return GetField<uint8_t>(VT_VUSER, 0) != 0;
|
|
}
|
|
const ::flatbuffers::String *npid() const {
|
|
return GetPointer<const ::flatbuffers::String *>(VT_NPID);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<uint8_t>(verifier, VT_VUSER, 1) &&
|
|
VerifyOffset(verifier, VT_NPID) &&
|
|
verifier.VerifyString(npid()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct TusUserBuilder {
|
|
typedef TusUser Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_vuser(bool vuser) {
|
|
fbb_.AddElement<uint8_t>(TusUser::VT_VUSER, static_cast<uint8_t>(vuser), 0);
|
|
}
|
|
void add_npid(::flatbuffers::Offset<::flatbuffers::String> npid) {
|
|
fbb_.AddOffset(TusUser::VT_NPID, npid);
|
|
}
|
|
explicit TusUserBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<TusUser> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<TusUser>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<TusUser> CreateTusUser(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
bool vuser = false,
|
|
::flatbuffers::Offset<::flatbuffers::String> npid = 0) {
|
|
TusUserBuilder builder_(_fbb);
|
|
builder_.add_npid(npid);
|
|
builder_.add_vuser(vuser);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<TusUser> CreateTusUserDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
bool vuser = false,
|
|
const char *npid = nullptr) {
|
|
auto npid__ = npid ? _fbb.CreateString(npid) : 0;
|
|
return CreateTusUser(
|
|
_fbb,
|
|
vuser,
|
|
npid__);
|
|
}
|
|
|
|
struct TusVariable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef TusVariableBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_OWNERID = 4,
|
|
VT_HASDATA = 6,
|
|
VT_LASTCHANGEDDATE = 8,
|
|
VT_LASTCHANGEDAUTHORID = 10,
|
|
VT_VARIABLE = 12,
|
|
VT_OLDVARIABLE = 14
|
|
};
|
|
const ::flatbuffers::String *ownerId() const {
|
|
return GetPointer<const ::flatbuffers::String *>(VT_OWNERID);
|
|
}
|
|
bool hasData() const {
|
|
return GetField<uint8_t>(VT_HASDATA, 0) != 0;
|
|
}
|
|
uint64_t lastChangedDate() const {
|
|
return GetField<uint64_t>(VT_LASTCHANGEDDATE, 0);
|
|
}
|
|
const ::flatbuffers::String *lastChangedAuthorId() const {
|
|
return GetPointer<const ::flatbuffers::String *>(VT_LASTCHANGEDAUTHORID);
|
|
}
|
|
int64_t variable() const {
|
|
return GetField<int64_t>(VT_VARIABLE, 0);
|
|
}
|
|
int64_t oldVariable() const {
|
|
return GetField<int64_t>(VT_OLDVARIABLE, 0);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_OWNERID) &&
|
|
verifier.VerifyString(ownerId()) &&
|
|
VerifyField<uint8_t>(verifier, VT_HASDATA, 1) &&
|
|
VerifyField<uint64_t>(verifier, VT_LASTCHANGEDDATE, 8) &&
|
|
VerifyOffset(verifier, VT_LASTCHANGEDAUTHORID) &&
|
|
verifier.VerifyString(lastChangedAuthorId()) &&
|
|
VerifyField<int64_t>(verifier, VT_VARIABLE, 8) &&
|
|
VerifyField<int64_t>(verifier, VT_OLDVARIABLE, 8) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct TusVariableBuilder {
|
|
typedef TusVariable Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_ownerId(::flatbuffers::Offset<::flatbuffers::String> ownerId) {
|
|
fbb_.AddOffset(TusVariable::VT_OWNERID, ownerId);
|
|
}
|
|
void add_hasData(bool hasData) {
|
|
fbb_.AddElement<uint8_t>(TusVariable::VT_HASDATA, static_cast<uint8_t>(hasData), 0);
|
|
}
|
|
void add_lastChangedDate(uint64_t lastChangedDate) {
|
|
fbb_.AddElement<uint64_t>(TusVariable::VT_LASTCHANGEDDATE, lastChangedDate, 0);
|
|
}
|
|
void add_lastChangedAuthorId(::flatbuffers::Offset<::flatbuffers::String> lastChangedAuthorId) {
|
|
fbb_.AddOffset(TusVariable::VT_LASTCHANGEDAUTHORID, lastChangedAuthorId);
|
|
}
|
|
void add_variable(int64_t variable) {
|
|
fbb_.AddElement<int64_t>(TusVariable::VT_VARIABLE, variable, 0);
|
|
}
|
|
void add_oldVariable(int64_t oldVariable) {
|
|
fbb_.AddElement<int64_t>(TusVariable::VT_OLDVARIABLE, oldVariable, 0);
|
|
}
|
|
explicit TusVariableBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<TusVariable> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<TusVariable>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<TusVariable> CreateTusVariable(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<::flatbuffers::String> ownerId = 0,
|
|
bool hasData = false,
|
|
uint64_t lastChangedDate = 0,
|
|
::flatbuffers::Offset<::flatbuffers::String> lastChangedAuthorId = 0,
|
|
int64_t variable = 0,
|
|
int64_t oldVariable = 0) {
|
|
TusVariableBuilder builder_(_fbb);
|
|
builder_.add_oldVariable(oldVariable);
|
|
builder_.add_variable(variable);
|
|
builder_.add_lastChangedDate(lastChangedDate);
|
|
builder_.add_lastChangedAuthorId(lastChangedAuthorId);
|
|
builder_.add_ownerId(ownerId);
|
|
builder_.add_hasData(hasData);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<TusVariable> CreateTusVariableDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
const char *ownerId = nullptr,
|
|
bool hasData = false,
|
|
uint64_t lastChangedDate = 0,
|
|
const char *lastChangedAuthorId = nullptr,
|
|
int64_t variable = 0,
|
|
int64_t oldVariable = 0) {
|
|
auto ownerId__ = ownerId ? _fbb.CreateString(ownerId) : 0;
|
|
auto lastChangedAuthorId__ = lastChangedAuthorId ? _fbb.CreateString(lastChangedAuthorId) : 0;
|
|
return CreateTusVariable(
|
|
_fbb,
|
|
ownerId__,
|
|
hasData,
|
|
lastChangedDate,
|
|
lastChangedAuthorId__,
|
|
variable,
|
|
oldVariable);
|
|
}
|
|
|
|
struct TusVarResponse FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef TusVarResponseBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_VARS = 4
|
|
};
|
|
const ::flatbuffers::Vector<::flatbuffers::Offset<TusVariable>> *vars() const {
|
|
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<TusVariable>> *>(VT_VARS);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_VARS) &&
|
|
verifier.VerifyVector(vars()) &&
|
|
verifier.VerifyVectorOfTables(vars()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct TusVarResponseBuilder {
|
|
typedef TusVarResponse Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_vars(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<TusVariable>>> vars) {
|
|
fbb_.AddOffset(TusVarResponse::VT_VARS, vars);
|
|
}
|
|
explicit TusVarResponseBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<TusVarResponse> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<TusVarResponse>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<TusVarResponse> CreateTusVarResponse(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<TusVariable>>> vars = 0) {
|
|
TusVarResponseBuilder builder_(_fbb);
|
|
builder_.add_vars(vars);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<TusVarResponse> CreateTusVarResponseDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
const std::vector<::flatbuffers::Offset<TusVariable>> *vars = nullptr) {
|
|
auto vars__ = vars ? _fbb.CreateVector<::flatbuffers::Offset<TusVariable>>(*vars) : 0;
|
|
return CreateTusVarResponse(
|
|
_fbb,
|
|
vars__);
|
|
}
|
|
|
|
struct TusSetMultiSlotVariableRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef TusSetMultiSlotVariableRequestBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_USER = 4,
|
|
VT_SLOTIDARRAY = 6,
|
|
VT_VARIABLEARRAY = 8
|
|
};
|
|
const TusUser *user() const {
|
|
return GetPointer<const TusUser *>(VT_USER);
|
|
}
|
|
const ::flatbuffers::Vector<int32_t> *slotIdArray() const {
|
|
return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_SLOTIDARRAY);
|
|
}
|
|
const ::flatbuffers::Vector<int64_t> *variableArray() const {
|
|
return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_VARIABLEARRAY);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_USER) &&
|
|
verifier.VerifyTable(user()) &&
|
|
VerifyOffset(verifier, VT_SLOTIDARRAY) &&
|
|
verifier.VerifyVector(slotIdArray()) &&
|
|
VerifyOffset(verifier, VT_VARIABLEARRAY) &&
|
|
verifier.VerifyVector(variableArray()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct TusSetMultiSlotVariableRequestBuilder {
|
|
typedef TusSetMultiSlotVariableRequest Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_user(::flatbuffers::Offset<TusUser> user) {
|
|
fbb_.AddOffset(TusSetMultiSlotVariableRequest::VT_USER, user);
|
|
}
|
|
void add_slotIdArray(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> slotIdArray) {
|
|
fbb_.AddOffset(TusSetMultiSlotVariableRequest::VT_SLOTIDARRAY, slotIdArray);
|
|
}
|
|
void add_variableArray(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> variableArray) {
|
|
fbb_.AddOffset(TusSetMultiSlotVariableRequest::VT_VARIABLEARRAY, variableArray);
|
|
}
|
|
explicit TusSetMultiSlotVariableRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<TusSetMultiSlotVariableRequest> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<TusSetMultiSlotVariableRequest>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<TusSetMultiSlotVariableRequest> CreateTusSetMultiSlotVariableRequest(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<TusUser> user = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> slotIdArray = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> variableArray = 0) {
|
|
TusSetMultiSlotVariableRequestBuilder builder_(_fbb);
|
|
builder_.add_variableArray(variableArray);
|
|
builder_.add_slotIdArray(slotIdArray);
|
|
builder_.add_user(user);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<TusSetMultiSlotVariableRequest> CreateTusSetMultiSlotVariableRequestDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<TusUser> user = 0,
|
|
const std::vector<int32_t> *slotIdArray = nullptr,
|
|
const std::vector<int64_t> *variableArray = nullptr) {
|
|
auto slotIdArray__ = slotIdArray ? _fbb.CreateVector<int32_t>(*slotIdArray) : 0;
|
|
auto variableArray__ = variableArray ? _fbb.CreateVector<int64_t>(*variableArray) : 0;
|
|
return CreateTusSetMultiSlotVariableRequest(
|
|
_fbb,
|
|
user,
|
|
slotIdArray__,
|
|
variableArray__);
|
|
}
|
|
|
|
struct TusGetMultiSlotVariableRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef TusGetMultiSlotVariableRequestBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_USER = 4,
|
|
VT_SLOTIDARRAY = 6
|
|
};
|
|
const TusUser *user() const {
|
|
return GetPointer<const TusUser *>(VT_USER);
|
|
}
|
|
const ::flatbuffers::Vector<int32_t> *slotIdArray() const {
|
|
return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_SLOTIDARRAY);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_USER) &&
|
|
verifier.VerifyTable(user()) &&
|
|
VerifyOffset(verifier, VT_SLOTIDARRAY) &&
|
|
verifier.VerifyVector(slotIdArray()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct TusGetMultiSlotVariableRequestBuilder {
|
|
typedef TusGetMultiSlotVariableRequest Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_user(::flatbuffers::Offset<TusUser> user) {
|
|
fbb_.AddOffset(TusGetMultiSlotVariableRequest::VT_USER, user);
|
|
}
|
|
void add_slotIdArray(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> slotIdArray) {
|
|
fbb_.AddOffset(TusGetMultiSlotVariableRequest::VT_SLOTIDARRAY, slotIdArray);
|
|
}
|
|
explicit TusGetMultiSlotVariableRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<TusGetMultiSlotVariableRequest> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<TusGetMultiSlotVariableRequest>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<TusGetMultiSlotVariableRequest> CreateTusGetMultiSlotVariableRequest(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<TusUser> user = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> slotIdArray = 0) {
|
|
TusGetMultiSlotVariableRequestBuilder builder_(_fbb);
|
|
builder_.add_slotIdArray(slotIdArray);
|
|
builder_.add_user(user);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<TusGetMultiSlotVariableRequest> CreateTusGetMultiSlotVariableRequestDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<TusUser> user = 0,
|
|
const std::vector<int32_t> *slotIdArray = nullptr) {
|
|
auto slotIdArray__ = slotIdArray ? _fbb.CreateVector<int32_t>(*slotIdArray) : 0;
|
|
return CreateTusGetMultiSlotVariableRequest(
|
|
_fbb,
|
|
user,
|
|
slotIdArray__);
|
|
}
|
|
|
|
struct TusGetMultiUserVariableRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef TusGetMultiUserVariableRequestBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_USERS = 4,
|
|
VT_SLOTID = 6
|
|
};
|
|
const ::flatbuffers::Vector<::flatbuffers::Offset<TusUser>> *users() const {
|
|
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<TusUser>> *>(VT_USERS);
|
|
}
|
|
int32_t slotId() const {
|
|
return GetField<int32_t>(VT_SLOTID, 0);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_USERS) &&
|
|
verifier.VerifyVector(users()) &&
|
|
verifier.VerifyVectorOfTables(users()) &&
|
|
VerifyField<int32_t>(verifier, VT_SLOTID, 4) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct TusGetMultiUserVariableRequestBuilder {
|
|
typedef TusGetMultiUserVariableRequest Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_users(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<TusUser>>> users) {
|
|
fbb_.AddOffset(TusGetMultiUserVariableRequest::VT_USERS, users);
|
|
}
|
|
void add_slotId(int32_t slotId) {
|
|
fbb_.AddElement<int32_t>(TusGetMultiUserVariableRequest::VT_SLOTID, slotId, 0);
|
|
}
|
|
explicit TusGetMultiUserVariableRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<TusGetMultiUserVariableRequest> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<TusGetMultiUserVariableRequest>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<TusGetMultiUserVariableRequest> CreateTusGetMultiUserVariableRequest(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<TusUser>>> users = 0,
|
|
int32_t slotId = 0) {
|
|
TusGetMultiUserVariableRequestBuilder builder_(_fbb);
|
|
builder_.add_slotId(slotId);
|
|
builder_.add_users(users);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<TusGetMultiUserVariableRequest> CreateTusGetMultiUserVariableRequestDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
const std::vector<::flatbuffers::Offset<TusUser>> *users = nullptr,
|
|
int32_t slotId = 0) {
|
|
auto users__ = users ? _fbb.CreateVector<::flatbuffers::Offset<TusUser>>(*users) : 0;
|
|
return CreateTusGetMultiUserVariableRequest(
|
|
_fbb,
|
|
users__,
|
|
slotId);
|
|
}
|
|
|
|
struct TusGetFriendsVariableRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef TusGetFriendsVariableRequestBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_SLOTID = 4,
|
|
VT_INCLUDESELF = 6,
|
|
VT_SORTTYPE = 8,
|
|
VT_ARRAYNUM = 10
|
|
};
|
|
int32_t slotId() const {
|
|
return GetField<int32_t>(VT_SLOTID, 0);
|
|
}
|
|
bool includeSelf() const {
|
|
return GetField<uint8_t>(VT_INCLUDESELF, 0) != 0;
|
|
}
|
|
int32_t sortType() const {
|
|
return GetField<int32_t>(VT_SORTTYPE, 0);
|
|
}
|
|
uint32_t arrayNum() const {
|
|
return GetField<uint32_t>(VT_ARRAYNUM, 0);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<int32_t>(verifier, VT_SLOTID, 4) &&
|
|
VerifyField<uint8_t>(verifier, VT_INCLUDESELF, 1) &&
|
|
VerifyField<int32_t>(verifier, VT_SORTTYPE, 4) &&
|
|
VerifyField<uint32_t>(verifier, VT_ARRAYNUM, 4) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct TusGetFriendsVariableRequestBuilder {
|
|
typedef TusGetFriendsVariableRequest Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_slotId(int32_t slotId) {
|
|
fbb_.AddElement<int32_t>(TusGetFriendsVariableRequest::VT_SLOTID, slotId, 0);
|
|
}
|
|
void add_includeSelf(bool includeSelf) {
|
|
fbb_.AddElement<uint8_t>(TusGetFriendsVariableRequest::VT_INCLUDESELF, static_cast<uint8_t>(includeSelf), 0);
|
|
}
|
|
void add_sortType(int32_t sortType) {
|
|
fbb_.AddElement<int32_t>(TusGetFriendsVariableRequest::VT_SORTTYPE, sortType, 0);
|
|
}
|
|
void add_arrayNum(uint32_t arrayNum) {
|
|
fbb_.AddElement<uint32_t>(TusGetFriendsVariableRequest::VT_ARRAYNUM, arrayNum, 0);
|
|
}
|
|
explicit TusGetFriendsVariableRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<TusGetFriendsVariableRequest> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<TusGetFriendsVariableRequest>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<TusGetFriendsVariableRequest> CreateTusGetFriendsVariableRequest(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
int32_t slotId = 0,
|
|
bool includeSelf = false,
|
|
int32_t sortType = 0,
|
|
uint32_t arrayNum = 0) {
|
|
TusGetFriendsVariableRequestBuilder builder_(_fbb);
|
|
builder_.add_arrayNum(arrayNum);
|
|
builder_.add_sortType(sortType);
|
|
builder_.add_slotId(slotId);
|
|
builder_.add_includeSelf(includeSelf);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
struct TusAddAndGetVariableRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef TusAddAndGetVariableRequestBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_USER = 4,
|
|
VT_SLOTID = 6,
|
|
VT_INVARIABLE = 8,
|
|
VT_ISLASTCHANGEDDATE = 10,
|
|
VT_ISLASTCHANGEDAUTHORID = 12
|
|
};
|
|
const TusUser *user() const {
|
|
return GetPointer<const TusUser *>(VT_USER);
|
|
}
|
|
int32_t slotId() const {
|
|
return GetField<int32_t>(VT_SLOTID, 0);
|
|
}
|
|
int64_t inVariable() const {
|
|
return GetField<int64_t>(VT_INVARIABLE, 0);
|
|
}
|
|
const ::flatbuffers::Vector<uint64_t> *isLastChangedDate() const {
|
|
return GetPointer<const ::flatbuffers::Vector<uint64_t> *>(VT_ISLASTCHANGEDDATE);
|
|
}
|
|
const ::flatbuffers::String *isLastChangedAuthorId() const {
|
|
return GetPointer<const ::flatbuffers::String *>(VT_ISLASTCHANGEDAUTHORID);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_USER) &&
|
|
verifier.VerifyTable(user()) &&
|
|
VerifyField<int32_t>(verifier, VT_SLOTID, 4) &&
|
|
VerifyField<int64_t>(verifier, VT_INVARIABLE, 8) &&
|
|
VerifyOffset(verifier, VT_ISLASTCHANGEDDATE) &&
|
|
verifier.VerifyVector(isLastChangedDate()) &&
|
|
VerifyOffset(verifier, VT_ISLASTCHANGEDAUTHORID) &&
|
|
verifier.VerifyString(isLastChangedAuthorId()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct TusAddAndGetVariableRequestBuilder {
|
|
typedef TusAddAndGetVariableRequest Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_user(::flatbuffers::Offset<TusUser> user) {
|
|
fbb_.AddOffset(TusAddAndGetVariableRequest::VT_USER, user);
|
|
}
|
|
void add_slotId(int32_t slotId) {
|
|
fbb_.AddElement<int32_t>(TusAddAndGetVariableRequest::VT_SLOTID, slotId, 0);
|
|
}
|
|
void add_inVariable(int64_t inVariable) {
|
|
fbb_.AddElement<int64_t>(TusAddAndGetVariableRequest::VT_INVARIABLE, inVariable, 0);
|
|
}
|
|
void add_isLastChangedDate(::flatbuffers::Offset<::flatbuffers::Vector<uint64_t>> isLastChangedDate) {
|
|
fbb_.AddOffset(TusAddAndGetVariableRequest::VT_ISLASTCHANGEDDATE, isLastChangedDate);
|
|
}
|
|
void add_isLastChangedAuthorId(::flatbuffers::Offset<::flatbuffers::String> isLastChangedAuthorId) {
|
|
fbb_.AddOffset(TusAddAndGetVariableRequest::VT_ISLASTCHANGEDAUTHORID, isLastChangedAuthorId);
|
|
}
|
|
explicit TusAddAndGetVariableRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<TusAddAndGetVariableRequest> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<TusAddAndGetVariableRequest>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<TusAddAndGetVariableRequest> CreateTusAddAndGetVariableRequest(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<TusUser> user = 0,
|
|
int32_t slotId = 0,
|
|
int64_t inVariable = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<uint64_t>> isLastChangedDate = 0,
|
|
::flatbuffers::Offset<::flatbuffers::String> isLastChangedAuthorId = 0) {
|
|
TusAddAndGetVariableRequestBuilder builder_(_fbb);
|
|
builder_.add_inVariable(inVariable);
|
|
builder_.add_isLastChangedAuthorId(isLastChangedAuthorId);
|
|
builder_.add_isLastChangedDate(isLastChangedDate);
|
|
builder_.add_slotId(slotId);
|
|
builder_.add_user(user);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<TusAddAndGetVariableRequest> CreateTusAddAndGetVariableRequestDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<TusUser> user = 0,
|
|
int32_t slotId = 0,
|
|
int64_t inVariable = 0,
|
|
const std::vector<uint64_t> *isLastChangedDate = nullptr,
|
|
const char *isLastChangedAuthorId = nullptr) {
|
|
auto isLastChangedDate__ = isLastChangedDate ? _fbb.CreateVector<uint64_t>(*isLastChangedDate) : 0;
|
|
auto isLastChangedAuthorId__ = isLastChangedAuthorId ? _fbb.CreateString(isLastChangedAuthorId) : 0;
|
|
return CreateTusAddAndGetVariableRequest(
|
|
_fbb,
|
|
user,
|
|
slotId,
|
|
inVariable,
|
|
isLastChangedDate__,
|
|
isLastChangedAuthorId__);
|
|
}
|
|
|
|
struct TusTryAndSetVariableRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef TusTryAndSetVariableRequestBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_USER = 4,
|
|
VT_SLOTID = 6,
|
|
VT_OPETYPE = 8,
|
|
VT_VARIABLE = 10,
|
|
VT_ISLASTCHANGEDDATE = 12,
|
|
VT_ISLASTCHANGEDAUTHORID = 14,
|
|
VT_COMPAREVALUE = 16
|
|
};
|
|
const TusUser *user() const {
|
|
return GetPointer<const TusUser *>(VT_USER);
|
|
}
|
|
int32_t slotId() const {
|
|
return GetField<int32_t>(VT_SLOTID, 0);
|
|
}
|
|
int32_t opeType() const {
|
|
return GetField<int32_t>(VT_OPETYPE, 0);
|
|
}
|
|
int64_t variable() const {
|
|
return GetField<int64_t>(VT_VARIABLE, 0);
|
|
}
|
|
const ::flatbuffers::Vector<uint64_t> *isLastChangedDate() const {
|
|
return GetPointer<const ::flatbuffers::Vector<uint64_t> *>(VT_ISLASTCHANGEDDATE);
|
|
}
|
|
const ::flatbuffers::String *isLastChangedAuthorId() const {
|
|
return GetPointer<const ::flatbuffers::String *>(VT_ISLASTCHANGEDAUTHORID);
|
|
}
|
|
const ::flatbuffers::Vector<int64_t> *compareValue() const {
|
|
return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_COMPAREVALUE);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_USER) &&
|
|
verifier.VerifyTable(user()) &&
|
|
VerifyField<int32_t>(verifier, VT_SLOTID, 4) &&
|
|
VerifyField<int32_t>(verifier, VT_OPETYPE, 4) &&
|
|
VerifyField<int64_t>(verifier, VT_VARIABLE, 8) &&
|
|
VerifyOffset(verifier, VT_ISLASTCHANGEDDATE) &&
|
|
verifier.VerifyVector(isLastChangedDate()) &&
|
|
VerifyOffset(verifier, VT_ISLASTCHANGEDAUTHORID) &&
|
|
verifier.VerifyString(isLastChangedAuthorId()) &&
|
|
VerifyOffset(verifier, VT_COMPAREVALUE) &&
|
|
verifier.VerifyVector(compareValue()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct TusTryAndSetVariableRequestBuilder {
|
|
typedef TusTryAndSetVariableRequest Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_user(::flatbuffers::Offset<TusUser> user) {
|
|
fbb_.AddOffset(TusTryAndSetVariableRequest::VT_USER, user);
|
|
}
|
|
void add_slotId(int32_t slotId) {
|
|
fbb_.AddElement<int32_t>(TusTryAndSetVariableRequest::VT_SLOTID, slotId, 0);
|
|
}
|
|
void add_opeType(int32_t opeType) {
|
|
fbb_.AddElement<int32_t>(TusTryAndSetVariableRequest::VT_OPETYPE, opeType, 0);
|
|
}
|
|
void add_variable(int64_t variable) {
|
|
fbb_.AddElement<int64_t>(TusTryAndSetVariableRequest::VT_VARIABLE, variable, 0);
|
|
}
|
|
void add_isLastChangedDate(::flatbuffers::Offset<::flatbuffers::Vector<uint64_t>> isLastChangedDate) {
|
|
fbb_.AddOffset(TusTryAndSetVariableRequest::VT_ISLASTCHANGEDDATE, isLastChangedDate);
|
|
}
|
|
void add_isLastChangedAuthorId(::flatbuffers::Offset<::flatbuffers::String> isLastChangedAuthorId) {
|
|
fbb_.AddOffset(TusTryAndSetVariableRequest::VT_ISLASTCHANGEDAUTHORID, isLastChangedAuthorId);
|
|
}
|
|
void add_compareValue(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> compareValue) {
|
|
fbb_.AddOffset(TusTryAndSetVariableRequest::VT_COMPAREVALUE, compareValue);
|
|
}
|
|
explicit TusTryAndSetVariableRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<TusTryAndSetVariableRequest> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<TusTryAndSetVariableRequest>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<TusTryAndSetVariableRequest> CreateTusTryAndSetVariableRequest(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<TusUser> user = 0,
|
|
int32_t slotId = 0,
|
|
int32_t opeType = 0,
|
|
int64_t variable = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<uint64_t>> isLastChangedDate = 0,
|
|
::flatbuffers::Offset<::flatbuffers::String> isLastChangedAuthorId = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> compareValue = 0) {
|
|
TusTryAndSetVariableRequestBuilder builder_(_fbb);
|
|
builder_.add_variable(variable);
|
|
builder_.add_compareValue(compareValue);
|
|
builder_.add_isLastChangedAuthorId(isLastChangedAuthorId);
|
|
builder_.add_isLastChangedDate(isLastChangedDate);
|
|
builder_.add_opeType(opeType);
|
|
builder_.add_slotId(slotId);
|
|
builder_.add_user(user);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<TusTryAndSetVariableRequest> CreateTusTryAndSetVariableRequestDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<TusUser> user = 0,
|
|
int32_t slotId = 0,
|
|
int32_t opeType = 0,
|
|
int64_t variable = 0,
|
|
const std::vector<uint64_t> *isLastChangedDate = nullptr,
|
|
const char *isLastChangedAuthorId = nullptr,
|
|
const std::vector<int64_t> *compareValue = nullptr) {
|
|
auto isLastChangedDate__ = isLastChangedDate ? _fbb.CreateVector<uint64_t>(*isLastChangedDate) : 0;
|
|
auto isLastChangedAuthorId__ = isLastChangedAuthorId ? _fbb.CreateString(isLastChangedAuthorId) : 0;
|
|
auto compareValue__ = compareValue ? _fbb.CreateVector<int64_t>(*compareValue) : 0;
|
|
return CreateTusTryAndSetVariableRequest(
|
|
_fbb,
|
|
user,
|
|
slotId,
|
|
opeType,
|
|
variable,
|
|
isLastChangedDate__,
|
|
isLastChangedAuthorId__,
|
|
compareValue__);
|
|
}
|
|
|
|
struct TusDeleteMultiSlotVariableRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef TusDeleteMultiSlotVariableRequestBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_USER = 4,
|
|
VT_SLOTIDARRAY = 6
|
|
};
|
|
const TusUser *user() const {
|
|
return GetPointer<const TusUser *>(VT_USER);
|
|
}
|
|
const ::flatbuffers::Vector<int32_t> *slotIdArray() const {
|
|
return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_SLOTIDARRAY);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_USER) &&
|
|
verifier.VerifyTable(user()) &&
|
|
VerifyOffset(verifier, VT_SLOTIDARRAY) &&
|
|
verifier.VerifyVector(slotIdArray()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct TusDeleteMultiSlotVariableRequestBuilder {
|
|
typedef TusDeleteMultiSlotVariableRequest Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_user(::flatbuffers::Offset<TusUser> user) {
|
|
fbb_.AddOffset(TusDeleteMultiSlotVariableRequest::VT_USER, user);
|
|
}
|
|
void add_slotIdArray(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> slotIdArray) {
|
|
fbb_.AddOffset(TusDeleteMultiSlotVariableRequest::VT_SLOTIDARRAY, slotIdArray);
|
|
}
|
|
explicit TusDeleteMultiSlotVariableRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<TusDeleteMultiSlotVariableRequest> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<TusDeleteMultiSlotVariableRequest>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<TusDeleteMultiSlotVariableRequest> CreateTusDeleteMultiSlotVariableRequest(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<TusUser> user = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> slotIdArray = 0) {
|
|
TusDeleteMultiSlotVariableRequestBuilder builder_(_fbb);
|
|
builder_.add_slotIdArray(slotIdArray);
|
|
builder_.add_user(user);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<TusDeleteMultiSlotVariableRequest> CreateTusDeleteMultiSlotVariableRequestDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<TusUser> user = 0,
|
|
const std::vector<int32_t> *slotIdArray = nullptr) {
|
|
auto slotIdArray__ = slotIdArray ? _fbb.CreateVector<int32_t>(*slotIdArray) : 0;
|
|
return CreateTusDeleteMultiSlotVariableRequest(
|
|
_fbb,
|
|
user,
|
|
slotIdArray__);
|
|
}
|
|
|
|
struct TusSetDataRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef TusSetDataRequestBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_USER = 4,
|
|
VT_SLOTID = 6,
|
|
VT_DATA = 8,
|
|
VT_INFO = 10,
|
|
VT_ISLASTCHANGEDDATE = 12,
|
|
VT_ISLASTCHANGEDAUTHORID = 14
|
|
};
|
|
const TusUser *user() const {
|
|
return GetPointer<const TusUser *>(VT_USER);
|
|
}
|
|
int32_t slotId() const {
|
|
return GetField<int32_t>(VT_SLOTID, 0);
|
|
}
|
|
const ::flatbuffers::Vector<uint8_t> *data() const {
|
|
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_DATA);
|
|
}
|
|
const ::flatbuffers::Vector<uint8_t> *info() const {
|
|
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_INFO);
|
|
}
|
|
const ::flatbuffers::Vector<uint64_t> *isLastChangedDate() const {
|
|
return GetPointer<const ::flatbuffers::Vector<uint64_t> *>(VT_ISLASTCHANGEDDATE);
|
|
}
|
|
const ::flatbuffers::String *isLastChangedAuthorId() const {
|
|
return GetPointer<const ::flatbuffers::String *>(VT_ISLASTCHANGEDAUTHORID);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_USER) &&
|
|
verifier.VerifyTable(user()) &&
|
|
VerifyField<int32_t>(verifier, VT_SLOTID, 4) &&
|
|
VerifyOffset(verifier, VT_DATA) &&
|
|
verifier.VerifyVector(data()) &&
|
|
VerifyOffset(verifier, VT_INFO) &&
|
|
verifier.VerifyVector(info()) &&
|
|
VerifyOffset(verifier, VT_ISLASTCHANGEDDATE) &&
|
|
verifier.VerifyVector(isLastChangedDate()) &&
|
|
VerifyOffset(verifier, VT_ISLASTCHANGEDAUTHORID) &&
|
|
verifier.VerifyString(isLastChangedAuthorId()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct TusSetDataRequestBuilder {
|
|
typedef TusSetDataRequest Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_user(::flatbuffers::Offset<TusUser> user) {
|
|
fbb_.AddOffset(TusSetDataRequest::VT_USER, user);
|
|
}
|
|
void add_slotId(int32_t slotId) {
|
|
fbb_.AddElement<int32_t>(TusSetDataRequest::VT_SLOTID, slotId, 0);
|
|
}
|
|
void add_data(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data) {
|
|
fbb_.AddOffset(TusSetDataRequest::VT_DATA, data);
|
|
}
|
|
void add_info(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> info) {
|
|
fbb_.AddOffset(TusSetDataRequest::VT_INFO, info);
|
|
}
|
|
void add_isLastChangedDate(::flatbuffers::Offset<::flatbuffers::Vector<uint64_t>> isLastChangedDate) {
|
|
fbb_.AddOffset(TusSetDataRequest::VT_ISLASTCHANGEDDATE, isLastChangedDate);
|
|
}
|
|
void add_isLastChangedAuthorId(::flatbuffers::Offset<::flatbuffers::String> isLastChangedAuthorId) {
|
|
fbb_.AddOffset(TusSetDataRequest::VT_ISLASTCHANGEDAUTHORID, isLastChangedAuthorId);
|
|
}
|
|
explicit TusSetDataRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<TusSetDataRequest> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<TusSetDataRequest>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<TusSetDataRequest> CreateTusSetDataRequest(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<TusUser> user = 0,
|
|
int32_t slotId = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> info = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<uint64_t>> isLastChangedDate = 0,
|
|
::flatbuffers::Offset<::flatbuffers::String> isLastChangedAuthorId = 0) {
|
|
TusSetDataRequestBuilder builder_(_fbb);
|
|
builder_.add_isLastChangedAuthorId(isLastChangedAuthorId);
|
|
builder_.add_isLastChangedDate(isLastChangedDate);
|
|
builder_.add_info(info);
|
|
builder_.add_data(data);
|
|
builder_.add_slotId(slotId);
|
|
builder_.add_user(user);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<TusSetDataRequest> CreateTusSetDataRequestDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<TusUser> user = 0,
|
|
int32_t slotId = 0,
|
|
const std::vector<uint8_t> *data = nullptr,
|
|
const std::vector<uint8_t> *info = nullptr,
|
|
const std::vector<uint64_t> *isLastChangedDate = nullptr,
|
|
const char *isLastChangedAuthorId = nullptr) {
|
|
auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
|
|
auto info__ = info ? _fbb.CreateVector<uint8_t>(*info) : 0;
|
|
auto isLastChangedDate__ = isLastChangedDate ? _fbb.CreateVector<uint64_t>(*isLastChangedDate) : 0;
|
|
auto isLastChangedAuthorId__ = isLastChangedAuthorId ? _fbb.CreateString(isLastChangedAuthorId) : 0;
|
|
return CreateTusSetDataRequest(
|
|
_fbb,
|
|
user,
|
|
slotId,
|
|
data__,
|
|
info__,
|
|
isLastChangedDate__,
|
|
isLastChangedAuthorId__);
|
|
}
|
|
|
|
struct TusDataStatus FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef TusDataStatusBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_OWNERID = 4,
|
|
VT_HASDATA = 6,
|
|
VT_LASTCHANGEDDATE = 8,
|
|
VT_LASTCHANGEDAUTHORID = 10,
|
|
VT_INFO = 12
|
|
};
|
|
const ::flatbuffers::String *ownerId() const {
|
|
return GetPointer<const ::flatbuffers::String *>(VT_OWNERID);
|
|
}
|
|
bool hasData() const {
|
|
return GetField<uint8_t>(VT_HASDATA, 0) != 0;
|
|
}
|
|
uint64_t lastChangedDate() const {
|
|
return GetField<uint64_t>(VT_LASTCHANGEDDATE, 0);
|
|
}
|
|
const ::flatbuffers::String *lastChangedAuthorId() const {
|
|
return GetPointer<const ::flatbuffers::String *>(VT_LASTCHANGEDAUTHORID);
|
|
}
|
|
const ::flatbuffers::Vector<uint8_t> *info() const {
|
|
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_INFO);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_OWNERID) &&
|
|
verifier.VerifyString(ownerId()) &&
|
|
VerifyField<uint8_t>(verifier, VT_HASDATA, 1) &&
|
|
VerifyField<uint64_t>(verifier, VT_LASTCHANGEDDATE, 8) &&
|
|
VerifyOffset(verifier, VT_LASTCHANGEDAUTHORID) &&
|
|
verifier.VerifyString(lastChangedAuthorId()) &&
|
|
VerifyOffset(verifier, VT_INFO) &&
|
|
verifier.VerifyVector(info()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct TusDataStatusBuilder {
|
|
typedef TusDataStatus Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_ownerId(::flatbuffers::Offset<::flatbuffers::String> ownerId) {
|
|
fbb_.AddOffset(TusDataStatus::VT_OWNERID, ownerId);
|
|
}
|
|
void add_hasData(bool hasData) {
|
|
fbb_.AddElement<uint8_t>(TusDataStatus::VT_HASDATA, static_cast<uint8_t>(hasData), 0);
|
|
}
|
|
void add_lastChangedDate(uint64_t lastChangedDate) {
|
|
fbb_.AddElement<uint64_t>(TusDataStatus::VT_LASTCHANGEDDATE, lastChangedDate, 0);
|
|
}
|
|
void add_lastChangedAuthorId(::flatbuffers::Offset<::flatbuffers::String> lastChangedAuthorId) {
|
|
fbb_.AddOffset(TusDataStatus::VT_LASTCHANGEDAUTHORID, lastChangedAuthorId);
|
|
}
|
|
void add_info(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> info) {
|
|
fbb_.AddOffset(TusDataStatus::VT_INFO, info);
|
|
}
|
|
explicit TusDataStatusBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<TusDataStatus> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<TusDataStatus>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<TusDataStatus> CreateTusDataStatus(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<::flatbuffers::String> ownerId = 0,
|
|
bool hasData = false,
|
|
uint64_t lastChangedDate = 0,
|
|
::flatbuffers::Offset<::flatbuffers::String> lastChangedAuthorId = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> info = 0) {
|
|
TusDataStatusBuilder builder_(_fbb);
|
|
builder_.add_lastChangedDate(lastChangedDate);
|
|
builder_.add_info(info);
|
|
builder_.add_lastChangedAuthorId(lastChangedAuthorId);
|
|
builder_.add_ownerId(ownerId);
|
|
builder_.add_hasData(hasData);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<TusDataStatus> CreateTusDataStatusDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
const char *ownerId = nullptr,
|
|
bool hasData = false,
|
|
uint64_t lastChangedDate = 0,
|
|
const char *lastChangedAuthorId = nullptr,
|
|
const std::vector<uint8_t> *info = nullptr) {
|
|
auto ownerId__ = ownerId ? _fbb.CreateString(ownerId) : 0;
|
|
auto lastChangedAuthorId__ = lastChangedAuthorId ? _fbb.CreateString(lastChangedAuthorId) : 0;
|
|
auto info__ = info ? _fbb.CreateVector<uint8_t>(*info) : 0;
|
|
return CreateTusDataStatus(
|
|
_fbb,
|
|
ownerId__,
|
|
hasData,
|
|
lastChangedDate,
|
|
lastChangedAuthorId__,
|
|
info__);
|
|
}
|
|
|
|
struct TusData FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef TusDataBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_STATUS = 4,
|
|
VT_DATA = 6
|
|
};
|
|
const TusDataStatus *status() const {
|
|
return GetPointer<const TusDataStatus *>(VT_STATUS);
|
|
}
|
|
const ::flatbuffers::Vector<uint8_t> *data() const {
|
|
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_DATA);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_STATUS) &&
|
|
verifier.VerifyTable(status()) &&
|
|
VerifyOffset(verifier, VT_DATA) &&
|
|
verifier.VerifyVector(data()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct TusDataBuilder {
|
|
typedef TusData Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_status(::flatbuffers::Offset<TusDataStatus> status) {
|
|
fbb_.AddOffset(TusData::VT_STATUS, status);
|
|
}
|
|
void add_data(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data) {
|
|
fbb_.AddOffset(TusData::VT_DATA, data);
|
|
}
|
|
explicit TusDataBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<TusData> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<TusData>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<TusData> CreateTusData(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<TusDataStatus> status = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data = 0) {
|
|
TusDataBuilder builder_(_fbb);
|
|
builder_.add_data(data);
|
|
builder_.add_status(status);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<TusData> CreateTusDataDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<TusDataStatus> status = 0,
|
|
const std::vector<uint8_t> *data = nullptr) {
|
|
auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
|
|
return CreateTusData(
|
|
_fbb,
|
|
status,
|
|
data__);
|
|
}
|
|
|
|
struct TusDataStatusResponse FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef TusDataStatusResponseBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_STATUS = 4
|
|
};
|
|
const ::flatbuffers::Vector<::flatbuffers::Offset<TusDataStatus>> *status() const {
|
|
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<TusDataStatus>> *>(VT_STATUS);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_STATUS) &&
|
|
verifier.VerifyVector(status()) &&
|
|
verifier.VerifyVectorOfTables(status()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct TusDataStatusResponseBuilder {
|
|
typedef TusDataStatusResponse Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_status(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<TusDataStatus>>> status) {
|
|
fbb_.AddOffset(TusDataStatusResponse::VT_STATUS, status);
|
|
}
|
|
explicit TusDataStatusResponseBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<TusDataStatusResponse> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<TusDataStatusResponse>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<TusDataStatusResponse> CreateTusDataStatusResponse(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<TusDataStatus>>> status = 0) {
|
|
TusDataStatusResponseBuilder builder_(_fbb);
|
|
builder_.add_status(status);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<TusDataStatusResponse> CreateTusDataStatusResponseDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
const std::vector<::flatbuffers::Offset<TusDataStatus>> *status = nullptr) {
|
|
auto status__ = status ? _fbb.CreateVector<::flatbuffers::Offset<TusDataStatus>>(*status) : 0;
|
|
return CreateTusDataStatusResponse(
|
|
_fbb,
|
|
status__);
|
|
}
|
|
|
|
struct TusGetDataRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef TusGetDataRequestBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_USER = 4,
|
|
VT_SLOTID = 6
|
|
};
|
|
const TusUser *user() const {
|
|
return GetPointer<const TusUser *>(VT_USER);
|
|
}
|
|
int32_t slotId() const {
|
|
return GetField<int32_t>(VT_SLOTID, 0);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_USER) &&
|
|
verifier.VerifyTable(user()) &&
|
|
VerifyField<int32_t>(verifier, VT_SLOTID, 4) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct TusGetDataRequestBuilder {
|
|
typedef TusGetDataRequest Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_user(::flatbuffers::Offset<TusUser> user) {
|
|
fbb_.AddOffset(TusGetDataRequest::VT_USER, user);
|
|
}
|
|
void add_slotId(int32_t slotId) {
|
|
fbb_.AddElement<int32_t>(TusGetDataRequest::VT_SLOTID, slotId, 0);
|
|
}
|
|
explicit TusGetDataRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<TusGetDataRequest> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<TusGetDataRequest>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<TusGetDataRequest> CreateTusGetDataRequest(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<TusUser> user = 0,
|
|
int32_t slotId = 0) {
|
|
TusGetDataRequestBuilder builder_(_fbb);
|
|
builder_.add_slotId(slotId);
|
|
builder_.add_user(user);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
struct TusGetMultiSlotDataStatusRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef TusGetMultiSlotDataStatusRequestBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_USER = 4,
|
|
VT_SLOTIDARRAY = 6
|
|
};
|
|
const TusUser *user() const {
|
|
return GetPointer<const TusUser *>(VT_USER);
|
|
}
|
|
const ::flatbuffers::Vector<int32_t> *slotIdArray() const {
|
|
return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_SLOTIDARRAY);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_USER) &&
|
|
verifier.VerifyTable(user()) &&
|
|
VerifyOffset(verifier, VT_SLOTIDARRAY) &&
|
|
verifier.VerifyVector(slotIdArray()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct TusGetMultiSlotDataStatusRequestBuilder {
|
|
typedef TusGetMultiSlotDataStatusRequest Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_user(::flatbuffers::Offset<TusUser> user) {
|
|
fbb_.AddOffset(TusGetMultiSlotDataStatusRequest::VT_USER, user);
|
|
}
|
|
void add_slotIdArray(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> slotIdArray) {
|
|
fbb_.AddOffset(TusGetMultiSlotDataStatusRequest::VT_SLOTIDARRAY, slotIdArray);
|
|
}
|
|
explicit TusGetMultiSlotDataStatusRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<TusGetMultiSlotDataStatusRequest> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<TusGetMultiSlotDataStatusRequest>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<TusGetMultiSlotDataStatusRequest> CreateTusGetMultiSlotDataStatusRequest(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<TusUser> user = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> slotIdArray = 0) {
|
|
TusGetMultiSlotDataStatusRequestBuilder builder_(_fbb);
|
|
builder_.add_slotIdArray(slotIdArray);
|
|
builder_.add_user(user);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<TusGetMultiSlotDataStatusRequest> CreateTusGetMultiSlotDataStatusRequestDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<TusUser> user = 0,
|
|
const std::vector<int32_t> *slotIdArray = nullptr) {
|
|
auto slotIdArray__ = slotIdArray ? _fbb.CreateVector<int32_t>(*slotIdArray) : 0;
|
|
return CreateTusGetMultiSlotDataStatusRequest(
|
|
_fbb,
|
|
user,
|
|
slotIdArray__);
|
|
}
|
|
|
|
struct TusGetMultiUserDataStatusRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef TusGetMultiUserDataStatusRequestBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_USERS = 4,
|
|
VT_SLOTID = 6
|
|
};
|
|
const ::flatbuffers::Vector<::flatbuffers::Offset<TusUser>> *users() const {
|
|
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<TusUser>> *>(VT_USERS);
|
|
}
|
|
int32_t slotId() const {
|
|
return GetField<int32_t>(VT_SLOTID, 0);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_USERS) &&
|
|
verifier.VerifyVector(users()) &&
|
|
verifier.VerifyVectorOfTables(users()) &&
|
|
VerifyField<int32_t>(verifier, VT_SLOTID, 4) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct TusGetMultiUserDataStatusRequestBuilder {
|
|
typedef TusGetMultiUserDataStatusRequest Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_users(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<TusUser>>> users) {
|
|
fbb_.AddOffset(TusGetMultiUserDataStatusRequest::VT_USERS, users);
|
|
}
|
|
void add_slotId(int32_t slotId) {
|
|
fbb_.AddElement<int32_t>(TusGetMultiUserDataStatusRequest::VT_SLOTID, slotId, 0);
|
|
}
|
|
explicit TusGetMultiUserDataStatusRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<TusGetMultiUserDataStatusRequest> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<TusGetMultiUserDataStatusRequest>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<TusGetMultiUserDataStatusRequest> CreateTusGetMultiUserDataStatusRequest(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<TusUser>>> users = 0,
|
|
int32_t slotId = 0) {
|
|
TusGetMultiUserDataStatusRequestBuilder builder_(_fbb);
|
|
builder_.add_slotId(slotId);
|
|
builder_.add_users(users);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<TusGetMultiUserDataStatusRequest> CreateTusGetMultiUserDataStatusRequestDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
const std::vector<::flatbuffers::Offset<TusUser>> *users = nullptr,
|
|
int32_t slotId = 0) {
|
|
auto users__ = users ? _fbb.CreateVector<::flatbuffers::Offset<TusUser>>(*users) : 0;
|
|
return CreateTusGetMultiUserDataStatusRequest(
|
|
_fbb,
|
|
users__,
|
|
slotId);
|
|
}
|
|
|
|
struct TusGetFriendsDataStatusRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef TusGetFriendsDataStatusRequestBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_SLOTID = 4,
|
|
VT_INCLUDESELF = 6,
|
|
VT_SORTTYPE = 8,
|
|
VT_ARRAYNUM = 10
|
|
};
|
|
int32_t slotId() const {
|
|
return GetField<int32_t>(VT_SLOTID, 0);
|
|
}
|
|
bool includeSelf() const {
|
|
return GetField<uint8_t>(VT_INCLUDESELF, 0) != 0;
|
|
}
|
|
int32_t sortType() const {
|
|
return GetField<int32_t>(VT_SORTTYPE, 0);
|
|
}
|
|
uint32_t arrayNum() const {
|
|
return GetField<uint32_t>(VT_ARRAYNUM, 0);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<int32_t>(verifier, VT_SLOTID, 4) &&
|
|
VerifyField<uint8_t>(verifier, VT_INCLUDESELF, 1) &&
|
|
VerifyField<int32_t>(verifier, VT_SORTTYPE, 4) &&
|
|
VerifyField<uint32_t>(verifier, VT_ARRAYNUM, 4) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct TusGetFriendsDataStatusRequestBuilder {
|
|
typedef TusGetFriendsDataStatusRequest Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_slotId(int32_t slotId) {
|
|
fbb_.AddElement<int32_t>(TusGetFriendsDataStatusRequest::VT_SLOTID, slotId, 0);
|
|
}
|
|
void add_includeSelf(bool includeSelf) {
|
|
fbb_.AddElement<uint8_t>(TusGetFriendsDataStatusRequest::VT_INCLUDESELF, static_cast<uint8_t>(includeSelf), 0);
|
|
}
|
|
void add_sortType(int32_t sortType) {
|
|
fbb_.AddElement<int32_t>(TusGetFriendsDataStatusRequest::VT_SORTTYPE, sortType, 0);
|
|
}
|
|
void add_arrayNum(uint32_t arrayNum) {
|
|
fbb_.AddElement<uint32_t>(TusGetFriendsDataStatusRequest::VT_ARRAYNUM, arrayNum, 0);
|
|
}
|
|
explicit TusGetFriendsDataStatusRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<TusGetFriendsDataStatusRequest> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<TusGetFriendsDataStatusRequest>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<TusGetFriendsDataStatusRequest> CreateTusGetFriendsDataStatusRequest(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
int32_t slotId = 0,
|
|
bool includeSelf = false,
|
|
int32_t sortType = 0,
|
|
uint32_t arrayNum = 0) {
|
|
TusGetFriendsDataStatusRequestBuilder builder_(_fbb);
|
|
builder_.add_arrayNum(arrayNum);
|
|
builder_.add_sortType(sortType);
|
|
builder_.add_slotId(slotId);
|
|
builder_.add_includeSelf(includeSelf);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
struct TusDeleteMultiSlotDataRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef TusDeleteMultiSlotDataRequestBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_USER = 4,
|
|
VT_SLOTIDARRAY = 6
|
|
};
|
|
const TusUser *user() const {
|
|
return GetPointer<const TusUser *>(VT_USER);
|
|
}
|
|
const ::flatbuffers::Vector<int32_t> *slotIdArray() const {
|
|
return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_SLOTIDARRAY);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_USER) &&
|
|
verifier.VerifyTable(user()) &&
|
|
VerifyOffset(verifier, VT_SLOTIDARRAY) &&
|
|
verifier.VerifyVector(slotIdArray()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct TusDeleteMultiSlotDataRequestBuilder {
|
|
typedef TusDeleteMultiSlotDataRequest Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_user(::flatbuffers::Offset<TusUser> user) {
|
|
fbb_.AddOffset(TusDeleteMultiSlotDataRequest::VT_USER, user);
|
|
}
|
|
void add_slotIdArray(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> slotIdArray) {
|
|
fbb_.AddOffset(TusDeleteMultiSlotDataRequest::VT_SLOTIDARRAY, slotIdArray);
|
|
}
|
|
explicit TusDeleteMultiSlotDataRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<TusDeleteMultiSlotDataRequest> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<TusDeleteMultiSlotDataRequest>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<TusDeleteMultiSlotDataRequest> CreateTusDeleteMultiSlotDataRequest(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<TusUser> user = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> slotIdArray = 0) {
|
|
TusDeleteMultiSlotDataRequestBuilder builder_(_fbb);
|
|
builder_.add_slotIdArray(slotIdArray);
|
|
builder_.add_user(user);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<TusDeleteMultiSlotDataRequest> CreateTusDeleteMultiSlotDataRequestDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<TusUser> user = 0,
|
|
const std::vector<int32_t> *slotIdArray = nullptr) {
|
|
auto slotIdArray__ = slotIdArray ? _fbb.CreateVector<int32_t>(*slotIdArray) : 0;
|
|
return CreateTusDeleteMultiSlotDataRequest(
|
|
_fbb,
|
|
user,
|
|
slotIdArray__);
|
|
}
|
|
|
|
struct SetPresenceRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef SetPresenceRequestBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_TITLE = 4,
|
|
VT_STATUS = 6,
|
|
VT_COMMENT = 8,
|
|
VT_DATA = 10
|
|
};
|
|
const ::flatbuffers::String *title() const {
|
|
return GetPointer<const ::flatbuffers::String *>(VT_TITLE);
|
|
}
|
|
const ::flatbuffers::String *status() const {
|
|
return GetPointer<const ::flatbuffers::String *>(VT_STATUS);
|
|
}
|
|
const ::flatbuffers::String *comment() const {
|
|
return GetPointer<const ::flatbuffers::String *>(VT_COMMENT);
|
|
}
|
|
const ::flatbuffers::Vector<uint8_t> *data() const {
|
|
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_DATA);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_TITLE) &&
|
|
verifier.VerifyString(title()) &&
|
|
VerifyOffset(verifier, VT_STATUS) &&
|
|
verifier.VerifyString(status()) &&
|
|
VerifyOffset(verifier, VT_COMMENT) &&
|
|
verifier.VerifyString(comment()) &&
|
|
VerifyOffset(verifier, VT_DATA) &&
|
|
verifier.VerifyVector(data()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct SetPresenceRequestBuilder {
|
|
typedef SetPresenceRequest Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_title(::flatbuffers::Offset<::flatbuffers::String> title) {
|
|
fbb_.AddOffset(SetPresenceRequest::VT_TITLE, title);
|
|
}
|
|
void add_status(::flatbuffers::Offset<::flatbuffers::String> status) {
|
|
fbb_.AddOffset(SetPresenceRequest::VT_STATUS, status);
|
|
}
|
|
void add_comment(::flatbuffers::Offset<::flatbuffers::String> comment) {
|
|
fbb_.AddOffset(SetPresenceRequest::VT_COMMENT, comment);
|
|
}
|
|
void add_data(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data) {
|
|
fbb_.AddOffset(SetPresenceRequest::VT_DATA, data);
|
|
}
|
|
explicit SetPresenceRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<SetPresenceRequest> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<SetPresenceRequest>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<SetPresenceRequest> CreateSetPresenceRequest(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<::flatbuffers::String> title = 0,
|
|
::flatbuffers::Offset<::flatbuffers::String> status = 0,
|
|
::flatbuffers::Offset<::flatbuffers::String> comment = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data = 0) {
|
|
SetPresenceRequestBuilder builder_(_fbb);
|
|
builder_.add_data(data);
|
|
builder_.add_comment(comment);
|
|
builder_.add_status(status);
|
|
builder_.add_title(title);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<SetPresenceRequest> CreateSetPresenceRequestDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
const char *title = nullptr,
|
|
const char *status = nullptr,
|
|
const char *comment = nullptr,
|
|
const std::vector<uint8_t> *data = nullptr) {
|
|
auto title__ = title ? _fbb.CreateString(title) : 0;
|
|
auto status__ = status ? _fbb.CreateString(status) : 0;
|
|
auto comment__ = comment ? _fbb.CreateString(comment) : 0;
|
|
auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
|
|
return CreateSetPresenceRequest(
|
|
_fbb,
|
|
title__,
|
|
status__,
|
|
comment__,
|
|
data__);
|
|
}
|
|
|
|
struct MatchingSearchCondition FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef MatchingSearchConditionBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_ATTR_TYPE = 4,
|
|
VT_ATTR_ID = 6,
|
|
VT_COMP_OP = 8,
|
|
VT_COMP_VALUE = 10
|
|
};
|
|
uint32_t attr_type() const {
|
|
return GetField<uint32_t>(VT_ATTR_TYPE, 0);
|
|
}
|
|
uint32_t attr_id() const {
|
|
return GetField<uint32_t>(VT_ATTR_ID, 0);
|
|
}
|
|
uint32_t comp_op() const {
|
|
return GetField<uint32_t>(VT_COMP_OP, 0);
|
|
}
|
|
uint32_t comp_value() const {
|
|
return GetField<uint32_t>(VT_COMP_VALUE, 0);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<uint32_t>(verifier, VT_ATTR_TYPE, 4) &&
|
|
VerifyField<uint32_t>(verifier, VT_ATTR_ID, 4) &&
|
|
VerifyField<uint32_t>(verifier, VT_COMP_OP, 4) &&
|
|
VerifyField<uint32_t>(verifier, VT_COMP_VALUE, 4) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct MatchingSearchConditionBuilder {
|
|
typedef MatchingSearchCondition Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_attr_type(uint32_t attr_type) {
|
|
fbb_.AddElement<uint32_t>(MatchingSearchCondition::VT_ATTR_TYPE, attr_type, 0);
|
|
}
|
|
void add_attr_id(uint32_t attr_id) {
|
|
fbb_.AddElement<uint32_t>(MatchingSearchCondition::VT_ATTR_ID, attr_id, 0);
|
|
}
|
|
void add_comp_op(uint32_t comp_op) {
|
|
fbb_.AddElement<uint32_t>(MatchingSearchCondition::VT_COMP_OP, comp_op, 0);
|
|
}
|
|
void add_comp_value(uint32_t comp_value) {
|
|
fbb_.AddElement<uint32_t>(MatchingSearchCondition::VT_COMP_VALUE, comp_value, 0);
|
|
}
|
|
explicit MatchingSearchConditionBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<MatchingSearchCondition> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<MatchingSearchCondition>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<MatchingSearchCondition> CreateMatchingSearchCondition(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint32_t attr_type = 0,
|
|
uint32_t attr_id = 0,
|
|
uint32_t comp_op = 0,
|
|
uint32_t comp_value = 0) {
|
|
MatchingSearchConditionBuilder builder_(_fbb);
|
|
builder_.add_comp_value(comp_value);
|
|
builder_.add_comp_op(comp_op);
|
|
builder_.add_attr_id(attr_id);
|
|
builder_.add_attr_type(attr_type);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
struct MatchingAttr FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef MatchingAttrBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_ATTR_TYPE = 4,
|
|
VT_ATTR_ID = 6,
|
|
VT_NUM = 8,
|
|
VT_DATA = 10
|
|
};
|
|
uint32_t attr_type() const {
|
|
return GetField<uint32_t>(VT_ATTR_TYPE, 0);
|
|
}
|
|
uint32_t attr_id() const {
|
|
return GetField<uint32_t>(VT_ATTR_ID, 0);
|
|
}
|
|
uint32_t num() const {
|
|
return GetField<uint32_t>(VT_NUM, 0);
|
|
}
|
|
const ::flatbuffers::Vector<uint8_t> *data() const {
|
|
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_DATA);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<uint32_t>(verifier, VT_ATTR_TYPE, 4) &&
|
|
VerifyField<uint32_t>(verifier, VT_ATTR_ID, 4) &&
|
|
VerifyField<uint32_t>(verifier, VT_NUM, 4) &&
|
|
VerifyOffset(verifier, VT_DATA) &&
|
|
verifier.VerifyVector(data()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct MatchingAttrBuilder {
|
|
typedef MatchingAttr Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_attr_type(uint32_t attr_type) {
|
|
fbb_.AddElement<uint32_t>(MatchingAttr::VT_ATTR_TYPE, attr_type, 0);
|
|
}
|
|
void add_attr_id(uint32_t attr_id) {
|
|
fbb_.AddElement<uint32_t>(MatchingAttr::VT_ATTR_ID, attr_id, 0);
|
|
}
|
|
void add_num(uint32_t num) {
|
|
fbb_.AddElement<uint32_t>(MatchingAttr::VT_NUM, num, 0);
|
|
}
|
|
void add_data(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data) {
|
|
fbb_.AddOffset(MatchingAttr::VT_DATA, data);
|
|
}
|
|
explicit MatchingAttrBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<MatchingAttr> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<MatchingAttr>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<MatchingAttr> CreateMatchingAttr(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint32_t attr_type = 0,
|
|
uint32_t attr_id = 0,
|
|
uint32_t num = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data = 0) {
|
|
MatchingAttrBuilder builder_(_fbb);
|
|
builder_.add_data(data);
|
|
builder_.add_num(num);
|
|
builder_.add_attr_id(attr_id);
|
|
builder_.add_attr_type(attr_type);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<MatchingAttr> CreateMatchingAttrDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint32_t attr_type = 0,
|
|
uint32_t attr_id = 0,
|
|
uint32_t num = 0,
|
|
const std::vector<uint8_t> *data = nullptr) {
|
|
auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
|
|
return CreateMatchingAttr(
|
|
_fbb,
|
|
attr_type,
|
|
attr_id,
|
|
num,
|
|
data__);
|
|
}
|
|
|
|
struct CreateRoomGUIRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef CreateRoomGUIRequestBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_TOTAL_SLOTS = 4,
|
|
VT_PRIVATE_SLOTS = 6,
|
|
VT_PRIVILEGE_GRANT = 8,
|
|
VT_STEALTH = 10,
|
|
VT_GAME_ATTRS = 12
|
|
};
|
|
uint32_t total_slots() const {
|
|
return GetField<uint32_t>(VT_TOTAL_SLOTS, 0);
|
|
}
|
|
uint32_t private_slots() const {
|
|
return GetField<uint32_t>(VT_PRIVATE_SLOTS, 0);
|
|
}
|
|
bool privilege_grant() const {
|
|
return GetField<uint8_t>(VT_PRIVILEGE_GRANT, 0) != 0;
|
|
}
|
|
bool stealth() const {
|
|
return GetField<uint8_t>(VT_STEALTH, 0) != 0;
|
|
}
|
|
const ::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>> *game_attrs() const {
|
|
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>> *>(VT_GAME_ATTRS);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<uint32_t>(verifier, VT_TOTAL_SLOTS, 4) &&
|
|
VerifyField<uint32_t>(verifier, VT_PRIVATE_SLOTS, 4) &&
|
|
VerifyField<uint8_t>(verifier, VT_PRIVILEGE_GRANT, 1) &&
|
|
VerifyField<uint8_t>(verifier, VT_STEALTH, 1) &&
|
|
VerifyOffset(verifier, VT_GAME_ATTRS) &&
|
|
verifier.VerifyVector(game_attrs()) &&
|
|
verifier.VerifyVectorOfTables(game_attrs()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct CreateRoomGUIRequestBuilder {
|
|
typedef CreateRoomGUIRequest Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_total_slots(uint32_t total_slots) {
|
|
fbb_.AddElement<uint32_t>(CreateRoomGUIRequest::VT_TOTAL_SLOTS, total_slots, 0);
|
|
}
|
|
void add_private_slots(uint32_t private_slots) {
|
|
fbb_.AddElement<uint32_t>(CreateRoomGUIRequest::VT_PRIVATE_SLOTS, private_slots, 0);
|
|
}
|
|
void add_privilege_grant(bool privilege_grant) {
|
|
fbb_.AddElement<uint8_t>(CreateRoomGUIRequest::VT_PRIVILEGE_GRANT, static_cast<uint8_t>(privilege_grant), 0);
|
|
}
|
|
void add_stealth(bool stealth) {
|
|
fbb_.AddElement<uint8_t>(CreateRoomGUIRequest::VT_STEALTH, static_cast<uint8_t>(stealth), 0);
|
|
}
|
|
void add_game_attrs(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>>> game_attrs) {
|
|
fbb_.AddOffset(CreateRoomGUIRequest::VT_GAME_ATTRS, game_attrs);
|
|
}
|
|
explicit CreateRoomGUIRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<CreateRoomGUIRequest> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<CreateRoomGUIRequest>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<CreateRoomGUIRequest> CreateCreateRoomGUIRequest(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint32_t total_slots = 0,
|
|
uint32_t private_slots = 0,
|
|
bool privilege_grant = false,
|
|
bool stealth = false,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>>> game_attrs = 0) {
|
|
CreateRoomGUIRequestBuilder builder_(_fbb);
|
|
builder_.add_game_attrs(game_attrs);
|
|
builder_.add_private_slots(private_slots);
|
|
builder_.add_total_slots(total_slots);
|
|
builder_.add_stealth(stealth);
|
|
builder_.add_privilege_grant(privilege_grant);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<CreateRoomGUIRequest> CreateCreateRoomGUIRequestDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint32_t total_slots = 0,
|
|
uint32_t private_slots = 0,
|
|
bool privilege_grant = false,
|
|
bool stealth = false,
|
|
const std::vector<::flatbuffers::Offset<MatchingAttr>> *game_attrs = nullptr) {
|
|
auto game_attrs__ = game_attrs ? _fbb.CreateVector<::flatbuffers::Offset<MatchingAttr>>(*game_attrs) : 0;
|
|
return CreateCreateRoomGUIRequest(
|
|
_fbb,
|
|
total_slots,
|
|
private_slots,
|
|
privilege_grant,
|
|
stealth,
|
|
game_attrs__);
|
|
}
|
|
|
|
struct GUIUserInfo FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef GUIUserInfoBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_INFO = 4,
|
|
VT_OWNER = 6
|
|
};
|
|
const UserInfo *info() const {
|
|
return GetPointer<const UserInfo *>(VT_INFO);
|
|
}
|
|
bool owner() const {
|
|
return GetField<uint8_t>(VT_OWNER, 0) != 0;
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_INFO) &&
|
|
verifier.VerifyTable(info()) &&
|
|
VerifyField<uint8_t>(verifier, VT_OWNER, 1) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct GUIUserInfoBuilder {
|
|
typedef GUIUserInfo Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_info(::flatbuffers::Offset<UserInfo> info) {
|
|
fbb_.AddOffset(GUIUserInfo::VT_INFO, info);
|
|
}
|
|
void add_owner(bool owner) {
|
|
fbb_.AddElement<uint8_t>(GUIUserInfo::VT_OWNER, static_cast<uint8_t>(owner), 0);
|
|
}
|
|
explicit GUIUserInfoBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<GUIUserInfo> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<GUIUserInfo>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<GUIUserInfo> CreateGUIUserInfo(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<UserInfo> info = 0,
|
|
bool owner = false) {
|
|
GUIUserInfoBuilder builder_(_fbb);
|
|
builder_.add_info(info);
|
|
builder_.add_owner(owner);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
struct MatchingRoomStatus FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef MatchingRoomStatusBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_ID = 4,
|
|
VT_MEMBERS = 6,
|
|
VT_KICK_ACTOR = 8,
|
|
VT_OPT = 10
|
|
};
|
|
const ::flatbuffers::Vector<uint8_t> *id() const {
|
|
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_ID);
|
|
}
|
|
const ::flatbuffers::Vector<::flatbuffers::Offset<GUIUserInfo>> *members() const {
|
|
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<GUIUserInfo>> *>(VT_MEMBERS);
|
|
}
|
|
const ::flatbuffers::String *kick_actor() const {
|
|
return GetPointer<const ::flatbuffers::String *>(VT_KICK_ACTOR);
|
|
}
|
|
const ::flatbuffers::Vector<uint8_t> *opt() const {
|
|
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_OPT);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_ID) &&
|
|
verifier.VerifyVector(id()) &&
|
|
VerifyOffset(verifier, VT_MEMBERS) &&
|
|
verifier.VerifyVector(members()) &&
|
|
verifier.VerifyVectorOfTables(members()) &&
|
|
VerifyOffset(verifier, VT_KICK_ACTOR) &&
|
|
verifier.VerifyString(kick_actor()) &&
|
|
VerifyOffset(verifier, VT_OPT) &&
|
|
verifier.VerifyVector(opt()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct MatchingRoomStatusBuilder {
|
|
typedef MatchingRoomStatus Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_id(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> id) {
|
|
fbb_.AddOffset(MatchingRoomStatus::VT_ID, id);
|
|
}
|
|
void add_members(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<GUIUserInfo>>> members) {
|
|
fbb_.AddOffset(MatchingRoomStatus::VT_MEMBERS, members);
|
|
}
|
|
void add_kick_actor(::flatbuffers::Offset<::flatbuffers::String> kick_actor) {
|
|
fbb_.AddOffset(MatchingRoomStatus::VT_KICK_ACTOR, kick_actor);
|
|
}
|
|
void add_opt(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> opt) {
|
|
fbb_.AddOffset(MatchingRoomStatus::VT_OPT, opt);
|
|
}
|
|
explicit MatchingRoomStatusBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<MatchingRoomStatus> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<MatchingRoomStatus>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<MatchingRoomStatus> CreateMatchingRoomStatus(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> id = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<GUIUserInfo>>> members = 0,
|
|
::flatbuffers::Offset<::flatbuffers::String> kick_actor = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> opt = 0) {
|
|
MatchingRoomStatusBuilder builder_(_fbb);
|
|
builder_.add_opt(opt);
|
|
builder_.add_kick_actor(kick_actor);
|
|
builder_.add_members(members);
|
|
builder_.add_id(id);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<MatchingRoomStatus> CreateMatchingRoomStatusDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
const std::vector<uint8_t> *id = nullptr,
|
|
const std::vector<::flatbuffers::Offset<GUIUserInfo>> *members = nullptr,
|
|
const char *kick_actor = nullptr,
|
|
const std::vector<uint8_t> *opt = nullptr) {
|
|
auto id__ = id ? _fbb.CreateVector<uint8_t>(*id) : 0;
|
|
auto members__ = members ? _fbb.CreateVector<::flatbuffers::Offset<GUIUserInfo>>(*members) : 0;
|
|
auto kick_actor__ = kick_actor ? _fbb.CreateString(kick_actor) : 0;
|
|
auto opt__ = opt ? _fbb.CreateVector<uint8_t>(*opt) : 0;
|
|
return CreateMatchingRoomStatus(
|
|
_fbb,
|
|
id__,
|
|
members__,
|
|
kick_actor__,
|
|
opt__);
|
|
}
|
|
|
|
struct GetRoomListGUIRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef GetRoomListGUIRequestBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_RANGE_START = 4,
|
|
VT_RANGE_MAX = 6,
|
|
VT_CONDS = 8,
|
|
VT_ATTRS = 10
|
|
};
|
|
uint32_t range_start() const {
|
|
return GetField<uint32_t>(VT_RANGE_START, 0);
|
|
}
|
|
uint32_t range_max() const {
|
|
return GetField<uint32_t>(VT_RANGE_MAX, 0);
|
|
}
|
|
const ::flatbuffers::Vector<::flatbuffers::Offset<MatchingSearchCondition>> *conds() const {
|
|
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<MatchingSearchCondition>> *>(VT_CONDS);
|
|
}
|
|
const ::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>> *attrs() const {
|
|
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>> *>(VT_ATTRS);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<uint32_t>(verifier, VT_RANGE_START, 4) &&
|
|
VerifyField<uint32_t>(verifier, VT_RANGE_MAX, 4) &&
|
|
VerifyOffset(verifier, VT_CONDS) &&
|
|
verifier.VerifyVector(conds()) &&
|
|
verifier.VerifyVectorOfTables(conds()) &&
|
|
VerifyOffset(verifier, VT_ATTRS) &&
|
|
verifier.VerifyVector(attrs()) &&
|
|
verifier.VerifyVectorOfTables(attrs()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct GetRoomListGUIRequestBuilder {
|
|
typedef GetRoomListGUIRequest Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_range_start(uint32_t range_start) {
|
|
fbb_.AddElement<uint32_t>(GetRoomListGUIRequest::VT_RANGE_START, range_start, 0);
|
|
}
|
|
void add_range_max(uint32_t range_max) {
|
|
fbb_.AddElement<uint32_t>(GetRoomListGUIRequest::VT_RANGE_MAX, range_max, 0);
|
|
}
|
|
void add_conds(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MatchingSearchCondition>>> conds) {
|
|
fbb_.AddOffset(GetRoomListGUIRequest::VT_CONDS, conds);
|
|
}
|
|
void add_attrs(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>>> attrs) {
|
|
fbb_.AddOffset(GetRoomListGUIRequest::VT_ATTRS, attrs);
|
|
}
|
|
explicit GetRoomListGUIRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<GetRoomListGUIRequest> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<GetRoomListGUIRequest>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<GetRoomListGUIRequest> CreateGetRoomListGUIRequest(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint32_t range_start = 0,
|
|
uint32_t range_max = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MatchingSearchCondition>>> conds = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>>> attrs = 0) {
|
|
GetRoomListGUIRequestBuilder builder_(_fbb);
|
|
builder_.add_attrs(attrs);
|
|
builder_.add_conds(conds);
|
|
builder_.add_range_max(range_max);
|
|
builder_.add_range_start(range_start);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<GetRoomListGUIRequest> CreateGetRoomListGUIRequestDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint32_t range_start = 0,
|
|
uint32_t range_max = 0,
|
|
const std::vector<::flatbuffers::Offset<MatchingSearchCondition>> *conds = nullptr,
|
|
const std::vector<::flatbuffers::Offset<MatchingAttr>> *attrs = nullptr) {
|
|
auto conds__ = conds ? _fbb.CreateVector<::flatbuffers::Offset<MatchingSearchCondition>>(*conds) : 0;
|
|
auto attrs__ = attrs ? _fbb.CreateVector<::flatbuffers::Offset<MatchingAttr>>(*attrs) : 0;
|
|
return CreateGetRoomListGUIRequest(
|
|
_fbb,
|
|
range_start,
|
|
range_max,
|
|
conds__,
|
|
attrs__);
|
|
}
|
|
|
|
struct MatchingRoom FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef MatchingRoomBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_ID = 4,
|
|
VT_ATTR = 6
|
|
};
|
|
const ::flatbuffers::Vector<uint8_t> *id() const {
|
|
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_ID);
|
|
}
|
|
const ::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>> *attr() const {
|
|
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>> *>(VT_ATTR);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_ID) &&
|
|
verifier.VerifyVector(id()) &&
|
|
VerifyOffset(verifier, VT_ATTR) &&
|
|
verifier.VerifyVector(attr()) &&
|
|
verifier.VerifyVectorOfTables(attr()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct MatchingRoomBuilder {
|
|
typedef MatchingRoom Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_id(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> id) {
|
|
fbb_.AddOffset(MatchingRoom::VT_ID, id);
|
|
}
|
|
void add_attr(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>>> attr) {
|
|
fbb_.AddOffset(MatchingRoom::VT_ATTR, attr);
|
|
}
|
|
explicit MatchingRoomBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<MatchingRoom> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<MatchingRoom>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<MatchingRoom> CreateMatchingRoom(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> id = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>>> attr = 0) {
|
|
MatchingRoomBuilder builder_(_fbb);
|
|
builder_.add_attr(attr);
|
|
builder_.add_id(id);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<MatchingRoom> CreateMatchingRoomDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
const std::vector<uint8_t> *id = nullptr,
|
|
const std::vector<::flatbuffers::Offset<MatchingAttr>> *attr = nullptr) {
|
|
auto id__ = id ? _fbb.CreateVector<uint8_t>(*id) : 0;
|
|
auto attr__ = attr ? _fbb.CreateVector<::flatbuffers::Offset<MatchingAttr>>(*attr) : 0;
|
|
return CreateMatchingRoom(
|
|
_fbb,
|
|
id__,
|
|
attr__);
|
|
}
|
|
|
|
struct MatchingRoomList FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef MatchingRoomListBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_START = 4,
|
|
VT_TOTAL = 6,
|
|
VT_ROOMS = 8
|
|
};
|
|
uint32_t start() const {
|
|
return GetField<uint32_t>(VT_START, 0);
|
|
}
|
|
uint32_t total() const {
|
|
return GetField<uint32_t>(VT_TOTAL, 0);
|
|
}
|
|
const ::flatbuffers::Vector<::flatbuffers::Offset<MatchingRoom>> *rooms() const {
|
|
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<MatchingRoom>> *>(VT_ROOMS);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyField<uint32_t>(verifier, VT_START, 4) &&
|
|
VerifyField<uint32_t>(verifier, VT_TOTAL, 4) &&
|
|
VerifyOffset(verifier, VT_ROOMS) &&
|
|
verifier.VerifyVector(rooms()) &&
|
|
verifier.VerifyVectorOfTables(rooms()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct MatchingRoomListBuilder {
|
|
typedef MatchingRoomList Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_start(uint32_t start) {
|
|
fbb_.AddElement<uint32_t>(MatchingRoomList::VT_START, start, 0);
|
|
}
|
|
void add_total(uint32_t total) {
|
|
fbb_.AddElement<uint32_t>(MatchingRoomList::VT_TOTAL, total, 0);
|
|
}
|
|
void add_rooms(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MatchingRoom>>> rooms) {
|
|
fbb_.AddOffset(MatchingRoomList::VT_ROOMS, rooms);
|
|
}
|
|
explicit MatchingRoomListBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<MatchingRoomList> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<MatchingRoomList>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<MatchingRoomList> CreateMatchingRoomList(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint32_t start = 0,
|
|
uint32_t total = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MatchingRoom>>> rooms = 0) {
|
|
MatchingRoomListBuilder builder_(_fbb);
|
|
builder_.add_rooms(rooms);
|
|
builder_.add_total(total);
|
|
builder_.add_start(start);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<MatchingRoomList> CreateMatchingRoomListDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
uint32_t start = 0,
|
|
uint32_t total = 0,
|
|
const std::vector<::flatbuffers::Offset<MatchingRoom>> *rooms = nullptr) {
|
|
auto rooms__ = rooms ? _fbb.CreateVector<::flatbuffers::Offset<MatchingRoom>>(*rooms) : 0;
|
|
return CreateMatchingRoomList(
|
|
_fbb,
|
|
start,
|
|
total,
|
|
rooms__);
|
|
}
|
|
|
|
struct MatchingGuiRoomId FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef MatchingGuiRoomIdBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_ID = 4
|
|
};
|
|
const ::flatbuffers::Vector<uint8_t> *id() const {
|
|
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_ID);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_ID) &&
|
|
verifier.VerifyVector(id()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct MatchingGuiRoomIdBuilder {
|
|
typedef MatchingGuiRoomId Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_id(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> id) {
|
|
fbb_.AddOffset(MatchingGuiRoomId::VT_ID, id);
|
|
}
|
|
explicit MatchingGuiRoomIdBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<MatchingGuiRoomId> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<MatchingGuiRoomId>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<MatchingGuiRoomId> CreateMatchingGuiRoomId(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> id = 0) {
|
|
MatchingGuiRoomIdBuilder builder_(_fbb);
|
|
builder_.add_id(id);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<MatchingGuiRoomId> CreateMatchingGuiRoomIdDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
const std::vector<uint8_t> *id = nullptr) {
|
|
auto id__ = id ? _fbb.CreateVector<uint8_t>(*id) : 0;
|
|
return CreateMatchingGuiRoomId(
|
|
_fbb,
|
|
id__);
|
|
}
|
|
|
|
struct SetRoomSearchFlagGUI FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef SetRoomSearchFlagGUIBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_ROOMID = 4,
|
|
VT_STEALTH = 6
|
|
};
|
|
const ::flatbuffers::Vector<uint8_t> *roomid() const {
|
|
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_ROOMID);
|
|
}
|
|
bool stealth() const {
|
|
return GetField<uint8_t>(VT_STEALTH, 0) != 0;
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_ROOMID) &&
|
|
verifier.VerifyVector(roomid()) &&
|
|
VerifyField<uint8_t>(verifier, VT_STEALTH, 1) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct SetRoomSearchFlagGUIBuilder {
|
|
typedef SetRoomSearchFlagGUI Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_roomid(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> roomid) {
|
|
fbb_.AddOffset(SetRoomSearchFlagGUI::VT_ROOMID, roomid);
|
|
}
|
|
void add_stealth(bool stealth) {
|
|
fbb_.AddElement<uint8_t>(SetRoomSearchFlagGUI::VT_STEALTH, static_cast<uint8_t>(stealth), 0);
|
|
}
|
|
explicit SetRoomSearchFlagGUIBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<SetRoomSearchFlagGUI> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<SetRoomSearchFlagGUI>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<SetRoomSearchFlagGUI> CreateSetRoomSearchFlagGUI(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> roomid = 0,
|
|
bool stealth = false) {
|
|
SetRoomSearchFlagGUIBuilder builder_(_fbb);
|
|
builder_.add_roomid(roomid);
|
|
builder_.add_stealth(stealth);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<SetRoomSearchFlagGUI> CreateSetRoomSearchFlagGUIDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
const std::vector<uint8_t> *roomid = nullptr,
|
|
bool stealth = false) {
|
|
auto roomid__ = roomid ? _fbb.CreateVector<uint8_t>(*roomid) : 0;
|
|
return CreateSetRoomSearchFlagGUI(
|
|
_fbb,
|
|
roomid__,
|
|
stealth);
|
|
}
|
|
|
|
struct QuickMatchGUIRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef QuickMatchGUIRequestBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_CONDS = 4,
|
|
VT_AVAILABLE_NUM = 6
|
|
};
|
|
const ::flatbuffers::Vector<::flatbuffers::Offset<MatchingSearchCondition>> *conds() const {
|
|
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<MatchingSearchCondition>> *>(VT_CONDS);
|
|
}
|
|
uint32_t available_num() const {
|
|
return GetField<uint32_t>(VT_AVAILABLE_NUM, 0);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_CONDS) &&
|
|
verifier.VerifyVector(conds()) &&
|
|
verifier.VerifyVectorOfTables(conds()) &&
|
|
VerifyField<uint32_t>(verifier, VT_AVAILABLE_NUM, 4) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct QuickMatchGUIRequestBuilder {
|
|
typedef QuickMatchGUIRequest Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_conds(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MatchingSearchCondition>>> conds) {
|
|
fbb_.AddOffset(QuickMatchGUIRequest::VT_CONDS, conds);
|
|
}
|
|
void add_available_num(uint32_t available_num) {
|
|
fbb_.AddElement<uint32_t>(QuickMatchGUIRequest::VT_AVAILABLE_NUM, available_num, 0);
|
|
}
|
|
explicit QuickMatchGUIRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<QuickMatchGUIRequest> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<QuickMatchGUIRequest>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<QuickMatchGUIRequest> CreateQuickMatchGUIRequest(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MatchingSearchCondition>>> conds = 0,
|
|
uint32_t available_num = 0) {
|
|
QuickMatchGUIRequestBuilder builder_(_fbb);
|
|
builder_.add_available_num(available_num);
|
|
builder_.add_conds(conds);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<QuickMatchGUIRequest> CreateQuickMatchGUIRequestDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
const std::vector<::flatbuffers::Offset<MatchingSearchCondition>> *conds = nullptr,
|
|
uint32_t available_num = 0) {
|
|
auto conds__ = conds ? _fbb.CreateVector<::flatbuffers::Offset<MatchingSearchCondition>>(*conds) : 0;
|
|
return CreateQuickMatchGUIRequest(
|
|
_fbb,
|
|
conds__,
|
|
available_num);
|
|
}
|
|
|
|
struct SearchJoinRoomGUIRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef SearchJoinRoomGUIRequestBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_CONDS = 4,
|
|
VT_ATTRS = 6
|
|
};
|
|
const ::flatbuffers::Vector<::flatbuffers::Offset<MatchingSearchCondition>> *conds() const {
|
|
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<MatchingSearchCondition>> *>(VT_CONDS);
|
|
}
|
|
const ::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>> *attrs() const {
|
|
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>> *>(VT_ATTRS);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_CONDS) &&
|
|
verifier.VerifyVector(conds()) &&
|
|
verifier.VerifyVectorOfTables(conds()) &&
|
|
VerifyOffset(verifier, VT_ATTRS) &&
|
|
verifier.VerifyVector(attrs()) &&
|
|
verifier.VerifyVectorOfTables(attrs()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct SearchJoinRoomGUIRequestBuilder {
|
|
typedef SearchJoinRoomGUIRequest Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_conds(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MatchingSearchCondition>>> conds) {
|
|
fbb_.AddOffset(SearchJoinRoomGUIRequest::VT_CONDS, conds);
|
|
}
|
|
void add_attrs(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>>> attrs) {
|
|
fbb_.AddOffset(SearchJoinRoomGUIRequest::VT_ATTRS, attrs);
|
|
}
|
|
explicit SearchJoinRoomGUIRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<SearchJoinRoomGUIRequest> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<SearchJoinRoomGUIRequest>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<SearchJoinRoomGUIRequest> CreateSearchJoinRoomGUIRequest(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MatchingSearchCondition>>> conds = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>>> attrs = 0) {
|
|
SearchJoinRoomGUIRequestBuilder builder_(_fbb);
|
|
builder_.add_attrs(attrs);
|
|
builder_.add_conds(conds);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<SearchJoinRoomGUIRequest> CreateSearchJoinRoomGUIRequestDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
const std::vector<::flatbuffers::Offset<MatchingSearchCondition>> *conds = nullptr,
|
|
const std::vector<::flatbuffers::Offset<MatchingAttr>> *attrs = nullptr) {
|
|
auto conds__ = conds ? _fbb.CreateVector<::flatbuffers::Offset<MatchingSearchCondition>>(*conds) : 0;
|
|
auto attrs__ = attrs ? _fbb.CreateVector<::flatbuffers::Offset<MatchingAttr>>(*attrs) : 0;
|
|
return CreateSearchJoinRoomGUIRequest(
|
|
_fbb,
|
|
conds__,
|
|
attrs__);
|
|
}
|
|
|
|
struct MatchingSearchJoinRoomInfo FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
|
typedef MatchingSearchJoinRoomInfoBuilder Builder;
|
|
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
|
VT_ROOM = 4,
|
|
VT_ATTR = 6
|
|
};
|
|
const MatchingRoomStatus *room() const {
|
|
return GetPointer<const MatchingRoomStatus *>(VT_ROOM);
|
|
}
|
|
const ::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>> *attr() const {
|
|
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>> *>(VT_ATTR);
|
|
}
|
|
bool Verify(::flatbuffers::Verifier &verifier) const {
|
|
return VerifyTableStart(verifier) &&
|
|
VerifyOffset(verifier, VT_ROOM) &&
|
|
verifier.VerifyTable(room()) &&
|
|
VerifyOffset(verifier, VT_ATTR) &&
|
|
verifier.VerifyVector(attr()) &&
|
|
verifier.VerifyVectorOfTables(attr()) &&
|
|
verifier.EndTable();
|
|
}
|
|
};
|
|
|
|
struct MatchingSearchJoinRoomInfoBuilder {
|
|
typedef MatchingSearchJoinRoomInfo Table;
|
|
::flatbuffers::FlatBufferBuilder &fbb_;
|
|
::flatbuffers::uoffset_t start_;
|
|
void add_room(::flatbuffers::Offset<MatchingRoomStatus> room) {
|
|
fbb_.AddOffset(MatchingSearchJoinRoomInfo::VT_ROOM, room);
|
|
}
|
|
void add_attr(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>>> attr) {
|
|
fbb_.AddOffset(MatchingSearchJoinRoomInfo::VT_ATTR, attr);
|
|
}
|
|
explicit MatchingSearchJoinRoomInfoBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
|
: fbb_(_fbb) {
|
|
start_ = fbb_.StartTable();
|
|
}
|
|
::flatbuffers::Offset<MatchingSearchJoinRoomInfo> Finish() {
|
|
const auto end = fbb_.EndTable(start_);
|
|
auto o = ::flatbuffers::Offset<MatchingSearchJoinRoomInfo>(end);
|
|
return o;
|
|
}
|
|
};
|
|
|
|
inline ::flatbuffers::Offset<MatchingSearchJoinRoomInfo> CreateMatchingSearchJoinRoomInfo(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<MatchingRoomStatus> room = 0,
|
|
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MatchingAttr>>> attr = 0) {
|
|
MatchingSearchJoinRoomInfoBuilder builder_(_fbb);
|
|
builder_.add_attr(attr);
|
|
builder_.add_room(room);
|
|
return builder_.Finish();
|
|
}
|
|
|
|
inline ::flatbuffers::Offset<MatchingSearchJoinRoomInfo> CreateMatchingSearchJoinRoomInfoDirect(
|
|
::flatbuffers::FlatBufferBuilder &_fbb,
|
|
::flatbuffers::Offset<MatchingRoomStatus> room = 0,
|
|
const std::vector<::flatbuffers::Offset<MatchingAttr>> *attr = nullptr) {
|
|
auto attr__ = attr ? _fbb.CreateVector<::flatbuffers::Offset<MatchingAttr>>(*attr) : 0;
|
|
return CreateMatchingSearchJoinRoomInfo(
|
|
_fbb,
|
|
room,
|
|
attr__);
|
|
}
|
|
|
|
#endif // FLATBUFFERS_GENERATED_NP2STRUCTS_H_
|