mirror of
https://github.com/google/flatbuffers.git
synced 2026-06-02 04:04:19 +00:00
emit global scoped ::flatbuffers in c++ (#7764)
This commit is contained in:
Derek Bailey
File diff suppressed because it is too large
Load Diff
@@ -19,7 +19,7 @@ struct ScalarStuff;
|
||||
struct ScalarStuffBuilder;
|
||||
struct ScalarStuffT;
|
||||
|
||||
inline const flatbuffers::TypeTable *ScalarStuffTypeTable();
|
||||
inline const ::flatbuffers::TypeTable *ScalarStuffTypeTable();
|
||||
|
||||
enum class OptionalByte : int8_t {
|
||||
None = 0,
|
||||
@@ -49,56 +49,56 @@ inline const char * const *EnumNamesOptionalByte() {
|
||||
}
|
||||
|
||||
inline const char *EnumNameOptionalByte(OptionalByte e) {
|
||||
if (flatbuffers::IsOutRange(e, OptionalByte::None, OptionalByte::Two)) return "";
|
||||
if (::flatbuffers::IsOutRange(e, OptionalByte::None, OptionalByte::Two)) return "";
|
||||
const size_t index = static_cast<size_t>(e);
|
||||
return EnumNamesOptionalByte()[index];
|
||||
}
|
||||
|
||||
struct ScalarStuffT : public flatbuffers::NativeTable {
|
||||
struct ScalarStuffT : public ::flatbuffers::NativeTable {
|
||||
typedef ScalarStuff TableType;
|
||||
int8_t just_i8 = 0;
|
||||
flatbuffers::Optional<int8_t> maybe_i8 = flatbuffers::nullopt;
|
||||
::flatbuffers::Optional<int8_t> maybe_i8 = ::flatbuffers::nullopt;
|
||||
int8_t default_i8 = 42;
|
||||
uint8_t just_u8 = 0;
|
||||
flatbuffers::Optional<uint8_t> maybe_u8 = flatbuffers::nullopt;
|
||||
::flatbuffers::Optional<uint8_t> maybe_u8 = ::flatbuffers::nullopt;
|
||||
uint8_t default_u8 = 42;
|
||||
int16_t just_i16 = 0;
|
||||
flatbuffers::Optional<int16_t> maybe_i16 = flatbuffers::nullopt;
|
||||
::flatbuffers::Optional<int16_t> maybe_i16 = ::flatbuffers::nullopt;
|
||||
int16_t default_i16 = 42;
|
||||
uint16_t just_u16 = 0;
|
||||
flatbuffers::Optional<uint16_t> maybe_u16 = flatbuffers::nullopt;
|
||||
::flatbuffers::Optional<uint16_t> maybe_u16 = ::flatbuffers::nullopt;
|
||||
uint16_t default_u16 = 42;
|
||||
int32_t just_i32 = 0;
|
||||
flatbuffers::Optional<int32_t> maybe_i32 = flatbuffers::nullopt;
|
||||
::flatbuffers::Optional<int32_t> maybe_i32 = ::flatbuffers::nullopt;
|
||||
int32_t default_i32 = 42;
|
||||
uint32_t just_u32 = 0;
|
||||
flatbuffers::Optional<uint32_t> maybe_u32 = flatbuffers::nullopt;
|
||||
::flatbuffers::Optional<uint32_t> maybe_u32 = ::flatbuffers::nullopt;
|
||||
uint32_t default_u32 = 42;
|
||||
int64_t just_i64 = 0;
|
||||
flatbuffers::Optional<int64_t> maybe_i64 = flatbuffers::nullopt;
|
||||
::flatbuffers::Optional<int64_t> maybe_i64 = ::flatbuffers::nullopt;
|
||||
int64_t default_i64 = 42LL;
|
||||
uint64_t just_u64 = 0;
|
||||
flatbuffers::Optional<uint64_t> maybe_u64 = flatbuffers::nullopt;
|
||||
::flatbuffers::Optional<uint64_t> maybe_u64 = ::flatbuffers::nullopt;
|
||||
uint64_t default_u64 = 42ULL;
|
||||
float just_f32 = 0.0f;
|
||||
flatbuffers::Optional<float> maybe_f32 = flatbuffers::nullopt;
|
||||
::flatbuffers::Optional<float> maybe_f32 = ::flatbuffers::nullopt;
|
||||
float default_f32 = 42.0f;
|
||||
double just_f64 = 0.0;
|
||||
flatbuffers::Optional<double> maybe_f64 = flatbuffers::nullopt;
|
||||
::flatbuffers::Optional<double> maybe_f64 = ::flatbuffers::nullopt;
|
||||
double default_f64 = 42.0;
|
||||
bool just_bool = false;
|
||||
flatbuffers::Optional<bool> maybe_bool = flatbuffers::nullopt;
|
||||
::flatbuffers::Optional<bool> maybe_bool = ::flatbuffers::nullopt;
|
||||
bool default_bool = true;
|
||||
optional_scalars::OptionalByte just_enum = optional_scalars::OptionalByte::None;
|
||||
flatbuffers::Optional<optional_scalars::OptionalByte> maybe_enum = flatbuffers::nullopt;
|
||||
::flatbuffers::Optional<optional_scalars::OptionalByte> maybe_enum = ::flatbuffers::nullopt;
|
||||
optional_scalars::OptionalByte default_enum = optional_scalars::OptionalByte::One;
|
||||
};
|
||||
|
||||
struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
||||
struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
||||
typedef ScalarStuffT NativeTableType;
|
||||
typedef ScalarStuffBuilder Builder;
|
||||
struct Traits;
|
||||
static const flatbuffers::TypeTable *MiniReflectTypeTable() {
|
||||
static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
|
||||
return ScalarStuffTypeTable();
|
||||
}
|
||||
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
||||
@@ -145,7 +145,7 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
||||
bool mutate_just_i8(int8_t _just_i8 = 0) {
|
||||
return SetField<int8_t>(VT_JUST_I8, _just_i8, 0);
|
||||
}
|
||||
flatbuffers::Optional<int8_t> maybe_i8() const {
|
||||
::flatbuffers::Optional<int8_t> maybe_i8() const {
|
||||
return GetOptional<int8_t, int8_t>(VT_MAYBE_I8);
|
||||
}
|
||||
bool mutate_maybe_i8(int8_t _maybe_i8) {
|
||||
@@ -163,7 +163,7 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
||||
bool mutate_just_u8(uint8_t _just_u8 = 0) {
|
||||
return SetField<uint8_t>(VT_JUST_U8, _just_u8, 0);
|
||||
}
|
||||
flatbuffers::Optional<uint8_t> maybe_u8() const {
|
||||
::flatbuffers::Optional<uint8_t> maybe_u8() const {
|
||||
return GetOptional<uint8_t, uint8_t>(VT_MAYBE_U8);
|
||||
}
|
||||
bool mutate_maybe_u8(uint8_t _maybe_u8) {
|
||||
@@ -181,7 +181,7 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
||||
bool mutate_just_i16(int16_t _just_i16 = 0) {
|
||||
return SetField<int16_t>(VT_JUST_I16, _just_i16, 0);
|
||||
}
|
||||
flatbuffers::Optional<int16_t> maybe_i16() const {
|
||||
::flatbuffers::Optional<int16_t> maybe_i16() const {
|
||||
return GetOptional<int16_t, int16_t>(VT_MAYBE_I16);
|
||||
}
|
||||
bool mutate_maybe_i16(int16_t _maybe_i16) {
|
||||
@@ -199,7 +199,7 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
||||
bool mutate_just_u16(uint16_t _just_u16 = 0) {
|
||||
return SetField<uint16_t>(VT_JUST_U16, _just_u16, 0);
|
||||
}
|
||||
flatbuffers::Optional<uint16_t> maybe_u16() const {
|
||||
::flatbuffers::Optional<uint16_t> maybe_u16() const {
|
||||
return GetOptional<uint16_t, uint16_t>(VT_MAYBE_U16);
|
||||
}
|
||||
bool mutate_maybe_u16(uint16_t _maybe_u16) {
|
||||
@@ -217,7 +217,7 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
||||
bool mutate_just_i32(int32_t _just_i32 = 0) {
|
||||
return SetField<int32_t>(VT_JUST_I32, _just_i32, 0);
|
||||
}
|
||||
flatbuffers::Optional<int32_t> maybe_i32() const {
|
||||
::flatbuffers::Optional<int32_t> maybe_i32() const {
|
||||
return GetOptional<int32_t, int32_t>(VT_MAYBE_I32);
|
||||
}
|
||||
bool mutate_maybe_i32(int32_t _maybe_i32) {
|
||||
@@ -235,7 +235,7 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
||||
bool mutate_just_u32(uint32_t _just_u32 = 0) {
|
||||
return SetField<uint32_t>(VT_JUST_U32, _just_u32, 0);
|
||||
}
|
||||
flatbuffers::Optional<uint32_t> maybe_u32() const {
|
||||
::flatbuffers::Optional<uint32_t> maybe_u32() const {
|
||||
return GetOptional<uint32_t, uint32_t>(VT_MAYBE_U32);
|
||||
}
|
||||
bool mutate_maybe_u32(uint32_t _maybe_u32) {
|
||||
@@ -253,7 +253,7 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
||||
bool mutate_just_i64(int64_t _just_i64 = 0) {
|
||||
return SetField<int64_t>(VT_JUST_I64, _just_i64, 0);
|
||||
}
|
||||
flatbuffers::Optional<int64_t> maybe_i64() const {
|
||||
::flatbuffers::Optional<int64_t> maybe_i64() const {
|
||||
return GetOptional<int64_t, int64_t>(VT_MAYBE_I64);
|
||||
}
|
||||
bool mutate_maybe_i64(int64_t _maybe_i64) {
|
||||
@@ -271,7 +271,7 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
||||
bool mutate_just_u64(uint64_t _just_u64 = 0) {
|
||||
return SetField<uint64_t>(VT_JUST_U64, _just_u64, 0);
|
||||
}
|
||||
flatbuffers::Optional<uint64_t> maybe_u64() const {
|
||||
::flatbuffers::Optional<uint64_t> maybe_u64() const {
|
||||
return GetOptional<uint64_t, uint64_t>(VT_MAYBE_U64);
|
||||
}
|
||||
bool mutate_maybe_u64(uint64_t _maybe_u64) {
|
||||
@@ -289,7 +289,7 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
||||
bool mutate_just_f32(float _just_f32 = 0.0f) {
|
||||
return SetField<float>(VT_JUST_F32, _just_f32, 0.0f);
|
||||
}
|
||||
flatbuffers::Optional<float> maybe_f32() const {
|
||||
::flatbuffers::Optional<float> maybe_f32() const {
|
||||
return GetOptional<float, float>(VT_MAYBE_F32);
|
||||
}
|
||||
bool mutate_maybe_f32(float _maybe_f32) {
|
||||
@@ -307,7 +307,7 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
||||
bool mutate_just_f64(double _just_f64 = 0.0) {
|
||||
return SetField<double>(VT_JUST_F64, _just_f64, 0.0);
|
||||
}
|
||||
flatbuffers::Optional<double> maybe_f64() const {
|
||||
::flatbuffers::Optional<double> maybe_f64() const {
|
||||
return GetOptional<double, double>(VT_MAYBE_F64);
|
||||
}
|
||||
bool mutate_maybe_f64(double _maybe_f64) {
|
||||
@@ -325,7 +325,7 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
||||
bool mutate_just_bool(bool _just_bool = 0) {
|
||||
return SetField<uint8_t>(VT_JUST_BOOL, static_cast<uint8_t>(_just_bool), 0);
|
||||
}
|
||||
flatbuffers::Optional<bool> maybe_bool() const {
|
||||
::flatbuffers::Optional<bool> maybe_bool() const {
|
||||
return GetOptional<uint8_t, bool>(VT_MAYBE_BOOL);
|
||||
}
|
||||
bool mutate_maybe_bool(bool _maybe_bool) {
|
||||
@@ -343,7 +343,7 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
||||
bool mutate_just_enum(optional_scalars::OptionalByte _just_enum = static_cast<optional_scalars::OptionalByte>(0)) {
|
||||
return SetField<int8_t>(VT_JUST_ENUM, static_cast<int8_t>(_just_enum), 0);
|
||||
}
|
||||
flatbuffers::Optional<optional_scalars::OptionalByte> maybe_enum() const {
|
||||
::flatbuffers::Optional<optional_scalars::OptionalByte> maybe_enum() const {
|
||||
return GetOptional<int8_t, optional_scalars::OptionalByte>(VT_MAYBE_ENUM);
|
||||
}
|
||||
bool mutate_maybe_enum(optional_scalars::OptionalByte _maybe_enum) {
|
||||
@@ -395,7 +395,7 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
||||
else if constexpr (Index == 35) return default_enum();
|
||||
else static_assert(Index != Index, "Invalid Field Index");
|
||||
}
|
||||
bool Verify(flatbuffers::Verifier &verifier) const {
|
||||
bool Verify(::flatbuffers::Verifier &verifier) const {
|
||||
return VerifyTableStart(verifier) &&
|
||||
VerifyField<int8_t>(verifier, VT_JUST_I8, 1) &&
|
||||
VerifyField<int8_t>(verifier, VT_MAYBE_I8, 1) &&
|
||||
@@ -435,15 +435,15 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
||||
VerifyField<int8_t>(verifier, VT_DEFAULT_ENUM, 1) &&
|
||||
verifier.EndTable();
|
||||
}
|
||||
ScalarStuffT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
|
||||
void UnPackTo(ScalarStuffT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
|
||||
static flatbuffers::Offset<ScalarStuff> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ScalarStuffT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
|
||||
ScalarStuffT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
|
||||
void UnPackTo(ScalarStuffT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
|
||||
static ::flatbuffers::Offset<ScalarStuff> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ScalarStuffT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
|
||||
};
|
||||
|
||||
struct ScalarStuffBuilder {
|
||||
typedef ScalarStuff Table;
|
||||
flatbuffers::FlatBufferBuilder &fbb_;
|
||||
flatbuffers::uoffset_t start_;
|
||||
::flatbuffers::FlatBufferBuilder &fbb_;
|
||||
::flatbuffers::uoffset_t start_;
|
||||
void add_just_i8(int8_t just_i8) {
|
||||
fbb_.AddElement<int8_t>(ScalarStuff::VT_JUST_I8, just_i8, 0);
|
||||
}
|
||||
@@ -552,54 +552,54 @@ struct ScalarStuffBuilder {
|
||||
void add_default_enum(optional_scalars::OptionalByte default_enum) {
|
||||
fbb_.AddElement<int8_t>(ScalarStuff::VT_DEFAULT_ENUM, static_cast<int8_t>(default_enum), 1);
|
||||
}
|
||||
explicit ScalarStuffBuilder(flatbuffers::FlatBufferBuilder &_fbb)
|
||||
explicit ScalarStuffBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
||||
: fbb_(_fbb) {
|
||||
start_ = fbb_.StartTable();
|
||||
}
|
||||
flatbuffers::Offset<ScalarStuff> Finish() {
|
||||
::flatbuffers::Offset<ScalarStuff> Finish() {
|
||||
const auto end = fbb_.EndTable(start_);
|
||||
auto o = flatbuffers::Offset<ScalarStuff>(end);
|
||||
auto o = ::flatbuffers::Offset<ScalarStuff>(end);
|
||||
return o;
|
||||
}
|
||||
};
|
||||
|
||||
inline flatbuffers::Offset<ScalarStuff> CreateScalarStuff(
|
||||
flatbuffers::FlatBufferBuilder &_fbb,
|
||||
inline ::flatbuffers::Offset<ScalarStuff> CreateScalarStuff(
|
||||
::flatbuffers::FlatBufferBuilder &_fbb,
|
||||
int8_t just_i8 = 0,
|
||||
flatbuffers::Optional<int8_t> maybe_i8 = flatbuffers::nullopt,
|
||||
::flatbuffers::Optional<int8_t> maybe_i8 = ::flatbuffers::nullopt,
|
||||
int8_t default_i8 = 42,
|
||||
uint8_t just_u8 = 0,
|
||||
flatbuffers::Optional<uint8_t> maybe_u8 = flatbuffers::nullopt,
|
||||
::flatbuffers::Optional<uint8_t> maybe_u8 = ::flatbuffers::nullopt,
|
||||
uint8_t default_u8 = 42,
|
||||
int16_t just_i16 = 0,
|
||||
flatbuffers::Optional<int16_t> maybe_i16 = flatbuffers::nullopt,
|
||||
::flatbuffers::Optional<int16_t> maybe_i16 = ::flatbuffers::nullopt,
|
||||
int16_t default_i16 = 42,
|
||||
uint16_t just_u16 = 0,
|
||||
flatbuffers::Optional<uint16_t> maybe_u16 = flatbuffers::nullopt,
|
||||
::flatbuffers::Optional<uint16_t> maybe_u16 = ::flatbuffers::nullopt,
|
||||
uint16_t default_u16 = 42,
|
||||
int32_t just_i32 = 0,
|
||||
flatbuffers::Optional<int32_t> maybe_i32 = flatbuffers::nullopt,
|
||||
::flatbuffers::Optional<int32_t> maybe_i32 = ::flatbuffers::nullopt,
|
||||
int32_t default_i32 = 42,
|
||||
uint32_t just_u32 = 0,
|
||||
flatbuffers::Optional<uint32_t> maybe_u32 = flatbuffers::nullopt,
|
||||
::flatbuffers::Optional<uint32_t> maybe_u32 = ::flatbuffers::nullopt,
|
||||
uint32_t default_u32 = 42,
|
||||
int64_t just_i64 = 0,
|
||||
flatbuffers::Optional<int64_t> maybe_i64 = flatbuffers::nullopt,
|
||||
::flatbuffers::Optional<int64_t> maybe_i64 = ::flatbuffers::nullopt,
|
||||
int64_t default_i64 = 42LL,
|
||||
uint64_t just_u64 = 0,
|
||||
flatbuffers::Optional<uint64_t> maybe_u64 = flatbuffers::nullopt,
|
||||
::flatbuffers::Optional<uint64_t> maybe_u64 = ::flatbuffers::nullopt,
|
||||
uint64_t default_u64 = 42ULL,
|
||||
float just_f32 = 0.0f,
|
||||
flatbuffers::Optional<float> maybe_f32 = flatbuffers::nullopt,
|
||||
::flatbuffers::Optional<float> maybe_f32 = ::flatbuffers::nullopt,
|
||||
float default_f32 = 42.0f,
|
||||
double just_f64 = 0.0,
|
||||
flatbuffers::Optional<double> maybe_f64 = flatbuffers::nullopt,
|
||||
::flatbuffers::Optional<double> maybe_f64 = ::flatbuffers::nullopt,
|
||||
double default_f64 = 42.0,
|
||||
bool just_bool = false,
|
||||
flatbuffers::Optional<bool> maybe_bool = flatbuffers::nullopt,
|
||||
::flatbuffers::Optional<bool> maybe_bool = ::flatbuffers::nullopt,
|
||||
bool default_bool = true,
|
||||
optional_scalars::OptionalByte just_enum = optional_scalars::OptionalByte::None,
|
||||
flatbuffers::Optional<optional_scalars::OptionalByte> maybe_enum = flatbuffers::nullopt,
|
||||
::flatbuffers::Optional<optional_scalars::OptionalByte> maybe_enum = ::flatbuffers::nullopt,
|
||||
optional_scalars::OptionalByte default_enum = optional_scalars::OptionalByte::One) {
|
||||
ScalarStuffBuilder builder_(_fbb);
|
||||
builder_.add_default_f64(default_f64);
|
||||
@@ -689,15 +689,15 @@ struct ScalarStuff::Traits {
|
||||
using FieldType = decltype(std::declval<type>().get_field<Index>());
|
||||
};
|
||||
|
||||
flatbuffers::Offset<ScalarStuff> CreateScalarStuff(flatbuffers::FlatBufferBuilder &_fbb, const ScalarStuffT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
|
||||
::flatbuffers::Offset<ScalarStuff> CreateScalarStuff(::flatbuffers::FlatBufferBuilder &_fbb, const ScalarStuffT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
|
||||
|
||||
inline ScalarStuffT *ScalarStuff::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
|
||||
inline ScalarStuffT *ScalarStuff::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
|
||||
auto _o = std::make_unique<ScalarStuffT>();
|
||||
UnPackTo(_o.get(), _resolver);
|
||||
return _o.release();
|
||||
}
|
||||
|
||||
inline void ScalarStuff::UnPackTo(ScalarStuffT *_o, const flatbuffers::resolver_function_t *_resolver) const {
|
||||
inline void ScalarStuff::UnPackTo(ScalarStuffT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
|
||||
(void)_o;
|
||||
(void)_resolver;
|
||||
{ auto _e = just_i8(); _o->just_i8 = _e; }
|
||||
@@ -738,14 +738,14 @@ inline void ScalarStuff::UnPackTo(ScalarStuffT *_o, const flatbuffers::resolver_
|
||||
{ auto _e = default_enum(); _o->default_enum = _e; }
|
||||
}
|
||||
|
||||
inline flatbuffers::Offset<ScalarStuff> ScalarStuff::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ScalarStuffT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
|
||||
inline ::flatbuffers::Offset<ScalarStuff> ScalarStuff::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ScalarStuffT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
|
||||
return CreateScalarStuff(_fbb, _o, _rehasher);
|
||||
}
|
||||
|
||||
inline flatbuffers::Offset<ScalarStuff> CreateScalarStuff(flatbuffers::FlatBufferBuilder &_fbb, const ScalarStuffT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
|
||||
inline ::flatbuffers::Offset<ScalarStuff> CreateScalarStuff(::flatbuffers::FlatBufferBuilder &_fbb, const ScalarStuffT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
|
||||
(void)_rehasher;
|
||||
(void)_o;
|
||||
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ScalarStuffT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
|
||||
struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const ScalarStuffT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
|
||||
auto _just_i8 = _o->just_i8;
|
||||
auto _maybe_i8 = _o->maybe_i8;
|
||||
auto _default_i8 = _o->default_i8;
|
||||
@@ -822,13 +822,13 @@ inline flatbuffers::Offset<ScalarStuff> CreateScalarStuff(flatbuffers::FlatBuffe
|
||||
_default_enum);
|
||||
}
|
||||
|
||||
inline const flatbuffers::TypeTable *OptionalByteTypeTable() {
|
||||
static const flatbuffers::TypeCode type_codes[] = {
|
||||
{ flatbuffers::ET_CHAR, 0, 0 },
|
||||
{ flatbuffers::ET_CHAR, 0, 0 },
|
||||
{ flatbuffers::ET_CHAR, 0, 0 }
|
||||
inline const ::flatbuffers::TypeTable *OptionalByteTypeTable() {
|
||||
static const ::flatbuffers::TypeCode type_codes[] = {
|
||||
{ ::flatbuffers::ET_CHAR, 0, 0 },
|
||||
{ ::flatbuffers::ET_CHAR, 0, 0 },
|
||||
{ ::flatbuffers::ET_CHAR, 0, 0 }
|
||||
};
|
||||
static const flatbuffers::TypeFunction type_refs[] = {
|
||||
static const ::flatbuffers::TypeFunction type_refs[] = {
|
||||
optional_scalars::OptionalByteTypeTable
|
||||
};
|
||||
static const char * const names[] = {
|
||||
@@ -836,52 +836,52 @@ inline const flatbuffers::TypeTable *OptionalByteTypeTable() {
|
||||
"One",
|
||||
"Two"
|
||||
};
|
||||
static const flatbuffers::TypeTable tt = {
|
||||
flatbuffers::ST_ENUM, 3, type_codes, type_refs, nullptr, nullptr, names
|
||||
static const ::flatbuffers::TypeTable tt = {
|
||||
::flatbuffers::ST_ENUM, 3, type_codes, type_refs, nullptr, nullptr, names
|
||||
};
|
||||
return &tt;
|
||||
}
|
||||
|
||||
inline const flatbuffers::TypeTable *ScalarStuffTypeTable() {
|
||||
static const flatbuffers::TypeCode type_codes[] = {
|
||||
{ flatbuffers::ET_CHAR, 0, -1 },
|
||||
{ flatbuffers::ET_CHAR, 0, -1 },
|
||||
{ flatbuffers::ET_CHAR, 0, -1 },
|
||||
{ flatbuffers::ET_UCHAR, 0, -1 },
|
||||
{ flatbuffers::ET_UCHAR, 0, -1 },
|
||||
{ flatbuffers::ET_UCHAR, 0, -1 },
|
||||
{ flatbuffers::ET_SHORT, 0, -1 },
|
||||
{ flatbuffers::ET_SHORT, 0, -1 },
|
||||
{ flatbuffers::ET_SHORT, 0, -1 },
|
||||
{ flatbuffers::ET_USHORT, 0, -1 },
|
||||
{ flatbuffers::ET_USHORT, 0, -1 },
|
||||
{ flatbuffers::ET_USHORT, 0, -1 },
|
||||
{ flatbuffers::ET_INT, 0, -1 },
|
||||
{ flatbuffers::ET_INT, 0, -1 },
|
||||
{ flatbuffers::ET_INT, 0, -1 },
|
||||
{ flatbuffers::ET_UINT, 0, -1 },
|
||||
{ flatbuffers::ET_UINT, 0, -1 },
|
||||
{ flatbuffers::ET_UINT, 0, -1 },
|
||||
{ flatbuffers::ET_LONG, 0, -1 },
|
||||
{ flatbuffers::ET_LONG, 0, -1 },
|
||||
{ flatbuffers::ET_LONG, 0, -1 },
|
||||
{ flatbuffers::ET_ULONG, 0, -1 },
|
||||
{ flatbuffers::ET_ULONG, 0, -1 },
|
||||
{ flatbuffers::ET_ULONG, 0, -1 },
|
||||
{ flatbuffers::ET_FLOAT, 0, -1 },
|
||||
{ flatbuffers::ET_FLOAT, 0, -1 },
|
||||
{ flatbuffers::ET_FLOAT, 0, -1 },
|
||||
{ flatbuffers::ET_DOUBLE, 0, -1 },
|
||||
{ flatbuffers::ET_DOUBLE, 0, -1 },
|
||||
{ flatbuffers::ET_DOUBLE, 0, -1 },
|
||||
{ flatbuffers::ET_BOOL, 0, -1 },
|
||||
{ flatbuffers::ET_BOOL, 0, -1 },
|
||||
{ flatbuffers::ET_BOOL, 0, -1 },
|
||||
{ flatbuffers::ET_CHAR, 0, 0 },
|
||||
{ flatbuffers::ET_CHAR, 0, 0 },
|
||||
{ flatbuffers::ET_CHAR, 0, 0 }
|
||||
inline const ::flatbuffers::TypeTable *ScalarStuffTypeTable() {
|
||||
static const ::flatbuffers::TypeCode type_codes[] = {
|
||||
{ ::flatbuffers::ET_CHAR, 0, -1 },
|
||||
{ ::flatbuffers::ET_CHAR, 0, -1 },
|
||||
{ ::flatbuffers::ET_CHAR, 0, -1 },
|
||||
{ ::flatbuffers::ET_UCHAR, 0, -1 },
|
||||
{ ::flatbuffers::ET_UCHAR, 0, -1 },
|
||||
{ ::flatbuffers::ET_UCHAR, 0, -1 },
|
||||
{ ::flatbuffers::ET_SHORT, 0, -1 },
|
||||
{ ::flatbuffers::ET_SHORT, 0, -1 },
|
||||
{ ::flatbuffers::ET_SHORT, 0, -1 },
|
||||
{ ::flatbuffers::ET_USHORT, 0, -1 },
|
||||
{ ::flatbuffers::ET_USHORT, 0, -1 },
|
||||
{ ::flatbuffers::ET_USHORT, 0, -1 },
|
||||
{ ::flatbuffers::ET_INT, 0, -1 },
|
||||
{ ::flatbuffers::ET_INT, 0, -1 },
|
||||
{ ::flatbuffers::ET_INT, 0, -1 },
|
||||
{ ::flatbuffers::ET_UINT, 0, -1 },
|
||||
{ ::flatbuffers::ET_UINT, 0, -1 },
|
||||
{ ::flatbuffers::ET_UINT, 0, -1 },
|
||||
{ ::flatbuffers::ET_LONG, 0, -1 },
|
||||
{ ::flatbuffers::ET_LONG, 0, -1 },
|
||||
{ ::flatbuffers::ET_LONG, 0, -1 },
|
||||
{ ::flatbuffers::ET_ULONG, 0, -1 },
|
||||
{ ::flatbuffers::ET_ULONG, 0, -1 },
|
||||
{ ::flatbuffers::ET_ULONG, 0, -1 },
|
||||
{ ::flatbuffers::ET_FLOAT, 0, -1 },
|
||||
{ ::flatbuffers::ET_FLOAT, 0, -1 },
|
||||
{ ::flatbuffers::ET_FLOAT, 0, -1 },
|
||||
{ ::flatbuffers::ET_DOUBLE, 0, -1 },
|
||||
{ ::flatbuffers::ET_DOUBLE, 0, -1 },
|
||||
{ ::flatbuffers::ET_DOUBLE, 0, -1 },
|
||||
{ ::flatbuffers::ET_BOOL, 0, -1 },
|
||||
{ ::flatbuffers::ET_BOOL, 0, -1 },
|
||||
{ ::flatbuffers::ET_BOOL, 0, -1 },
|
||||
{ ::flatbuffers::ET_CHAR, 0, 0 },
|
||||
{ ::flatbuffers::ET_CHAR, 0, 0 },
|
||||
{ ::flatbuffers::ET_CHAR, 0, 0 }
|
||||
};
|
||||
static const flatbuffers::TypeFunction type_refs[] = {
|
||||
static const ::flatbuffers::TypeFunction type_refs[] = {
|
||||
optional_scalars::OptionalByteTypeTable
|
||||
};
|
||||
static const char * const names[] = {
|
||||
@@ -922,26 +922,26 @@ inline const flatbuffers::TypeTable *ScalarStuffTypeTable() {
|
||||
"maybe_enum",
|
||||
"default_enum"
|
||||
};
|
||||
static const flatbuffers::TypeTable tt = {
|
||||
flatbuffers::ST_TABLE, 36, type_codes, type_refs, nullptr, nullptr, names
|
||||
static const ::flatbuffers::TypeTable tt = {
|
||||
::flatbuffers::ST_TABLE, 36, type_codes, type_refs, nullptr, nullptr, names
|
||||
};
|
||||
return &tt;
|
||||
}
|
||||
|
||||
inline const optional_scalars::ScalarStuff *GetScalarStuff(const void *buf) {
|
||||
return flatbuffers::GetRoot<optional_scalars::ScalarStuff>(buf);
|
||||
return ::flatbuffers::GetRoot<optional_scalars::ScalarStuff>(buf);
|
||||
}
|
||||
|
||||
inline const optional_scalars::ScalarStuff *GetSizePrefixedScalarStuff(const void *buf) {
|
||||
return flatbuffers::GetSizePrefixedRoot<optional_scalars::ScalarStuff>(buf);
|
||||
return ::flatbuffers::GetSizePrefixedRoot<optional_scalars::ScalarStuff>(buf);
|
||||
}
|
||||
|
||||
inline ScalarStuff *GetMutableScalarStuff(void *buf) {
|
||||
return flatbuffers::GetMutableRoot<ScalarStuff>(buf);
|
||||
return ::flatbuffers::GetMutableRoot<ScalarStuff>(buf);
|
||||
}
|
||||
|
||||
inline optional_scalars::ScalarStuff *GetMutableSizePrefixedScalarStuff(void *buf) {
|
||||
return flatbuffers::GetMutableSizePrefixedRoot<optional_scalars::ScalarStuff>(buf);
|
||||
return ::flatbuffers::GetMutableSizePrefixedRoot<optional_scalars::ScalarStuff>(buf);
|
||||
}
|
||||
|
||||
inline const char *ScalarStuffIdentifier() {
|
||||
@@ -949,22 +949,22 @@ inline const char *ScalarStuffIdentifier() {
|
||||
}
|
||||
|
||||
inline bool ScalarStuffBufferHasIdentifier(const void *buf) {
|
||||
return flatbuffers::BufferHasIdentifier(
|
||||
return ::flatbuffers::BufferHasIdentifier(
|
||||
buf, ScalarStuffIdentifier());
|
||||
}
|
||||
|
||||
inline bool SizePrefixedScalarStuffBufferHasIdentifier(const void *buf) {
|
||||
return flatbuffers::BufferHasIdentifier(
|
||||
return ::flatbuffers::BufferHasIdentifier(
|
||||
buf, ScalarStuffIdentifier(), true);
|
||||
}
|
||||
|
||||
inline bool VerifyScalarStuffBuffer(
|
||||
flatbuffers::Verifier &verifier) {
|
||||
::flatbuffers::Verifier &verifier) {
|
||||
return verifier.VerifyBuffer<optional_scalars::ScalarStuff>(ScalarStuffIdentifier());
|
||||
}
|
||||
|
||||
inline bool VerifySizePrefixedScalarStuffBuffer(
|
||||
flatbuffers::Verifier &verifier) {
|
||||
::flatbuffers::Verifier &verifier) {
|
||||
return verifier.VerifySizePrefixedBuffer<optional_scalars::ScalarStuff>(ScalarStuffIdentifier());
|
||||
}
|
||||
|
||||
@@ -973,26 +973,26 @@ inline const char *ScalarStuffExtension() {
|
||||
}
|
||||
|
||||
inline void FinishScalarStuffBuffer(
|
||||
flatbuffers::FlatBufferBuilder &fbb,
|
||||
flatbuffers::Offset<optional_scalars::ScalarStuff> root) {
|
||||
::flatbuffers::FlatBufferBuilder &fbb,
|
||||
::flatbuffers::Offset<optional_scalars::ScalarStuff> root) {
|
||||
fbb.Finish(root, ScalarStuffIdentifier());
|
||||
}
|
||||
|
||||
inline void FinishSizePrefixedScalarStuffBuffer(
|
||||
flatbuffers::FlatBufferBuilder &fbb,
|
||||
flatbuffers::Offset<optional_scalars::ScalarStuff> root) {
|
||||
::flatbuffers::FlatBufferBuilder &fbb,
|
||||
::flatbuffers::Offset<optional_scalars::ScalarStuff> root) {
|
||||
fbb.FinishSizePrefixed(root, ScalarStuffIdentifier());
|
||||
}
|
||||
|
||||
inline std::unique_ptr<optional_scalars::ScalarStuffT> UnPackScalarStuff(
|
||||
const void *buf,
|
||||
const flatbuffers::resolver_function_t *res = nullptr) {
|
||||
const ::flatbuffers::resolver_function_t *res = nullptr) {
|
||||
return std::unique_ptr<optional_scalars::ScalarStuffT>(GetScalarStuff(buf)->UnPack(res));
|
||||
}
|
||||
|
||||
inline std::unique_ptr<optional_scalars::ScalarStuffT> UnPackSizePrefixedScalarStuff(
|
||||
const void *buf,
|
||||
const flatbuffers::resolver_function_t *res = nullptr) {
|
||||
const ::flatbuffers::resolver_function_t *res = nullptr) {
|
||||
return std::unique_ptr<optional_scalars::ScalarStuffT>(GetSizePrefixedScalarStuff(buf)->UnPack(res));
|
||||
}
|
||||
|
||||
|
||||
@@ -31,17 +31,17 @@ struct Movie;
|
||||
struct MovieBuilder;
|
||||
struct MovieT;
|
||||
|
||||
inline const flatbuffers::TypeTable *AttackerTypeTable();
|
||||
inline const ::flatbuffers::TypeTable *AttackerTypeTable();
|
||||
|
||||
inline const flatbuffers::TypeTable *RapunzelTypeTable();
|
||||
inline const ::flatbuffers::TypeTable *RapunzelTypeTable();
|
||||
|
||||
inline const flatbuffers::TypeTable *BookReaderTypeTable();
|
||||
inline const ::flatbuffers::TypeTable *BookReaderTypeTable();
|
||||
|
||||
inline const flatbuffers::TypeTable *FallingTubTypeTable();
|
||||
inline const ::flatbuffers::TypeTable *FallingTubTypeTable();
|
||||
|
||||
inline const flatbuffers::TypeTable *HandFanTypeTable();
|
||||
inline const ::flatbuffers::TypeTable *HandFanTypeTable();
|
||||
|
||||
inline const flatbuffers::TypeTable *MovieTypeTable();
|
||||
inline const ::flatbuffers::TypeTable *MovieTypeTable();
|
||||
|
||||
enum class Character : uint8_t {
|
||||
NONE = 0,
|
||||
@@ -83,7 +83,7 @@ inline const char * const *EnumNamesCharacter() {
|
||||
}
|
||||
|
||||
inline const char *EnumNameCharacter(Character e) {
|
||||
if (flatbuffers::IsOutRange(e, Character::NONE, Character::Unused)) return "";
|
||||
if (::flatbuffers::IsOutRange(e, Character::NONE, Character::Unused)) return "";
|
||||
const size_t index = static_cast<size_t>(e);
|
||||
return EnumNamesCharacter()[index];
|
||||
}
|
||||
@@ -105,8 +105,8 @@ struct CharacterUnion {
|
||||
|
||||
void Reset();
|
||||
|
||||
static void *UnPack(const void *obj, Character type, const flatbuffers::resolver_function_t *resolver);
|
||||
flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
|
||||
static void *UnPack(const void *obj, Character type, const ::flatbuffers::resolver_function_t *resolver);
|
||||
::flatbuffers::Offset<void> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
|
||||
|
||||
AttackerT *AsMuLan() {
|
||||
return type == Character::MuLan ?
|
||||
@@ -158,8 +158,8 @@ struct CharacterUnion {
|
||||
}
|
||||
};
|
||||
|
||||
bool VerifyCharacter(flatbuffers::Verifier &verifier, const void *obj, Character type);
|
||||
bool VerifyCharacterVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<Character> *types);
|
||||
bool VerifyCharacter(::flatbuffers::Verifier &verifier, const void *obj, Character type);
|
||||
bool VerifyCharacterVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Character> *types);
|
||||
|
||||
enum class Gadget : uint8_t {
|
||||
NONE = 0,
|
||||
@@ -189,7 +189,7 @@ inline const char * const *EnumNamesGadget() {
|
||||
}
|
||||
|
||||
inline const char *EnumNameGadget(Gadget e) {
|
||||
if (flatbuffers::IsOutRange(e, Gadget::NONE, Gadget::HandFan)) return "";
|
||||
if (::flatbuffers::IsOutRange(e, Gadget::NONE, Gadget::HandFan)) return "";
|
||||
const size_t index = static_cast<size_t>(e);
|
||||
return EnumNamesGadget()[index];
|
||||
}
|
||||
@@ -245,8 +245,8 @@ struct GadgetUnion {
|
||||
}
|
||||
}
|
||||
|
||||
static void *UnPack(const void *obj, Gadget type, const flatbuffers::resolver_function_t *resolver);
|
||||
flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
|
||||
static void *UnPack(const void *obj, Gadget type, const ::flatbuffers::resolver_function_t *resolver);
|
||||
::flatbuffers::Offset<void> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
|
||||
|
||||
FallingTub *AsFallingTub() {
|
||||
return type == Gadget::FallingTub ?
|
||||
@@ -266,8 +266,8 @@ struct GadgetUnion {
|
||||
}
|
||||
};
|
||||
|
||||
bool VerifyGadget(flatbuffers::Verifier &verifier, const void *obj, Gadget type);
|
||||
bool VerifyGadgetVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<Gadget> *types);
|
||||
bool VerifyGadget(::flatbuffers::Verifier &verifier, const void *obj, Gadget type);
|
||||
bool VerifyGadgetVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Gadget> *types);
|
||||
|
||||
FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Rapunzel FLATBUFFERS_FINAL_CLASS {
|
||||
private:
|
||||
@@ -275,20 +275,20 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Rapunzel FLATBUFFERS_FINAL_CLASS {
|
||||
|
||||
public:
|
||||
struct Traits;
|
||||
static const flatbuffers::TypeTable *MiniReflectTypeTable() {
|
||||
static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
|
||||
return RapunzelTypeTable();
|
||||
}
|
||||
Rapunzel()
|
||||
: hair_length_(0) {
|
||||
}
|
||||
Rapunzel(int32_t _hair_length)
|
||||
: hair_length_(flatbuffers::EndianScalar(_hair_length)) {
|
||||
: hair_length_(::flatbuffers::EndianScalar(_hair_length)) {
|
||||
}
|
||||
int32_t hair_length() const {
|
||||
return flatbuffers::EndianScalar(hair_length_);
|
||||
return ::flatbuffers::EndianScalar(hair_length_);
|
||||
}
|
||||
void mutate_hair_length(int32_t _hair_length) {
|
||||
flatbuffers::WriteScalar(&hair_length_, _hair_length);
|
||||
::flatbuffers::WriteScalar(&hair_length_, _hair_length);
|
||||
}
|
||||
template<size_t Index>
|
||||
auto get_field() const {
|
||||
@@ -316,20 +316,20 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) BookReader FLATBUFFERS_FINAL_CLASS {
|
||||
|
||||
public:
|
||||
struct Traits;
|
||||
static const flatbuffers::TypeTable *MiniReflectTypeTable() {
|
||||
static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
|
||||
return BookReaderTypeTable();
|
||||
}
|
||||
BookReader()
|
||||
: books_read_(0) {
|
||||
}
|
||||
BookReader(int32_t _books_read)
|
||||
: books_read_(flatbuffers::EndianScalar(_books_read)) {
|
||||
: books_read_(::flatbuffers::EndianScalar(_books_read)) {
|
||||
}
|
||||
int32_t books_read() const {
|
||||
return flatbuffers::EndianScalar(books_read_);
|
||||
return ::flatbuffers::EndianScalar(books_read_);
|
||||
}
|
||||
void mutate_books_read(int32_t _books_read) {
|
||||
flatbuffers::WriteScalar(&books_read_, _books_read);
|
||||
::flatbuffers::WriteScalar(&books_read_, _books_read);
|
||||
}
|
||||
template<size_t Index>
|
||||
auto get_field() const {
|
||||
@@ -357,20 +357,20 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) FallingTub FLATBUFFERS_FINAL_CLASS {
|
||||
|
||||
public:
|
||||
struct Traits;
|
||||
static const flatbuffers::TypeTable *MiniReflectTypeTable() {
|
||||
static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
|
||||
return FallingTubTypeTable();
|
||||
}
|
||||
FallingTub()
|
||||
: weight_(0) {
|
||||
}
|
||||
FallingTub(int32_t _weight)
|
||||
: weight_(flatbuffers::EndianScalar(_weight)) {
|
||||
: weight_(::flatbuffers::EndianScalar(_weight)) {
|
||||
}
|
||||
int32_t weight() const {
|
||||
return flatbuffers::EndianScalar(weight_);
|
||||
return ::flatbuffers::EndianScalar(weight_);
|
||||
}
|
||||
void mutate_weight(int32_t _weight) {
|
||||
flatbuffers::WriteScalar(&weight_, _weight);
|
||||
::flatbuffers::WriteScalar(&weight_, _weight);
|
||||
}
|
||||
template<size_t Index>
|
||||
auto get_field() const {
|
||||
@@ -392,16 +392,16 @@ struct FallingTub::Traits {
|
||||
using FieldType = decltype(std::declval<type>().get_field<Index>());
|
||||
};
|
||||
|
||||
struct AttackerT : public flatbuffers::NativeTable {
|
||||
struct AttackerT : public ::flatbuffers::NativeTable {
|
||||
typedef Attacker TableType;
|
||||
int32_t sword_attack_damage = 0;
|
||||
};
|
||||
|
||||
struct Attacker FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
||||
struct Attacker FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
||||
typedef AttackerT NativeTableType;
|
||||
typedef AttackerBuilder Builder;
|
||||
struct Traits;
|
||||
static const flatbuffers::TypeTable *MiniReflectTypeTable() {
|
||||
static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
|
||||
return AttackerTypeTable();
|
||||
}
|
||||
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
||||
@@ -418,36 +418,36 @@ struct Attacker FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
||||
if constexpr (Index == 0) return sword_attack_damage();
|
||||
else static_assert(Index != Index, "Invalid Field Index");
|
||||
}
|
||||
bool Verify(flatbuffers::Verifier &verifier) const {
|
||||
bool Verify(::flatbuffers::Verifier &verifier) const {
|
||||
return VerifyTableStart(verifier) &&
|
||||
VerifyField<int32_t>(verifier, VT_SWORD_ATTACK_DAMAGE, 4) &&
|
||||
verifier.EndTable();
|
||||
}
|
||||
AttackerT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
|
||||
void UnPackTo(AttackerT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
|
||||
static flatbuffers::Offset<Attacker> Pack(flatbuffers::FlatBufferBuilder &_fbb, const AttackerT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
|
||||
AttackerT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
|
||||
void UnPackTo(AttackerT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
|
||||
static ::flatbuffers::Offset<Attacker> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const AttackerT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
|
||||
};
|
||||
|
||||
struct AttackerBuilder {
|
||||
typedef Attacker Table;
|
||||
flatbuffers::FlatBufferBuilder &fbb_;
|
||||
flatbuffers::uoffset_t start_;
|
||||
::flatbuffers::FlatBufferBuilder &fbb_;
|
||||
::flatbuffers::uoffset_t start_;
|
||||
void add_sword_attack_damage(int32_t sword_attack_damage) {
|
||||
fbb_.AddElement<int32_t>(Attacker::VT_SWORD_ATTACK_DAMAGE, sword_attack_damage, 0);
|
||||
}
|
||||
explicit AttackerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
|
||||
explicit AttackerBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
||||
: fbb_(_fbb) {
|
||||
start_ = fbb_.StartTable();
|
||||
}
|
||||
flatbuffers::Offset<Attacker> Finish() {
|
||||
::flatbuffers::Offset<Attacker> Finish() {
|
||||
const auto end = fbb_.EndTable(start_);
|
||||
auto o = flatbuffers::Offset<Attacker>(end);
|
||||
auto o = ::flatbuffers::Offset<Attacker>(end);
|
||||
return o;
|
||||
}
|
||||
};
|
||||
|
||||
inline flatbuffers::Offset<Attacker> CreateAttacker(
|
||||
flatbuffers::FlatBufferBuilder &_fbb,
|
||||
inline ::flatbuffers::Offset<Attacker> CreateAttacker(
|
||||
::flatbuffers::FlatBufferBuilder &_fbb,
|
||||
int32_t sword_attack_damage = 0) {
|
||||
AttackerBuilder builder_(_fbb);
|
||||
builder_.add_sword_attack_damage(sword_attack_damage);
|
||||
@@ -467,18 +467,18 @@ struct Attacker::Traits {
|
||||
using FieldType = decltype(std::declval<type>().get_field<Index>());
|
||||
};
|
||||
|
||||
flatbuffers::Offset<Attacker> CreateAttacker(flatbuffers::FlatBufferBuilder &_fbb, const AttackerT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
|
||||
::flatbuffers::Offset<Attacker> CreateAttacker(::flatbuffers::FlatBufferBuilder &_fbb, const AttackerT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
|
||||
|
||||
struct HandFanT : public flatbuffers::NativeTable {
|
||||
struct HandFanT : public ::flatbuffers::NativeTable {
|
||||
typedef HandFan TableType;
|
||||
int32_t length = 0;
|
||||
};
|
||||
|
||||
struct HandFan FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
||||
struct HandFan FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
||||
typedef HandFanT NativeTableType;
|
||||
typedef HandFanBuilder Builder;
|
||||
struct Traits;
|
||||
static const flatbuffers::TypeTable *MiniReflectTypeTable() {
|
||||
static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
|
||||
return HandFanTypeTable();
|
||||
}
|
||||
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
||||
@@ -495,36 +495,36 @@ struct HandFan FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
||||
if constexpr (Index == 0) return length();
|
||||
else static_assert(Index != Index, "Invalid Field Index");
|
||||
}
|
||||
bool Verify(flatbuffers::Verifier &verifier) const {
|
||||
bool Verify(::flatbuffers::Verifier &verifier) const {
|
||||
return VerifyTableStart(verifier) &&
|
||||
VerifyField<int32_t>(verifier, VT_LENGTH, 4) &&
|
||||
verifier.EndTable();
|
||||
}
|
||||
HandFanT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
|
||||
void UnPackTo(HandFanT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
|
||||
static flatbuffers::Offset<HandFan> Pack(flatbuffers::FlatBufferBuilder &_fbb, const HandFanT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
|
||||
HandFanT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
|
||||
void UnPackTo(HandFanT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
|
||||
static ::flatbuffers::Offset<HandFan> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const HandFanT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
|
||||
};
|
||||
|
||||
struct HandFanBuilder {
|
||||
typedef HandFan Table;
|
||||
flatbuffers::FlatBufferBuilder &fbb_;
|
||||
flatbuffers::uoffset_t start_;
|
||||
::flatbuffers::FlatBufferBuilder &fbb_;
|
||||
::flatbuffers::uoffset_t start_;
|
||||
void add_length(int32_t length) {
|
||||
fbb_.AddElement<int32_t>(HandFan::VT_LENGTH, length, 0);
|
||||
}
|
||||
explicit HandFanBuilder(flatbuffers::FlatBufferBuilder &_fbb)
|
||||
explicit HandFanBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
||||
: fbb_(_fbb) {
|
||||
start_ = fbb_.StartTable();
|
||||
}
|
||||
flatbuffers::Offset<HandFan> Finish() {
|
||||
::flatbuffers::Offset<HandFan> Finish() {
|
||||
const auto end = fbb_.EndTable(start_);
|
||||
auto o = flatbuffers::Offset<HandFan>(end);
|
||||
auto o = ::flatbuffers::Offset<HandFan>(end);
|
||||
return o;
|
||||
}
|
||||
};
|
||||
|
||||
inline flatbuffers::Offset<HandFan> CreateHandFan(
|
||||
flatbuffers::FlatBufferBuilder &_fbb,
|
||||
inline ::flatbuffers::Offset<HandFan> CreateHandFan(
|
||||
::flatbuffers::FlatBufferBuilder &_fbb,
|
||||
int32_t length = 0) {
|
||||
HandFanBuilder builder_(_fbb);
|
||||
builder_.add_length(length);
|
||||
@@ -544,19 +544,19 @@ struct HandFan::Traits {
|
||||
using FieldType = decltype(std::declval<type>().get_field<Index>());
|
||||
};
|
||||
|
||||
flatbuffers::Offset<HandFan> CreateHandFan(flatbuffers::FlatBufferBuilder &_fbb, const HandFanT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
|
||||
::flatbuffers::Offset<HandFan> CreateHandFan(::flatbuffers::FlatBufferBuilder &_fbb, const HandFanT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
|
||||
|
||||
struct MovieT : public flatbuffers::NativeTable {
|
||||
struct MovieT : public ::flatbuffers::NativeTable {
|
||||
typedef Movie TableType;
|
||||
CharacterUnion main_character{};
|
||||
std::vector<CharacterUnion> characters{};
|
||||
};
|
||||
|
||||
struct Movie FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
||||
struct Movie FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
||||
typedef MovieT NativeTableType;
|
||||
typedef MovieBuilder Builder;
|
||||
struct Traits;
|
||||
static const flatbuffers::TypeTable *MiniReflectTypeTable() {
|
||||
static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
|
||||
return MovieTypeTable();
|
||||
}
|
||||
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
||||
@@ -583,26 +583,26 @@ struct Movie FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
||||
const BookReader *main_character_as_BookFan() const {
|
||||
return main_character_type() == Character::BookFan ? static_cast<const BookReader *>(main_character()) : nullptr;
|
||||
}
|
||||
const flatbuffers::String *main_character_as_Other() const {
|
||||
return main_character_type() == Character::Other ? static_cast<const flatbuffers::String *>(main_character()) : nullptr;
|
||||
const ::flatbuffers::String *main_character_as_Other() const {
|
||||
return main_character_type() == Character::Other ? static_cast<const ::flatbuffers::String *>(main_character()) : nullptr;
|
||||
}
|
||||
const flatbuffers::String *main_character_as_Unused() const {
|
||||
return main_character_type() == Character::Unused ? static_cast<const flatbuffers::String *>(main_character()) : nullptr;
|
||||
const ::flatbuffers::String *main_character_as_Unused() const {
|
||||
return main_character_type() == Character::Unused ? static_cast<const ::flatbuffers::String *>(main_character()) : nullptr;
|
||||
}
|
||||
void *mutable_main_character() {
|
||||
return GetPointer<void *>(VT_MAIN_CHARACTER);
|
||||
}
|
||||
const flatbuffers::Vector<Character> *characters_type() const {
|
||||
return GetPointer<const flatbuffers::Vector<Character> *>(VT_CHARACTERS_TYPE);
|
||||
const ::flatbuffers::Vector<Character> *characters_type() const {
|
||||
return GetPointer<const ::flatbuffers::Vector<Character> *>(VT_CHARACTERS_TYPE);
|
||||
}
|
||||
flatbuffers::Vector<Character> *mutable_characters_type() {
|
||||
return GetPointer<flatbuffers::Vector<Character> *>(VT_CHARACTERS_TYPE);
|
||||
::flatbuffers::Vector<Character> *mutable_characters_type() {
|
||||
return GetPointer<::flatbuffers::Vector<Character> *>(VT_CHARACTERS_TYPE);
|
||||
}
|
||||
const flatbuffers::Vector<flatbuffers::Offset<void>> *characters() const {
|
||||
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<void>> *>(VT_CHARACTERS);
|
||||
const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *characters() const {
|
||||
return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *>(VT_CHARACTERS);
|
||||
}
|
||||
flatbuffers::Vector<flatbuffers::Offset<void>> *mutable_characters() {
|
||||
return GetPointer<flatbuffers::Vector<flatbuffers::Offset<void>> *>(VT_CHARACTERS);
|
||||
::flatbuffers::Vector<::flatbuffers::Offset<void>> *mutable_characters() {
|
||||
return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<void>> *>(VT_CHARACTERS);
|
||||
}
|
||||
template<size_t Index>
|
||||
auto get_field() const {
|
||||
@@ -612,7 +612,7 @@ struct Movie FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
||||
else if constexpr (Index == 3) return characters();
|
||||
else static_assert(Index != Index, "Invalid Field Index");
|
||||
}
|
||||
bool Verify(flatbuffers::Verifier &verifier) const {
|
||||
bool Verify(::flatbuffers::Verifier &verifier) const {
|
||||
return VerifyTableStart(verifier) &&
|
||||
VerifyField<uint8_t>(verifier, VT_MAIN_CHARACTER_TYPE, 1) &&
|
||||
VerifyOffset(verifier, VT_MAIN_CHARACTER) &&
|
||||
@@ -624,44 +624,44 @@ struct Movie FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
|
||||
VerifyCharacterVector(verifier, characters(), characters_type()) &&
|
||||
verifier.EndTable();
|
||||
}
|
||||
MovieT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
|
||||
void UnPackTo(MovieT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
|
||||
static flatbuffers::Offset<Movie> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MovieT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
|
||||
MovieT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
|
||||
void UnPackTo(MovieT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
|
||||
static ::flatbuffers::Offset<Movie> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const MovieT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
|
||||
};
|
||||
|
||||
struct MovieBuilder {
|
||||
typedef Movie Table;
|
||||
flatbuffers::FlatBufferBuilder &fbb_;
|
||||
flatbuffers::uoffset_t start_;
|
||||
::flatbuffers::FlatBufferBuilder &fbb_;
|
||||
::flatbuffers::uoffset_t start_;
|
||||
void add_main_character_type(Character main_character_type) {
|
||||
fbb_.AddElement<uint8_t>(Movie::VT_MAIN_CHARACTER_TYPE, static_cast<uint8_t>(main_character_type), 0);
|
||||
}
|
||||
void add_main_character(flatbuffers::Offset<void> main_character) {
|
||||
void add_main_character(::flatbuffers::Offset<void> main_character) {
|
||||
fbb_.AddOffset(Movie::VT_MAIN_CHARACTER, main_character);
|
||||
}
|
||||
void add_characters_type(flatbuffers::Offset<flatbuffers::Vector<Character>> characters_type) {
|
||||
void add_characters_type(::flatbuffers::Offset<::flatbuffers::Vector<Character>> characters_type) {
|
||||
fbb_.AddOffset(Movie::VT_CHARACTERS_TYPE, characters_type);
|
||||
}
|
||||
void add_characters(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<void>>> characters) {
|
||||
void add_characters(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<void>>> characters) {
|
||||
fbb_.AddOffset(Movie::VT_CHARACTERS, characters);
|
||||
}
|
||||
explicit MovieBuilder(flatbuffers::FlatBufferBuilder &_fbb)
|
||||
explicit MovieBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
||||
: fbb_(_fbb) {
|
||||
start_ = fbb_.StartTable();
|
||||
}
|
||||
flatbuffers::Offset<Movie> Finish() {
|
||||
::flatbuffers::Offset<Movie> Finish() {
|
||||
const auto end = fbb_.EndTable(start_);
|
||||
auto o = flatbuffers::Offset<Movie>(end);
|
||||
auto o = ::flatbuffers::Offset<Movie>(end);
|
||||
return o;
|
||||
}
|
||||
};
|
||||
|
||||
inline flatbuffers::Offset<Movie> CreateMovie(
|
||||
flatbuffers::FlatBufferBuilder &_fbb,
|
||||
inline ::flatbuffers::Offset<Movie> CreateMovie(
|
||||
::flatbuffers::FlatBufferBuilder &_fbb,
|
||||
Character main_character_type = Character::NONE,
|
||||
flatbuffers::Offset<void> main_character = 0,
|
||||
flatbuffers::Offset<flatbuffers::Vector<Character>> characters_type = 0,
|
||||
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<void>>> characters = 0) {
|
||||
::flatbuffers::Offset<void> main_character = 0,
|
||||
::flatbuffers::Offset<::flatbuffers::Vector<Character>> characters_type = 0,
|
||||
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<void>>> characters = 0) {
|
||||
MovieBuilder builder_(_fbb);
|
||||
builder_.add_characters(characters);
|
||||
builder_.add_characters_type(characters_type);
|
||||
@@ -686,14 +686,14 @@ struct Movie::Traits {
|
||||
using FieldType = decltype(std::declval<type>().get_field<Index>());
|
||||
};
|
||||
|
||||
inline flatbuffers::Offset<Movie> CreateMovieDirect(
|
||||
flatbuffers::FlatBufferBuilder &_fbb,
|
||||
inline ::flatbuffers::Offset<Movie> CreateMovieDirect(
|
||||
::flatbuffers::FlatBufferBuilder &_fbb,
|
||||
Character main_character_type = Character::NONE,
|
||||
flatbuffers::Offset<void> main_character = 0,
|
||||
::flatbuffers::Offset<void> main_character = 0,
|
||||
const std::vector<Character> *characters_type = nullptr,
|
||||
const std::vector<flatbuffers::Offset<void>> *characters = nullptr) {
|
||||
const std::vector<::flatbuffers::Offset<void>> *characters = nullptr) {
|
||||
auto characters_type__ = characters_type ? _fbb.CreateVector<Character>(*characters_type) : 0;
|
||||
auto characters__ = characters ? _fbb.CreateVector<flatbuffers::Offset<void>>(*characters) : 0;
|
||||
auto characters__ = characters ? _fbb.CreateVector<::flatbuffers::Offset<void>>(*characters) : 0;
|
||||
return CreateMovie(
|
||||
_fbb,
|
||||
main_character_type,
|
||||
@@ -702,87 +702,87 @@ inline flatbuffers::Offset<Movie> CreateMovieDirect(
|
||||
characters__);
|
||||
}
|
||||
|
||||
flatbuffers::Offset<Movie> CreateMovie(flatbuffers::FlatBufferBuilder &_fbb, const MovieT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
|
||||
::flatbuffers::Offset<Movie> CreateMovie(::flatbuffers::FlatBufferBuilder &_fbb, const MovieT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
|
||||
|
||||
inline AttackerT *Attacker::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
|
||||
inline AttackerT *Attacker::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
|
||||
auto _o = std::make_unique<AttackerT>();
|
||||
UnPackTo(_o.get(), _resolver);
|
||||
return _o.release();
|
||||
}
|
||||
|
||||
inline void Attacker::UnPackTo(AttackerT *_o, const flatbuffers::resolver_function_t *_resolver) const {
|
||||
inline void Attacker::UnPackTo(AttackerT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
|
||||
(void)_o;
|
||||
(void)_resolver;
|
||||
{ auto _e = sword_attack_damage(); _o->sword_attack_damage = _e; }
|
||||
}
|
||||
|
||||
inline flatbuffers::Offset<Attacker> Attacker::Pack(flatbuffers::FlatBufferBuilder &_fbb, const AttackerT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
|
||||
inline ::flatbuffers::Offset<Attacker> Attacker::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const AttackerT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
|
||||
return CreateAttacker(_fbb, _o, _rehasher);
|
||||
}
|
||||
|
||||
inline flatbuffers::Offset<Attacker> CreateAttacker(flatbuffers::FlatBufferBuilder &_fbb, const AttackerT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
|
||||
inline ::flatbuffers::Offset<Attacker> CreateAttacker(::flatbuffers::FlatBufferBuilder &_fbb, const AttackerT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
|
||||
(void)_rehasher;
|
||||
(void)_o;
|
||||
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const AttackerT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
|
||||
struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const AttackerT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
|
||||
auto _sword_attack_damage = _o->sword_attack_damage;
|
||||
return CreateAttacker(
|
||||
_fbb,
|
||||
_sword_attack_damage);
|
||||
}
|
||||
|
||||
inline HandFanT *HandFan::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
|
||||
inline HandFanT *HandFan::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
|
||||
auto _o = std::make_unique<HandFanT>();
|
||||
UnPackTo(_o.get(), _resolver);
|
||||
return _o.release();
|
||||
}
|
||||
|
||||
inline void HandFan::UnPackTo(HandFanT *_o, const flatbuffers::resolver_function_t *_resolver) const {
|
||||
inline void HandFan::UnPackTo(HandFanT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
|
||||
(void)_o;
|
||||
(void)_resolver;
|
||||
{ auto _e = length(); _o->length = _e; }
|
||||
}
|
||||
|
||||
inline flatbuffers::Offset<HandFan> HandFan::Pack(flatbuffers::FlatBufferBuilder &_fbb, const HandFanT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
|
||||
inline ::flatbuffers::Offset<HandFan> HandFan::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const HandFanT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
|
||||
return CreateHandFan(_fbb, _o, _rehasher);
|
||||
}
|
||||
|
||||
inline flatbuffers::Offset<HandFan> CreateHandFan(flatbuffers::FlatBufferBuilder &_fbb, const HandFanT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
|
||||
inline ::flatbuffers::Offset<HandFan> CreateHandFan(::flatbuffers::FlatBufferBuilder &_fbb, const HandFanT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
|
||||
(void)_rehasher;
|
||||
(void)_o;
|
||||
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const HandFanT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
|
||||
struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const HandFanT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
|
||||
auto _length = _o->length;
|
||||
return CreateHandFan(
|
||||
_fbb,
|
||||
_length);
|
||||
}
|
||||
|
||||
inline MovieT *Movie::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
|
||||
inline MovieT *Movie::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
|
||||
auto _o = std::make_unique<MovieT>();
|
||||
UnPackTo(_o.get(), _resolver);
|
||||
return _o.release();
|
||||
}
|
||||
|
||||
inline void Movie::UnPackTo(MovieT *_o, const flatbuffers::resolver_function_t *_resolver) const {
|
||||
inline void Movie::UnPackTo(MovieT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
|
||||
(void)_o;
|
||||
(void)_resolver;
|
||||
{ auto _e = main_character_type(); _o->main_character.type = _e; }
|
||||
{ auto _e = main_character(); if (_e) _o->main_character.value = CharacterUnion::UnPack(_e, main_character_type(), _resolver); }
|
||||
{ auto _e = characters_type(); if (_e) { _o->characters.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->characters[_i].type = static_cast<Character>(_e->Get(_i)); } } else { _o->characters.resize(0); } }
|
||||
{ auto _e = characters(); if (_e) { _o->characters.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->characters[_i].value = CharacterUnion::UnPack(_e->Get(_i), characters_type()->GetEnum<Character>(_i), _resolver); } } else { _o->characters.resize(0); } }
|
||||
{ auto _e = characters_type(); if (_e) { _o->characters.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->characters[_i].type = static_cast<Character>(_e->Get(_i)); } } else { _o->characters.resize(0); } }
|
||||
{ auto _e = characters(); if (_e) { _o->characters.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->characters[_i].value = CharacterUnion::UnPack(_e->Get(_i), characters_type()->GetEnum<Character>(_i), _resolver); } } else { _o->characters.resize(0); } }
|
||||
}
|
||||
|
||||
inline flatbuffers::Offset<Movie> Movie::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MovieT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
|
||||
inline ::flatbuffers::Offset<Movie> Movie::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const MovieT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
|
||||
return CreateMovie(_fbb, _o, _rehasher);
|
||||
}
|
||||
|
||||
inline flatbuffers::Offset<Movie> CreateMovie(flatbuffers::FlatBufferBuilder &_fbb, const MovieT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
|
||||
inline ::flatbuffers::Offset<Movie> CreateMovie(::flatbuffers::FlatBufferBuilder &_fbb, const MovieT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
|
||||
(void)_rehasher;
|
||||
(void)_o;
|
||||
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MovieT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
|
||||
struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const MovieT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
|
||||
auto _main_character_type = _o->main_character.type;
|
||||
auto _main_character = _o->main_character.Pack(_fbb);
|
||||
auto _characters_type = _o->characters.size() ? _fbb.CreateVector<Character>(_o->characters.size(), [](size_t i, _VectorArgs *__va) { return __va->__o->characters[i].type; }, &_va) : 0;
|
||||
auto _characters = _o->characters.size() ? _fbb.CreateVector<flatbuffers::Offset<void>>(_o->characters.size(), [](size_t i, _VectorArgs *__va) { return __va->__o->characters[i].Pack(*__va->__fbb, __va->__rehasher); }, &_va) : 0;
|
||||
auto _characters = _o->characters.size() ? _fbb.CreateVector<::flatbuffers::Offset<void>>(_o->characters.size(), [](size_t i, _VectorArgs *__va) { return __va->__o->characters[i].Pack(*__va->__fbb, __va->__rehasher); }, &_va) : 0;
|
||||
return CreateMovie(
|
||||
_fbb,
|
||||
_main_character_type,
|
||||
@@ -791,7 +791,7 @@ inline flatbuffers::Offset<Movie> CreateMovie(flatbuffers::FlatBufferBuilder &_f
|
||||
_characters);
|
||||
}
|
||||
|
||||
inline bool VerifyCharacter(flatbuffers::Verifier &verifier, const void *obj, Character type) {
|
||||
inline bool VerifyCharacter(::flatbuffers::Verifier &verifier, const void *obj, Character type) {
|
||||
switch (type) {
|
||||
case Character::NONE: {
|
||||
return true;
|
||||
@@ -810,21 +810,21 @@ inline bool VerifyCharacter(flatbuffers::Verifier &verifier, const void *obj, Ch
|
||||
return verifier.VerifyField<BookReader>(static_cast<const uint8_t *>(obj), 0, 4);
|
||||
}
|
||||
case Character::Other: {
|
||||
auto ptr = reinterpret_cast<const flatbuffers::String *>(obj);
|
||||
auto ptr = reinterpret_cast<const ::flatbuffers::String *>(obj);
|
||||
return verifier.VerifyString(ptr);
|
||||
}
|
||||
case Character::Unused: {
|
||||
auto ptr = reinterpret_cast<const flatbuffers::String *>(obj);
|
||||
auto ptr = reinterpret_cast<const ::flatbuffers::String *>(obj);
|
||||
return verifier.VerifyString(ptr);
|
||||
}
|
||||
default: return true;
|
||||
}
|
||||
}
|
||||
|
||||
inline bool VerifyCharacterVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<Character> *types) {
|
||||
inline bool VerifyCharacterVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Character> *types) {
|
||||
if (!values || !types) return !values && !types;
|
||||
if (values->size() != types->size()) return false;
|
||||
for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
|
||||
for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
|
||||
if (!VerifyCharacter(
|
||||
verifier, values->Get(i), types->GetEnum<Character>(i))) {
|
||||
return false;
|
||||
@@ -833,7 +833,7 @@ inline bool VerifyCharacterVector(flatbuffers::Verifier &verifier, const flatbuf
|
||||
return true;
|
||||
}
|
||||
|
||||
inline void *CharacterUnion::UnPack(const void *obj, Character type, const flatbuffers::resolver_function_t *resolver) {
|
||||
inline void *CharacterUnion::UnPack(const void *obj, Character type, const ::flatbuffers::resolver_function_t *resolver) {
|
||||
(void)resolver;
|
||||
switch (type) {
|
||||
case Character::MuLan: {
|
||||
@@ -853,18 +853,18 @@ inline void *CharacterUnion::UnPack(const void *obj, Character type, const flatb
|
||||
return new BookReader(*ptr);
|
||||
}
|
||||
case Character::Other: {
|
||||
auto ptr = reinterpret_cast<const flatbuffers::String *>(obj);
|
||||
auto ptr = reinterpret_cast<const ::flatbuffers::String *>(obj);
|
||||
return new std::string(ptr->c_str(), ptr->size());
|
||||
}
|
||||
case Character::Unused: {
|
||||
auto ptr = reinterpret_cast<const flatbuffers::String *>(obj);
|
||||
auto ptr = reinterpret_cast<const ::flatbuffers::String *>(obj);
|
||||
return new std::string(ptr->c_str(), ptr->size());
|
||||
}
|
||||
default: return nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
inline flatbuffers::Offset<void> CharacterUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const {
|
||||
inline ::flatbuffers::Offset<void> CharacterUnion::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher) const {
|
||||
(void)_rehasher;
|
||||
switch (type) {
|
||||
case Character::MuLan: {
|
||||
@@ -964,7 +964,7 @@ inline void CharacterUnion::Reset() {
|
||||
type = Character::NONE;
|
||||
}
|
||||
|
||||
inline bool VerifyGadget(flatbuffers::Verifier &verifier, const void *obj, Gadget type) {
|
||||
inline bool VerifyGadget(::flatbuffers::Verifier &verifier, const void *obj, Gadget type) {
|
||||
switch (type) {
|
||||
case Gadget::NONE: {
|
||||
return true;
|
||||
@@ -980,10 +980,10 @@ inline bool VerifyGadget(flatbuffers::Verifier &verifier, const void *obj, Gadge
|
||||
}
|
||||
}
|
||||
|
||||
inline bool VerifyGadgetVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<Gadget> *types) {
|
||||
inline bool VerifyGadgetVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Gadget> *types) {
|
||||
if (!values || !types) return !values && !types;
|
||||
if (values->size() != types->size()) return false;
|
||||
for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
|
||||
for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
|
||||
if (!VerifyGadget(
|
||||
verifier, values->Get(i), types->GetEnum<Gadget>(i))) {
|
||||
return false;
|
||||
@@ -992,7 +992,7 @@ inline bool VerifyGadgetVector(flatbuffers::Verifier &verifier, const flatbuffer
|
||||
return true;
|
||||
}
|
||||
|
||||
inline void *GadgetUnion::UnPack(const void *obj, Gadget type, const flatbuffers::resolver_function_t *resolver) {
|
||||
inline void *GadgetUnion::UnPack(const void *obj, Gadget type, const ::flatbuffers::resolver_function_t *resolver) {
|
||||
(void)resolver;
|
||||
switch (type) {
|
||||
case Gadget::FallingTub: {
|
||||
@@ -1007,7 +1007,7 @@ inline void *GadgetUnion::UnPack(const void *obj, Gadget type, const flatbuffers
|
||||
}
|
||||
}
|
||||
|
||||
inline flatbuffers::Offset<void> GadgetUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const {
|
||||
inline ::flatbuffers::Offset<void> GadgetUnion::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher) const {
|
||||
(void)_rehasher;
|
||||
switch (type) {
|
||||
case Gadget::FallingTub: {
|
||||
@@ -1055,17 +1055,17 @@ inline void GadgetUnion::Reset() {
|
||||
type = Gadget::NONE;
|
||||
}
|
||||
|
||||
inline const flatbuffers::TypeTable *CharacterTypeTable() {
|
||||
static const flatbuffers::TypeCode type_codes[] = {
|
||||
{ flatbuffers::ET_SEQUENCE, 0, -1 },
|
||||
{ flatbuffers::ET_SEQUENCE, 0, 0 },
|
||||
{ flatbuffers::ET_SEQUENCE, 0, 1 },
|
||||
{ flatbuffers::ET_SEQUENCE, 0, 2 },
|
||||
{ flatbuffers::ET_SEQUENCE, 0, 2 },
|
||||
{ flatbuffers::ET_STRING, 0, -1 },
|
||||
{ flatbuffers::ET_STRING, 0, -1 }
|
||||
inline const ::flatbuffers::TypeTable *CharacterTypeTable() {
|
||||
static const ::flatbuffers::TypeCode type_codes[] = {
|
||||
{ ::flatbuffers::ET_SEQUENCE, 0, -1 },
|
||||
{ ::flatbuffers::ET_SEQUENCE, 0, 0 },
|
||||
{ ::flatbuffers::ET_SEQUENCE, 0, 1 },
|
||||
{ ::flatbuffers::ET_SEQUENCE, 0, 2 },
|
||||
{ ::flatbuffers::ET_SEQUENCE, 0, 2 },
|
||||
{ ::flatbuffers::ET_STRING, 0, -1 },
|
||||
{ ::flatbuffers::ET_STRING, 0, -1 }
|
||||
};
|
||||
static const flatbuffers::TypeFunction type_refs[] = {
|
||||
static const ::flatbuffers::TypeFunction type_refs[] = {
|
||||
AttackerTypeTable,
|
||||
RapunzelTypeTable,
|
||||
BookReaderTypeTable
|
||||
@@ -1079,19 +1079,19 @@ inline const flatbuffers::TypeTable *CharacterTypeTable() {
|
||||
"Other",
|
||||
"Unused"
|
||||
};
|
||||
static const flatbuffers::TypeTable tt = {
|
||||
flatbuffers::ST_UNION, 7, type_codes, type_refs, nullptr, nullptr, names
|
||||
static const ::flatbuffers::TypeTable tt = {
|
||||
::flatbuffers::ST_UNION, 7, type_codes, type_refs, nullptr, nullptr, names
|
||||
};
|
||||
return &tt;
|
||||
}
|
||||
|
||||
inline const flatbuffers::TypeTable *GadgetTypeTable() {
|
||||
static const flatbuffers::TypeCode type_codes[] = {
|
||||
{ flatbuffers::ET_SEQUENCE, 0, -1 },
|
||||
{ flatbuffers::ET_SEQUENCE, 0, 0 },
|
||||
{ flatbuffers::ET_SEQUENCE, 0, 1 }
|
||||
inline const ::flatbuffers::TypeTable *GadgetTypeTable() {
|
||||
static const ::flatbuffers::TypeCode type_codes[] = {
|
||||
{ ::flatbuffers::ET_SEQUENCE, 0, -1 },
|
||||
{ ::flatbuffers::ET_SEQUENCE, 0, 0 },
|
||||
{ ::flatbuffers::ET_SEQUENCE, 0, 1 }
|
||||
};
|
||||
static const flatbuffers::TypeFunction type_refs[] = {
|
||||
static const ::flatbuffers::TypeFunction type_refs[] = {
|
||||
FallingTubTypeTable,
|
||||
HandFanTypeTable
|
||||
};
|
||||
@@ -1100,88 +1100,88 @@ inline const flatbuffers::TypeTable *GadgetTypeTable() {
|
||||
"FallingTub",
|
||||
"HandFan"
|
||||
};
|
||||
static const flatbuffers::TypeTable tt = {
|
||||
flatbuffers::ST_UNION, 3, type_codes, type_refs, nullptr, nullptr, names
|
||||
static const ::flatbuffers::TypeTable tt = {
|
||||
::flatbuffers::ST_UNION, 3, type_codes, type_refs, nullptr, nullptr, names
|
||||
};
|
||||
return &tt;
|
||||
}
|
||||
|
||||
inline const flatbuffers::TypeTable *AttackerTypeTable() {
|
||||
static const flatbuffers::TypeCode type_codes[] = {
|
||||
{ flatbuffers::ET_INT, 0, -1 }
|
||||
inline const ::flatbuffers::TypeTable *AttackerTypeTable() {
|
||||
static const ::flatbuffers::TypeCode type_codes[] = {
|
||||
{ ::flatbuffers::ET_INT, 0, -1 }
|
||||
};
|
||||
static const char * const names[] = {
|
||||
"sword_attack_damage"
|
||||
};
|
||||
static const flatbuffers::TypeTable tt = {
|
||||
flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
|
||||
static const ::flatbuffers::TypeTable tt = {
|
||||
::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
|
||||
};
|
||||
return &tt;
|
||||
}
|
||||
|
||||
inline const flatbuffers::TypeTable *RapunzelTypeTable() {
|
||||
static const flatbuffers::TypeCode type_codes[] = {
|
||||
{ flatbuffers::ET_INT, 0, -1 }
|
||||
inline const ::flatbuffers::TypeTable *RapunzelTypeTable() {
|
||||
static const ::flatbuffers::TypeCode type_codes[] = {
|
||||
{ ::flatbuffers::ET_INT, 0, -1 }
|
||||
};
|
||||
static const int64_t values[] = { 0, 4 };
|
||||
static const char * const names[] = {
|
||||
"hair_length"
|
||||
};
|
||||
static const flatbuffers::TypeTable tt = {
|
||||
flatbuffers::ST_STRUCT, 1, type_codes, nullptr, nullptr, values, names
|
||||
static const ::flatbuffers::TypeTable tt = {
|
||||
::flatbuffers::ST_STRUCT, 1, type_codes, nullptr, nullptr, values, names
|
||||
};
|
||||
return &tt;
|
||||
}
|
||||
|
||||
inline const flatbuffers::TypeTable *BookReaderTypeTable() {
|
||||
static const flatbuffers::TypeCode type_codes[] = {
|
||||
{ flatbuffers::ET_INT, 0, -1 }
|
||||
inline const ::flatbuffers::TypeTable *BookReaderTypeTable() {
|
||||
static const ::flatbuffers::TypeCode type_codes[] = {
|
||||
{ ::flatbuffers::ET_INT, 0, -1 }
|
||||
};
|
||||
static const int64_t values[] = { 0, 4 };
|
||||
static const char * const names[] = {
|
||||
"books_read"
|
||||
};
|
||||
static const flatbuffers::TypeTable tt = {
|
||||
flatbuffers::ST_STRUCT, 1, type_codes, nullptr, nullptr, values, names
|
||||
static const ::flatbuffers::TypeTable tt = {
|
||||
::flatbuffers::ST_STRUCT, 1, type_codes, nullptr, nullptr, values, names
|
||||
};
|
||||
return &tt;
|
||||
}
|
||||
|
||||
inline const flatbuffers::TypeTable *FallingTubTypeTable() {
|
||||
static const flatbuffers::TypeCode type_codes[] = {
|
||||
{ flatbuffers::ET_INT, 0, -1 }
|
||||
inline const ::flatbuffers::TypeTable *FallingTubTypeTable() {
|
||||
static const ::flatbuffers::TypeCode type_codes[] = {
|
||||
{ ::flatbuffers::ET_INT, 0, -1 }
|
||||
};
|
||||
static const int64_t values[] = { 0, 4 };
|
||||
static const char * const names[] = {
|
||||
"weight"
|
||||
};
|
||||
static const flatbuffers::TypeTable tt = {
|
||||
flatbuffers::ST_STRUCT, 1, type_codes, nullptr, nullptr, values, names
|
||||
static const ::flatbuffers::TypeTable tt = {
|
||||
::flatbuffers::ST_STRUCT, 1, type_codes, nullptr, nullptr, values, names
|
||||
};
|
||||
return &tt;
|
||||
}
|
||||
|
||||
inline const flatbuffers::TypeTable *HandFanTypeTable() {
|
||||
static const flatbuffers::TypeCode type_codes[] = {
|
||||
{ flatbuffers::ET_INT, 0, -1 }
|
||||
inline const ::flatbuffers::TypeTable *HandFanTypeTable() {
|
||||
static const ::flatbuffers::TypeCode type_codes[] = {
|
||||
{ ::flatbuffers::ET_INT, 0, -1 }
|
||||
};
|
||||
static const char * const names[] = {
|
||||
"length"
|
||||
};
|
||||
static const flatbuffers::TypeTable tt = {
|
||||
flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
|
||||
static const ::flatbuffers::TypeTable tt = {
|
||||
::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
|
||||
};
|
||||
return &tt;
|
||||
}
|
||||
|
||||
inline const flatbuffers::TypeTable *MovieTypeTable() {
|
||||
static const flatbuffers::TypeCode type_codes[] = {
|
||||
{ flatbuffers::ET_UTYPE, 0, 0 },
|
||||
{ flatbuffers::ET_SEQUENCE, 0, 0 },
|
||||
{ flatbuffers::ET_UTYPE, 1, 0 },
|
||||
{ flatbuffers::ET_SEQUENCE, 1, 0 }
|
||||
inline const ::flatbuffers::TypeTable *MovieTypeTable() {
|
||||
static const ::flatbuffers::TypeCode type_codes[] = {
|
||||
{ ::flatbuffers::ET_UTYPE, 0, 0 },
|
||||
{ ::flatbuffers::ET_SEQUENCE, 0, 0 },
|
||||
{ ::flatbuffers::ET_UTYPE, 1, 0 },
|
||||
{ ::flatbuffers::ET_SEQUENCE, 1, 0 }
|
||||
};
|
||||
static const flatbuffers::TypeFunction type_refs[] = {
|
||||
static const ::flatbuffers::TypeFunction type_refs[] = {
|
||||
CharacterTypeTable
|
||||
};
|
||||
static const char * const names[] = {
|
||||
@@ -1190,26 +1190,26 @@ inline const flatbuffers::TypeTable *MovieTypeTable() {
|
||||
"characters_type",
|
||||
"characters"
|
||||
};
|
||||
static const flatbuffers::TypeTable tt = {
|
||||
flatbuffers::ST_TABLE, 4, type_codes, type_refs, nullptr, nullptr, names
|
||||
static const ::flatbuffers::TypeTable tt = {
|
||||
::flatbuffers::ST_TABLE, 4, type_codes, type_refs, nullptr, nullptr, names
|
||||
};
|
||||
return &tt;
|
||||
}
|
||||
|
||||
inline const Movie *GetMovie(const void *buf) {
|
||||
return flatbuffers::GetRoot<Movie>(buf);
|
||||
return ::flatbuffers::GetRoot<Movie>(buf);
|
||||
}
|
||||
|
||||
inline const Movie *GetSizePrefixedMovie(const void *buf) {
|
||||
return flatbuffers::GetSizePrefixedRoot<Movie>(buf);
|
||||
return ::flatbuffers::GetSizePrefixedRoot<Movie>(buf);
|
||||
}
|
||||
|
||||
inline Movie *GetMutableMovie(void *buf) {
|
||||
return flatbuffers::GetMutableRoot<Movie>(buf);
|
||||
return ::flatbuffers::GetMutableRoot<Movie>(buf);
|
||||
}
|
||||
|
||||
inline Movie *GetMutableSizePrefixedMovie(void *buf) {
|
||||
return flatbuffers::GetMutableSizePrefixedRoot<Movie>(buf);
|
||||
return ::flatbuffers::GetMutableSizePrefixedRoot<Movie>(buf);
|
||||
}
|
||||
|
||||
inline const char *MovieIdentifier() {
|
||||
@@ -1217,46 +1217,46 @@ inline const char *MovieIdentifier() {
|
||||
}
|
||||
|
||||
inline bool MovieBufferHasIdentifier(const void *buf) {
|
||||
return flatbuffers::BufferHasIdentifier(
|
||||
return ::flatbuffers::BufferHasIdentifier(
|
||||
buf, MovieIdentifier());
|
||||
}
|
||||
|
||||
inline bool SizePrefixedMovieBufferHasIdentifier(const void *buf) {
|
||||
return flatbuffers::BufferHasIdentifier(
|
||||
return ::flatbuffers::BufferHasIdentifier(
|
||||
buf, MovieIdentifier(), true);
|
||||
}
|
||||
|
||||
inline bool VerifyMovieBuffer(
|
||||
flatbuffers::Verifier &verifier) {
|
||||
::flatbuffers::Verifier &verifier) {
|
||||
return verifier.VerifyBuffer<Movie>(MovieIdentifier());
|
||||
}
|
||||
|
||||
inline bool VerifySizePrefixedMovieBuffer(
|
||||
flatbuffers::Verifier &verifier) {
|
||||
::flatbuffers::Verifier &verifier) {
|
||||
return verifier.VerifySizePrefixedBuffer<Movie>(MovieIdentifier());
|
||||
}
|
||||
|
||||
inline void FinishMovieBuffer(
|
||||
flatbuffers::FlatBufferBuilder &fbb,
|
||||
flatbuffers::Offset<Movie> root) {
|
||||
::flatbuffers::FlatBufferBuilder &fbb,
|
||||
::flatbuffers::Offset<Movie> root) {
|
||||
fbb.Finish(root, MovieIdentifier());
|
||||
}
|
||||
|
||||
inline void FinishSizePrefixedMovieBuffer(
|
||||
flatbuffers::FlatBufferBuilder &fbb,
|
||||
flatbuffers::Offset<Movie> root) {
|
||||
::flatbuffers::FlatBufferBuilder &fbb,
|
||||
::flatbuffers::Offset<Movie> root) {
|
||||
fbb.FinishSizePrefixed(root, MovieIdentifier());
|
||||
}
|
||||
|
||||
inline std::unique_ptr<MovieT> UnPackMovie(
|
||||
const void *buf,
|
||||
const flatbuffers::resolver_function_t *res = nullptr) {
|
||||
const ::flatbuffers::resolver_function_t *res = nullptr) {
|
||||
return std::unique_ptr<MovieT>(GetMovie(buf)->UnPack(res));
|
||||
}
|
||||
|
||||
inline std::unique_ptr<MovieT> UnPackSizePrefixedMovie(
|
||||
const void *buf,
|
||||
const flatbuffers::resolver_function_t *res = nullptr) {
|
||||
const ::flatbuffers::resolver_function_t *res = nullptr) {
|
||||
return std::unique_ptr<MovieT>(GetSizePrefixedMovie(buf)->UnPack(res));
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user