BigfootDev/flatbuffers-bigfoot
1
0
Fork 0
forked from BigfootDev/flatbuffers
Code Pull Requests Activity

emit global scoped ::flatbuffers in c++ (#7764)

Browse Source
This commit is contained in:
Derek Bailey
2023-01-07 12:17:07 -08:00
committed by GitHub
parent c95cf661af
commit 75af533e95
22 changed files with 5236 additions and 5235 deletions
Download Patch File Download Diff File Expand all files Collapse all files

602
include/flatbuffers/reflection_generated.h
View File

File diff suppressed because it is too large Load Diff

324
samples/monster_generated.h
View File

@@ -33,11 +33,11 @@ bool operator!=(const MonsterT &lhs, const MonsterT &rhs);
bool operator==(const WeaponT &lhs, const WeaponT &rhs); bool operator==(const WeaponT &lhs, const WeaponT &rhs);
bool operator!=(const WeaponT &lhs, const WeaponT &rhs); bool operator!=(const WeaponT &lhs, const WeaponT &rhs);
inline const flatbuffers::TypeTable *Vec3TypeTable(); inline const ::flatbuffers::TypeTable *Vec3TypeTable();
inline const flatbuffers::TypeTable *MonsterTypeTable(); inline const ::flatbuffers::TypeTable *MonsterTypeTable();
inline const flatbuffers::TypeTable *WeaponTypeTable(); inline const ::flatbuffers::TypeTable *WeaponTypeTable();
enum Color : int8_t { enum Color : int8_t {
Color_Red = 0, Color_Red = 0,
@@ -67,7 +67,7 @@ inline const char * const *EnumNamesColor() {
} }
inline const char *EnumNameColor(Color e) { inline const char *EnumNameColor(Color e) {
if (flatbuffers::IsOutRange(e, Color_Red, Color_Blue)) return ""; if (::flatbuffers::IsOutRange(e, Color_Red, Color_Blue)) return "";
const size_t index = static_cast<size_t>(e); const size_t index = static_cast<size_t>(e);
return EnumNamesColor()[index]; return EnumNamesColor()[index];
} }
@@ -97,7 +97,7 @@ inline const char * const *EnumNamesEquipment() {
} }
inline const char *EnumNameEquipment(Equipment e) { inline const char *EnumNameEquipment(Equipment e) {
if (flatbuffers::IsOutRange(e, Equipment_NONE, Equipment_Weapon)) return ""; if (::flatbuffers::IsOutRange(e, Equipment_NONE, Equipment_Weapon)) return "";
const size_t index = static_cast<size_t>(e); const size_t index = static_cast<size_t>(e);
return EnumNamesEquipment()[index]; return EnumNamesEquipment()[index];
} }
@@ -145,8 +145,8 @@ struct EquipmentUnion {
} }
} }
static void *UnPack(const void *obj, Equipment type, const flatbuffers::resolver_function_t *resolver); static void *UnPack(const void *obj, Equipment type, const ::flatbuffers::resolver_function_t *resolver);
flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const; ::flatbuffers::Offset<void> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
MyGame::Sample::WeaponT *AsWeapon() { MyGame::Sample::WeaponT *AsWeapon() {
return type == Equipment_Weapon ? return type == Equipment_Weapon ?
@@ -179,8 +179,8 @@ inline bool operator!=(const EquipmentUnion &lhs, const EquipmentUnion &rhs) {
return !(lhs == rhs); return !(lhs == rhs);
} }
bool VerifyEquipment(flatbuffers::Verifier &verifier, const void *obj, Equipment type); bool VerifyEquipment(::flatbuffers::Verifier &verifier, const void *obj, Equipment type);
bool VerifyEquipmentVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types); bool VerifyEquipmentVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Vec3 FLATBUFFERS_FINAL_CLASS { FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Vec3 FLATBUFFERS_FINAL_CLASS {
private: private:
@@ -189,7 +189,7 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Vec3 FLATBUFFERS_FINAL_CLASS {
float z_; float z_;
public: public:
static const flatbuffers::TypeTable *MiniReflectTypeTable() { static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return Vec3TypeTable(); return Vec3TypeTable();
} }
Vec3() Vec3()
@@ -198,27 +198,27 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Vec3 FLATBUFFERS_FINAL_CLASS {
z_(0) { z_(0) {
} }
Vec3(float _x, float _y, float _z) Vec3(float _x, float _y, float _z)
: x_(flatbuffers::EndianScalar(_x)), : x_(::flatbuffers::EndianScalar(_x)),
y_(flatbuffers::EndianScalar(_y)), y_(::flatbuffers::EndianScalar(_y)),
z_(flatbuffers::EndianScalar(_z)) { z_(::flatbuffers::EndianScalar(_z)) {
} }
float x() const { float x() const {
return flatbuffers::EndianScalar(x_); return ::flatbuffers::EndianScalar(x_);
} }
void mutate_x(float _x) { void mutate_x(float _x) {
flatbuffers::WriteScalar(&x_, _x); ::flatbuffers::WriteScalar(&x_, _x);
} }
float y() const { float y() const {
return flatbuffers::EndianScalar(y_); return ::flatbuffers::EndianScalar(y_);
} }
void mutate_y(float _y) { void mutate_y(float _y) {
flatbuffers::WriteScalar(&y_, _y); ::flatbuffers::WriteScalar(&y_, _y);
} }
float z() const { float z() const {
return flatbuffers::EndianScalar(z_); return ::flatbuffers::EndianScalar(z_);
} }
void mutate_z(float _z) { void mutate_z(float _z) {
flatbuffers::WriteScalar(&z_, _z); ::flatbuffers::WriteScalar(&z_, _z);
} }
}; };
FLATBUFFERS_STRUCT_END(Vec3, 12); FLATBUFFERS_STRUCT_END(Vec3, 12);
@@ -235,7 +235,7 @@ inline bool operator!=(const Vec3 &lhs, const Vec3 &rhs) {
} }
struct MonsterT : public flatbuffers::NativeTable { struct MonsterT : public ::flatbuffers::NativeTable {
typedef Monster TableType; typedef Monster TableType;
flatbuffers::unique_ptr<MyGame::Sample::Vec3> pos{}; flatbuffers::unique_ptr<MyGame::Sample::Vec3> pos{};
int16_t mana = 150; int16_t mana = 150;
@@ -252,10 +252,10 @@ struct MonsterT : public flatbuffers::NativeTable {
MonsterT &operator=(MonsterT o) FLATBUFFERS_NOEXCEPT; MonsterT &operator=(MonsterT o) FLATBUFFERS_NOEXCEPT;
}; };
struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef MonsterT NativeTableType; typedef MonsterT NativeTableType;
typedef MonsterBuilder Builder; typedef MonsterBuilder Builder;
static const flatbuffers::TypeTable *MiniReflectTypeTable() { static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return MonsterTypeTable(); return MonsterTypeTable();
} }
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
@@ -288,17 +288,17 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool mutate_hp(int16_t _hp = 100) { bool mutate_hp(int16_t _hp = 100) {
return SetField<int16_t>(VT_HP, _hp, 100); return SetField<int16_t>(VT_HP, _hp, 100);
} }
const flatbuffers::String *name() const { const ::flatbuffers::String *name() const {
return GetPointer<const flatbuffers::String *>(VT_NAME); return GetPointer<const ::flatbuffers::String *>(VT_NAME);
} }
flatbuffers::String *mutable_name() { ::flatbuffers::String *mutable_name() {
return GetPointer<flatbuffers::String *>(VT_NAME); return GetPointer<::flatbuffers::String *>(VT_NAME);
} }
const flatbuffers::Vector<uint8_t> *inventory() const { const ::flatbuffers::Vector<uint8_t> *inventory() const {
return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_INVENTORY); return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_INVENTORY);
} }
flatbuffers::Vector<uint8_t> *mutable_inventory() { ::flatbuffers::Vector<uint8_t> *mutable_inventory() {
return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_INVENTORY); return GetPointer<::flatbuffers::Vector<uint8_t> *>(VT_INVENTORY);
} }
MyGame::Sample::Color color() const { MyGame::Sample::Color color() const {
return static_cast<MyGame::Sample::Color>(GetField<int8_t>(VT_COLOR, 2)); return static_cast<MyGame::Sample::Color>(GetField<int8_t>(VT_COLOR, 2));
@@ -306,11 +306,11 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool mutate_color(MyGame::Sample::Color _color = static_cast<MyGame::Sample::Color>(2)) { bool mutate_color(MyGame::Sample::Color _color = static_cast<MyGame::Sample::Color>(2)) {
return SetField<int8_t>(VT_COLOR, static_cast<int8_t>(_color), 2); return SetField<int8_t>(VT_COLOR, static_cast<int8_t>(_color), 2);
} }
const flatbuffers::Vector<flatbuffers::Offset<MyGame::Sample::Weapon>> *weapons() const { const ::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Sample::Weapon>> *weapons() const {
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<MyGame::Sample::Weapon>> *>(VT_WEAPONS); return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Sample::Weapon>> *>(VT_WEAPONS);
} }
flatbuffers::Vector<flatbuffers::Offset<MyGame::Sample::Weapon>> *mutable_weapons() { ::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Sample::Weapon>> *mutable_weapons() {
return GetPointer<flatbuffers::Vector<flatbuffers::Offset<MyGame::Sample::Weapon>> *>(VT_WEAPONS); return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Sample::Weapon>> *>(VT_WEAPONS);
} }
MyGame::Sample::Equipment equipped_type() const { MyGame::Sample::Equipment equipped_type() const {
return static_cast<MyGame::Sample::Equipment>(GetField<uint8_t>(VT_EQUIPPED_TYPE, 0)); return static_cast<MyGame::Sample::Equipment>(GetField<uint8_t>(VT_EQUIPPED_TYPE, 0));
@@ -325,13 +325,13 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
void *mutable_equipped() { void *mutable_equipped() {
return GetPointer<void *>(VT_EQUIPPED); return GetPointer<void *>(VT_EQUIPPED);
} }
const flatbuffers::Vector<const MyGame::Sample::Vec3 *> *path() const { const ::flatbuffers::Vector<const MyGame::Sample::Vec3 *> *path() const {
return GetPointer<const flatbuffers::Vector<const MyGame::Sample::Vec3 *> *>(VT_PATH); return GetPointer<const ::flatbuffers::Vector<const MyGame::Sample::Vec3 *> *>(VT_PATH);
} }
flatbuffers::Vector<const MyGame::Sample::Vec3 *> *mutable_path() { ::flatbuffers::Vector<const MyGame::Sample::Vec3 *> *mutable_path() {
return GetPointer<flatbuffers::Vector<const MyGame::Sample::Vec3 *> *>(VT_PATH); return GetPointer<::flatbuffers::Vector<const MyGame::Sample::Vec3 *> *>(VT_PATH);
} }
bool Verify(flatbuffers::Verifier &verifier) const { bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) && return VerifyTableStart(verifier) &&
VerifyField<MyGame::Sample::Vec3>(verifier, VT_POS, 4) && VerifyField<MyGame::Sample::Vec3>(verifier, VT_POS, 4) &&
VerifyField<int16_t>(verifier, VT_MANA, 2) && VerifyField<int16_t>(verifier, VT_MANA, 2) &&
@@ -351,9 +351,9 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
verifier.VerifyVector(path()) && verifier.VerifyVector(path()) &&
verifier.EndTable(); verifier.EndTable();
} }
MonsterT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; MonsterT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(MonsterT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; void UnPackTo(MonsterT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<Monster> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); static ::flatbuffers::Offset<Monster> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
}; };
template<> inline const MyGame::Sample::Weapon *Monster::equipped_as<MyGame::Sample::Weapon>() const { template<> inline const MyGame::Sample::Weapon *Monster::equipped_as<MyGame::Sample::Weapon>() const {
@@ -362,8 +362,8 @@ template<> inline const MyGame::Sample::Weapon *Monster::equipped_as<MyGame::Sam
struct MonsterBuilder { struct MonsterBuilder {
typedef Monster Table; typedef Monster Table;
flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_; ::flatbuffers::uoffset_t start_;
void add_pos(const MyGame::Sample::Vec3 *pos) { void add_pos(const MyGame::Sample::Vec3 *pos) {
fbb_.AddStruct(Monster::VT_POS, pos); fbb_.AddStruct(Monster::VT_POS, pos);
} }
@@ -373,50 +373,50 @@ struct MonsterBuilder {
void add_hp(int16_t hp) { void add_hp(int16_t hp) {
fbb_.AddElement<int16_t>(Monster::VT_HP, hp, 100); fbb_.AddElement<int16_t>(Monster::VT_HP, hp, 100);
} }
void add_name(flatbuffers::Offset<flatbuffers::String> name) { void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
fbb_.AddOffset(Monster::VT_NAME, name); fbb_.AddOffset(Monster::VT_NAME, name);
} }
void add_inventory(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> inventory) { void add_inventory(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> inventory) {
fbb_.AddOffset(Monster::VT_INVENTORY, inventory); fbb_.AddOffset(Monster::VT_INVENTORY, inventory);
} }
void add_color(MyGame::Sample::Color color) { void add_color(MyGame::Sample::Color color) {
fbb_.AddElement<int8_t>(Monster::VT_COLOR, static_cast<int8_t>(color), 2); fbb_.AddElement<int8_t>(Monster::VT_COLOR, static_cast<int8_t>(color), 2);
} }
void add_weapons(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<MyGame::Sample::Weapon>>> weapons) { void add_weapons(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Sample::Weapon>>> weapons) {
fbb_.AddOffset(Monster::VT_WEAPONS, weapons); fbb_.AddOffset(Monster::VT_WEAPONS, weapons);
} }
void add_equipped_type(MyGame::Sample::Equipment equipped_type) { void add_equipped_type(MyGame::Sample::Equipment equipped_type) {
fbb_.AddElement<uint8_t>(Monster::VT_EQUIPPED_TYPE, static_cast<uint8_t>(equipped_type), 0); fbb_.AddElement<uint8_t>(Monster::VT_EQUIPPED_TYPE, static_cast<uint8_t>(equipped_type), 0);
} }
void add_equipped(flatbuffers::Offset<void> equipped) { void add_equipped(::flatbuffers::Offset<void> equipped) {
fbb_.AddOffset(Monster::VT_EQUIPPED, equipped); fbb_.AddOffset(Monster::VT_EQUIPPED, equipped);
} }
void add_path(flatbuffers::Offset<flatbuffers::Vector<const MyGame::Sample::Vec3 *>> path) { void add_path(::flatbuffers::Offset<::flatbuffers::Vector<const MyGame::Sample::Vec3 *>> path) {
fbb_.AddOffset(Monster::VT_PATH, path); fbb_.AddOffset(Monster::VT_PATH, path);
} }
explicit MonsterBuilder(flatbuffers::FlatBufferBuilder &_fbb) explicit MonsterBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) { : fbb_(_fbb) {
start_ = fbb_.StartTable(); start_ = fbb_.StartTable();
} }
flatbuffers::Offset<Monster> Finish() { ::flatbuffers::Offset<Monster> Finish() {
const auto end = fbb_.EndTable(start_); const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<Monster>(end); auto o = ::flatbuffers::Offset<Monster>(end);
return o; return o;
} }
}; };
inline flatbuffers::Offset<Monster> CreateMonster( inline ::flatbuffers::Offset<Monster> CreateMonster(
flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::FlatBufferBuilder &_fbb,
const MyGame::Sample::Vec3 *pos = nullptr, const MyGame::Sample::Vec3 *pos = nullptr,
int16_t mana = 150, int16_t mana = 150,
int16_t hp = 100, int16_t hp = 100,
flatbuffers::Offset<flatbuffers::String> name = 0, ::flatbuffers::Offset<::flatbuffers::String> name = 0,
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> inventory = 0, ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> inventory = 0,
MyGame::Sample::Color color = MyGame::Sample::Color_Blue, MyGame::Sample::Color color = MyGame::Sample::Color_Blue,
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<MyGame::Sample::Weapon>>> weapons = 0, ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<MyGame::Sample::Weapon>>> weapons = 0,
MyGame::Sample::Equipment equipped_type = MyGame::Sample::Equipment_NONE, MyGame::Sample::Equipment equipped_type = MyGame::Sample::Equipment_NONE,
flatbuffers::Offset<void> equipped = 0, ::flatbuffers::Offset<void> equipped = 0,
flatbuffers::Offset<flatbuffers::Vector<const MyGame::Sample::Vec3 *>> path = 0) { ::flatbuffers::Offset<::flatbuffers::Vector<const MyGame::Sample::Vec3 *>> path = 0) {
MonsterBuilder builder_(_fbb); MonsterBuilder builder_(_fbb);
builder_.add_path(path); builder_.add_path(path);
builder_.add_equipped(equipped); builder_.add_equipped(equipped);
@@ -431,21 +431,21 @@ inline flatbuffers::Offset<Monster> CreateMonster(
return builder_.Finish(); return builder_.Finish();
} }
inline flatbuffers::Offset<Monster> CreateMonsterDirect( inline ::flatbuffers::Offset<Monster> CreateMonsterDirect(
flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::FlatBufferBuilder &_fbb,
const MyGame::Sample::Vec3 *pos = nullptr, const MyGame::Sample::Vec3 *pos = nullptr,
int16_t mana = 150, int16_t mana = 150,
int16_t hp = 100, int16_t hp = 100,
const char *name = nullptr, const char *name = nullptr,
const std::vector<uint8_t> *inventory = nullptr, const std::vector<uint8_t> *inventory = nullptr,
MyGame::Sample::Color color = MyGame::Sample::Color_Blue, MyGame::Sample::Color color = MyGame::Sample::Color_Blue,
const std::vector<flatbuffers::Offset<MyGame::Sample::Weapon>> *weapons = nullptr, const std::vector<::flatbuffers::Offset<MyGame::Sample::Weapon>> *weapons = nullptr,
MyGame::Sample::Equipment equipped_type = MyGame::Sample::Equipment_NONE, MyGame::Sample::Equipment equipped_type = MyGame::Sample::Equipment_NONE,
flatbuffers::Offset<void> equipped = 0, ::flatbuffers::Offset<void> equipped = 0,
const std::vector<MyGame::Sample::Vec3> *path = nullptr) { const std::vector<MyGame::Sample::Vec3> *path = nullptr) {
auto name__ = name ? _fbb.CreateString(name) : 0; auto name__ = name ? _fbb.CreateString(name) : 0;
auto inventory__ = inventory ? _fbb.CreateVector<uint8_t>(*inventory) : 0; auto inventory__ = inventory ? _fbb.CreateVector<uint8_t>(*inventory) : 0;
auto weapons__ = weapons ? _fbb.CreateVector<flatbuffers::Offset<MyGame::Sample::Weapon>>(*weapons) : 0; auto weapons__ = weapons ? _fbb.CreateVector<::flatbuffers::Offset<MyGame::Sample::Weapon>>(*weapons) : 0;
auto path__ = path ? _fbb.CreateVectorOfStructs<MyGame::Sample::Vec3>(*path) : 0; auto path__ = path ? _fbb.CreateVectorOfStructs<MyGame::Sample::Vec3>(*path) : 0;
return MyGame::Sample::CreateMonster( return MyGame::Sample::CreateMonster(
_fbb, _fbb,
@@ -461,29 +461,29 @@ inline flatbuffers::Offset<Monster> CreateMonsterDirect(
path__); path__);
} }
flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); ::flatbuffers::Offset<Monster> CreateMonster(::flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct WeaponT : public flatbuffers::NativeTable { struct WeaponT : public ::flatbuffers::NativeTable {
typedef Weapon TableType; typedef Weapon TableType;
std::string name{}; std::string name{};
int16_t damage = 0; int16_t damage = 0;
}; };
struct Weapon FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { struct Weapon FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef WeaponT NativeTableType; typedef WeaponT NativeTableType;
typedef WeaponBuilder Builder; typedef WeaponBuilder Builder;
static const flatbuffers::TypeTable *MiniReflectTypeTable() { static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return WeaponTypeTable(); return WeaponTypeTable();
} }
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_NAME = 4, VT_NAME = 4,
VT_DAMAGE = 6 VT_DAMAGE = 6
}; };
const flatbuffers::String *name() const { const ::flatbuffers::String *name() const {
return GetPointer<const flatbuffers::String *>(VT_NAME); return GetPointer<const ::flatbuffers::String *>(VT_NAME);
} }
flatbuffers::String *mutable_name() { ::flatbuffers::String *mutable_name() {
return GetPointer<flatbuffers::String *>(VT_NAME); return GetPointer<::flatbuffers::String *>(VT_NAME);
} }
int16_t damage() const { int16_t damage() const {
return GetField<int16_t>(VT_DAMAGE, 0); return GetField<int16_t>(VT_DAMAGE, 0);
@@ -491,42 +491,42 @@ struct Weapon FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool mutate_damage(int16_t _damage = 0) { bool mutate_damage(int16_t _damage = 0) {
return SetField<int16_t>(VT_DAMAGE, _damage, 0); return SetField<int16_t>(VT_DAMAGE, _damage, 0);
} }
bool Verify(flatbuffers::Verifier &verifier) const { bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) && return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_NAME) && VerifyOffset(verifier, VT_NAME) &&
verifier.VerifyString(name()) && verifier.VerifyString(name()) &&
VerifyField<int16_t>(verifier, VT_DAMAGE, 2) && VerifyField<int16_t>(verifier, VT_DAMAGE, 2) &&
verifier.EndTable(); verifier.EndTable();
} }
WeaponT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; WeaponT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(WeaponT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; void UnPackTo(WeaponT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<Weapon> Pack(flatbuffers::FlatBufferBuilder &_fbb, const WeaponT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); static ::flatbuffers::Offset<Weapon> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const WeaponT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
}; };
struct WeaponBuilder { struct WeaponBuilder {
typedef Weapon Table; typedef Weapon Table;
flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_; ::flatbuffers::uoffset_t start_;
void add_name(flatbuffers::Offset<flatbuffers::String> name) { void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
fbb_.AddOffset(Weapon::VT_NAME, name); fbb_.AddOffset(Weapon::VT_NAME, name);
} }
void add_damage(int16_t damage) { void add_damage(int16_t damage) {
fbb_.AddElement<int16_t>(Weapon::VT_DAMAGE, damage, 0); fbb_.AddElement<int16_t>(Weapon::VT_DAMAGE, damage, 0);
} }
explicit WeaponBuilder(flatbuffers::FlatBufferBuilder &_fbb) explicit WeaponBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) { : fbb_(_fbb) {
start_ = fbb_.StartTable(); start_ = fbb_.StartTable();
} }
flatbuffers::Offset<Weapon> Finish() { ::flatbuffers::Offset<Weapon> Finish() {
const auto end = fbb_.EndTable(start_); const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<Weapon>(end); auto o = ::flatbuffers::Offset<Weapon>(end);
return o; return o;
} }
}; };
inline flatbuffers::Offset<Weapon> CreateWeapon( inline ::flatbuffers::Offset<Weapon> CreateWeapon(
flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<flatbuffers::String> name = 0, ::flatbuffers::Offset<::flatbuffers::String> name = 0,
int16_t damage = 0) { int16_t damage = 0) {
WeaponBuilder builder_(_fbb); WeaponBuilder builder_(_fbb);
builder_.add_name(name); builder_.add_name(name);
@@ -534,8 +534,8 @@ inline flatbuffers::Offset<Weapon> CreateWeapon(
return builder_.Finish(); return builder_.Finish();
} }
inline flatbuffers::Offset<Weapon> CreateWeaponDirect( inline ::flatbuffers::Offset<Weapon> CreateWeaponDirect(
flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::FlatBufferBuilder &_fbb,
const char *name = nullptr, const char *name = nullptr,
int16_t damage = 0) { int16_t damage = 0) {
auto name__ = name ? _fbb.CreateString(name) : 0; auto name__ = name ? _fbb.CreateString(name) : 0;
@@ -545,7 +545,7 @@ inline flatbuffers::Offset<Weapon> CreateWeaponDirect(
damage); damage);
} }
flatbuffers::Offset<Weapon> CreateWeapon(flatbuffers::FlatBufferBuilder &_fbb, const WeaponT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); ::flatbuffers::Offset<Weapon> CreateWeapon(::flatbuffers::FlatBufferBuilder &_fbb, const WeaponT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
inline bool operator==(const MonsterT &lhs, const MonsterT &rhs) { inline bool operator==(const MonsterT &lhs, const MonsterT &rhs) {
@@ -592,13 +592,13 @@ inline MonsterT &MonsterT::operator=(MonsterT o) FLATBUFFERS_NOEXCEPT {
return *this; return *this;
} }
inline MonsterT *Monster::UnPack(const flatbuffers::resolver_function_t *_resolver) const { inline MonsterT *Monster::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
auto _o = std::unique_ptr<MonsterT>(new MonsterT()); auto _o = std::unique_ptr<MonsterT>(new MonsterT());
UnPackTo(_o.get(), _resolver); UnPackTo(_o.get(), _resolver);
return _o.release(); return _o.release();
} }
inline void Monster::UnPackTo(MonsterT *_o, const flatbuffers::resolver_function_t *_resolver) const { inline void Monster::UnPackTo(MonsterT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
(void)_o; (void)_o;
(void)_resolver; (void)_resolver;
{ auto _e = pos(); if (_e) _o->pos = flatbuffers::unique_ptr<MyGame::Sample::Vec3>(new MyGame::Sample::Vec3(*_e)); } { auto _e = pos(); if (_e) _o->pos = flatbuffers::unique_ptr<MyGame::Sample::Vec3>(new MyGame::Sample::Vec3(*_e)); }
@@ -607,27 +607,27 @@ inline void Monster::UnPackTo(MonsterT *_o, const flatbuffers::resolver_function
{ auto _e = name(); if (_e) _o->name = _e->str(); } { auto _e = name(); if (_e) _o->name = _e->str(); }
{ auto _e = inventory(); if (_e) { _o->inventory.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->inventory.begin()); } } { auto _e = inventory(); if (_e) { _o->inventory.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->inventory.begin()); } }
{ auto _e = color(); _o->color = _e; } { auto _e = color(); _o->color = _e; }
{ auto _e = weapons(); if (_e) { _o->weapons.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->weapons[_i]) { _e->Get(_i)->UnPackTo(_o->weapons[_i].get(), _resolver); } else { _o->weapons[_i] = flatbuffers::unique_ptr<MyGame::Sample::WeaponT>(_e->Get(_i)->UnPack(_resolver)); }; } } else { _o->weapons.resize(0); } } { auto _e = weapons(); if (_e) { _o->weapons.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->weapons[_i]) { _e->Get(_i)->UnPackTo(_o->weapons[_i].get(), _resolver); } else { _o->weapons[_i] = flatbuffers::unique_ptr<MyGame::Sample::WeaponT>(_e->Get(_i)->UnPack(_resolver)); }; } } else { _o->weapons.resize(0); } }
{ auto _e = equipped_type(); _o->equipped.type = _e; } { auto _e = equipped_type(); _o->equipped.type = _e; }
{ auto _e = equipped(); if (_e) _o->equipped.value = MyGame::Sample::EquipmentUnion::UnPack(_e, equipped_type(), _resolver); } { auto _e = equipped(); if (_e) _o->equipped.value = MyGame::Sample::EquipmentUnion::UnPack(_e, equipped_type(), _resolver); }
{ auto _e = path(); if (_e) { _o->path.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->path[_i] = *_e->Get(_i); } } else { _o->path.resize(0); } } { auto _e = path(); if (_e) { _o->path.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->path[_i] = *_e->Get(_i); } } else { _o->path.resize(0); } }
} }
inline flatbuffers::Offset<Monster> Monster::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const flatbuffers::rehasher_function_t *_rehasher) { inline ::flatbuffers::Offset<Monster> Monster::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateMonster(_fbb, _o, _rehasher); return CreateMonster(_fbb, _o, _rehasher);
} }
inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher) { inline ::flatbuffers::Offset<Monster> CreateMonster(::flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher; (void)_rehasher;
(void)_o; (void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MonsterT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const MonsterT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _pos = _o->pos ? _o->pos.get() : nullptr; auto _pos = _o->pos ? _o->pos.get() : nullptr;
auto _mana = _o->mana; auto _mana = _o->mana;
auto _hp = _o->hp; auto _hp = _o->hp;
auto _name = _o->name.empty() ? 0 : _fbb.CreateString(_o->name); auto _name = _o->name.empty() ? 0 : _fbb.CreateString(_o->name);
auto _inventory = _o->inventory.size() ? _fbb.CreateVector(_o->inventory) : 0; auto _inventory = _o->inventory.size() ? _fbb.CreateVector(_o->inventory) : 0;
auto _color = _o->color; auto _color = _o->color;
auto _weapons = _o->weapons.size() ? _fbb.CreateVector<flatbuffers::Offset<MyGame::Sample::Weapon>> (_o->weapons.size(), [](size_t i, _VectorArgs *__va) { return CreateWeapon(*__va->__fbb, __va->__o->weapons[i].get(), __va->__rehasher); }, &_va ) : 0; auto _weapons = _o->weapons.size() ? _fbb.CreateVector<::flatbuffers::Offset<MyGame::Sample::Weapon>> (_o->weapons.size(), [](size_t i, _VectorArgs *__va) { return CreateWeapon(*__va->__fbb, __va->__o->weapons[i].get(), __va->__rehasher); }, &_va ) : 0;
auto _equipped_type = _o->equipped.type; auto _equipped_type = _o->equipped.type;
auto _equipped = _o->equipped.Pack(_fbb); auto _equipped = _o->equipped.Pack(_fbb);
auto _path = _o->path.size() ? _fbb.CreateVectorOfStructs(_o->path) : 0; auto _path = _o->path.size() ? _fbb.CreateVectorOfStructs(_o->path) : 0;
@@ -657,27 +657,27 @@ inline bool operator!=(const WeaponT &lhs, const WeaponT &rhs) {
} }
inline WeaponT *Weapon::UnPack(const flatbuffers::resolver_function_t *_resolver) const { inline WeaponT *Weapon::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
auto _o = std::unique_ptr<WeaponT>(new WeaponT()); auto _o = std::unique_ptr<WeaponT>(new WeaponT());
UnPackTo(_o.get(), _resolver); UnPackTo(_o.get(), _resolver);
return _o.release(); return _o.release();
} }
inline void Weapon::UnPackTo(WeaponT *_o, const flatbuffers::resolver_function_t *_resolver) const { inline void Weapon::UnPackTo(WeaponT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
(void)_o; (void)_o;
(void)_resolver; (void)_resolver;
{ auto _e = name(); if (_e) _o->name = _e->str(); } { auto _e = name(); if (_e) _o->name = _e->str(); }
{ auto _e = damage(); _o->damage = _e; } { auto _e = damage(); _o->damage = _e; }
} }
inline flatbuffers::Offset<Weapon> Weapon::Pack(flatbuffers::FlatBufferBuilder &_fbb, const WeaponT* _o, const flatbuffers::rehasher_function_t *_rehasher) { inline ::flatbuffers::Offset<Weapon> Weapon::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const WeaponT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateWeapon(_fbb, _o, _rehasher); return CreateWeapon(_fbb, _o, _rehasher);
} }
inline flatbuffers::Offset<Weapon> CreateWeapon(flatbuffers::FlatBufferBuilder &_fbb, const WeaponT *_o, const flatbuffers::rehasher_function_t *_rehasher) { inline ::flatbuffers::Offset<Weapon> CreateWeapon(::flatbuffers::FlatBufferBuilder &_fbb, const WeaponT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher; (void)_rehasher;
(void)_o; (void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const WeaponT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const WeaponT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _name = _o->name.empty() ? 0 : _fbb.CreateString(_o->name); auto _name = _o->name.empty() ? 0 : _fbb.CreateString(_o->name);
auto _damage = _o->damage; auto _damage = _o->damage;
return MyGame::Sample::CreateWeapon( return MyGame::Sample::CreateWeapon(
@@ -686,7 +686,7 @@ inline flatbuffers::Offset<Weapon> CreateWeapon(flatbuffers::FlatBufferBuilder &
_damage); _damage);
} }
inline bool VerifyEquipment(flatbuffers::Verifier &verifier, const void *obj, Equipment type) { inline bool VerifyEquipment(::flatbuffers::Verifier &verifier, const void *obj, Equipment type) {
switch (type) { switch (type) {
case Equipment_NONE: { case Equipment_NONE: {
return true; return true;
@@ -699,10 +699,10 @@ inline bool VerifyEquipment(flatbuffers::Verifier &verifier, const void *obj, Eq
} }
} }
inline bool VerifyEquipmentVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) { inline bool VerifyEquipmentVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
if (!values || !types) return !values && !types; if (!values || !types) return !values && !types;
if (values->size() != types->size()) return false; 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 (!VerifyEquipment( if (!VerifyEquipment(
verifier, values->Get(i), types->GetEnum<Equipment>(i))) { verifier, values->Get(i), types->GetEnum<Equipment>(i))) {
return false; return false;
@@ -711,7 +711,7 @@ inline bool VerifyEquipmentVector(flatbuffers::Verifier &verifier, const flatbuf
return true; return true;
} }
inline void *EquipmentUnion::UnPack(const void *obj, Equipment type, const flatbuffers::resolver_function_t *resolver) { inline void *EquipmentUnion::UnPack(const void *obj, Equipment type, const ::flatbuffers::resolver_function_t *resolver) {
(void)resolver; (void)resolver;
switch (type) { switch (type) {
case Equipment_Weapon: { case Equipment_Weapon: {
@@ -722,7 +722,7 @@ inline void *EquipmentUnion::UnPack(const void *obj, Equipment type, const flatb
} }
} }
inline flatbuffers::Offset<void> EquipmentUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const { inline ::flatbuffers::Offset<void> EquipmentUnion::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher) const {
(void)_rehasher; (void)_rehasher;
switch (type) { switch (type) {
case Equipment_Weapon: { case Equipment_Weapon: {
@@ -757,13 +757,13 @@ inline void EquipmentUnion::Reset() {
type = Equipment_NONE; type = Equipment_NONE;
} }
inline const flatbuffers::TypeTable *ColorTypeTable() { inline const ::flatbuffers::TypeTable *ColorTypeTable() {
static const flatbuffers::TypeCode type_codes[] = { static const ::flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_CHAR, 0, 0 }, { ::flatbuffers::ET_CHAR, 0, 0 },
{ flatbuffers::ET_CHAR, 0, 0 }, { ::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[] = {
MyGame::Sample::ColorTypeTable MyGame::Sample::ColorTypeTable
}; };
static const char * const names[] = { static const char * const names[] = {
@@ -771,35 +771,35 @@ inline const flatbuffers::TypeTable *ColorTypeTable() {
"Green", "Green",
"Blue" "Blue"
}; };
static const flatbuffers::TypeTable tt = { static const ::flatbuffers::TypeTable tt = {
flatbuffers::ST_ENUM, 3, type_codes, type_refs, nullptr, nullptr, names ::flatbuffers::ST_ENUM, 3, type_codes, type_refs, nullptr, nullptr, names
}; };
return &tt; return &tt;
} }
inline const flatbuffers::TypeTable *EquipmentTypeTable() { inline const ::flatbuffers::TypeTable *EquipmentTypeTable() {
static const flatbuffers::TypeCode type_codes[] = { static const ::flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_SEQUENCE, 0, -1 }, { ::flatbuffers::ET_SEQUENCE, 0, -1 },
{ flatbuffers::ET_SEQUENCE, 0, 0 } { ::flatbuffers::ET_SEQUENCE, 0, 0 }
}; };
static const flatbuffers::TypeFunction type_refs[] = { static const ::flatbuffers::TypeFunction type_refs[] = {
MyGame::Sample::WeaponTypeTable MyGame::Sample::WeaponTypeTable
}; };
static const char * const names[] = { static const char * const names[] = {
"NONE", "NONE",
"Weapon" "Weapon"
}; };
static const flatbuffers::TypeTable tt = { static const ::flatbuffers::TypeTable tt = {
flatbuffers::ST_UNION, 2, type_codes, type_refs, nullptr, nullptr, names ::flatbuffers::ST_UNION, 2, type_codes, type_refs, nullptr, nullptr, names
}; };
return &tt; return &tt;
} }
inline const flatbuffers::TypeTable *Vec3TypeTable() { inline const ::flatbuffers::TypeTable *Vec3TypeTable() {
static const flatbuffers::TypeCode type_codes[] = { static const ::flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_FLOAT, 0, -1 }, { ::flatbuffers::ET_FLOAT, 0, -1 },
{ flatbuffers::ET_FLOAT, 0, -1 }, { ::flatbuffers::ET_FLOAT, 0, -1 },
{ flatbuffers::ET_FLOAT, 0, -1 } { ::flatbuffers::ET_FLOAT, 0, -1 }
}; };
static const int64_t values[] = { 0, 4, 8, 12 }; static const int64_t values[] = { 0, 4, 8, 12 };
static const char * const names[] = { static const char * const names[] = {
@@ -807,27 +807,27 @@ inline const flatbuffers::TypeTable *Vec3TypeTable() {
"y", "y",
"z" "z"
}; };
static const flatbuffers::TypeTable tt = { static const ::flatbuffers::TypeTable tt = {
flatbuffers::ST_STRUCT, 3, type_codes, nullptr, nullptr, values, names ::flatbuffers::ST_STRUCT, 3, type_codes, nullptr, nullptr, values, names
}; };
return &tt; return &tt;
} }
inline const flatbuffers::TypeTable *MonsterTypeTable() { inline const ::flatbuffers::TypeTable *MonsterTypeTable() {
static const flatbuffers::TypeCode type_codes[] = { static const ::flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_SEQUENCE, 0, 0 }, { ::flatbuffers::ET_SEQUENCE, 0, 0 },
{ flatbuffers::ET_SHORT, 0, -1 }, { ::flatbuffers::ET_SHORT, 0, -1 },
{ flatbuffers::ET_SHORT, 0, -1 }, { ::flatbuffers::ET_SHORT, 0, -1 },
{ flatbuffers::ET_STRING, 0, -1 }, { ::flatbuffers::ET_STRING, 0, -1 },
{ flatbuffers::ET_BOOL, 0, -1 }, { ::flatbuffers::ET_BOOL, 0, -1 },
{ flatbuffers::ET_UCHAR, 1, -1 }, { ::flatbuffers::ET_UCHAR, 1, -1 },
{ flatbuffers::ET_CHAR, 0, 1 }, { ::flatbuffers::ET_CHAR, 0, 1 },
{ flatbuffers::ET_SEQUENCE, 1, 2 }, { ::flatbuffers::ET_SEQUENCE, 1, 2 },
{ flatbuffers::ET_UTYPE, 0, 3 }, { ::flatbuffers::ET_UTYPE, 0, 3 },
{ flatbuffers::ET_SEQUENCE, 0, 3 }, { ::flatbuffers::ET_SEQUENCE, 0, 3 },
{ flatbuffers::ET_SEQUENCE, 1, 0 } { ::flatbuffers::ET_SEQUENCE, 1, 0 }
}; };
static const flatbuffers::TypeFunction type_refs[] = { static const ::flatbuffers::TypeFunction type_refs[] = {
MyGame::Sample::Vec3TypeTable, MyGame::Sample::Vec3TypeTable,
MyGame::Sample::ColorTypeTable, MyGame::Sample::ColorTypeTable,
MyGame::Sample::WeaponTypeTable, MyGame::Sample::WeaponTypeTable,
@@ -846,74 +846,74 @@ inline const flatbuffers::TypeTable *MonsterTypeTable() {
"equipped", "equipped",
"path" "path"
}; };
static const flatbuffers::TypeTable tt = { static const ::flatbuffers::TypeTable tt = {
flatbuffers::ST_TABLE, 11, type_codes, type_refs, nullptr, nullptr, names ::flatbuffers::ST_TABLE, 11, type_codes, type_refs, nullptr, nullptr, names
}; };
return &tt; return &tt;
} }
inline const flatbuffers::TypeTable *WeaponTypeTable() { inline const ::flatbuffers::TypeTable *WeaponTypeTable() {
static const flatbuffers::TypeCode type_codes[] = { static const ::flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_STRING, 0, -1 }, { ::flatbuffers::ET_STRING, 0, -1 },
{ flatbuffers::ET_SHORT, 0, -1 } { ::flatbuffers::ET_SHORT, 0, -1 }
}; };
static const char * const names[] = { static const char * const names[] = {
"name", "name",
"damage" "damage"
}; };
static const flatbuffers::TypeTable tt = { static const ::flatbuffers::TypeTable tt = {
flatbuffers::ST_TABLE, 2, type_codes, nullptr, nullptr, nullptr, names ::flatbuffers::ST_TABLE, 2, type_codes, nullptr, nullptr, nullptr, names
}; };
return &tt; return &tt;
} }
inline const MyGame::Sample::Monster *GetMonster(const void *buf) { inline const MyGame::Sample::Monster *GetMonster(const void *buf) {
return flatbuffers::GetRoot<MyGame::Sample::Monster>(buf); return ::flatbuffers::GetRoot<MyGame::Sample::Monster>(buf);
} }
inline const MyGame::Sample::Monster *GetSizePrefixedMonster(const void *buf) { inline const MyGame::Sample::Monster *GetSizePrefixedMonster(const void *buf) {
return flatbuffers::GetSizePrefixedRoot<MyGame::Sample::Monster>(buf); return ::flatbuffers::GetSizePrefixedRoot<MyGame::Sample::Monster>(buf);
} }
inline Monster *GetMutableMonster(void *buf) { inline Monster *GetMutableMonster(void *buf) {
return flatbuffers::GetMutableRoot<Monster>(buf); return ::flatbuffers::GetMutableRoot<Monster>(buf);
} }
inline MyGame::Sample::Monster *GetMutableSizePrefixedMonster(void *buf) { inline MyGame::Sample::Monster *GetMutableSizePrefixedMonster(void *buf) {
return flatbuffers::GetMutableSizePrefixedRoot<MyGame::Sample::Monster>(buf); return ::flatbuffers::GetMutableSizePrefixedRoot<MyGame::Sample::Monster>(buf);
} }
inline bool VerifyMonsterBuffer( inline bool VerifyMonsterBuffer(
flatbuffers::Verifier &verifier) { ::flatbuffers::Verifier &verifier) {
return verifier.VerifyBuffer<MyGame::Sample::Monster>(nullptr); return verifier.VerifyBuffer<MyGame::Sample::Monster>(nullptr);
} }
inline bool VerifySizePrefixedMonsterBuffer( inline bool VerifySizePrefixedMonsterBuffer(
flatbuffers::Verifier &verifier) { ::flatbuffers::Verifier &verifier) {
return verifier.VerifySizePrefixedBuffer<MyGame::Sample::Monster>(nullptr); return verifier.VerifySizePrefixedBuffer<MyGame::Sample::Monster>(nullptr);
} }
inline void FinishMonsterBuffer( inline void FinishMonsterBuffer(
flatbuffers::FlatBufferBuilder &fbb, ::flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<MyGame::Sample::Monster> root) { ::flatbuffers::Offset<MyGame::Sample::Monster> root) {
fbb.Finish(root); fbb.Finish(root);
} }
inline void FinishSizePrefixedMonsterBuffer( inline void FinishSizePrefixedMonsterBuffer(
flatbuffers::FlatBufferBuilder &fbb, ::flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<MyGame::Sample::Monster> root) { ::flatbuffers::Offset<MyGame::Sample::Monster> root) {
fbb.FinishSizePrefixed(root); fbb.FinishSizePrefixed(root);
} }
inline flatbuffers::unique_ptr<MyGame::Sample::MonsterT> UnPackMonster( inline flatbuffers::unique_ptr<MyGame::Sample::MonsterT> UnPackMonster(
const void *buf, const void *buf,
const flatbuffers::resolver_function_t *res = nullptr) { const ::flatbuffers::resolver_function_t *res = nullptr) {
return flatbuffers::unique_ptr<MyGame::Sample::MonsterT>(GetMonster(buf)->UnPack(res)); return flatbuffers::unique_ptr<MyGame::Sample::MonsterT>(GetMonster(buf)->UnPack(res));
} }
inline flatbuffers::unique_ptr<MyGame::Sample::MonsterT> UnPackSizePrefixedMonster( inline flatbuffers::unique_ptr<MyGame::Sample::MonsterT> UnPackSizePrefixedMonster(
const void *buf, const void *buf,
const flatbuffers::resolver_function_t *res = nullptr) { const ::flatbuffers::resolver_function_t *res = nullptr) {
return flatbuffers::unique_ptr<MyGame::Sample::MonsterT>(GetSizePrefixedMonster(buf)->UnPack(res)); return flatbuffers::unique_ptr<MyGame::Sample::MonsterT>(GetSizePrefixedMonster(buf)->UnPack(res));
} }

225
src/idl_gen_cpp.cpp
View File

@@ -90,7 +90,7 @@ enum CppStandard { CPP_STD_X0 = 0, CPP_STD_11, CPP_STD_17 };
// Define a style of 'struct' constructor if it has 'Array' fields. // Define a style of 'struct' constructor if it has 'Array' fields.
enum GenArrayArgMode { enum GenArrayArgMode {
kArrayArgModeNone, // don't generate initialization args kArrayArgModeNone, // don't generate initialization args
kArrayArgModeSpanStatic, // generate flatbuffers::span<T,N> kArrayArgModeSpanStatic, // generate ::flatbuffers::span<T,N>
}; };
// Extension of IDLOptions for cpp-generator. // Extension of IDLOptions for cpp-generator.
@@ -252,14 +252,13 @@ class CppGenerator : public BaseGenerator {
// Get the name of the included file as defined by the schema, and strip // Get the name of the included file as defined by the schema, and strip
// the .fbs extension. // the .fbs extension.
const std::string name_without_ext = const std::string name_without_ext =
flatbuffers::StripExtension(included_file.schema_name); StripExtension(included_file.schema_name);
// If we are told to keep the prefix of the included schema, leave it // If we are told to keep the prefix of the included schema, leave it
// unchanged, otherwise strip the leading path off so just the "basename" // unchanged, otherwise strip the leading path off so just the "basename"
// of the include is retained. // of the include is retained.
const std::string basename = const std::string basename =
opts_.keep_prefix ? name_without_ext opts_.keep_prefix ? name_without_ext : StripPath(name_without_ext);
: flatbuffers::StripPath(name_without_ext);
code_ += "#include \"" + code_ += "#include \"" +
GeneratedFileName(opts_.include_prefix, basename, opts_) + "\""; GeneratedFileName(opts_.include_prefix, basename, opts_) + "\"";
@@ -522,7 +521,7 @@ class CppGenerator : public BaseGenerator {
code_ += code_ +=
"const {{CPP_NAME}} *{{NULLABLE_EXT}}Get{{STRUCT_NAME}}(const void " "const {{CPP_NAME}} *{{NULLABLE_EXT}}Get{{STRUCT_NAME}}(const void "
"*buf) {"; "*buf) {";
code_ += " return flatbuffers::GetRoot<{{CPP_NAME}}>(buf);"; code_ += " return ::flatbuffers::GetRoot<{{CPP_NAME}}>(buf);";
code_ += "}"; code_ += "}";
code_ += ""; code_ += "";
@@ -531,14 +530,16 @@ class CppGenerator : public BaseGenerator {
"const {{CPP_NAME}} " "const {{CPP_NAME}} "
"*{{NULLABLE_EXT}}GetSizePrefixed{{STRUCT_NAME}}(const void " "*{{NULLABLE_EXT}}GetSizePrefixed{{STRUCT_NAME}}(const void "
"*buf) {"; "*buf) {";
code_ += " return flatbuffers::GetSizePrefixedRoot<{{CPP_NAME}}>(buf);"; code_ +=
" return ::flatbuffers::GetSizePrefixedRoot<{{CPP_NAME}}>(buf);";
code_ += "}"; code_ += "}";
code_ += ""; code_ += "";
if (opts_.mutable_buffer) { if (opts_.mutable_buffer) {
code_ += "inline \\"; code_ += "inline \\";
code_ += "{{STRUCT_NAME}} *GetMutable{{STRUCT_NAME}}(void *buf) {"; code_ += "{{STRUCT_NAME}} *GetMutable{{STRUCT_NAME}}(void *buf) {";
code_ += " return flatbuffers::GetMutableRoot<{{STRUCT_NAME}}>(buf);"; code_ +=
" return ::flatbuffers::GetMutableRoot<{{STRUCT_NAME}}>(buf);";
code_ += "}"; code_ += "}";
code_ += ""; code_ += "";
@@ -549,7 +550,7 @@ class CppGenerator : public BaseGenerator {
"*buf) {"; "*buf) {";
code_ += code_ +=
" return " " return "
"flatbuffers::GetMutableSizePrefixedRoot<{{CPP_NAME}}>(buf);"; "::flatbuffers::GetMutableSizePrefixedRoot<{{CPP_NAME}}>(buf);";
code_ += "}"; code_ += "}";
code_ += ""; code_ += "";
} }
@@ -564,7 +565,7 @@ class CppGenerator : public BaseGenerator {
// Check if a buffer has the identifier. // Check if a buffer has the identifier.
code_ += "inline \\"; code_ += "inline \\";
code_ += "bool {{STRUCT_NAME}}BufferHasIdentifier(const void *buf) {"; code_ += "bool {{STRUCT_NAME}}BufferHasIdentifier(const void *buf) {";
code_ += " return flatbuffers::BufferHasIdentifier("; code_ += " return ::flatbuffers::BufferHasIdentifier(";
code_ += " buf, {{STRUCT_NAME}}Identifier());"; code_ += " buf, {{STRUCT_NAME}}Identifier());";
code_ += "}"; code_ += "}";
code_ += ""; code_ += "";
@@ -574,7 +575,7 @@ class CppGenerator : public BaseGenerator {
code_ += code_ +=
"bool SizePrefixed{{STRUCT_NAME}}BufferHasIdentifier(const void " "bool SizePrefixed{{STRUCT_NAME}}BufferHasIdentifier(const void "
"*buf) {"; "*buf) {";
code_ += " return flatbuffers::BufferHasIdentifier("; code_ += " return ::flatbuffers::BufferHasIdentifier(";
code_ += " buf, {{STRUCT_NAME}}Identifier(), true);"; code_ += " buf, {{STRUCT_NAME}}Identifier(), true);";
code_ += "}"; code_ += "}";
code_ += ""; code_ += "";
@@ -588,13 +589,13 @@ class CppGenerator : public BaseGenerator {
} }
code_ += "inline bool Verify{{STRUCT_NAME}}Buffer("; code_ += "inline bool Verify{{STRUCT_NAME}}Buffer(";
code_ += " flatbuffers::Verifier &verifier) {"; code_ += " ::flatbuffers::Verifier &verifier) {";
code_ += " return verifier.VerifyBuffer<{{CPP_NAME}}>({{ID}});"; code_ += " return verifier.VerifyBuffer<{{CPP_NAME}}>({{ID}});";
code_ += "}"; code_ += "}";
code_ += ""; code_ += "";
code_ += "inline bool VerifySizePrefixed{{STRUCT_NAME}}Buffer("; code_ += "inline bool VerifySizePrefixed{{STRUCT_NAME}}Buffer(";
code_ += " flatbuffers::Verifier &verifier) {"; code_ += " ::flatbuffers::Verifier &verifier) {";
code_ += code_ +=
" return verifier.VerifySizePrefixedBuffer<{{CPP_NAME}}>({{ID}});"; " return verifier.VerifySizePrefixedBuffer<{{CPP_NAME}}>({{ID}});";
code_ += "}"; code_ += "}";
@@ -610,8 +611,8 @@ class CppGenerator : public BaseGenerator {
// Finish a buffer with a given root object: // Finish a buffer with a given root object:
code_ += "inline void Finish{{STRUCT_NAME}}Buffer("; code_ += "inline void Finish{{STRUCT_NAME}}Buffer(";
code_ += " flatbuffers::FlatBufferBuilder &fbb,"; code_ += " ::flatbuffers::FlatBufferBuilder &fbb,";
code_ += " flatbuffers::Offset<{{CPP_NAME}}> root) {"; code_ += " ::flatbuffers::Offset<{{CPP_NAME}}> root) {";
if (parser_.file_identifier_.length()) if (parser_.file_identifier_.length())
code_ += " fbb.Finish(root, {{STRUCT_NAME}}Identifier());"; code_ += " fbb.Finish(root, {{STRUCT_NAME}}Identifier());";
else else
@@ -620,8 +621,8 @@ class CppGenerator : public BaseGenerator {
code_ += ""; code_ += "";
code_ += "inline void FinishSizePrefixed{{STRUCT_NAME}}Buffer("; code_ += "inline void FinishSizePrefixed{{STRUCT_NAME}}Buffer(";
code_ += " flatbuffers::FlatBufferBuilder &fbb,"; code_ += " ::flatbuffers::FlatBufferBuilder &fbb,";
code_ += " flatbuffers::Offset<{{CPP_NAME}}> root) {"; code_ += " ::flatbuffers::Offset<{{CPP_NAME}}> root) {";
if (parser_.file_identifier_.length()) if (parser_.file_identifier_.length())
code_ += " fbb.FinishSizePrefixed(root, {{STRUCT_NAME}}Identifier());"; code_ += " fbb.FinishSizePrefixed(root, {{STRUCT_NAME}}Identifier());";
else else
@@ -639,7 +640,8 @@ class CppGenerator : public BaseGenerator {
code_ += "inline {{UNPACK_RETURN}} UnPack{{STRUCT_NAME}}("; code_ += "inline {{UNPACK_RETURN}} UnPack{{STRUCT_NAME}}(";
code_ += " const void *buf,"; code_ += " const void *buf,";
code_ += " const flatbuffers::resolver_function_t *res = nullptr) {"; code_ +=
" const ::flatbuffers::resolver_function_t *res = nullptr) {";
code_ += " return {{UNPACK_TYPE}}\\"; code_ += " return {{UNPACK_TYPE}}\\";
code_ += "(Get{{STRUCT_NAME}}(buf)->UnPack(res));"; code_ += "(Get{{STRUCT_NAME}}(buf)->UnPack(res));";
code_ += "}"; code_ += "}";
@@ -647,7 +649,8 @@ class CppGenerator : public BaseGenerator {
code_ += "inline {{UNPACK_RETURN}} UnPackSizePrefixed{{STRUCT_NAME}}("; code_ += "inline {{UNPACK_RETURN}} UnPackSizePrefixed{{STRUCT_NAME}}(";
code_ += " const void *buf,"; code_ += " const void *buf,";
code_ += " const flatbuffers::resolver_function_t *res = nullptr) {"; code_ +=
" const ::flatbuffers::resolver_function_t *res = nullptr) {";
code_ += " return {{UNPACK_TYPE}}\\"; code_ += " return {{UNPACK_TYPE}}\\";
code_ += "(GetSizePrefixed{{STRUCT_NAME}}(buf)->UnPack(res));"; code_ += "(GetSizePrefixed{{STRUCT_NAME}}(buf)->UnPack(res));";
code_ += "}"; code_ += "}";
@@ -735,12 +738,12 @@ class CppGenerator : public BaseGenerator {
std::string GenTypePointer(const Type &type) const { std::string GenTypePointer(const Type &type) const {
switch (type.base_type) { switch (type.base_type) {
case BASE_TYPE_STRING: { case BASE_TYPE_STRING: {
return "flatbuffers::String"; return "::flatbuffers::String";
} }
case BASE_TYPE_VECTOR: { case BASE_TYPE_VECTOR: {
const auto type_name = GenTypeWire( const auto type_name = GenTypeWire(
type.VectorType(), "", VectorElementUserFacing(type.VectorType())); type.VectorType(), "", VectorElementUserFacing(type.VectorType()));
return "flatbuffers::Vector<" + type_name + ">"; return "::flatbuffers::Vector<" + type_name + ">";
} }
case BASE_TYPE_STRUCT: { case BASE_TYPE_STRUCT: {
return WrapInNameSpace(*type.struct_def); return WrapInNameSpace(*type.struct_def);
@@ -762,7 +765,7 @@ class CppGenerator : public BaseGenerator {
} else if (IsStruct(type)) { } else if (IsStruct(type)) {
return "const " + GenTypePointer(type) + " *"; return "const " + GenTypePointer(type) + " *";
} else { } else {
return "flatbuffers::Offset<" + GenTypePointer(type) + ">" + postfix; return "::flatbuffers::Offset<" + GenTypePointer(type) + ">" + postfix;
} }
} }
@@ -774,7 +777,7 @@ class CppGenerator : public BaseGenerator {
} else if (IsStruct(type)) { } else if (IsStruct(type)) {
return GenTypePointer(type); return GenTypePointer(type);
} else { } else {
return "flatbuffers::uoffset_t"; return "::flatbuffers::uoffset_t";
} }
} }
@@ -807,7 +810,8 @@ class CppGenerator : public BaseGenerator {
} }
bool FlexibleStringConstructor(const FieldDef *field) { bool FlexibleStringConstructor(const FieldDef *field) {
auto attr = field != nullptr && (field->attributes.Lookup("cpp_str_flex_ctor") != nullptr); auto attr = field != nullptr &&
(field->attributes.Lookup("cpp_str_flex_ctor") != nullptr);
auto ret = attr ? attr : opts_.cpp_object_api_string_flexible_constructor; auto ret = attr ? attr : opts_.cpp_object_api_string_flexible_constructor;
return ret && NativeString(field) != return ret && NativeString(field) !=
"std::string"; // Only for custom string types. "std::string"; // Only for custom string types.
@@ -835,10 +839,10 @@ class CppGenerator : public BaseGenerator {
return ptr_type == "naked" ? "" : ".get()"; return ptr_type == "naked" ? "" : ".get()";
} }
std::string GenOptionalNull() { return "flatbuffers::nullopt"; } std::string GenOptionalNull() { return "::flatbuffers::nullopt"; }
std::string GenOptionalDecl(const Type &type) { std::string GenOptionalDecl(const Type &type) {
return "flatbuffers::Optional<" + GenTypeBasic(type, true) + ">"; return "::flatbuffers::Optional<" + GenTypeBasic(type, true) + ">";
} }
std::string GenTypeNative(const Type &type, bool invector, std::string GenTypeNative(const Type &type, bool invector,
@@ -912,10 +916,10 @@ class CppGenerator : public BaseGenerator {
} }
std::string GenTypeSpan(const Type &type, bool immutable, size_t extent) { std::string GenTypeSpan(const Type &type, bool immutable, size_t extent) {
// Generate "flatbuffers::span<const U, extent>". // Generate "::flatbuffers::span<const U, extent>".
FLATBUFFERS_ASSERT(IsSeries(type) && "unexpected type"); FLATBUFFERS_ASSERT(IsSeries(type) && "unexpected type");
auto element_type = type.VectorType(); auto element_type = type.VectorType();
std::string text = "flatbuffers::span<"; std::string text = "::flatbuffers::span<";
text += immutable ? "const " : ""; text += immutable ? "const " : "";
if (IsScalar(element_type.base_type)) { if (IsScalar(element_type.base_type)) {
text += GenTypeBasic(element_type, IsEnum(element_type)); text += GenTypeBasic(element_type, IsEnum(element_type));
@@ -935,7 +939,7 @@ class CppGenerator : public BaseGenerator {
break; break;
} }
} }
if (extent != flatbuffers::dynamic_extent) { if (extent != dynamic_extent) {
text += ", "; text += ", ";
text += NumToString(extent); text += NumToString(extent);
} }
@@ -972,7 +976,7 @@ class CppGenerator : public BaseGenerator {
} }
return WrapInNameSpace(ev.union_type.struct_def->defined_namespace, name); return WrapInNameSpace(ev.union_type.struct_def->defined_namespace, name);
} else if (IsString(ev.union_type)) { } else if (IsString(ev.union_type)) {
return native_type ? "std::string" : "flatbuffers::String"; return native_type ? "std::string" : "::flatbuffers::String";
} else { } else {
FLATBUFFERS_ASSERT(false); FLATBUFFERS_ASSERT(false);
return Name(ev); return Name(ev);
@@ -981,7 +985,7 @@ class CppGenerator : public BaseGenerator {
std::string UnionVerifySignature(const EnumDef &enum_def) { std::string UnionVerifySignature(const EnumDef &enum_def) {
return "bool Verify" + Name(enum_def) + return "bool Verify" + Name(enum_def) +
"(flatbuffers::Verifier &verifier, const void *obj, " + "(::flatbuffers::Verifier &verifier, const void *obj, " +
Name(enum_def) + " type)"; Name(enum_def) + " type)";
} }
@@ -989,42 +993,44 @@ class CppGenerator : public BaseGenerator {
auto name = Name(enum_def); auto name = Name(enum_def);
auto type = opts_.scoped_enums ? name : "uint8_t"; auto type = opts_.scoped_enums ? name : "uint8_t";
return "bool Verify" + name + "Vector" + return "bool Verify" + name + "Vector" +
"(flatbuffers::Verifier &verifier, " + "(::flatbuffers::Verifier &verifier, " +
"const flatbuffers::Vector<flatbuffers::Offset<void>> *values, " + "const ::flatbuffers::Vector<::flatbuffers::Offset<void>> "
"const flatbuffers::Vector<" + type + "> *types)"; "*values, " +
"const ::flatbuffers::Vector<" + type + "> *types)";
} }
std::string UnionUnPackSignature(const EnumDef &enum_def, bool inclass) { std::string UnionUnPackSignature(const EnumDef &enum_def, bool inclass) {
return (inclass ? "static " : "") + std::string("void *") + return (inclass ? "static " : "") + std::string("void *") +
(inclass ? "" : Name(enum_def) + "Union::") + (inclass ? "" : Name(enum_def) + "Union::") +
"UnPack(const void *obj, " + Name(enum_def) + "UnPack(const void *obj, " + Name(enum_def) +
" type, const flatbuffers::resolver_function_t *resolver)"; " type, const ::flatbuffers::resolver_function_t *resolver)";
} }
std::string UnionPackSignature(const EnumDef &enum_def, bool inclass) { std::string UnionPackSignature(const EnumDef &enum_def, bool inclass) {
return "flatbuffers::Offset<void> " + return "::flatbuffers::Offset<void> " +
(inclass ? "" : Name(enum_def) + "Union::") + (inclass ? "" : Name(enum_def) + "Union::") +
"Pack(flatbuffers::FlatBufferBuilder &_fbb, " + "Pack(::flatbuffers::FlatBufferBuilder &_fbb, " +
"const flatbuffers::rehasher_function_t *_rehasher" + "const ::flatbuffers::rehasher_function_t *_rehasher" +
(inclass ? " = nullptr" : "") + ") const"; (inclass ? " = nullptr" : "") + ") const";
} }
std::string TableCreateSignature(const StructDef &struct_def, bool predecl, std::string TableCreateSignature(const StructDef &struct_def, bool predecl,
const IDLOptions &opts) { const IDLOptions &opts) {
return "flatbuffers::Offset<" + Name(struct_def) + "> Create" + return "::flatbuffers::Offset<" + Name(struct_def) + "> Create" +
Name(struct_def) + "(flatbuffers::FlatBufferBuilder &_fbb, const " + Name(struct_def) +
"(::flatbuffers::FlatBufferBuilder &_fbb, const " +
NativeName(Name(struct_def), &struct_def, opts) + NativeName(Name(struct_def), &struct_def, opts) +
" *_o, const flatbuffers::rehasher_function_t *_rehasher" + " *_o, const ::flatbuffers::rehasher_function_t *_rehasher" +
(predecl ? " = nullptr" : "") + ")"; (predecl ? " = nullptr" : "") + ")";
} }
std::string TablePackSignature(const StructDef &struct_def, bool inclass, std::string TablePackSignature(const StructDef &struct_def, bool inclass,
const IDLOptions &opts) { const IDLOptions &opts) {
return std::string(inclass ? "static " : "") + "flatbuffers::Offset<" + return std::string(inclass ? "static " : "") + "::flatbuffers::Offset<" +
Name(struct_def) + "> " + (inclass ? "" : Name(struct_def) + "::") + Name(struct_def) + "> " + (inclass ? "" : Name(struct_def) + "::") +
"Pack(flatbuffers::FlatBufferBuilder &_fbb, " + "const " + "Pack(::flatbuffers::FlatBufferBuilder &_fbb, " + "const " +
NativeName(Name(struct_def), &struct_def, opts) + "* _o, " + NativeName(Name(struct_def), &struct_def, opts) + "* _o, " +
"const flatbuffers::rehasher_function_t *_rehasher" + "const ::flatbuffers::rehasher_function_t *_rehasher" +
(inclass ? " = nullptr" : "") + ")"; (inclass ? " = nullptr" : "") + ")";
} }
@@ -1032,7 +1038,7 @@ class CppGenerator : public BaseGenerator {
const IDLOptions &opts) { const IDLOptions &opts) {
return NativeName(Name(struct_def), &struct_def, opts) + " *" + return NativeName(Name(struct_def), &struct_def, opts) + " *" +
(inclass ? "" : Name(struct_def) + "::") + (inclass ? "" : Name(struct_def) + "::") +
"UnPack(const flatbuffers::resolver_function_t *_resolver" + "UnPack(const ::flatbuffers::resolver_function_t *_resolver" +
(inclass ? " = nullptr" : "") + ") const"; (inclass ? " = nullptr" : "") + ") const";
} }
@@ -1040,13 +1046,13 @@ class CppGenerator : public BaseGenerator {
const IDLOptions &opts) { const IDLOptions &opts) {
return "void " + (inclass ? "" : Name(struct_def) + "::") + "UnPackTo(" + return "void " + (inclass ? "" : Name(struct_def) + "::") + "UnPackTo(" +
NativeName(Name(struct_def), &struct_def, opts) + " *" + NativeName(Name(struct_def), &struct_def, opts) + " *" +
"_o, const flatbuffers::resolver_function_t *_resolver" + "_o, const ::flatbuffers::resolver_function_t *_resolver" +
(inclass ? " = nullptr" : "") + ") const"; (inclass ? " = nullptr" : "") + ") const";
} }
void GenMiniReflectPre(const StructDef *struct_def) { void GenMiniReflectPre(const StructDef *struct_def) {
code_.SetValue("NAME", struct_def->name); code_.SetValue("NAME", struct_def->name);
code_ += "inline const flatbuffers::TypeTable *{{NAME}}TypeTable();"; code_ += "inline const ::flatbuffers::TypeTable *{{NAME}}TypeTable();";
code_ += ""; code_ += "";
} }
@@ -1104,9 +1110,9 @@ class CppGenerator : public BaseGenerator {
} }
} }
if (is_array) { array_sizes.push_back(type.fixed_length); } if (is_array) { array_sizes.push_back(type.fixed_length); }
ts += "{ flatbuffers::" + std::string(ElementaryTypeNames()[et]) + ", " + ts += "{ ::flatbuffers::" + std::string(ElementaryTypeNames()[et]) +
NumToString(is_vector || is_array) + ", " + NumToString(ref_idx) + ", " + NumToString(is_vector || is_array) + ", " +
" }"; NumToString(ref_idx) + " }";
} }
std::string rs; std::string rs;
for (auto &type_ref : type_refs) { for (auto &type_ref : type_refs) {
@@ -1147,14 +1153,14 @@ class CppGenerator : public BaseGenerator {
code_.SetValue("ARRAYSIZES", as); code_.SetValue("ARRAYSIZES", as);
code_.SetValue("NAMES", ns); code_.SetValue("NAMES", ns);
code_.SetValue("VALUES", vs); code_.SetValue("VALUES", vs);
code_ += "inline const flatbuffers::TypeTable *{{NAME}}TypeTable() {"; code_ += "inline const ::flatbuffers::TypeTable *{{NAME}}TypeTable() {";
if (num_fields) { if (num_fields) {
code_ += " static const flatbuffers::TypeCode type_codes[] = {"; code_ += " static const ::flatbuffers::TypeCode type_codes[] = {";
code_ += " {{TYPES}}"; code_ += " {{TYPES}}";
code_ += " };"; code_ += " };";
} }
if (!type_refs.empty()) { if (!type_refs.empty()) {
code_ += " static const flatbuffers::TypeFunction type_refs[] = {"; code_ += " static const ::flatbuffers::TypeFunction type_refs[] = {";
code_ += " {{REFS}}"; code_ += " {{REFS}}";
code_ += " };"; code_ += " };";
} }
@@ -1172,8 +1178,8 @@ class CppGenerator : public BaseGenerator {
code_ += " {{NAMES}}"; code_ += " {{NAMES}}";
code_ += " };"; code_ += " };";
} }
code_ += " static const flatbuffers::TypeTable tt = {"; code_ += " static const ::flatbuffers::TypeTable tt = {";
code_ += std::string(" flatbuffers::{{SEQ_TYPE}}, {{NUM_FIELDS}}, ") + code_ += std::string(" ::flatbuffers::{{SEQ_TYPE}}, {{NUM_FIELDS}}, ") +
(num_fields ? "type_codes, " : "nullptr, ") + (num_fields ? "type_codes, " : "nullptr, ") +
(!type_refs.empty() ? "type_refs, " : "nullptr, ") + (!type_refs.empty() ? "type_refs, " : "nullptr, ") +
(!as.empty() ? "array_sizes, " : "nullptr, ") + (!as.empty() ? "array_sizes, " : "nullptr, ") +
@@ -1383,7 +1389,7 @@ class CppGenerator : public BaseGenerator {
code_ += " if (lhs.type != rhs.type) return false;"; code_ += " if (lhs.type != rhs.type) return false;";
code_ += " switch (lhs.type) {"; code_ += " switch (lhs.type) {";
for (const auto &ev: enum_def.Vals()) { for (const auto &ev : enum_def.Vals()) {
code_.SetValue("NATIVE_ID", GetEnumValUse(enum_def, *ev)); code_.SetValue("NATIVE_ID", GetEnumValUse(enum_def, *ev));
if (ev->IsNonZero()) { if (ev->IsNonZero()) {
const auto native_type = GetUnionElement(*ev, true, opts_); const auto native_type = GetUnionElement(*ev, true, opts_);
@@ -1467,7 +1473,7 @@ class CppGenerator : public BaseGenerator {
code_ += "inline const char *EnumName{{ENUM_NAME}}({{ENUM_NAME}} e) {"; code_ += "inline const char *EnumName{{ENUM_NAME}}({{ENUM_NAME}} e) {";
code_ += " if (flatbuffers::IsOutRange(e, " + code_ += " if (::flatbuffers::IsOutRange(e, " +
GetEnumValUse(enum_def, *enum_def.MinValue()) + ", " + GetEnumValUse(enum_def, *enum_def.MinValue()) + ", " +
GetEnumValUse(enum_def, *enum_def.MaxValue()) + GetEnumValUse(enum_def, *enum_def.MaxValue()) +
")) return \"\";"; ")) return \"\";";
@@ -1547,7 +1553,8 @@ class CppGenerator : public BaseGenerator {
code_ += "inline " + UnionVectorVerifySignature(enum_def) + " {"; code_ += "inline " + UnionVectorVerifySignature(enum_def) + " {";
code_ += " if (!values || !types) return !values && !types;"; code_ += " if (!values || !types) return !values && !types;";
code_ += " if (values->size() != types->size()) return false;"; code_ += " if (values->size() != types->size()) return false;";
code_ += " for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {"; code_ +=
" for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {";
code_ += " if (!Verify" + Name(enum_def) + "("; code_ += " if (!Verify" + Name(enum_def) + "(";
code_ += " verifier, values->Get(i), types->GetEnum<" + code_ += " verifier, values->Get(i), types->GetEnum<" +
Name(enum_def) + ">(i))) {"; Name(enum_def) + ">(i))) {";
@@ -1628,7 +1635,7 @@ class CppGenerator : public BaseGenerator {
"inline {{ENUM_NAME}}Union::{{ENUM_NAME}}Union(const " "inline {{ENUM_NAME}}Union::{{ENUM_NAME}}Union(const "
"{{ENUM_NAME}}Union &u) : type(u.type), value(nullptr) {"; "{{ENUM_NAME}}Union &u) : type(u.type), value(nullptr) {";
code_ += " switch (type) {"; code_ += " switch (type) {";
for (const auto &ev: enum_def.Vals()) { for (const auto &ev : enum_def.Vals()) {
if (ev->IsZero()) { continue; } if (ev->IsZero()) { continue; }
code_.SetValue("LABEL", GetEnumValUse(enum_def, *ev)); code_.SetValue("LABEL", GetEnumValUse(enum_def, *ev));
code_.SetValue("TYPE", GetUnionElement(*ev, true, opts_)); code_.SetValue("TYPE", GetUnionElement(*ev, true, opts_));
@@ -1944,7 +1951,7 @@ class CppGenerator : public BaseGenerator {
std::string initializer_list; std::string initializer_list;
std::string vector_copies; std::string vector_copies;
std::string swaps; std::string swaps;
for (const auto &field: struct_def.fields.vec) { for (const auto &field : struct_def.fields.vec) {
const auto &type = field->value.type; const auto &type = field->value.type;
if (field->deprecated || type.base_type == BASE_TYPE_UTYPE) continue; if (field->deprecated || type.base_type == BASE_TYPE_UTYPE) continue;
if (type.base_type == BASE_TYPE_STRUCT) { if (type.base_type == BASE_TYPE_STRUCT) {
@@ -2038,7 +2045,7 @@ class CppGenerator : public BaseGenerator {
} }
void GenCompareOperator(const StructDef &struct_def, void GenCompareOperator(const StructDef &struct_def,
const std::string& accessSuffix = "") { const std::string &accessSuffix = "") {
std::string compare_op; std::string compare_op;
for (auto it = struct_def.fields.vec.begin(); for (auto it = struct_def.fields.vec.begin();
it != struct_def.fields.vec.end(); ++it) { it != struct_def.fields.vec.end(); ++it) {
@@ -2137,12 +2144,10 @@ class CppGenerator : public BaseGenerator {
code_.SetValue("NATIVE_NAME", native_name); code_.SetValue("NATIVE_NAME", native_name);
// Generate a C++ object that can hold an unpacked version of this table. // Generate a C++ object that can hold an unpacked version of this table.
code_ += "struct {{NATIVE_NAME}} : public flatbuffers::NativeTable {"; code_ += "struct {{NATIVE_NAME}} : public ::flatbuffers::NativeTable {";
code_ += " typedef {{STRUCT_NAME}} TableType;"; code_ += " typedef {{STRUCT_NAME}} TableType;";
GenFullyQualifiedNameGetter(struct_def, native_name); GenFullyQualifiedNameGetter(struct_def, native_name);
for (const auto field : struct_def.fields.vec) { for (const auto field : struct_def.fields.vec) { GenMember(*field); }
GenMember(*field);
}
GenOperatorNewDelete(struct_def); GenOperatorNewDelete(struct_def);
GenDefaultConstructor(struct_def); GenDefaultConstructor(struct_def);
GenCopyMoveCtorAndAssigOpDecls(struct_def); GenCopyMoveCtorAndAssigOpDecls(struct_def);
@@ -2248,7 +2253,7 @@ class CppGenerator : public BaseGenerator {
code_ += code_ +=
" bool KeyCompareLessThan(const {{STRUCT_NAME}} * const o) const {"; " bool KeyCompareLessThan(const {{STRUCT_NAME}} * const o) const {";
if (is_string) { if (is_string) {
// use operator< of flatbuffers::String // use operator< of ::flatbuffers::String
code_ += " return *{{FIELD_NAME}}() < *o->{{FIELD_NAME}}();"; code_ += " return *{{FIELD_NAME}}() < *o->{{FIELD_NAME}}();";
} else if (is_array) { } else if (is_array) {
const auto &elem_type = field.value.type.VectorType(); const auto &elem_type = field.value.type.VectorType();
@@ -2266,7 +2271,7 @@ class CppGenerator : public BaseGenerator {
} else if (is_array) { } else if (is_array) {
const auto &elem_type = field.value.type.VectorType(); const auto &elem_type = field.value.type.VectorType();
if (IsScalar(elem_type.base_type)) { if (IsScalar(elem_type.base_type)) {
std::string input_type = "flatbuffers::Array<" + std::string input_type = "::flatbuffers::Array<" +
GenTypeBasic(elem_type, false) + ", " + GenTypeBasic(elem_type, false) + ", " +
NumToString(elem_type.fixed_length) + ">"; NumToString(elem_type.fixed_length) + ">";
code_.SetValue("INPUT_TYPE", input_type); code_.SetValue("INPUT_TYPE", input_type);
@@ -2276,7 +2281,7 @@ class CppGenerator : public BaseGenerator {
code_ += code_ +=
" const {{INPUT_TYPE}} *curr_{{FIELD_NAME}} = {{FIELD_NAME}}();"; " const {{INPUT_TYPE}} *curr_{{FIELD_NAME}} = {{FIELD_NAME}}();";
code_ += code_ +=
" for (flatbuffers::uoffset_t i = 0; i < " " for (::flatbuffers::uoffset_t i = 0; i < "
"curr_{{FIELD_NAME}}->size(); i++) {"; "curr_{{FIELD_NAME}}->size(); i++) {";
code_ += " const auto lhs = curr_{{FIELD_NAME}}->Get(i);"; code_ += " const auto lhs = curr_{{FIELD_NAME}}->Get(i);";
code_ += " const auto rhs = _{{FIELD_NAME}}->Get(i);"; code_ += " const auto rhs = _{{FIELD_NAME}}->Get(i);";
@@ -2581,7 +2586,7 @@ class CppGenerator : public BaseGenerator {
code_.SetValue("STRUCT_NAME", Name(struct_def)); code_.SetValue("STRUCT_NAME", Name(struct_def));
code_ += code_ +=
"struct {{STRUCT_NAME}} FLATBUFFERS_FINAL_CLASS" "struct {{STRUCT_NAME}} FLATBUFFERS_FINAL_CLASS"
" : private flatbuffers::Table {"; " : private ::flatbuffers::Table {";
if (opts_.generate_object_based_api) { if (opts_.generate_object_based_api) {
code_ += " typedef {{NATIVE_NAME}} NativeTableType;"; code_ += " typedef {{NATIVE_NAME}} NativeTableType;";
} }
@@ -2589,7 +2594,7 @@ class CppGenerator : public BaseGenerator {
if (opts_.g_cpp_std >= cpp::CPP_STD_17) { code_ += " struct Traits;"; } if (opts_.g_cpp_std >= cpp::CPP_STD_17) { code_ += " struct Traits;"; }
if (opts_.mini_reflect != IDLOptions::kNone) { if (opts_.mini_reflect != IDLOptions::kNone) {
code_ += code_ +=
" static const flatbuffers::TypeTable *MiniReflectTypeTable() {"; " static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {";
code_ += " return {{STRUCT_NAME}}TypeTable();"; code_ += " return {{STRUCT_NAME}}TypeTable();";
code_ += " }"; code_ += " }";
} }
@@ -2635,7 +2640,7 @@ class CppGenerator : public BaseGenerator {
code_ += " const {{CPP_NAME}} *{{FIELD_NAME}}_nested_root() const {"; code_ += " const {{CPP_NAME}} *{{FIELD_NAME}}_nested_root() const {";
code_ += code_ +=
" return " " return "
"flatbuffers::GetRoot<{{CPP_NAME}}>({{FIELD_NAME}}()->Data());"; "::flatbuffers::GetRoot<{{CPP_NAME}}>({{FIELD_NAME}}()->Data());";
code_ += " }"; code_ += " }";
} }
@@ -2659,7 +2664,7 @@ class CppGenerator : public BaseGenerator {
// Generate a verifier function that can check a buffer from an untrusted // Generate a verifier function that can check a buffer from an untrusted
// source will never cause reads outside the buffer. // source will never cause reads outside the buffer.
code_ += " bool Verify(flatbuffers::Verifier &verifier) const {"; code_ += " bool Verify(::flatbuffers::Verifier &verifier) const {";
code_ += " return VerifyTableStart(verifier)\\"; code_ += " return VerifyTableStart(verifier)\\";
for (const auto &field : struct_def.fields.vec) { for (const auto &field : struct_def.fields.vec) {
if (field->deprecated) { continue; } if (field->deprecated) { continue; }
@@ -2749,8 +2754,8 @@ class CppGenerator : public BaseGenerator {
// Generate a builder struct: // Generate a builder struct:
code_ += "struct {{STRUCT_NAME}}Builder {"; code_ += "struct {{STRUCT_NAME}}Builder {";
code_ += " typedef {{STRUCT_NAME}} Table;"; code_ += " typedef {{STRUCT_NAME}} Table;";
code_ += " flatbuffers::FlatBufferBuilder &fbb_;"; code_ += " ::flatbuffers::FlatBufferBuilder &fbb_;";
code_ += " flatbuffers::uoffset_t start_;"; code_ += " ::flatbuffers::uoffset_t start_;";
bool has_string_or_vector_fields = false; bool has_string_or_vector_fields = false;
for (auto it = struct_def.fields.vec.begin(); for (auto it = struct_def.fields.vec.begin();
@@ -2797,18 +2802,18 @@ class CppGenerator : public BaseGenerator {
// Builder constructor // Builder constructor
code_ += code_ +=
" explicit {{STRUCT_NAME}}Builder(flatbuffers::FlatBufferBuilder " " explicit {{STRUCT_NAME}}Builder(::flatbuffers::FlatBufferBuilder "
"&_fbb)"; "&_fbb)";
code_ += " : fbb_(_fbb) {"; code_ += " : fbb_(_fbb) {";
code_ += " start_ = fbb_.StartTable();"; code_ += " start_ = fbb_.StartTable();";
code_ += " }"; code_ += " }";
// Finish() function. // Finish() function.
code_ += " flatbuffers::Offset<{{STRUCT_NAME}}> Finish() {"; code_ += " ::flatbuffers::Offset<{{STRUCT_NAME}}> Finish() {";
code_ += " const auto end = fbb_.EndTable(start_);"; code_ += " const auto end = fbb_.EndTable(start_);";
code_ += " auto o = flatbuffers::Offset<{{STRUCT_NAME}}>(end);"; code_ += " auto o = ::flatbuffers::Offset<{{STRUCT_NAME}}>(end);";
for (const auto &field: struct_def.fields.vec) { for (const auto &field : struct_def.fields.vec) {
if (!field->deprecated && field->IsRequired()) { if (!field->deprecated && field->IsRequired()) {
code_.SetValue("FIELD_NAME", Name(*field)); code_.SetValue("FIELD_NAME", Name(*field));
code_.SetValue("OFFSET_NAME", GenFieldOffsetName(*field)); code_.SetValue("OFFSET_NAME", GenFieldOffsetName(*field));
@@ -2823,13 +2828,11 @@ class CppGenerator : public BaseGenerator {
// Generate a convenient CreateX function that uses the above builder // Generate a convenient CreateX function that uses the above builder
// to create a table in one go. // to create a table in one go.
code_ += code_ +=
"inline flatbuffers::Offset<{{STRUCT_NAME}}> " "inline ::flatbuffers::Offset<{{STRUCT_NAME}}> "
"Create{{STRUCT_NAME}}("; "Create{{STRUCT_NAME}}(";
code_ += " flatbuffers::FlatBufferBuilder &_fbb\\"; code_ += " ::flatbuffers::FlatBufferBuilder &_fbb\\";
for (const auto &field : struct_def.fields.vec) { for (const auto &field : struct_def.fields.vec) {
if (!field->deprecated) { if (!field->deprecated) { GenParam(*field, false, ",\n "); }
GenParam(*field, false, ",\n ");
}
} }
code_ += ") {"; code_ += ") {";
@@ -2863,9 +2866,9 @@ class CppGenerator : public BaseGenerator {
// Generate a CreateXDirect function with vector types as parameters // Generate a CreateXDirect function with vector types as parameters
if (opts_.cpp_direct_copy && has_string_or_vector_fields) { if (opts_.cpp_direct_copy && has_string_or_vector_fields) {
code_ += code_ +=
"inline flatbuffers::Offset<{{STRUCT_NAME}}> " "inline ::flatbuffers::Offset<{{STRUCT_NAME}}> "
"Create{{STRUCT_NAME}}Direct("; "Create{{STRUCT_NAME}}Direct(";
code_ += " flatbuffers::FlatBufferBuilder &_fbb\\"; code_ += " ::flatbuffers::FlatBufferBuilder &_fbb\\";
for (const auto &field : struct_def.fields.vec) { for (const auto &field : struct_def.fields.vec) {
if (!field->deprecated) { GenParam(*field, true, ",\n "); } if (!field->deprecated) { GenParam(*field, true, ",\n "); }
} }
@@ -2955,7 +2958,7 @@ class CppGenerator : public BaseGenerator {
const auto &struct_attrs = type.struct_def->attributes; const auto &struct_attrs = type.struct_def->attributes;
const auto native_type = struct_attrs.Lookup("native_type"); const auto native_type = struct_attrs.Lookup("native_type");
if (native_type) { if (native_type) {
std::string unpack_call = "flatbuffers::UnPack"; std::string unpack_call = "::flatbuffers::UnPack";
const auto pack_name = struct_attrs.Lookup("native_type_pack_name"); const auto pack_name = struct_attrs.Lookup("native_type_pack_name");
if (pack_name) { unpack_call += pack_name->constant; } if (pack_name) { unpack_call += pack_name->constant; }
unpack_call += "(*" + val + ")"; unpack_call += "(*" + val + ")";
@@ -3029,7 +3032,7 @@ class CppGenerator : public BaseGenerator {
: (field.value.type.element == BASE_TYPE_UNION ? ".value" : (field.value.type.element == BASE_TYPE_UNION ? ".value"
: ""); : "");
code += "for (flatbuffers::uoffset_t _i = 0;"; code += "for (::flatbuffers::uoffset_t _i = 0;";
code += " _i < _e->size(); _i++) { "; code += " _i < _e->size(); _i++) { ";
auto cpp_type = field.attributes.Lookup("cpp_type"); auto cpp_type = field.attributes.Lookup("cpp_type");
if (cpp_type) { if (cpp_type) {
@@ -3044,7 +3047,7 @@ class CppGenerator : public BaseGenerator {
code += "(reinterpret_cast<void **>(&_o->" + name + "[_i]" + code += "(reinterpret_cast<void **>(&_o->" + name + "[_i]" +
access + "), "; access + "), ";
code += code +=
"static_cast<flatbuffers::hash_value_t>(" + indexing + "));"; "static_cast<::flatbuffers::hash_value_t>(" + indexing + "));";
if (PtrType(&field) == "naked") { if (PtrType(&field) == "naked") {
code += " else "; code += " else ";
code += "_o->" + name + "[_i]" + access + " = nullptr"; code += "_o->" + name + "[_i]" + access + " = nullptr";
@@ -3099,7 +3102,7 @@ class CppGenerator : public BaseGenerator {
code += "if (_resolver) "; code += "if (_resolver) ";
code += "(*_resolver)"; code += "(*_resolver)";
code += "(reinterpret_cast<void **>(&_o->" + Name(field) + "), "; code += "(reinterpret_cast<void **>(&_o->" + Name(field) + "), ";
code += "static_cast<flatbuffers::hash_value_t>(_e));"; code += "static_cast<::flatbuffers::hash_value_t>(_e));";
if (PtrType(&field) == "naked") { if (PtrType(&field) == "naked") {
code += " else "; code += " else ";
code += "_o->" + Name(field) + " = nullptr;"; code += "_o->" + Name(field) + " = nullptr;";
@@ -3196,7 +3199,8 @@ class CppGenerator : public BaseGenerator {
// Use by-function serialization to emulate // Use by-function serialization to emulate
// CreateVectorOfStrings(); this works also with non-std strings. // CreateVectorOfStrings(); this works also with non-std strings.
code += code +=
"_fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>" "_fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::"
"String>>"
" "; " ";
code += "(" + value + ".size(), "; code += "(" + value + ".size(), ";
code += "[](size_t i, _VectorArgs *__va) { "; code += "[](size_t i, _VectorArgs *__va) { ";
@@ -3219,7 +3223,7 @@ class CppGenerator : public BaseGenerator {
const auto pack_name = const auto pack_name =
struct_attrs.Lookup("native_type_pack_name"); struct_attrs.Lookup("native_type_pack_name");
if (pack_name) { if (pack_name) {
code += ", flatbuffers::Pack" + pack_name->constant; code += ", ::flatbuffers::Pack" + pack_name->constant;
} }
code += ")"; code += ")";
} else { } else {
@@ -3227,7 +3231,7 @@ class CppGenerator : public BaseGenerator {
code += "(" + value + ")"; code += "(" + value + ")";
} }
} else { } else {
code += "_fbb.CreateVector<flatbuffers::Offset<"; code += "_fbb.CreateVector<::flatbuffers::Offset<";
code += WrapInNameSpace(*vector_type.struct_def) + ">> "; code += WrapInNameSpace(*vector_type.struct_def) + ">> ";
code += "(" + value + ".size(), "; code += "(" + value + ".size(), ";
code += "[](size_t i, _VectorArgs *__va) { "; code += "[](size_t i, _VectorArgs *__va) { ";
@@ -3248,7 +3252,7 @@ class CppGenerator : public BaseGenerator {
} }
case BASE_TYPE_UNION: { case BASE_TYPE_UNION: {
code += code +=
"_fbb.CreateVector<flatbuffers::" "_fbb.CreateVector<::flatbuffers::"
"Offset<void>>(" + "Offset<void>>(" +
value + value +
".size(), [](size_t i, _VectorArgs *__va) { " ".size(), [](size_t i, _VectorArgs *__va) { "
@@ -3277,7 +3281,7 @@ class CppGenerator : public BaseGenerator {
const auto basetype = GenTypeBasic( const auto basetype = GenTypeBasic(
field.value.type.enum_def->underlying_type, false); field.value.type.enum_def->underlying_type, false);
code += "_fbb.CreateVectorScalarCast<" + basetype + code += "_fbb.CreateVectorScalarCast<" + basetype +
">(flatbuffers::data(" + value + "), " + value + ">(::flatbuffers::data(" + value + "), " + value +
".size())"; ".size())";
} else if (field.attributes.Lookup("cpp_type")) { } else if (field.attributes.Lookup("cpp_type")) {
auto type = GenTypeBasic(vector_type, false); auto type = GenTypeBasic(vector_type, false);
@@ -3313,7 +3317,7 @@ class CppGenerator : public BaseGenerator {
const auto &struct_attribs = field.value.type.struct_def->attributes; const auto &struct_attribs = field.value.type.struct_def->attributes;
const auto native_type = struct_attribs.Lookup("native_type"); const auto native_type = struct_attribs.Lookup("native_type");
if (native_type) { if (native_type) {
code += "flatbuffers::Pack"; code += "::flatbuffers::Pack";
const auto pack_name = const auto pack_name =
struct_attribs.Lookup("native_type_pack_name"); struct_attribs.Lookup("native_type_pack_name");
if (pack_name) { code += pack_name->constant; } if (pack_name) { code += pack_name->constant; }
@@ -3415,11 +3419,11 @@ class CppGenerator : public BaseGenerator {
code_ += code_ +=
" struct _VectorArgs " " struct _VectorArgs "
"{ flatbuffers::FlatBufferBuilder *__fbb; " "{ ::flatbuffers::FlatBufferBuilder *__fbb; "
"const " + "const " +
NativeName(Name(struct_def), &struct_def, opts_) + NativeName(Name(struct_def), &struct_def, opts_) +
"* __o; " "* __o; "
"const flatbuffers::rehasher_function_t *__rehasher; } _va = { " "const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { "
"&_fbb, _o, _rehasher}; (void)_va;"; "&_fbb, _o, _rehasher}; (void)_va;";
for (auto it = struct_def.fields.vec.begin(); for (auto it = struct_def.fields.vec.begin();
@@ -3568,7 +3572,7 @@ class CppGenerator : public BaseGenerator {
init_list += Name(field) + "_"; init_list += Name(field) + "_";
if (IsScalar(type.base_type)) { if (IsScalar(type.base_type)) {
auto scalar_type = GenUnderlyingCast(field, false, arg_name); auto scalar_type = GenUnderlyingCast(field, false, arg_name);
init_list += "(flatbuffers::EndianScalar(" + scalar_type + "))"; init_list += "(::flatbuffers::EndianScalar(" + scalar_type + "))";
} else { } else {
FLATBUFFERS_ASSERT((is_array && !init_arrays) || IsStruct(type)); FLATBUFFERS_ASSERT((is_array && !init_arrays) || IsStruct(type));
if (!is_array) if (!is_array)
@@ -3604,7 +3608,7 @@ class CppGenerator : public BaseGenerator {
is_enum ? "CastToArrayOfEnum<" + face_type + ">" : "CastToArray"; is_enum ? "CastToArrayOfEnum<" + face_type + ">" : "CastToArray";
const auto field_name = Name(*field) + "_"; const auto field_name = Name(*field) + "_";
const auto arg_name = "_" + Name(*field); const auto arg_name = "_" + Name(*field);
code_ += " flatbuffers::" + get_array + "(" + field_name + code_ += " ::flatbuffers::" + get_array + "(" + field_name +
").CopyFromSpan(" + arg_name + ");"; ").CopyFromSpan(" + arg_name + ");";
} }
if (field->padding) { if (field->padding) {
@@ -3624,7 +3628,7 @@ class CppGenerator : public BaseGenerator {
// It requires a specialization of Array class. // It requires a specialization of Array class.
// Generate Array<uint8_t> for Array<bool>. // Generate Array<uint8_t> for Array<bool>.
const auto face_type = GenTypeGet(type, " ", "", "", is_enum); const auto face_type = GenTypeGet(type, " ", "", "", is_enum);
std::string ret_type = "flatbuffers::Array<" + face_type + ", " + std::string ret_type = "::flatbuffers::Array<" + face_type + ", " +
NumToString(type.fixed_length) + ">"; NumToString(type.fixed_length) + ">";
if (mutable_accessor) if (mutable_accessor)
code_ += " " + ret_type + " *mutable_{{FIELD_NAME}}() {"; code_ += " " + ret_type + " *mutable_{{FIELD_NAME}}() {";
@@ -3633,7 +3637,7 @@ class CppGenerator : public BaseGenerator {
std::string get_array = std::string get_array =
is_enum ? "CastToArrayOfEnum<" + face_type + ">" : "CastToArray"; is_enum ? "CastToArrayOfEnum<" + face_type + ">" : "CastToArray";
code_ += " return &flatbuffers::" + get_array + "({{FIELD_VALUE}});"; code_ += " return &::flatbuffers::" + get_array + "({{FIELD_VALUE}});";
code_ += " }"; code_ += " }";
} }
@@ -3654,7 +3658,7 @@ class CppGenerator : public BaseGenerator {
code_ += " private:"; code_ += " private:";
int padding_id = 0; int padding_id = 0;
for (const auto &field: struct_def.fields.vec) { for (const auto &field : struct_def.fields.vec) {
const auto &field_type = field->value.type; const auto &field_type = field->value.type;
code_.SetValue("FIELD_TYPE", GenTypeGet(field_type, " ", "", " ", false)); code_.SetValue("FIELD_TYPE", GenTypeGet(field_type, " ", "", " ", false));
code_.SetValue("FIELD_NAME", Name(*field)); code_.SetValue("FIELD_NAME", Name(*field));
@@ -3680,7 +3684,7 @@ class CppGenerator : public BaseGenerator {
// Make TypeTable accessible via the generated struct. // Make TypeTable accessible via the generated struct.
if (opts_.mini_reflect != IDLOptions::kNone) { if (opts_.mini_reflect != IDLOptions::kNone) {
code_ += code_ +=
" static const flatbuffers::TypeTable *MiniReflectTypeTable() {"; " static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {";
code_ += " return {{STRUCT_NAME}}TypeTable();"; code_ += " return {{STRUCT_NAME}}TypeTable();";
code_ += " }"; code_ += " }";
} }
@@ -3694,17 +3698,15 @@ class CppGenerator : public BaseGenerator {
// excluding arrays. // excluding arrays.
GenStructConstructor(struct_def, kArrayArgModeNone); GenStructConstructor(struct_def, kArrayArgModeNone);
auto arrays_num = std::count_if(struct_def.fields.vec.begin(), auto arrays_num = std::count_if(
struct_def.fields.vec.end(), struct_def.fields.vec.begin(), struct_def.fields.vec.end(),
[](const flatbuffers::FieldDef *fd) { [](const FieldDef *fd) { return IsArray(fd->value.type); });
return IsArray(fd->value.type);
});
if (arrays_num > 0) { if (arrays_num > 0) {
GenStructConstructor(struct_def, kArrayArgModeSpanStatic); GenStructConstructor(struct_def, kArrayArgModeSpanStatic);
} }
// Generate accessor methods of the form: // Generate accessor methods of the form:
// type name() const { return flatbuffers::EndianScalar(name_); } // type name() const { return ::flatbuffers::EndianScalar(name_); }
for (const auto &field : struct_def.fields.vec) { for (const auto &field : struct_def.fields.vec) {
const auto &type = field->value.type; const auto &type = field->value.type;
const auto is_scalar = IsScalar(type.base_type); const auto is_scalar = IsScalar(type.base_type);
@@ -3714,7 +3716,7 @@ class CppGenerator : public BaseGenerator {
is_array ? "" : " &", true); is_array ? "" : " &", true);
auto member = Name(*field) + "_"; auto member = Name(*field) + "_";
auto value = auto value =
is_scalar ? "flatbuffers::EndianScalar(" + member + ")" : member; is_scalar ? "::flatbuffers::EndianScalar(" + member + ")" : member;
code_.SetValue("FIELD_NAME", Name(*field)); code_.SetValue("FIELD_NAME", Name(*field));
code_.SetValue("FIELD_TYPE", field_type); code_.SetValue("FIELD_TYPE", field_type);
@@ -3743,7 +3745,7 @@ class CppGenerator : public BaseGenerator {
code_ += " void mutate_{{FIELD_NAME}}({{ARG}} _{{FIELD_NAME}}) {"; code_ += " void mutate_{{FIELD_NAME}}({{ARG}} _{{FIELD_NAME}}) {";
code_ += code_ +=
" flatbuffers::WriteScalar(&{{FIELD_NAME}}_, " " ::flatbuffers::WriteScalar(&{{FIELD_NAME}}_, "
"{{FIELD_VALUE}});"; "{{FIELD_VALUE}});";
code_ += " }"; code_ += " }";
} else if (is_array) { } else if (is_array) {
@@ -3858,8 +3860,7 @@ bool GenerateCPP(const Parser &parser, const std::string &path,
std::string CPPMakeRule(const Parser &parser, const std::string &path, std::string CPPMakeRule(const Parser &parser, const std::string &path,
const std::string &file_name) { const std::string &file_name) {
const auto filebase = const auto filebase = StripPath(StripExtension(file_name));
flatbuffers::StripPath(flatbuffers::StripExtension(file_name));
cpp::CppGenerator geneartor(parser, path, file_name, parser.opts); cpp::CppGenerator geneartor(parser, path, file_name, parser.opts);
const auto included_files = parser.GetIncludedFilesRecursive(file_name); const auto included_files = parser.GetIncludedFilesRecursive(file_name);
std::string make_rule = std::string make_rule =

214
tests/alignment_test_generated.h
View File

@@ -34,13 +34,13 @@ bool operator!=(const OuterLargeT &lhs, const OuterLargeT &rhs);
bool operator==(const BadAlignmentRootT &lhs, const BadAlignmentRootT &rhs); bool operator==(const BadAlignmentRootT &lhs, const BadAlignmentRootT &rhs);
bool operator!=(const BadAlignmentRootT &lhs, const BadAlignmentRootT &rhs); bool operator!=(const BadAlignmentRootT &lhs, const BadAlignmentRootT &rhs);
inline const flatbuffers::TypeTable *BadAlignmentSmallTypeTable(); inline const ::flatbuffers::TypeTable *BadAlignmentSmallTypeTable();
inline const flatbuffers::TypeTable *BadAlignmentLargeTypeTable(); inline const ::flatbuffers::TypeTable *BadAlignmentLargeTypeTable();
inline const flatbuffers::TypeTable *OuterLargeTypeTable(); inline const ::flatbuffers::TypeTable *OuterLargeTypeTable();
inline const flatbuffers::TypeTable *BadAlignmentRootTypeTable(); inline const ::flatbuffers::TypeTable *BadAlignmentRootTypeTable();
FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) BadAlignmentSmall FLATBUFFERS_FINAL_CLASS { FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) BadAlignmentSmall FLATBUFFERS_FINAL_CLASS {
private: private:
@@ -49,7 +49,7 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) BadAlignmentSmall FLATBUFFERS_FINAL_CLASS
uint32_t var_2_; uint32_t var_2_;
public: public:
static const flatbuffers::TypeTable *MiniReflectTypeTable() { static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return BadAlignmentSmallTypeTable(); return BadAlignmentSmallTypeTable();
} }
BadAlignmentSmall() BadAlignmentSmall()
@@ -58,27 +58,27 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) BadAlignmentSmall FLATBUFFERS_FINAL_CLASS
var_2_(0) { var_2_(0) {
} }
BadAlignmentSmall(uint32_t _var_0, uint32_t _var_1, uint32_t _var_2) BadAlignmentSmall(uint32_t _var_0, uint32_t _var_1, uint32_t _var_2)
: var_0_(flatbuffers::EndianScalar(_var_0)), : var_0_(::flatbuffers::EndianScalar(_var_0)),
var_1_(flatbuffers::EndianScalar(_var_1)), var_1_(::flatbuffers::EndianScalar(_var_1)),
var_2_(flatbuffers::EndianScalar(_var_2)) { var_2_(::flatbuffers::EndianScalar(_var_2)) {
} }
uint32_t var_0() const { uint32_t var_0() const {
return flatbuffers::EndianScalar(var_0_); return ::flatbuffers::EndianScalar(var_0_);
} }
void mutate_var_0(uint32_t _var_0) { void mutate_var_0(uint32_t _var_0) {
flatbuffers::WriteScalar(&var_0_, _var_0); ::flatbuffers::WriteScalar(&var_0_, _var_0);
} }
uint32_t var_1() const { uint32_t var_1() const {
return flatbuffers::EndianScalar(var_1_); return ::flatbuffers::EndianScalar(var_1_);
} }
void mutate_var_1(uint32_t _var_1) { void mutate_var_1(uint32_t _var_1) {
flatbuffers::WriteScalar(&var_1_, _var_1); ::flatbuffers::WriteScalar(&var_1_, _var_1);
} }
uint32_t var_2() const { uint32_t var_2() const {
return flatbuffers::EndianScalar(var_2_); return ::flatbuffers::EndianScalar(var_2_);
} }
void mutate_var_2(uint32_t _var_2) { void mutate_var_2(uint32_t _var_2) {
flatbuffers::WriteScalar(&var_2_, _var_2); ::flatbuffers::WriteScalar(&var_2_, _var_2);
} }
}; };
FLATBUFFERS_STRUCT_END(BadAlignmentSmall, 12); FLATBUFFERS_STRUCT_END(BadAlignmentSmall, 12);
@@ -100,20 +100,20 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) BadAlignmentLarge FLATBUFFERS_FINAL_CLASS
uint64_t var_0_; uint64_t var_0_;
public: public:
static const flatbuffers::TypeTable *MiniReflectTypeTable() { static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return BadAlignmentLargeTypeTable(); return BadAlignmentLargeTypeTable();
} }
BadAlignmentLarge() BadAlignmentLarge()
: var_0_(0) { : var_0_(0) {
} }
BadAlignmentLarge(uint64_t _var_0) BadAlignmentLarge(uint64_t _var_0)
: var_0_(flatbuffers::EndianScalar(_var_0)) { : var_0_(::flatbuffers::EndianScalar(_var_0)) {
} }
uint64_t var_0() const { uint64_t var_0() const {
return flatbuffers::EndianScalar(var_0_); return ::flatbuffers::EndianScalar(var_0_);
} }
void mutate_var_0(uint64_t _var_0) { void mutate_var_0(uint64_t _var_0) {
flatbuffers::WriteScalar(&var_0_, _var_0); ::flatbuffers::WriteScalar(&var_0_, _var_0);
} }
}; };
FLATBUFFERS_STRUCT_END(BadAlignmentLarge, 8); FLATBUFFERS_STRUCT_END(BadAlignmentLarge, 8);
@@ -128,7 +128,7 @@ inline bool operator!=(const BadAlignmentLarge &lhs, const BadAlignmentLarge &rh
} }
struct OuterLargeT : public flatbuffers::NativeTable { struct OuterLargeT : public ::flatbuffers::NativeTable {
typedef OuterLarge TableType; typedef OuterLarge TableType;
flatbuffers::unique_ptr<BadAlignmentLarge> large{}; flatbuffers::unique_ptr<BadAlignmentLarge> large{};
OuterLargeT() = default; OuterLargeT() = default;
@@ -137,10 +137,10 @@ struct OuterLargeT : public flatbuffers::NativeTable {
OuterLargeT &operator=(OuterLargeT o) FLATBUFFERS_NOEXCEPT; OuterLargeT &operator=(OuterLargeT o) FLATBUFFERS_NOEXCEPT;
}; };
struct OuterLarge FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { struct OuterLarge FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef OuterLargeT NativeTableType; typedef OuterLargeT NativeTableType;
typedef OuterLargeBuilder Builder; typedef OuterLargeBuilder Builder;
static const flatbuffers::TypeTable *MiniReflectTypeTable() { static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return OuterLargeTypeTable(); return OuterLargeTypeTable();
} }
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
@@ -152,45 +152,45 @@ struct OuterLarge FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
BadAlignmentLarge *mutable_large() { BadAlignmentLarge *mutable_large() {
return GetStruct<BadAlignmentLarge *>(VT_LARGE); return GetStruct<BadAlignmentLarge *>(VT_LARGE);
} }
bool Verify(flatbuffers::Verifier &verifier) const { bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) && return VerifyTableStart(verifier) &&
VerifyField<BadAlignmentLarge>(verifier, VT_LARGE, 8) && VerifyField<BadAlignmentLarge>(verifier, VT_LARGE, 8) &&
verifier.EndTable(); verifier.EndTable();
} }
OuterLargeT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; OuterLargeT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(OuterLargeT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; void UnPackTo(OuterLargeT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<OuterLarge> Pack(flatbuffers::FlatBufferBuilder &_fbb, const OuterLargeT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); static ::flatbuffers::Offset<OuterLarge> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const OuterLargeT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
}; };
struct OuterLargeBuilder { struct OuterLargeBuilder {
typedef OuterLarge Table; typedef OuterLarge Table;
flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_; ::flatbuffers::uoffset_t start_;
void add_large(const BadAlignmentLarge *large) { void add_large(const BadAlignmentLarge *large) {
fbb_.AddStruct(OuterLarge::VT_LARGE, large); fbb_.AddStruct(OuterLarge::VT_LARGE, large);
} }
explicit OuterLargeBuilder(flatbuffers::FlatBufferBuilder &_fbb) explicit OuterLargeBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) { : fbb_(_fbb) {
start_ = fbb_.StartTable(); start_ = fbb_.StartTable();
} }
flatbuffers::Offset<OuterLarge> Finish() { ::flatbuffers::Offset<OuterLarge> Finish() {
const auto end = fbb_.EndTable(start_); const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<OuterLarge>(end); auto o = ::flatbuffers::Offset<OuterLarge>(end);
return o; return o;
} }
}; };
inline flatbuffers::Offset<OuterLarge> CreateOuterLarge( inline ::flatbuffers::Offset<OuterLarge> CreateOuterLarge(
flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::FlatBufferBuilder &_fbb,
const BadAlignmentLarge *large = nullptr) { const BadAlignmentLarge *large = nullptr) {
OuterLargeBuilder builder_(_fbb); OuterLargeBuilder builder_(_fbb);
builder_.add_large(large); builder_.add_large(large);
return builder_.Finish(); return builder_.Finish();
} }
flatbuffers::Offset<OuterLarge> CreateOuterLarge(flatbuffers::FlatBufferBuilder &_fbb, const OuterLargeT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); ::flatbuffers::Offset<OuterLarge> CreateOuterLarge(::flatbuffers::FlatBufferBuilder &_fbb, const OuterLargeT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct BadAlignmentRootT : public flatbuffers::NativeTable { struct BadAlignmentRootT : public ::flatbuffers::NativeTable {
typedef BadAlignmentRoot TableType; typedef BadAlignmentRoot TableType;
flatbuffers::unique_ptr<OuterLargeT> large{}; flatbuffers::unique_ptr<OuterLargeT> large{};
std::vector<BadAlignmentSmall> small{}; std::vector<BadAlignmentSmall> small{};
@@ -200,10 +200,10 @@ struct BadAlignmentRootT : public flatbuffers::NativeTable {
BadAlignmentRootT &operator=(BadAlignmentRootT o) FLATBUFFERS_NOEXCEPT; BadAlignmentRootT &operator=(BadAlignmentRootT o) FLATBUFFERS_NOEXCEPT;
}; };
struct BadAlignmentRoot FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { struct BadAlignmentRoot FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef BadAlignmentRootT NativeTableType; typedef BadAlignmentRootT NativeTableType;
typedef BadAlignmentRootBuilder Builder; typedef BadAlignmentRootBuilder Builder;
static const flatbuffers::TypeTable *MiniReflectTypeTable() { static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return BadAlignmentRootTypeTable(); return BadAlignmentRootTypeTable();
} }
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
@@ -216,13 +216,13 @@ struct BadAlignmentRoot FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
OuterLarge *mutable_large() { OuterLarge *mutable_large() {
return GetPointer<OuterLarge *>(VT_LARGE); return GetPointer<OuterLarge *>(VT_LARGE);
} }
const flatbuffers::Vector<const BadAlignmentSmall *> *small() const { const ::flatbuffers::Vector<const BadAlignmentSmall *> *small() const {
return GetPointer<const flatbuffers::Vector<const BadAlignmentSmall *> *>(VT_SMALL); return GetPointer<const ::flatbuffers::Vector<const BadAlignmentSmall *> *>(VT_SMALL);
} }
flatbuffers::Vector<const BadAlignmentSmall *> *mutable_small() { ::flatbuffers::Vector<const BadAlignmentSmall *> *mutable_small() {
return GetPointer<flatbuffers::Vector<const BadAlignmentSmall *> *>(VT_SMALL); return GetPointer<::flatbuffers::Vector<const BadAlignmentSmall *> *>(VT_SMALL);
} }
bool Verify(flatbuffers::Verifier &verifier) const { bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) && return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_LARGE) && VerifyOffset(verifier, VT_LARGE) &&
verifier.VerifyTable(large()) && verifier.VerifyTable(large()) &&
@@ -230,45 +230,45 @@ struct BadAlignmentRoot FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
verifier.VerifyVector(small()) && verifier.VerifyVector(small()) &&
verifier.EndTable(); verifier.EndTable();
} }
BadAlignmentRootT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; BadAlignmentRootT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(BadAlignmentRootT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; void UnPackTo(BadAlignmentRootT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<BadAlignmentRoot> Pack(flatbuffers::FlatBufferBuilder &_fbb, const BadAlignmentRootT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); static ::flatbuffers::Offset<BadAlignmentRoot> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const BadAlignmentRootT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
}; };
struct BadAlignmentRootBuilder { struct BadAlignmentRootBuilder {
typedef BadAlignmentRoot Table; typedef BadAlignmentRoot Table;
flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_; ::flatbuffers::uoffset_t start_;
void add_large(flatbuffers::Offset<OuterLarge> large) { void add_large(::flatbuffers::Offset<OuterLarge> large) {
fbb_.AddOffset(BadAlignmentRoot::VT_LARGE, large); fbb_.AddOffset(BadAlignmentRoot::VT_LARGE, large);
} }
void add_small(flatbuffers::Offset<flatbuffers::Vector<const BadAlignmentSmall *>> small) { void add_small(::flatbuffers::Offset<::flatbuffers::Vector<const BadAlignmentSmall *>> small) {
fbb_.AddOffset(BadAlignmentRoot::VT_SMALL, small); fbb_.AddOffset(BadAlignmentRoot::VT_SMALL, small);
} }
explicit BadAlignmentRootBuilder(flatbuffers::FlatBufferBuilder &_fbb) explicit BadAlignmentRootBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) { : fbb_(_fbb) {
start_ = fbb_.StartTable(); start_ = fbb_.StartTable();
} }
flatbuffers::Offset<BadAlignmentRoot> Finish() { ::flatbuffers::Offset<BadAlignmentRoot> Finish() {
const auto end = fbb_.EndTable(start_); const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<BadAlignmentRoot>(end); auto o = ::flatbuffers::Offset<BadAlignmentRoot>(end);
return o; return o;
} }
}; };
inline flatbuffers::Offset<BadAlignmentRoot> CreateBadAlignmentRoot( inline ::flatbuffers::Offset<BadAlignmentRoot> CreateBadAlignmentRoot(
flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<OuterLarge> large = 0, ::flatbuffers::Offset<OuterLarge> large = 0,
flatbuffers::Offset<flatbuffers::Vector<const BadAlignmentSmall *>> small = 0) { ::flatbuffers::Offset<::flatbuffers::Vector<const BadAlignmentSmall *>> small = 0) {
BadAlignmentRootBuilder builder_(_fbb); BadAlignmentRootBuilder builder_(_fbb);
builder_.add_small(small); builder_.add_small(small);
builder_.add_large(large); builder_.add_large(large);
return builder_.Finish(); return builder_.Finish();
} }
inline flatbuffers::Offset<BadAlignmentRoot> CreateBadAlignmentRootDirect( inline ::flatbuffers::Offset<BadAlignmentRoot> CreateBadAlignmentRootDirect(
flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<OuterLarge> large = 0, ::flatbuffers::Offset<OuterLarge> large = 0,
const std::vector<BadAlignmentSmall> *small = nullptr) { const std::vector<BadAlignmentSmall> *small = nullptr) {
auto small__ = small ? _fbb.CreateVectorOfStructs<BadAlignmentSmall>(*small) : 0; auto small__ = small ? _fbb.CreateVectorOfStructs<BadAlignmentSmall>(*small) : 0;
return CreateBadAlignmentRoot( return CreateBadAlignmentRoot(
@@ -277,7 +277,7 @@ inline flatbuffers::Offset<BadAlignmentRoot> CreateBadAlignmentRootDirect(
small__); small__);
} }
flatbuffers::Offset<BadAlignmentRoot> CreateBadAlignmentRoot(flatbuffers::FlatBufferBuilder &_fbb, const BadAlignmentRootT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); ::flatbuffers::Offset<BadAlignmentRoot> CreateBadAlignmentRoot(::flatbuffers::FlatBufferBuilder &_fbb, const BadAlignmentRootT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
inline bool operator==(const OuterLargeT &lhs, const OuterLargeT &rhs) { inline bool operator==(const OuterLargeT &lhs, const OuterLargeT &rhs) {
@@ -299,26 +299,26 @@ inline OuterLargeT &OuterLargeT::operator=(OuterLargeT o) FLATBUFFERS_NOEXCEPT {
return *this; return *this;
} }
inline OuterLargeT *OuterLarge::UnPack(const flatbuffers::resolver_function_t *_resolver) const { inline OuterLargeT *OuterLarge::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
auto _o = std::unique_ptr<OuterLargeT>(new OuterLargeT()); auto _o = std::unique_ptr<OuterLargeT>(new OuterLargeT());
UnPackTo(_o.get(), _resolver); UnPackTo(_o.get(), _resolver);
return _o.release(); return _o.release();
} }
inline void OuterLarge::UnPackTo(OuterLargeT *_o, const flatbuffers::resolver_function_t *_resolver) const { inline void OuterLarge::UnPackTo(OuterLargeT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
(void)_o; (void)_o;
(void)_resolver; (void)_resolver;
{ auto _e = large(); if (_e) _o->large = flatbuffers::unique_ptr<BadAlignmentLarge>(new BadAlignmentLarge(*_e)); } { auto _e = large(); if (_e) _o->large = flatbuffers::unique_ptr<BadAlignmentLarge>(new BadAlignmentLarge(*_e)); }
} }
inline flatbuffers::Offset<OuterLarge> OuterLarge::Pack(flatbuffers::FlatBufferBuilder &_fbb, const OuterLargeT* _o, const flatbuffers::rehasher_function_t *_rehasher) { inline ::flatbuffers::Offset<OuterLarge> OuterLarge::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const OuterLargeT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateOuterLarge(_fbb, _o, _rehasher); return CreateOuterLarge(_fbb, _o, _rehasher);
} }
inline flatbuffers::Offset<OuterLarge> CreateOuterLarge(flatbuffers::FlatBufferBuilder &_fbb, const OuterLargeT *_o, const flatbuffers::rehasher_function_t *_rehasher) { inline ::flatbuffers::Offset<OuterLarge> CreateOuterLarge(::flatbuffers::FlatBufferBuilder &_fbb, const OuterLargeT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher; (void)_rehasher;
(void)_o; (void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const OuterLargeT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const OuterLargeT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _large = _o->large ? _o->large.get() : nullptr; auto _large = _o->large ? _o->large.get() : nullptr;
return CreateOuterLarge( return CreateOuterLarge(
_fbb, _fbb,
@@ -348,27 +348,27 @@ inline BadAlignmentRootT &BadAlignmentRootT::operator=(BadAlignmentRootT o) FLAT
return *this; return *this;
} }
inline BadAlignmentRootT *BadAlignmentRoot::UnPack(const flatbuffers::resolver_function_t *_resolver) const { inline BadAlignmentRootT *BadAlignmentRoot::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
auto _o = std::unique_ptr<BadAlignmentRootT>(new BadAlignmentRootT()); auto _o = std::unique_ptr<BadAlignmentRootT>(new BadAlignmentRootT());
UnPackTo(_o.get(), _resolver); UnPackTo(_o.get(), _resolver);
return _o.release(); return _o.release();
} }
inline void BadAlignmentRoot::UnPackTo(BadAlignmentRootT *_o, const flatbuffers::resolver_function_t *_resolver) const { inline void BadAlignmentRoot::UnPackTo(BadAlignmentRootT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
(void)_o; (void)_o;
(void)_resolver; (void)_resolver;
{ auto _e = large(); if (_e) { if(_o->large) { _e->UnPackTo(_o->large.get(), _resolver); } else { _o->large = flatbuffers::unique_ptr<OuterLargeT>(_e->UnPack(_resolver)); } } else if (_o->large) { _o->large.reset(); } } { auto _e = large(); if (_e) { if(_o->large) { _e->UnPackTo(_o->large.get(), _resolver); } else { _o->large = flatbuffers::unique_ptr<OuterLargeT>(_e->UnPack(_resolver)); } } else if (_o->large) { _o->large.reset(); } }
{ auto _e = small(); if (_e) { _o->small.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->small[_i] = *_e->Get(_i); } } else { _o->small.resize(0); } } { auto _e = small(); if (_e) { _o->small.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->small[_i] = *_e->Get(_i); } } else { _o->small.resize(0); } }
} }
inline flatbuffers::Offset<BadAlignmentRoot> BadAlignmentRoot::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BadAlignmentRootT* _o, const flatbuffers::rehasher_function_t *_rehasher) { inline ::flatbuffers::Offset<BadAlignmentRoot> BadAlignmentRoot::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const BadAlignmentRootT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateBadAlignmentRoot(_fbb, _o, _rehasher); return CreateBadAlignmentRoot(_fbb, _o, _rehasher);
} }
inline flatbuffers::Offset<BadAlignmentRoot> CreateBadAlignmentRoot(flatbuffers::FlatBufferBuilder &_fbb, const BadAlignmentRootT *_o, const flatbuffers::rehasher_function_t *_rehasher) { inline ::flatbuffers::Offset<BadAlignmentRoot> CreateBadAlignmentRoot(::flatbuffers::FlatBufferBuilder &_fbb, const BadAlignmentRootT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher; (void)_rehasher;
(void)_o; (void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const BadAlignmentRootT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const BadAlignmentRootT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _large = _o->large ? CreateOuterLarge(_fbb, _o->large.get(), _rehasher) : 0; auto _large = _o->large ? CreateOuterLarge(_fbb, _o->large.get(), _rehasher) : 0;
auto _small = _o->small.size() ? _fbb.CreateVectorOfStructs(_o->small) : 0; auto _small = _o->small.size() ? _fbb.CreateVectorOfStructs(_o->small) : 0;
return CreateBadAlignmentRoot( return CreateBadAlignmentRoot(
@@ -377,11 +377,11 @@ inline flatbuffers::Offset<BadAlignmentRoot> CreateBadAlignmentRoot(flatbuffers:
_small); _small);
} }
inline const flatbuffers::TypeTable *BadAlignmentSmallTypeTable() { inline const ::flatbuffers::TypeTable *BadAlignmentSmallTypeTable() {
static const flatbuffers::TypeCode type_codes[] = { static const ::flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_UINT, 0, -1 }, { ::flatbuffers::ET_UINT, 0, -1 },
{ flatbuffers::ET_UINT, 0, -1 }, { ::flatbuffers::ET_UINT, 0, -1 },
{ flatbuffers::ET_UINT, 0, -1 } { ::flatbuffers::ET_UINT, 0, -1 }
}; };
static const int64_t values[] = { 0, 4, 8, 12 }; static const int64_t values[] = { 0, 4, 8, 12 };
static const char * const names[] = { static const char * const names[] = {
@@ -389,48 +389,48 @@ inline const flatbuffers::TypeTable *BadAlignmentSmallTypeTable() {
"var_1", "var_1",
"var_2" "var_2"
}; };
static const flatbuffers::TypeTable tt = { static const ::flatbuffers::TypeTable tt = {
flatbuffers::ST_STRUCT, 3, type_codes, nullptr, nullptr, values, names ::flatbuffers::ST_STRUCT, 3, type_codes, nullptr, nullptr, values, names
}; };
return &tt; return &tt;
} }
inline const flatbuffers::TypeTable *BadAlignmentLargeTypeTable() { inline const ::flatbuffers::TypeTable *BadAlignmentLargeTypeTable() {
static const flatbuffers::TypeCode type_codes[] = { static const ::flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_ULONG, 0, -1 } { ::flatbuffers::ET_ULONG, 0, -1 }
}; };
static const int64_t values[] = { 0, 8 }; static const int64_t values[] = { 0, 8 };
static const char * const names[] = { static const char * const names[] = {
"var_0" "var_0"
}; };
static const flatbuffers::TypeTable tt = { static const ::flatbuffers::TypeTable tt = {
flatbuffers::ST_STRUCT, 1, type_codes, nullptr, nullptr, values, names ::flatbuffers::ST_STRUCT, 1, type_codes, nullptr, nullptr, values, names
}; };
return &tt; return &tt;
} }
inline const flatbuffers::TypeTable *OuterLargeTypeTable() { inline const ::flatbuffers::TypeTable *OuterLargeTypeTable() {
static const flatbuffers::TypeCode type_codes[] = { static const ::flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_SEQUENCE, 0, 0 } { ::flatbuffers::ET_SEQUENCE, 0, 0 }
}; };
static const flatbuffers::TypeFunction type_refs[] = { static const ::flatbuffers::TypeFunction type_refs[] = {
BadAlignmentLargeTypeTable BadAlignmentLargeTypeTable
}; };
static const char * const names[] = { static const char * const names[] = {
"large" "large"
}; };
static const flatbuffers::TypeTable tt = { static const ::flatbuffers::TypeTable tt = {
flatbuffers::ST_TABLE, 1, type_codes, type_refs, nullptr, nullptr, names ::flatbuffers::ST_TABLE, 1, type_codes, type_refs, nullptr, nullptr, names
}; };
return &tt; return &tt;
} }
inline const flatbuffers::TypeTable *BadAlignmentRootTypeTable() { inline const ::flatbuffers::TypeTable *BadAlignmentRootTypeTable() {
static const flatbuffers::TypeCode type_codes[] = { static const ::flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_SEQUENCE, 0, 0 }, { ::flatbuffers::ET_SEQUENCE, 0, 0 },
{ flatbuffers::ET_SEQUENCE, 1, 1 } { ::flatbuffers::ET_SEQUENCE, 1, 1 }
}; };
static const flatbuffers::TypeFunction type_refs[] = { static const ::flatbuffers::TypeFunction type_refs[] = {
OuterLargeTypeTable, OuterLargeTypeTable,
BadAlignmentSmallTypeTable BadAlignmentSmallTypeTable
}; };
@@ -438,59 +438,59 @@ inline const flatbuffers::TypeTable *BadAlignmentRootTypeTable() {
"large", "large",
"small" "small"
}; };
static const flatbuffers::TypeTable tt = { static const ::flatbuffers::TypeTable tt = {
flatbuffers::ST_TABLE, 2, type_codes, type_refs, nullptr, nullptr, names ::flatbuffers::ST_TABLE, 2, type_codes, type_refs, nullptr, nullptr, names
}; };
return &tt; return &tt;
} }
inline const BadAlignmentRoot *GetBadAlignmentRoot(const void *buf) { inline const BadAlignmentRoot *GetBadAlignmentRoot(const void *buf) {
return flatbuffers::GetRoot<BadAlignmentRoot>(buf); return ::flatbuffers::GetRoot<BadAlignmentRoot>(buf);
} }
inline const BadAlignmentRoot *GetSizePrefixedBadAlignmentRoot(const void *buf) { inline const BadAlignmentRoot *GetSizePrefixedBadAlignmentRoot(const void *buf) {
return flatbuffers::GetSizePrefixedRoot<BadAlignmentRoot>(buf); return ::flatbuffers::GetSizePrefixedRoot<BadAlignmentRoot>(buf);
} }
inline BadAlignmentRoot *GetMutableBadAlignmentRoot(void *buf) { inline BadAlignmentRoot *GetMutableBadAlignmentRoot(void *buf) {
return flatbuffers::GetMutableRoot<BadAlignmentRoot>(buf); return ::flatbuffers::GetMutableRoot<BadAlignmentRoot>(buf);
} }
inline BadAlignmentRoot *GetMutableSizePrefixedBadAlignmentRoot(void *buf) { inline BadAlignmentRoot *GetMutableSizePrefixedBadAlignmentRoot(void *buf) {
return flatbuffers::GetMutableSizePrefixedRoot<BadAlignmentRoot>(buf); return ::flatbuffers::GetMutableSizePrefixedRoot<BadAlignmentRoot>(buf);
} }
inline bool VerifyBadAlignmentRootBuffer( inline bool VerifyBadAlignmentRootBuffer(
flatbuffers::Verifier &verifier) { ::flatbuffers::Verifier &verifier) {
return verifier.VerifyBuffer<BadAlignmentRoot>(nullptr); return verifier.VerifyBuffer<BadAlignmentRoot>(nullptr);
} }
inline bool VerifySizePrefixedBadAlignmentRootBuffer( inline bool VerifySizePrefixedBadAlignmentRootBuffer(
flatbuffers::Verifier &verifier) { ::flatbuffers::Verifier &verifier) {
return verifier.VerifySizePrefixedBuffer<BadAlignmentRoot>(nullptr); return verifier.VerifySizePrefixedBuffer<BadAlignmentRoot>(nullptr);
} }
inline void FinishBadAlignmentRootBuffer( inline void FinishBadAlignmentRootBuffer(
flatbuffers::FlatBufferBuilder &fbb, ::flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<BadAlignmentRoot> root) { ::flatbuffers::Offset<BadAlignmentRoot> root) {
fbb.Finish(root); fbb.Finish(root);
} }
inline void FinishSizePrefixedBadAlignmentRootBuffer( inline void FinishSizePrefixedBadAlignmentRootBuffer(
flatbuffers::FlatBufferBuilder &fbb, ::flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<BadAlignmentRoot> root) { ::flatbuffers::Offset<BadAlignmentRoot> root) {
fbb.FinishSizePrefixed(root); fbb.FinishSizePrefixed(root);
} }
inline flatbuffers::unique_ptr<BadAlignmentRootT> UnPackBadAlignmentRoot( inline flatbuffers::unique_ptr<BadAlignmentRootT> UnPackBadAlignmentRoot(
const void *buf, const void *buf,
const flatbuffers::resolver_function_t *res = nullptr) { const ::flatbuffers::resolver_function_t *res = nullptr) {
return flatbuffers::unique_ptr<BadAlignmentRootT>(GetBadAlignmentRoot(buf)->UnPack(res)); return flatbuffers::unique_ptr<BadAlignmentRootT>(GetBadAlignmentRoot(buf)->UnPack(res));
} }
inline flatbuffers::unique_ptr<BadAlignmentRootT> UnPackSizePrefixedBadAlignmentRoot( inline flatbuffers::unique_ptr<BadAlignmentRootT> UnPackSizePrefixedBadAlignmentRoot(
const void *buf, const void *buf,
const flatbuffers::resolver_function_t *res = nullptr) { const ::flatbuffers::resolver_function_t *res = nullptr) {
return flatbuffers::unique_ptr<BadAlignmentRootT>(GetSizePrefixedBadAlignmentRoot(buf)->UnPack(res)); return flatbuffers::unique_ptr<BadAlignmentRootT>(GetSizePrefixedBadAlignmentRoot(buf)->UnPack(res));
} }

244
tests/arrays_test_generated.h
View File

@@ -31,11 +31,11 @@ bool operator!=(const ArrayStruct &lhs, const ArrayStruct &rhs);
bool operator==(const ArrayTableT &lhs, const ArrayTableT &rhs); bool operator==(const ArrayTableT &lhs, const ArrayTableT &rhs);
bool operator!=(const ArrayTableT &lhs, const ArrayTableT &rhs); bool operator!=(const ArrayTableT &lhs, const ArrayTableT &rhs);
inline const flatbuffers::TypeTable *NestedStructTypeTable(); inline const ::flatbuffers::TypeTable *NestedStructTypeTable();
inline const flatbuffers::TypeTable *ArrayStructTypeTable(); inline const ::flatbuffers::TypeTable *ArrayStructTypeTable();
inline const flatbuffers::TypeTable *ArrayTableTypeTable(); inline const ::flatbuffers::TypeTable *ArrayTableTypeTable();
enum class TestEnum : int8_t { enum class TestEnum : int8_t {
A = 0, A = 0,
@@ -65,7 +65,7 @@ inline const char * const *EnumNamesTestEnum() {
} }
inline const char *EnumNameTestEnum(TestEnum e) { inline const char *EnumNameTestEnum(TestEnum e) {
if (flatbuffers::IsOutRange(e, TestEnum::A, TestEnum::C)) return ""; if (::flatbuffers::IsOutRange(e, TestEnum::A, TestEnum::C)) return "";
const size_t index = static_cast<size_t>(e); const size_t index = static_cast<size_t>(e);
return EnumNamesTestEnum()[index]; return EnumNamesTestEnum()[index];
} }
@@ -79,7 +79,7 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) NestedStruct FLATBUFFERS_FINAL_CLASS {
int64_t d_[2]; int64_t d_[2];
public: public:
static const flatbuffers::TypeTable *MiniReflectTypeTable() { static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return NestedStructTypeTable(); return NestedStructTypeTable();
} }
NestedStruct() NestedStruct()
@@ -94,7 +94,7 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) NestedStruct FLATBUFFERS_FINAL_CLASS {
} }
NestedStruct(MyGame::Example::TestEnum _b) NestedStruct(MyGame::Example::TestEnum _b)
: a_(), : a_(),
b_(flatbuffers::EndianScalar(static_cast<int8_t>(_b))), b_(::flatbuffers::EndianScalar(static_cast<int8_t>(_b))),
c_(), c_(),
padding0__(0), padding0__(0),
padding1__(0), padding1__(0),
@@ -102,39 +102,39 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) NestedStruct FLATBUFFERS_FINAL_CLASS {
(void)padding0__; (void)padding0__;
(void)padding1__; (void)padding1__;
} }
NestedStruct(flatbuffers::span<const int32_t, 2> _a, MyGame::Example::TestEnum _b, flatbuffers::span<const MyGame::Example::TestEnum, 2> _c, flatbuffers::span<const int64_t, 2> _d) NestedStruct(::flatbuffers::span<const int32_t, 2> _a, MyGame::Example::TestEnum _b, ::flatbuffers::span<const MyGame::Example::TestEnum, 2> _c, ::flatbuffers::span<const int64_t, 2> _d)
: b_(flatbuffers::EndianScalar(static_cast<int8_t>(_b))), : b_(::flatbuffers::EndianScalar(static_cast<int8_t>(_b))),
padding0__(0), padding0__(0),
padding1__(0) { padding1__(0) {
flatbuffers::CastToArray(a_).CopyFromSpan(_a); ::flatbuffers::CastToArray(a_).CopyFromSpan(_a);
flatbuffers::CastToArrayOfEnum<MyGame::Example::TestEnum>(c_).CopyFromSpan(_c); ::flatbuffers::CastToArrayOfEnum<MyGame::Example::TestEnum>(c_).CopyFromSpan(_c);
(void)padding0__; (void)padding0__;
(void)padding1__; (void)padding1__;
flatbuffers::CastToArray(d_).CopyFromSpan(_d); ::flatbuffers::CastToArray(d_).CopyFromSpan(_d);
} }
const flatbuffers::Array<int32_t, 2> *a() const { const ::flatbuffers::Array<int32_t, 2> *a() const {
return &flatbuffers::CastToArray(a_); return &::flatbuffers::CastToArray(a_);
} }
flatbuffers::Array<int32_t, 2> *mutable_a() { ::flatbuffers::Array<int32_t, 2> *mutable_a() {
return &flatbuffers::CastToArray(a_); return &::flatbuffers::CastToArray(a_);
} }
MyGame::Example::TestEnum b() const { MyGame::Example::TestEnum b() const {
return static_cast<MyGame::Example::TestEnum>(flatbuffers::EndianScalar(b_)); return static_cast<MyGame::Example::TestEnum>(::flatbuffers::EndianScalar(b_));
} }
void mutate_b(MyGame::Example::TestEnum _b) { void mutate_b(MyGame::Example::TestEnum _b) {
flatbuffers::WriteScalar(&b_, static_cast<int8_t>(_b)); ::flatbuffers::WriteScalar(&b_, static_cast<int8_t>(_b));
} }
const flatbuffers::Array<MyGame::Example::TestEnum, 2> *c() const { const ::flatbuffers::Array<MyGame::Example::TestEnum, 2> *c() const {
return &flatbuffers::CastToArrayOfEnum<MyGame::Example::TestEnum>(c_); return &::flatbuffers::CastToArrayOfEnum<MyGame::Example::TestEnum>(c_);
} }
flatbuffers::Array<MyGame::Example::TestEnum, 2> *mutable_c() { ::flatbuffers::Array<MyGame::Example::TestEnum, 2> *mutable_c() {
return &flatbuffers::CastToArrayOfEnum<MyGame::Example::TestEnum>(c_); return &::flatbuffers::CastToArrayOfEnum<MyGame::Example::TestEnum>(c_);
} }
const flatbuffers::Array<int64_t, 2> *d() const { const ::flatbuffers::Array<int64_t, 2> *d() const {
return &flatbuffers::CastToArray(d_); return &::flatbuffers::CastToArray(d_);
} }
flatbuffers::Array<int64_t, 2> *mutable_d() { ::flatbuffers::Array<int64_t, 2> *mutable_d() {
return &flatbuffers::CastToArray(d_); return &::flatbuffers::CastToArray(d_);
} }
}; };
FLATBUFFERS_STRUCT_END(NestedStruct, 32); FLATBUFFERS_STRUCT_END(NestedStruct, 32);
@@ -164,7 +164,7 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) ArrayStruct FLATBUFFERS_FINAL_CLASS {
int64_t f_[2]; int64_t f_[2];
public: public:
static const flatbuffers::TypeTable *MiniReflectTypeTable() { static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return ArrayStructTypeTable(); return ArrayStructTypeTable();
} }
ArrayStruct() ArrayStruct()
@@ -184,14 +184,14 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) ArrayStruct FLATBUFFERS_FINAL_CLASS {
(void)padding3__; (void)padding3__;
} }
ArrayStruct(float _a, int8_t _c, int32_t _e) ArrayStruct(float _a, int8_t _c, int32_t _e)
: a_(flatbuffers::EndianScalar(_a)), : a_(::flatbuffers::EndianScalar(_a)),
b_(), b_(),
c_(flatbuffers::EndianScalar(_c)), c_(::flatbuffers::EndianScalar(_c)),
padding0__(0), padding0__(0),
padding1__(0), padding1__(0),
padding2__(0), padding2__(0),
d_(), d_(),
e_(flatbuffers::EndianScalar(_e)), e_(::flatbuffers::EndianScalar(_e)),
padding3__(0), padding3__(0),
f_() { f_() {
(void)padding0__; (void)padding0__;
@@ -199,57 +199,57 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) ArrayStruct FLATBUFFERS_FINAL_CLASS {
(void)padding2__; (void)padding2__;
(void)padding3__; (void)padding3__;
} }
ArrayStruct(float _a, flatbuffers::span<const int32_t, 15> _b, int8_t _c, flatbuffers::span<const MyGame::Example::NestedStruct, 2> _d, int32_t _e, flatbuffers::span<const int64_t, 2> _f) ArrayStruct(float _a, ::flatbuffers::span<const int32_t, 15> _b, int8_t _c, ::flatbuffers::span<const MyGame::Example::NestedStruct, 2> _d, int32_t _e, ::flatbuffers::span<const int64_t, 2> _f)
: a_(flatbuffers::EndianScalar(_a)), : a_(::flatbuffers::EndianScalar(_a)),
c_(flatbuffers::EndianScalar(_c)), c_(::flatbuffers::EndianScalar(_c)),
padding0__(0), padding0__(0),
padding1__(0), padding1__(0),
padding2__(0), padding2__(0),
e_(flatbuffers::EndianScalar(_e)), e_(::flatbuffers::EndianScalar(_e)),
padding3__(0) { padding3__(0) {
flatbuffers::CastToArray(b_).CopyFromSpan(_b); ::flatbuffers::CastToArray(b_).CopyFromSpan(_b);
(void)padding0__; (void)padding0__;
(void)padding1__; (void)padding1__;
(void)padding2__; (void)padding2__;
flatbuffers::CastToArray(d_).CopyFromSpan(_d); ::flatbuffers::CastToArray(d_).CopyFromSpan(_d);
(void)padding3__; (void)padding3__;
flatbuffers::CastToArray(f_).CopyFromSpan(_f); ::flatbuffers::CastToArray(f_).CopyFromSpan(_f);
} }
float a() const { float a() const {
return flatbuffers::EndianScalar(a_); return ::flatbuffers::EndianScalar(a_);
} }
void mutate_a(float _a) { void mutate_a(float _a) {
flatbuffers::WriteScalar(&a_, _a); ::flatbuffers::WriteScalar(&a_, _a);
} }
const flatbuffers::Array<int32_t, 15> *b() const { const ::flatbuffers::Array<int32_t, 15> *b() const {
return &flatbuffers::CastToArray(b_); return &::flatbuffers::CastToArray(b_);
} }
flatbuffers::Array<int32_t, 15> *mutable_b() { ::flatbuffers::Array<int32_t, 15> *mutable_b() {
return &flatbuffers::CastToArray(b_); return &::flatbuffers::CastToArray(b_);
} }
int8_t c() const { int8_t c() const {
return flatbuffers::EndianScalar(c_); return ::flatbuffers::EndianScalar(c_);
} }
void mutate_c(int8_t _c) { void mutate_c(int8_t _c) {
flatbuffers::WriteScalar(&c_, _c); ::flatbuffers::WriteScalar(&c_, _c);
} }
const flatbuffers::Array<MyGame::Example::NestedStruct, 2> *d() const { const ::flatbuffers::Array<MyGame::Example::NestedStruct, 2> *d() const {
return &flatbuffers::CastToArray(d_); return &::flatbuffers::CastToArray(d_);
} }
flatbuffers::Array<MyGame::Example::NestedStruct, 2> *mutable_d() { ::flatbuffers::Array<MyGame::Example::NestedStruct, 2> *mutable_d() {
return &flatbuffers::CastToArray(d_); return &::flatbuffers::CastToArray(d_);
} }
int32_t e() const { int32_t e() const {
return flatbuffers::EndianScalar(e_); return ::flatbuffers::EndianScalar(e_);
} }
void mutate_e(int32_t _e) { void mutate_e(int32_t _e) {
flatbuffers::WriteScalar(&e_, _e); ::flatbuffers::WriteScalar(&e_, _e);
} }
const flatbuffers::Array<int64_t, 2> *f() const { const ::flatbuffers::Array<int64_t, 2> *f() const {
return &flatbuffers::CastToArray(f_); return &::flatbuffers::CastToArray(f_);
} }
flatbuffers::Array<int64_t, 2> *mutable_f() { ::flatbuffers::Array<int64_t, 2> *mutable_f() {
return &flatbuffers::CastToArray(f_); return &::flatbuffers::CastToArray(f_);
} }
}; };
FLATBUFFERS_STRUCT_END(ArrayStruct, 160); FLATBUFFERS_STRUCT_END(ArrayStruct, 160);
@@ -269,7 +269,7 @@ inline bool operator!=(const ArrayStruct &lhs, const ArrayStruct &rhs) {
} }
struct ArrayTableT : public flatbuffers::NativeTable { struct ArrayTableT : public ::flatbuffers::NativeTable {
typedef ArrayTable TableType; typedef ArrayTable TableType;
flatbuffers::unique_ptr<MyGame::Example::ArrayStruct> a{}; flatbuffers::unique_ptr<MyGame::Example::ArrayStruct> a{};
ArrayTableT() = default; ArrayTableT() = default;
@@ -278,10 +278,10 @@ struct ArrayTableT : public flatbuffers::NativeTable {
ArrayTableT &operator=(ArrayTableT o) FLATBUFFERS_NOEXCEPT; ArrayTableT &operator=(ArrayTableT o) FLATBUFFERS_NOEXCEPT;
}; };
struct ArrayTable FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { struct ArrayTable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef ArrayTableT NativeTableType; typedef ArrayTableT NativeTableType;
typedef ArrayTableBuilder Builder; typedef ArrayTableBuilder Builder;
static const flatbuffers::TypeTable *MiniReflectTypeTable() { static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return ArrayTableTypeTable(); return ArrayTableTypeTable();
} }
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
@@ -293,43 +293,43 @@ struct ArrayTable FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
MyGame::Example::ArrayStruct *mutable_a() { MyGame::Example::ArrayStruct *mutable_a() {
return GetStruct<MyGame::Example::ArrayStruct *>(VT_A); return GetStruct<MyGame::Example::ArrayStruct *>(VT_A);
} }
bool Verify(flatbuffers::Verifier &verifier) const { bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) && return VerifyTableStart(verifier) &&
VerifyField<MyGame::Example::ArrayStruct>(verifier, VT_A, 8) && VerifyField<MyGame::Example::ArrayStruct>(verifier, VT_A, 8) &&
verifier.EndTable(); verifier.EndTable();
} }
ArrayTableT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; ArrayTableT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(ArrayTableT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; void UnPackTo(ArrayTableT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<ArrayTable> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ArrayTableT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); static ::flatbuffers::Offset<ArrayTable> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ArrayTableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
}; };
struct ArrayTableBuilder { struct ArrayTableBuilder {
typedef ArrayTable Table; typedef ArrayTable Table;
flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_; ::flatbuffers::uoffset_t start_;
void add_a(const MyGame::Example::ArrayStruct *a) { void add_a(const MyGame::Example::ArrayStruct *a) {
fbb_.AddStruct(ArrayTable::VT_A, a); fbb_.AddStruct(ArrayTable::VT_A, a);
} }
explicit ArrayTableBuilder(flatbuffers::FlatBufferBuilder &_fbb) explicit ArrayTableBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) { : fbb_(_fbb) {
start_ = fbb_.StartTable(); start_ = fbb_.StartTable();
} }
flatbuffers::Offset<ArrayTable> Finish() { ::flatbuffers::Offset<ArrayTable> Finish() {
const auto end = fbb_.EndTable(start_); const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<ArrayTable>(end); auto o = ::flatbuffers::Offset<ArrayTable>(end);
return o; return o;
} }
}; };
inline flatbuffers::Offset<ArrayTable> CreateArrayTable( inline ::flatbuffers::Offset<ArrayTable> CreateArrayTable(
flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::FlatBufferBuilder &_fbb,
const MyGame::Example::ArrayStruct *a = nullptr) { const MyGame::Example::ArrayStruct *a = nullptr) {
ArrayTableBuilder builder_(_fbb); ArrayTableBuilder builder_(_fbb);
builder_.add_a(a); builder_.add_a(a);
return builder_.Finish(); return builder_.Finish();
} }
flatbuffers::Offset<ArrayTable> CreateArrayTable(flatbuffers::FlatBufferBuilder &_fbb, const ArrayTableT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); ::flatbuffers::Offset<ArrayTable> CreateArrayTable(::flatbuffers::FlatBufferBuilder &_fbb, const ArrayTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
inline bool operator==(const ArrayTableT &lhs, const ArrayTableT &rhs) { inline bool operator==(const ArrayTableT &lhs, const ArrayTableT &rhs) {
@@ -351,39 +351,39 @@ inline ArrayTableT &ArrayTableT::operator=(ArrayTableT o) FLATBUFFERS_NOEXCEPT {
return *this; return *this;
} }
inline ArrayTableT *ArrayTable::UnPack(const flatbuffers::resolver_function_t *_resolver) const { inline ArrayTableT *ArrayTable::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
auto _o = std::unique_ptr<ArrayTableT>(new ArrayTableT()); auto _o = std::unique_ptr<ArrayTableT>(new ArrayTableT());
UnPackTo(_o.get(), _resolver); UnPackTo(_o.get(), _resolver);
return _o.release(); return _o.release();
} }
inline void ArrayTable::UnPackTo(ArrayTableT *_o, const flatbuffers::resolver_function_t *_resolver) const { inline void ArrayTable::UnPackTo(ArrayTableT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
(void)_o; (void)_o;
(void)_resolver; (void)_resolver;
{ auto _e = a(); if (_e) _o->a = flatbuffers::unique_ptr<MyGame::Example::ArrayStruct>(new MyGame::Example::ArrayStruct(*_e)); } { auto _e = a(); if (_e) _o->a = flatbuffers::unique_ptr<MyGame::Example::ArrayStruct>(new MyGame::Example::ArrayStruct(*_e)); }
} }
inline flatbuffers::Offset<ArrayTable> ArrayTable::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ArrayTableT* _o, const flatbuffers::rehasher_function_t *_rehasher) { inline ::flatbuffers::Offset<ArrayTable> ArrayTable::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ArrayTableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateArrayTable(_fbb, _o, _rehasher); return CreateArrayTable(_fbb, _o, _rehasher);
} }
inline flatbuffers::Offset<ArrayTable> CreateArrayTable(flatbuffers::FlatBufferBuilder &_fbb, const ArrayTableT *_o, const flatbuffers::rehasher_function_t *_rehasher) { inline ::flatbuffers::Offset<ArrayTable> CreateArrayTable(::flatbuffers::FlatBufferBuilder &_fbb, const ArrayTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher; (void)_rehasher;
(void)_o; (void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ArrayTableT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const ArrayTableT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _a = _o->a ? _o->a.get() : nullptr; auto _a = _o->a ? _o->a.get() : nullptr;
return MyGame::Example::CreateArrayTable( return MyGame::Example::CreateArrayTable(
_fbb, _fbb,
_a); _a);
} }
inline const flatbuffers::TypeTable *TestEnumTypeTable() { inline const ::flatbuffers::TypeTable *TestEnumTypeTable() {
static const flatbuffers::TypeCode type_codes[] = { static const ::flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_CHAR, 0, 0 }, { ::flatbuffers::ET_CHAR, 0, 0 },
{ flatbuffers::ET_CHAR, 0, 0 }, { ::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[] = {
MyGame::Example::TestEnumTypeTable MyGame::Example::TestEnumTypeTable
}; };
static const char * const names[] = { static const char * const names[] = {
@@ -391,20 +391,20 @@ inline const flatbuffers::TypeTable *TestEnumTypeTable() {
"B", "B",
"C" "C"
}; };
static const flatbuffers::TypeTable tt = { static const ::flatbuffers::TypeTable tt = {
flatbuffers::ST_ENUM, 3, type_codes, type_refs, nullptr, nullptr, names ::flatbuffers::ST_ENUM, 3, type_codes, type_refs, nullptr, nullptr, names
}; };
return &tt; return &tt;
} }
inline const flatbuffers::TypeTable *NestedStructTypeTable() { inline const ::flatbuffers::TypeTable *NestedStructTypeTable() {
static const flatbuffers::TypeCode type_codes[] = { static const ::flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_INT, 1, -1 }, { ::flatbuffers::ET_INT, 1, -1 },
{ flatbuffers::ET_CHAR, 0, 0 }, { ::flatbuffers::ET_CHAR, 0, 0 },
{ flatbuffers::ET_CHAR, 1, 0 }, { ::flatbuffers::ET_CHAR, 1, 0 },
{ flatbuffers::ET_LONG, 1, -1 } { ::flatbuffers::ET_LONG, 1, -1 }
}; };
static const flatbuffers::TypeFunction type_refs[] = { static const ::flatbuffers::TypeFunction type_refs[] = {
MyGame::Example::TestEnumTypeTable MyGame::Example::TestEnumTypeTable
}; };
static const int16_t array_sizes[] = { 2, 2, 2, }; static const int16_t array_sizes[] = { 2, 2, 2, };
@@ -415,22 +415,22 @@ inline const flatbuffers::TypeTable *NestedStructTypeTable() {
"c", "c",
"d" "d"
}; };
static const flatbuffers::TypeTable tt = { static const ::flatbuffers::TypeTable tt = {
flatbuffers::ST_STRUCT, 4, type_codes, type_refs, array_sizes, values, names ::flatbuffers::ST_STRUCT, 4, type_codes, type_refs, array_sizes, values, names
}; };
return &tt; return &tt;
} }
inline const flatbuffers::TypeTable *ArrayStructTypeTable() { inline const ::flatbuffers::TypeTable *ArrayStructTypeTable() {
static const flatbuffers::TypeCode type_codes[] = { static const ::flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_FLOAT, 0, -1 }, { ::flatbuffers::ET_FLOAT, 0, -1 },
{ flatbuffers::ET_INT, 1, -1 }, { ::flatbuffers::ET_INT, 1, -1 },
{ flatbuffers::ET_CHAR, 0, -1 }, { ::flatbuffers::ET_CHAR, 0, -1 },
{ flatbuffers::ET_SEQUENCE, 1, 0 }, { ::flatbuffers::ET_SEQUENCE, 1, 0 },
{ flatbuffers::ET_INT, 0, -1 }, { ::flatbuffers::ET_INT, 0, -1 },
{ flatbuffers::ET_LONG, 1, -1 } { ::flatbuffers::ET_LONG, 1, -1 }
}; };
static const flatbuffers::TypeFunction type_refs[] = { static const ::flatbuffers::TypeFunction type_refs[] = {
MyGame::Example::NestedStructTypeTable MyGame::Example::NestedStructTypeTable
}; };
static const int16_t array_sizes[] = { 15, 2, 2, }; static const int16_t array_sizes[] = { 15, 2, 2, };
@@ -443,42 +443,42 @@ inline const flatbuffers::TypeTable *ArrayStructTypeTable() {
"e", "e",
"f" "f"
}; };
static const flatbuffers::TypeTable tt = { static const ::flatbuffers::TypeTable tt = {
flatbuffers::ST_STRUCT, 6, type_codes, type_refs, array_sizes, values, names ::flatbuffers::ST_STRUCT, 6, type_codes, type_refs, array_sizes, values, names
}; };
return &tt; return &tt;
} }
inline const flatbuffers::TypeTable *ArrayTableTypeTable() { inline const ::flatbuffers::TypeTable *ArrayTableTypeTable() {
static const flatbuffers::TypeCode type_codes[] = { static const ::flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_SEQUENCE, 0, 0 } { ::flatbuffers::ET_SEQUENCE, 0, 0 }
}; };
static const flatbuffers::TypeFunction type_refs[] = { static const ::flatbuffers::TypeFunction type_refs[] = {
MyGame::Example::ArrayStructTypeTable MyGame::Example::ArrayStructTypeTable
}; };
static const char * const names[] = { static const char * const names[] = {
"a" "a"
}; };
static const flatbuffers::TypeTable tt = { static const ::flatbuffers::TypeTable tt = {
flatbuffers::ST_TABLE, 1, type_codes, type_refs, nullptr, nullptr, names ::flatbuffers::ST_TABLE, 1, type_codes, type_refs, nullptr, nullptr, names
}; };
return &tt; return &tt;
} }
inline const MyGame::Example::ArrayTable *GetArrayTable(const void *buf) { inline const MyGame::Example::ArrayTable *GetArrayTable(const void *buf) {
return flatbuffers::GetRoot<MyGame::Example::ArrayTable>(buf); return ::flatbuffers::GetRoot<MyGame::Example::ArrayTable>(buf);
} }
inline const MyGame::Example::ArrayTable *GetSizePrefixedArrayTable(const void *buf) { inline const MyGame::Example::ArrayTable *GetSizePrefixedArrayTable(const void *buf) {
return flatbuffers::GetSizePrefixedRoot<MyGame::Example::ArrayTable>(buf); return ::flatbuffers::GetSizePrefixedRoot<MyGame::Example::ArrayTable>(buf);
} }
inline ArrayTable *GetMutableArrayTable(void *buf) { inline ArrayTable *GetMutableArrayTable(void *buf) {
return flatbuffers::GetMutableRoot<ArrayTable>(buf); return ::flatbuffers::GetMutableRoot<ArrayTable>(buf);
} }
inline MyGame::Example::ArrayTable *GetMutableSizePrefixedArrayTable(void *buf) { inline MyGame::Example::ArrayTable *GetMutableSizePrefixedArrayTable(void *buf) {
return flatbuffers::GetMutableSizePrefixedRoot<MyGame::Example::ArrayTable>(buf); return ::flatbuffers::GetMutableSizePrefixedRoot<MyGame::Example::ArrayTable>(buf);
} }
inline const char *ArrayTableIdentifier() { inline const char *ArrayTableIdentifier() {
@@ -486,22 +486,22 @@ inline const char *ArrayTableIdentifier() {
} }
inline bool ArrayTableBufferHasIdentifier(const void *buf) { inline bool ArrayTableBufferHasIdentifier(const void *buf) {
return flatbuffers::BufferHasIdentifier( return ::flatbuffers::BufferHasIdentifier(
buf, ArrayTableIdentifier()); buf, ArrayTableIdentifier());
} }
inline bool SizePrefixedArrayTableBufferHasIdentifier(const void *buf) { inline bool SizePrefixedArrayTableBufferHasIdentifier(const void *buf) {
return flatbuffers::BufferHasIdentifier( return ::flatbuffers::BufferHasIdentifier(
buf, ArrayTableIdentifier(), true); buf, ArrayTableIdentifier(), true);
} }
inline bool VerifyArrayTableBuffer( inline bool VerifyArrayTableBuffer(
flatbuffers::Verifier &verifier) { ::flatbuffers::Verifier &verifier) {
return verifier.VerifyBuffer<MyGame::Example::ArrayTable>(ArrayTableIdentifier()); return verifier.VerifyBuffer<MyGame::Example::ArrayTable>(ArrayTableIdentifier());
} }
inline bool VerifySizePrefixedArrayTableBuffer( inline bool VerifySizePrefixedArrayTableBuffer(
flatbuffers::Verifier &verifier) { ::flatbuffers::Verifier &verifier) {
return verifier.VerifySizePrefixedBuffer<MyGame::Example::ArrayTable>(ArrayTableIdentifier()); return verifier.VerifySizePrefixedBuffer<MyGame::Example::ArrayTable>(ArrayTableIdentifier());
} }
@@ -510,26 +510,26 @@ inline const char *ArrayTableExtension() {
} }
inline void FinishArrayTableBuffer( inline void FinishArrayTableBuffer(
flatbuffers::FlatBufferBuilder &fbb, ::flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<MyGame::Example::ArrayTable> root) { ::flatbuffers::Offset<MyGame::Example::ArrayTable> root) {
fbb.Finish(root, ArrayTableIdentifier()); fbb.Finish(root, ArrayTableIdentifier());
} }
inline void FinishSizePrefixedArrayTableBuffer( inline void FinishSizePrefixedArrayTableBuffer(
flatbuffers::FlatBufferBuilder &fbb, ::flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<MyGame::Example::ArrayTable> root) { ::flatbuffers::Offset<MyGame::Example::ArrayTable> root) {
fbb.FinishSizePrefixed(root, ArrayTableIdentifier()); fbb.FinishSizePrefixed(root, ArrayTableIdentifier());
} }
inline flatbuffers::unique_ptr<MyGame::Example::ArrayTableT> UnPackArrayTable( inline flatbuffers::unique_ptr<MyGame::Example::ArrayTableT> UnPackArrayTable(
const void *buf, const void *buf,
const flatbuffers::resolver_function_t *res = nullptr) { const ::flatbuffers::resolver_function_t *res = nullptr) {
return flatbuffers::unique_ptr<MyGame::Example::ArrayTableT>(GetArrayTable(buf)->UnPack(res)); return flatbuffers::unique_ptr<MyGame::Example::ArrayTableT>(GetArrayTable(buf)->UnPack(res));
} }
inline flatbuffers::unique_ptr<MyGame::Example::ArrayTableT> UnPackSizePrefixedArrayTable( inline flatbuffers::unique_ptr<MyGame::Example::ArrayTableT> UnPackSizePrefixedArrayTable(
const void *buf, const void *buf,
const flatbuffers::resolver_function_t *res = nullptr) { const ::flatbuffers::resolver_function_t *res = nullptr) {
return flatbuffers::unique_ptr<MyGame::Example::ArrayTableT>(GetSizePrefixedArrayTable(buf)->UnPack(res)); return flatbuffers::unique_ptr<MyGame::Example::ArrayTableT>(GetSizePrefixedArrayTable(buf)->UnPack(res));
} }

1258
tests/cpp17/generated_cpp17/monster_test_generated.h
View File

File diff suppressed because it is too large Load Diff

242
tests/cpp17/generated_cpp17/optional_scalars_generated.h
View File

@@ -19,7 +19,7 @@ struct ScalarStuff;
struct ScalarStuffBuilder; struct ScalarStuffBuilder;
struct ScalarStuffT; struct ScalarStuffT;
inline const flatbuffers::TypeTable *ScalarStuffTypeTable(); inline const ::flatbuffers::TypeTable *ScalarStuffTypeTable();
enum class OptionalByte : int8_t { enum class OptionalByte : int8_t {
None = 0, None = 0,
@@ -49,56 +49,56 @@ inline const char * const *EnumNamesOptionalByte() {
} }
inline const char *EnumNameOptionalByte(OptionalByte e) { 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); const size_t index = static_cast<size_t>(e);
return EnumNamesOptionalByte()[index]; return EnumNamesOptionalByte()[index];
} }
struct ScalarStuffT : public flatbuffers::NativeTable { struct ScalarStuffT : public ::flatbuffers::NativeTable {
typedef ScalarStuff TableType; typedef ScalarStuff TableType;
int8_t just_i8 = 0; 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; int8_t default_i8 = 42;
uint8_t just_u8 = 0; 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; uint8_t default_u8 = 42;
int16_t just_i16 = 0; 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; int16_t default_i16 = 42;
uint16_t just_u16 = 0; 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; uint16_t default_u16 = 42;
int32_t just_i32 = 0; 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; int32_t default_i32 = 42;
uint32_t just_u32 = 0; 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; uint32_t default_u32 = 42;
int64_t just_i64 = 0; 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; int64_t default_i64 = 42LL;
uint64_t just_u64 = 0; 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; uint64_t default_u64 = 42ULL;
float just_f32 = 0.0f; float just_f32 = 0.0f;
flatbuffers::Optional<float> maybe_f32 = flatbuffers::nullopt; ::flatbuffers::Optional<float> maybe_f32 = ::flatbuffers::nullopt;
float default_f32 = 42.0f; float default_f32 = 42.0f;
double just_f64 = 0.0; double just_f64 = 0.0;
flatbuffers::Optional<double> maybe_f64 = flatbuffers::nullopt; ::flatbuffers::Optional<double> maybe_f64 = ::flatbuffers::nullopt;
double default_f64 = 42.0; double default_f64 = 42.0;
bool just_bool = false; bool just_bool = false;
flatbuffers::Optional<bool> maybe_bool = flatbuffers::nullopt; ::flatbuffers::Optional<bool> maybe_bool = ::flatbuffers::nullopt;
bool default_bool = true; bool default_bool = true;
optional_scalars::OptionalByte just_enum = optional_scalars::OptionalByte::None; 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; 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 ScalarStuffT NativeTableType;
typedef ScalarStuffBuilder Builder; typedef ScalarStuffBuilder Builder;
struct Traits; struct Traits;
static const flatbuffers::TypeTable *MiniReflectTypeTable() { static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return ScalarStuffTypeTable(); return ScalarStuffTypeTable();
} }
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { 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) { bool mutate_just_i8(int8_t _just_i8 = 0) {
return SetField<int8_t>(VT_JUST_I8, _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); return GetOptional<int8_t, int8_t>(VT_MAYBE_I8);
} }
bool mutate_maybe_i8(int8_t _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) { bool mutate_just_u8(uint8_t _just_u8 = 0) {
return SetField<uint8_t>(VT_JUST_U8, _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); return GetOptional<uint8_t, uint8_t>(VT_MAYBE_U8);
} }
bool mutate_maybe_u8(uint8_t _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) { bool mutate_just_i16(int16_t _just_i16 = 0) {
return SetField<int16_t>(VT_JUST_I16, _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); return GetOptional<int16_t, int16_t>(VT_MAYBE_I16);
} }
bool mutate_maybe_i16(int16_t _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) { bool mutate_just_u16(uint16_t _just_u16 = 0) {
return SetField<uint16_t>(VT_JUST_U16, _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); return GetOptional<uint16_t, uint16_t>(VT_MAYBE_U16);
} }
bool mutate_maybe_u16(uint16_t _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) { bool mutate_just_i32(int32_t _just_i32 = 0) {
return SetField<int32_t>(VT_JUST_I32, _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); return GetOptional<int32_t, int32_t>(VT_MAYBE_I32);
} }
bool mutate_maybe_i32(int32_t _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) { bool mutate_just_u32(uint32_t _just_u32 = 0) {
return SetField<uint32_t>(VT_JUST_U32, _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); return GetOptional<uint32_t, uint32_t>(VT_MAYBE_U32);
} }
bool mutate_maybe_u32(uint32_t _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) { bool mutate_just_i64(int64_t _just_i64 = 0) {
return SetField<int64_t>(VT_JUST_I64, _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); return GetOptional<int64_t, int64_t>(VT_MAYBE_I64);
} }
bool mutate_maybe_i64(int64_t _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) { bool mutate_just_u64(uint64_t _just_u64 = 0) {
return SetField<uint64_t>(VT_JUST_U64, _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); return GetOptional<uint64_t, uint64_t>(VT_MAYBE_U64);
} }
bool mutate_maybe_u64(uint64_t _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) { bool mutate_just_f32(float _just_f32 = 0.0f) {
return SetField<float>(VT_JUST_F32, _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); return GetOptional<float, float>(VT_MAYBE_F32);
} }
bool mutate_maybe_f32(float _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) { bool mutate_just_f64(double _just_f64 = 0.0) {
return SetField<double>(VT_JUST_F64, _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); return GetOptional<double, double>(VT_MAYBE_F64);
} }
bool mutate_maybe_f64(double _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) { bool mutate_just_bool(bool _just_bool = 0) {
return SetField<uint8_t>(VT_JUST_BOOL, static_cast<uint8_t>(_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); return GetOptional<uint8_t, bool>(VT_MAYBE_BOOL);
} }
bool mutate_maybe_bool(bool _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)) { 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); 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); return GetOptional<int8_t, optional_scalars::OptionalByte>(VT_MAYBE_ENUM);
} }
bool mutate_maybe_enum(optional_scalars::OptionalByte _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 if constexpr (Index == 35) return default_enum();
else static_assert(Index != Index, "Invalid Field Index"); else static_assert(Index != Index, "Invalid Field Index");
} }
bool Verify(flatbuffers::Verifier &verifier) const { bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) && return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_JUST_I8, 1) && VerifyField<int8_t>(verifier, VT_JUST_I8, 1) &&
VerifyField<int8_t>(verifier, VT_MAYBE_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) && VerifyField<int8_t>(verifier, VT_DEFAULT_ENUM, 1) &&
verifier.EndTable(); verifier.EndTable();
} }
ScalarStuffT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; ScalarStuffT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(ScalarStuffT *_o, 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); static ::flatbuffers::Offset<ScalarStuff> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ScalarStuffT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
}; };
struct ScalarStuffBuilder { struct ScalarStuffBuilder {
typedef ScalarStuff Table; typedef ScalarStuff Table;
flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_; ::flatbuffers::uoffset_t start_;
void add_just_i8(int8_t just_i8) { void add_just_i8(int8_t just_i8) {
fbb_.AddElement<int8_t>(ScalarStuff::VT_JUST_I8, just_i8, 0); 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) { void add_default_enum(optional_scalars::OptionalByte default_enum) {
fbb_.AddElement<int8_t>(ScalarStuff::VT_DEFAULT_ENUM, static_cast<int8_t>(default_enum), 1); 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) { : fbb_(_fbb) {
start_ = fbb_.StartTable(); start_ = fbb_.StartTable();
} }
flatbuffers::Offset<ScalarStuff> Finish() { ::flatbuffers::Offset<ScalarStuff> Finish() {
const auto end = fbb_.EndTable(start_); const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<ScalarStuff>(end); auto o = ::flatbuffers::Offset<ScalarStuff>(end);
return o; return o;
} }
}; };
inline flatbuffers::Offset<ScalarStuff> CreateScalarStuff( inline ::flatbuffers::Offset<ScalarStuff> CreateScalarStuff(
flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::FlatBufferBuilder &_fbb,
int8_t just_i8 = 0, 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, int8_t default_i8 = 42,
uint8_t just_u8 = 0, 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, uint8_t default_u8 = 42,
int16_t just_i16 = 0, 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, int16_t default_i16 = 42,
uint16_t just_u16 = 0, 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, uint16_t default_u16 = 42,
int32_t just_i32 = 0, 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, int32_t default_i32 = 42,
uint32_t just_u32 = 0, 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, uint32_t default_u32 = 42,
int64_t just_i64 = 0, 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, int64_t default_i64 = 42LL,
uint64_t just_u64 = 0, 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, uint64_t default_u64 = 42ULL,
float just_f32 = 0.0f, float just_f32 = 0.0f,
flatbuffers::Optional<float> maybe_f32 = flatbuffers::nullopt, ::flatbuffers::Optional<float> maybe_f32 = ::flatbuffers::nullopt,
float default_f32 = 42.0f, float default_f32 = 42.0f,
double just_f64 = 0.0, double just_f64 = 0.0,
flatbuffers::Optional<double> maybe_f64 = flatbuffers::nullopt, ::flatbuffers::Optional<double> maybe_f64 = ::flatbuffers::nullopt,
double default_f64 = 42.0, double default_f64 = 42.0,
bool just_bool = false, bool just_bool = false,
flatbuffers::Optional<bool> maybe_bool = flatbuffers::nullopt, ::flatbuffers::Optional<bool> maybe_bool = ::flatbuffers::nullopt,
bool default_bool = true, bool default_bool = true,
optional_scalars::OptionalByte just_enum = optional_scalars::OptionalByte::None, 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) { optional_scalars::OptionalByte default_enum = optional_scalars::OptionalByte::One) {
ScalarStuffBuilder builder_(_fbb); ScalarStuffBuilder builder_(_fbb);
builder_.add_default_f64(default_f64); builder_.add_default_f64(default_f64);
@@ -689,15 +689,15 @@ struct ScalarStuff::Traits {
using FieldType = decltype(std::declval<type>().get_field<Index>()); 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>(); auto _o = std::make_unique<ScalarStuffT>();
UnPackTo(_o.get(), _resolver); UnPackTo(_o.get(), _resolver);
return _o.release(); 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)_o;
(void)_resolver; (void)_resolver;
{ auto _e = just_i8(); _o->just_i8 = _e; } { 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; } { 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); 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)_rehasher;
(void)_o; (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 _just_i8 = _o->just_i8;
auto _maybe_i8 = _o->maybe_i8; auto _maybe_i8 = _o->maybe_i8;
auto _default_i8 = _o->default_i8; auto _default_i8 = _o->default_i8;
@@ -822,13 +822,13 @@ inline flatbuffers::Offset<ScalarStuff> CreateScalarStuff(flatbuffers::FlatBuffe
_default_enum); _default_enum);
} }
inline const flatbuffers::TypeTable *OptionalByteTypeTable() { inline const ::flatbuffers::TypeTable *OptionalByteTypeTable() {
static const flatbuffers::TypeCode type_codes[] = { static const ::flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_CHAR, 0, 0 }, { ::flatbuffers::ET_CHAR, 0, 0 },
{ flatbuffers::ET_CHAR, 0, 0 }, { ::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 optional_scalars::OptionalByteTypeTable
}; };
static const char * const names[] = { static const char * const names[] = {
@@ -836,52 +836,52 @@ inline const flatbuffers::TypeTable *OptionalByteTypeTable() {
"One", "One",
"Two" "Two"
}; };
static const flatbuffers::TypeTable tt = { static const ::flatbuffers::TypeTable tt = {
flatbuffers::ST_ENUM, 3, type_codes, type_refs, nullptr, nullptr, names ::flatbuffers::ST_ENUM, 3, type_codes, type_refs, nullptr, nullptr, names
}; };
return &tt; return &tt;
} }
inline const flatbuffers::TypeTable *ScalarStuffTypeTable() { inline const ::flatbuffers::TypeTable *ScalarStuffTypeTable() {
static const flatbuffers::TypeCode type_codes[] = { static const ::flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_CHAR, 0, -1 }, { ::flatbuffers::ET_CHAR, 0, -1 },
{ flatbuffers::ET_CHAR, 0, -1 }, { ::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_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_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_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_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_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_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_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_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_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_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 }, { ::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 optional_scalars::OptionalByteTypeTable
}; };
static const char * const names[] = { static const char * const names[] = {
@@ -922,26 +922,26 @@ inline const flatbuffers::TypeTable *ScalarStuffTypeTable() {
"maybe_enum", "maybe_enum",
"default_enum" "default_enum"
}; };
static const flatbuffers::TypeTable tt = { static const ::flatbuffers::TypeTable tt = {
flatbuffers::ST_TABLE, 36, type_codes, type_refs, nullptr, nullptr, names ::flatbuffers::ST_TABLE, 36, type_codes, type_refs, nullptr, nullptr, names
}; };
return &tt; return &tt;
} }
inline const optional_scalars::ScalarStuff *GetScalarStuff(const void *buf) { 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) { 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) { inline ScalarStuff *GetMutableScalarStuff(void *buf) {
return flatbuffers::GetMutableRoot<ScalarStuff>(buf); return ::flatbuffers::GetMutableRoot<ScalarStuff>(buf);
} }
inline optional_scalars::ScalarStuff *GetMutableSizePrefixedScalarStuff(void *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() { inline const char *ScalarStuffIdentifier() {
@@ -949,22 +949,22 @@ inline const char *ScalarStuffIdentifier() {
} }
inline bool ScalarStuffBufferHasIdentifier(const void *buf) { inline bool ScalarStuffBufferHasIdentifier(const void *buf) {
return flatbuffers::BufferHasIdentifier( return ::flatbuffers::BufferHasIdentifier(
buf, ScalarStuffIdentifier()); buf, ScalarStuffIdentifier());
} }
inline bool SizePrefixedScalarStuffBufferHasIdentifier(const void *buf) { inline bool SizePrefixedScalarStuffBufferHasIdentifier(const void *buf) {
return flatbuffers::BufferHasIdentifier( return ::flatbuffers::BufferHasIdentifier(
buf, ScalarStuffIdentifier(), true); buf, ScalarStuffIdentifier(), true);
} }
inline bool VerifyScalarStuffBuffer( inline bool VerifyScalarStuffBuffer(
flatbuffers::Verifier &verifier) { ::flatbuffers::Verifier &verifier) {
return verifier.VerifyBuffer<optional_scalars::ScalarStuff>(ScalarStuffIdentifier()); return verifier.VerifyBuffer<optional_scalars::ScalarStuff>(ScalarStuffIdentifier());
} }
inline bool VerifySizePrefixedScalarStuffBuffer( inline bool VerifySizePrefixedScalarStuffBuffer(
flatbuffers::Verifier &verifier) { ::flatbuffers::Verifier &verifier) {
return verifier.VerifySizePrefixedBuffer<optional_scalars::ScalarStuff>(ScalarStuffIdentifier()); return verifier.VerifySizePrefixedBuffer<optional_scalars::ScalarStuff>(ScalarStuffIdentifier());
} }
@@ -973,26 +973,26 @@ inline const char *ScalarStuffExtension() {
} }
inline void FinishScalarStuffBuffer( inline void FinishScalarStuffBuffer(
flatbuffers::FlatBufferBuilder &fbb, ::flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<optional_scalars::ScalarStuff> root) { ::flatbuffers::Offset<optional_scalars::ScalarStuff> root) {
fbb.Finish(root, ScalarStuffIdentifier()); fbb.Finish(root, ScalarStuffIdentifier());
} }
inline void FinishSizePrefixedScalarStuffBuffer( inline void FinishSizePrefixedScalarStuffBuffer(
flatbuffers::FlatBufferBuilder &fbb, ::flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<optional_scalars::ScalarStuff> root) { ::flatbuffers::Offset<optional_scalars::ScalarStuff> root) {
fbb.FinishSizePrefixed(root, ScalarStuffIdentifier()); fbb.FinishSizePrefixed(root, ScalarStuffIdentifier());
} }
inline std::unique_ptr<optional_scalars::ScalarStuffT> UnPackScalarStuff( inline std::unique_ptr<optional_scalars::ScalarStuffT> UnPackScalarStuff(
const void *buf, 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)); return std::unique_ptr<optional_scalars::ScalarStuffT>(GetScalarStuff(buf)->UnPack(res));
} }
inline std::unique_ptr<optional_scalars::ScalarStuffT> UnPackSizePrefixedScalarStuff( inline std::unique_ptr<optional_scalars::ScalarStuffT> UnPackSizePrefixedScalarStuff(
const void *buf, 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)); return std::unique_ptr<optional_scalars::ScalarStuffT>(GetSizePrefixedScalarStuff(buf)->UnPack(res));
} }

392
tests/cpp17/generated_cpp17/union_vector_generated.h
View File

@@ -31,17 +31,17 @@ struct Movie;
struct MovieBuilder; struct MovieBuilder;
struct MovieT; 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 { enum class Character : uint8_t {
NONE = 0, NONE = 0,
@@ -83,7 +83,7 @@ inline const char * const *EnumNamesCharacter() {
} }
inline const char *EnumNameCharacter(Character e) { 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); const size_t index = static_cast<size_t>(e);
return EnumNamesCharacter()[index]; return EnumNamesCharacter()[index];
} }
@@ -105,8 +105,8 @@ struct CharacterUnion {
void Reset(); void Reset();
static void *UnPack(const void *obj, Character type, const flatbuffers::resolver_function_t *resolver); 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; ::flatbuffers::Offset<void> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
AttackerT *AsMuLan() { AttackerT *AsMuLan() {
return type == Character::MuLan ? return type == Character::MuLan ?
@@ -158,8 +158,8 @@ struct CharacterUnion {
} }
}; };
bool VerifyCharacter(flatbuffers::Verifier &verifier, const void *obj, Character type); 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 VerifyCharacterVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Character> *types);
enum class Gadget : uint8_t { enum class Gadget : uint8_t {
NONE = 0, NONE = 0,
@@ -189,7 +189,7 @@ inline const char * const *EnumNamesGadget() {
} }
inline const char *EnumNameGadget(Gadget e) { 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); const size_t index = static_cast<size_t>(e);
return EnumNamesGadget()[index]; return EnumNamesGadget()[index];
} }
@@ -245,8 +245,8 @@ struct GadgetUnion {
} }
} }
static void *UnPack(const void *obj, Gadget type, const flatbuffers::resolver_function_t *resolver); 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; ::flatbuffers::Offset<void> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
FallingTub *AsFallingTub() { FallingTub *AsFallingTub() {
return type == Gadget::FallingTub ? return type == Gadget::FallingTub ?
@@ -266,8 +266,8 @@ struct GadgetUnion {
} }
}; };
bool VerifyGadget(flatbuffers::Verifier &verifier, const void *obj, Gadget type); 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 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 { FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Rapunzel FLATBUFFERS_FINAL_CLASS {
private: private:
@@ -275,20 +275,20 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Rapunzel FLATBUFFERS_FINAL_CLASS {
public: public:
struct Traits; struct Traits;
static const flatbuffers::TypeTable *MiniReflectTypeTable() { static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return RapunzelTypeTable(); return RapunzelTypeTable();
} }
Rapunzel() Rapunzel()
: hair_length_(0) { : hair_length_(0) {
} }
Rapunzel(int32_t _hair_length) Rapunzel(int32_t _hair_length)
: hair_length_(flatbuffers::EndianScalar(_hair_length)) { : hair_length_(::flatbuffers::EndianScalar(_hair_length)) {
} }
int32_t hair_length() const { int32_t hair_length() const {
return flatbuffers::EndianScalar(hair_length_); return ::flatbuffers::EndianScalar(hair_length_);
} }
void mutate_hair_length(int32_t _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> template<size_t Index>
auto get_field() const { auto get_field() const {
@@ -316,20 +316,20 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) BookReader FLATBUFFERS_FINAL_CLASS {
public: public:
struct Traits; struct Traits;
static const flatbuffers::TypeTable *MiniReflectTypeTable() { static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return BookReaderTypeTable(); return BookReaderTypeTable();
} }
BookReader() BookReader()
: books_read_(0) { : books_read_(0) {
} }
BookReader(int32_t _books_read) BookReader(int32_t _books_read)
: books_read_(flatbuffers::EndianScalar(_books_read)) { : books_read_(::flatbuffers::EndianScalar(_books_read)) {
} }
int32_t books_read() const { int32_t books_read() const {
return flatbuffers::EndianScalar(books_read_); return ::flatbuffers::EndianScalar(books_read_);
} }
void mutate_books_read(int32_t _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> template<size_t Index>
auto get_field() const { auto get_field() const {
@@ -357,20 +357,20 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) FallingTub FLATBUFFERS_FINAL_CLASS {
public: public:
struct Traits; struct Traits;
static const flatbuffers::TypeTable *MiniReflectTypeTable() { static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return FallingTubTypeTable(); return FallingTubTypeTable();
} }
FallingTub() FallingTub()
: weight_(0) { : weight_(0) {
} }
FallingTub(int32_t _weight) FallingTub(int32_t _weight)
: weight_(flatbuffers::EndianScalar(_weight)) { : weight_(::flatbuffers::EndianScalar(_weight)) {
} }
int32_t weight() const { int32_t weight() const {
return flatbuffers::EndianScalar(weight_); return ::flatbuffers::EndianScalar(weight_);
} }
void mutate_weight(int32_t _weight) { void mutate_weight(int32_t _weight) {
flatbuffers::WriteScalar(&weight_, _weight); ::flatbuffers::WriteScalar(&weight_, _weight);
} }
template<size_t Index> template<size_t Index>
auto get_field() const { auto get_field() const {
@@ -392,16 +392,16 @@ struct FallingTub::Traits {
using FieldType = decltype(std::declval<type>().get_field<Index>()); using FieldType = decltype(std::declval<type>().get_field<Index>());
}; };
struct AttackerT : public flatbuffers::NativeTable { struct AttackerT : public ::flatbuffers::NativeTable {
typedef Attacker TableType; typedef Attacker TableType;
int32_t sword_attack_damage = 0; 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 AttackerT NativeTableType;
typedef AttackerBuilder Builder; typedef AttackerBuilder Builder;
struct Traits; struct Traits;
static const flatbuffers::TypeTable *MiniReflectTypeTable() { static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return AttackerTypeTable(); return AttackerTypeTable();
} }
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { 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(); if constexpr (Index == 0) return sword_attack_damage();
else static_assert(Index != Index, "Invalid Field Index"); else static_assert(Index != Index, "Invalid Field Index");
} }
bool Verify(flatbuffers::Verifier &verifier) const { bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) && return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_SWORD_ATTACK_DAMAGE, 4) && VerifyField<int32_t>(verifier, VT_SWORD_ATTACK_DAMAGE, 4) &&
verifier.EndTable(); verifier.EndTable();
} }
AttackerT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; AttackerT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(AttackerT *_o, 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); static ::flatbuffers::Offset<Attacker> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const AttackerT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
}; };
struct AttackerBuilder { struct AttackerBuilder {
typedef Attacker Table; typedef Attacker Table;
flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_; ::flatbuffers::uoffset_t start_;
void add_sword_attack_damage(int32_t sword_attack_damage) { void add_sword_attack_damage(int32_t sword_attack_damage) {
fbb_.AddElement<int32_t>(Attacker::VT_SWORD_ATTACK_DAMAGE, sword_attack_damage, 0); 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) { : fbb_(_fbb) {
start_ = fbb_.StartTable(); start_ = fbb_.StartTable();
} }
flatbuffers::Offset<Attacker> Finish() { ::flatbuffers::Offset<Attacker> Finish() {
const auto end = fbb_.EndTable(start_); const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<Attacker>(end); auto o = ::flatbuffers::Offset<Attacker>(end);
return o; return o;
} }
}; };
inline flatbuffers::Offset<Attacker> CreateAttacker( inline ::flatbuffers::Offset<Attacker> CreateAttacker(
flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::FlatBufferBuilder &_fbb,
int32_t sword_attack_damage = 0) { int32_t sword_attack_damage = 0) {
AttackerBuilder builder_(_fbb); AttackerBuilder builder_(_fbb);
builder_.add_sword_attack_damage(sword_attack_damage); builder_.add_sword_attack_damage(sword_attack_damage);
@@ -467,18 +467,18 @@ struct Attacker::Traits {
using FieldType = decltype(std::declval<type>().get_field<Index>()); 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; typedef HandFan TableType;
int32_t length = 0; int32_t length = 0;
}; };
struct HandFan FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { struct HandFan FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef HandFanT NativeTableType; typedef HandFanT NativeTableType;
typedef HandFanBuilder Builder; typedef HandFanBuilder Builder;
struct Traits; struct Traits;
static const flatbuffers::TypeTable *MiniReflectTypeTable() { static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return HandFanTypeTable(); return HandFanTypeTable();
} }
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
@@ -495,36 +495,36 @@ struct HandFan FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
if constexpr (Index == 0) return length(); if constexpr (Index == 0) return length();
else static_assert(Index != Index, "Invalid Field Index"); else static_assert(Index != Index, "Invalid Field Index");
} }
bool Verify(flatbuffers::Verifier &verifier) const { bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) && return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_LENGTH, 4) && VerifyField<int32_t>(verifier, VT_LENGTH, 4) &&
verifier.EndTable(); verifier.EndTable();
} }
HandFanT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; HandFanT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(HandFanT *_o, 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); static ::flatbuffers::Offset<HandFan> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const HandFanT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
}; };
struct HandFanBuilder { struct HandFanBuilder {
typedef HandFan Table; typedef HandFan Table;
flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_; ::flatbuffers::uoffset_t start_;
void add_length(int32_t length) { void add_length(int32_t length) {
fbb_.AddElement<int32_t>(HandFan::VT_LENGTH, length, 0); fbb_.AddElement<int32_t>(HandFan::VT_LENGTH, length, 0);
} }
explicit HandFanBuilder(flatbuffers::FlatBufferBuilder &_fbb) explicit HandFanBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) { : fbb_(_fbb) {
start_ = fbb_.StartTable(); start_ = fbb_.StartTable();
} }
flatbuffers::Offset<HandFan> Finish() { ::flatbuffers::Offset<HandFan> Finish() {
const auto end = fbb_.EndTable(start_); const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<HandFan>(end); auto o = ::flatbuffers::Offset<HandFan>(end);
return o; return o;
} }
}; };
inline flatbuffers::Offset<HandFan> CreateHandFan( inline ::flatbuffers::Offset<HandFan> CreateHandFan(
flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::FlatBufferBuilder &_fbb,
int32_t length = 0) { int32_t length = 0) {
HandFanBuilder builder_(_fbb); HandFanBuilder builder_(_fbb);
builder_.add_length(length); builder_.add_length(length);
@@ -544,19 +544,19 @@ struct HandFan::Traits {
using FieldType = decltype(std::declval<type>().get_field<Index>()); 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; typedef Movie TableType;
CharacterUnion main_character{}; CharacterUnion main_character{};
std::vector<CharacterUnion> characters{}; std::vector<CharacterUnion> characters{};
}; };
struct Movie FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { struct Movie FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef MovieT NativeTableType; typedef MovieT NativeTableType;
typedef MovieBuilder Builder; typedef MovieBuilder Builder;
struct Traits; struct Traits;
static const flatbuffers::TypeTable *MiniReflectTypeTable() { static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return MovieTypeTable(); return MovieTypeTable();
} }
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { 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 { const BookReader *main_character_as_BookFan() const {
return main_character_type() == Character::BookFan ? static_cast<const BookReader *>(main_character()) : nullptr; return main_character_type() == Character::BookFan ? static_cast<const BookReader *>(main_character()) : nullptr;
} }
const flatbuffers::String *main_character_as_Other() const { const ::flatbuffers::String *main_character_as_Other() const {
return main_character_type() == Character::Other ? static_cast<const flatbuffers::String *>(main_character()) : nullptr; return main_character_type() == Character::Other ? static_cast<const ::flatbuffers::String *>(main_character()) : nullptr;
} }
const flatbuffers::String *main_character_as_Unused() const { const ::flatbuffers::String *main_character_as_Unused() const {
return main_character_type() == Character::Unused ? static_cast<const flatbuffers::String *>(main_character()) : nullptr; return main_character_type() == Character::Unused ? static_cast<const ::flatbuffers::String *>(main_character()) : nullptr;
} }
void *mutable_main_character() { void *mutable_main_character() {
return GetPointer<void *>(VT_MAIN_CHARACTER); return GetPointer<void *>(VT_MAIN_CHARACTER);
} }
const flatbuffers::Vector<Character> *characters_type() const { const ::flatbuffers::Vector<Character> *characters_type() const {
return GetPointer<const flatbuffers::Vector<Character> *>(VT_CHARACTERS_TYPE); return GetPointer<const ::flatbuffers::Vector<Character> *>(VT_CHARACTERS_TYPE);
} }
flatbuffers::Vector<Character> *mutable_characters_type() { ::flatbuffers::Vector<Character> *mutable_characters_type() {
return GetPointer<flatbuffers::Vector<Character> *>(VT_CHARACTERS_TYPE); return GetPointer<::flatbuffers::Vector<Character> *>(VT_CHARACTERS_TYPE);
} }
const flatbuffers::Vector<flatbuffers::Offset<void>> *characters() const { const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *characters() const {
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<void>> *>(VT_CHARACTERS); return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *>(VT_CHARACTERS);
} }
flatbuffers::Vector<flatbuffers::Offset<void>> *mutable_characters() { ::flatbuffers::Vector<::flatbuffers::Offset<void>> *mutable_characters() {
return GetPointer<flatbuffers::Vector<flatbuffers::Offset<void>> *>(VT_CHARACTERS); return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<void>> *>(VT_CHARACTERS);
} }
template<size_t Index> template<size_t Index>
auto get_field() const { auto get_field() const {
@@ -612,7 +612,7 @@ struct Movie FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
else if constexpr (Index == 3) return characters(); else if constexpr (Index == 3) return characters();
else static_assert(Index != Index, "Invalid Field Index"); else static_assert(Index != Index, "Invalid Field Index");
} }
bool Verify(flatbuffers::Verifier &verifier) const { bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) && return VerifyTableStart(verifier) &&
VerifyField<uint8_t>(verifier, VT_MAIN_CHARACTER_TYPE, 1) && VerifyField<uint8_t>(verifier, VT_MAIN_CHARACTER_TYPE, 1) &&
VerifyOffset(verifier, VT_MAIN_CHARACTER) && VerifyOffset(verifier, VT_MAIN_CHARACTER) &&
@@ -624,44 +624,44 @@ struct Movie FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VerifyCharacterVector(verifier, characters(), characters_type()) && VerifyCharacterVector(verifier, characters(), characters_type()) &&
verifier.EndTable(); verifier.EndTable();
} }
MovieT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; MovieT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(MovieT *_o, 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); static ::flatbuffers::Offset<Movie> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const MovieT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
}; };
struct MovieBuilder { struct MovieBuilder {
typedef Movie Table; typedef Movie Table;
flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_; ::flatbuffers::uoffset_t start_;
void add_main_character_type(Character main_character_type) { 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); 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); 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); 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); fbb_.AddOffset(Movie::VT_CHARACTERS, characters);
} }
explicit MovieBuilder(flatbuffers::FlatBufferBuilder &_fbb) explicit MovieBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) { : fbb_(_fbb) {
start_ = fbb_.StartTable(); start_ = fbb_.StartTable();
} }
flatbuffers::Offset<Movie> Finish() { ::flatbuffers::Offset<Movie> Finish() {
const auto end = fbb_.EndTable(start_); const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<Movie>(end); auto o = ::flatbuffers::Offset<Movie>(end);
return o; return o;
} }
}; };
inline flatbuffers::Offset<Movie> CreateMovie( inline ::flatbuffers::Offset<Movie> CreateMovie(
flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::FlatBufferBuilder &_fbb,
Character main_character_type = Character::NONE, Character main_character_type = Character::NONE,
flatbuffers::Offset<void> main_character = 0, ::flatbuffers::Offset<void> main_character = 0,
flatbuffers::Offset<flatbuffers::Vector<Character>> characters_type = 0, ::flatbuffers::Offset<::flatbuffers::Vector<Character>> characters_type = 0,
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<void>>> characters = 0) { ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<void>>> characters = 0) {
MovieBuilder builder_(_fbb); MovieBuilder builder_(_fbb);
builder_.add_characters(characters); builder_.add_characters(characters);
builder_.add_characters_type(characters_type); builder_.add_characters_type(characters_type);
@@ -686,14 +686,14 @@ struct Movie::Traits {
using FieldType = decltype(std::declval<type>().get_field<Index>()); using FieldType = decltype(std::declval<type>().get_field<Index>());
}; };
inline flatbuffers::Offset<Movie> CreateMovieDirect( inline ::flatbuffers::Offset<Movie> CreateMovieDirect(
flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::FlatBufferBuilder &_fbb,
Character main_character_type = Character::NONE, 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<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_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( return CreateMovie(
_fbb, _fbb,
main_character_type, main_character_type,
@@ -702,87 +702,87 @@ inline flatbuffers::Offset<Movie> CreateMovieDirect(
characters__); 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>(); auto _o = std::make_unique<AttackerT>();
UnPackTo(_o.get(), _resolver); UnPackTo(_o.get(), _resolver);
return _o.release(); 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)_o;
(void)_resolver; (void)_resolver;
{ auto _e = sword_attack_damage(); _o->sword_attack_damage = _e; } { 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); 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)_rehasher;
(void)_o; (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; auto _sword_attack_damage = _o->sword_attack_damage;
return CreateAttacker( return CreateAttacker(
_fbb, _fbb,
_sword_attack_damage); _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>(); auto _o = std::make_unique<HandFanT>();
UnPackTo(_o.get(), _resolver); UnPackTo(_o.get(), _resolver);
return _o.release(); 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)_o;
(void)_resolver; (void)_resolver;
{ auto _e = length(); _o->length = _e; } { 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); 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)_rehasher;
(void)_o; (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; auto _length = _o->length;
return CreateHandFan( return CreateHandFan(
_fbb, _fbb,
_length); _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>(); auto _o = std::make_unique<MovieT>();
UnPackTo(_o.get(), _resolver); UnPackTo(_o.get(), _resolver);
return _o.release(); 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)_o;
(void)_resolver; (void)_resolver;
{ auto _e = main_character_type(); _o->main_character.type = _e; } { 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 = 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_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(); 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); 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)_rehasher;
(void)_o; (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_type = _o->main_character.type;
auto _main_character = _o->main_character.Pack(_fbb); 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_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( return CreateMovie(
_fbb, _fbb,
_main_character_type, _main_character_type,
@@ -791,7 +791,7 @@ inline flatbuffers::Offset<Movie> CreateMovie(flatbuffers::FlatBufferBuilder &_f
_characters); _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) { switch (type) {
case Character::NONE: { case Character::NONE: {
return true; 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); return verifier.VerifyField<BookReader>(static_cast<const uint8_t *>(obj), 0, 4);
} }
case Character::Other: { case Character::Other: {
auto ptr = reinterpret_cast<const flatbuffers::String *>(obj); auto ptr = reinterpret_cast<const ::flatbuffers::String *>(obj);
return verifier.VerifyString(ptr); return verifier.VerifyString(ptr);
} }
case Character::Unused: { case Character::Unused: {
auto ptr = reinterpret_cast<const flatbuffers::String *>(obj); auto ptr = reinterpret_cast<const ::flatbuffers::String *>(obj);
return verifier.VerifyString(ptr); return verifier.VerifyString(ptr);
} }
default: return true; 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 || !types) return !values && !types;
if (values->size() != types->size()) return false; 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( if (!VerifyCharacter(
verifier, values->Get(i), types->GetEnum<Character>(i))) { verifier, values->Get(i), types->GetEnum<Character>(i))) {
return false; return false;
@@ -833,7 +833,7 @@ inline bool VerifyCharacterVector(flatbuffers::Verifier &verifier, const flatbuf
return true; 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; (void)resolver;
switch (type) { switch (type) {
case Character::MuLan: { case Character::MuLan: {
@@ -853,18 +853,18 @@ inline void *CharacterUnion::UnPack(const void *obj, Character type, const flatb
return new BookReader(*ptr); return new BookReader(*ptr);
} }
case Character::Other: { 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()); return new std::string(ptr->c_str(), ptr->size());
} }
case Character::Unused: { 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()); return new std::string(ptr->c_str(), ptr->size());
} }
default: return nullptr; 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; (void)_rehasher;
switch (type) { switch (type) {
case Character::MuLan: { case Character::MuLan: {
@@ -964,7 +964,7 @@ inline void CharacterUnion::Reset() {
type = Character::NONE; 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) { switch (type) {
case Gadget::NONE: { case Gadget::NONE: {
return true; 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 || !types) return !values && !types;
if (values->size() != types->size()) return false; 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( if (!VerifyGadget(
verifier, values->Get(i), types->GetEnum<Gadget>(i))) { verifier, values->Get(i), types->GetEnum<Gadget>(i))) {
return false; return false;
@@ -992,7 +992,7 @@ inline bool VerifyGadgetVector(flatbuffers::Verifier &verifier, const flatbuffer
return true; 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; (void)resolver;
switch (type) { switch (type) {
case Gadget::FallingTub: { 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; (void)_rehasher;
switch (type) { switch (type) {
case Gadget::FallingTub: { case Gadget::FallingTub: {
@@ -1055,17 +1055,17 @@ inline void GadgetUnion::Reset() {
type = Gadget::NONE; type = Gadget::NONE;
} }
inline const flatbuffers::TypeTable *CharacterTypeTable() { inline const ::flatbuffers::TypeTable *CharacterTypeTable() {
static const flatbuffers::TypeCode type_codes[] = { static const ::flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_SEQUENCE, 0, -1 }, { ::flatbuffers::ET_SEQUENCE, 0, -1 },
{ flatbuffers::ET_SEQUENCE, 0, 0 }, { ::flatbuffers::ET_SEQUENCE, 0, 0 },
{ flatbuffers::ET_SEQUENCE, 0, 1 }, { ::flatbuffers::ET_SEQUENCE, 0, 1 },
{ flatbuffers::ET_SEQUENCE, 0, 2 }, { ::flatbuffers::ET_SEQUENCE, 0, 2 },
{ flatbuffers::ET_SEQUENCE, 0, 2 }, { ::flatbuffers::ET_SEQUENCE, 0, 2 },
{ flatbuffers::ET_STRING, 0, -1 }, { ::flatbuffers::ET_STRING, 0, -1 },
{ flatbuffers::ET_STRING, 0, -1 } { ::flatbuffers::ET_STRING, 0, -1 }
}; };
static const flatbuffers::TypeFunction type_refs[] = { static const ::flatbuffers::TypeFunction type_refs[] = {
AttackerTypeTable, AttackerTypeTable,
RapunzelTypeTable, RapunzelTypeTable,
BookReaderTypeTable BookReaderTypeTable
@@ -1079,19 +1079,19 @@ inline const flatbuffers::TypeTable *CharacterTypeTable() {
"Other", "Other",
"Unused" "Unused"
}; };
static const flatbuffers::TypeTable tt = { static const ::flatbuffers::TypeTable tt = {
flatbuffers::ST_UNION, 7, type_codes, type_refs, nullptr, nullptr, names ::flatbuffers::ST_UNION, 7, type_codes, type_refs, nullptr, nullptr, names
}; };
return &tt; return &tt;
} }
inline const flatbuffers::TypeTable *GadgetTypeTable() { inline const ::flatbuffers::TypeTable *GadgetTypeTable() {
static const flatbuffers::TypeCode type_codes[] = { static const ::flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_SEQUENCE, 0, -1 }, { ::flatbuffers::ET_SEQUENCE, 0, -1 },
{ flatbuffers::ET_SEQUENCE, 0, 0 }, { ::flatbuffers::ET_SEQUENCE, 0, 0 },
{ flatbuffers::ET_SEQUENCE, 0, 1 } { ::flatbuffers::ET_SEQUENCE, 0, 1 }
}; };
static const flatbuffers::TypeFunction type_refs[] = { static const ::flatbuffers::TypeFunction type_refs[] = {
FallingTubTypeTable, FallingTubTypeTable,
HandFanTypeTable HandFanTypeTable
}; };
@@ -1100,88 +1100,88 @@ inline const flatbuffers::TypeTable *GadgetTypeTable() {
"FallingTub", "FallingTub",
"HandFan" "HandFan"
}; };
static const flatbuffers::TypeTable tt = { static const ::flatbuffers::TypeTable tt = {
flatbuffers::ST_UNION, 3, type_codes, type_refs, nullptr, nullptr, names ::flatbuffers::ST_UNION, 3, type_codes, type_refs, nullptr, nullptr, names
}; };
return &tt; return &tt;
} }
inline const flatbuffers::TypeTable *AttackerTypeTable() { inline const ::flatbuffers::TypeTable *AttackerTypeTable() {
static const flatbuffers::TypeCode type_codes[] = { static const ::flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_INT, 0, -1 } { ::flatbuffers::ET_INT, 0, -1 }
}; };
static const char * const names[] = { static const char * const names[] = {
"sword_attack_damage" "sword_attack_damage"
}; };
static const flatbuffers::TypeTable tt = { static const ::flatbuffers::TypeTable tt = {
flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names ::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
}; };
return &tt; return &tt;
} }
inline const flatbuffers::TypeTable *RapunzelTypeTable() { inline const ::flatbuffers::TypeTable *RapunzelTypeTable() {
static const flatbuffers::TypeCode type_codes[] = { static const ::flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_INT, 0, -1 } { ::flatbuffers::ET_INT, 0, -1 }
}; };
static const int64_t values[] = { 0, 4 }; static const int64_t values[] = { 0, 4 };
static const char * const names[] = { static const char * const names[] = {
"hair_length" "hair_length"
}; };
static const flatbuffers::TypeTable tt = { static const ::flatbuffers::TypeTable tt = {
flatbuffers::ST_STRUCT, 1, type_codes, nullptr, nullptr, values, names ::flatbuffers::ST_STRUCT, 1, type_codes, nullptr, nullptr, values, names
}; };
return &tt; return &tt;
} }
inline const flatbuffers::TypeTable *BookReaderTypeTable() { inline const ::flatbuffers::TypeTable *BookReaderTypeTable() {
static const flatbuffers::TypeCode type_codes[] = { static const ::flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_INT, 0, -1 } { ::flatbuffers::ET_INT, 0, -1 }
}; };
static const int64_t values[] = { 0, 4 }; static const int64_t values[] = { 0, 4 };
static const char * const names[] = { static const char * const names[] = {
"books_read" "books_read"
}; };
static const flatbuffers::TypeTable tt = { static const ::flatbuffers::TypeTable tt = {
flatbuffers::ST_STRUCT, 1, type_codes, nullptr, nullptr, values, names ::flatbuffers::ST_STRUCT, 1, type_codes, nullptr, nullptr, values, names
}; };
return &tt; return &tt;
} }
inline const flatbuffers::TypeTable *FallingTubTypeTable() { inline const ::flatbuffers::TypeTable *FallingTubTypeTable() {
static const flatbuffers::TypeCode type_codes[] = { static const ::flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_INT, 0, -1 } { ::flatbuffers::ET_INT, 0, -1 }
}; };
static const int64_t values[] = { 0, 4 }; static const int64_t values[] = { 0, 4 };
static const char * const names[] = { static const char * const names[] = {
"weight" "weight"
}; };
static const flatbuffers::TypeTable tt = { static const ::flatbuffers::TypeTable tt = {
flatbuffers::ST_STRUCT, 1, type_codes, nullptr, nullptr, values, names ::flatbuffers::ST_STRUCT, 1, type_codes, nullptr, nullptr, values, names
}; };
return &tt; return &tt;
} }
inline const flatbuffers::TypeTable *HandFanTypeTable() { inline const ::flatbuffers::TypeTable *HandFanTypeTable() {
static const flatbuffers::TypeCode type_codes[] = { static const ::flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_INT, 0, -1 } { ::flatbuffers::ET_INT, 0, -1 }
}; };
static const char * const names[] = { static const char * const names[] = {
"length" "length"
}; };
static const flatbuffers::TypeTable tt = { static const ::flatbuffers::TypeTable tt = {
flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names ::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
}; };
return &tt; return &tt;
} }
inline const flatbuffers::TypeTable *MovieTypeTable() { inline const ::flatbuffers::TypeTable *MovieTypeTable() {
static const flatbuffers::TypeCode type_codes[] = { static const ::flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_UTYPE, 0, 0 }, { ::flatbuffers::ET_UTYPE, 0, 0 },
{ flatbuffers::ET_SEQUENCE, 0, 0 }, { ::flatbuffers::ET_SEQUENCE, 0, 0 },
{ flatbuffers::ET_UTYPE, 1, 0 }, { ::flatbuffers::ET_UTYPE, 1, 0 },
{ flatbuffers::ET_SEQUENCE, 1, 0 } { ::flatbuffers::ET_SEQUENCE, 1, 0 }
}; };
static const flatbuffers::TypeFunction type_refs[] = { static const ::flatbuffers::TypeFunction type_refs[] = {
CharacterTypeTable CharacterTypeTable
}; };
static const char * const names[] = { static const char * const names[] = {
@@ -1190,26 +1190,26 @@ inline const flatbuffers::TypeTable *MovieTypeTable() {
"characters_type", "characters_type",
"characters" "characters"
}; };
static const flatbuffers::TypeTable tt = { static const ::flatbuffers::TypeTable tt = {
flatbuffers::ST_TABLE, 4, type_codes, type_refs, nullptr, nullptr, names ::flatbuffers::ST_TABLE, 4, type_codes, type_refs, nullptr, nullptr, names
}; };
return &tt; return &tt;
} }
inline const Movie *GetMovie(const void *buf) { inline const Movie *GetMovie(const void *buf) {
return flatbuffers::GetRoot<Movie>(buf); return ::flatbuffers::GetRoot<Movie>(buf);
} }
inline const Movie *GetSizePrefixedMovie(const void *buf) { inline const Movie *GetSizePrefixedMovie(const void *buf) {
return flatbuffers::GetSizePrefixedRoot<Movie>(buf); return ::flatbuffers::GetSizePrefixedRoot<Movie>(buf);
} }
inline Movie *GetMutableMovie(void *buf) { inline Movie *GetMutableMovie(void *buf) {
return flatbuffers::GetMutableRoot<Movie>(buf); return ::flatbuffers::GetMutableRoot<Movie>(buf);
} }
inline Movie *GetMutableSizePrefixedMovie(void *buf) { inline Movie *GetMutableSizePrefixedMovie(void *buf) {
return flatbuffers::GetMutableSizePrefixedRoot<Movie>(buf); return ::flatbuffers::GetMutableSizePrefixedRoot<Movie>(buf);
} }
inline const char *MovieIdentifier() { inline const char *MovieIdentifier() {
@@ -1217,46 +1217,46 @@ inline const char *MovieIdentifier() {
} }
inline bool MovieBufferHasIdentifier(const void *buf) { inline bool MovieBufferHasIdentifier(const void *buf) {
return flatbuffers::BufferHasIdentifier( return ::flatbuffers::BufferHasIdentifier(
buf, MovieIdentifier()); buf, MovieIdentifier());
} }
inline bool SizePrefixedMovieBufferHasIdentifier(const void *buf) { inline bool SizePrefixedMovieBufferHasIdentifier(const void *buf) {
return flatbuffers::BufferHasIdentifier( return ::flatbuffers::BufferHasIdentifier(
buf, MovieIdentifier(), true); buf, MovieIdentifier(), true);
} }
inline bool VerifyMovieBuffer( inline bool VerifyMovieBuffer(
flatbuffers::Verifier &verifier) { ::flatbuffers::Verifier &verifier) {
return verifier.VerifyBuffer<Movie>(MovieIdentifier()); return verifier.VerifyBuffer<Movie>(MovieIdentifier());
} }
inline bool VerifySizePrefixedMovieBuffer( inline bool VerifySizePrefixedMovieBuffer(
flatbuffers::Verifier &verifier) { ::flatbuffers::Verifier &verifier) {
return verifier.VerifySizePrefixedBuffer<Movie>(MovieIdentifier()); return verifier.VerifySizePrefixedBuffer<Movie>(MovieIdentifier());
} }
inline void FinishMovieBuffer( inline void FinishMovieBuffer(
flatbuffers::FlatBufferBuilder &fbb, ::flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<Movie> root) { ::flatbuffers::Offset<Movie> root) {
fbb.Finish(root, MovieIdentifier()); fbb.Finish(root, MovieIdentifier());
} }
inline void FinishSizePrefixedMovieBuffer( inline void FinishSizePrefixedMovieBuffer(
flatbuffers::FlatBufferBuilder &fbb, ::flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<Movie> root) { ::flatbuffers::Offset<Movie> root) {
fbb.FinishSizePrefixed(root, MovieIdentifier()); fbb.FinishSizePrefixed(root, MovieIdentifier());
} }
inline std::unique_ptr<MovieT> UnPackMovie( inline std::unique_ptr<MovieT> UnPackMovie(
const void *buf, 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)); return std::unique_ptr<MovieT>(GetMovie(buf)->UnPack(res));
} }
inline std::unique_ptr<MovieT> UnPackSizePrefixedMovie( inline std::unique_ptr<MovieT> UnPackSizePrefixedMovie(
const void *buf, 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)); return std::unique_ptr<MovieT>(GetSizePrefixedMovie(buf)->UnPack(res));
} }

134
tests/evolution_test/evolution_v1_generated.h
View File

@@ -52,7 +52,7 @@ inline const char * const *EnumNamesEnum() {
} }
inline const char *EnumNameEnum(Enum e) { inline const char *EnumNameEnum(Enum e) {
if (flatbuffers::IsOutRange(e, Enum::King, Enum::Queen)) return ""; if (::flatbuffers::IsOutRange(e, Enum::King, Enum::Queen)) return "";
const size_t index = static_cast<size_t>(e); const size_t index = static_cast<size_t>(e);
return EnumNamesEnum()[index]; return EnumNamesEnum()[index];
} }
@@ -85,7 +85,7 @@ inline const char * const *EnumNamesUnion() {
} }
inline const char *EnumNameUnion(Union e) { inline const char *EnumNameUnion(Union e) {
if (flatbuffers::IsOutRange(e, Union::NONE, Union::TableB)) return ""; if (::flatbuffers::IsOutRange(e, Union::NONE, Union::TableB)) return "";
const size_t index = static_cast<size_t>(e); const size_t index = static_cast<size_t>(e);
return EnumNamesUnion()[index]; return EnumNamesUnion()[index];
} }
@@ -102,8 +102,8 @@ template<> struct UnionTraits<Evolution::V1::TableB> {
static const Union enum_value = Union::TableB; static const Union enum_value = Union::TableB;
}; };
bool VerifyUnion(flatbuffers::Verifier &verifier, const void *obj, Union type); bool VerifyUnion(::flatbuffers::Verifier &verifier, const void *obj, Union type);
bool VerifyUnionVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<Union> *types); bool VerifyUnionVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Union> *types);
FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) Struct FLATBUFFERS_FINAL_CLASS { FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) Struct FLATBUFFERS_FINAL_CLASS {
private: private:
@@ -119,16 +119,16 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) Struct FLATBUFFERS_FINAL_CLASS {
(void)padding0__; (void)padding0__;
} }
Struct(int32_t _a, double _b) Struct(int32_t _a, double _b)
: a_(flatbuffers::EndianScalar(_a)), : a_(::flatbuffers::EndianScalar(_a)),
padding0__(0), padding0__(0),
b_(flatbuffers::EndianScalar(_b)) { b_(::flatbuffers::EndianScalar(_b)) {
(void)padding0__; (void)padding0__;
} }
int32_t a() const { int32_t a() const {
return flatbuffers::EndianScalar(a_); return ::flatbuffers::EndianScalar(a_);
} }
double b() const { double b() const {
return flatbuffers::EndianScalar(b_); return ::flatbuffers::EndianScalar(b_);
} }
}; };
FLATBUFFERS_STRUCT_END(Struct, 16); FLATBUFFERS_STRUCT_END(Struct, 16);
@@ -144,7 +144,7 @@ inline bool operator!=(const Struct &lhs, const Struct &rhs) {
} }
struct TableA FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { struct TableA FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef TableABuilder Builder; typedef TableABuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_A = 4, VT_A = 4,
@@ -156,7 +156,7 @@ struct TableA FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
int32_t b() const { int32_t b() const {
return GetField<int32_t>(VT_B, 0); return GetField<int32_t>(VT_B, 0);
} }
bool Verify(flatbuffers::Verifier &verifier) const { bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) && return VerifyTableStart(verifier) &&
VerifyField<float>(verifier, VT_A, 4) && VerifyField<float>(verifier, VT_A, 4) &&
VerifyField<int32_t>(verifier, VT_B, 4) && VerifyField<int32_t>(verifier, VT_B, 4) &&
@@ -166,27 +166,27 @@ struct TableA FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct TableABuilder { struct TableABuilder {
typedef TableA Table; typedef TableA Table;
flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_; ::flatbuffers::uoffset_t start_;
void add_a(float a) { void add_a(float a) {
fbb_.AddElement<float>(TableA::VT_A, a, 0.0f); fbb_.AddElement<float>(TableA::VT_A, a, 0.0f);
} }
void add_b(int32_t b) { void add_b(int32_t b) {
fbb_.AddElement<int32_t>(TableA::VT_B, b, 0); fbb_.AddElement<int32_t>(TableA::VT_B, b, 0);
} }
explicit TableABuilder(flatbuffers::FlatBufferBuilder &_fbb) explicit TableABuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) { : fbb_(_fbb) {
start_ = fbb_.StartTable(); start_ = fbb_.StartTable();
} }
flatbuffers::Offset<TableA> Finish() { ::flatbuffers::Offset<TableA> Finish() {
const auto end = fbb_.EndTable(start_); const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<TableA>(end); auto o = ::flatbuffers::Offset<TableA>(end);
return o; return o;
} }
}; };
inline flatbuffers::Offset<TableA> CreateTableA( inline ::flatbuffers::Offset<TableA> CreateTableA(
flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::FlatBufferBuilder &_fbb,
float a = 0.0f, float a = 0.0f,
int32_t b = 0) { int32_t b = 0) {
TableABuilder builder_(_fbb); TableABuilder builder_(_fbb);
@@ -195,7 +195,7 @@ inline flatbuffers::Offset<TableA> CreateTableA(
return builder_.Finish(); return builder_.Finish();
} }
struct TableB FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { struct TableB FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef TableBBuilder Builder; typedef TableBBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_A = 4 VT_A = 4
@@ -203,7 +203,7 @@ struct TableB FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
int32_t a() const { int32_t a() const {
return GetField<int32_t>(VT_A, 0); return GetField<int32_t>(VT_A, 0);
} }
bool Verify(flatbuffers::Verifier &verifier) const { bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) && return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_A, 4) && VerifyField<int32_t>(verifier, VT_A, 4) &&
verifier.EndTable(); verifier.EndTable();
@@ -212,31 +212,31 @@ struct TableB FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct TableBBuilder { struct TableBBuilder {
typedef TableB Table; typedef TableB Table;
flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_; ::flatbuffers::uoffset_t start_;
void add_a(int32_t a) { void add_a(int32_t a) {
fbb_.AddElement<int32_t>(TableB::VT_A, a, 0); fbb_.AddElement<int32_t>(TableB::VT_A, a, 0);
} }
explicit TableBBuilder(flatbuffers::FlatBufferBuilder &_fbb) explicit TableBBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) { : fbb_(_fbb) {
start_ = fbb_.StartTable(); start_ = fbb_.StartTable();
} }
flatbuffers::Offset<TableB> Finish() { ::flatbuffers::Offset<TableB> Finish() {
const auto end = fbb_.EndTable(start_); const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<TableB>(end); auto o = ::flatbuffers::Offset<TableB>(end);
return o; return o;
} }
}; };
inline flatbuffers::Offset<TableB> CreateTableB( inline ::flatbuffers::Offset<TableB> CreateTableB(
flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::FlatBufferBuilder &_fbb,
int32_t a = 0) { int32_t a = 0) {
TableBBuilder builder_(_fbb); TableBBuilder builder_(_fbb);
builder_.add_a(a); builder_.add_a(a);
return builder_.Finish(); return builder_.Finish();
} }
struct Root FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { struct Root FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef RootBuilder Builder; typedef RootBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_A = 4, VT_A = 4,
@@ -280,11 +280,11 @@ struct Root FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
const Evolution::V1::Struct *f() const { const Evolution::V1::Struct *f() const {
return GetStruct<const Evolution::V1::Struct *>(VT_F); return GetStruct<const Evolution::V1::Struct *>(VT_F);
} }
const flatbuffers::Vector<int32_t> *g() const { const ::flatbuffers::Vector<int32_t> *g() const {
return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_G); return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_G);
} }
const flatbuffers::Vector<flatbuffers::Offset<Evolution::V1::TableB>> *h() const { const ::flatbuffers::Vector<::flatbuffers::Offset<Evolution::V1::TableB>> *h() const {
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<Evolution::V1::TableB>> *>(VT_H); return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<Evolution::V1::TableB>> *>(VT_H);
} }
int32_t i() const { int32_t i() const {
return GetField<int32_t>(VT_I, 1234); return GetField<int32_t>(VT_I, 1234);
@@ -302,7 +302,7 @@ struct Root FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
const Evolution::V1::TableB *j_as_TableB() const { const Evolution::V1::TableB *j_as_TableB() const {
return j_type() == Evolution::V1::Union::TableB ? static_cast<const Evolution::V1::TableB *>(j()) : nullptr; return j_type() == Evolution::V1::Union::TableB ? static_cast<const Evolution::V1::TableB *>(j()) : nullptr;
} }
bool Verify(flatbuffers::Verifier &verifier) const { bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) && return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_A, 4) && VerifyField<int32_t>(verifier, VT_A, 4) &&
VerifyField<uint8_t>(verifier, VT_B, 1) && VerifyField<uint8_t>(verifier, VT_B, 1) &&
@@ -344,8 +344,8 @@ template<> inline const Evolution::V1::TableB *Root::j_as<Evolution::V1::TableB>
struct RootBuilder { struct RootBuilder {
typedef Root Table; typedef Root Table;
flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_; ::flatbuffers::uoffset_t start_;
void add_a(int32_t a) { void add_a(int32_t a) {
fbb_.AddElement<int32_t>(Root::VT_A, a, 0); fbb_.AddElement<int32_t>(Root::VT_A, a, 0);
} }
@@ -355,22 +355,22 @@ struct RootBuilder {
void add_c_type(Evolution::V1::Union c_type) { void add_c_type(Evolution::V1::Union c_type) {
fbb_.AddElement<uint8_t>(Root::VT_C_TYPE, static_cast<uint8_t>(c_type), 0); fbb_.AddElement<uint8_t>(Root::VT_C_TYPE, static_cast<uint8_t>(c_type), 0);
} }
void add_c(flatbuffers::Offset<void> c) { void add_c(::flatbuffers::Offset<void> c) {
fbb_.AddOffset(Root::VT_C, c); fbb_.AddOffset(Root::VT_C, c);
} }
void add_d(Evolution::V1::Enum d) { void add_d(Evolution::V1::Enum d) {
fbb_.AddElement<int8_t>(Root::VT_D, static_cast<int8_t>(d), 0); fbb_.AddElement<int8_t>(Root::VT_D, static_cast<int8_t>(d), 0);
} }
void add_e(flatbuffers::Offset<Evolution::V1::TableA> e) { void add_e(::flatbuffers::Offset<Evolution::V1::TableA> e) {
fbb_.AddOffset(Root::VT_E, e); fbb_.AddOffset(Root::VT_E, e);
} }
void add_f(const Evolution::V1::Struct *f) { void add_f(const Evolution::V1::Struct *f) {
fbb_.AddStruct(Root::VT_F, f); fbb_.AddStruct(Root::VT_F, f);
} }
void add_g(flatbuffers::Offset<flatbuffers::Vector<int32_t>> g) { void add_g(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> g) {
fbb_.AddOffset(Root::VT_G, g); fbb_.AddOffset(Root::VT_G, g);
} }
void add_h(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Evolution::V1::TableB>>> h) { void add_h(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<Evolution::V1::TableB>>> h) {
fbb_.AddOffset(Root::VT_H, h); fbb_.AddOffset(Root::VT_H, h);
} }
void add_i(int32_t i) { void add_i(int32_t i) {
@@ -379,34 +379,34 @@ struct RootBuilder {
void add_j_type(Evolution::V1::Union j_type) { void add_j_type(Evolution::V1::Union j_type) {
fbb_.AddElement<uint8_t>(Root::VT_J_TYPE, static_cast<uint8_t>(j_type), 0); fbb_.AddElement<uint8_t>(Root::VT_J_TYPE, static_cast<uint8_t>(j_type), 0);
} }
void add_j(flatbuffers::Offset<void> j) { void add_j(::flatbuffers::Offset<void> j) {
fbb_.AddOffset(Root::VT_J, j); fbb_.AddOffset(Root::VT_J, j);
} }
explicit RootBuilder(flatbuffers::FlatBufferBuilder &_fbb) explicit RootBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) { : fbb_(_fbb) {
start_ = fbb_.StartTable(); start_ = fbb_.StartTable();
} }
flatbuffers::Offset<Root> Finish() { ::flatbuffers::Offset<Root> Finish() {
const auto end = fbb_.EndTable(start_); const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<Root>(end); auto o = ::flatbuffers::Offset<Root>(end);
return o; return o;
} }
}; };
inline flatbuffers::Offset<Root> CreateRoot( inline ::flatbuffers::Offset<Root> CreateRoot(
flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::FlatBufferBuilder &_fbb,
int32_t a = 0, int32_t a = 0,
bool b = false, bool b = false,
Evolution::V1::Union c_type = Evolution::V1::Union::NONE, Evolution::V1::Union c_type = Evolution::V1::Union::NONE,
flatbuffers::Offset<void> c = 0, ::flatbuffers::Offset<void> c = 0,
Evolution::V1::Enum d = Evolution::V1::Enum::King, Evolution::V1::Enum d = Evolution::V1::Enum::King,
flatbuffers::Offset<Evolution::V1::TableA> e = 0, ::flatbuffers::Offset<Evolution::V1::TableA> e = 0,
const Evolution::V1::Struct *f = nullptr, const Evolution::V1::Struct *f = nullptr,
flatbuffers::Offset<flatbuffers::Vector<int32_t>> g = 0, ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> g = 0,
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Evolution::V1::TableB>>> h = 0, ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<Evolution::V1::TableB>>> h = 0,
int32_t i = 1234, int32_t i = 1234,
Evolution::V1::Union j_type = Evolution::V1::Union::NONE, Evolution::V1::Union j_type = Evolution::V1::Union::NONE,
flatbuffers::Offset<void> j = 0) { ::flatbuffers::Offset<void> j = 0) {
RootBuilder builder_(_fbb); RootBuilder builder_(_fbb);
builder_.add_j(j); builder_.add_j(j);
builder_.add_i(i); builder_.add_i(i);
@@ -423,22 +423,22 @@ inline flatbuffers::Offset<Root> CreateRoot(
return builder_.Finish(); return builder_.Finish();
} }
inline flatbuffers::Offset<Root> CreateRootDirect( inline ::flatbuffers::Offset<Root> CreateRootDirect(
flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::FlatBufferBuilder &_fbb,
int32_t a = 0, int32_t a = 0,
bool b = false, bool b = false,
Evolution::V1::Union c_type = Evolution::V1::Union::NONE, Evolution::V1::Union c_type = Evolution::V1::Union::NONE,
flatbuffers::Offset<void> c = 0, ::flatbuffers::Offset<void> c = 0,
Evolution::V1::Enum d = Evolution::V1::Enum::King, Evolution::V1::Enum d = Evolution::V1::Enum::King,
flatbuffers::Offset<Evolution::V1::TableA> e = 0, ::flatbuffers::Offset<Evolution::V1::TableA> e = 0,
const Evolution::V1::Struct *f = nullptr, const Evolution::V1::Struct *f = nullptr,
const std::vector<int32_t> *g = nullptr, const std::vector<int32_t> *g = nullptr,
const std::vector<flatbuffers::Offset<Evolution::V1::TableB>> *h = nullptr, const std::vector<::flatbuffers::Offset<Evolution::V1::TableB>> *h = nullptr,
int32_t i = 1234, int32_t i = 1234,
Evolution::V1::Union j_type = Evolution::V1::Union::NONE, Evolution::V1::Union j_type = Evolution::V1::Union::NONE,
flatbuffers::Offset<void> j = 0) { ::flatbuffers::Offset<void> j = 0) {
auto g__ = g ? _fbb.CreateVector<int32_t>(*g) : 0; auto g__ = g ? _fbb.CreateVector<int32_t>(*g) : 0;
auto h__ = h ? _fbb.CreateVector<flatbuffers::Offset<Evolution::V1::TableB>>(*h) : 0; auto h__ = h ? _fbb.CreateVector<::flatbuffers::Offset<Evolution::V1::TableB>>(*h) : 0;
return Evolution::V1::CreateRoot( return Evolution::V1::CreateRoot(
_fbb, _fbb,
a, a,
@@ -455,7 +455,7 @@ inline flatbuffers::Offset<Root> CreateRootDirect(
j); j);
} }
inline bool VerifyUnion(flatbuffers::Verifier &verifier, const void *obj, Union type) { inline bool VerifyUnion(::flatbuffers::Verifier &verifier, const void *obj, Union type) {
switch (type) { switch (type) {
case Union::NONE: { case Union::NONE: {
return true; return true;
@@ -472,10 +472,10 @@ inline bool VerifyUnion(flatbuffers::Verifier &verifier, const void *obj, Union
} }
} }
inline bool VerifyUnionVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<Union> *types) { inline bool VerifyUnionVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Union> *types) {
if (!values || !types) return !values && !types; if (!values || !types) return !values && !types;
if (values->size() != types->size()) return false; 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 (!VerifyUnion( if (!VerifyUnion(
verifier, values->Get(i), types->GetEnum<Union>(i))) { verifier, values->Get(i), types->GetEnum<Union>(i))) {
return false; return false;
@@ -485,32 +485,32 @@ inline bool VerifyUnionVector(flatbuffers::Verifier &verifier, const flatbuffers
} }
inline const Evolution::V1::Root *GetRoot(const void *buf) { inline const Evolution::V1::Root *GetRoot(const void *buf) {
return flatbuffers::GetRoot<Evolution::V1::Root>(buf); return ::flatbuffers::GetRoot<Evolution::V1::Root>(buf);
} }
inline const Evolution::V1::Root *GetSizePrefixedRoot(const void *buf) { inline const Evolution::V1::Root *GetSizePrefixedRoot(const void *buf) {
return flatbuffers::GetSizePrefixedRoot<Evolution::V1::Root>(buf); return ::flatbuffers::GetSizePrefixedRoot<Evolution::V1::Root>(buf);
} }
inline bool VerifyRootBuffer( inline bool VerifyRootBuffer(
flatbuffers::Verifier &verifier) { ::flatbuffers::Verifier &verifier) {
return verifier.VerifyBuffer<Evolution::V1::Root>(nullptr); return verifier.VerifyBuffer<Evolution::V1::Root>(nullptr);
} }
inline bool VerifySizePrefixedRootBuffer( inline bool VerifySizePrefixedRootBuffer(
flatbuffers::Verifier &verifier) { ::flatbuffers::Verifier &verifier) {
return verifier.VerifySizePrefixedBuffer<Evolution::V1::Root>(nullptr); return verifier.VerifySizePrefixedBuffer<Evolution::V1::Root>(nullptr);
} }
inline void FinishRootBuffer( inline void FinishRootBuffer(
flatbuffers::FlatBufferBuilder &fbb, ::flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<Evolution::V1::Root> root) { ::flatbuffers::Offset<Evolution::V1::Root> root) {
fbb.Finish(root); fbb.Finish(root);
} }
inline void FinishSizePrefixedRootBuffer( inline void FinishSizePrefixedRootBuffer(
flatbuffers::FlatBufferBuilder &fbb, ::flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<Evolution::V1::Root> root) { ::flatbuffers::Offset<Evolution::V1::Root> root) {
fbb.FinishSizePrefixed(root); fbb.FinishSizePrefixed(root);
} }

176
tests/evolution_test/evolution_v2_generated.h
View File

@@ -61,7 +61,7 @@ inline const char * const *EnumNamesEnum() {
} }
inline const char *EnumNameEnum(Enum e) { inline const char *EnumNameEnum(Enum e) {
if (flatbuffers::IsOutRange(e, Enum::King, Enum::Bishop)) return ""; if (::flatbuffers::IsOutRange(e, Enum::King, Enum::Bishop)) return "";
const size_t index = static_cast<size_t>(e); const size_t index = static_cast<size_t>(e);
return EnumNamesEnum()[index]; return EnumNamesEnum()[index];
} }
@@ -97,7 +97,7 @@ inline const char * const *EnumNamesUnion() {
} }
inline const char *EnumNameUnion(Union e) { inline const char *EnumNameUnion(Union e) {
if (flatbuffers::IsOutRange(e, Union::NONE, Union::TableC)) return ""; if (::flatbuffers::IsOutRange(e, Union::NONE, Union::TableC)) return "";
const size_t index = static_cast<size_t>(e); const size_t index = static_cast<size_t>(e);
return EnumNamesUnion()[index]; return EnumNamesUnion()[index];
} }
@@ -118,8 +118,8 @@ template<> struct UnionTraits<Evolution::V2::TableC> {
static const Union enum_value = Union::TableC; static const Union enum_value = Union::TableC;
}; };
bool VerifyUnion(flatbuffers::Verifier &verifier, const void *obj, Union type); bool VerifyUnion(::flatbuffers::Verifier &verifier, const void *obj, Union type);
bool VerifyUnionVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<Union> *types); bool VerifyUnionVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Union> *types);
FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) Struct FLATBUFFERS_FINAL_CLASS { FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) Struct FLATBUFFERS_FINAL_CLASS {
private: private:
@@ -135,16 +135,16 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) Struct FLATBUFFERS_FINAL_CLASS {
(void)padding0__; (void)padding0__;
} }
Struct(int32_t _a, double _b) Struct(int32_t _a, double _b)
: a_(flatbuffers::EndianScalar(_a)), : a_(::flatbuffers::EndianScalar(_a)),
padding0__(0), padding0__(0),
b_(flatbuffers::EndianScalar(_b)) { b_(::flatbuffers::EndianScalar(_b)) {
(void)padding0__; (void)padding0__;
} }
int32_t a() const { int32_t a() const {
return flatbuffers::EndianScalar(a_); return ::flatbuffers::EndianScalar(a_);
} }
double b() const { double b() const {
return flatbuffers::EndianScalar(b_); return ::flatbuffers::EndianScalar(b_);
} }
}; };
FLATBUFFERS_STRUCT_END(Struct, 16); FLATBUFFERS_STRUCT_END(Struct, 16);
@@ -160,7 +160,7 @@ inline bool operator!=(const Struct &lhs, const Struct &rhs) {
} }
struct TableA FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { struct TableA FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef TableABuilder Builder; typedef TableABuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_A = 4, VT_A = 4,
@@ -173,10 +173,10 @@ struct TableA FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
int32_t b() const { int32_t b() const {
return GetField<int32_t>(VT_B, 0); return GetField<int32_t>(VT_B, 0);
} }
const flatbuffers::String *c() const { const ::flatbuffers::String *c() const {
return GetPointer<const flatbuffers::String *>(VT_C); return GetPointer<const ::flatbuffers::String *>(VT_C);
} }
bool Verify(flatbuffers::Verifier &verifier) const { bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) && return VerifyTableStart(verifier) &&
VerifyField<float>(verifier, VT_A, 4) && VerifyField<float>(verifier, VT_A, 4) &&
VerifyField<int32_t>(verifier, VT_B, 4) && VerifyField<int32_t>(verifier, VT_B, 4) &&
@@ -188,33 +188,33 @@ struct TableA FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct TableABuilder { struct TableABuilder {
typedef TableA Table; typedef TableA Table;
flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_; ::flatbuffers::uoffset_t start_;
void add_a(float a) { void add_a(float a) {
fbb_.AddElement<float>(TableA::VT_A, a, 0.0f); fbb_.AddElement<float>(TableA::VT_A, a, 0.0f);
} }
void add_b(int32_t b) { void add_b(int32_t b) {
fbb_.AddElement<int32_t>(TableA::VT_B, b, 0); fbb_.AddElement<int32_t>(TableA::VT_B, b, 0);
} }
void add_c(flatbuffers::Offset<flatbuffers::String> c) { void add_c(::flatbuffers::Offset<::flatbuffers::String> c) {
fbb_.AddOffset(TableA::VT_C, c); fbb_.AddOffset(TableA::VT_C, c);
} }
explicit TableABuilder(flatbuffers::FlatBufferBuilder &_fbb) explicit TableABuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) { : fbb_(_fbb) {
start_ = fbb_.StartTable(); start_ = fbb_.StartTable();
} }
flatbuffers::Offset<TableA> Finish() { ::flatbuffers::Offset<TableA> Finish() {
const auto end = fbb_.EndTable(start_); const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<TableA>(end); auto o = ::flatbuffers::Offset<TableA>(end);
return o; return o;
} }
}; };
inline flatbuffers::Offset<TableA> CreateTableA( inline ::flatbuffers::Offset<TableA> CreateTableA(
flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::FlatBufferBuilder &_fbb,
float a = 0.0f, float a = 0.0f,
int32_t b = 0, int32_t b = 0,
flatbuffers::Offset<flatbuffers::String> c = 0) { ::flatbuffers::Offset<::flatbuffers::String> c = 0) {
TableABuilder builder_(_fbb); TableABuilder builder_(_fbb);
builder_.add_c(c); builder_.add_c(c);
builder_.add_b(b); builder_.add_b(b);
@@ -222,8 +222,8 @@ inline flatbuffers::Offset<TableA> CreateTableA(
return builder_.Finish(); return builder_.Finish();
} }
inline flatbuffers::Offset<TableA> CreateTableADirect( inline ::flatbuffers::Offset<TableA> CreateTableADirect(
flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::FlatBufferBuilder &_fbb,
float a = 0.0f, float a = 0.0f,
int32_t b = 0, int32_t b = 0,
const char *c = nullptr) { const char *c = nullptr) {
@@ -235,7 +235,7 @@ inline flatbuffers::Offset<TableA> CreateTableADirect(
c__); c__);
} }
struct TableB FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { struct TableB FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef TableBBuilder Builder; typedef TableBBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_A = 4 VT_A = 4
@@ -243,7 +243,7 @@ struct TableB FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
int32_t a() const { int32_t a() const {
return GetField<int32_t>(VT_A, 0); return GetField<int32_t>(VT_A, 0);
} }
bool Verify(flatbuffers::Verifier &verifier) const { bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) && return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_A, 4) && VerifyField<int32_t>(verifier, VT_A, 4) &&
verifier.EndTable(); verifier.EndTable();
@@ -252,31 +252,31 @@ struct TableB FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct TableBBuilder { struct TableBBuilder {
typedef TableB Table; typedef TableB Table;
flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_; ::flatbuffers::uoffset_t start_;
void add_a(int32_t a) { void add_a(int32_t a) {
fbb_.AddElement<int32_t>(TableB::VT_A, a, 0); fbb_.AddElement<int32_t>(TableB::VT_A, a, 0);
} }
explicit TableBBuilder(flatbuffers::FlatBufferBuilder &_fbb) explicit TableBBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) { : fbb_(_fbb) {
start_ = fbb_.StartTable(); start_ = fbb_.StartTable();
} }
flatbuffers::Offset<TableB> Finish() { ::flatbuffers::Offset<TableB> Finish() {
const auto end = fbb_.EndTable(start_); const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<TableB>(end); auto o = ::flatbuffers::Offset<TableB>(end);
return o; return o;
} }
}; };
inline flatbuffers::Offset<TableB> CreateTableB( inline ::flatbuffers::Offset<TableB> CreateTableB(
flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::FlatBufferBuilder &_fbb,
int32_t a = 0) { int32_t a = 0) {
TableBBuilder builder_(_fbb); TableBBuilder builder_(_fbb);
builder_.add_a(a); builder_.add_a(a);
return builder_.Finish(); return builder_.Finish();
} }
struct TableC FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { struct TableC FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef TableCBuilder Builder; typedef TableCBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_A = 4, VT_A = 4,
@@ -285,10 +285,10 @@ struct TableC FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
double a() const { double a() const {
return GetField<double>(VT_A, 0.0); return GetField<double>(VT_A, 0.0);
} }
const flatbuffers::String *b() const { const ::flatbuffers::String *b() const {
return GetPointer<const flatbuffers::String *>(VT_B); return GetPointer<const ::flatbuffers::String *>(VT_B);
} }
bool Verify(flatbuffers::Verifier &verifier) const { bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) && return VerifyTableStart(verifier) &&
VerifyField<double>(verifier, VT_A, 8) && VerifyField<double>(verifier, VT_A, 8) &&
VerifyOffset(verifier, VT_B) && VerifyOffset(verifier, VT_B) &&
@@ -299,37 +299,37 @@ struct TableC FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
struct TableCBuilder { struct TableCBuilder {
typedef TableC Table; typedef TableC Table;
flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_; ::flatbuffers::uoffset_t start_;
void add_a(double a) { void add_a(double a) {
fbb_.AddElement<double>(TableC::VT_A, a, 0.0); fbb_.AddElement<double>(TableC::VT_A, a, 0.0);
} }
void add_b(flatbuffers::Offset<flatbuffers::String> b) { void add_b(::flatbuffers::Offset<::flatbuffers::String> b) {
fbb_.AddOffset(TableC::VT_B, b); fbb_.AddOffset(TableC::VT_B, b);
} }
explicit TableCBuilder(flatbuffers::FlatBufferBuilder &_fbb) explicit TableCBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) { : fbb_(_fbb) {
start_ = fbb_.StartTable(); start_ = fbb_.StartTable();
} }
flatbuffers::Offset<TableC> Finish() { ::flatbuffers::Offset<TableC> Finish() {
const auto end = fbb_.EndTable(start_); const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<TableC>(end); auto o = ::flatbuffers::Offset<TableC>(end);
return o; return o;
} }
}; };
inline flatbuffers::Offset<TableC> CreateTableC( inline ::flatbuffers::Offset<TableC> CreateTableC(
flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::FlatBufferBuilder &_fbb,
double a = 0.0, double a = 0.0,
flatbuffers::Offset<flatbuffers::String> b = 0) { ::flatbuffers::Offset<::flatbuffers::String> b = 0) {
TableCBuilder builder_(_fbb); TableCBuilder builder_(_fbb);
builder_.add_a(a); builder_.add_a(a);
builder_.add_b(b); builder_.add_b(b);
return builder_.Finish(); return builder_.Finish();
} }
inline flatbuffers::Offset<TableC> CreateTableCDirect( inline ::flatbuffers::Offset<TableC> CreateTableCDirect(
flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::FlatBufferBuilder &_fbb,
double a = 0.0, double a = 0.0,
const char *b = nullptr) { const char *b = nullptr) {
auto b__ = b ? _fbb.CreateString(b) : 0; auto b__ = b ? _fbb.CreateString(b) : 0;
@@ -339,7 +339,7 @@ inline flatbuffers::Offset<TableC> CreateTableCDirect(
b__); b__);
} }
struct Root FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { struct Root FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef RootBuilder Builder; typedef RootBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_B = 6, VT_B = 6,
@@ -382,11 +382,11 @@ struct Root FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
const Evolution::V2::Struct *ff() const { const Evolution::V2::Struct *ff() const {
return GetStruct<const Evolution::V2::Struct *>(VT_FF); return GetStruct<const Evolution::V2::Struct *>(VT_FF);
} }
const flatbuffers::Vector<int32_t> *g() const { const ::flatbuffers::Vector<int32_t> *g() const {
return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_G); return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_G);
} }
const flatbuffers::Vector<flatbuffers::Offset<Evolution::V2::TableB>> *h() const { const ::flatbuffers::Vector<::flatbuffers::Offset<Evolution::V2::TableB>> *h() const {
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<Evolution::V2::TableB>> *>(VT_H); return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<Evolution::V2::TableB>> *>(VT_H);
} }
uint32_t i() const { uint32_t i() const {
return GetField<uint32_t>(VT_I, 1234); return GetField<uint32_t>(VT_I, 1234);
@@ -397,7 +397,7 @@ struct Root FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
uint8_t l() const { uint8_t l() const {
return GetField<uint8_t>(VT_L, 56); return GetField<uint8_t>(VT_L, 56);
} }
bool Verify(flatbuffers::Verifier &verifier) const { bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) && return VerifyTableStart(verifier) &&
VerifyField<uint8_t>(verifier, VT_B, 1) && VerifyField<uint8_t>(verifier, VT_B, 1) &&
VerifyField<uint8_t>(verifier, VT_C_TYPE, 1) && VerifyField<uint8_t>(verifier, VT_C_TYPE, 1) &&
@@ -434,64 +434,64 @@ template<> inline const Evolution::V2::TableC *Root::c_as<Evolution::V2::TableC>
struct RootBuilder { struct RootBuilder {
typedef Root Table; typedef Root Table;
flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_; ::flatbuffers::uoffset_t start_;
void add_b(bool b) { void add_b(bool b) {
fbb_.AddElement<uint8_t>(Root::VT_B, static_cast<uint8_t>(b), 0); fbb_.AddElement<uint8_t>(Root::VT_B, static_cast<uint8_t>(b), 0);
} }
void add_c_type(Evolution::V2::Union c_type) { void add_c_type(Evolution::V2::Union c_type) {
fbb_.AddElement<uint8_t>(Root::VT_C_TYPE, static_cast<uint8_t>(c_type), 0); fbb_.AddElement<uint8_t>(Root::VT_C_TYPE, static_cast<uint8_t>(c_type), 0);
} }
void add_c(flatbuffers::Offset<void> c) { void add_c(::flatbuffers::Offset<void> c) {
fbb_.AddOffset(Root::VT_C, c); fbb_.AddOffset(Root::VT_C, c);
} }
void add_d(Evolution::V2::Enum d) { void add_d(Evolution::V2::Enum d) {
fbb_.AddElement<int8_t>(Root::VT_D, static_cast<int8_t>(d), 0); fbb_.AddElement<int8_t>(Root::VT_D, static_cast<int8_t>(d), 0);
} }
void add_e(flatbuffers::Offset<Evolution::V2::TableA> e) { void add_e(::flatbuffers::Offset<Evolution::V2::TableA> e) {
fbb_.AddOffset(Root::VT_E, e); fbb_.AddOffset(Root::VT_E, e);
} }
void add_ff(const Evolution::V2::Struct *ff) { void add_ff(const Evolution::V2::Struct *ff) {
fbb_.AddStruct(Root::VT_FF, ff); fbb_.AddStruct(Root::VT_FF, ff);
} }
void add_g(flatbuffers::Offset<flatbuffers::Vector<int32_t>> g) { void add_g(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> g) {
fbb_.AddOffset(Root::VT_G, g); fbb_.AddOffset(Root::VT_G, g);
} }
void add_h(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Evolution::V2::TableB>>> h) { void add_h(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<Evolution::V2::TableB>>> h) {
fbb_.AddOffset(Root::VT_H, h); fbb_.AddOffset(Root::VT_H, h);
} }
void add_i(uint32_t i) { void add_i(uint32_t i) {
fbb_.AddElement<uint32_t>(Root::VT_I, i, 1234); fbb_.AddElement<uint32_t>(Root::VT_I, i, 1234);
} }
void add_k(flatbuffers::Offset<Evolution::V2::TableC> k) { void add_k(::flatbuffers::Offset<Evolution::V2::TableC> k) {
fbb_.AddOffset(Root::VT_K, k); fbb_.AddOffset(Root::VT_K, k);
} }
void add_l(uint8_t l) { void add_l(uint8_t l) {
fbb_.AddElement<uint8_t>(Root::VT_L, l, 56); fbb_.AddElement<uint8_t>(Root::VT_L, l, 56);
} }
explicit RootBuilder(flatbuffers::FlatBufferBuilder &_fbb) explicit RootBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) { : fbb_(_fbb) {
start_ = fbb_.StartTable(); start_ = fbb_.StartTable();
} }
flatbuffers::Offset<Root> Finish() { ::flatbuffers::Offset<Root> Finish() {
const auto end = fbb_.EndTable(start_); const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<Root>(end); auto o = ::flatbuffers::Offset<Root>(end);
return o; return o;
} }
}; };
inline flatbuffers::Offset<Root> CreateRoot( inline ::flatbuffers::Offset<Root> CreateRoot(
flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::FlatBufferBuilder &_fbb,
bool b = false, bool b = false,
Evolution::V2::Union c_type = Evolution::V2::Union::NONE, Evolution::V2::Union c_type = Evolution::V2::Union::NONE,
flatbuffers::Offset<void> c = 0, ::flatbuffers::Offset<void> c = 0,
Evolution::V2::Enum d = Evolution::V2::Enum::King, Evolution::V2::Enum d = Evolution::V2::Enum::King,
flatbuffers::Offset<Evolution::V2::TableA> e = 0, ::flatbuffers::Offset<Evolution::V2::TableA> e = 0,
const Evolution::V2::Struct *ff = nullptr, const Evolution::V2::Struct *ff = nullptr,
flatbuffers::Offset<flatbuffers::Vector<int32_t>> g = 0, ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> g = 0,
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Evolution::V2::TableB>>> h = 0, ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<Evolution::V2::TableB>>> h = 0,
uint32_t i = 1234, uint32_t i = 1234,
flatbuffers::Offset<Evolution::V2::TableC> k = 0, ::flatbuffers::Offset<Evolution::V2::TableC> k = 0,
uint8_t l = 56) { uint8_t l = 56) {
RootBuilder builder_(_fbb); RootBuilder builder_(_fbb);
builder_.add_k(k); builder_.add_k(k);
@@ -508,21 +508,21 @@ inline flatbuffers::Offset<Root> CreateRoot(
return builder_.Finish(); return builder_.Finish();
} }
inline flatbuffers::Offset<Root> CreateRootDirect( inline ::flatbuffers::Offset<Root> CreateRootDirect(
flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::FlatBufferBuilder &_fbb,
bool b = false, bool b = false,
Evolution::V2::Union c_type = Evolution::V2::Union::NONE, Evolution::V2::Union c_type = Evolution::V2::Union::NONE,
flatbuffers::Offset<void> c = 0, ::flatbuffers::Offset<void> c = 0,
Evolution::V2::Enum d = Evolution::V2::Enum::King, Evolution::V2::Enum d = Evolution::V2::Enum::King,
flatbuffers::Offset<Evolution::V2::TableA> e = 0, ::flatbuffers::Offset<Evolution::V2::TableA> e = 0,
const Evolution::V2::Struct *ff = nullptr, const Evolution::V2::Struct *ff = nullptr,
const std::vector<int32_t> *g = nullptr, const std::vector<int32_t> *g = nullptr,
const std::vector<flatbuffers::Offset<Evolution::V2::TableB>> *h = nullptr, const std::vector<::flatbuffers::Offset<Evolution::V2::TableB>> *h = nullptr,
uint32_t i = 1234, uint32_t i = 1234,
flatbuffers::Offset<Evolution::V2::TableC> k = 0, ::flatbuffers::Offset<Evolution::V2::TableC> k = 0,
uint8_t l = 56) { uint8_t l = 56) {
auto g__ = g ? _fbb.CreateVector<int32_t>(*g) : 0; auto g__ = g ? _fbb.CreateVector<int32_t>(*g) : 0;
auto h__ = h ? _fbb.CreateVector<flatbuffers::Offset<Evolution::V2::TableB>>(*h) : 0; auto h__ = h ? _fbb.CreateVector<::flatbuffers::Offset<Evolution::V2::TableB>>(*h) : 0;
return Evolution::V2::CreateRoot( return Evolution::V2::CreateRoot(
_fbb, _fbb,
b, b,
@@ -538,7 +538,7 @@ inline flatbuffers::Offset<Root> CreateRootDirect(
l); l);
} }
inline bool VerifyUnion(flatbuffers::Verifier &verifier, const void *obj, Union type) { inline bool VerifyUnion(::flatbuffers::Verifier &verifier, const void *obj, Union type) {
switch (type) { switch (type) {
case Union::NONE: { case Union::NONE: {
return true; return true;
@@ -559,10 +559,10 @@ inline bool VerifyUnion(flatbuffers::Verifier &verifier, const void *obj, Union
} }
} }
inline bool VerifyUnionVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<Union> *types) { inline bool VerifyUnionVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Union> *types) {
if (!values || !types) return !values && !types; if (!values || !types) return !values && !types;
if (values->size() != types->size()) return false; 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 (!VerifyUnion( if (!VerifyUnion(
verifier, values->Get(i), types->GetEnum<Union>(i))) { verifier, values->Get(i), types->GetEnum<Union>(i))) {
return false; return false;
@@ -572,32 +572,32 @@ inline bool VerifyUnionVector(flatbuffers::Verifier &verifier, const flatbuffers
} }
inline const Evolution::V2::Root *GetRoot(const void *buf) { inline const Evolution::V2::Root *GetRoot(const void *buf) {
return flatbuffers::GetRoot<Evolution::V2::Root>(buf); return ::flatbuffers::GetRoot<Evolution::V2::Root>(buf);
} }
inline const Evolution::V2::Root *GetSizePrefixedRoot(const void *buf) { inline const Evolution::V2::Root *GetSizePrefixedRoot(const void *buf) {
return flatbuffers::GetSizePrefixedRoot<Evolution::V2::Root>(buf); return ::flatbuffers::GetSizePrefixedRoot<Evolution::V2::Root>(buf);
} }
inline bool VerifyRootBuffer( inline bool VerifyRootBuffer(
flatbuffers::Verifier &verifier) { ::flatbuffers::Verifier &verifier) {
return verifier.VerifyBuffer<Evolution::V2::Root>(nullptr); return verifier.VerifyBuffer<Evolution::V2::Root>(nullptr);
} }
inline bool VerifySizePrefixedRootBuffer( inline bool VerifySizePrefixedRootBuffer(
flatbuffers::Verifier &verifier) { ::flatbuffers::Verifier &verifier) {
return verifier.VerifySizePrefixedBuffer<Evolution::V2::Root>(nullptr); return verifier.VerifySizePrefixedBuffer<Evolution::V2::Root>(nullptr);
} }
inline void FinishRootBuffer( inline void FinishRootBuffer(
flatbuffers::FlatBufferBuilder &fbb, ::flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<Evolution::V2::Root> root) { ::flatbuffers::Offset<Evolution::V2::Root> root) {
fbb.Finish(root); fbb.Finish(root);
} }
inline void FinishSizePrefixedRootBuffer( inline void FinishSizePrefixedRootBuffer(
flatbuffers::FlatBufferBuilder &fbb, ::flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<Evolution::V2::Root> root) { ::flatbuffers::Offset<Evolution::V2::Root> root) {
fbb.FinishSizePrefixed(root); fbb.FinishSizePrefixed(root);
} }

214
tests/key_field/key_field_sample_generated.h
View File

@@ -31,11 +31,11 @@ bool operator!=(const Bar &lhs, const Bar &rhs);
bool operator==(const FooTableT &lhs, const FooTableT &rhs); bool operator==(const FooTableT &lhs, const FooTableT &rhs);
bool operator!=(const FooTableT &lhs, const FooTableT &rhs); bool operator!=(const FooTableT &lhs, const FooTableT &rhs);
inline const flatbuffers::TypeTable *BazTypeTable(); inline const ::flatbuffers::TypeTable *BazTypeTable();
inline const flatbuffers::TypeTable *BarTypeTable(); inline const ::flatbuffers::TypeTable *BarTypeTable();
inline const flatbuffers::TypeTable *FooTableTypeTable(); inline const ::flatbuffers::TypeTable *FooTableTypeTable();
FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(1) Baz FLATBUFFERS_FINAL_CLASS { FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(1) Baz FLATBUFFERS_FINAL_CLASS {
private: private:
@@ -43,7 +43,7 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(1) Baz FLATBUFFERS_FINAL_CLASS {
uint8_t b_; uint8_t b_;
public: public:
static const flatbuffers::TypeTable *MiniReflectTypeTable() { static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return BazTypeTable(); return BazTypeTable();
} }
Baz() Baz()
@@ -52,24 +52,24 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(1) Baz FLATBUFFERS_FINAL_CLASS {
} }
Baz(uint8_t _b) Baz(uint8_t _b)
: a_(), : a_(),
b_(flatbuffers::EndianScalar(_b)) { b_(::flatbuffers::EndianScalar(_b)) {
} }
Baz(flatbuffers::span<const uint8_t, 4> _a, uint8_t _b) Baz(::flatbuffers::span<const uint8_t, 4> _a, uint8_t _b)
: b_(flatbuffers::EndianScalar(_b)) { : b_(::flatbuffers::EndianScalar(_b)) {
flatbuffers::CastToArray(a_).CopyFromSpan(_a); ::flatbuffers::CastToArray(a_).CopyFromSpan(_a);
} }
const flatbuffers::Array<uint8_t, 4> *a() const { const ::flatbuffers::Array<uint8_t, 4> *a() const {
return &flatbuffers::CastToArray(a_); return &::flatbuffers::CastToArray(a_);
} }
flatbuffers::Array<uint8_t, 4> *mutable_a() { ::flatbuffers::Array<uint8_t, 4> *mutable_a() {
return &flatbuffers::CastToArray(a_); return &::flatbuffers::CastToArray(a_);
} }
bool KeyCompareLessThan(const Baz * const o) const { bool KeyCompareLessThan(const Baz * const o) const {
return KeyCompareWithValue(o->a()) < 0; return KeyCompareWithValue(o->a()) < 0;
} }
int KeyCompareWithValue(const flatbuffers::Array<uint8_t, 4> *_a) const { int KeyCompareWithValue(const ::flatbuffers::Array<uint8_t, 4> *_a) const {
const flatbuffers::Array<uint8_t, 4> *curr_a = a(); const ::flatbuffers::Array<uint8_t, 4> *curr_a = a();
for (flatbuffers::uoffset_t i = 0; i < curr_a->size(); i++) { for (::flatbuffers::uoffset_t i = 0; i < curr_a->size(); i++) {
const auto lhs = curr_a->Get(i); const auto lhs = curr_a->Get(i);
const auto rhs = _a->Get(i); const auto rhs = _a->Get(i);
if(lhs != rhs) if(lhs != rhs)
@@ -78,10 +78,10 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(1) Baz FLATBUFFERS_FINAL_CLASS {
return 0; return 0;
} }
uint8_t b() const { uint8_t b() const {
return flatbuffers::EndianScalar(b_); return ::flatbuffers::EndianScalar(b_);
} }
void mutate_b(uint8_t _b) { void mutate_b(uint8_t _b) {
flatbuffers::WriteScalar(&b_, _b); ::flatbuffers::WriteScalar(&b_, _b);
} }
}; };
FLATBUFFERS_STRUCT_END(Baz, 5); FLATBUFFERS_STRUCT_END(Baz, 5);
@@ -104,7 +104,7 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Bar FLATBUFFERS_FINAL_CLASS {
int8_t padding0__; int16_t padding1__; int8_t padding0__; int16_t padding1__;
public: public:
static const flatbuffers::TypeTable *MiniReflectTypeTable() { static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return BarTypeTable(); return BarTypeTable();
} }
Bar() Bar()
@@ -117,32 +117,32 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Bar FLATBUFFERS_FINAL_CLASS {
} }
Bar(uint8_t _b) Bar(uint8_t _b)
: a_(), : a_(),
b_(flatbuffers::EndianScalar(_b)), b_(::flatbuffers::EndianScalar(_b)),
padding0__(0), padding0__(0),
padding1__(0) { padding1__(0) {
(void)padding0__; (void)padding0__;
(void)padding1__; (void)padding1__;
} }
Bar(flatbuffers::span<const float, 3> _a, uint8_t _b) Bar(::flatbuffers::span<const float, 3> _a, uint8_t _b)
: b_(flatbuffers::EndianScalar(_b)), : b_(::flatbuffers::EndianScalar(_b)),
padding0__(0), padding0__(0),
padding1__(0) { padding1__(0) {
flatbuffers::CastToArray(a_).CopyFromSpan(_a); ::flatbuffers::CastToArray(a_).CopyFromSpan(_a);
(void)padding0__; (void)padding0__;
(void)padding1__; (void)padding1__;
} }
const flatbuffers::Array<float, 3> *a() const { const ::flatbuffers::Array<float, 3> *a() const {
return &flatbuffers::CastToArray(a_); return &::flatbuffers::CastToArray(a_);
} }
flatbuffers::Array<float, 3> *mutable_a() { ::flatbuffers::Array<float, 3> *mutable_a() {
return &flatbuffers::CastToArray(a_); return &::flatbuffers::CastToArray(a_);
} }
bool KeyCompareLessThan(const Bar * const o) const { bool KeyCompareLessThan(const Bar * const o) const {
return KeyCompareWithValue(o->a()) < 0; return KeyCompareWithValue(o->a()) < 0;
} }
int KeyCompareWithValue(const flatbuffers::Array<float, 3> *_a) const { int KeyCompareWithValue(const ::flatbuffers::Array<float, 3> *_a) const {
const flatbuffers::Array<float, 3> *curr_a = a(); const ::flatbuffers::Array<float, 3> *curr_a = a();
for (flatbuffers::uoffset_t i = 0; i < curr_a->size(); i++) { for (::flatbuffers::uoffset_t i = 0; i < curr_a->size(); i++) {
const auto lhs = curr_a->Get(i); const auto lhs = curr_a->Get(i);
const auto rhs = _a->Get(i); const auto rhs = _a->Get(i);
if(lhs != rhs) if(lhs != rhs)
@@ -151,10 +151,10 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Bar FLATBUFFERS_FINAL_CLASS {
return 0; return 0;
} }
uint8_t b() const { uint8_t b() const {
return flatbuffers::EndianScalar(b_); return ::flatbuffers::EndianScalar(b_);
} }
void mutate_b(uint8_t _b) { void mutate_b(uint8_t _b) {
flatbuffers::WriteScalar(&b_, _b); ::flatbuffers::WriteScalar(&b_, _b);
} }
}; };
FLATBUFFERS_STRUCT_END(Bar, 16); FLATBUFFERS_STRUCT_END(Bar, 16);
@@ -170,7 +170,7 @@ inline bool operator!=(const Bar &lhs, const Bar &rhs) {
} }
struct FooTableT : public flatbuffers::NativeTable { struct FooTableT : public ::flatbuffers::NativeTable {
typedef FooTable TableType; typedef FooTable TableType;
int32_t a = 0; int32_t a = 0;
int32_t b = 0; int32_t b = 0;
@@ -179,10 +179,10 @@ struct FooTableT : public flatbuffers::NativeTable {
std::vector<keyfield::sample::Bar> e{}; std::vector<keyfield::sample::Bar> e{};
}; };
struct FooTable FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { struct FooTable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef FooTableT NativeTableType; typedef FooTableT NativeTableType;
typedef FooTableBuilder Builder; typedef FooTableBuilder Builder;
static const flatbuffers::TypeTable *MiniReflectTypeTable() { static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return FooTableTypeTable(); return FooTableTypeTable();
} }
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
@@ -204,11 +204,11 @@ struct FooTable FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool mutate_b(int32_t _b = 0) { bool mutate_b(int32_t _b = 0) {
return SetField<int32_t>(VT_B, _b, 0); return SetField<int32_t>(VT_B, _b, 0);
} }
const flatbuffers::String *c() const { const ::flatbuffers::String *c() const {
return GetPointer<const flatbuffers::String *>(VT_C); return GetPointer<const ::flatbuffers::String *>(VT_C);
} }
flatbuffers::String *mutable_c() { ::flatbuffers::String *mutable_c() {
return GetPointer<flatbuffers::String *>(VT_C); return GetPointer<::flatbuffers::String *>(VT_C);
} }
bool KeyCompareLessThan(const FooTable * const o) const { bool KeyCompareLessThan(const FooTable * const o) const {
return *c() < *o->c(); return *c() < *o->c();
@@ -216,19 +216,19 @@ struct FooTable FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
int KeyCompareWithValue(const char *_c) const { int KeyCompareWithValue(const char *_c) const {
return strcmp(c()->c_str(), _c); return strcmp(c()->c_str(), _c);
} }
const flatbuffers::Vector<const keyfield::sample::Baz *> *d() const { const ::flatbuffers::Vector<const keyfield::sample::Baz *> *d() const {
return GetPointer<const flatbuffers::Vector<const keyfield::sample::Baz *> *>(VT_D); return GetPointer<const ::flatbuffers::Vector<const keyfield::sample::Baz *> *>(VT_D);
} }
flatbuffers::Vector<const keyfield::sample::Baz *> *mutable_d() { ::flatbuffers::Vector<const keyfield::sample::Baz *> *mutable_d() {
return GetPointer<flatbuffers::Vector<const keyfield::sample::Baz *> *>(VT_D); return GetPointer<::flatbuffers::Vector<const keyfield::sample::Baz *> *>(VT_D);
} }
const flatbuffers::Vector<const keyfield::sample::Bar *> *e() const { const ::flatbuffers::Vector<const keyfield::sample::Bar *> *e() const {
return GetPointer<const flatbuffers::Vector<const keyfield::sample::Bar *> *>(VT_E); return GetPointer<const ::flatbuffers::Vector<const keyfield::sample::Bar *> *>(VT_E);
} }
flatbuffers::Vector<const keyfield::sample::Bar *> *mutable_e() { ::flatbuffers::Vector<const keyfield::sample::Bar *> *mutable_e() {
return GetPointer<flatbuffers::Vector<const keyfield::sample::Bar *> *>(VT_E); return GetPointer<::flatbuffers::Vector<const keyfield::sample::Bar *> *>(VT_E);
} }
bool Verify(flatbuffers::Verifier &verifier) const { bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) && return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_A, 4) && VerifyField<int32_t>(verifier, VT_A, 4) &&
VerifyField<int32_t>(verifier, VT_B, 4) && VerifyField<int32_t>(verifier, VT_B, 4) &&
@@ -240,49 +240,49 @@ struct FooTable FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
verifier.VerifyVector(e()) && verifier.VerifyVector(e()) &&
verifier.EndTable(); verifier.EndTable();
} }
FooTableT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; FooTableT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(FooTableT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; void UnPackTo(FooTableT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<FooTable> Pack(flatbuffers::FlatBufferBuilder &_fbb, const FooTableT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); static ::flatbuffers::Offset<FooTable> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const FooTableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
}; };
struct FooTableBuilder { struct FooTableBuilder {
typedef FooTable Table; typedef FooTable Table;
flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_; ::flatbuffers::uoffset_t start_;
void add_a(int32_t a) { void add_a(int32_t a) {
fbb_.AddElement<int32_t>(FooTable::VT_A, a, 0); fbb_.AddElement<int32_t>(FooTable::VT_A, a, 0);
} }
void add_b(int32_t b) { void add_b(int32_t b) {
fbb_.AddElement<int32_t>(FooTable::VT_B, b, 0); fbb_.AddElement<int32_t>(FooTable::VT_B, b, 0);
} }
void add_c(flatbuffers::Offset<flatbuffers::String> c) { void add_c(::flatbuffers::Offset<::flatbuffers::String> c) {
fbb_.AddOffset(FooTable::VT_C, c); fbb_.AddOffset(FooTable::VT_C, c);
} }
void add_d(flatbuffers::Offset<flatbuffers::Vector<const keyfield::sample::Baz *>> d) { void add_d(::flatbuffers::Offset<::flatbuffers::Vector<const keyfield::sample::Baz *>> d) {
fbb_.AddOffset(FooTable::VT_D, d); fbb_.AddOffset(FooTable::VT_D, d);
} }
void add_e(flatbuffers::Offset<flatbuffers::Vector<const keyfield::sample::Bar *>> e) { void add_e(::flatbuffers::Offset<::flatbuffers::Vector<const keyfield::sample::Bar *>> e) {
fbb_.AddOffset(FooTable::VT_E, e); fbb_.AddOffset(FooTable::VT_E, e);
} }
explicit FooTableBuilder(flatbuffers::FlatBufferBuilder &_fbb) explicit FooTableBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) { : fbb_(_fbb) {
start_ = fbb_.StartTable(); start_ = fbb_.StartTable();
} }
flatbuffers::Offset<FooTable> Finish() { ::flatbuffers::Offset<FooTable> Finish() {
const auto end = fbb_.EndTable(start_); const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<FooTable>(end); auto o = ::flatbuffers::Offset<FooTable>(end);
fbb_.Required(o, FooTable::VT_C); fbb_.Required(o, FooTable::VT_C);
return o; return o;
} }
}; };
inline flatbuffers::Offset<FooTable> CreateFooTable( inline ::flatbuffers::Offset<FooTable> CreateFooTable(
flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::FlatBufferBuilder &_fbb,
int32_t a = 0, int32_t a = 0,
int32_t b = 0, int32_t b = 0,
flatbuffers::Offset<flatbuffers::String> c = 0, ::flatbuffers::Offset<::flatbuffers::String> c = 0,
flatbuffers::Offset<flatbuffers::Vector<const keyfield::sample::Baz *>> d = 0, ::flatbuffers::Offset<::flatbuffers::Vector<const keyfield::sample::Baz *>> d = 0,
flatbuffers::Offset<flatbuffers::Vector<const keyfield::sample::Bar *>> e = 0) { ::flatbuffers::Offset<::flatbuffers::Vector<const keyfield::sample::Bar *>> e = 0) {
FooTableBuilder builder_(_fbb); FooTableBuilder builder_(_fbb);
builder_.add_e(e); builder_.add_e(e);
builder_.add_d(d); builder_.add_d(d);
@@ -292,8 +292,8 @@ inline flatbuffers::Offset<FooTable> CreateFooTable(
return builder_.Finish(); return builder_.Finish();
} }
inline flatbuffers::Offset<FooTable> CreateFooTableDirect( inline ::flatbuffers::Offset<FooTable> CreateFooTableDirect(
flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::FlatBufferBuilder &_fbb,
int32_t a = 0, int32_t a = 0,
int32_t b = 0, int32_t b = 0,
const char *c = nullptr, const char *c = nullptr,
@@ -311,7 +311,7 @@ inline flatbuffers::Offset<FooTable> CreateFooTableDirect(
e__); e__);
} }
flatbuffers::Offset<FooTable> CreateFooTable(flatbuffers::FlatBufferBuilder &_fbb, const FooTableT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); ::flatbuffers::Offset<FooTable> CreateFooTable(::flatbuffers::FlatBufferBuilder &_fbb, const FooTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
inline bool operator==(const FooTableT &lhs, const FooTableT &rhs) { inline bool operator==(const FooTableT &lhs, const FooTableT &rhs) {
@@ -328,30 +328,30 @@ inline bool operator!=(const FooTableT &lhs, const FooTableT &rhs) {
} }
inline FooTableT *FooTable::UnPack(const flatbuffers::resolver_function_t *_resolver) const { inline FooTableT *FooTable::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
auto _o = std::unique_ptr<FooTableT>(new FooTableT()); auto _o = std::unique_ptr<FooTableT>(new FooTableT());
UnPackTo(_o.get(), _resolver); UnPackTo(_o.get(), _resolver);
return _o.release(); return _o.release();
} }
inline void FooTable::UnPackTo(FooTableT *_o, const flatbuffers::resolver_function_t *_resolver) const { inline void FooTable::UnPackTo(FooTableT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
(void)_o; (void)_o;
(void)_resolver; (void)_resolver;
{ auto _e = a(); _o->a = _e; } { auto _e = a(); _o->a = _e; }
{ auto _e = b(); _o->b = _e; } { auto _e = b(); _o->b = _e; }
{ auto _e = c(); if (_e) _o->c = _e->str(); } { auto _e = c(); if (_e) _o->c = _e->str(); }
{ auto _e = d(); if (_e) { _o->d.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->d[_i] = *_e->Get(_i); } } else { _o->d.resize(0); } } { auto _e = d(); if (_e) { _o->d.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->d[_i] = *_e->Get(_i); } } else { _o->d.resize(0); } }
{ auto _e = e(); if (_e) { _o->e.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->e[_i] = *_e->Get(_i); } } else { _o->e.resize(0); } } { auto _e = e(); if (_e) { _o->e.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->e[_i] = *_e->Get(_i); } } else { _o->e.resize(0); } }
} }
inline flatbuffers::Offset<FooTable> FooTable::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FooTableT* _o, const flatbuffers::rehasher_function_t *_rehasher) { inline ::flatbuffers::Offset<FooTable> FooTable::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const FooTableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateFooTable(_fbb, _o, _rehasher); return CreateFooTable(_fbb, _o, _rehasher);
} }
inline flatbuffers::Offset<FooTable> CreateFooTable(flatbuffers::FlatBufferBuilder &_fbb, const FooTableT *_o, const flatbuffers::rehasher_function_t *_rehasher) { inline ::flatbuffers::Offset<FooTable> CreateFooTable(::flatbuffers::FlatBufferBuilder &_fbb, const FooTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher; (void)_rehasher;
(void)_o; (void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const FooTableT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const FooTableT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _a = _o->a; auto _a = _o->a;
auto _b = _o->b; auto _b = _o->b;
auto _c = _fbb.CreateString(_o->c); auto _c = _fbb.CreateString(_o->c);
@@ -366,10 +366,10 @@ inline flatbuffers::Offset<FooTable> CreateFooTable(flatbuffers::FlatBufferBuild
_e); _e);
} }
inline const flatbuffers::TypeTable *BazTypeTable() { inline const ::flatbuffers::TypeTable *BazTypeTable() {
static const flatbuffers::TypeCode type_codes[] = { static const ::flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_UCHAR, 1, -1 }, { ::flatbuffers::ET_UCHAR, 1, -1 },
{ flatbuffers::ET_UCHAR, 0, -1 } { ::flatbuffers::ET_UCHAR, 0, -1 }
}; };
static const int16_t array_sizes[] = { 4, }; static const int16_t array_sizes[] = { 4, };
static const int64_t values[] = { 0, 4, 5 }; static const int64_t values[] = { 0, 4, 5 };
@@ -377,16 +377,16 @@ inline const flatbuffers::TypeTable *BazTypeTable() {
"a", "a",
"b" "b"
}; };
static const flatbuffers::TypeTable tt = { static const ::flatbuffers::TypeTable tt = {
flatbuffers::ST_STRUCT, 2, type_codes, nullptr, array_sizes, values, names ::flatbuffers::ST_STRUCT, 2, type_codes, nullptr, array_sizes, values, names
}; };
return &tt; return &tt;
} }
inline const flatbuffers::TypeTable *BarTypeTable() { inline const ::flatbuffers::TypeTable *BarTypeTable() {
static const flatbuffers::TypeCode type_codes[] = { static const ::flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_FLOAT, 1, -1 }, { ::flatbuffers::ET_FLOAT, 1, -1 },
{ flatbuffers::ET_UCHAR, 0, -1 } { ::flatbuffers::ET_UCHAR, 0, -1 }
}; };
static const int16_t array_sizes[] = { 3, }; static const int16_t array_sizes[] = { 3, };
static const int64_t values[] = { 0, 12, 16 }; static const int64_t values[] = { 0, 12, 16 };
@@ -394,21 +394,21 @@ inline const flatbuffers::TypeTable *BarTypeTable() {
"a", "a",
"b" "b"
}; };
static const flatbuffers::TypeTable tt = { static const ::flatbuffers::TypeTable tt = {
flatbuffers::ST_STRUCT, 2, type_codes, nullptr, array_sizes, values, names ::flatbuffers::ST_STRUCT, 2, type_codes, nullptr, array_sizes, values, names
}; };
return &tt; return &tt;
} }
inline const flatbuffers::TypeTable *FooTableTypeTable() { inline const ::flatbuffers::TypeTable *FooTableTypeTable() {
static const flatbuffers::TypeCode type_codes[] = { static const ::flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_INT, 0, -1 }, { ::flatbuffers::ET_INT, 0, -1 },
{ flatbuffers::ET_INT, 0, -1 }, { ::flatbuffers::ET_INT, 0, -1 },
{ flatbuffers::ET_STRING, 0, -1 }, { ::flatbuffers::ET_STRING, 0, -1 },
{ flatbuffers::ET_SEQUENCE, 1, 0 }, { ::flatbuffers::ET_SEQUENCE, 1, 0 },
{ flatbuffers::ET_SEQUENCE, 1, 1 } { ::flatbuffers::ET_SEQUENCE, 1, 1 }
}; };
static const flatbuffers::TypeFunction type_refs[] = { static const ::flatbuffers::TypeFunction type_refs[] = {
keyfield::sample::BazTypeTable, keyfield::sample::BazTypeTable,
keyfield::sample::BarTypeTable keyfield::sample::BarTypeTable
}; };
@@ -419,59 +419,59 @@ inline const flatbuffers::TypeTable *FooTableTypeTable() {
"d", "d",
"e" "e"
}; };
static const flatbuffers::TypeTable tt = { static const ::flatbuffers::TypeTable tt = {
flatbuffers::ST_TABLE, 5, type_codes, type_refs, nullptr, nullptr, names ::flatbuffers::ST_TABLE, 5, type_codes, type_refs, nullptr, nullptr, names
}; };
return &tt; return &tt;
} }
inline const keyfield::sample::FooTable *GetFooTable(const void *buf) { inline const keyfield::sample::FooTable *GetFooTable(const void *buf) {
return flatbuffers::GetRoot<keyfield::sample::FooTable>(buf); return ::flatbuffers::GetRoot<keyfield::sample::FooTable>(buf);
} }
inline const keyfield::sample::FooTable *GetSizePrefixedFooTable(const void *buf) { inline const keyfield::sample::FooTable *GetSizePrefixedFooTable(const void *buf) {
return flatbuffers::GetSizePrefixedRoot<keyfield::sample::FooTable>(buf); return ::flatbuffers::GetSizePrefixedRoot<keyfield::sample::FooTable>(buf);
} }
inline FooTable *GetMutableFooTable(void *buf) { inline FooTable *GetMutableFooTable(void *buf) {
return flatbuffers::GetMutableRoot<FooTable>(buf); return ::flatbuffers::GetMutableRoot<FooTable>(buf);
} }
inline keyfield::sample::FooTable *GetMutableSizePrefixedFooTable(void *buf) { inline keyfield::sample::FooTable *GetMutableSizePrefixedFooTable(void *buf) {
return flatbuffers::GetMutableSizePrefixedRoot<keyfield::sample::FooTable>(buf); return ::flatbuffers::GetMutableSizePrefixedRoot<keyfield::sample::FooTable>(buf);
} }
inline bool VerifyFooTableBuffer( inline bool VerifyFooTableBuffer(
flatbuffers::Verifier &verifier) { ::flatbuffers::Verifier &verifier) {
return verifier.VerifyBuffer<keyfield::sample::FooTable>(nullptr); return verifier.VerifyBuffer<keyfield::sample::FooTable>(nullptr);
} }
inline bool VerifySizePrefixedFooTableBuffer( inline bool VerifySizePrefixedFooTableBuffer(
flatbuffers::Verifier &verifier) { ::flatbuffers::Verifier &verifier) {
return verifier.VerifySizePrefixedBuffer<keyfield::sample::FooTable>(nullptr); return verifier.VerifySizePrefixedBuffer<keyfield::sample::FooTable>(nullptr);
} }
inline void FinishFooTableBuffer( inline void FinishFooTableBuffer(
flatbuffers::FlatBufferBuilder &fbb, ::flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<keyfield::sample::FooTable> root) { ::flatbuffers::Offset<keyfield::sample::FooTable> root) {
fbb.Finish(root); fbb.Finish(root);
} }
inline void FinishSizePrefixedFooTableBuffer( inline void FinishSizePrefixedFooTableBuffer(
flatbuffers::FlatBufferBuilder &fbb, ::flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<keyfield::sample::FooTable> root) { ::flatbuffers::Offset<keyfield::sample::FooTable> root) {
fbb.FinishSizePrefixed(root); fbb.FinishSizePrefixed(root);
} }
inline flatbuffers::unique_ptr<keyfield::sample::FooTableT> UnPackFooTable( inline flatbuffers::unique_ptr<keyfield::sample::FooTableT> UnPackFooTable(
const void *buf, const void *buf,
const flatbuffers::resolver_function_t *res = nullptr) { const ::flatbuffers::resolver_function_t *res = nullptr) {
return flatbuffers::unique_ptr<keyfield::sample::FooTableT>(GetFooTable(buf)->UnPack(res)); return flatbuffers::unique_ptr<keyfield::sample::FooTableT>(GetFooTable(buf)->UnPack(res));
} }
inline flatbuffers::unique_ptr<keyfield::sample::FooTableT> UnPackSizePrefixedFooTable( inline flatbuffers::unique_ptr<keyfield::sample::FooTableT> UnPackSizePrefixedFooTable(
const void *buf, const void *buf,
const flatbuffers::resolver_function_t *res = nullptr) { const ::flatbuffers::resolver_function_t *res = nullptr) {
return flatbuffers::unique_ptr<keyfield::sample::FooTableT>(GetSizePrefixedFooTable(buf)->UnPack(res)); return flatbuffers::unique_ptr<keyfield::sample::FooTableT>(GetSizePrefixedFooTable(buf)->UnPack(res));
} }

132
tests/monster_extra_generated.h
View File

@@ -22,9 +22,9 @@ struct MonsterExtraT;
bool operator==(const MonsterExtraT &lhs, const MonsterExtraT &rhs); bool operator==(const MonsterExtraT &lhs, const MonsterExtraT &rhs);
bool operator!=(const MonsterExtraT &lhs, const MonsterExtraT &rhs); bool operator!=(const MonsterExtraT &lhs, const MonsterExtraT &rhs);
inline const flatbuffers::TypeTable *MonsterExtraTypeTable(); inline const ::flatbuffers::TypeTable *MonsterExtraTypeTable();
struct MonsterExtraT : public flatbuffers::NativeTable { struct MonsterExtraT : public ::flatbuffers::NativeTable {
typedef MonsterExtra TableType; typedef MonsterExtra TableType;
double d0 = std::numeric_limits<double>::quiet_NaN(); double d0 = std::numeric_limits<double>::quiet_NaN();
double d1 = std::numeric_limits<double>::quiet_NaN(); double d1 = std::numeric_limits<double>::quiet_NaN();
@@ -38,10 +38,10 @@ struct MonsterExtraT : public flatbuffers::NativeTable {
std::vector<float> fvec{}; std::vector<float> fvec{};
}; };
struct MonsterExtra FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { struct MonsterExtra FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef MonsterExtraT NativeTableType; typedef MonsterExtraT NativeTableType;
typedef MonsterExtraBuilder Builder; typedef MonsterExtraBuilder Builder;
static const flatbuffers::TypeTable *MiniReflectTypeTable() { static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return MonsterExtraTypeTable(); return MonsterExtraTypeTable();
} }
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
@@ -104,19 +104,19 @@ struct MonsterExtra FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool mutate_f3(float _f3 = -std::numeric_limits<float>::infinity()) { bool mutate_f3(float _f3 = -std::numeric_limits<float>::infinity()) {
return SetField<float>(VT_F3, _f3, -std::numeric_limits<float>::infinity()); return SetField<float>(VT_F3, _f3, -std::numeric_limits<float>::infinity());
} }
const flatbuffers::Vector<double> *dvec() const { const ::flatbuffers::Vector<double> *dvec() const {
return GetPointer<const flatbuffers::Vector<double> *>(VT_DVEC); return GetPointer<const ::flatbuffers::Vector<double> *>(VT_DVEC);
} }
flatbuffers::Vector<double> *mutable_dvec() { ::flatbuffers::Vector<double> *mutable_dvec() {
return GetPointer<flatbuffers::Vector<double> *>(VT_DVEC); return GetPointer<::flatbuffers::Vector<double> *>(VT_DVEC);
} }
const flatbuffers::Vector<float> *fvec() const { const ::flatbuffers::Vector<float> *fvec() const {
return GetPointer<const flatbuffers::Vector<float> *>(VT_FVEC); return GetPointer<const ::flatbuffers::Vector<float> *>(VT_FVEC);
} }
flatbuffers::Vector<float> *mutable_fvec() { ::flatbuffers::Vector<float> *mutable_fvec() {
return GetPointer<flatbuffers::Vector<float> *>(VT_FVEC); return GetPointer<::flatbuffers::Vector<float> *>(VT_FVEC);
} }
bool Verify(flatbuffers::Verifier &verifier) const { bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) && return VerifyTableStart(verifier) &&
VerifyField<double>(verifier, VT_D0, 8) && VerifyField<double>(verifier, VT_D0, 8) &&
VerifyField<double>(verifier, VT_D1, 8) && VerifyField<double>(verifier, VT_D1, 8) &&
@@ -132,15 +132,15 @@ struct MonsterExtra FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
verifier.VerifyVector(fvec()) && verifier.VerifyVector(fvec()) &&
verifier.EndTable(); verifier.EndTable();
} }
MonsterExtraT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; MonsterExtraT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(MonsterExtraT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; void UnPackTo(MonsterExtraT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<MonsterExtra> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterExtraT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); static ::flatbuffers::Offset<MonsterExtra> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const MonsterExtraT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
}; };
struct MonsterExtraBuilder { struct MonsterExtraBuilder {
typedef MonsterExtra Table; typedef MonsterExtra Table;
flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_; ::flatbuffers::uoffset_t start_;
void add_d0(double d0) { void add_d0(double d0) {
fbb_.AddElement<double>(MonsterExtra::VT_D0, d0, std::numeric_limits<double>::quiet_NaN()); fbb_.AddElement<double>(MonsterExtra::VT_D0, d0, std::numeric_limits<double>::quiet_NaN());
} }
@@ -165,25 +165,25 @@ struct MonsterExtraBuilder {
void add_f3(float f3) { void add_f3(float f3) {
fbb_.AddElement<float>(MonsterExtra::VT_F3, f3, -std::numeric_limits<float>::infinity()); fbb_.AddElement<float>(MonsterExtra::VT_F3, f3, -std::numeric_limits<float>::infinity());
} }
void add_dvec(flatbuffers::Offset<flatbuffers::Vector<double>> dvec) { void add_dvec(::flatbuffers::Offset<::flatbuffers::Vector<double>> dvec) {
fbb_.AddOffset(MonsterExtra::VT_DVEC, dvec); fbb_.AddOffset(MonsterExtra::VT_DVEC, dvec);
} }
void add_fvec(flatbuffers::Offset<flatbuffers::Vector<float>> fvec) { void add_fvec(::flatbuffers::Offset<::flatbuffers::Vector<float>> fvec) {
fbb_.AddOffset(MonsterExtra::VT_FVEC, fvec); fbb_.AddOffset(MonsterExtra::VT_FVEC, fvec);
} }
explicit MonsterExtraBuilder(flatbuffers::FlatBufferBuilder &_fbb) explicit MonsterExtraBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) { : fbb_(_fbb) {
start_ = fbb_.StartTable(); start_ = fbb_.StartTable();
} }
flatbuffers::Offset<MonsterExtra> Finish() { ::flatbuffers::Offset<MonsterExtra> Finish() {
const auto end = fbb_.EndTable(start_); const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<MonsterExtra>(end); auto o = ::flatbuffers::Offset<MonsterExtra>(end);
return o; return o;
} }
}; };
inline flatbuffers::Offset<MonsterExtra> CreateMonsterExtra( inline ::flatbuffers::Offset<MonsterExtra> CreateMonsterExtra(
flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::FlatBufferBuilder &_fbb,
double d0 = std::numeric_limits<double>::quiet_NaN(), double d0 = std::numeric_limits<double>::quiet_NaN(),
double d1 = std::numeric_limits<double>::quiet_NaN(), double d1 = std::numeric_limits<double>::quiet_NaN(),
double d2 = std::numeric_limits<double>::infinity(), double d2 = std::numeric_limits<double>::infinity(),
@@ -192,8 +192,8 @@ inline flatbuffers::Offset<MonsterExtra> CreateMonsterExtra(
float f1 = std::numeric_limits<float>::quiet_NaN(), float f1 = std::numeric_limits<float>::quiet_NaN(),
float f2 = std::numeric_limits<float>::infinity(), float f2 = std::numeric_limits<float>::infinity(),
float f3 = -std::numeric_limits<float>::infinity(), float f3 = -std::numeric_limits<float>::infinity(),
flatbuffers::Offset<flatbuffers::Vector<double>> dvec = 0, ::flatbuffers::Offset<::flatbuffers::Vector<double>> dvec = 0,
flatbuffers::Offset<flatbuffers::Vector<float>> fvec = 0) { ::flatbuffers::Offset<::flatbuffers::Vector<float>> fvec = 0) {
MonsterExtraBuilder builder_(_fbb); MonsterExtraBuilder builder_(_fbb);
builder_.add_d3(d3); builder_.add_d3(d3);
builder_.add_d2(d2); builder_.add_d2(d2);
@@ -208,8 +208,8 @@ inline flatbuffers::Offset<MonsterExtra> CreateMonsterExtra(
return builder_.Finish(); return builder_.Finish();
} }
inline flatbuffers::Offset<MonsterExtra> CreateMonsterExtraDirect( inline ::flatbuffers::Offset<MonsterExtra> CreateMonsterExtraDirect(
flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::FlatBufferBuilder &_fbb,
double d0 = std::numeric_limits<double>::quiet_NaN(), double d0 = std::numeric_limits<double>::quiet_NaN(),
double d1 = std::numeric_limits<double>::quiet_NaN(), double d1 = std::numeric_limits<double>::quiet_NaN(),
double d2 = std::numeric_limits<double>::infinity(), double d2 = std::numeric_limits<double>::infinity(),
@@ -236,7 +236,7 @@ inline flatbuffers::Offset<MonsterExtra> CreateMonsterExtraDirect(
fvec__); fvec__);
} }
flatbuffers::Offset<MonsterExtra> CreateMonsterExtra(flatbuffers::FlatBufferBuilder &_fbb, const MonsterExtraT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); ::flatbuffers::Offset<MonsterExtra> CreateMonsterExtra(::flatbuffers::FlatBufferBuilder &_fbb, const MonsterExtraT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
inline bool operator==(const MonsterExtraT &lhs, const MonsterExtraT &rhs) { inline bool operator==(const MonsterExtraT &lhs, const MonsterExtraT &rhs) {
@@ -258,13 +258,13 @@ inline bool operator!=(const MonsterExtraT &lhs, const MonsterExtraT &rhs) {
} }
inline MonsterExtraT *MonsterExtra::UnPack(const flatbuffers::resolver_function_t *_resolver) const { inline MonsterExtraT *MonsterExtra::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
auto _o = std::unique_ptr<MonsterExtraT>(new MonsterExtraT()); auto _o = std::unique_ptr<MonsterExtraT>(new MonsterExtraT());
UnPackTo(_o.get(), _resolver); UnPackTo(_o.get(), _resolver);
return _o.release(); return _o.release();
} }
inline void MonsterExtra::UnPackTo(MonsterExtraT *_o, const flatbuffers::resolver_function_t *_resolver) const { inline void MonsterExtra::UnPackTo(MonsterExtraT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
(void)_o; (void)_o;
(void)_resolver; (void)_resolver;
{ auto _e = d0(); _o->d0 = _e; } { auto _e = d0(); _o->d0 = _e; }
@@ -275,18 +275,18 @@ inline void MonsterExtra::UnPackTo(MonsterExtraT *_o, const flatbuffers::resolve
{ auto _e = f1(); _o->f1 = _e; } { auto _e = f1(); _o->f1 = _e; }
{ auto _e = f2(); _o->f2 = _e; } { auto _e = f2(); _o->f2 = _e; }
{ auto _e = f3(); _o->f3 = _e; } { auto _e = f3(); _o->f3 = _e; }
{ auto _e = dvec(); if (_e) { _o->dvec.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->dvec[_i] = _e->Get(_i); } } else { _o->dvec.resize(0); } } { auto _e = dvec(); if (_e) { _o->dvec.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->dvec[_i] = _e->Get(_i); } } else { _o->dvec.resize(0); } }
{ auto _e = fvec(); if (_e) { _o->fvec.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->fvec[_i] = _e->Get(_i); } } else { _o->fvec.resize(0); } } { auto _e = fvec(); if (_e) { _o->fvec.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->fvec[_i] = _e->Get(_i); } } else { _o->fvec.resize(0); } }
} }
inline flatbuffers::Offset<MonsterExtra> MonsterExtra::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterExtraT* _o, const flatbuffers::rehasher_function_t *_rehasher) { inline ::flatbuffers::Offset<MonsterExtra> MonsterExtra::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const MonsterExtraT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateMonsterExtra(_fbb, _o, _rehasher); return CreateMonsterExtra(_fbb, _o, _rehasher);
} }
inline flatbuffers::Offset<MonsterExtra> CreateMonsterExtra(flatbuffers::FlatBufferBuilder &_fbb, const MonsterExtraT *_o, const flatbuffers::rehasher_function_t *_rehasher) { inline ::flatbuffers::Offset<MonsterExtra> CreateMonsterExtra(::flatbuffers::FlatBufferBuilder &_fbb, const MonsterExtraT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher; (void)_rehasher;
(void)_o; (void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MonsterExtraT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const MonsterExtraT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _d0 = _o->d0; auto _d0 = _o->d0;
auto _d1 = _o->d1; auto _d1 = _o->d1;
auto _d2 = _o->d2; auto _d2 = _o->d2;
@@ -311,19 +311,19 @@ inline flatbuffers::Offset<MonsterExtra> CreateMonsterExtra(flatbuffers::FlatBuf
_fvec); _fvec);
} }
inline const flatbuffers::TypeTable *MonsterExtraTypeTable() { inline const ::flatbuffers::TypeTable *MonsterExtraTypeTable() {
static const flatbuffers::TypeCode type_codes[] = { static const ::flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_DOUBLE, 0, -1 }, { ::flatbuffers::ET_DOUBLE, 0, -1 },
{ flatbuffers::ET_DOUBLE, 0, -1 }, { ::flatbuffers::ET_DOUBLE, 0, -1 },
{ flatbuffers::ET_DOUBLE, 0, -1 }, { ::flatbuffers::ET_DOUBLE, 0, -1 },
{ flatbuffers::ET_DOUBLE, 0, -1 }, { ::flatbuffers::ET_DOUBLE, 0, -1 },
{ flatbuffers::ET_FLOAT, 0, -1 }, { ::flatbuffers::ET_FLOAT, 0, -1 },
{ flatbuffers::ET_FLOAT, 0, -1 }, { ::flatbuffers::ET_FLOAT, 0, -1 },
{ flatbuffers::ET_FLOAT, 0, -1 }, { ::flatbuffers::ET_FLOAT, 0, -1 },
{ flatbuffers::ET_FLOAT, 0, -1 }, { ::flatbuffers::ET_FLOAT, 0, -1 },
{ flatbuffers::ET_DOUBLE, 1, -1 }, { ::flatbuffers::ET_DOUBLE, 1, -1 },
{ flatbuffers::ET_FLOAT, 1, -1 }, { ::flatbuffers::ET_FLOAT, 1, -1 },
{ flatbuffers::ET_INT, 0, -1 } { ::flatbuffers::ET_INT, 0, -1 }
}; };
static const char * const names[] = { static const char * const names[] = {
"d0", "d0",
@@ -338,26 +338,26 @@ inline const flatbuffers::TypeTable *MonsterExtraTypeTable() {
"fvec", "fvec",
"deprec" "deprec"
}; };
static const flatbuffers::TypeTable tt = { static const ::flatbuffers::TypeTable tt = {
flatbuffers::ST_TABLE, 11, type_codes, nullptr, nullptr, nullptr, names ::flatbuffers::ST_TABLE, 11, type_codes, nullptr, nullptr, nullptr, names
}; };
return &tt; return &tt;
} }
inline const MyGame::MonsterExtra *GetMonsterExtra(const void *buf) { inline const MyGame::MonsterExtra *GetMonsterExtra(const void *buf) {
return flatbuffers::GetRoot<MyGame::MonsterExtra>(buf); return ::flatbuffers::GetRoot<MyGame::MonsterExtra>(buf);
} }
inline const MyGame::MonsterExtra *GetSizePrefixedMonsterExtra(const void *buf) { inline const MyGame::MonsterExtra *GetSizePrefixedMonsterExtra(const void *buf) {
return flatbuffers::GetSizePrefixedRoot<MyGame::MonsterExtra>(buf); return ::flatbuffers::GetSizePrefixedRoot<MyGame::MonsterExtra>(buf);
} }
inline MonsterExtra *GetMutableMonsterExtra(void *buf) { inline MonsterExtra *GetMutableMonsterExtra(void *buf) {
return flatbuffers::GetMutableRoot<MonsterExtra>(buf); return ::flatbuffers::GetMutableRoot<MonsterExtra>(buf);
} }
inline MyGame::MonsterExtra *GetMutableSizePrefixedMonsterExtra(void *buf) { inline MyGame::MonsterExtra *GetMutableSizePrefixedMonsterExtra(void *buf) {
return flatbuffers::GetMutableSizePrefixedRoot<MyGame::MonsterExtra>(buf); return ::flatbuffers::GetMutableSizePrefixedRoot<MyGame::MonsterExtra>(buf);
} }
inline const char *MonsterExtraIdentifier() { inline const char *MonsterExtraIdentifier() {
@@ -365,22 +365,22 @@ inline const char *MonsterExtraIdentifier() {
} }
inline bool MonsterExtraBufferHasIdentifier(const void *buf) { inline bool MonsterExtraBufferHasIdentifier(const void *buf) {
return flatbuffers::BufferHasIdentifier( return ::flatbuffers::BufferHasIdentifier(
buf, MonsterExtraIdentifier()); buf, MonsterExtraIdentifier());
} }
inline bool SizePrefixedMonsterExtraBufferHasIdentifier(const void *buf) { inline bool SizePrefixedMonsterExtraBufferHasIdentifier(const void *buf) {
return flatbuffers::BufferHasIdentifier( return ::flatbuffers::BufferHasIdentifier(
buf, MonsterExtraIdentifier(), true); buf, MonsterExtraIdentifier(), true);
} }
inline bool VerifyMonsterExtraBuffer( inline bool VerifyMonsterExtraBuffer(
flatbuffers::Verifier &verifier) { ::flatbuffers::Verifier &verifier) {
return verifier.VerifyBuffer<MyGame::MonsterExtra>(MonsterExtraIdentifier()); return verifier.VerifyBuffer<MyGame::MonsterExtra>(MonsterExtraIdentifier());
} }
inline bool VerifySizePrefixedMonsterExtraBuffer( inline bool VerifySizePrefixedMonsterExtraBuffer(
flatbuffers::Verifier &verifier) { ::flatbuffers::Verifier &verifier) {
return verifier.VerifySizePrefixedBuffer<MyGame::MonsterExtra>(MonsterExtraIdentifier()); return verifier.VerifySizePrefixedBuffer<MyGame::MonsterExtra>(MonsterExtraIdentifier());
} }
@@ -389,26 +389,26 @@ inline const char *MonsterExtraExtension() {
} }
inline void FinishMonsterExtraBuffer( inline void FinishMonsterExtraBuffer(
flatbuffers::FlatBufferBuilder &fbb, ::flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<MyGame::MonsterExtra> root) { ::flatbuffers::Offset<MyGame::MonsterExtra> root) {
fbb.Finish(root, MonsterExtraIdentifier()); fbb.Finish(root, MonsterExtraIdentifier());
} }
inline void FinishSizePrefixedMonsterExtraBuffer( inline void FinishSizePrefixedMonsterExtraBuffer(
flatbuffers::FlatBufferBuilder &fbb, ::flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<MyGame::MonsterExtra> root) { ::flatbuffers::Offset<MyGame::MonsterExtra> root) {
fbb.FinishSizePrefixed(root, MonsterExtraIdentifier()); fbb.FinishSizePrefixed(root, MonsterExtraIdentifier());
} }
inline flatbuffers::unique_ptr<MyGame::MonsterExtraT> UnPackMonsterExtra( inline flatbuffers::unique_ptr<MyGame::MonsterExtraT> UnPackMonsterExtra(
const void *buf, const void *buf,
const flatbuffers::resolver_function_t *res = nullptr) { const ::flatbuffers::resolver_function_t *res = nullptr) {
return flatbuffers::unique_ptr<MyGame::MonsterExtraT>(GetMonsterExtra(buf)->UnPack(res)); return flatbuffers::unique_ptr<MyGame::MonsterExtraT>(GetMonsterExtra(buf)->UnPack(res));
} }
inline flatbuffers::unique_ptr<MyGame::MonsterExtraT> UnPackSizePrefixedMonsterExtra( inline flatbuffers::unique_ptr<MyGame::MonsterExtraT> UnPackSizePrefixedMonsterExtra(
const void *buf, const void *buf,
const flatbuffers::resolver_function_t *res = nullptr) { const ::flatbuffers::resolver_function_t *res = nullptr) {
return flatbuffers::unique_ptr<MyGame::MonsterExtraT>(GetSizePrefixedMonsterExtra(buf)->UnPack(res)); return flatbuffers::unique_ptr<MyGame::MonsterExtraT>(GetSizePrefixedMonsterExtra(buf)->UnPack(res));
} }

1260
tests/monster_test_generated.h
View File

File diff suppressed because it is too large Load Diff

1260
tests/monster_test_suffix/ext_only/monster_test_generated.hpp
View File

File diff suppressed because it is too large Load Diff

1260
tests/monster_test_suffix/filesuffix_only/monster_test_suffix.h
View File

File diff suppressed because it is too large Load Diff

1260
tests/monster_test_suffix/monster_test_suffix.hpp
View File

File diff suppressed because it is too large Load Diff

132
tests/namespace_test/namespace_test1_generated.h
View File

@@ -27,9 +27,9 @@ bool operator!=(const TableInNestedNST &lhs, const TableInNestedNST &rhs);
bool operator==(const StructInNestedNS &lhs, const StructInNestedNS &rhs); bool operator==(const StructInNestedNS &lhs, const StructInNestedNS &rhs);
bool operator!=(const StructInNestedNS &lhs, const StructInNestedNS &rhs); bool operator!=(const StructInNestedNS &lhs, const StructInNestedNS &rhs);
inline const flatbuffers::TypeTable *TableInNestedNSTypeTable(); inline const ::flatbuffers::TypeTable *TableInNestedNSTypeTable();
inline const flatbuffers::TypeTable *StructInNestedNSTypeTable(); inline const ::flatbuffers::TypeTable *StructInNestedNSTypeTable();
enum UnionInNestedNS : uint8_t { enum UnionInNestedNS : uint8_t {
UnionInNestedNS_NONE = 0, UnionInNestedNS_NONE = 0,
@@ -56,7 +56,7 @@ inline const char * const *EnumNamesUnionInNestedNS() {
} }
inline const char *EnumNameUnionInNestedNS(UnionInNestedNS e) { inline const char *EnumNameUnionInNestedNS(UnionInNestedNS e) {
if (flatbuffers::IsOutRange(e, UnionInNestedNS_NONE, UnionInNestedNS_TableInNestedNS)) return ""; if (::flatbuffers::IsOutRange(e, UnionInNestedNS_NONE, UnionInNestedNS_TableInNestedNS)) return "";
const size_t index = static_cast<size_t>(e); const size_t index = static_cast<size_t>(e);
return EnumNamesUnionInNestedNS()[index]; return EnumNamesUnionInNestedNS()[index];
} }
@@ -104,8 +104,8 @@ struct UnionInNestedNSUnion {
} }
} }
static void *UnPack(const void *obj, UnionInNestedNS type, const flatbuffers::resolver_function_t *resolver); static void *UnPack(const void *obj, UnionInNestedNS type, const ::flatbuffers::resolver_function_t *resolver);
flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const; ::flatbuffers::Offset<void> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
NamespaceA::NamespaceB::TableInNestedNST *AsTableInNestedNS() { NamespaceA::NamespaceB::TableInNestedNST *AsTableInNestedNS() {
return type == UnionInNestedNS_TableInNestedNS ? return type == UnionInNestedNS_TableInNestedNS ?
@@ -138,8 +138,8 @@ inline bool operator!=(const UnionInNestedNSUnion &lhs, const UnionInNestedNSUni
return !(lhs == rhs); return !(lhs == rhs);
} }
bool VerifyUnionInNestedNS(flatbuffers::Verifier &verifier, const void *obj, UnionInNestedNS type); bool VerifyUnionInNestedNS(::flatbuffers::Verifier &verifier, const void *obj, UnionInNestedNS type);
bool VerifyUnionInNestedNSVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types); bool VerifyUnionInNestedNSVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
enum EnumInNestedNS : int8_t { enum EnumInNestedNS : int8_t {
EnumInNestedNS_A = 0, EnumInNestedNS_A = 0,
@@ -169,7 +169,7 @@ inline const char * const *EnumNamesEnumInNestedNS() {
} }
inline const char *EnumNameEnumInNestedNS(EnumInNestedNS e) { inline const char *EnumNameEnumInNestedNS(EnumInNestedNS e) {
if (flatbuffers::IsOutRange(e, EnumInNestedNS_A, EnumInNestedNS_C)) return ""; if (::flatbuffers::IsOutRange(e, EnumInNestedNS_A, EnumInNestedNS_C)) return "";
const size_t index = static_cast<size_t>(e); const size_t index = static_cast<size_t>(e);
return EnumNamesEnumInNestedNS()[index]; return EnumNamesEnumInNestedNS()[index];
} }
@@ -180,7 +180,7 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) StructInNestedNS FLATBUFFERS_FINAL_CLASS
int32_t b_; int32_t b_;
public: public:
static const flatbuffers::TypeTable *MiniReflectTypeTable() { static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return StructInNestedNSTypeTable(); return StructInNestedNSTypeTable();
} }
static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() { static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
@@ -191,20 +191,20 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) StructInNestedNS FLATBUFFERS_FINAL_CLASS
b_(0) { b_(0) {
} }
StructInNestedNS(int32_t _a, int32_t _b) StructInNestedNS(int32_t _a, int32_t _b)
: a_(flatbuffers::EndianScalar(_a)), : a_(::flatbuffers::EndianScalar(_a)),
b_(flatbuffers::EndianScalar(_b)) { b_(::flatbuffers::EndianScalar(_b)) {
} }
int32_t a() const { int32_t a() const {
return flatbuffers::EndianScalar(a_); return ::flatbuffers::EndianScalar(a_);
} }
void mutate_a(int32_t _a) { void mutate_a(int32_t _a) {
flatbuffers::WriteScalar(&a_, _a); ::flatbuffers::WriteScalar(&a_, _a);
} }
int32_t b() const { int32_t b() const {
return flatbuffers::EndianScalar(b_); return ::flatbuffers::EndianScalar(b_);
} }
void mutate_b(int32_t _b) { void mutate_b(int32_t _b) {
flatbuffers::WriteScalar(&b_, _b); ::flatbuffers::WriteScalar(&b_, _b);
} }
}; };
FLATBUFFERS_STRUCT_END(StructInNestedNS, 8); FLATBUFFERS_STRUCT_END(StructInNestedNS, 8);
@@ -220,7 +220,7 @@ inline bool operator!=(const StructInNestedNS &lhs, const StructInNestedNS &rhs)
} }
struct TableInNestedNST : public flatbuffers::NativeTable { struct TableInNestedNST : public ::flatbuffers::NativeTable {
typedef TableInNestedNS TableType; typedef TableInNestedNS TableType;
static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() { static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
return "NamespaceA.NamespaceB.TableInNestedNST"; return "NamespaceA.NamespaceB.TableInNestedNST";
@@ -228,10 +228,10 @@ struct TableInNestedNST : public flatbuffers::NativeTable {
int32_t foo = 0; int32_t foo = 0;
}; };
struct TableInNestedNS FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { struct TableInNestedNS FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef TableInNestedNST NativeTableType; typedef TableInNestedNST NativeTableType;
typedef TableInNestedNSBuilder Builder; typedef TableInNestedNSBuilder Builder;
static const flatbuffers::TypeTable *MiniReflectTypeTable() { static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return TableInNestedNSTypeTable(); return TableInNestedNSTypeTable();
} }
static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() { static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
@@ -246,43 +246,43 @@ struct TableInNestedNS FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool mutate_foo(int32_t _foo = 0) { bool mutate_foo(int32_t _foo = 0) {
return SetField<int32_t>(VT_FOO, _foo, 0); return SetField<int32_t>(VT_FOO, _foo, 0);
} }
bool Verify(flatbuffers::Verifier &verifier) const { bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) && return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_FOO, 4) && VerifyField<int32_t>(verifier, VT_FOO, 4) &&
verifier.EndTable(); verifier.EndTable();
} }
TableInNestedNST *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; TableInNestedNST *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(TableInNestedNST *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; void UnPackTo(TableInNestedNST *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<TableInNestedNS> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TableInNestedNST* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); static ::flatbuffers::Offset<TableInNestedNS> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const TableInNestedNST* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
}; };
struct TableInNestedNSBuilder { struct TableInNestedNSBuilder {
typedef TableInNestedNS Table; typedef TableInNestedNS Table;
flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_; ::flatbuffers::uoffset_t start_;
void add_foo(int32_t foo) { void add_foo(int32_t foo) {
fbb_.AddElement<int32_t>(TableInNestedNS::VT_FOO, foo, 0); fbb_.AddElement<int32_t>(TableInNestedNS::VT_FOO, foo, 0);
} }
explicit TableInNestedNSBuilder(flatbuffers::FlatBufferBuilder &_fbb) explicit TableInNestedNSBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) { : fbb_(_fbb) {
start_ = fbb_.StartTable(); start_ = fbb_.StartTable();
} }
flatbuffers::Offset<TableInNestedNS> Finish() { ::flatbuffers::Offset<TableInNestedNS> Finish() {
const auto end = fbb_.EndTable(start_); const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<TableInNestedNS>(end); auto o = ::flatbuffers::Offset<TableInNestedNS>(end);
return o; return o;
} }
}; };
inline flatbuffers::Offset<TableInNestedNS> CreateTableInNestedNS( inline ::flatbuffers::Offset<TableInNestedNS> CreateTableInNestedNS(
flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::FlatBufferBuilder &_fbb,
int32_t foo = 0) { int32_t foo = 0) {
TableInNestedNSBuilder builder_(_fbb); TableInNestedNSBuilder builder_(_fbb);
builder_.add_foo(foo); builder_.add_foo(foo);
return builder_.Finish(); return builder_.Finish();
} }
flatbuffers::Offset<TableInNestedNS> CreateTableInNestedNS(flatbuffers::FlatBufferBuilder &_fbb, const TableInNestedNST *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); ::flatbuffers::Offset<TableInNestedNS> CreateTableInNestedNS(::flatbuffers::FlatBufferBuilder &_fbb, const TableInNestedNST *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
inline bool operator==(const TableInNestedNST &lhs, const TableInNestedNST &rhs) { inline bool operator==(const TableInNestedNST &lhs, const TableInNestedNST &rhs) {
@@ -295,33 +295,33 @@ inline bool operator!=(const TableInNestedNST &lhs, const TableInNestedNST &rhs)
} }
inline TableInNestedNST *TableInNestedNS::UnPack(const flatbuffers::resolver_function_t *_resolver) const { inline TableInNestedNST *TableInNestedNS::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
auto _o = std::unique_ptr<TableInNestedNST>(new TableInNestedNST()); auto _o = std::unique_ptr<TableInNestedNST>(new TableInNestedNST());
UnPackTo(_o.get(), _resolver); UnPackTo(_o.get(), _resolver);
return _o.release(); return _o.release();
} }
inline void TableInNestedNS::UnPackTo(TableInNestedNST *_o, const flatbuffers::resolver_function_t *_resolver) const { inline void TableInNestedNS::UnPackTo(TableInNestedNST *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
(void)_o; (void)_o;
(void)_resolver; (void)_resolver;
{ auto _e = foo(); _o->foo = _e; } { auto _e = foo(); _o->foo = _e; }
} }
inline flatbuffers::Offset<TableInNestedNS> TableInNestedNS::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TableInNestedNST* _o, const flatbuffers::rehasher_function_t *_rehasher) { inline ::flatbuffers::Offset<TableInNestedNS> TableInNestedNS::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const TableInNestedNST* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateTableInNestedNS(_fbb, _o, _rehasher); return CreateTableInNestedNS(_fbb, _o, _rehasher);
} }
inline flatbuffers::Offset<TableInNestedNS> CreateTableInNestedNS(flatbuffers::FlatBufferBuilder &_fbb, const TableInNestedNST *_o, const flatbuffers::rehasher_function_t *_rehasher) { inline ::flatbuffers::Offset<TableInNestedNS> CreateTableInNestedNS(::flatbuffers::FlatBufferBuilder &_fbb, const TableInNestedNST *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher; (void)_rehasher;
(void)_o; (void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TableInNestedNST* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const TableInNestedNST* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _foo = _o->foo; auto _foo = _o->foo;
return NamespaceA::NamespaceB::CreateTableInNestedNS( return NamespaceA::NamespaceB::CreateTableInNestedNS(
_fbb, _fbb,
_foo); _foo);
} }
inline bool VerifyUnionInNestedNS(flatbuffers::Verifier &verifier, const void *obj, UnionInNestedNS type) { inline bool VerifyUnionInNestedNS(::flatbuffers::Verifier &verifier, const void *obj, UnionInNestedNS type) {
switch (type) { switch (type) {
case UnionInNestedNS_NONE: { case UnionInNestedNS_NONE: {
return true; return true;
@@ -334,10 +334,10 @@ inline bool VerifyUnionInNestedNS(flatbuffers::Verifier &verifier, const void *o
} }
} }
inline bool VerifyUnionInNestedNSVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) { inline bool VerifyUnionInNestedNSVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
if (!values || !types) return !values && !types; if (!values || !types) return !values && !types;
if (values->size() != types->size()) return false; 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 (!VerifyUnionInNestedNS( if (!VerifyUnionInNestedNS(
verifier, values->Get(i), types->GetEnum<UnionInNestedNS>(i))) { verifier, values->Get(i), types->GetEnum<UnionInNestedNS>(i))) {
return false; return false;
@@ -346,7 +346,7 @@ inline bool VerifyUnionInNestedNSVector(flatbuffers::Verifier &verifier, const f
return true; return true;
} }
inline void *UnionInNestedNSUnion::UnPack(const void *obj, UnionInNestedNS type, const flatbuffers::resolver_function_t *resolver) { inline void *UnionInNestedNSUnion::UnPack(const void *obj, UnionInNestedNS type, const ::flatbuffers::resolver_function_t *resolver) {
(void)resolver; (void)resolver;
switch (type) { switch (type) {
case UnionInNestedNS_TableInNestedNS: { case UnionInNestedNS_TableInNestedNS: {
@@ -357,7 +357,7 @@ inline void *UnionInNestedNSUnion::UnPack(const void *obj, UnionInNestedNS type,
} }
} }
inline flatbuffers::Offset<void> UnionInNestedNSUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const { inline ::flatbuffers::Offset<void> UnionInNestedNSUnion::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher) const {
(void)_rehasher; (void)_rehasher;
switch (type) { switch (type) {
case UnionInNestedNS_TableInNestedNS: { case UnionInNestedNS_TableInNestedNS: {
@@ -392,31 +392,31 @@ inline void UnionInNestedNSUnion::Reset() {
type = UnionInNestedNS_NONE; type = UnionInNestedNS_NONE;
} }
inline const flatbuffers::TypeTable *UnionInNestedNSTypeTable() { inline const ::flatbuffers::TypeTable *UnionInNestedNSTypeTable() {
static const flatbuffers::TypeCode type_codes[] = { static const ::flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_SEQUENCE, 0, -1 }, { ::flatbuffers::ET_SEQUENCE, 0, -1 },
{ flatbuffers::ET_SEQUENCE, 0, 0 } { ::flatbuffers::ET_SEQUENCE, 0, 0 }
}; };
static const flatbuffers::TypeFunction type_refs[] = { static const ::flatbuffers::TypeFunction type_refs[] = {
NamespaceA::NamespaceB::TableInNestedNSTypeTable NamespaceA::NamespaceB::TableInNestedNSTypeTable
}; };
static const char * const names[] = { static const char * const names[] = {
"NONE", "NONE",
"TableInNestedNS" "TableInNestedNS"
}; };
static const flatbuffers::TypeTable tt = { static const ::flatbuffers::TypeTable tt = {
flatbuffers::ST_UNION, 2, type_codes, type_refs, nullptr, nullptr, names ::flatbuffers::ST_UNION, 2, type_codes, type_refs, nullptr, nullptr, names
}; };
return &tt; return &tt;
} }
inline const flatbuffers::TypeTable *EnumInNestedNSTypeTable() { inline const ::flatbuffers::TypeTable *EnumInNestedNSTypeTable() {
static const flatbuffers::TypeCode type_codes[] = { static const ::flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_CHAR, 0, 0 }, { ::flatbuffers::ET_CHAR, 0, 0 },
{ flatbuffers::ET_CHAR, 0, 0 }, { ::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[] = {
NamespaceA::NamespaceB::EnumInNestedNSTypeTable NamespaceA::NamespaceB::EnumInNestedNSTypeTable
}; };
static const char * const names[] = { static const char * const names[] = {
@@ -424,37 +424,37 @@ inline const flatbuffers::TypeTable *EnumInNestedNSTypeTable() {
"B", "B",
"C" "C"
}; };
static const flatbuffers::TypeTable tt = { static const ::flatbuffers::TypeTable tt = {
flatbuffers::ST_ENUM, 3, type_codes, type_refs, nullptr, nullptr, names ::flatbuffers::ST_ENUM, 3, type_codes, type_refs, nullptr, nullptr, names
}; };
return &tt; return &tt;
} }
inline const flatbuffers::TypeTable *TableInNestedNSTypeTable() { inline const ::flatbuffers::TypeTable *TableInNestedNSTypeTable() {
static const flatbuffers::TypeCode type_codes[] = { static const ::flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_INT, 0, -1 } { ::flatbuffers::ET_INT, 0, -1 }
}; };
static const char * const names[] = { static const char * const names[] = {
"foo" "foo"
}; };
static const flatbuffers::TypeTable tt = { static const ::flatbuffers::TypeTable tt = {
flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names ::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
}; };
return &tt; return &tt;
} }
inline const flatbuffers::TypeTable *StructInNestedNSTypeTable() { inline const ::flatbuffers::TypeTable *StructInNestedNSTypeTable() {
static const flatbuffers::TypeCode type_codes[] = { static const ::flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_INT, 0, -1 }, { ::flatbuffers::ET_INT, 0, -1 },
{ flatbuffers::ET_INT, 0, -1 } { ::flatbuffers::ET_INT, 0, -1 }
}; };
static const int64_t values[] = { 0, 4, 8 }; static const int64_t values[] = { 0, 4, 8 };
static const char * const names[] = { static const char * const names[] = {
"a", "a",
"b" "b"
}; };
static const flatbuffers::TypeTable tt = { static const ::flatbuffers::TypeTable tt = {
flatbuffers::ST_STRUCT, 2, type_codes, nullptr, nullptr, values, names ::flatbuffers::ST_STRUCT, 2, type_codes, nullptr, nullptr, values, names
}; };
return &tt; return &tt;
} }

192
tests/namespace_test/namespace_test2_generated.h
View File

@@ -50,21 +50,21 @@ namespace NamespaceA {
bool operator==(const SecondTableInAT &lhs, const SecondTableInAT &rhs); bool operator==(const SecondTableInAT &lhs, const SecondTableInAT &rhs);
bool operator!=(const SecondTableInAT &lhs, const SecondTableInAT &rhs); bool operator!=(const SecondTableInAT &lhs, const SecondTableInAT &rhs);
inline const flatbuffers::TypeTable *TableInFirstNSTypeTable(); inline const ::flatbuffers::TypeTable *TableInFirstNSTypeTable();
} // namespace NamespaceA } // namespace NamespaceA
namespace NamespaceC { namespace NamespaceC {
inline const flatbuffers::TypeTable *TableInCTypeTable(); inline const ::flatbuffers::TypeTable *TableInCTypeTable();
} // namespace NamespaceC } // namespace NamespaceC
namespace NamespaceA { namespace NamespaceA {
inline const flatbuffers::TypeTable *SecondTableInATypeTable(); inline const ::flatbuffers::TypeTable *SecondTableInATypeTable();
struct TableInFirstNST : public flatbuffers::NativeTable { struct TableInFirstNST : public ::flatbuffers::NativeTable {
typedef TableInFirstNS TableType; typedef TableInFirstNS TableType;
static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() { static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
return "NamespaceA.TableInFirstNST"; return "NamespaceA.TableInFirstNST";
@@ -79,10 +79,10 @@ struct TableInFirstNST : public flatbuffers::NativeTable {
TableInFirstNST &operator=(TableInFirstNST o) FLATBUFFERS_NOEXCEPT; TableInFirstNST &operator=(TableInFirstNST o) FLATBUFFERS_NOEXCEPT;
}; };
struct TableInFirstNS FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { struct TableInFirstNS FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef TableInFirstNST NativeTableType; typedef TableInFirstNST NativeTableType;
typedef TableInFirstNSBuilder Builder; typedef TableInFirstNSBuilder Builder;
static const flatbuffers::TypeTable *MiniReflectTypeTable() { static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return TableInFirstNSTypeTable(); return TableInFirstNSTypeTable();
} }
static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() { static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
@@ -126,7 +126,7 @@ struct TableInFirstNS FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
NamespaceA::NamespaceB::StructInNestedNS *mutable_foo_struct() { NamespaceA::NamespaceB::StructInNestedNS *mutable_foo_struct() {
return GetStruct<NamespaceA::NamespaceB::StructInNestedNS *>(VT_FOO_STRUCT); return GetStruct<NamespaceA::NamespaceB::StructInNestedNS *>(VT_FOO_STRUCT);
} }
bool Verify(flatbuffers::Verifier &verifier) const { bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) && return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_FOO_TABLE) && VerifyOffset(verifier, VT_FOO_TABLE) &&
verifier.VerifyTable(foo_table()) && verifier.VerifyTable(foo_table()) &&
@@ -137,9 +137,9 @@ struct TableInFirstNS FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VerifyField<NamespaceA::NamespaceB::StructInNestedNS>(verifier, VT_FOO_STRUCT, 4) && VerifyField<NamespaceA::NamespaceB::StructInNestedNS>(verifier, VT_FOO_STRUCT, 4) &&
verifier.EndTable(); verifier.EndTable();
} }
TableInFirstNST *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; TableInFirstNST *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(TableInFirstNST *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; void UnPackTo(TableInFirstNST *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<TableInFirstNS> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TableInFirstNST* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); static ::flatbuffers::Offset<TableInFirstNS> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const TableInFirstNST* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
}; };
template<> inline const NamespaceA::NamespaceB::TableInNestedNS *TableInFirstNS::foo_union_as<NamespaceA::NamespaceB::TableInNestedNS>() const { template<> inline const NamespaceA::NamespaceB::TableInNestedNS *TableInFirstNS::foo_union_as<NamespaceA::NamespaceB::TableInNestedNS>() const {
@@ -148,9 +148,9 @@ template<> inline const NamespaceA::NamespaceB::TableInNestedNS *TableInFirstNS:
struct TableInFirstNSBuilder { struct TableInFirstNSBuilder {
typedef TableInFirstNS Table; typedef TableInFirstNS Table;
flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_; ::flatbuffers::uoffset_t start_;
void add_foo_table(flatbuffers::Offset<NamespaceA::NamespaceB::TableInNestedNS> foo_table) { void add_foo_table(::flatbuffers::Offset<NamespaceA::NamespaceB::TableInNestedNS> foo_table) {
fbb_.AddOffset(TableInFirstNS::VT_FOO_TABLE, foo_table); fbb_.AddOffset(TableInFirstNS::VT_FOO_TABLE, foo_table);
} }
void add_foo_enum(NamespaceA::NamespaceB::EnumInNestedNS foo_enum) { void add_foo_enum(NamespaceA::NamespaceB::EnumInNestedNS foo_enum) {
@@ -159,29 +159,29 @@ struct TableInFirstNSBuilder {
void add_foo_union_type(NamespaceA::NamespaceB::UnionInNestedNS foo_union_type) { void add_foo_union_type(NamespaceA::NamespaceB::UnionInNestedNS foo_union_type) {
fbb_.AddElement<uint8_t>(TableInFirstNS::VT_FOO_UNION_TYPE, static_cast<uint8_t>(foo_union_type), 0); fbb_.AddElement<uint8_t>(TableInFirstNS::VT_FOO_UNION_TYPE, static_cast<uint8_t>(foo_union_type), 0);
} }
void add_foo_union(flatbuffers::Offset<void> foo_union) { void add_foo_union(::flatbuffers::Offset<void> foo_union) {
fbb_.AddOffset(TableInFirstNS::VT_FOO_UNION, foo_union); fbb_.AddOffset(TableInFirstNS::VT_FOO_UNION, foo_union);
} }
void add_foo_struct(const NamespaceA::NamespaceB::StructInNestedNS *foo_struct) { void add_foo_struct(const NamespaceA::NamespaceB::StructInNestedNS *foo_struct) {
fbb_.AddStruct(TableInFirstNS::VT_FOO_STRUCT, foo_struct); fbb_.AddStruct(TableInFirstNS::VT_FOO_STRUCT, foo_struct);
} }
explicit TableInFirstNSBuilder(flatbuffers::FlatBufferBuilder &_fbb) explicit TableInFirstNSBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) { : fbb_(_fbb) {
start_ = fbb_.StartTable(); start_ = fbb_.StartTable();
} }
flatbuffers::Offset<TableInFirstNS> Finish() { ::flatbuffers::Offset<TableInFirstNS> Finish() {
const auto end = fbb_.EndTable(start_); const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<TableInFirstNS>(end); auto o = ::flatbuffers::Offset<TableInFirstNS>(end);
return o; return o;
} }
}; };
inline flatbuffers::Offset<TableInFirstNS> CreateTableInFirstNS( inline ::flatbuffers::Offset<TableInFirstNS> CreateTableInFirstNS(
flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<NamespaceA::NamespaceB::TableInNestedNS> foo_table = 0, ::flatbuffers::Offset<NamespaceA::NamespaceB::TableInNestedNS> foo_table = 0,
NamespaceA::NamespaceB::EnumInNestedNS foo_enum = NamespaceA::NamespaceB::EnumInNestedNS_A, NamespaceA::NamespaceB::EnumInNestedNS foo_enum = NamespaceA::NamespaceB::EnumInNestedNS_A,
NamespaceA::NamespaceB::UnionInNestedNS foo_union_type = NamespaceA::NamespaceB::UnionInNestedNS_NONE, NamespaceA::NamespaceB::UnionInNestedNS foo_union_type = NamespaceA::NamespaceB::UnionInNestedNS_NONE,
flatbuffers::Offset<void> foo_union = 0, ::flatbuffers::Offset<void> foo_union = 0,
const NamespaceA::NamespaceB::StructInNestedNS *foo_struct = nullptr) { const NamespaceA::NamespaceB::StructInNestedNS *foo_struct = nullptr) {
TableInFirstNSBuilder builder_(_fbb); TableInFirstNSBuilder builder_(_fbb);
builder_.add_foo_struct(foo_struct); builder_.add_foo_struct(foo_struct);
@@ -192,13 +192,13 @@ inline flatbuffers::Offset<TableInFirstNS> CreateTableInFirstNS(
return builder_.Finish(); return builder_.Finish();
} }
flatbuffers::Offset<TableInFirstNS> CreateTableInFirstNS(flatbuffers::FlatBufferBuilder &_fbb, const TableInFirstNST *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); ::flatbuffers::Offset<TableInFirstNS> CreateTableInFirstNS(::flatbuffers::FlatBufferBuilder &_fbb, const TableInFirstNST *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
} // namespace NamespaceA } // namespace NamespaceA
namespace NamespaceC { namespace NamespaceC {
struct TableInCT : public flatbuffers::NativeTable { struct TableInCT : public ::flatbuffers::NativeTable {
typedef TableInC TableType; typedef TableInC TableType;
static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() { static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
return "NamespaceC.TableInCT"; return "NamespaceC.TableInCT";
@@ -211,10 +211,10 @@ struct TableInCT : public flatbuffers::NativeTable {
TableInCT &operator=(TableInCT o) FLATBUFFERS_NOEXCEPT; TableInCT &operator=(TableInCT o) FLATBUFFERS_NOEXCEPT;
}; };
struct TableInC FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { struct TableInC FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef TableInCT NativeTableType; typedef TableInCT NativeTableType;
typedef TableInCBuilder Builder; typedef TableInCBuilder Builder;
static const flatbuffers::TypeTable *MiniReflectTypeTable() { static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return TableInCTypeTable(); return TableInCTypeTable();
} }
static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() { static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
@@ -236,7 +236,7 @@ struct TableInC FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
NamespaceA::SecondTableInA *mutable_refer_to_a2() { NamespaceA::SecondTableInA *mutable_refer_to_a2() {
return GetPointer<NamespaceA::SecondTableInA *>(VT_REFER_TO_A2); return GetPointer<NamespaceA::SecondTableInA *>(VT_REFER_TO_A2);
} }
bool Verify(flatbuffers::Verifier &verifier) const { bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) && return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_REFER_TO_A1) && VerifyOffset(verifier, VT_REFER_TO_A1) &&
verifier.VerifyTable(refer_to_a1()) && verifier.VerifyTable(refer_to_a1()) &&
@@ -244,49 +244,49 @@ struct TableInC FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
verifier.VerifyTable(refer_to_a2()) && verifier.VerifyTable(refer_to_a2()) &&
verifier.EndTable(); verifier.EndTable();
} }
TableInCT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; TableInCT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(TableInCT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; void UnPackTo(TableInCT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<TableInC> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TableInCT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); static ::flatbuffers::Offset<TableInC> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const TableInCT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
}; };
struct TableInCBuilder { struct TableInCBuilder {
typedef TableInC Table; typedef TableInC Table;
flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_; ::flatbuffers::uoffset_t start_;
void add_refer_to_a1(flatbuffers::Offset<NamespaceA::TableInFirstNS> refer_to_a1) { void add_refer_to_a1(::flatbuffers::Offset<NamespaceA::TableInFirstNS> refer_to_a1) {
fbb_.AddOffset(TableInC::VT_REFER_TO_A1, refer_to_a1); fbb_.AddOffset(TableInC::VT_REFER_TO_A1, refer_to_a1);
} }
void add_refer_to_a2(flatbuffers::Offset<NamespaceA::SecondTableInA> refer_to_a2) { void add_refer_to_a2(::flatbuffers::Offset<NamespaceA::SecondTableInA> refer_to_a2) {
fbb_.AddOffset(TableInC::VT_REFER_TO_A2, refer_to_a2); fbb_.AddOffset(TableInC::VT_REFER_TO_A2, refer_to_a2);
} }
explicit TableInCBuilder(flatbuffers::FlatBufferBuilder &_fbb) explicit TableInCBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) { : fbb_(_fbb) {
start_ = fbb_.StartTable(); start_ = fbb_.StartTable();
} }
flatbuffers::Offset<TableInC> Finish() { ::flatbuffers::Offset<TableInC> Finish() {
const auto end = fbb_.EndTable(start_); const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<TableInC>(end); auto o = ::flatbuffers::Offset<TableInC>(end);
return o; return o;
} }
}; };
inline flatbuffers::Offset<TableInC> CreateTableInC( inline ::flatbuffers::Offset<TableInC> CreateTableInC(
flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<NamespaceA::TableInFirstNS> refer_to_a1 = 0, ::flatbuffers::Offset<NamespaceA::TableInFirstNS> refer_to_a1 = 0,
flatbuffers::Offset<NamespaceA::SecondTableInA> refer_to_a2 = 0) { ::flatbuffers::Offset<NamespaceA::SecondTableInA> refer_to_a2 = 0) {
TableInCBuilder builder_(_fbb); TableInCBuilder builder_(_fbb);
builder_.add_refer_to_a2(refer_to_a2); builder_.add_refer_to_a2(refer_to_a2);
builder_.add_refer_to_a1(refer_to_a1); builder_.add_refer_to_a1(refer_to_a1);
return builder_.Finish(); return builder_.Finish();
} }
flatbuffers::Offset<TableInC> CreateTableInC(flatbuffers::FlatBufferBuilder &_fbb, const TableInCT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); ::flatbuffers::Offset<TableInC> CreateTableInC(::flatbuffers::FlatBufferBuilder &_fbb, const TableInCT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
} // namespace NamespaceC } // namespace NamespaceC
namespace NamespaceA { namespace NamespaceA {
struct SecondTableInAT : public flatbuffers::NativeTable { struct SecondTableInAT : public ::flatbuffers::NativeTable {
typedef SecondTableInA TableType; typedef SecondTableInA TableType;
static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() { static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
return "NamespaceA.SecondTableInAT"; return "NamespaceA.SecondTableInAT";
@@ -298,10 +298,10 @@ struct SecondTableInAT : public flatbuffers::NativeTable {
SecondTableInAT &operator=(SecondTableInAT o) FLATBUFFERS_NOEXCEPT; SecondTableInAT &operator=(SecondTableInAT o) FLATBUFFERS_NOEXCEPT;
}; };
struct SecondTableInA FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { struct SecondTableInA FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef SecondTableInAT NativeTableType; typedef SecondTableInAT NativeTableType;
typedef SecondTableInABuilder Builder; typedef SecondTableInABuilder Builder;
static const flatbuffers::TypeTable *MiniReflectTypeTable() { static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return SecondTableInATypeTable(); return SecondTableInATypeTable();
} }
static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() { static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
@@ -316,44 +316,44 @@ struct SecondTableInA FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
NamespaceC::TableInC *mutable_refer_to_c() { NamespaceC::TableInC *mutable_refer_to_c() {
return GetPointer<NamespaceC::TableInC *>(VT_REFER_TO_C); return GetPointer<NamespaceC::TableInC *>(VT_REFER_TO_C);
} }
bool Verify(flatbuffers::Verifier &verifier) const { bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) && return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_REFER_TO_C) && VerifyOffset(verifier, VT_REFER_TO_C) &&
verifier.VerifyTable(refer_to_c()) && verifier.VerifyTable(refer_to_c()) &&
verifier.EndTable(); verifier.EndTable();
} }
SecondTableInAT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; SecondTableInAT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(SecondTableInAT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; void UnPackTo(SecondTableInAT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<SecondTableInA> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SecondTableInAT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); static ::flatbuffers::Offset<SecondTableInA> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SecondTableInAT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
}; };
struct SecondTableInABuilder { struct SecondTableInABuilder {
typedef SecondTableInA Table; typedef SecondTableInA Table;
flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_; ::flatbuffers::uoffset_t start_;
void add_refer_to_c(flatbuffers::Offset<NamespaceC::TableInC> refer_to_c) { void add_refer_to_c(::flatbuffers::Offset<NamespaceC::TableInC> refer_to_c) {
fbb_.AddOffset(SecondTableInA::VT_REFER_TO_C, refer_to_c); fbb_.AddOffset(SecondTableInA::VT_REFER_TO_C, refer_to_c);
} }
explicit SecondTableInABuilder(flatbuffers::FlatBufferBuilder &_fbb) explicit SecondTableInABuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) { : fbb_(_fbb) {
start_ = fbb_.StartTable(); start_ = fbb_.StartTable();
} }
flatbuffers::Offset<SecondTableInA> Finish() { ::flatbuffers::Offset<SecondTableInA> Finish() {
const auto end = fbb_.EndTable(start_); const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<SecondTableInA>(end); auto o = ::flatbuffers::Offset<SecondTableInA>(end);
return o; return o;
} }
}; };
inline flatbuffers::Offset<SecondTableInA> CreateSecondTableInA( inline ::flatbuffers::Offset<SecondTableInA> CreateSecondTableInA(
flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<NamespaceC::TableInC> refer_to_c = 0) { ::flatbuffers::Offset<NamespaceC::TableInC> refer_to_c = 0) {
SecondTableInABuilder builder_(_fbb); SecondTableInABuilder builder_(_fbb);
builder_.add_refer_to_c(refer_to_c); builder_.add_refer_to_c(refer_to_c);
return builder_.Finish(); return builder_.Finish();
} }
flatbuffers::Offset<SecondTableInA> CreateSecondTableInA(flatbuffers::FlatBufferBuilder &_fbb, const SecondTableInAT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); ::flatbuffers::Offset<SecondTableInA> CreateSecondTableInA(::flatbuffers::FlatBufferBuilder &_fbb, const SecondTableInAT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
inline bool operator==(const TableInFirstNST &lhs, const TableInFirstNST &rhs) { inline bool operator==(const TableInFirstNST &lhs, const TableInFirstNST &rhs) {
@@ -384,13 +384,13 @@ inline TableInFirstNST &TableInFirstNST::operator=(TableInFirstNST o) FLATBUFFER
return *this; return *this;
} }
inline TableInFirstNST *TableInFirstNS::UnPack(const flatbuffers::resolver_function_t *_resolver) const { inline TableInFirstNST *TableInFirstNS::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
auto _o = std::unique_ptr<TableInFirstNST>(new TableInFirstNST()); auto _o = std::unique_ptr<TableInFirstNST>(new TableInFirstNST());
UnPackTo(_o.get(), _resolver); UnPackTo(_o.get(), _resolver);
return _o.release(); return _o.release();
} }
inline void TableInFirstNS::UnPackTo(TableInFirstNST *_o, const flatbuffers::resolver_function_t *_resolver) const { inline void TableInFirstNS::UnPackTo(TableInFirstNST *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
(void)_o; (void)_o;
(void)_resolver; (void)_resolver;
{ auto _e = foo_table(); if (_e) { if(_o->foo_table) { _e->UnPackTo(_o->foo_table.get(), _resolver); } else { _o->foo_table = flatbuffers::unique_ptr<NamespaceA::NamespaceB::TableInNestedNST>(_e->UnPack(_resolver)); } } else if (_o->foo_table) { _o->foo_table.reset(); } } { auto _e = foo_table(); if (_e) { if(_o->foo_table) { _e->UnPackTo(_o->foo_table.get(), _resolver); } else { _o->foo_table = flatbuffers::unique_ptr<NamespaceA::NamespaceB::TableInNestedNST>(_e->UnPack(_resolver)); } } else if (_o->foo_table) { _o->foo_table.reset(); } }
@@ -400,14 +400,14 @@ inline void TableInFirstNS::UnPackTo(TableInFirstNST *_o, const flatbuffers::res
{ auto _e = foo_struct(); if (_e) _o->foo_struct = flatbuffers::unique_ptr<NamespaceA::NamespaceB::StructInNestedNS>(new NamespaceA::NamespaceB::StructInNestedNS(*_e)); } { auto _e = foo_struct(); if (_e) _o->foo_struct = flatbuffers::unique_ptr<NamespaceA::NamespaceB::StructInNestedNS>(new NamespaceA::NamespaceB::StructInNestedNS(*_e)); }
} }
inline flatbuffers::Offset<TableInFirstNS> TableInFirstNS::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TableInFirstNST* _o, const flatbuffers::rehasher_function_t *_rehasher) { inline ::flatbuffers::Offset<TableInFirstNS> TableInFirstNS::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const TableInFirstNST* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateTableInFirstNS(_fbb, _o, _rehasher); return CreateTableInFirstNS(_fbb, _o, _rehasher);
} }
inline flatbuffers::Offset<TableInFirstNS> CreateTableInFirstNS(flatbuffers::FlatBufferBuilder &_fbb, const TableInFirstNST *_o, const flatbuffers::rehasher_function_t *_rehasher) { inline ::flatbuffers::Offset<TableInFirstNS> CreateTableInFirstNS(::flatbuffers::FlatBufferBuilder &_fbb, const TableInFirstNST *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher; (void)_rehasher;
(void)_o; (void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TableInFirstNST* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const TableInFirstNST* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _foo_table = _o->foo_table ? CreateTableInNestedNS(_fbb, _o->foo_table.get(), _rehasher) : 0; auto _foo_table = _o->foo_table ? CreateTableInNestedNS(_fbb, _o->foo_table.get(), _rehasher) : 0;
auto _foo_enum = _o->foo_enum; auto _foo_enum = _o->foo_enum;
auto _foo_union_type = _o->foo_union.type; auto _foo_union_type = _o->foo_union.type;
@@ -449,27 +449,27 @@ inline TableInCT &TableInCT::operator=(TableInCT o) FLATBUFFERS_NOEXCEPT {
return *this; return *this;
} }
inline TableInCT *TableInC::UnPack(const flatbuffers::resolver_function_t *_resolver) const { inline TableInCT *TableInC::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
auto _o = std::unique_ptr<TableInCT>(new TableInCT()); auto _o = std::unique_ptr<TableInCT>(new TableInCT());
UnPackTo(_o.get(), _resolver); UnPackTo(_o.get(), _resolver);
return _o.release(); return _o.release();
} }
inline void TableInC::UnPackTo(TableInCT *_o, const flatbuffers::resolver_function_t *_resolver) const { inline void TableInC::UnPackTo(TableInCT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
(void)_o; (void)_o;
(void)_resolver; (void)_resolver;
{ auto _e = refer_to_a1(); if (_e) { if(_o->refer_to_a1) { _e->UnPackTo(_o->refer_to_a1.get(), _resolver); } else { _o->refer_to_a1 = flatbuffers::unique_ptr<NamespaceA::TableInFirstNST>(_e->UnPack(_resolver)); } } else if (_o->refer_to_a1) { _o->refer_to_a1.reset(); } } { auto _e = refer_to_a1(); if (_e) { if(_o->refer_to_a1) { _e->UnPackTo(_o->refer_to_a1.get(), _resolver); } else { _o->refer_to_a1 = flatbuffers::unique_ptr<NamespaceA::TableInFirstNST>(_e->UnPack(_resolver)); } } else if (_o->refer_to_a1) { _o->refer_to_a1.reset(); } }
{ auto _e = refer_to_a2(); if (_e) { if(_o->refer_to_a2) { _e->UnPackTo(_o->refer_to_a2.get(), _resolver); } else { _o->refer_to_a2 = flatbuffers::unique_ptr<NamespaceA::SecondTableInAT>(_e->UnPack(_resolver)); } } else if (_o->refer_to_a2) { _o->refer_to_a2.reset(); } } { auto _e = refer_to_a2(); if (_e) { if(_o->refer_to_a2) { _e->UnPackTo(_o->refer_to_a2.get(), _resolver); } else { _o->refer_to_a2 = flatbuffers::unique_ptr<NamespaceA::SecondTableInAT>(_e->UnPack(_resolver)); } } else if (_o->refer_to_a2) { _o->refer_to_a2.reset(); } }
} }
inline flatbuffers::Offset<TableInC> TableInC::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TableInCT* _o, const flatbuffers::rehasher_function_t *_rehasher) { inline ::flatbuffers::Offset<TableInC> TableInC::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const TableInCT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateTableInC(_fbb, _o, _rehasher); return CreateTableInC(_fbb, _o, _rehasher);
} }
inline flatbuffers::Offset<TableInC> CreateTableInC(flatbuffers::FlatBufferBuilder &_fbb, const TableInCT *_o, const flatbuffers::rehasher_function_t *_rehasher) { inline ::flatbuffers::Offset<TableInC> CreateTableInC(::flatbuffers::FlatBufferBuilder &_fbb, const TableInCT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher; (void)_rehasher;
(void)_o; (void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TableInCT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const TableInCT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _refer_to_a1 = _o->refer_to_a1 ? CreateTableInFirstNS(_fbb, _o->refer_to_a1.get(), _rehasher) : 0; auto _refer_to_a1 = _o->refer_to_a1 ? CreateTableInFirstNS(_fbb, _o->refer_to_a1.get(), _rehasher) : 0;
auto _refer_to_a2 = _o->refer_to_a2 ? CreateSecondTableInA(_fbb, _o->refer_to_a2.get(), _rehasher) : 0; auto _refer_to_a2 = _o->refer_to_a2 ? CreateSecondTableInA(_fbb, _o->refer_to_a2.get(), _rehasher) : 0;
return NamespaceC::CreateTableInC( return NamespaceC::CreateTableInC(
@@ -502,41 +502,41 @@ inline SecondTableInAT &SecondTableInAT::operator=(SecondTableInAT o) FLATBUFFER
return *this; return *this;
} }
inline SecondTableInAT *SecondTableInA::UnPack(const flatbuffers::resolver_function_t *_resolver) const { inline SecondTableInAT *SecondTableInA::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
auto _o = std::unique_ptr<SecondTableInAT>(new SecondTableInAT()); auto _o = std::unique_ptr<SecondTableInAT>(new SecondTableInAT());
UnPackTo(_o.get(), _resolver); UnPackTo(_o.get(), _resolver);
return _o.release(); return _o.release();
} }
inline void SecondTableInA::UnPackTo(SecondTableInAT *_o, const flatbuffers::resolver_function_t *_resolver) const { inline void SecondTableInA::UnPackTo(SecondTableInAT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
(void)_o; (void)_o;
(void)_resolver; (void)_resolver;
{ auto _e = refer_to_c(); if (_e) { if(_o->refer_to_c) { _e->UnPackTo(_o->refer_to_c.get(), _resolver); } else { _o->refer_to_c = flatbuffers::unique_ptr<NamespaceC::TableInCT>(_e->UnPack(_resolver)); } } else if (_o->refer_to_c) { _o->refer_to_c.reset(); } } { auto _e = refer_to_c(); if (_e) { if(_o->refer_to_c) { _e->UnPackTo(_o->refer_to_c.get(), _resolver); } else { _o->refer_to_c = flatbuffers::unique_ptr<NamespaceC::TableInCT>(_e->UnPack(_resolver)); } } else if (_o->refer_to_c) { _o->refer_to_c.reset(); } }
} }
inline flatbuffers::Offset<SecondTableInA> SecondTableInA::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SecondTableInAT* _o, const flatbuffers::rehasher_function_t *_rehasher) { inline ::flatbuffers::Offset<SecondTableInA> SecondTableInA::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SecondTableInAT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateSecondTableInA(_fbb, _o, _rehasher); return CreateSecondTableInA(_fbb, _o, _rehasher);
} }
inline flatbuffers::Offset<SecondTableInA> CreateSecondTableInA(flatbuffers::FlatBufferBuilder &_fbb, const SecondTableInAT *_o, const flatbuffers::rehasher_function_t *_rehasher) { inline ::flatbuffers::Offset<SecondTableInA> CreateSecondTableInA(::flatbuffers::FlatBufferBuilder &_fbb, const SecondTableInAT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher; (void)_rehasher;
(void)_o; (void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SecondTableInAT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const SecondTableInAT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _refer_to_c = _o->refer_to_c ? CreateTableInC(_fbb, _o->refer_to_c.get(), _rehasher) : 0; auto _refer_to_c = _o->refer_to_c ? CreateTableInC(_fbb, _o->refer_to_c.get(), _rehasher) : 0;
return NamespaceA::CreateSecondTableInA( return NamespaceA::CreateSecondTableInA(
_fbb, _fbb,
_refer_to_c); _refer_to_c);
} }
inline const flatbuffers::TypeTable *TableInFirstNSTypeTable() { inline const ::flatbuffers::TypeTable *TableInFirstNSTypeTable() {
static const flatbuffers::TypeCode type_codes[] = { static const ::flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_SEQUENCE, 0, 0 }, { ::flatbuffers::ET_SEQUENCE, 0, 0 },
{ flatbuffers::ET_CHAR, 0, 1 }, { ::flatbuffers::ET_CHAR, 0, 1 },
{ flatbuffers::ET_UTYPE, 0, 2 }, { ::flatbuffers::ET_UTYPE, 0, 2 },
{ flatbuffers::ET_SEQUENCE, 0, 2 }, { ::flatbuffers::ET_SEQUENCE, 0, 2 },
{ flatbuffers::ET_SEQUENCE, 0, 3 } { ::flatbuffers::ET_SEQUENCE, 0, 3 }
}; };
static const flatbuffers::TypeFunction type_refs[] = { static const ::flatbuffers::TypeFunction type_refs[] = {
NamespaceA::NamespaceB::TableInNestedNSTypeTable, NamespaceA::NamespaceB::TableInNestedNSTypeTable,
NamespaceA::NamespaceB::EnumInNestedNSTypeTable, NamespaceA::NamespaceB::EnumInNestedNSTypeTable,
NamespaceA::NamespaceB::UnionInNestedNSTypeTable, NamespaceA::NamespaceB::UnionInNestedNSTypeTable,
@@ -549,8 +549,8 @@ inline const flatbuffers::TypeTable *TableInFirstNSTypeTable() {
"foo_union", "foo_union",
"foo_struct" "foo_struct"
}; };
static const flatbuffers::TypeTable tt = { static const ::flatbuffers::TypeTable tt = {
flatbuffers::ST_TABLE, 5, type_codes, type_refs, nullptr, nullptr, names ::flatbuffers::ST_TABLE, 5, type_codes, type_refs, nullptr, nullptr, names
}; };
return &tt; return &tt;
} }
@@ -559,12 +559,12 @@ inline const flatbuffers::TypeTable *TableInFirstNSTypeTable() {
namespace NamespaceC { namespace NamespaceC {
inline const flatbuffers::TypeTable *TableInCTypeTable() { inline const ::flatbuffers::TypeTable *TableInCTypeTable() {
static const flatbuffers::TypeCode type_codes[] = { static const ::flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_SEQUENCE, 0, 0 }, { ::flatbuffers::ET_SEQUENCE, 0, 0 },
{ flatbuffers::ET_SEQUENCE, 0, 1 } { ::flatbuffers::ET_SEQUENCE, 0, 1 }
}; };
static const flatbuffers::TypeFunction type_refs[] = { static const ::flatbuffers::TypeFunction type_refs[] = {
NamespaceA::TableInFirstNSTypeTable, NamespaceA::TableInFirstNSTypeTable,
NamespaceA::SecondTableInATypeTable NamespaceA::SecondTableInATypeTable
}; };
@@ -572,8 +572,8 @@ inline const flatbuffers::TypeTable *TableInCTypeTable() {
"refer_to_a1", "refer_to_a1",
"refer_to_a2" "refer_to_a2"
}; };
static const flatbuffers::TypeTable tt = { static const ::flatbuffers::TypeTable tt = {
flatbuffers::ST_TABLE, 2, type_codes, type_refs, nullptr, nullptr, names ::flatbuffers::ST_TABLE, 2, type_codes, type_refs, nullptr, nullptr, names
}; };
return &tt; return &tt;
} }
@@ -582,18 +582,18 @@ inline const flatbuffers::TypeTable *TableInCTypeTable() {
namespace NamespaceA { namespace NamespaceA {
inline const flatbuffers::TypeTable *SecondTableInATypeTable() { inline const ::flatbuffers::TypeTable *SecondTableInATypeTable() {
static const flatbuffers::TypeCode type_codes[] = { static const ::flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_SEQUENCE, 0, 0 } { ::flatbuffers::ET_SEQUENCE, 0, 0 }
}; };
static const flatbuffers::TypeFunction type_refs[] = { static const ::flatbuffers::TypeFunction type_refs[] = {
NamespaceC::TableInCTypeTable NamespaceC::TableInCTypeTable
}; };
static const char * const names[] = { static const char * const names[] = {
"refer_to_c" "refer_to_c"
}; };
static const flatbuffers::TypeTable tt = { static const ::flatbuffers::TypeTable tt = {
flatbuffers::ST_TABLE, 1, type_codes, type_refs, nullptr, nullptr, names ::flatbuffers::ST_TABLE, 1, type_codes, type_refs, nullptr, nullptr, names
}; };
return &tt; return &tt;
} }

130
tests/native_inline_table_test_generated.h
View File

@@ -26,19 +26,19 @@ bool operator!=(const NativeInlineTableT &lhs, const NativeInlineTableT &rhs);
bool operator==(const TestNativeInlineTableT &lhs, const TestNativeInlineTableT &rhs); bool operator==(const TestNativeInlineTableT &lhs, const TestNativeInlineTableT &rhs);
bool operator!=(const TestNativeInlineTableT &lhs, const TestNativeInlineTableT &rhs); bool operator!=(const TestNativeInlineTableT &lhs, const TestNativeInlineTableT &rhs);
inline const flatbuffers::TypeTable *NativeInlineTableTypeTable(); inline const ::flatbuffers::TypeTable *NativeInlineTableTypeTable();
inline const flatbuffers::TypeTable *TestNativeInlineTableTypeTable(); inline const ::flatbuffers::TypeTable *TestNativeInlineTableTypeTable();
struct NativeInlineTableT : public flatbuffers::NativeTable { struct NativeInlineTableT : public ::flatbuffers::NativeTable {
typedef NativeInlineTable TableType; typedef NativeInlineTable TableType;
int32_t a = 0; int32_t a = 0;
}; };
struct NativeInlineTable FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { struct NativeInlineTable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef NativeInlineTableT NativeTableType; typedef NativeInlineTableT NativeTableType;
typedef NativeInlineTableBuilder Builder; typedef NativeInlineTableBuilder Builder;
static const flatbuffers::TypeTable *MiniReflectTypeTable() { static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return NativeInlineTableTypeTable(); return NativeInlineTableTypeTable();
} }
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
@@ -50,112 +50,112 @@ struct NativeInlineTable FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool mutate_a(int32_t _a = 0) { bool mutate_a(int32_t _a = 0) {
return SetField<int32_t>(VT_A, _a, 0); return SetField<int32_t>(VT_A, _a, 0);
} }
bool Verify(flatbuffers::Verifier &verifier) const { bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) && return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_A, 4) && VerifyField<int32_t>(verifier, VT_A, 4) &&
verifier.EndTable(); verifier.EndTable();
} }
NativeInlineTableT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; NativeInlineTableT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(NativeInlineTableT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; void UnPackTo(NativeInlineTableT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<NativeInlineTable> Pack(flatbuffers::FlatBufferBuilder &_fbb, const NativeInlineTableT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); static ::flatbuffers::Offset<NativeInlineTable> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const NativeInlineTableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
}; };
struct NativeInlineTableBuilder { struct NativeInlineTableBuilder {
typedef NativeInlineTable Table; typedef NativeInlineTable Table;
flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_; ::flatbuffers::uoffset_t start_;
void add_a(int32_t a) { void add_a(int32_t a) {
fbb_.AddElement<int32_t>(NativeInlineTable::VT_A, a, 0); fbb_.AddElement<int32_t>(NativeInlineTable::VT_A, a, 0);
} }
explicit NativeInlineTableBuilder(flatbuffers::FlatBufferBuilder &_fbb) explicit NativeInlineTableBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) { : fbb_(_fbb) {
start_ = fbb_.StartTable(); start_ = fbb_.StartTable();
} }
flatbuffers::Offset<NativeInlineTable> Finish() { ::flatbuffers::Offset<NativeInlineTable> Finish() {
const auto end = fbb_.EndTable(start_); const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<NativeInlineTable>(end); auto o = ::flatbuffers::Offset<NativeInlineTable>(end);
return o; return o;
} }
}; };
inline flatbuffers::Offset<NativeInlineTable> CreateNativeInlineTable( inline ::flatbuffers::Offset<NativeInlineTable> CreateNativeInlineTable(
flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::FlatBufferBuilder &_fbb,
int32_t a = 0) { int32_t a = 0) {
NativeInlineTableBuilder builder_(_fbb); NativeInlineTableBuilder builder_(_fbb);
builder_.add_a(a); builder_.add_a(a);
return builder_.Finish(); return builder_.Finish();
} }
flatbuffers::Offset<NativeInlineTable> CreateNativeInlineTable(flatbuffers::FlatBufferBuilder &_fbb, const NativeInlineTableT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); ::flatbuffers::Offset<NativeInlineTable> CreateNativeInlineTable(::flatbuffers::FlatBufferBuilder &_fbb, const NativeInlineTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct TestNativeInlineTableT : public flatbuffers::NativeTable { struct TestNativeInlineTableT : public ::flatbuffers::NativeTable {
typedef TestNativeInlineTable TableType; typedef TestNativeInlineTable TableType;
std::vector<NativeInlineTableT> t{}; std::vector<NativeInlineTableT> t{};
}; };
struct TestNativeInlineTable FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { struct TestNativeInlineTable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef TestNativeInlineTableT NativeTableType; typedef TestNativeInlineTableT NativeTableType;
typedef TestNativeInlineTableBuilder Builder; typedef TestNativeInlineTableBuilder Builder;
static const flatbuffers::TypeTable *MiniReflectTypeTable() { static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return TestNativeInlineTableTypeTable(); return TestNativeInlineTableTypeTable();
} }
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_T = 4 VT_T = 4
}; };
const flatbuffers::Vector<flatbuffers::Offset<NativeInlineTable>> *t() const { const ::flatbuffers::Vector<::flatbuffers::Offset<NativeInlineTable>> *t() const {
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<NativeInlineTable>> *>(VT_T); return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<NativeInlineTable>> *>(VT_T);
} }
flatbuffers::Vector<flatbuffers::Offset<NativeInlineTable>> *mutable_t() { ::flatbuffers::Vector<::flatbuffers::Offset<NativeInlineTable>> *mutable_t() {
return GetPointer<flatbuffers::Vector<flatbuffers::Offset<NativeInlineTable>> *>(VT_T); return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<NativeInlineTable>> *>(VT_T);
} }
bool Verify(flatbuffers::Verifier &verifier) const { bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) && return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_T) && VerifyOffset(verifier, VT_T) &&
verifier.VerifyVector(t()) && verifier.VerifyVector(t()) &&
verifier.VerifyVectorOfTables(t()) && verifier.VerifyVectorOfTables(t()) &&
verifier.EndTable(); verifier.EndTable();
} }
TestNativeInlineTableT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; TestNativeInlineTableT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(TestNativeInlineTableT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; void UnPackTo(TestNativeInlineTableT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<TestNativeInlineTable> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TestNativeInlineTableT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); static ::flatbuffers::Offset<TestNativeInlineTable> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const TestNativeInlineTableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
}; };
struct TestNativeInlineTableBuilder { struct TestNativeInlineTableBuilder {
typedef TestNativeInlineTable Table; typedef TestNativeInlineTable Table;
flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_; ::flatbuffers::uoffset_t start_;
void add_t(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<NativeInlineTable>>> t) { void add_t(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<NativeInlineTable>>> t) {
fbb_.AddOffset(TestNativeInlineTable::VT_T, t); fbb_.AddOffset(TestNativeInlineTable::VT_T, t);
} }
explicit TestNativeInlineTableBuilder(flatbuffers::FlatBufferBuilder &_fbb) explicit TestNativeInlineTableBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) { : fbb_(_fbb) {
start_ = fbb_.StartTable(); start_ = fbb_.StartTable();
} }
flatbuffers::Offset<TestNativeInlineTable> Finish() { ::flatbuffers::Offset<TestNativeInlineTable> Finish() {
const auto end = fbb_.EndTable(start_); const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<TestNativeInlineTable>(end); auto o = ::flatbuffers::Offset<TestNativeInlineTable>(end);
return o; return o;
} }
}; };
inline flatbuffers::Offset<TestNativeInlineTable> CreateTestNativeInlineTable( inline ::flatbuffers::Offset<TestNativeInlineTable> CreateTestNativeInlineTable(
flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<NativeInlineTable>>> t = 0) { ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<NativeInlineTable>>> t = 0) {
TestNativeInlineTableBuilder builder_(_fbb); TestNativeInlineTableBuilder builder_(_fbb);
builder_.add_t(t); builder_.add_t(t);
return builder_.Finish(); return builder_.Finish();
} }
inline flatbuffers::Offset<TestNativeInlineTable> CreateTestNativeInlineTableDirect( inline ::flatbuffers::Offset<TestNativeInlineTable> CreateTestNativeInlineTableDirect(
flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<flatbuffers::Offset<NativeInlineTable>> *t = nullptr) { const std::vector<::flatbuffers::Offset<NativeInlineTable>> *t = nullptr) {
auto t__ = t ? _fbb.CreateVector<flatbuffers::Offset<NativeInlineTable>>(*t) : 0; auto t__ = t ? _fbb.CreateVector<::flatbuffers::Offset<NativeInlineTable>>(*t) : 0;
return CreateTestNativeInlineTable( return CreateTestNativeInlineTable(
_fbb, _fbb,
t__); t__);
} }
flatbuffers::Offset<TestNativeInlineTable> CreateTestNativeInlineTable(flatbuffers::FlatBufferBuilder &_fbb, const TestNativeInlineTableT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); ::flatbuffers::Offset<TestNativeInlineTable> CreateTestNativeInlineTable(::flatbuffers::FlatBufferBuilder &_fbb, const TestNativeInlineTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
inline bool operator==(const NativeInlineTableT &lhs, const NativeInlineTableT &rhs) { inline bool operator==(const NativeInlineTableT &lhs, const NativeInlineTableT &rhs) {
@@ -168,26 +168,26 @@ inline bool operator!=(const NativeInlineTableT &lhs, const NativeInlineTableT &
} }
inline NativeInlineTableT *NativeInlineTable::UnPack(const flatbuffers::resolver_function_t *_resolver) const { inline NativeInlineTableT *NativeInlineTable::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
auto _o = std::unique_ptr<NativeInlineTableT>(new NativeInlineTableT()); auto _o = std::unique_ptr<NativeInlineTableT>(new NativeInlineTableT());
UnPackTo(_o.get(), _resolver); UnPackTo(_o.get(), _resolver);
return _o.release(); return _o.release();
} }
inline void NativeInlineTable::UnPackTo(NativeInlineTableT *_o, const flatbuffers::resolver_function_t *_resolver) const { inline void NativeInlineTable::UnPackTo(NativeInlineTableT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
(void)_o; (void)_o;
(void)_resolver; (void)_resolver;
{ auto _e = a(); _o->a = _e; } { auto _e = a(); _o->a = _e; }
} }
inline flatbuffers::Offset<NativeInlineTable> NativeInlineTable::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NativeInlineTableT* _o, const flatbuffers::rehasher_function_t *_rehasher) { inline ::flatbuffers::Offset<NativeInlineTable> NativeInlineTable::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const NativeInlineTableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateNativeInlineTable(_fbb, _o, _rehasher); return CreateNativeInlineTable(_fbb, _o, _rehasher);
} }
inline flatbuffers::Offset<NativeInlineTable> CreateNativeInlineTable(flatbuffers::FlatBufferBuilder &_fbb, const NativeInlineTableT *_o, const flatbuffers::rehasher_function_t *_rehasher) { inline ::flatbuffers::Offset<NativeInlineTable> CreateNativeInlineTable(::flatbuffers::FlatBufferBuilder &_fbb, const NativeInlineTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher; (void)_rehasher;
(void)_o; (void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const NativeInlineTableT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const NativeInlineTableT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _a = _o->a; auto _a = _o->a;
return CreateNativeInlineTable( return CreateNativeInlineTable(
_fbb, _fbb,
@@ -205,57 +205,57 @@ inline bool operator!=(const TestNativeInlineTableT &lhs, const TestNativeInline
} }
inline TestNativeInlineTableT *TestNativeInlineTable::UnPack(const flatbuffers::resolver_function_t *_resolver) const { inline TestNativeInlineTableT *TestNativeInlineTable::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
auto _o = std::unique_ptr<TestNativeInlineTableT>(new TestNativeInlineTableT()); auto _o = std::unique_ptr<TestNativeInlineTableT>(new TestNativeInlineTableT());
UnPackTo(_o.get(), _resolver); UnPackTo(_o.get(), _resolver);
return _o.release(); return _o.release();
} }
inline void TestNativeInlineTable::UnPackTo(TestNativeInlineTableT *_o, const flatbuffers::resolver_function_t *_resolver) const { inline void TestNativeInlineTable::UnPackTo(TestNativeInlineTableT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
(void)_o; (void)_o;
(void)_resolver; (void)_resolver;
{ auto _e = t(); if (_e) { _o->t.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->t[_i] = *flatbuffers::unique_ptr<NativeInlineTableT>(_e->Get(_i)->UnPack(_resolver)); } } else { _o->t.resize(0); } } { auto _e = t(); if (_e) { _o->t.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->t[_i] = *flatbuffers::unique_ptr<NativeInlineTableT>(_e->Get(_i)->UnPack(_resolver)); } } else { _o->t.resize(0); } }
} }
inline flatbuffers::Offset<TestNativeInlineTable> TestNativeInlineTable::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TestNativeInlineTableT* _o, const flatbuffers::rehasher_function_t *_rehasher) { inline ::flatbuffers::Offset<TestNativeInlineTable> TestNativeInlineTable::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const TestNativeInlineTableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateTestNativeInlineTable(_fbb, _o, _rehasher); return CreateTestNativeInlineTable(_fbb, _o, _rehasher);
} }
inline flatbuffers::Offset<TestNativeInlineTable> CreateTestNativeInlineTable(flatbuffers::FlatBufferBuilder &_fbb, const TestNativeInlineTableT *_o, const flatbuffers::rehasher_function_t *_rehasher) { inline ::flatbuffers::Offset<TestNativeInlineTable> CreateTestNativeInlineTable(::flatbuffers::FlatBufferBuilder &_fbb, const TestNativeInlineTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher; (void)_rehasher;
(void)_o; (void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TestNativeInlineTableT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const TestNativeInlineTableT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _t = _o->t.size() ? _fbb.CreateVector<flatbuffers::Offset<NativeInlineTable>> (_o->t.size(), [](size_t i, _VectorArgs *__va) { return CreateNativeInlineTable(*__va->__fbb, &(__va->__o->t[i]), __va->__rehasher); }, &_va ) : 0; auto _t = _o->t.size() ? _fbb.CreateVector<::flatbuffers::Offset<NativeInlineTable>> (_o->t.size(), [](size_t i, _VectorArgs *__va) { return CreateNativeInlineTable(*__va->__fbb, &(__va->__o->t[i]), __va->__rehasher); }, &_va ) : 0;
return CreateTestNativeInlineTable( return CreateTestNativeInlineTable(
_fbb, _fbb,
_t); _t);
} }
inline const flatbuffers::TypeTable *NativeInlineTableTypeTable() { inline const ::flatbuffers::TypeTable *NativeInlineTableTypeTable() {
static const flatbuffers::TypeCode type_codes[] = { static const ::flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_INT, 0, -1 } { ::flatbuffers::ET_INT, 0, -1 }
}; };
static const char * const names[] = { static const char * const names[] = {
"a" "a"
}; };
static const flatbuffers::TypeTable tt = { static const ::flatbuffers::TypeTable tt = {
flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names ::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
}; };
return &tt; return &tt;
} }
inline const flatbuffers::TypeTable *TestNativeInlineTableTypeTable() { inline const ::flatbuffers::TypeTable *TestNativeInlineTableTypeTable() {
static const flatbuffers::TypeCode type_codes[] = { static const ::flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_SEQUENCE, 1, 0 } { ::flatbuffers::ET_SEQUENCE, 1, 0 }
}; };
static const flatbuffers::TypeFunction type_refs[] = { static const ::flatbuffers::TypeFunction type_refs[] = {
NativeInlineTableTypeTable NativeInlineTableTypeTable
}; };
static const char * const names[] = { static const char * const names[] = {
"t" "t"
}; };
static const flatbuffers::TypeTable tt = { static const ::flatbuffers::TypeTable tt = {
flatbuffers::ST_TABLE, 1, type_codes, type_refs, nullptr, nullptr, names ::flatbuffers::ST_TABLE, 1, type_codes, type_refs, nullptr, nullptr, names
}; };
return &tt; return &tt;
} }

186
tests/native_type_test_generated.h
View File

@@ -25,11 +25,11 @@ struct ApplicationData;
struct ApplicationDataBuilder; struct ApplicationDataBuilder;
struct ApplicationDataT; struct ApplicationDataT;
inline const flatbuffers::TypeTable *Vector3DTypeTable(); inline const ::flatbuffers::TypeTable *Vector3DTypeTable();
inline const flatbuffers::TypeTable *Vector3DAltTypeTable(); inline const ::flatbuffers::TypeTable *Vector3DAltTypeTable();
inline const flatbuffers::TypeTable *ApplicationDataTypeTable(); inline const ::flatbuffers::TypeTable *ApplicationDataTypeTable();
FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Vector3D FLATBUFFERS_FINAL_CLASS { FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Vector3D FLATBUFFERS_FINAL_CLASS {
private: private:
@@ -38,7 +38,7 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Vector3D FLATBUFFERS_FINAL_CLASS {
float z_; float z_;
public: public:
static const flatbuffers::TypeTable *MiniReflectTypeTable() { static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return Vector3DTypeTable(); return Vector3DTypeTable();
} }
Vector3D() Vector3D()
@@ -47,27 +47,27 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Vector3D FLATBUFFERS_FINAL_CLASS {
z_(0) { z_(0) {
} }
Vector3D(float _x, float _y, float _z) Vector3D(float _x, float _y, float _z)
: x_(flatbuffers::EndianScalar(_x)), : x_(::flatbuffers::EndianScalar(_x)),
y_(flatbuffers::EndianScalar(_y)), y_(::flatbuffers::EndianScalar(_y)),
z_(flatbuffers::EndianScalar(_z)) { z_(::flatbuffers::EndianScalar(_z)) {
} }
float x() const { float x() const {
return flatbuffers::EndianScalar(x_); return ::flatbuffers::EndianScalar(x_);
} }
void mutate_x(float _x) { void mutate_x(float _x) {
flatbuffers::WriteScalar(&x_, _x); ::flatbuffers::WriteScalar(&x_, _x);
} }
float y() const { float y() const {
return flatbuffers::EndianScalar(y_); return ::flatbuffers::EndianScalar(y_);
} }
void mutate_y(float _y) { void mutate_y(float _y) {
flatbuffers::WriteScalar(&y_, _y); ::flatbuffers::WriteScalar(&y_, _y);
} }
float z() const { float z() const {
return flatbuffers::EndianScalar(z_); return ::flatbuffers::EndianScalar(z_);
} }
void mutate_z(float _z) { void mutate_z(float _z) {
flatbuffers::WriteScalar(&z_, _z); ::flatbuffers::WriteScalar(&z_, _z);
} }
}; };
FLATBUFFERS_STRUCT_END(Vector3D, 12); FLATBUFFERS_STRUCT_END(Vector3D, 12);
@@ -79,7 +79,7 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Vector3DAlt FLATBUFFERS_FINAL_CLASS {
float c_; float c_;
public: public:
static const flatbuffers::TypeTable *MiniReflectTypeTable() { static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return Vector3DAltTypeTable(); return Vector3DAltTypeTable();
} }
Vector3DAlt() Vector3DAlt()
@@ -88,60 +88,60 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Vector3DAlt FLATBUFFERS_FINAL_CLASS {
c_(0) { c_(0) {
} }
Vector3DAlt(float _a, float _b, float _c) Vector3DAlt(float _a, float _b, float _c)
: a_(flatbuffers::EndianScalar(_a)), : a_(::flatbuffers::EndianScalar(_a)),
b_(flatbuffers::EndianScalar(_b)), b_(::flatbuffers::EndianScalar(_b)),
c_(flatbuffers::EndianScalar(_c)) { c_(::flatbuffers::EndianScalar(_c)) {
} }
float a() const { float a() const {
return flatbuffers::EndianScalar(a_); return ::flatbuffers::EndianScalar(a_);
} }
void mutate_a(float _a) { void mutate_a(float _a) {
flatbuffers::WriteScalar(&a_, _a); ::flatbuffers::WriteScalar(&a_, _a);
} }
float b() const { float b() const {
return flatbuffers::EndianScalar(b_); return ::flatbuffers::EndianScalar(b_);
} }
void mutate_b(float _b) { void mutate_b(float _b) {
flatbuffers::WriteScalar(&b_, _b); ::flatbuffers::WriteScalar(&b_, _b);
} }
float c() const { float c() const {
return flatbuffers::EndianScalar(c_); return ::flatbuffers::EndianScalar(c_);
} }
void mutate_c(float _c) { void mutate_c(float _c) {
flatbuffers::WriteScalar(&c_, _c); ::flatbuffers::WriteScalar(&c_, _c);
} }
}; };
FLATBUFFERS_STRUCT_END(Vector3DAlt, 12); FLATBUFFERS_STRUCT_END(Vector3DAlt, 12);
struct ApplicationDataT : public flatbuffers::NativeTable { struct ApplicationDataT : public ::flatbuffers::NativeTable {
typedef ApplicationData TableType; typedef ApplicationData TableType;
std::vector<Native::Vector3D> vectors{}; std::vector<Native::Vector3D> vectors{};
std::vector<Native::Vector3D> vectors_alt{}; std::vector<Native::Vector3D> vectors_alt{};
}; };
struct ApplicationData FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { struct ApplicationData FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef ApplicationDataT NativeTableType; typedef ApplicationDataT NativeTableType;
typedef ApplicationDataBuilder Builder; typedef ApplicationDataBuilder Builder;
static const flatbuffers::TypeTable *MiniReflectTypeTable() { static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return ApplicationDataTypeTable(); return ApplicationDataTypeTable();
} }
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_VECTORS = 4, VT_VECTORS = 4,
VT_VECTORS_ALT = 6 VT_VECTORS_ALT = 6
}; };
const flatbuffers::Vector<const Geometry::Vector3D *> *vectors() const { const ::flatbuffers::Vector<const Geometry::Vector3D *> *vectors() const {
return GetPointer<const flatbuffers::Vector<const Geometry::Vector3D *> *>(VT_VECTORS); return GetPointer<const ::flatbuffers::Vector<const Geometry::Vector3D *> *>(VT_VECTORS);
} }
flatbuffers::Vector<const Geometry::Vector3D *> *mutable_vectors() { ::flatbuffers::Vector<const Geometry::Vector3D *> *mutable_vectors() {
return GetPointer<flatbuffers::Vector<const Geometry::Vector3D *> *>(VT_VECTORS); return GetPointer<::flatbuffers::Vector<const Geometry::Vector3D *> *>(VT_VECTORS);
} }
const flatbuffers::Vector<const Geometry::Vector3DAlt *> *vectors_alt() const { const ::flatbuffers::Vector<const Geometry::Vector3DAlt *> *vectors_alt() const {
return GetPointer<const flatbuffers::Vector<const Geometry::Vector3DAlt *> *>(VT_VECTORS_ALT); return GetPointer<const ::flatbuffers::Vector<const Geometry::Vector3DAlt *> *>(VT_VECTORS_ALT);
} }
flatbuffers::Vector<const Geometry::Vector3DAlt *> *mutable_vectors_alt() { ::flatbuffers::Vector<const Geometry::Vector3DAlt *> *mutable_vectors_alt() {
return GetPointer<flatbuffers::Vector<const Geometry::Vector3DAlt *> *>(VT_VECTORS_ALT); return GetPointer<::flatbuffers::Vector<const Geometry::Vector3DAlt *> *>(VT_VECTORS_ALT);
} }
bool Verify(flatbuffers::Verifier &verifier) const { bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) && return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_VECTORS) && VerifyOffset(verifier, VT_VECTORS) &&
verifier.VerifyVector(vectors()) && verifier.VerifyVector(vectors()) &&
@@ -149,44 +149,44 @@ struct ApplicationData FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
verifier.VerifyVector(vectors_alt()) && verifier.VerifyVector(vectors_alt()) &&
verifier.EndTable(); verifier.EndTable();
} }
ApplicationDataT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; ApplicationDataT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(ApplicationDataT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; void UnPackTo(ApplicationDataT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<ApplicationData> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ApplicationDataT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); static ::flatbuffers::Offset<ApplicationData> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ApplicationDataT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
}; };
struct ApplicationDataBuilder { struct ApplicationDataBuilder {
typedef ApplicationData Table; typedef ApplicationData Table;
flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_; ::flatbuffers::uoffset_t start_;
void add_vectors(flatbuffers::Offset<flatbuffers::Vector<const Geometry::Vector3D *>> vectors) { void add_vectors(::flatbuffers::Offset<::flatbuffers::Vector<const Geometry::Vector3D *>> vectors) {
fbb_.AddOffset(ApplicationData::VT_VECTORS, vectors); fbb_.AddOffset(ApplicationData::VT_VECTORS, vectors);
} }
void add_vectors_alt(flatbuffers::Offset<flatbuffers::Vector<const Geometry::Vector3DAlt *>> vectors_alt) { void add_vectors_alt(::flatbuffers::Offset<::flatbuffers::Vector<const Geometry::Vector3DAlt *>> vectors_alt) {
fbb_.AddOffset(ApplicationData::VT_VECTORS_ALT, vectors_alt); fbb_.AddOffset(ApplicationData::VT_VECTORS_ALT, vectors_alt);
} }
explicit ApplicationDataBuilder(flatbuffers::FlatBufferBuilder &_fbb) explicit ApplicationDataBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) { : fbb_(_fbb) {
start_ = fbb_.StartTable(); start_ = fbb_.StartTable();
} }
flatbuffers::Offset<ApplicationData> Finish() { ::flatbuffers::Offset<ApplicationData> Finish() {
const auto end = fbb_.EndTable(start_); const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<ApplicationData>(end); auto o = ::flatbuffers::Offset<ApplicationData>(end);
return o; return o;
} }
}; };
inline flatbuffers::Offset<ApplicationData> CreateApplicationData( inline ::flatbuffers::Offset<ApplicationData> CreateApplicationData(
flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<flatbuffers::Vector<const Geometry::Vector3D *>> vectors = 0, ::flatbuffers::Offset<::flatbuffers::Vector<const Geometry::Vector3D *>> vectors = 0,
flatbuffers::Offset<flatbuffers::Vector<const Geometry::Vector3DAlt *>> vectors_alt = 0) { ::flatbuffers::Offset<::flatbuffers::Vector<const Geometry::Vector3DAlt *>> vectors_alt = 0) {
ApplicationDataBuilder builder_(_fbb); ApplicationDataBuilder builder_(_fbb);
builder_.add_vectors_alt(vectors_alt); builder_.add_vectors_alt(vectors_alt);
builder_.add_vectors(vectors); builder_.add_vectors(vectors);
return builder_.Finish(); return builder_.Finish();
} }
inline flatbuffers::Offset<ApplicationData> CreateApplicationDataDirect( inline ::flatbuffers::Offset<ApplicationData> CreateApplicationDataDirect(
flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<Geometry::Vector3D> *vectors = nullptr, const std::vector<Geometry::Vector3D> *vectors = nullptr,
const std::vector<Geometry::Vector3DAlt> *vectors_alt = nullptr) { const std::vector<Geometry::Vector3DAlt> *vectors_alt = nullptr) {
auto vectors__ = vectors ? _fbb.CreateVectorOfStructs<Geometry::Vector3D>(*vectors) : 0; auto vectors__ = vectors ? _fbb.CreateVectorOfStructs<Geometry::Vector3D>(*vectors) : 0;
@@ -197,42 +197,42 @@ inline flatbuffers::Offset<ApplicationData> CreateApplicationDataDirect(
vectors_alt__); vectors_alt__);
} }
flatbuffers::Offset<ApplicationData> CreateApplicationData(flatbuffers::FlatBufferBuilder &_fbb, const ApplicationDataT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); ::flatbuffers::Offset<ApplicationData> CreateApplicationData(::flatbuffers::FlatBufferBuilder &_fbb, const ApplicationDataT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
inline ApplicationDataT *ApplicationData::UnPack(const flatbuffers::resolver_function_t *_resolver) const { inline ApplicationDataT *ApplicationData::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
auto _o = std::unique_ptr<ApplicationDataT>(new ApplicationDataT()); auto _o = std::unique_ptr<ApplicationDataT>(new ApplicationDataT());
UnPackTo(_o.get(), _resolver); UnPackTo(_o.get(), _resolver);
return _o.release(); return _o.release();
} }
inline void ApplicationData::UnPackTo(ApplicationDataT *_o, const flatbuffers::resolver_function_t *_resolver) const { inline void ApplicationData::UnPackTo(ApplicationDataT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
(void)_o; (void)_o;
(void)_resolver; (void)_resolver;
{ auto _e = vectors(); if (_e) { _o->vectors.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->vectors[_i] = flatbuffers::UnPack(*_e->Get(_i)); } } else { _o->vectors.resize(0); } } { auto _e = vectors(); if (_e) { _o->vectors.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->vectors[_i] = ::flatbuffers::UnPack(*_e->Get(_i)); } } else { _o->vectors.resize(0); } }
{ auto _e = vectors_alt(); if (_e) { _o->vectors_alt.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->vectors_alt[_i] = flatbuffers::UnPackVector3DAlt(*_e->Get(_i)); } } else { _o->vectors_alt.resize(0); } } { auto _e = vectors_alt(); if (_e) { _o->vectors_alt.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->vectors_alt[_i] = ::flatbuffers::UnPackVector3DAlt(*_e->Get(_i)); } } else { _o->vectors_alt.resize(0); } }
} }
inline flatbuffers::Offset<ApplicationData> ApplicationData::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ApplicationDataT* _o, const flatbuffers::rehasher_function_t *_rehasher) { inline ::flatbuffers::Offset<ApplicationData> ApplicationData::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ApplicationDataT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
return CreateApplicationData(_fbb, _o, _rehasher); return CreateApplicationData(_fbb, _o, _rehasher);
} }
inline flatbuffers::Offset<ApplicationData> CreateApplicationData(flatbuffers::FlatBufferBuilder &_fbb, const ApplicationDataT *_o, const flatbuffers::rehasher_function_t *_rehasher) { inline ::flatbuffers::Offset<ApplicationData> CreateApplicationData(::flatbuffers::FlatBufferBuilder &_fbb, const ApplicationDataT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher; (void)_rehasher;
(void)_o; (void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ApplicationDataT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const ApplicationDataT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _vectors = _o->vectors.size() ? _fbb.CreateVectorOfNativeStructs<Geometry::Vector3D, Native::Vector3D>(_o->vectors) : 0; auto _vectors = _o->vectors.size() ? _fbb.CreateVectorOfNativeStructs<Geometry::Vector3D, Native::Vector3D>(_o->vectors) : 0;
auto _vectors_alt = _o->vectors_alt.size() ? _fbb.CreateVectorOfNativeStructs<Geometry::Vector3DAlt, Native::Vector3D>(_o->vectors_alt, flatbuffers::PackVector3DAlt) : 0; auto _vectors_alt = _o->vectors_alt.size() ? _fbb.CreateVectorOfNativeStructs<Geometry::Vector3DAlt, Native::Vector3D>(_o->vectors_alt, ::flatbuffers::PackVector3DAlt) : 0;
return Geometry::CreateApplicationData( return Geometry::CreateApplicationData(
_fbb, _fbb,
_vectors, _vectors,
_vectors_alt); _vectors_alt);
} }
inline const flatbuffers::TypeTable *Vector3DTypeTable() { inline const ::flatbuffers::TypeTable *Vector3DTypeTable() {
static const flatbuffers::TypeCode type_codes[] = { static const ::flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_FLOAT, 0, -1 }, { ::flatbuffers::ET_FLOAT, 0, -1 },
{ flatbuffers::ET_FLOAT, 0, -1 }, { ::flatbuffers::ET_FLOAT, 0, -1 },
{ flatbuffers::ET_FLOAT, 0, -1 } { ::flatbuffers::ET_FLOAT, 0, -1 }
}; };
static const int64_t values[] = { 0, 4, 8, 12 }; static const int64_t values[] = { 0, 4, 8, 12 };
static const char * const names[] = { static const char * const names[] = {
@@ -240,17 +240,17 @@ inline const flatbuffers::TypeTable *Vector3DTypeTable() {
"y", "y",
"z" "z"
}; };
static const flatbuffers::TypeTable tt = { static const ::flatbuffers::TypeTable tt = {
flatbuffers::ST_STRUCT, 3, type_codes, nullptr, nullptr, values, names ::flatbuffers::ST_STRUCT, 3, type_codes, nullptr, nullptr, values, names
}; };
return &tt; return &tt;
} }
inline const flatbuffers::TypeTable *Vector3DAltTypeTable() { inline const ::flatbuffers::TypeTable *Vector3DAltTypeTable() {
static const flatbuffers::TypeCode type_codes[] = { static const ::flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_FLOAT, 0, -1 }, { ::flatbuffers::ET_FLOAT, 0, -1 },
{ flatbuffers::ET_FLOAT, 0, -1 }, { ::flatbuffers::ET_FLOAT, 0, -1 },
{ flatbuffers::ET_FLOAT, 0, -1 } { ::flatbuffers::ET_FLOAT, 0, -1 }
}; };
static const int64_t values[] = { 0, 4, 8, 12 }; static const int64_t values[] = { 0, 4, 8, 12 };
static const char * const names[] = { static const char * const names[] = {
@@ -258,18 +258,18 @@ inline const flatbuffers::TypeTable *Vector3DAltTypeTable() {
"b", "b",
"c" "c"
}; };
static const flatbuffers::TypeTable tt = { static const ::flatbuffers::TypeTable tt = {
flatbuffers::ST_STRUCT, 3, type_codes, nullptr, nullptr, values, names ::flatbuffers::ST_STRUCT, 3, type_codes, nullptr, nullptr, values, names
}; };
return &tt; return &tt;
} }
inline const flatbuffers::TypeTable *ApplicationDataTypeTable() { inline const ::flatbuffers::TypeTable *ApplicationDataTypeTable() {
static const flatbuffers::TypeCode type_codes[] = { static const ::flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_SEQUENCE, 1, 0 }, { ::flatbuffers::ET_SEQUENCE, 1, 0 },
{ flatbuffers::ET_SEQUENCE, 1, 1 } { ::flatbuffers::ET_SEQUENCE, 1, 1 }
}; };
static const flatbuffers::TypeFunction type_refs[] = { static const ::flatbuffers::TypeFunction type_refs[] = {
Geometry::Vector3DTypeTable, Geometry::Vector3DTypeTable,
Geometry::Vector3DAltTypeTable Geometry::Vector3DAltTypeTable
}; };
@@ -277,59 +277,59 @@ inline const flatbuffers::TypeTable *ApplicationDataTypeTable() {
"vectors", "vectors",
"vectors_alt" "vectors_alt"
}; };
static const flatbuffers::TypeTable tt = { static const ::flatbuffers::TypeTable tt = {
flatbuffers::ST_TABLE, 2, type_codes, type_refs, nullptr, nullptr, names ::flatbuffers::ST_TABLE, 2, type_codes, type_refs, nullptr, nullptr, names
}; };
return &tt; return &tt;
} }
inline const Geometry::ApplicationData *GetApplicationData(const void *buf) { inline const Geometry::ApplicationData *GetApplicationData(const void *buf) {
return flatbuffers::GetRoot<Geometry::ApplicationData>(buf); return ::flatbuffers::GetRoot<Geometry::ApplicationData>(buf);
} }
inline const Geometry::ApplicationData *GetSizePrefixedApplicationData(const void *buf) { inline const Geometry::ApplicationData *GetSizePrefixedApplicationData(const void *buf) {
return flatbuffers::GetSizePrefixedRoot<Geometry::ApplicationData>(buf); return ::flatbuffers::GetSizePrefixedRoot<Geometry::ApplicationData>(buf);
} }
inline ApplicationData *GetMutableApplicationData(void *buf) { inline ApplicationData *GetMutableApplicationData(void *buf) {
return flatbuffers::GetMutableRoot<ApplicationData>(buf); return ::flatbuffers::GetMutableRoot<ApplicationData>(buf);
} }
inline Geometry::ApplicationData *GetMutableSizePrefixedApplicationData(void *buf) { inline Geometry::ApplicationData *GetMutableSizePrefixedApplicationData(void *buf) {
return flatbuffers::GetMutableSizePrefixedRoot<Geometry::ApplicationData>(buf); return ::flatbuffers::GetMutableSizePrefixedRoot<Geometry::ApplicationData>(buf);
} }
inline bool VerifyApplicationDataBuffer( inline bool VerifyApplicationDataBuffer(
flatbuffers::Verifier &verifier) { ::flatbuffers::Verifier &verifier) {
return verifier.VerifyBuffer<Geometry::ApplicationData>(nullptr); return verifier.VerifyBuffer<Geometry::ApplicationData>(nullptr);
} }
inline bool VerifySizePrefixedApplicationDataBuffer( inline bool VerifySizePrefixedApplicationDataBuffer(
flatbuffers::Verifier &verifier) { ::flatbuffers::Verifier &verifier) {
return verifier.VerifySizePrefixedBuffer<Geometry::ApplicationData>(nullptr); return verifier.VerifySizePrefixedBuffer<Geometry::ApplicationData>(nullptr);
} }
inline void FinishApplicationDataBuffer( inline void FinishApplicationDataBuffer(
flatbuffers::FlatBufferBuilder &fbb, ::flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<Geometry::ApplicationData> root) { ::flatbuffers::Offset<Geometry::ApplicationData> root) {
fbb.Finish(root); fbb.Finish(root);
} }
inline void FinishSizePrefixedApplicationDataBuffer( inline void FinishSizePrefixedApplicationDataBuffer(
flatbuffers::FlatBufferBuilder &fbb, ::flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<Geometry::ApplicationData> root) { ::flatbuffers::Offset<Geometry::ApplicationData> root) {
fbb.FinishSizePrefixed(root); fbb.FinishSizePrefixed(root);
} }
inline flatbuffers::unique_ptr<Geometry::ApplicationDataT> UnPackApplicationData( inline flatbuffers::unique_ptr<Geometry::ApplicationDataT> UnPackApplicationData(
const void *buf, const void *buf,
const flatbuffers::resolver_function_t *res = nullptr) { const ::flatbuffers::resolver_function_t *res = nullptr) {
return flatbuffers::unique_ptr<Geometry::ApplicationDataT>(GetApplicationData(buf)->UnPack(res)); return flatbuffers::unique_ptr<Geometry::ApplicationDataT>(GetApplicationData(buf)->UnPack(res));
} }
inline flatbuffers::unique_ptr<Geometry::ApplicationDataT> UnPackSizePrefixedApplicationData( inline flatbuffers::unique_ptr<Geometry::ApplicationDataT> UnPackSizePrefixedApplicationData(
const void *buf, const void *buf,
const flatbuffers::resolver_function_t *res = nullptr) { const ::flatbuffers::resolver_function_t *res = nullptr) {
return flatbuffers::unique_ptr<Geometry::ApplicationDataT>(GetSizePrefixedApplicationData(buf)->UnPack(res)); return flatbuffers::unique_ptr<Geometry::ApplicationDataT>(GetSizePrefixedApplicationData(buf)->UnPack(res));
} }

242
tests/optional_scalars_generated.h
View File

@@ -22,7 +22,7 @@ struct ScalarStuffT;
bool operator==(const ScalarStuffT &lhs, const ScalarStuffT &rhs); bool operator==(const ScalarStuffT &lhs, const ScalarStuffT &rhs);
bool operator!=(const ScalarStuffT &lhs, const ScalarStuffT &rhs); bool operator!=(const ScalarStuffT &lhs, const ScalarStuffT &rhs);
inline const flatbuffers::TypeTable *ScalarStuffTypeTable(); inline const ::flatbuffers::TypeTable *ScalarStuffTypeTable();
enum OptionalByte : int8_t { enum OptionalByte : int8_t {
OptionalByte_None = 0, OptionalByte_None = 0,
@@ -52,55 +52,55 @@ inline const char * const *EnumNamesOptionalByte() {
} }
inline const char *EnumNameOptionalByte(OptionalByte e) { 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); const size_t index = static_cast<size_t>(e);
return EnumNamesOptionalByte()[index]; return EnumNamesOptionalByte()[index];
} }
struct ScalarStuffT : public flatbuffers::NativeTable { struct ScalarStuffT : public ::flatbuffers::NativeTable {
typedef ScalarStuff TableType; typedef ScalarStuff TableType;
int8_t just_i8 = 0; 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; int8_t default_i8 = 42;
uint8_t just_u8 = 0; 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; uint8_t default_u8 = 42;
int16_t just_i16 = 0; 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; int16_t default_i16 = 42;
uint16_t just_u16 = 0; 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; uint16_t default_u16 = 42;
int32_t just_i32 = 0; 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; int32_t default_i32 = 42;
uint32_t just_u32 = 0; 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; uint32_t default_u32 = 42;
int64_t just_i64 = 0; 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; int64_t default_i64 = 42LL;
uint64_t just_u64 = 0; 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; uint64_t default_u64 = 42ULL;
float just_f32 = 0.0f; float just_f32 = 0.0f;
flatbuffers::Optional<float> maybe_f32 = flatbuffers::nullopt; ::flatbuffers::Optional<float> maybe_f32 = ::flatbuffers::nullopt;
float default_f32 = 42.0f; float default_f32 = 42.0f;
double just_f64 = 0.0; double just_f64 = 0.0;
flatbuffers::Optional<double> maybe_f64 = flatbuffers::nullopt; ::flatbuffers::Optional<double> maybe_f64 = ::flatbuffers::nullopt;
double default_f64 = 42.0; double default_f64 = 42.0;
bool just_bool = false; bool just_bool = false;
flatbuffers::Optional<bool> maybe_bool = flatbuffers::nullopt; ::flatbuffers::Optional<bool> maybe_bool = ::flatbuffers::nullopt;
bool default_bool = true; bool default_bool = true;
optional_scalars::OptionalByte just_enum = optional_scalars::OptionalByte_None; 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; 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 ScalarStuffT NativeTableType;
typedef ScalarStuffBuilder Builder; typedef ScalarStuffBuilder Builder;
static const flatbuffers::TypeTable *MiniReflectTypeTable() { static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return ScalarStuffTypeTable(); return ScalarStuffTypeTable();
} }
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
@@ -147,7 +147,7 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool mutate_just_i8(int8_t _just_i8 = 0) { bool mutate_just_i8(int8_t _just_i8 = 0) {
return SetField<int8_t>(VT_JUST_I8, _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); return GetOptional<int8_t, int8_t>(VT_MAYBE_I8);
} }
bool mutate_maybe_i8(int8_t _maybe_i8) { bool mutate_maybe_i8(int8_t _maybe_i8) {
@@ -165,7 +165,7 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool mutate_just_u8(uint8_t _just_u8 = 0) { bool mutate_just_u8(uint8_t _just_u8 = 0) {
return SetField<uint8_t>(VT_JUST_U8, _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); return GetOptional<uint8_t, uint8_t>(VT_MAYBE_U8);
} }
bool mutate_maybe_u8(uint8_t _maybe_u8) { bool mutate_maybe_u8(uint8_t _maybe_u8) {
@@ -183,7 +183,7 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool mutate_just_i16(int16_t _just_i16 = 0) { bool mutate_just_i16(int16_t _just_i16 = 0) {
return SetField<int16_t>(VT_JUST_I16, _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); return GetOptional<int16_t, int16_t>(VT_MAYBE_I16);
} }
bool mutate_maybe_i16(int16_t _maybe_i16) { bool mutate_maybe_i16(int16_t _maybe_i16) {
@@ -201,7 +201,7 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool mutate_just_u16(uint16_t _just_u16 = 0) { bool mutate_just_u16(uint16_t _just_u16 = 0) {
return SetField<uint16_t>(VT_JUST_U16, _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); return GetOptional<uint16_t, uint16_t>(VT_MAYBE_U16);
} }
bool mutate_maybe_u16(uint16_t _maybe_u16) { bool mutate_maybe_u16(uint16_t _maybe_u16) {
@@ -219,7 +219,7 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool mutate_just_i32(int32_t _just_i32 = 0) { bool mutate_just_i32(int32_t _just_i32 = 0) {
return SetField<int32_t>(VT_JUST_I32, _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); return GetOptional<int32_t, int32_t>(VT_MAYBE_I32);
} }
bool mutate_maybe_i32(int32_t _maybe_i32) { bool mutate_maybe_i32(int32_t _maybe_i32) {
@@ -237,7 +237,7 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool mutate_just_u32(uint32_t _just_u32 = 0) { bool mutate_just_u32(uint32_t _just_u32 = 0) {
return SetField<uint32_t>(VT_JUST_U32, _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); return GetOptional<uint32_t, uint32_t>(VT_MAYBE_U32);
} }
bool mutate_maybe_u32(uint32_t _maybe_u32) { bool mutate_maybe_u32(uint32_t _maybe_u32) {
@@ -255,7 +255,7 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool mutate_just_i64(int64_t _just_i64 = 0) { bool mutate_just_i64(int64_t _just_i64 = 0) {
return SetField<int64_t>(VT_JUST_I64, _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); return GetOptional<int64_t, int64_t>(VT_MAYBE_I64);
} }
bool mutate_maybe_i64(int64_t _maybe_i64) { bool mutate_maybe_i64(int64_t _maybe_i64) {
@@ -273,7 +273,7 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool mutate_just_u64(uint64_t _just_u64 = 0) { bool mutate_just_u64(uint64_t _just_u64 = 0) {
return SetField<uint64_t>(VT_JUST_U64, _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); return GetOptional<uint64_t, uint64_t>(VT_MAYBE_U64);
} }
bool mutate_maybe_u64(uint64_t _maybe_u64) { bool mutate_maybe_u64(uint64_t _maybe_u64) {
@@ -291,7 +291,7 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool mutate_just_f32(float _just_f32 = 0.0f) { bool mutate_just_f32(float _just_f32 = 0.0f) {
return SetField<float>(VT_JUST_F32, _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); return GetOptional<float, float>(VT_MAYBE_F32);
} }
bool mutate_maybe_f32(float _maybe_f32) { bool mutate_maybe_f32(float _maybe_f32) {
@@ -309,7 +309,7 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool mutate_just_f64(double _just_f64 = 0.0) { bool mutate_just_f64(double _just_f64 = 0.0) {
return SetField<double>(VT_JUST_F64, _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); return GetOptional<double, double>(VT_MAYBE_F64);
} }
bool mutate_maybe_f64(double _maybe_f64) { bool mutate_maybe_f64(double _maybe_f64) {
@@ -327,7 +327,7 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool mutate_just_bool(bool _just_bool = 0) { bool mutate_just_bool(bool _just_bool = 0) {
return SetField<uint8_t>(VT_JUST_BOOL, static_cast<uint8_t>(_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); return GetOptional<uint8_t, bool>(VT_MAYBE_BOOL);
} }
bool mutate_maybe_bool(bool _maybe_bool) { bool mutate_maybe_bool(bool _maybe_bool) {
@@ -345,7 +345,7 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool mutate_just_enum(optional_scalars::OptionalByte _just_enum = static_cast<optional_scalars::OptionalByte>(0)) { 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); 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); return GetOptional<int8_t, optional_scalars::OptionalByte>(VT_MAYBE_ENUM);
} }
bool mutate_maybe_enum(optional_scalars::OptionalByte _maybe_enum) { bool mutate_maybe_enum(optional_scalars::OptionalByte _maybe_enum) {
@@ -357,7 +357,7 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool mutate_default_enum(optional_scalars::OptionalByte _default_enum = static_cast<optional_scalars::OptionalByte>(1)) { bool mutate_default_enum(optional_scalars::OptionalByte _default_enum = static_cast<optional_scalars::OptionalByte>(1)) {
return SetField<int8_t>(VT_DEFAULT_ENUM, static_cast<int8_t>(_default_enum), 1); return SetField<int8_t>(VT_DEFAULT_ENUM, static_cast<int8_t>(_default_enum), 1);
} }
bool Verify(flatbuffers::Verifier &verifier) const { bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) && return VerifyTableStart(verifier) &&
VerifyField<int8_t>(verifier, VT_JUST_I8, 1) && VerifyField<int8_t>(verifier, VT_JUST_I8, 1) &&
VerifyField<int8_t>(verifier, VT_MAYBE_I8, 1) && VerifyField<int8_t>(verifier, VT_MAYBE_I8, 1) &&
@@ -397,15 +397,15 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VerifyField<int8_t>(verifier, VT_DEFAULT_ENUM, 1) && VerifyField<int8_t>(verifier, VT_DEFAULT_ENUM, 1) &&
verifier.EndTable(); verifier.EndTable();
} }
ScalarStuffT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; ScalarStuffT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(ScalarStuffT *_o, 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); static ::flatbuffers::Offset<ScalarStuff> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ScalarStuffT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
}; };
struct ScalarStuffBuilder { struct ScalarStuffBuilder {
typedef ScalarStuff Table; typedef ScalarStuff Table;
flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_; ::flatbuffers::uoffset_t start_;
void add_just_i8(int8_t just_i8) { void add_just_i8(int8_t just_i8) {
fbb_.AddElement<int8_t>(ScalarStuff::VT_JUST_I8, just_i8, 0); fbb_.AddElement<int8_t>(ScalarStuff::VT_JUST_I8, just_i8, 0);
} }
@@ -514,54 +514,54 @@ struct ScalarStuffBuilder {
void add_default_enum(optional_scalars::OptionalByte default_enum) { void add_default_enum(optional_scalars::OptionalByte default_enum) {
fbb_.AddElement<int8_t>(ScalarStuff::VT_DEFAULT_ENUM, static_cast<int8_t>(default_enum), 1); 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) { : fbb_(_fbb) {
start_ = fbb_.StartTable(); start_ = fbb_.StartTable();
} }
flatbuffers::Offset<ScalarStuff> Finish() { ::flatbuffers::Offset<ScalarStuff> Finish() {
const auto end = fbb_.EndTable(start_); const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<ScalarStuff>(end); auto o = ::flatbuffers::Offset<ScalarStuff>(end);
return o; return o;
} }
}; };
inline flatbuffers::Offset<ScalarStuff> CreateScalarStuff( inline ::flatbuffers::Offset<ScalarStuff> CreateScalarStuff(
flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::FlatBufferBuilder &_fbb,
int8_t just_i8 = 0, 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, int8_t default_i8 = 42,
uint8_t just_u8 = 0, 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, uint8_t default_u8 = 42,
int16_t just_i16 = 0, 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, int16_t default_i16 = 42,
uint16_t just_u16 = 0, 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, uint16_t default_u16 = 42,
int32_t just_i32 = 0, 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, int32_t default_i32 = 42,
uint32_t just_u32 = 0, 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, uint32_t default_u32 = 42,
int64_t just_i64 = 0, 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, int64_t default_i64 = 42LL,
uint64_t just_u64 = 0, 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, uint64_t default_u64 = 42ULL,
float just_f32 = 0.0f, float just_f32 = 0.0f,
flatbuffers::Optional<float> maybe_f32 = flatbuffers::nullopt, ::flatbuffers::Optional<float> maybe_f32 = ::flatbuffers::nullopt,
float default_f32 = 42.0f, float default_f32 = 42.0f,
double just_f64 = 0.0, double just_f64 = 0.0,
flatbuffers::Optional<double> maybe_f64 = flatbuffers::nullopt, ::flatbuffers::Optional<double> maybe_f64 = ::flatbuffers::nullopt,
double default_f64 = 42.0, double default_f64 = 42.0,
bool just_bool = false, bool just_bool = false,
flatbuffers::Optional<bool> maybe_bool = flatbuffers::nullopt, ::flatbuffers::Optional<bool> maybe_bool = ::flatbuffers::nullopt,
bool default_bool = true, bool default_bool = true,
optional_scalars::OptionalByte just_enum = optional_scalars::OptionalByte_None, 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) { optional_scalars::OptionalByte default_enum = optional_scalars::OptionalByte_One) {
ScalarStuffBuilder builder_(_fbb); ScalarStuffBuilder builder_(_fbb);
builder_.add_default_f64(default_f64); builder_.add_default_f64(default_f64);
@@ -603,7 +603,7 @@ inline flatbuffers::Offset<ScalarStuff> CreateScalarStuff(
return builder_.Finish(); return builder_.Finish();
} }
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 bool operator==(const ScalarStuffT &lhs, const ScalarStuffT &rhs) { inline bool operator==(const ScalarStuffT &lhs, const ScalarStuffT &rhs) {
@@ -651,13 +651,13 @@ inline bool operator!=(const ScalarStuffT &lhs, const ScalarStuffT &rhs) {
} }
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::unique_ptr<ScalarStuffT>(new ScalarStuffT()); auto _o = std::unique_ptr<ScalarStuffT>(new ScalarStuffT());
UnPackTo(_o.get(), _resolver); UnPackTo(_o.get(), _resolver);
return _o.release(); 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)_o;
(void)_resolver; (void)_resolver;
{ auto _e = just_i8(); _o->just_i8 = _e; } { auto _e = just_i8(); _o->just_i8 = _e; }
@@ -698,14 +698,14 @@ inline void ScalarStuff::UnPackTo(ScalarStuffT *_o, const flatbuffers::resolver_
{ auto _e = default_enum(); _o->default_enum = _e; } { 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); 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)_rehasher;
(void)_o; (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 _just_i8 = _o->just_i8;
auto _maybe_i8 = _o->maybe_i8; auto _maybe_i8 = _o->maybe_i8;
auto _default_i8 = _o->default_i8; auto _default_i8 = _o->default_i8;
@@ -782,13 +782,13 @@ inline flatbuffers::Offset<ScalarStuff> CreateScalarStuff(flatbuffers::FlatBuffe
_default_enum); _default_enum);
} }
inline const flatbuffers::TypeTable *OptionalByteTypeTable() { inline const ::flatbuffers::TypeTable *OptionalByteTypeTable() {
static const flatbuffers::TypeCode type_codes[] = { static const ::flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_CHAR, 0, 0 }, { ::flatbuffers::ET_CHAR, 0, 0 },
{ flatbuffers::ET_CHAR, 0, 0 }, { ::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 optional_scalars::OptionalByteTypeTable
}; };
static const char * const names[] = { static const char * const names[] = {
@@ -796,52 +796,52 @@ inline const flatbuffers::TypeTable *OptionalByteTypeTable() {
"One", "One",
"Two" "Two"
}; };
static const flatbuffers::TypeTable tt = { static const ::flatbuffers::TypeTable tt = {
flatbuffers::ST_ENUM, 3, type_codes, type_refs, nullptr, nullptr, names ::flatbuffers::ST_ENUM, 3, type_codes, type_refs, nullptr, nullptr, names
}; };
return &tt; return &tt;
} }
inline const flatbuffers::TypeTable *ScalarStuffTypeTable() { inline const ::flatbuffers::TypeTable *ScalarStuffTypeTable() {
static const flatbuffers::TypeCode type_codes[] = { static const ::flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_CHAR, 0, -1 }, { ::flatbuffers::ET_CHAR, 0, -1 },
{ flatbuffers::ET_CHAR, 0, -1 }, { ::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_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_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_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_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_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_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_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_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_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_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 }, { ::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 optional_scalars::OptionalByteTypeTable
}; };
static const char * const names[] = { static const char * const names[] = {
@@ -882,26 +882,26 @@ inline const flatbuffers::TypeTable *ScalarStuffTypeTable() {
"maybe_enum", "maybe_enum",
"default_enum" "default_enum"
}; };
static const flatbuffers::TypeTable tt = { static const ::flatbuffers::TypeTable tt = {
flatbuffers::ST_TABLE, 36, type_codes, type_refs, nullptr, nullptr, names ::flatbuffers::ST_TABLE, 36, type_codes, type_refs, nullptr, nullptr, names
}; };
return &tt; return &tt;
} }
inline const optional_scalars::ScalarStuff *GetScalarStuff(const void *buf) { 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) { 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) { inline ScalarStuff *GetMutableScalarStuff(void *buf) {
return flatbuffers::GetMutableRoot<ScalarStuff>(buf); return ::flatbuffers::GetMutableRoot<ScalarStuff>(buf);
} }
inline optional_scalars::ScalarStuff *GetMutableSizePrefixedScalarStuff(void *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() { inline const char *ScalarStuffIdentifier() {
@@ -909,22 +909,22 @@ inline const char *ScalarStuffIdentifier() {
} }
inline bool ScalarStuffBufferHasIdentifier(const void *buf) { inline bool ScalarStuffBufferHasIdentifier(const void *buf) {
return flatbuffers::BufferHasIdentifier( return ::flatbuffers::BufferHasIdentifier(
buf, ScalarStuffIdentifier()); buf, ScalarStuffIdentifier());
} }
inline bool SizePrefixedScalarStuffBufferHasIdentifier(const void *buf) { inline bool SizePrefixedScalarStuffBufferHasIdentifier(const void *buf) {
return flatbuffers::BufferHasIdentifier( return ::flatbuffers::BufferHasIdentifier(
buf, ScalarStuffIdentifier(), true); buf, ScalarStuffIdentifier(), true);
} }
inline bool VerifyScalarStuffBuffer( inline bool VerifyScalarStuffBuffer(
flatbuffers::Verifier &verifier) { ::flatbuffers::Verifier &verifier) {
return verifier.VerifyBuffer<optional_scalars::ScalarStuff>(ScalarStuffIdentifier()); return verifier.VerifyBuffer<optional_scalars::ScalarStuff>(ScalarStuffIdentifier());
} }
inline bool VerifySizePrefixedScalarStuffBuffer( inline bool VerifySizePrefixedScalarStuffBuffer(
flatbuffers::Verifier &verifier) { ::flatbuffers::Verifier &verifier) {
return verifier.VerifySizePrefixedBuffer<optional_scalars::ScalarStuff>(ScalarStuffIdentifier()); return verifier.VerifySizePrefixedBuffer<optional_scalars::ScalarStuff>(ScalarStuffIdentifier());
} }
@@ -933,26 +933,26 @@ inline const char *ScalarStuffExtension() {
} }
inline void FinishScalarStuffBuffer( inline void FinishScalarStuffBuffer(
flatbuffers::FlatBufferBuilder &fbb, ::flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<optional_scalars::ScalarStuff> root) { ::flatbuffers::Offset<optional_scalars::ScalarStuff> root) {
fbb.Finish(root, ScalarStuffIdentifier()); fbb.Finish(root, ScalarStuffIdentifier());
} }
inline void FinishSizePrefixedScalarStuffBuffer( inline void FinishSizePrefixedScalarStuffBuffer(
flatbuffers::FlatBufferBuilder &fbb, ::flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<optional_scalars::ScalarStuff> root) { ::flatbuffers::Offset<optional_scalars::ScalarStuff> root) {
fbb.FinishSizePrefixed(root, ScalarStuffIdentifier()); fbb.FinishSizePrefixed(root, ScalarStuffIdentifier());
} }
inline flatbuffers::unique_ptr<optional_scalars::ScalarStuffT> UnPackScalarStuff( inline flatbuffers::unique_ptr<optional_scalars::ScalarStuffT> UnPackScalarStuff(
const void *buf, const void *buf,
const flatbuffers::resolver_function_t *res = nullptr) { const ::flatbuffers::resolver_function_t *res = nullptr) {
return flatbuffers::unique_ptr<optional_scalars::ScalarStuffT>(GetScalarStuff(buf)->UnPack(res)); return flatbuffers::unique_ptr<optional_scalars::ScalarStuffT>(GetScalarStuff(buf)->UnPack(res));
} }
inline flatbuffers::unique_ptr<optional_scalars::ScalarStuffT> UnPackSizePrefixedScalarStuff( inline flatbuffers::unique_ptr<optional_scalars::ScalarStuffT> UnPackSizePrefixedScalarStuff(
const void *buf, const void *buf,
const flatbuffers::resolver_function_t *res = nullptr) { const ::flatbuffers::resolver_function_t *res = nullptr) {
return flatbuffers::unique_ptr<optional_scalars::ScalarStuffT>(GetSizePrefixedScalarStuff(buf)->UnPack(res)); return flatbuffers::unique_ptr<optional_scalars::ScalarStuffT>(GetSizePrefixedScalarStuff(buf)->UnPack(res));
} }

392
tests/union_vector/union_vector_generated.h
View File

@@ -44,17 +44,17 @@ bool operator!=(const HandFanT &lhs, const HandFanT &rhs);
bool operator==(const MovieT &lhs, const MovieT &rhs); bool operator==(const MovieT &lhs, const MovieT &rhs);
bool operator!=(const MovieT &lhs, const MovieT &rhs); bool operator!=(const MovieT &lhs, const MovieT &rhs);
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 Character : uint8_t { enum Character : uint8_t {
Character_NONE = 0, Character_NONE = 0,
@@ -96,7 +96,7 @@ inline const char * const *EnumNamesCharacter() {
} }
inline const char *EnumNameCharacter(Character e) { 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); const size_t index = static_cast<size_t>(e);
return EnumNamesCharacter()[index]; return EnumNamesCharacter()[index];
} }
@@ -118,8 +118,8 @@ struct CharacterUnion {
void Reset(); void Reset();
static void *UnPack(const void *obj, Character type, const flatbuffers::resolver_function_t *resolver); 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; ::flatbuffers::Offset<void> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
AttackerT *AsMuLan() { AttackerT *AsMuLan() {
return type == Character_MuLan ? return type == Character_MuLan ?
@@ -212,8 +212,8 @@ inline bool operator!=(const CharacterUnion &lhs, const CharacterUnion &rhs) {
return !(lhs == rhs); return !(lhs == rhs);
} }
bool VerifyCharacter(flatbuffers::Verifier &verifier, const void *obj, Character type); 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<uint8_t> *types); bool VerifyCharacterVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
enum Gadget : uint8_t { enum Gadget : uint8_t {
Gadget_NONE = 0, Gadget_NONE = 0,
@@ -243,7 +243,7 @@ inline const char * const *EnumNamesGadget() {
} }
inline const char *EnumNameGadget(Gadget e) { 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); const size_t index = static_cast<size_t>(e);
return EnumNamesGadget()[index]; return EnumNamesGadget()[index];
} }
@@ -299,8 +299,8 @@ struct GadgetUnion {
} }
} }
static void *UnPack(const void *obj, Gadget type, const flatbuffers::resolver_function_t *resolver); 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; ::flatbuffers::Offset<void> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
FallingTub *AsFallingTub() { FallingTub *AsFallingTub() {
return type == Gadget_FallingTub ? return type == Gadget_FallingTub ?
@@ -345,28 +345,28 @@ inline bool operator!=(const GadgetUnion &lhs, const GadgetUnion &rhs) {
return !(lhs == rhs); return !(lhs == rhs);
} }
bool VerifyGadget(flatbuffers::Verifier &verifier, const void *obj, Gadget type); 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<uint8_t> *types); bool VerifyGadgetVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Rapunzel FLATBUFFERS_FINAL_CLASS { FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Rapunzel FLATBUFFERS_FINAL_CLASS {
private: private:
int32_t hair_length_; int32_t hair_length_;
public: public:
static const flatbuffers::TypeTable *MiniReflectTypeTable() { static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return RapunzelTypeTable(); return RapunzelTypeTable();
} }
Rapunzel() Rapunzel()
: hair_length_(0) { : hair_length_(0) {
} }
Rapunzel(int32_t _hair_length) Rapunzel(int32_t _hair_length)
: hair_length_(flatbuffers::EndianScalar(_hair_length)) { : hair_length_(::flatbuffers::EndianScalar(_hair_length)) {
} }
int32_t hair_length() const { int32_t hair_length() const {
return flatbuffers::EndianScalar(hair_length_); return ::flatbuffers::EndianScalar(hair_length_);
} }
void mutate_hair_length(int32_t _hair_length) { void mutate_hair_length(int32_t _hair_length) {
flatbuffers::WriteScalar(&hair_length_, _hair_length); ::flatbuffers::WriteScalar(&hair_length_, _hair_length);
} }
}; };
FLATBUFFERS_STRUCT_END(Rapunzel, 4); FLATBUFFERS_STRUCT_END(Rapunzel, 4);
@@ -386,20 +386,20 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) BookReader FLATBUFFERS_FINAL_CLASS {
int32_t books_read_; int32_t books_read_;
public: public:
static const flatbuffers::TypeTable *MiniReflectTypeTable() { static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return BookReaderTypeTable(); return BookReaderTypeTable();
} }
BookReader() BookReader()
: books_read_(0) { : books_read_(0) {
} }
BookReader(int32_t _books_read) BookReader(int32_t _books_read)
: books_read_(flatbuffers::EndianScalar(_books_read)) { : books_read_(::flatbuffers::EndianScalar(_books_read)) {
} }
int32_t books_read() const { int32_t books_read() const {
return flatbuffers::EndianScalar(books_read_); return ::flatbuffers::EndianScalar(books_read_);
} }
void mutate_books_read(int32_t _books_read) { void mutate_books_read(int32_t _books_read) {
flatbuffers::WriteScalar(&books_read_, _books_read); ::flatbuffers::WriteScalar(&books_read_, _books_read);
} }
}; };
FLATBUFFERS_STRUCT_END(BookReader, 4); FLATBUFFERS_STRUCT_END(BookReader, 4);
@@ -419,20 +419,20 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) FallingTub FLATBUFFERS_FINAL_CLASS {
int32_t weight_; int32_t weight_;
public: public:
static const flatbuffers::TypeTable *MiniReflectTypeTable() { static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return FallingTubTypeTable(); return FallingTubTypeTable();
} }
FallingTub() FallingTub()
: weight_(0) { : weight_(0) {
} }
FallingTub(int32_t _weight) FallingTub(int32_t _weight)
: weight_(flatbuffers::EndianScalar(_weight)) { : weight_(::flatbuffers::EndianScalar(_weight)) {
} }
int32_t weight() const { int32_t weight() const {
return flatbuffers::EndianScalar(weight_); return ::flatbuffers::EndianScalar(weight_);
} }
void mutate_weight(int32_t _weight) { void mutate_weight(int32_t _weight) {
flatbuffers::WriteScalar(&weight_, _weight); ::flatbuffers::WriteScalar(&weight_, _weight);
} }
}; };
FLATBUFFERS_STRUCT_END(FallingTub, 4); FLATBUFFERS_STRUCT_END(FallingTub, 4);
@@ -447,15 +447,15 @@ inline bool operator!=(const FallingTub &lhs, const FallingTub &rhs) {
} }
struct AttackerT : public flatbuffers::NativeTable { struct AttackerT : public ::flatbuffers::NativeTable {
typedef Attacker TableType; typedef Attacker TableType;
int32_t sword_attack_damage = 0; 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 AttackerT NativeTableType;
typedef AttackerBuilder Builder; typedef AttackerBuilder Builder;
static const flatbuffers::TypeTable *MiniReflectTypeTable() { static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return AttackerTypeTable(); return AttackerTypeTable();
} }
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
@@ -467,53 +467,53 @@ struct Attacker FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool mutate_sword_attack_damage(int32_t _sword_attack_damage = 0) { bool mutate_sword_attack_damage(int32_t _sword_attack_damage = 0) {
return SetField<int32_t>(VT_SWORD_ATTACK_DAMAGE, _sword_attack_damage, 0); return SetField<int32_t>(VT_SWORD_ATTACK_DAMAGE, _sword_attack_damage, 0);
} }
bool Verify(flatbuffers::Verifier &verifier) const { bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) && return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_SWORD_ATTACK_DAMAGE, 4) && VerifyField<int32_t>(verifier, VT_SWORD_ATTACK_DAMAGE, 4) &&
verifier.EndTable(); verifier.EndTable();
} }
AttackerT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; AttackerT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(AttackerT *_o, 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); static ::flatbuffers::Offset<Attacker> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const AttackerT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
}; };
struct AttackerBuilder { struct AttackerBuilder {
typedef Attacker Table; typedef Attacker Table;
flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_; ::flatbuffers::uoffset_t start_;
void add_sword_attack_damage(int32_t sword_attack_damage) { void add_sword_attack_damage(int32_t sword_attack_damage) {
fbb_.AddElement<int32_t>(Attacker::VT_SWORD_ATTACK_DAMAGE, sword_attack_damage, 0); 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) { : fbb_(_fbb) {
start_ = fbb_.StartTable(); start_ = fbb_.StartTable();
} }
flatbuffers::Offset<Attacker> Finish() { ::flatbuffers::Offset<Attacker> Finish() {
const auto end = fbb_.EndTable(start_); const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<Attacker>(end); auto o = ::flatbuffers::Offset<Attacker>(end);
return o; return o;
} }
}; };
inline flatbuffers::Offset<Attacker> CreateAttacker( inline ::flatbuffers::Offset<Attacker> CreateAttacker(
flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::FlatBufferBuilder &_fbb,
int32_t sword_attack_damage = 0) { int32_t sword_attack_damage = 0) {
AttackerBuilder builder_(_fbb); AttackerBuilder builder_(_fbb);
builder_.add_sword_attack_damage(sword_attack_damage); builder_.add_sword_attack_damage(sword_attack_damage);
return builder_.Finish(); return builder_.Finish();
} }
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; typedef HandFan TableType;
int32_t length = 0; int32_t length = 0;
}; };
struct HandFan FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { struct HandFan FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef HandFanT NativeTableType; typedef HandFanT NativeTableType;
typedef HandFanBuilder Builder; typedef HandFanBuilder Builder;
static const flatbuffers::TypeTable *MiniReflectTypeTable() { static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return HandFanTypeTable(); return HandFanTypeTable();
} }
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
@@ -525,54 +525,54 @@ struct HandFan FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
bool mutate_length(int32_t _length = 0) { bool mutate_length(int32_t _length = 0) {
return SetField<int32_t>(VT_LENGTH, _length, 0); return SetField<int32_t>(VT_LENGTH, _length, 0);
} }
bool Verify(flatbuffers::Verifier &verifier) const { bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) && return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_LENGTH, 4) && VerifyField<int32_t>(verifier, VT_LENGTH, 4) &&
verifier.EndTable(); verifier.EndTable();
} }
HandFanT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; HandFanT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(HandFanT *_o, 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); static ::flatbuffers::Offset<HandFan> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const HandFanT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
}; };
struct HandFanBuilder { struct HandFanBuilder {
typedef HandFan Table; typedef HandFan Table;
flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_; ::flatbuffers::uoffset_t start_;
void add_length(int32_t length) { void add_length(int32_t length) {
fbb_.AddElement<int32_t>(HandFan::VT_LENGTH, length, 0); fbb_.AddElement<int32_t>(HandFan::VT_LENGTH, length, 0);
} }
explicit HandFanBuilder(flatbuffers::FlatBufferBuilder &_fbb) explicit HandFanBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) { : fbb_(_fbb) {
start_ = fbb_.StartTable(); start_ = fbb_.StartTable();
} }
flatbuffers::Offset<HandFan> Finish() { ::flatbuffers::Offset<HandFan> Finish() {
const auto end = fbb_.EndTable(start_); const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<HandFan>(end); auto o = ::flatbuffers::Offset<HandFan>(end);
return o; return o;
} }
}; };
inline flatbuffers::Offset<HandFan> CreateHandFan( inline ::flatbuffers::Offset<HandFan> CreateHandFan(
flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::FlatBufferBuilder &_fbb,
int32_t length = 0) { int32_t length = 0) {
HandFanBuilder builder_(_fbb); HandFanBuilder builder_(_fbb);
builder_.add_length(length); builder_.add_length(length);
return builder_.Finish(); return builder_.Finish();
} }
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; typedef Movie TableType;
CharacterUnion main_character{}; CharacterUnion main_character{};
std::vector<CharacterUnion> characters{}; std::vector<CharacterUnion> characters{};
}; };
struct Movie FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { struct Movie FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef MovieT NativeTableType; typedef MovieT NativeTableType;
typedef MovieBuilder Builder; typedef MovieBuilder Builder;
static const flatbuffers::TypeTable *MiniReflectTypeTable() { static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
return MovieTypeTable(); return MovieTypeTable();
} }
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
@@ -599,28 +599,28 @@ struct Movie FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
const BookReader *main_character_as_BookFan() const { const BookReader *main_character_as_BookFan() const {
return main_character_type() == Character_BookFan ? static_cast<const BookReader *>(main_character()) : nullptr; return main_character_type() == Character_BookFan ? static_cast<const BookReader *>(main_character()) : nullptr;
} }
const flatbuffers::String *main_character_as_Other() const { const ::flatbuffers::String *main_character_as_Other() const {
return main_character_type() == Character_Other ? static_cast<const flatbuffers::String *>(main_character()) : nullptr; return main_character_type() == Character_Other ? static_cast<const ::flatbuffers::String *>(main_character()) : nullptr;
} }
const flatbuffers::String *main_character_as_Unused() const { const ::flatbuffers::String *main_character_as_Unused() const {
return main_character_type() == Character_Unused ? static_cast<const flatbuffers::String *>(main_character()) : nullptr; return main_character_type() == Character_Unused ? static_cast<const ::flatbuffers::String *>(main_character()) : nullptr;
} }
void *mutable_main_character() { void *mutable_main_character() {
return GetPointer<void *>(VT_MAIN_CHARACTER); return GetPointer<void *>(VT_MAIN_CHARACTER);
} }
const flatbuffers::Vector<uint8_t> *characters_type() const { const ::flatbuffers::Vector<uint8_t> *characters_type() const {
return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_CHARACTERS_TYPE); return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_CHARACTERS_TYPE);
} }
flatbuffers::Vector<uint8_t> *mutable_characters_type() { ::flatbuffers::Vector<uint8_t> *mutable_characters_type() {
return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_CHARACTERS_TYPE); return GetPointer<::flatbuffers::Vector<uint8_t> *>(VT_CHARACTERS_TYPE);
} }
const flatbuffers::Vector<flatbuffers::Offset<void>> *characters() const { const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *characters() const {
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<void>> *>(VT_CHARACTERS); return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *>(VT_CHARACTERS);
} }
flatbuffers::Vector<flatbuffers::Offset<void>> *mutable_characters() { ::flatbuffers::Vector<::flatbuffers::Offset<void>> *mutable_characters() {
return GetPointer<flatbuffers::Vector<flatbuffers::Offset<void>> *>(VT_CHARACTERS); return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<void>> *>(VT_CHARACTERS);
} }
bool Verify(flatbuffers::Verifier &verifier) const { bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) && return VerifyTableStart(verifier) &&
VerifyField<uint8_t>(verifier, VT_MAIN_CHARACTER_TYPE, 1) && VerifyField<uint8_t>(verifier, VT_MAIN_CHARACTER_TYPE, 1) &&
VerifyOffset(verifier, VT_MAIN_CHARACTER) && VerifyOffset(verifier, VT_MAIN_CHARACTER) &&
@@ -632,44 +632,44 @@ struct Movie FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VerifyCharacterVector(verifier, characters(), characters_type()) && VerifyCharacterVector(verifier, characters(), characters_type()) &&
verifier.EndTable(); verifier.EndTable();
} }
MovieT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; MovieT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(MovieT *_o, 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); static ::flatbuffers::Offset<Movie> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const MovieT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
}; };
struct MovieBuilder { struct MovieBuilder {
typedef Movie Table; typedef Movie Table;
flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_; ::flatbuffers::uoffset_t start_;
void add_main_character_type(Character main_character_type) { 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); 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); fbb_.AddOffset(Movie::VT_MAIN_CHARACTER, main_character);
} }
void add_characters_type(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> characters_type) { void add_characters_type(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> characters_type) {
fbb_.AddOffset(Movie::VT_CHARACTERS_TYPE, 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); fbb_.AddOffset(Movie::VT_CHARACTERS, characters);
} }
explicit MovieBuilder(flatbuffers::FlatBufferBuilder &_fbb) explicit MovieBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) { : fbb_(_fbb) {
start_ = fbb_.StartTable(); start_ = fbb_.StartTable();
} }
flatbuffers::Offset<Movie> Finish() { ::flatbuffers::Offset<Movie> Finish() {
const auto end = fbb_.EndTable(start_); const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<Movie>(end); auto o = ::flatbuffers::Offset<Movie>(end);
return o; return o;
} }
}; };
inline flatbuffers::Offset<Movie> CreateMovie( inline ::flatbuffers::Offset<Movie> CreateMovie(
flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::FlatBufferBuilder &_fbb,
Character main_character_type = Character_NONE, Character main_character_type = Character_NONE,
flatbuffers::Offset<void> main_character = 0, ::flatbuffers::Offset<void> main_character = 0,
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> characters_type = 0, ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> characters_type = 0,
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<void>>> characters = 0) { ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<void>>> characters = 0) {
MovieBuilder builder_(_fbb); MovieBuilder builder_(_fbb);
builder_.add_characters(characters); builder_.add_characters(characters);
builder_.add_characters_type(characters_type); builder_.add_characters_type(characters_type);
@@ -678,14 +678,14 @@ inline flatbuffers::Offset<Movie> CreateMovie(
return builder_.Finish(); return builder_.Finish();
} }
inline flatbuffers::Offset<Movie> CreateMovieDirect( inline ::flatbuffers::Offset<Movie> CreateMovieDirect(
flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::FlatBufferBuilder &_fbb,
Character main_character_type = Character_NONE, Character main_character_type = Character_NONE,
flatbuffers::Offset<void> main_character = 0, ::flatbuffers::Offset<void> main_character = 0,
const std::vector<uint8_t> *characters_type = nullptr, const std::vector<uint8_t> *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<uint8_t>(*characters_type) : 0; auto characters_type__ = characters_type ? _fbb.CreateVector<uint8_t>(*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( return CreateMovie(
_fbb, _fbb,
main_character_type, main_character_type,
@@ -694,7 +694,7 @@ inline flatbuffers::Offset<Movie> CreateMovieDirect(
characters__); 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 bool operator==(const AttackerT &lhs, const AttackerT &rhs) { inline bool operator==(const AttackerT &lhs, const AttackerT &rhs) {
@@ -707,26 +707,26 @@ inline bool operator!=(const AttackerT &lhs, const AttackerT &rhs) {
} }
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::unique_ptr<AttackerT>(new AttackerT()); auto _o = std::unique_ptr<AttackerT>(new AttackerT());
UnPackTo(_o.get(), _resolver); UnPackTo(_o.get(), _resolver);
return _o.release(); 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)_o;
(void)_resolver; (void)_resolver;
{ auto _e = sword_attack_damage(); _o->sword_attack_damage = _e; } { 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); 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)_rehasher;
(void)_o; (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; auto _sword_attack_damage = _o->sword_attack_damage;
return CreateAttacker( return CreateAttacker(
_fbb, _fbb,
@@ -744,26 +744,26 @@ inline bool operator!=(const HandFanT &lhs, const HandFanT &rhs) {
} }
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::unique_ptr<HandFanT>(new HandFanT()); auto _o = std::unique_ptr<HandFanT>(new HandFanT());
UnPackTo(_o.get(), _resolver); UnPackTo(_o.get(), _resolver);
return _o.release(); 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)_o;
(void)_resolver; (void)_resolver;
{ auto _e = length(); _o->length = _e; } { 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); 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)_rehasher;
(void)_o; (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; auto _length = _o->length;
return CreateHandFan( return CreateHandFan(
_fbb, _fbb,
@@ -782,33 +782,33 @@ inline bool operator!=(const MovieT &lhs, const MovieT &rhs) {
} }
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::unique_ptr<MovieT>(new MovieT()); auto _o = std::unique_ptr<MovieT>(new MovieT());
UnPackTo(_o.get(), _resolver); UnPackTo(_o.get(), _resolver);
return _o.release(); 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)_o;
(void)_resolver; (void)_resolver;
{ auto _e = main_character_type(); _o->main_character.type = _e; } { 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 = 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_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(); 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); 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)_rehasher;
(void)_o; (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_type = _o->main_character.type;
auto _main_character = _o->main_character.Pack(_fbb); auto _main_character = _o->main_character.Pack(_fbb);
auto _characters_type = _o->characters.size() ? _fbb.CreateVector<uint8_t>(_o->characters.size(), [](size_t i, _VectorArgs *__va) { return static_cast<uint8_t>(__va->__o->characters[i].type); }, &_va) : 0; auto _characters_type = _o->characters.size() ? _fbb.CreateVector<uint8_t>(_o->characters.size(), [](size_t i, _VectorArgs *__va) { return static_cast<uint8_t>(__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( return CreateMovie(
_fbb, _fbb,
_main_character_type, _main_character_type,
@@ -817,7 +817,7 @@ inline flatbuffers::Offset<Movie> CreateMovie(flatbuffers::FlatBufferBuilder &_f
_characters); _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) { switch (type) {
case Character_NONE: { case Character_NONE: {
return true; return true;
@@ -836,21 +836,21 @@ inline bool VerifyCharacter(flatbuffers::Verifier &verifier, const void *obj, Ch
return verifier.VerifyField<BookReader>(static_cast<const uint8_t *>(obj), 0, 4); return verifier.VerifyField<BookReader>(static_cast<const uint8_t *>(obj), 0, 4);
} }
case Character_Other: { case Character_Other: {
auto ptr = reinterpret_cast<const flatbuffers::String *>(obj); auto ptr = reinterpret_cast<const ::flatbuffers::String *>(obj);
return verifier.VerifyString(ptr); return verifier.VerifyString(ptr);
} }
case Character_Unused: { case Character_Unused: {
auto ptr = reinterpret_cast<const flatbuffers::String *>(obj); auto ptr = reinterpret_cast<const ::flatbuffers::String *>(obj);
return verifier.VerifyString(ptr); return verifier.VerifyString(ptr);
} }
default: return true; default: return true;
} }
} }
inline bool VerifyCharacterVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) { inline bool VerifyCharacterVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
if (!values || !types) return !values && !types; if (!values || !types) return !values && !types;
if (values->size() != types->size()) return false; 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( if (!VerifyCharacter(
verifier, values->Get(i), types->GetEnum<Character>(i))) { verifier, values->Get(i), types->GetEnum<Character>(i))) {
return false; return false;
@@ -859,7 +859,7 @@ inline bool VerifyCharacterVector(flatbuffers::Verifier &verifier, const flatbuf
return true; 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; (void)resolver;
switch (type) { switch (type) {
case Character_MuLan: { case Character_MuLan: {
@@ -879,18 +879,18 @@ inline void *CharacterUnion::UnPack(const void *obj, Character type, const flatb
return new BookReader(*ptr); return new BookReader(*ptr);
} }
case Character_Other: { 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()); return new std::string(ptr->c_str(), ptr->size());
} }
case Character_Unused: { 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()); return new std::string(ptr->c_str(), ptr->size());
} }
default: return nullptr; 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; (void)_rehasher;
switch (type) { switch (type) {
case Character_MuLan: { case Character_MuLan: {
@@ -990,7 +990,7 @@ inline void CharacterUnion::Reset() {
type = Character_NONE; 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) { switch (type) {
case Gadget_NONE: { case Gadget_NONE: {
return true; return true;
@@ -1006,10 +1006,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<uint8_t> *types) { inline bool VerifyGadgetVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
if (!values || !types) return !values && !types; if (!values || !types) return !values && !types;
if (values->size() != types->size()) return false; 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( if (!VerifyGadget(
verifier, values->Get(i), types->GetEnum<Gadget>(i))) { verifier, values->Get(i), types->GetEnum<Gadget>(i))) {
return false; return false;
@@ -1018,7 +1018,7 @@ inline bool VerifyGadgetVector(flatbuffers::Verifier &verifier, const flatbuffer
return true; 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; (void)resolver;
switch (type) { switch (type) {
case Gadget_FallingTub: { case Gadget_FallingTub: {
@@ -1033,7 +1033,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; (void)_rehasher;
switch (type) { switch (type) {
case Gadget_FallingTub: { case Gadget_FallingTub: {
@@ -1081,17 +1081,17 @@ inline void GadgetUnion::Reset() {
type = Gadget_NONE; type = Gadget_NONE;
} }
inline const flatbuffers::TypeTable *CharacterTypeTable() { inline const ::flatbuffers::TypeTable *CharacterTypeTable() {
static const flatbuffers::TypeCode type_codes[] = { static const ::flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_SEQUENCE, 0, -1 }, { ::flatbuffers::ET_SEQUENCE, 0, -1 },
{ flatbuffers::ET_SEQUENCE, 0, 0 }, { ::flatbuffers::ET_SEQUENCE, 0, 0 },
{ flatbuffers::ET_SEQUENCE, 0, 1 }, { ::flatbuffers::ET_SEQUENCE, 0, 1 },
{ flatbuffers::ET_SEQUENCE, 0, 2 }, { ::flatbuffers::ET_SEQUENCE, 0, 2 },
{ flatbuffers::ET_SEQUENCE, 0, 2 }, { ::flatbuffers::ET_SEQUENCE, 0, 2 },
{ flatbuffers::ET_STRING, 0, -1 }, { ::flatbuffers::ET_STRING, 0, -1 },
{ flatbuffers::ET_STRING, 0, -1 } { ::flatbuffers::ET_STRING, 0, -1 }
}; };
static const flatbuffers::TypeFunction type_refs[] = { static const ::flatbuffers::TypeFunction type_refs[] = {
AttackerTypeTable, AttackerTypeTable,
RapunzelTypeTable, RapunzelTypeTable,
BookReaderTypeTable BookReaderTypeTable
@@ -1105,19 +1105,19 @@ inline const flatbuffers::TypeTable *CharacterTypeTable() {
"Other", "Other",
"Unused" "Unused"
}; };
static const flatbuffers::TypeTable tt = { static const ::flatbuffers::TypeTable tt = {
flatbuffers::ST_UNION, 7, type_codes, type_refs, nullptr, nullptr, names ::flatbuffers::ST_UNION, 7, type_codes, type_refs, nullptr, nullptr, names
}; };
return &tt; return &tt;
} }
inline const flatbuffers::TypeTable *GadgetTypeTable() { inline const ::flatbuffers::TypeTable *GadgetTypeTable() {
static const flatbuffers::TypeCode type_codes[] = { static const ::flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_SEQUENCE, 0, -1 }, { ::flatbuffers::ET_SEQUENCE, 0, -1 },
{ flatbuffers::ET_SEQUENCE, 0, 0 }, { ::flatbuffers::ET_SEQUENCE, 0, 0 },
{ flatbuffers::ET_SEQUENCE, 0, 1 } { ::flatbuffers::ET_SEQUENCE, 0, 1 }
}; };
static const flatbuffers::TypeFunction type_refs[] = { static const ::flatbuffers::TypeFunction type_refs[] = {
FallingTubTypeTable, FallingTubTypeTable,
HandFanTypeTable HandFanTypeTable
}; };
@@ -1126,88 +1126,88 @@ inline const flatbuffers::TypeTable *GadgetTypeTable() {
"FallingTub", "FallingTub",
"HandFan" "HandFan"
}; };
static const flatbuffers::TypeTable tt = { static const ::flatbuffers::TypeTable tt = {
flatbuffers::ST_UNION, 3, type_codes, type_refs, nullptr, nullptr, names ::flatbuffers::ST_UNION, 3, type_codes, type_refs, nullptr, nullptr, names
}; };
return &tt; return &tt;
} }
inline const flatbuffers::TypeTable *AttackerTypeTable() { inline const ::flatbuffers::TypeTable *AttackerTypeTable() {
static const flatbuffers::TypeCode type_codes[] = { static const ::flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_INT, 0, -1 } { ::flatbuffers::ET_INT, 0, -1 }
}; };
static const char * const names[] = { static const char * const names[] = {
"sword_attack_damage" "sword_attack_damage"
}; };
static const flatbuffers::TypeTable tt = { static const ::flatbuffers::TypeTable tt = {
flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names ::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
}; };
return &tt; return &tt;
} }
inline const flatbuffers::TypeTable *RapunzelTypeTable() { inline const ::flatbuffers::TypeTable *RapunzelTypeTable() {
static const flatbuffers::TypeCode type_codes[] = { static const ::flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_INT, 0, -1 } { ::flatbuffers::ET_INT, 0, -1 }
}; };
static const int64_t values[] = { 0, 4 }; static const int64_t values[] = { 0, 4 };
static const char * const names[] = { static const char * const names[] = {
"hair_length" "hair_length"
}; };
static const flatbuffers::TypeTable tt = { static const ::flatbuffers::TypeTable tt = {
flatbuffers::ST_STRUCT, 1, type_codes, nullptr, nullptr, values, names ::flatbuffers::ST_STRUCT, 1, type_codes, nullptr, nullptr, values, names
}; };
return &tt; return &tt;
} }
inline const flatbuffers::TypeTable *BookReaderTypeTable() { inline const ::flatbuffers::TypeTable *BookReaderTypeTable() {
static const flatbuffers::TypeCode type_codes[] = { static const ::flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_INT, 0, -1 } { ::flatbuffers::ET_INT, 0, -1 }
}; };
static const int64_t values[] = { 0, 4 }; static const int64_t values[] = { 0, 4 };
static const char * const names[] = { static const char * const names[] = {
"books_read" "books_read"
}; };
static const flatbuffers::TypeTable tt = { static const ::flatbuffers::TypeTable tt = {
flatbuffers::ST_STRUCT, 1, type_codes, nullptr, nullptr, values, names ::flatbuffers::ST_STRUCT, 1, type_codes, nullptr, nullptr, values, names
}; };
return &tt; return &tt;
} }
inline const flatbuffers::TypeTable *FallingTubTypeTable() { inline const ::flatbuffers::TypeTable *FallingTubTypeTable() {
static const flatbuffers::TypeCode type_codes[] = { static const ::flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_INT, 0, -1 } { ::flatbuffers::ET_INT, 0, -1 }
}; };
static const int64_t values[] = { 0, 4 }; static const int64_t values[] = { 0, 4 };
static const char * const names[] = { static const char * const names[] = {
"weight" "weight"
}; };
static const flatbuffers::TypeTable tt = { static const ::flatbuffers::TypeTable tt = {
flatbuffers::ST_STRUCT, 1, type_codes, nullptr, nullptr, values, names ::flatbuffers::ST_STRUCT, 1, type_codes, nullptr, nullptr, values, names
}; };
return &tt; return &tt;
} }
inline const flatbuffers::TypeTable *HandFanTypeTable() { inline const ::flatbuffers::TypeTable *HandFanTypeTable() {
static const flatbuffers::TypeCode type_codes[] = { static const ::flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_INT, 0, -1 } { ::flatbuffers::ET_INT, 0, -1 }
}; };
static const char * const names[] = { static const char * const names[] = {
"length" "length"
}; };
static const flatbuffers::TypeTable tt = { static const ::flatbuffers::TypeTable tt = {
flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names ::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
}; };
return &tt; return &tt;
} }
inline const flatbuffers::TypeTable *MovieTypeTable() { inline const ::flatbuffers::TypeTable *MovieTypeTable() {
static const flatbuffers::TypeCode type_codes[] = { static const ::flatbuffers::TypeCode type_codes[] = {
{ flatbuffers::ET_UTYPE, 0, 0 }, { ::flatbuffers::ET_UTYPE, 0, 0 },
{ flatbuffers::ET_SEQUENCE, 0, 0 }, { ::flatbuffers::ET_SEQUENCE, 0, 0 },
{ flatbuffers::ET_UTYPE, 1, 0 }, { ::flatbuffers::ET_UTYPE, 1, 0 },
{ flatbuffers::ET_SEQUENCE, 1, 0 } { ::flatbuffers::ET_SEQUENCE, 1, 0 }
}; };
static const flatbuffers::TypeFunction type_refs[] = { static const ::flatbuffers::TypeFunction type_refs[] = {
CharacterTypeTable CharacterTypeTable
}; };
static const char * const names[] = { static const char * const names[] = {
@@ -1216,26 +1216,26 @@ inline const flatbuffers::TypeTable *MovieTypeTable() {
"characters_type", "characters_type",
"characters" "characters"
}; };
static const flatbuffers::TypeTable tt = { static const ::flatbuffers::TypeTable tt = {
flatbuffers::ST_TABLE, 4, type_codes, type_refs, nullptr, nullptr, names ::flatbuffers::ST_TABLE, 4, type_codes, type_refs, nullptr, nullptr, names
}; };
return &tt; return &tt;
} }
inline const Movie *GetMovie(const void *buf) { inline const Movie *GetMovie(const void *buf) {
return flatbuffers::GetRoot<Movie>(buf); return ::flatbuffers::GetRoot<Movie>(buf);
} }
inline const Movie *GetSizePrefixedMovie(const void *buf) { inline const Movie *GetSizePrefixedMovie(const void *buf) {
return flatbuffers::GetSizePrefixedRoot<Movie>(buf); return ::flatbuffers::GetSizePrefixedRoot<Movie>(buf);
} }
inline Movie *GetMutableMovie(void *buf) { inline Movie *GetMutableMovie(void *buf) {
return flatbuffers::GetMutableRoot<Movie>(buf); return ::flatbuffers::GetMutableRoot<Movie>(buf);
} }
inline Movie *GetMutableSizePrefixedMovie(void *buf) { inline Movie *GetMutableSizePrefixedMovie(void *buf) {
return flatbuffers::GetMutableSizePrefixedRoot<Movie>(buf); return ::flatbuffers::GetMutableSizePrefixedRoot<Movie>(buf);
} }
inline const char *MovieIdentifier() { inline const char *MovieIdentifier() {
@@ -1243,46 +1243,46 @@ inline const char *MovieIdentifier() {
} }
inline bool MovieBufferHasIdentifier(const void *buf) { inline bool MovieBufferHasIdentifier(const void *buf) {
return flatbuffers::BufferHasIdentifier( return ::flatbuffers::BufferHasIdentifier(
buf, MovieIdentifier()); buf, MovieIdentifier());
} }
inline bool SizePrefixedMovieBufferHasIdentifier(const void *buf) { inline bool SizePrefixedMovieBufferHasIdentifier(const void *buf) {
return flatbuffers::BufferHasIdentifier( return ::flatbuffers::BufferHasIdentifier(
buf, MovieIdentifier(), true); buf, MovieIdentifier(), true);
} }
inline bool VerifyMovieBuffer( inline bool VerifyMovieBuffer(
flatbuffers::Verifier &verifier) { ::flatbuffers::Verifier &verifier) {
return verifier.VerifyBuffer<Movie>(MovieIdentifier()); return verifier.VerifyBuffer<Movie>(MovieIdentifier());
} }
inline bool VerifySizePrefixedMovieBuffer( inline bool VerifySizePrefixedMovieBuffer(
flatbuffers::Verifier &verifier) { ::flatbuffers::Verifier &verifier) {
return verifier.VerifySizePrefixedBuffer<Movie>(MovieIdentifier()); return verifier.VerifySizePrefixedBuffer<Movie>(MovieIdentifier());
} }
inline void FinishMovieBuffer( inline void FinishMovieBuffer(
flatbuffers::FlatBufferBuilder &fbb, ::flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<Movie> root) { ::flatbuffers::Offset<Movie> root) {
fbb.Finish(root, MovieIdentifier()); fbb.Finish(root, MovieIdentifier());
} }
inline void FinishSizePrefixedMovieBuffer( inline void FinishSizePrefixedMovieBuffer(
flatbuffers::FlatBufferBuilder &fbb, ::flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<Movie> root) { ::flatbuffers::Offset<Movie> root) {
fbb.FinishSizePrefixed(root, MovieIdentifier()); fbb.FinishSizePrefixed(root, MovieIdentifier());
} }
inline flatbuffers::unique_ptr<MovieT> UnPackMovie( inline flatbuffers::unique_ptr<MovieT> UnPackMovie(
const void *buf, const void *buf,
const flatbuffers::resolver_function_t *res = nullptr) { const ::flatbuffers::resolver_function_t *res = nullptr) {
return flatbuffers::unique_ptr<MovieT>(GetMovie(buf)->UnPack(res)); return flatbuffers::unique_ptr<MovieT>(GetMovie(buf)->UnPack(res));
} }
inline flatbuffers::unique_ptr<MovieT> UnPackSizePrefixedMovie( inline flatbuffers::unique_ptr<MovieT> UnPackSizePrefixedMovie(
const void *buf, const void *buf,
const flatbuffers::resolver_function_t *res = nullptr) { const ::flatbuffers::resolver_function_t *res = nullptr) {
return flatbuffers::unique_ptr<MovieT>(GetSizePrefixedMovie(buf)->UnPack(res)); return flatbuffers::unique_ptr<MovieT>(GetSizePrefixedMovie(buf)->UnPack(res));
} }