BigfootDev/flatbuffers
1
0
Fork 1
mirror of https://github.com/google/flatbuffers.git synced 2026-06-11 07:27:27 +00:00
Code Issues Packages Projects Releases Wiki Activity

Added support for structs and strings in unions.

Browse Source 
(C++ only for now).
Also fixed vector of union support in the object API.

Bug: 36902939
Change-Id: I935f4cc2c303a4728e26c7916a8ec0adcd6f84cb
Tested: on Linux.
This commit is contained in:
Wouter van Oortmerssen
2017-04-10 15:56:51 -07:00
parent 1fc12e0e5b
commit b0752e179b
16 changed files with 856 additions and 322 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
tests/generate_code.sh
View File

@@ -16,7 +16,7 @@
../flatc --cpp --java --csharp --go --binary --python --js --ts --php --grpc --gen-mutable --gen-object-api --no-includes monster_test.fbs monsterdata_test.json
../flatc --cpp --java --csharp --go --binary --python --js --ts --php --gen-mutable -o namespace_test namespace_test/namespace_test1.fbs namespace_test/namespace_test2.fbs
../flatc --cpp -o union_vector ./union_vector/union_vector.fbs
../flatc --cpp --gen-mutable --gen-object-api -o union_vector ./union_vector/union_vector.fbs
../flatc -b --schema --bfbs-comments monster_test.fbs
cd ../samples
../flatc --cpp --gen-mutable --gen-object-api monster.fbs

BIN
tests/monster_test.bfbs
View File

Binary file not shown.

46
tests/monster_test_generated.h
View File

@@ -102,43 +102,43 @@ template<> struct AnyTraits<MyGame::Example2::Monster> {
struct AnyUnion {
Any type;
flatbuffers::NativeTable *table;
void *value;
AnyUnion() : type(Any_NONE), table(nullptr) {}
AnyUnion() : type(Any_NONE), value(nullptr) {}
AnyUnion(AnyUnion&& u) FLATBUFFERS_NOEXCEPT :
type(Any_NONE), table(nullptr)
{ std::swap(type, u.type); std::swap(table, u.table); }
type(Any_NONE), value(nullptr)
{ std::swap(type, u.type); std::swap(value, u.value); }
AnyUnion(const AnyUnion &);
AnyUnion &operator=(const AnyUnion &);
AnyUnion &operator=(AnyUnion &&u) FLATBUFFERS_NOEXCEPT
{ std::swap(type, u.type); std::swap(table, u.table); return *this; }
{ std::swap(type, u.type); std::swap(value, u.value); return *this; }
~AnyUnion() { Reset(); }
void Reset();
template <typename T>
void Set(T&& value) {
void Set(T&& val) {
Reset();
type = AnyTraits<typename T::TableType>::enum_value;
if (type != Any_NONE) {
table = new T(std::forward<T>(value));
value = new T(std::forward<T>(val));
}
}
static flatbuffers::NativeTable *UnPack(const void *obj, Any type, const flatbuffers::resolver_function_t *resolver);
static void *UnPack(const void *obj, Any type, const flatbuffers::resolver_function_t *resolver);
flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
MonsterT *AsMonster() {
return type == Any_Monster ?
reinterpret_cast<MonsterT *>(table) : nullptr;
reinterpret_cast<MonsterT *>(value) : nullptr;
}
TestSimpleTableWithEnumT *AsTestSimpleTableWithEnum() {
return type == Any_TestSimpleTableWithEnum ?
reinterpret_cast<TestSimpleTableWithEnumT *>(table) : nullptr;
reinterpret_cast<TestSimpleTableWithEnumT *>(value) : nullptr;
}
MyGame::Example2::MonsterT *AsMyGame_Example2_Monster() {
return type == Any_MyGame_Example2_Monster ?
reinterpret_cast<MyGame::Example2::MonsterT *>(table) : nullptr;
reinterpret_cast<MyGame::Example2::MonsterT *>(value) : nullptr;
}
};
@@ -629,13 +629,13 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
}
template<typename T> const T *test_as() const;
const Monster *test_as_Monster() const {
return (test_type() == Any_Monster)? static_cast<const Monster *>(test()) : nullptr;
return test_type() == Any_Monster ? static_cast<const Monster *>(test()) : nullptr;
}
const TestSimpleTableWithEnum *test_as_TestSimpleTableWithEnum() const {
return (test_type() == Any_TestSimpleTableWithEnum)? static_cast<const TestSimpleTableWithEnum *>(test()) : nullptr;
return test_type() == Any_TestSimpleTableWithEnum ? static_cast<const TestSimpleTableWithEnum *>(test()) : nullptr;
}
const MyGame::Example2::Monster *test_as_MyGame_Example2_Monster() const {
return (test_type() == Any_MyGame_Example2_Monster)? static_cast<const MyGame::Example2::Monster *>(test()) : nullptr;
return test_type() == Any_MyGame_Example2_Monster ? static_cast<const MyGame::Example2::Monster *>(test()) : nullptr;
}
void *mutable_test() {
return GetPointer<void *>(VT_TEST);
@@ -1172,7 +1172,7 @@ inline void Monster::UnPackTo(MonsterT *_o, const flatbuffers::resolver_function
{ auto _e = inventory(); if (_e) { _o->inventory.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->inventory[_i] = _e->Get(_i); } } };
{ auto _e = color(); _o->color = _e; };
{ auto _e = test_type(); _o->test.type = _e; };
{ auto _e = test(); if (_e) _o->test.table = AnyUnion::UnPack(_e, test_type(),_resolver); };
{ auto _e = test(); if (_e) _o->test.value = AnyUnion::UnPack(_e, test_type(), _resolver); };
{ auto _e = test4(); if (_e) { _o->test4.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->test4[_i] = *_e->Get(_i); } } };
{ auto _e = testarrayofstring(); if (_e) { _o->testarrayofstring.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->testarrayofstring[_i] = _e->Get(_i)->str(); } } };
{ auto _e = testarrayoftables(); if (_e) { _o->testarrayoftables.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->testarrayoftables[_i] = std::unique_ptr<MonsterT>(_e->Get(_i)->UnPack(_resolver)); } } };
@@ -1297,7 +1297,7 @@ inline bool VerifyAnyVector(flatbuffers::Verifier &verifier, const flatbuffers::
return true;
}
inline flatbuffers::NativeTable *AnyUnion::UnPack(const void *obj, Any type, const flatbuffers::resolver_function_t *resolver) {
inline void *AnyUnion::UnPack(const void *obj, Any type, const flatbuffers::resolver_function_t *resolver) {
switch (type) {
case Any_Monster: {
auto ptr = reinterpret_cast<const Monster *>(obj);
@@ -1318,15 +1318,15 @@ inline flatbuffers::NativeTable *AnyUnion::UnPack(const void *obj, Any type, con
inline flatbuffers::Offset<void> AnyUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const {
switch (type) {
case Any_Monster: {
auto ptr = reinterpret_cast<const MonsterT *>(table);
auto ptr = reinterpret_cast<const MonsterT *>(value);
return CreateMonster(_fbb, ptr, _rehasher).Union();
}
case Any_TestSimpleTableWithEnum: {
auto ptr = reinterpret_cast<const TestSimpleTableWithEnumT *>(table);
auto ptr = reinterpret_cast<const TestSimpleTableWithEnumT *>(value);
return CreateTestSimpleTableWithEnum(_fbb, ptr, _rehasher).Union();
}
case Any_MyGame_Example2_Monster: {
auto ptr = reinterpret_cast<const MyGame::Example2::MonsterT *>(table);
auto ptr = reinterpret_cast<const MyGame::Example2::MonsterT *>(value);
return CreateMonster(_fbb, ptr, _rehasher).Union();
}
default: return 0;
@@ -1336,23 +1336,23 @@ inline flatbuffers::Offset<void> AnyUnion::Pack(flatbuffers::FlatBufferBuilder &
inline void AnyUnion::Reset() {
switch (type) {
case Any_Monster: {
auto ptr = reinterpret_cast<MonsterT *>(table);
auto ptr = reinterpret_cast<MonsterT *>(value);
delete ptr;
break;
}
case Any_TestSimpleTableWithEnum: {
auto ptr = reinterpret_cast<TestSimpleTableWithEnumT *>(table);
auto ptr = reinterpret_cast<TestSimpleTableWithEnumT *>(value);
delete ptr;
break;
}
case Any_MyGame_Example2_Monster: {
auto ptr = reinterpret_cast<MyGame::Example2::MonsterT *>(table);
auto ptr = reinterpret_cast<MyGame::Example2::MonsterT *>(value);
delete ptr;
break;
}
default: break;
}
table = nullptr;
value = nullptr;
type = Any_NONE;
}

86
tests/test.cpp
View File

@@ -1334,46 +1334,78 @@ void UnionVectorTest() {
// union types.
std::vector<uint8_t> types;
types.push_back(static_cast<uint8_t>(Character_Belle));
types.push_back(static_cast<uint8_t>(Character_Rapunzel));
types.push_back(static_cast<uint8_t>(Character_MuLan));
types.push_back(static_cast<uint8_t>(Character_BookFan));
types.push_back(static_cast<uint8_t>(Character_Other));
types.push_back(static_cast<uint8_t>(Character_Unused));
// union values.
std::vector<flatbuffers::Offset<void>> characters;
characters.push_back(CreateBelle(fbb, /*books_read=*/7).Union());
characters.push_back(CreateRapunzel(fbb, /*hair_length=*/6).Union());
characters.push_back(CreateMuLan(fbb, /*sword_attack_damage=*/5).Union());
characters.push_back(fbb.CreateStruct(BookReader(/*books_read=*/7)).Union());
characters.push_back(CreateAttacker(fbb, /*sword_attack_damage=*/5).Union());
characters.push_back(fbb.CreateStruct(BookReader(/*books_read=*/2)).Union());
characters.push_back(fbb.CreateString("Other").Union());
characters.push_back(fbb.CreateString("Unused").Union());
// create Movie.
const auto movie_offset =
CreateMovie(fbb, fbb.CreateVector(types), fbb.CreateVector(characters));
CreateMovie(fbb,
Character_Rapunzel,
fbb.CreateStruct(Rapunzel(/*hair_length=*/6)).Union(),
fbb.CreateVector(types),
fbb.CreateVector(characters));
FinishMovieBuffer(fbb, movie_offset);
uint8_t *buf = fbb.GetBufferPointer();
auto buf = fbb.GetBufferPointer();
flatbuffers::Verifier verifier(buf, fbb.GetSize());
TEST_EQ(VerifyMovieBuffer(verifier), true);
const Movie *movie = GetMovie(buf);
TEST_EQ(movie->characters_type()->size(), 3);
TEST_EQ(
movie->characters_type()->GetEnum<Character>(0) == Character_Belle,
true);
TEST_EQ(
movie->characters_type()->GetEnum<Character>(1) == Character_Rapunzel,
true);
TEST_EQ(
movie->characters_type()->GetEnum<Character>(2) == Character_MuLan,
true);
auto flat_movie = GetMovie(buf);
TEST_EQ(movie->characters()->size(), 3);
const Belle *belle =
reinterpret_cast<const Belle*>(movie->characters()->Get(0));
TEST_EQ(belle->books_read(), 7);
const Rapunzel *rapunzel =
reinterpret_cast<const Rapunzel*>(movie->characters()->Get(1));
TEST_EQ(rapunzel->hair_length(), 6);
const MuLan *mu_lan =
reinterpret_cast<const MuLan*>(movie->characters()->Get(2));
TEST_EQ(mu_lan->sword_attack_damage(), 5);
auto TestMovie = [](const Movie *movie) {
TEST_EQ(movie->main_character_type() == Character_Rapunzel, true);
auto cts = movie->characters_type();
TEST_EQ(movie->characters_type()->size(), 5);
TEST_EQ(cts->GetEnum<Character>(0) == Character_Belle, true);
TEST_EQ(cts->GetEnum<Character>(1) == Character_MuLan, true);
TEST_EQ(cts->GetEnum<Character>(2) == Character_BookFan, true);
TEST_EQ(cts->GetEnum<Character>(3) == Character_Other, true);
TEST_EQ(cts->GetEnum<Character>(4) == Character_Unused, true);
auto rapunzel = movie->main_character_as_Rapunzel();
TEST_EQ(rapunzel->hair_length(), 6);
auto cs = movie->characters();
TEST_EQ(cs->size(), 5);
auto belle = cs->GetAs<BookReader>(0);
TEST_EQ(belle->books_read(), 7);
auto mu_lan = cs->GetAs<Attacker>(1);
TEST_EQ(mu_lan->sword_attack_damage(), 5);
auto book_fan = cs->GetAs<BookReader>(2);
TEST_EQ(book_fan->books_read(), 2);
auto other = cs->GetAsString(3);
TEST_EQ_STR(other->c_str(), "Other");
auto unused = cs->GetAsString(4);
TEST_EQ_STR(unused->c_str(), "Unused");
};
TestMovie(flat_movie);
auto movie_object = flat_movie->UnPack();
TEST_EQ(movie_object->main_character.AsRapunzel()->hair_length(), 6);
TEST_EQ(movie_object->characters[0].AsBelle()->books_read(), 7);
TEST_EQ(movie_object->characters[1].AsMuLan()->sword_attack_damage, 5);
TEST_EQ(movie_object->characters[2].AsBookFan()->books_read(), 2);
TEST_EQ_STR(movie_object->characters[3].AsOther()->c_str(), "Other");
TEST_EQ_STR(movie_object->characters[4].AsUnused()->c_str(), "Unused");
fbb.Clear();
fbb.Finish(Movie::Pack(fbb, movie_object));
auto repacked_movie = GetMovie(fbb.GetBufferPointer());
TestMovie(repacked_movie);
}
void ConformTest() {

19
tests/union_vector/union_vector.fbs
View File

@@ -1,22 +1,29 @@
table MuLan {
// Demonstrates the ability to have vectors of unions, and also to
// store structs and strings in unions.
table Attacker {
sword_attack_damage: int;
}
table Rapunzel {
struct Rapunzel {
hair_length: int;
}
table Belle {
struct BookReader {
books_read: int;
}
union Character {
MuLan,
Rapunzel,
Belle,
MuLan: Attacker, // Can have name be different from type.
Rapunzel, // Or just both the same, as before.
Belle: BookReader,
BookFan: BookReader,
Other: string,
Unused: string
}
table Movie {
main_character: Character;
characters: [Character];
}

482
tests/union_vector/union_vector_generated.h
View File

@@ -6,21 +6,26 @@
#include "flatbuffers/flatbuffers.h"
struct MuLan;
struct Attacker;
struct AttackerT;
struct Rapunzel;
struct Belle;
struct BookReader;
struct Movie;
struct MovieT;
enum Character {
Character_NONE = 0,
Character_MuLan = 1,
Character_Rapunzel = 2,
Character_Belle = 3,
Character_BookFan = 4,
Character_Other = 5,
Character_Unused = 6,
Character_MIN = Character_NONE,
Character_MAX = Character_Belle
Character_MAX = Character_Unused
};
inline const char **EnumNamesCharacter() {
@@ -29,6 +34,9 @@ inline const char **EnumNamesCharacter() {
"MuLan",
"Rapunzel",
"Belle",
"BookFan",
"Other",
"Unused",
nullptr
};
return names;
@@ -39,158 +47,221 @@ inline const char *EnumNameCharacter(Character e) {
return EnumNamesCharacter()[index];
}
template<typename T> struct CharacterTraits {
static const Character enum_value = Character_NONE;
};
struct CharacterUnion {
Character type;
void *value;
template<> struct CharacterTraits<MuLan> {
static const Character enum_value = Character_MuLan;
};
CharacterUnion() : type(Character_NONE), value(nullptr) {}
CharacterUnion(CharacterUnion&& u) FLATBUFFERS_NOEXCEPT :
type(Character_NONE), value(nullptr)
{ std::swap(type, u.type); std::swap(value, u.value); }
CharacterUnion(const CharacterUnion &);
CharacterUnion &operator=(const CharacterUnion &);
CharacterUnion &operator=(CharacterUnion &&u) FLATBUFFERS_NOEXCEPT
{ std::swap(type, u.type); std::swap(value, u.value); return *this; }
~CharacterUnion() { Reset(); }
template<> struct CharacterTraits<Rapunzel> {
static const Character enum_value = Character_Rapunzel;
};
void Reset();
template<> struct CharacterTraits<Belle> {
static const Character enum_value = Character_Belle;
static void *UnPack(const void *obj, Character type, const flatbuffers::resolver_function_t *resolver);
flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
AttackerT *AsMuLan() {
return type == Character_MuLan ?
reinterpret_cast<AttackerT *>(value) : nullptr;
}
Rapunzel *AsRapunzel() {
return type == Character_Rapunzel ?
reinterpret_cast<Rapunzel *>(value) : nullptr;
}
BookReader *AsBelle() {
return type == Character_Belle ?
reinterpret_cast<BookReader *>(value) : nullptr;
}
BookReader *AsBookFan() {
return type == Character_BookFan ?
reinterpret_cast<BookReader *>(value) : nullptr;
}
std::string *AsOther() {
return type == Character_Other ?
reinterpret_cast<std::string *>(value) : nullptr;
}
std::string *AsUnused() {
return type == Character_Unused ?
reinterpret_cast<std::string *>(value) : nullptr;
}
};
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);
struct MuLan FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
MANUALLY_ALIGNED_STRUCT(4) Rapunzel FLATBUFFERS_FINAL_CLASS {
private:
int32_t hair_length_;
public:
Rapunzel() {
memset(this, 0, sizeof(Rapunzel));
}
Rapunzel(const Rapunzel &_o) {
memcpy(this, &_o, sizeof(Rapunzel));
}
Rapunzel(int32_t _hair_length)
: hair_length_(flatbuffers::EndianScalar(_hair_length)) {
}
int32_t hair_length() const {
return flatbuffers::EndianScalar(hair_length_);
}
void mutate_hair_length(int32_t _hair_length) {
flatbuffers::WriteScalar(&hair_length_, _hair_length);
}
};
STRUCT_END(Rapunzel, 4);
MANUALLY_ALIGNED_STRUCT(4) BookReader FLATBUFFERS_FINAL_CLASS {
private:
int32_t books_read_;
public:
BookReader() {
memset(this, 0, sizeof(BookReader));
}
BookReader(const BookReader &_o) {
memcpy(this, &_o, sizeof(BookReader));
}
BookReader(int32_t _books_read)
: books_read_(flatbuffers::EndianScalar(_books_read)) {
}
int32_t books_read() const {
return flatbuffers::EndianScalar(books_read_);
}
void mutate_books_read(int32_t _books_read) {
flatbuffers::WriteScalar(&books_read_, _books_read);
}
};
STRUCT_END(BookReader, 4);
struct AttackerT : public flatbuffers::NativeTable {
typedef Attacker TableType;
int32_t sword_attack_damage;
AttackerT()
: sword_attack_damage(0) {
}
};
struct Attacker FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef AttackerT NativeTableType;
enum {
VT_SWORD_ATTACK_DAMAGE = 4
};
int32_t sword_attack_damage() const {
return GetField<int32_t>(VT_SWORD_ATTACK_DAMAGE, 0);
}
bool mutate_sword_attack_damage(int32_t _sword_attack_damage) {
return SetField<int32_t>(VT_SWORD_ATTACK_DAMAGE, _sword_attack_damage, 0);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_SWORD_ATTACK_DAMAGE) &&
verifier.EndTable();
}
AttackerT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(AttackerT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<Attacker> Pack(flatbuffers::FlatBufferBuilder &_fbb, const AttackerT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct MuLanBuilder {
struct AttackerBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_sword_attack_damage(int32_t sword_attack_damage) {
fbb_.AddElement<int32_t>(MuLan::VT_SWORD_ATTACK_DAMAGE, sword_attack_damage, 0);
fbb_.AddElement<int32_t>(Attacker::VT_SWORD_ATTACK_DAMAGE, sword_attack_damage, 0);
}
MuLanBuilder(flatbuffers::FlatBufferBuilder &_fbb)
AttackerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
MuLanBuilder &operator=(const MuLanBuilder &);
flatbuffers::Offset<MuLan> Finish() {
AttackerBuilder &operator=(const AttackerBuilder &);
flatbuffers::Offset<Attacker> Finish() {
const auto end = fbb_.EndTable(start_, 1);
auto o = flatbuffers::Offset<MuLan>(end);
auto o = flatbuffers::Offset<Attacker>(end);
return o;
}
};
inline flatbuffers::Offset<MuLan> CreateMuLan(
inline flatbuffers::Offset<Attacker> CreateAttacker(
flatbuffers::FlatBufferBuilder &_fbb,
int32_t sword_attack_damage = 0) {
MuLanBuilder builder_(_fbb);
AttackerBuilder builder_(_fbb);
builder_.add_sword_attack_damage(sword_attack_damage);
return builder_.Finish();
}
struct Rapunzel FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
enum {
VT_HAIR_LENGTH = 4
};
int32_t hair_length() const {
return GetField<int32_t>(VT_HAIR_LENGTH, 0);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_HAIR_LENGTH) &&
verifier.EndTable();
flatbuffers::Offset<Attacker> CreateAttacker(flatbuffers::FlatBufferBuilder &_fbb, const AttackerT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct MovieT : public flatbuffers::NativeTable {
typedef Movie TableType;
CharacterUnion main_character;
std::vector<CharacterUnion> characters;
MovieT() {
}
};
struct RapunzelBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_hair_length(int32_t hair_length) {
fbb_.AddElement<int32_t>(Rapunzel::VT_HAIR_LENGTH, hair_length, 0);
}
RapunzelBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
RapunzelBuilder &operator=(const RapunzelBuilder &);
flatbuffers::Offset<Rapunzel> Finish() {
const auto end = fbb_.EndTable(start_, 1);
auto o = flatbuffers::Offset<Rapunzel>(end);
return o;
}
};
inline flatbuffers::Offset<Rapunzel> CreateRapunzel(
flatbuffers::FlatBufferBuilder &_fbb,
int32_t hair_length = 0) {
RapunzelBuilder builder_(_fbb);
builder_.add_hair_length(hair_length);
return builder_.Finish();
}
struct Belle FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
enum {
VT_BOOKS_READ = 4
};
int32_t books_read() const {
return GetField<int32_t>(VT_BOOKS_READ, 0);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_BOOKS_READ) &&
verifier.EndTable();
}
};
struct BelleBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_books_read(int32_t books_read) {
fbb_.AddElement<int32_t>(Belle::VT_BOOKS_READ, books_read, 0);
}
BelleBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
BelleBuilder &operator=(const BelleBuilder &);
flatbuffers::Offset<Belle> Finish() {
const auto end = fbb_.EndTable(start_, 1);
auto o = flatbuffers::Offset<Belle>(end);
return o;
}
};
inline flatbuffers::Offset<Belle> CreateBelle(
flatbuffers::FlatBufferBuilder &_fbb,
int32_t books_read = 0) {
BelleBuilder builder_(_fbb);
builder_.add_books_read(books_read);
return builder_.Finish();
}
struct Movie FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef MovieT NativeTableType;
enum {
VT_CHARACTERS_TYPE = 4,
VT_CHARACTERS = 6
VT_MAIN_CHARACTER_TYPE = 4,
VT_MAIN_CHARACTER = 6,
VT_CHARACTERS_TYPE = 8,
VT_CHARACTERS = 10
};
Character main_character_type() const {
return static_cast<Character>(GetField<uint8_t>(VT_MAIN_CHARACTER_TYPE, 0));
}
bool mutate_main_character_type(Character _main_character_type) {
return SetField<uint8_t>(VT_MAIN_CHARACTER_TYPE, static_cast<uint8_t>(_main_character_type), 0);
}
const void *main_character() const {
return GetPointer<const void *>(VT_MAIN_CHARACTER);
}
template<typename T> const T *main_character_as() const;
const Attacker *main_character_as_MuLan() const {
return main_character_type() == Character_MuLan ? static_cast<const Attacker *>(main_character()) : nullptr;
}
const Rapunzel *main_character_as_Rapunzel() const {
return main_character_type() == Character_Rapunzel ? static_cast<const Rapunzel *>(main_character()) : nullptr;
}
const BookReader *main_character_as_Belle() const {
return main_character_type() == Character_Belle ? static_cast<const BookReader *>(main_character()) : nullptr;
}
const BookReader *main_character_as_BookFan() const {
return main_character_type() == Character_BookFan ? static_cast<const BookReader *>(main_character()) : nullptr;
}
const flatbuffers::String *main_character_as_Other() const {
return main_character_type() == Character_Other ? static_cast<const flatbuffers::String *>(main_character()) : nullptr;
}
const flatbuffers::String *main_character_as_Unused() const {
return main_character_type() == Character_Unused ? static_cast<const flatbuffers::String *>(main_character()) : nullptr;
}
void *mutable_main_character() {
return GetPointer<void *>(VT_MAIN_CHARACTER);
}
const flatbuffers::Vector<uint8_t> *characters_type() const {
return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_CHARACTERS_TYPE);
}
flatbuffers::Vector<uint8_t> *mutable_characters_type() {
return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_CHARACTERS_TYPE);
}
const flatbuffers::Vector<flatbuffers::Offset<void>> *characters() const {
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<void>> *>(VT_CHARACTERS);
}
flatbuffers::Vector<flatbuffers::Offset<void>> *mutable_characters() {
return GetPointer<flatbuffers::Vector<flatbuffers::Offset<void>> *>(VT_CHARACTERS);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint8_t>(verifier, VT_MAIN_CHARACTER_TYPE) &&
VerifyField<flatbuffers::uoffset_t>(verifier, VT_MAIN_CHARACTER) &&
VerifyCharacter(verifier, main_character(), main_character_type()) &&
VerifyField<flatbuffers::uoffset_t>(verifier, VT_CHARACTERS_TYPE) &&
verifier.Verify(characters_type()) &&
VerifyField<flatbuffers::uoffset_t>(verifier, VT_CHARACTERS) &&
@@ -198,11 +269,20 @@ struct Movie FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VerifyCharacterVector(verifier, characters(), characters_type()) &&
verifier.EndTable();
}
MovieT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(MovieT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<Movie> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MovieT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct MovieBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_main_character_type(Character main_character_type) {
fbb_.AddElement<uint8_t>(Movie::VT_MAIN_CHARACTER_TYPE, static_cast<uint8_t>(main_character_type), 0);
}
void add_main_character(flatbuffers::Offset<void> main_character) {
fbb_.AddOffset(Movie::VT_MAIN_CHARACTER, main_character);
}
void add_characters_type(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> characters_type) {
fbb_.AddOffset(Movie::VT_CHARACTERS_TYPE, characters_type);
}
@@ -215,7 +295,7 @@ struct MovieBuilder {
}
MovieBuilder &operator=(const MovieBuilder &);
flatbuffers::Offset<Movie> Finish() {
const auto end = fbb_.EndTable(start_, 2);
const auto end = fbb_.EndTable(start_, 4);
auto o = flatbuffers::Offset<Movie>(end);
return o;
}
@@ -223,40 +303,118 @@ struct MovieBuilder {
inline flatbuffers::Offset<Movie> CreateMovie(
flatbuffers::FlatBufferBuilder &_fbb,
Character main_character_type = Character_NONE,
flatbuffers::Offset<void> main_character = 0,
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> characters_type = 0,
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<void>>> characters = 0) {
MovieBuilder builder_(_fbb);
builder_.add_characters(characters);
builder_.add_characters_type(characters_type);
builder_.add_main_character(main_character);
builder_.add_main_character_type(main_character_type);
return builder_.Finish();
}
inline flatbuffers::Offset<Movie> CreateMovieDirect(
flatbuffers::FlatBufferBuilder &_fbb,
Character main_character_type = Character_NONE,
flatbuffers::Offset<void> main_character = 0,
const std::vector<uint8_t> *characters_type = nullptr,
const std::vector<flatbuffers::Offset<void>> *characters = nullptr) {
return CreateMovie(
_fbb,
main_character_type,
main_character,
characters_type ? _fbb.CreateVector<uint8_t>(*characters_type) : 0,
characters ? _fbb.CreateVector<flatbuffers::Offset<void>>(*characters) : 0);
}
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 {
auto _o = new AttackerT();
UnPackTo(_o, _resolver);
return _o;
}
inline void Attacker::UnPackTo(AttackerT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = sword_attack_damage(); _o->sword_attack_damage = _e; };
}
inline flatbuffers::Offset<Attacker> Attacker::Pack(flatbuffers::FlatBufferBuilder &_fbb, const AttackerT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateAttacker(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<Attacker> CreateAttacker(flatbuffers::FlatBufferBuilder &_fbb, const AttackerT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
auto _sword_attack_damage = _o->sword_attack_damage;
return CreateAttacker(
_fbb,
_sword_attack_damage);
}
inline MovieT *Movie::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = new MovieT();
UnPackTo(_o, _resolver);
return _o;
}
inline void Movie::UnPackTo(MovieT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = main_character_type(); _o->main_character.type = _e; };
{ auto _e = main_character(); if (_e) _o->main_character.value = CharacterUnion::UnPack(_e, main_character_type(), _resolver); };
{ auto _e = characters_type(); if (_e) { _o->characters.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->characters[_i].type = (Character)_e->Get(_i); } } };
{ 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); } } };
}
inline flatbuffers::Offset<Movie> Movie::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MovieT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateMovie(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<Movie> CreateMovie(flatbuffers::FlatBufferBuilder &_fbb, const MovieT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
auto _main_character_type = _o->main_character.type;
auto _main_character = _o->main_character.Pack(_fbb);
auto _characters_type = _o->characters.size() ? _fbb.CreateVector<uint8_t>(_o->characters.size(), [&](size_t i) { return static_cast<uint8_t>(_o->characters[i].type); }) : 0;
auto _characters = _o->characters.size() ? _fbb.CreateVector<flatbuffers::Offset<void>>(_o->characters.size(), [&](size_t i) { return _o->characters[i].Pack(_fbb, _rehasher); }) : 0;
return CreateMovie(
_fbb,
_main_character_type,
_main_character,
_characters_type,
_characters);
}
inline bool VerifyCharacter(flatbuffers::Verifier &verifier, const void *obj, Character type) {
switch (type) {
case Character_NONE: {
return true;
}
case Character_MuLan: {
auto ptr = reinterpret_cast<const MuLan *>(obj);
auto ptr = reinterpret_cast<const Attacker *>(obj);
return verifier.VerifyTable(ptr);
}
case Character_Rapunzel: {
auto ptr = reinterpret_cast<const Rapunzel *>(obj);
return verifier.VerifyTable(ptr);
return true;
}
case Character_Belle: {
auto ptr = reinterpret_cast<const Belle *>(obj);
return verifier.VerifyTable(ptr);
return true;
}
case Character_BookFan: {
return true;
}
case Character_Other: {
auto ptr = reinterpret_cast<const flatbuffers::String *>(obj);
return verifier.Verify(ptr);
}
case Character_Unused: {
auto ptr = reinterpret_cast<const flatbuffers::String *>(obj);
return verifier.Verify(ptr);
}
default: return false;
}
@@ -273,10 +431,112 @@ inline bool VerifyCharacterVector(flatbuffers::Verifier &verifier, const flatbuf
return true;
}
inline void *CharacterUnion::UnPack(const void *obj, Character type, const flatbuffers::resolver_function_t *resolver) {
switch (type) {
case Character_MuLan: {
auto ptr = reinterpret_cast<const Attacker *>(obj);
return ptr->UnPack(resolver);
}
case Character_Rapunzel: {
auto ptr = reinterpret_cast<const Rapunzel *>(obj);
return new Rapunzel(*ptr);
}
case Character_Belle: {
auto ptr = reinterpret_cast<const BookReader *>(obj);
return new BookReader(*ptr);
}
case Character_BookFan: {
auto ptr = reinterpret_cast<const BookReader *>(obj);
return new BookReader(*ptr);
}
case Character_Other: {
auto ptr = reinterpret_cast<const flatbuffers::String *>(obj);
return new std::string(ptr->c_str(), ptr->size());
}
case Character_Unused: {
auto ptr = reinterpret_cast<const flatbuffers::String *>(obj);
return new std::string(ptr->c_str(), ptr->size());
}
default: return nullptr;
}
}
inline flatbuffers::Offset<void> CharacterUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const {
switch (type) {
case Character_MuLan: {
auto ptr = reinterpret_cast<const AttackerT *>(value);
return CreateAttacker(_fbb, ptr, _rehasher).Union();
}
case Character_Rapunzel: {
auto ptr = reinterpret_cast<const Rapunzel *>(value);
return _fbb.CreateStruct(*ptr).Union();
}
case Character_Belle: {
auto ptr = reinterpret_cast<const BookReader *>(value);
return _fbb.CreateStruct(*ptr).Union();
}
case Character_BookFan: {
auto ptr = reinterpret_cast<const BookReader *>(value);
return _fbb.CreateStruct(*ptr).Union();
}
case Character_Other: {
auto ptr = reinterpret_cast<const std::string *>(value);
return _fbb.CreateString(*ptr).Union();
}
case Character_Unused: {
auto ptr = reinterpret_cast<const std::string *>(value);
return _fbb.CreateString(*ptr).Union();
}
default: return 0;
}
}
inline void CharacterUnion::Reset() {
switch (type) {
case Character_MuLan: {
auto ptr = reinterpret_cast<AttackerT *>(value);
delete ptr;
break;
}
case Character_Rapunzel: {
auto ptr = reinterpret_cast<Rapunzel *>(value);
delete ptr;
break;
}
case Character_Belle: {
auto ptr = reinterpret_cast<BookReader *>(value);
delete ptr;
break;
}
case Character_BookFan: {
auto ptr = reinterpret_cast<BookReader *>(value);
delete ptr;
break;
}
case Character_Other: {
auto ptr = reinterpret_cast<std::string *>(value);
delete ptr;
break;
}
case Character_Unused: {
auto ptr = reinterpret_cast<std::string *>(value);
delete ptr;
break;
}
default: break;
}
value = nullptr;
type = Character_NONE;
}
inline const Movie *GetMovie(const void *buf) {
return flatbuffers::GetRoot<Movie>(buf);
}
inline Movie *GetMutableMovie(void *buf) {
return flatbuffers::GetMutableRoot<Movie>(buf);
}
inline const char *MovieIdentifier() {
return "MOVI";
}
@@ -297,4 +557,10 @@ inline void FinishMovieBuffer(
fbb.Finish(root, MovieIdentifier());
}
inline std::unique_ptr<MovieT> UnPackMovie(
const void *buf,
const flatbuffers::resolver_function_t *res = nullptr) {
return std::unique_ptr<MovieT>(GetMovie(buf)->UnPack(res));
}
#endif // FLATBUFFERS_GENERATED_UNIONVECTOR_H_