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

add test

Browse Source
This commit is contained in:
Justin Davis
2025-12-09 22:01:51 -05:00
parent c7627432ef
commit 45e352b18f
11 changed files with 454 additions and 41 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -556,6 +556,7 @@ struct MovieT : public ::flatbuffers::NativeTable {
typedef Movie TableType;
CharacterUnion main_character{};
std::vector<CharacterUnion> characters{};
GadgetUnion gadget{};
};
struct Movie FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
@@ -569,7 +570,9 @@ struct Movie FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
VT_MAIN_CHARACTER_TYPE = 4,
VT_MAIN_CHARACTER = 6,
VT_CHARACTERS_TYPE = 8,
VT_CHARACTERS = 10
VT_CHARACTERS = 10,
VT_GADGET_TYPE = 12,
VT_GADGET = 14
};
Character main_character_type() const {
return static_cast<Character>(GetField<uint8_t>(VT_MAIN_CHARACTER_TYPE, 0));
@@ -628,12 +631,37 @@ struct Movie FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
::flatbuffers::Vector<::flatbuffers::Offset<void>> *mutable_characters() {
return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<void>> *>(VT_CHARACTERS);
}
Gadget gadget_type() const {
return static_cast<Gadget>(GetField<uint8_t>(VT_GADGET_TYPE, 0));
}
const void *gadget() const {
return GetPointer<const void *>(VT_GADGET);
}
template<typename T> const T *gadget_as() const;
const FallingTub *gadget_as_FallingTub() const {
return gadget_type() == Gadget::FallingTub ? static_cast<const FallingTub *>(gadget()) : nullptr;
}
const HandFan *gadget_as_HandFan() const {
return gadget_type() == Gadget::HandFan ? static_cast<const HandFan *>(gadget()) : nullptr;
}
void *mutable_gadget() {
return GetPointer<void *>(VT_GADGET);
}
template<typename T> T *mutable_gadget_as();
FallingTub *mutable_gadget_as_FallingTub() {
return gadget_type() == Gadget::FallingTub ? static_cast<FallingTub *>(mutable_gadget()) : nullptr;
}
HandFan *mutable_gadget_as_HandFan() {
return gadget_type() == Gadget::HandFan ? static_cast<HandFan *>(mutable_gadget()) : nullptr;
}
template<size_t Index>
auto get_field() const {
if constexpr (Index == 0) return main_character_type();
else if constexpr (Index == 1) return main_character();
else if constexpr (Index == 2) return characters_type();
else if constexpr (Index == 3) return characters();
else if constexpr (Index == 4) return gadget_type();
else if constexpr (Index == 5) return gadget();
else static_assert(Index != -1, "Invalid Field Index");
}
template <bool B = false>
@@ -647,6 +675,9 @@ struct Movie FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
VerifyOffset(verifier, VT_CHARACTERS) &&
verifier.VerifyVector(characters()) &&
VerifyCharacterVector(verifier, characters(), characters_type()) &&
VerifyField<uint8_t>(verifier, VT_GADGET_TYPE, 1) &&
VerifyOffset(verifier, VT_GADGET) &&
VerifyGadget(verifier, gadget(), gadget_type()) &&
verifier.EndTable();
}
MovieT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
@@ -654,6 +685,22 @@ struct Movie FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
static ::flatbuffers::Offset<Movie> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const MovieT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
template<> inline const FallingTub *Movie::gadget_as<FallingTub>() const {
return gadget_as_FallingTub();
}
template<> inline FallingTub *Movie::mutable_gadget_as<FallingTub>() {
return mutable_gadget_as_FallingTub();
}
template<> inline const HandFan *Movie::gadget_as<HandFan>() const {
return gadget_as_HandFan();
}
template<> inline HandFan *Movie::mutable_gadget_as<HandFan>() {
return mutable_gadget_as_HandFan();
}
struct MovieBuilder {
typedef Movie Table;
::flatbuffers::FlatBufferBuilder &fbb_;
@@ -670,6 +717,12 @@ struct MovieBuilder {
void add_characters(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<void>>> characters) {
fbb_.AddOffset(Movie::VT_CHARACTERS, characters);
}
void add_gadget_type(Gadget gadget_type) {
fbb_.AddElement<uint8_t>(Movie::VT_GADGET_TYPE, static_cast<uint8_t>(gadget_type), 0);
}
void add_gadget(::flatbuffers::Offset<void> gadget) {
fbb_.AddOffset(Movie::VT_GADGET, gadget);
}
explicit MovieBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
@@ -686,11 +739,15 @@ inline ::flatbuffers::Offset<Movie> CreateMovie(
Character main_character_type = Character::NONE,
::flatbuffers::Offset<void> main_character = 0,
::flatbuffers::Offset<::flatbuffers::Vector<Character>> characters_type = 0,
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<void>>> characters = 0) {
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<void>>> characters = 0,
Gadget gadget_type = Gadget::NONE,
::flatbuffers::Offset<void> gadget = 0) {
MovieBuilder builder_(_fbb);
builder_.add_gadget(gadget);
builder_.add_characters(characters);
builder_.add_characters_type(characters_type);
builder_.add_main_character(main_character);
builder_.add_gadget_type(gadget_type);
builder_.add_main_character_type(main_character_type);
return builder_.Finish();
}
@@ -700,12 +757,14 @@ struct Movie::Traits {
static auto constexpr Create = CreateMovie;
static constexpr auto name = "Movie";
static constexpr auto fully_qualified_name = "Movie";
static constexpr size_t fields_number = 4;
static constexpr size_t fields_number = 6;
static constexpr std::array<const char *, fields_number> field_names = {
"main_character_type",
"main_character",
"characters_type",
"characters"
"characters",
"gadget_type",
"gadget"
};
template<size_t Index>
using FieldType = decltype(std::declval<type>().get_field<Index>());
@@ -716,7 +775,9 @@ inline ::flatbuffers::Offset<Movie> CreateMovieDirect(
Character main_character_type = Character::NONE,
::flatbuffers::Offset<void> main_character = 0,
const std::vector<Character> *characters_type = nullptr,
const std::vector<::flatbuffers::Offset<void>> *characters = nullptr) {
const std::vector<::flatbuffers::Offset<void>> *characters = nullptr,
Gadget gadget_type = Gadget::NONE,
::flatbuffers::Offset<void> gadget = 0) {
auto characters_type__ = characters_type ? _fbb.CreateVector<Character>(*characters_type) : 0;
auto characters__ = characters ? _fbb.CreateVector<::flatbuffers::Offset<void>>(*characters) : 0;
return CreateMovie(
@@ -724,7 +785,9 @@ inline ::flatbuffers::Offset<Movie> CreateMovieDirect(
main_character_type,
main_character,
characters_type__,
characters__);
characters__,
gadget_type,
gadget);
}
::flatbuffers::Offset<Movie> CreateMovie(::flatbuffers::FlatBufferBuilder &_fbb, const MovieT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
@@ -794,6 +857,8 @@ inline void Movie::UnPackTo(MovieT *_o, const ::flatbuffers::resolver_function_t
{ auto _e = main_character(); if (_e) _o->main_character.value = CharacterUnion::UnPack(_e, main_character_type(), _resolver); }
{ auto _e = characters_type(); if (_e) { _o->characters.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->characters[_i].type = static_cast<Character>(_e->Get(_i)); } } else { _o->characters.resize(0); } }
{ auto _e = characters(); if (_e) { _o->characters.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->characters[_i].value = CharacterUnion::UnPack(_e->Get(_i), characters_type()->GetEnum<Character>(_i), _resolver); } } else { _o->characters.resize(0); } }
{ auto _e = gadget_type(); _o->gadget.type = _e; }
{ auto _e = gadget(); if (_e) _o->gadget.value = GadgetUnion::UnPack(_e, gadget_type(), _resolver); }
}
inline ::flatbuffers::Offset<Movie> CreateMovie(::flatbuffers::FlatBufferBuilder &_fbb, const MovieT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
@@ -808,12 +873,16 @@ inline ::flatbuffers::Offset<Movie> Movie::Pack(::flatbuffers::FlatBufferBuilder
auto _main_character = _o->main_character.Pack(_fbb);
auto _characters_type = _o->characters.size() ? _fbb.CreateVector<Character>(_o->characters.size(), [](size_t i, _VectorArgs *__va) { return __va->__o->characters[i].type; }, &_va) : 0;
auto _characters = _o->characters.size() ? _fbb.CreateVector<::flatbuffers::Offset<void>>(_o->characters.size(), [](size_t i, _VectorArgs *__va) { return __va->__o->characters[i].Pack(*__va->__fbb, __va->__rehasher); }, &_va) : 0;
auto _gadget_type = _o->gadget.type;
auto _gadget = _o->gadget.Pack(_fbb);
return CreateMovie(
_fbb,
_main_character_type,
_main_character,
_characters_type,
_characters);
_characters,
_gadget_type,
_gadget);
}
template <bool B>
@@ -1208,19 +1277,24 @@ inline const ::flatbuffers::TypeTable *MovieTypeTable() {
{ ::flatbuffers::ET_UTYPE, 0, 0 },
{ ::flatbuffers::ET_SEQUENCE, 0, 0 },
{ ::flatbuffers::ET_UTYPE, 1, 0 },
{ ::flatbuffers::ET_SEQUENCE, 1, 0 }
{ ::flatbuffers::ET_SEQUENCE, 1, 0 },
{ ::flatbuffers::ET_UTYPE, 0, 1 },
{ ::flatbuffers::ET_SEQUENCE, 0, 1 }
};
static const ::flatbuffers::TypeFunction type_refs[] = {
CharacterTypeTable
CharacterTypeTable,
GadgetTypeTable
};
static const char * const names[] = {
"main_character_type",
"main_character",
"characters_type",
"characters"
"characters",
"gadget_type",
"gadget"
};
static const ::flatbuffers::TypeTable tt = {
::flatbuffers::ST_TABLE, 4, type_codes, type_refs, nullptr, nullptr, names
::flatbuffers::ST_TABLE, 6, type_codes, type_refs, nullptr, nullptr, names
};
return &tt;
}

50
tests/cpp17/test_cpp17.cpp
View File

@@ -255,10 +255,60 @@ void OptionalScalarsTest() {
TEST_ASSERT(opts->maybe_i32() == std::optional<int64_t>(-1));
}
void MutableUnionMembersTest() {
flatbuffers::FlatBufferBuilder fbb;
// Create a Movie with union members
auto other_str = fbb.CreateString("other_character");
auto attacker = cpp17::CreateAttacker(fbb, 100);
std::vector<flatbuffers::Offset<void>> characters_vec;
std::vector<cpp17::Character> character_types;
characters_vec.push_back(attacker.Union());
character_types.push_back(cpp17::Character::MuLan);
characters_vec.push_back(other_str.Union());
character_types.push_back(cpp17::Character::Other);
auto characters_vector = fbb.CreateVector(characters_vec);
auto character_types_vector = fbb.CreateVector(character_types);
auto hand_fan = cpp17::CreateHandFan(fbb, 55);
auto movie = cpp17::CreateMovie(
fbb, cpp17::Character::MuLan, attacker.Union(), character_types_vector,
characters_vector, cpp17::Gadget::HandFan, hand_fan.Union());
fbb.Finish(movie);
// Test mutable union accessors
auto mutable_movie = cpp17::GetMutableMovie(fbb.GetBufferPointer());
// Test main_character union
TEST_EQ(mutable_movie->main_character_type(), cpp17::Character::MuLan);
auto main_attacker = mutable_movie->mutable_main_character_as_MuLan();
TEST_ASSERT(main_attacker != nullptr);
TEST_EQ(main_attacker->sword_attack_damage(), 100);
TEST_ASSERT(main_attacker->mutate_sword_attack_damage(150));
TEST_EQ(main_attacker->sword_attack_damage(), 150);
TEST_EQ(mutable_movie->gadget_as<cpp17::HandFan>()->length(), 55);
mutable_movie->mutable_gadget_as<cpp17::HandFan>()->mutate_length(75);
TEST_EQ(mutable_movie->gadget_as<cpp17::HandFan>()->length(), 75);
TEST_ASSERT(mutable_movie->mutable_gadget_as<cpp17::FallingTub>() == nullptr);
// Test characters vector unions
TEST_EQ(mutable_movie->characters_type()->size(), 2);
TEST_EQ(mutable_movie->characters_type()->Get(0), cpp17::Character::MuLan);
TEST_EQ(mutable_movie->characters_type()->Get(1), cpp17::Character::Other);
}
int FlatBufferCpp17Tests() {
CreateTableByTypeTest();
OptionalScalarsTest();
StringifyAnyFlatbuffersTypeTest();
MutableUnionMembersTest();
return 0;
}
} // namespace

54
tests/swift/Tests/Flatbuffers/union_vector_generated.swift
View File

@@ -496,6 +496,8 @@ public struct Movie: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable
case mainCharacter = 6
case charactersType = 8
case characters = 10
case gadgetType = 12
case gadget = 14
var v: Int32 { Int32(self.rawValue) }
var p: VOffset { self.rawValue }
}
@@ -505,24 +507,32 @@ public struct Movie: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable
public var charactersType: FlatbufferVector<Character> { return _accessor.vector(at: VTOFFSET.charactersType.v, byteSize: 1) }
public var characters: UnionFlatbufferVector { return _accessor.unionVector(at: VTOFFSET.characters.v, byteSize: 4) }
public func characters<T: FlatbuffersInitializable>(at index: Int32, type: T.Type) -> T? { let o = _accessor.offset(VTOFFSET.characters.v); return o == 0 ? nil : _accessor.directUnion(_accessor.vector(at: o) + index * 4) }
public static func startMovie(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 4) }
public var gadgetType: Gadget { let o = _accessor.offset(VTOFFSET.gadgetType.v); return o == 0 ? .none_ : Gadget(rawValue: _accessor.readBuffer(of: UInt8.self, at: o)) ?? .none_ }
public func gadget<T: FlatbuffersInitializable>(type: T.Type) -> T? { let o = _accessor.offset(VTOFFSET.gadget.v); return o == 0 ? nil : _accessor.union(o) }
public static func startMovie(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 6) }
public static func add(mainCharacterType: Character, _ fbb: inout FlatBufferBuilder) { fbb.add(element: mainCharacterType.rawValue, def: 0, at: VTOFFSET.mainCharacterType.p) }
public static func add(mainCharacter: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: mainCharacter, at: VTOFFSET.mainCharacter.p) }
public static func addVectorOf(charactersType: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: charactersType, at: VTOFFSET.charactersType.p) }
public static func addVectorOf(characters: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: characters, at: VTOFFSET.characters.p) }
public static func add(gadgetType: Gadget, _ fbb: inout FlatBufferBuilder) { fbb.add(element: gadgetType.rawValue, def: 0, at: VTOFFSET.gadgetType.p) }
public static func add(gadget: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: gadget, at: VTOFFSET.gadget.p) }
public static func endMovie(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
public static func createMovie(
_ fbb: inout FlatBufferBuilder,
mainCharacterType: Character = .none_,
mainCharacterOffset mainCharacter: Offset = Offset(),
charactersTypeVectorOffset charactersType: Offset = Offset(),
charactersVectorOffset characters: Offset = Offset()
charactersVectorOffset characters: Offset = Offset(),
gadgetType: Gadget = .none_,
gadgetOffset gadget: Offset = Offset()
) -> Offset {
let __start = Movie.startMovie(&fbb)
Movie.add(mainCharacterType: mainCharacterType, &fbb)
Movie.add(mainCharacter: mainCharacter, &fbb)
Movie.addVectorOf(charactersType: charactersType, &fbb)
Movie.addVectorOf(characters: characters, &fbb)
Movie.add(gadgetType: gadgetType, &fbb)
Movie.add(gadget: gadget, &fbb)
return Movie.endMovie(&fbb, start: __start)
}
@@ -543,6 +553,7 @@ public struct Movie: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable
}
let __characters = builder.createVector(ofOffsets: __characters__)
let __charactersType = builder.createVector(obj.characters.compactMap { $0?.type })
let __gadget = obj.gadget?.pack(builder: &builder) ?? Offset()
let __root = Movie.startMovie(&builder)
if let o = obj.mainCharacter?.type {
Movie.add(mainCharacterType: o, &builder)
@@ -551,6 +562,11 @@ public struct Movie: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable
Movie.addVectorOf(charactersType: __charactersType, &builder)
Movie.addVectorOf(characters: __characters, &builder)
if let o = obj.gadget?.type {
Movie.add(gadgetType: o, &builder)
Movie.add(gadget: __gadget, &builder)
}
return Movie.endMovie(&builder, start: __root)
}
@@ -592,6 +608,16 @@ public struct Movie: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable
try ForwardOffset<String>.verify(&verifier, at: pos, of: String.self)
}
})
try _v.visit(unionKey: VTOFFSET.gadgetType.p, unionField: VTOFFSET.gadget.p, unionKeyName: "gadgetType", fieldName: "gadget", required: false, completion: { (verifier, key: Gadget, pos) in
switch key {
case .none_:
break // NOTE - SWIFT doesnt support none
case .fallingtub:
try FallingTub.verify(&verifier, at: pos, of: FallingTub.self)
case .handfan:
try ForwardOffset<HandFan>.verify(&verifier, at: pos, of: HandFan.self)
}
})
_v.finish()
}
}
@@ -603,6 +629,8 @@ extension Movie: Encodable {
case mainCharacter = "main_character"
case charactersType = "characters_type"
case characters = "characters"
case gadgetType = "gadget_type"
case gadget = "gadget"
}
public func encode(to encoder: Encoder) throws {
var container = encoder.container(keyedBy: CodingKeys.self)
@@ -656,6 +684,18 @@ extension Movie: Encodable {
default: break;
}
}
if gadgetType != .none_ {
try container.encodeIfPresent(gadgetType, forKey: .gadgetType)
}
switch gadgetType {
case .fallingtub:
let _v = gadget(type: FallingTub.self)
try container.encodeIfPresent(_v, forKey: .gadget)
case .handfan:
let _v = gadget(type: HandFan.self)
try container.encodeIfPresent(_v, forKey: .gadget)
default: break;
}
}
}
@@ -663,6 +703,7 @@ public class MovieT: NativeObject {
public var mainCharacter: CharacterUnion?
public var characters: [CharacterUnion?]
public var gadget: GadgetUnion?
public init(_ _t: borrowing Movie) {
switch _t.mainCharacterType {
@@ -711,6 +752,15 @@ public class MovieT: NativeObject {
default: break
}
}
switch _t.gadgetType {
case .fallingtub:
let _v = _t.gadget(type: FallingTub_Mutable.self)
gadget = GadgetUnion(_v?.unpack(), type: .fallingtub)
case .handfan:
let _v = _t.gadget(type: HandFan.self)
gadget = GadgetUnion(_v?.unpack(), type: .handfan)
default: break
}
}
public init() {

48
tests/ts/union_vector/movie.ts
View File

@@ -7,6 +7,9 @@ import * as flatbuffers from 'flatbuffers';
import { Attacker, AttackerT } from './attacker.js';
import { BookReader, BookReaderT } from './book-reader.js';
import { Character, unionToCharacter, unionListToCharacter } from './character.js';
import { FallingTub, FallingTubT } from './falling-tub.js';
import { Gadget, unionToGadget, unionListToGadget } from './gadget.js';
import { HandFan, HandFanT } from './hand-fan.js';
import { Rapunzel, RapunzelT } from './rapunzel.js';
@@ -67,12 +70,22 @@ charactersLength():number {
return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;
}
gadgetType():Gadget {
const offset = this.bb!.__offset(this.bb_pos, 12);
return offset ? this.bb!.readUint8(this.bb_pos + offset) : Gadget.NONE;
}
gadget<T extends flatbuffers.Table>(obj:any):any|null {
const offset = this.bb!.__offset(this.bb_pos, 14);
return offset ? this.bb!.__union(obj, this.bb_pos + offset) : null;
}
static getFullyQualifiedName(): "Movie" {
return 'Movie';
}
static startMovie(builder:flatbuffers.Builder) {
builder.startObject(4);
builder.startObject(6);
}
static addMainCharacterType(builder:flatbuffers.Builder, mainCharacterType:Character) {
@@ -115,6 +128,14 @@ static startCharactersVector(builder:flatbuffers.Builder, numElems:number) {
builder.startVector(4, numElems, 4);
}
static addGadgetType(builder:flatbuffers.Builder, gadgetType:Gadget) {
builder.addFieldInt8(4, gadgetType, Gadget.NONE);
}
static addGadget(builder:flatbuffers.Builder, gadgetOffset:flatbuffers.Offset) {
builder.addFieldOffset(5, gadgetOffset, 0);
}
static endMovie(builder:flatbuffers.Builder):flatbuffers.Offset {
const offset = builder.endObject();
return offset;
@@ -128,12 +149,14 @@ static finishSizePrefixedMovieBuffer(builder:flatbuffers.Builder, offset:flatbuf
builder.finish(offset, 'MOVI', true);
}
static createMovie(builder:flatbuffers.Builder, mainCharacterType:Character, mainCharacterOffset:flatbuffers.Offset, charactersTypeOffset:flatbuffers.Offset, charactersOffset:flatbuffers.Offset):flatbuffers.Offset {
static createMovie(builder:flatbuffers.Builder, mainCharacterType:Character, mainCharacterOffset:flatbuffers.Offset, charactersTypeOffset:flatbuffers.Offset, charactersOffset:flatbuffers.Offset, gadgetType:Gadget, gadgetOffset:flatbuffers.Offset):flatbuffers.Offset {
Movie.startMovie(builder);
Movie.addMainCharacterType(builder, mainCharacterType);
Movie.addMainCharacter(builder, mainCharacterOffset);
Movie.addCharactersType(builder, charactersTypeOffset);
Movie.addCharacters(builder, charactersOffset);
Movie.addGadgetType(builder, gadgetType);
Movie.addGadget(builder, gadgetOffset);
return Movie.endMovie(builder);
}
@@ -159,6 +182,12 @@ unpack(): MovieT {
ret.push(temp.unpack());
}
return ret;
})(),
this.gadgetType(),
(() => {
const temp = unionToGadget(this.gadgetType(), this.gadget.bind(this));
if(temp === null) { return null; }
return temp.unpack()
})()
);
}
@@ -186,6 +215,12 @@ unpackTo(_o: MovieT): void {
}
return ret;
})();
_o.gadgetType = this.gadgetType();
_o.gadget = (() => {
const temp = unionToGadget(this.gadgetType(), this.gadget.bind(this));
if(temp === null) { return null; }
return temp.unpack()
})();
}
}
@@ -194,7 +229,9 @@ constructor(
public mainCharacterType: Character = Character.NONE,
public mainCharacter: AttackerT|BookReaderT|RapunzelT|string|null = null,
public charactersType: (Character)[] = [],
public characters: (AttackerT|BookReaderT|RapunzelT|string)[] = []
public characters: (AttackerT|BookReaderT|RapunzelT|string)[] = [],
public gadgetType: Gadget = Gadget.NONE,
public gadget: FallingTubT|HandFanT|null = null
){}
@@ -202,12 +239,15 @@ pack(builder:flatbuffers.Builder): flatbuffers.Offset {
const mainCharacter = builder.createObjectOffset(this.mainCharacter);
const charactersType = Movie.createCharactersTypeVector(builder, this.charactersType);
const characters = Movie.createCharactersVector(builder, builder.createObjectOffsetList(this.characters));
const gadget = builder.createObjectOffset(this.gadget);
return Movie.createMovie(builder,
this.mainCharacterType,
mainCharacter,
charactersType,
characters
characters,
this.gadgetType,
gadget
);
}
}

49
tests/union_vector/Movie.cs
View File

@@ -38,21 +38,29 @@ public struct Movie : IFlatbufferObject
public TTable? Characters<TTable>(int j) where TTable : struct, IFlatbufferObject { int o = __p.__offset(10); return o != 0 ? (TTable?)__p.__union<TTable>(__p.__vector(o) + j * 4) : null; }
public string CharactersAsString(int j) { int o = __p.__offset(10); return o != 0 ? __p.__string(__p.__vector(o) + j * 4) : null; }
public int CharactersLength { get { int o = __p.__offset(10); return o != 0 ? __p.__vector_len(o) : 0; } }
public Gadget GadgetType { get { int o = __p.__offset(12); return o != 0 ? (Gadget)__p.bb.Get(o + __p.bb_pos) : Gadget.NONE; } }
public TTable? Gadget<TTable>() where TTable : struct, IFlatbufferObject { int o = __p.__offset(14); return o != 0 ? (TTable?)__p.__union<TTable>(o + __p.bb_pos) : null; }
public FallingTub GadgetAsFallingTub() { return Gadget<FallingTub>().Value; }
public HandFan GadgetAsHandFan() { return Gadget<HandFan>().Value; }
public static Offset<Movie> CreateMovie(FlatBufferBuilder builder,
Character main_character_type = Character.NONE,
int main_characterOffset = 0,
VectorOffset characters_typeOffset = default(VectorOffset),
VectorOffset charactersOffset = default(VectorOffset)) {
builder.StartTable(4);
VectorOffset charactersOffset = default(VectorOffset),
Gadget gadget_type = Gadget.NONE,
int gadgetOffset = 0) {
builder.StartTable(6);
Movie.AddGadget(builder, gadgetOffset);
Movie.AddCharacters(builder, charactersOffset);
Movie.AddCharactersType(builder, characters_typeOffset);
Movie.AddMainCharacter(builder, main_characterOffset);
Movie.AddGadgetType(builder, gadget_type);
Movie.AddMainCharacterType(builder, main_character_type);
return Movie.EndMovie(builder);
}
public static void StartMovie(FlatBufferBuilder builder) { builder.StartTable(4); }
public static void StartMovie(FlatBufferBuilder builder) { builder.StartTable(6); }
public static void AddMainCharacterType(FlatBufferBuilder builder, Character mainCharacterType) { builder.AddByte(0, (byte)mainCharacterType, 0); }
public static void AddMainCharacter(FlatBufferBuilder builder, int mainCharacterOffset) { builder.AddOffset(1, mainCharacterOffset, 0); }
public static void AddCharactersType(FlatBufferBuilder builder, VectorOffset charactersTypeOffset) { builder.AddOffset(2, charactersTypeOffset.Value, 0); }
@@ -67,6 +75,8 @@ public struct Movie : IFlatbufferObject
public static VectorOffset CreateCharactersVectorBlock(FlatBufferBuilder builder, ArraySegment<int> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
public static VectorOffset CreateCharactersVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<int>(dataPtr, sizeInBytes); return builder.EndVector(); }
public static void StartCharactersVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
public static void AddGadgetType(FlatBufferBuilder builder, Gadget gadgetType) { builder.AddByte(4, (byte)gadgetType, 0); }
public static void AddGadget(FlatBufferBuilder builder, int gadgetOffset) { builder.AddOffset(5, gadgetOffset, 0); }
public static Offset<Movie> EndMovie(FlatBufferBuilder builder) {
int o = builder.EndTable();
return new Offset<Movie>(o);
@@ -129,6 +139,17 @@ public struct Movie : IFlatbufferObject
}
_o.Characters.Add(_o_Characters);
}
_o.Gadget = new GadgetUnion();
_o.Gadget.Type = this.GadgetType;
switch (this.GadgetType) {
default: break;
case Gadget.FallingTub:
_o.Gadget.Value = this.Gadget<FallingTub>().HasValue ? this.Gadget<FallingTub>().Value.UnPack() : null;
break;
case Gadget.HandFan:
_o.Gadget.Value = this.Gadget<HandFan>().HasValue ? this.Gadget<HandFan>().Value.UnPack() : null;
break;
}
}
public static Offset<Movie> Pack(FlatBufferBuilder builder, MovieT _o) {
if (_o == null) return default(Offset<Movie>);
@@ -146,12 +167,16 @@ public struct Movie : IFlatbufferObject
for (var _j = 0; _j < __characters.Length; ++_j) { __characters[_j] = CharacterUnion.Pack(builder, _o.Characters[_j]); }
_characters = CreateCharactersVector(builder, __characters);
}
var _gadget_type = _o.Gadget == null ? Gadget.NONE : _o.Gadget.Type;
var _gadget = _o.Gadget == null ? 0 : GadgetUnion.Pack(builder, _o.Gadget);
return CreateMovie(
builder,
_main_character_type,
_main_character,
_characters_type,
_characters);
_characters,
_gadget_type,
_gadget);
}
}
@@ -190,10 +215,24 @@ public class MovieT
[Newtonsoft.Json.JsonProperty("characters")]
[Newtonsoft.Json.JsonConverter(typeof(CharacterUnion_JsonConverter))]
public List<CharacterUnion> Characters { get; set; }
[Newtonsoft.Json.JsonProperty("gadget_type")]
private Gadget GadgetType {
get {
return this.Gadget != null ? this.Gadget.Type : Gadget.NONE;
}
set {
this.Gadget = new GadgetUnion();
this.Gadget.Type = value;
}
}
[Newtonsoft.Json.JsonProperty("gadget")]
[Newtonsoft.Json.JsonConverter(typeof(GadgetUnion_JsonConverter))]
public GadgetUnion Gadget { get; set; }
public MovieT() {
this.MainCharacter = null;
this.Characters = null;
this.Gadget = null;
}
public static MovieT DeserializeFromJson(string jsonText) {
@@ -221,6 +260,8 @@ static public class MovieVerify
&& verifier.VerifyField(tablePos, 4 /*MainCharacterType*/, 1 /*Character*/, 1, false)
&& verifier.VerifyUnion(tablePos, 4, 6 /*MainCharacter*/, CharacterVerify.Verify, false)
&& verifier.VerifyVectorOfData(tablePos, 8 /*CharactersType*/, 1 /*Character*/, false)
&& verifier.VerifyField(tablePos, 12 /*GadgetType*/, 1 /*Gadget*/, 1, false)
&& verifier.VerifyUnion(tablePos, 12, 14 /*Gadget*/, GadgetVerify.Verify, false)
&& verifier.VerifyTableEnd(tablePos);
}
}

32
tests/union_vector/Movie.java
View File

@@ -37,21 +37,27 @@ public final class Movie extends com.google.flatbuffers.Table {
public int charactersLength() { int o = __offset(10); return o != 0 ? __vector_len(o) : 0; }
public UnionVector charactersVector() { return charactersVector(new UnionVector()); }
public UnionVector charactersVector(UnionVector obj) { int o = __offset(10); return o != 0 ? obj.__assign(__vector(o), 4, bb) : null; }
public byte gadgetType() { int o = __offset(12); return o != 0 ? bb.get(o + bb_pos) : 0; }
public com.google.flatbuffers.Table gadget(com.google.flatbuffers.Table obj) { int o = __offset(14); return o != 0 ? __union(obj, o + bb_pos) : null; }
public static int createMovie(FlatBufferBuilder builder,
byte mainCharacterType,
int mainCharacterOffset,
int charactersTypeOffset,
int charactersOffset) {
builder.startTable(4);
int charactersOffset,
byte gadgetType,
int gadgetOffset) {
builder.startTable(6);
Movie.addGadget(builder, gadgetOffset);
Movie.addCharacters(builder, charactersOffset);
Movie.addCharactersType(builder, charactersTypeOffset);
Movie.addMainCharacter(builder, mainCharacterOffset);
Movie.addGadgetType(builder, gadgetType);
Movie.addMainCharacterType(builder, mainCharacterType);
return Movie.endMovie(builder);
}
public static void startMovie(FlatBufferBuilder builder) { builder.startTable(4); }
public static void startMovie(FlatBufferBuilder builder) { builder.startTable(6); }
public static void addMainCharacterType(FlatBufferBuilder builder, byte mainCharacterType) { builder.addByte(0, mainCharacterType, 0); }
public static void addMainCharacter(FlatBufferBuilder builder, int mainCharacterOffset) { builder.addOffset(1, mainCharacterOffset, 0); }
public static void addCharactersType(FlatBufferBuilder builder, int charactersTypeOffset) { builder.addOffset(2, charactersTypeOffset, 0); }
@@ -60,6 +66,8 @@ public final class Movie extends com.google.flatbuffers.Table {
public static void addCharacters(FlatBufferBuilder builder, int charactersOffset) { builder.addOffset(3, charactersOffset, 0); }
public static int createCharactersVector(FlatBufferBuilder builder, int[] data) { builder.startVector(4, data.length, 4); for (int i = data.length - 1; i >= 0; i--) builder.addOffset(data[i]); return builder.endVector(); }
public static void startCharactersVector(FlatBufferBuilder builder, int numElems) { builder.startVector(4, numElems, 4); }
public static void addGadgetType(FlatBufferBuilder builder, byte gadgetType) { builder.addByte(4, gadgetType, 0); }
public static void addGadget(FlatBufferBuilder builder, int gadgetOffset) { builder.addOffset(5, gadgetOffset, 0); }
public static int endMovie(FlatBufferBuilder builder) {
int o = builder.endTable();
return o;
@@ -107,6 +115,18 @@ public final class Movie extends com.google.flatbuffers.Table {
_oCharacters[_j] = _oCharactersElement;
}
_o.setCharacters(_oCharacters);
GadgetUnion _oGadget = new GadgetUnion();
byte _oGadgetType = gadgetType();
_oGadget.setType(_oGadgetType);
com.google.flatbuffers.Table _oGadgetValue;
switch (_oGadgetType) {
case Gadget.HandFan:
_oGadgetValue = gadget(new HandFan());
_oGadget.setValue(_oGadgetValue != null ? ((HandFan) _oGadgetValue).unpack() : null);
break;
default: break;
}
_o.setGadget(_oGadget);
}
public static int pack(FlatBufferBuilder builder, MovieT _o) {
if (_o == null) return 0;
@@ -126,12 +146,16 @@ public final class Movie extends com.google.flatbuffers.Table {
for (CharacterUnion _e : _o.getCharacters()) { __characters[_j] = CharacterUnion.pack(builder, _o.getCharacters()[_j]); _j++;}
_characters = createCharactersVector(builder, __characters);
}
byte _gadgetType = _o.getGadget() == null ? Gadget.NONE : _o.getGadget().getType();
int _gadget = _o.getGadget() == null ? 0 : GadgetUnion.pack(builder, _o.getGadget());
return createMovie(
builder,
_mainCharacterType,
_mainCharacter,
_charactersType,
_characters);
_characters,
_gadgetType,
_gadget);
}
}

27
tests/union_vector/Movie.kt
View File

@@ -78,6 +78,23 @@ class Movie : Table() {
get() {
val o = __offset(10); return if (o != 0) __vector_len(o) else 0
}
val gadgetType : UByte
get() {
val o = __offset(12)
return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u
}
fun mutateGadgetType(gadgetType: UByte) : Boolean {
val o = __offset(12)
return if (o != 0) {
bb.put(o + bb_pos, gadgetType.toByte())
true
} else {
false
}
}
fun gadget(obj: Table) : Table? {
val o = __offset(14); return if (o != 0) __union(obj, o + bb_pos) else null
}
companion object {
fun validateVersion() = Constants.FLATBUFFERS_25_9_23()
fun getRootAsMovie(_bb: ByteBuffer): Movie = getRootAsMovie(_bb, Movie())
@@ -86,15 +103,17 @@ class Movie : Table() {
return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb))
}
fun MovieBufferHasIdentifier(_bb: ByteBuffer) : Boolean = __has_identifier(_bb, "MOVI")
fun createMovie(builder: FlatBufferBuilder, mainCharacterType: UByte, mainCharacterOffset: Int, charactersTypeOffset: Int, charactersOffset: Int) : Int {
builder.startTable(4)
fun createMovie(builder: FlatBufferBuilder, mainCharacterType: UByte, mainCharacterOffset: Int, charactersTypeOffset: Int, charactersOffset: Int, gadgetType: UByte, gadgetOffset: Int) : Int {
builder.startTable(6)
addGadget(builder, gadgetOffset)
addCharacters(builder, charactersOffset)
addCharactersType(builder, charactersTypeOffset)
addMainCharacter(builder, mainCharacterOffset)
addGadgetType(builder, gadgetType)
addMainCharacterType(builder, mainCharacterType)
return endMovie(builder)
}
fun startMovie(builder: FlatBufferBuilder) = builder.startTable(4)
fun startMovie(builder: FlatBufferBuilder) = builder.startTable(6)
fun addMainCharacterType(builder: FlatBufferBuilder, mainCharacterType: UByte) = builder.addByte(0, mainCharacterType.toByte(), 0)
fun addMainCharacter(builder: FlatBufferBuilder, mainCharacter: Int) = builder.addOffset(1, mainCharacter, 0)
fun addCharactersType(builder: FlatBufferBuilder, charactersType: Int) = builder.addOffset(2, charactersType, 0)
@@ -116,6 +135,8 @@ class Movie : Table() {
return builder.endVector()
}
fun startCharactersVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(4, numElems, 4)
fun addGadgetType(builder: FlatBufferBuilder, gadgetType: UByte) = builder.addByte(4, gadgetType.toByte(), 0)
fun addGadget(builder: FlatBufferBuilder, gadget: Int) = builder.addOffset(5, gadget, 0)
fun endMovie(builder: FlatBufferBuilder) : Int {
val o = builder.endTable()
return o

41
tests/union_vector/Movie.php
View File

@@ -96,26 +96,46 @@ class Movie extends Table
return $o != 0 ? $this->__vector_len($o) : 0;
}
/**
* @return byte
*/
public function getGadgetType()
{
$o = $this->__offset(12);
return $o != 0 ? $this->bb->getByte($o + $this->bb_pos) : \Gadget::NONE;
}
/**
* @returnint
*/
public function getGadget($obj)
{
$o = $this->__offset(14);
return $o != 0 ? $this->__union($obj, $o) : null;
}
/**
* @param FlatBufferBuilder $builder
* @return void
*/
public static function startMovie(FlatBufferBuilder $builder)
{
$builder->StartObject(4);
$builder->StartObject(6);
}
/**
* @param FlatBufferBuilder $builder
* @return Movie
*/
public static function createMovie(FlatBufferBuilder $builder, $main_character_type, $main_character, $characters_type, $characters)
public static function createMovie(FlatBufferBuilder $builder, $main_character_type, $main_character, $characters_type, $characters, $gadget_type, $gadget)
{
$builder->startObject(4);
$builder->startObject(6);
self::addMainCharacterType($builder, $main_character_type);
self::addMainCharacter($builder, $main_character);
self::addCharactersType($builder, $characters_type);
self::addCharacters($builder, $characters);
self::addGadgetType($builder, $gadget_type);
self::addGadget($builder, $gadget);
$o = $builder->endObject();
return $o;
}
@@ -203,6 +223,21 @@ class Movie extends Table
$builder->startVector(4, $numElems, 4);
}
/**
* @param FlatBufferBuilder $builder
* @param byte
* @return void
*/
public static function addGadgetType(FlatBufferBuilder $builder, $gadgetType)
{
$builder->addByteX(4, $gadgetType, 0);
}
public static function addGadget(FlatBufferBuilder $builder, $offset)
{
$builder->addOffsetX(5, $offset, 0);
}
/**
* @param FlatBufferBuilder $builder
* @return int table offset

6
tests/union_vector/MovieT.java
View File

@@ -19,6 +19,7 @@ import java.nio.ByteOrder;
public class MovieT {
private CharacterUnion mainCharacter;
private CharacterUnion[] characters;
private GadgetUnion gadget;
public CharacterUnion getMainCharacter() { return mainCharacter; }
@@ -28,10 +29,15 @@ public class MovieT {
public void setCharacters(CharacterUnion[] characters) { this.characters = characters; }
public GadgetUnion getGadget() { return gadget; }
public void setGadget(GadgetUnion gadget) { this.gadget = gadget; }
public MovieT() {
this.mainCharacter = null;
this.characters = null;
this.gadget = null;
}
public static MovieT deserializeFromBinary(byte[] fbBuffer) {
return Movie.getRootAsMovie(ByteBuffer.wrap(fbBuffer)).unpack();

1
tests/union_vector/union_vector.fbs
View File

@@ -38,6 +38,7 @@ union Gadget {
table Movie {
main_character: Character;
characters: [Character];
gadget: Gadget;
}
root_type Movie;

91
tests/union_vector/union_vector_generated.h
View File

@@ -573,6 +573,7 @@ struct MovieT : public ::flatbuffers::NativeTable {
typedef Movie TableType;
CharacterUnion main_character{};
std::vector<CharacterUnion> characters{};
GadgetUnion gadget{};
};
struct Movie FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
@@ -585,7 +586,9 @@ struct Movie FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
VT_MAIN_CHARACTER_TYPE = 4,
VT_MAIN_CHARACTER = 6,
VT_CHARACTERS_TYPE = 8,
VT_CHARACTERS = 10
VT_CHARACTERS = 10,
VT_GADGET_TYPE = 12,
VT_GADGET = 14
};
Character main_character_type() const {
return static_cast<Character>(GetField<uint8_t>(VT_MAIN_CHARACTER_TYPE, 0));
@@ -644,6 +647,29 @@ struct Movie FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
::flatbuffers::Vector<::flatbuffers::Offset<void>> *mutable_characters() {
return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<void>> *>(VT_CHARACTERS);
}
Gadget gadget_type() const {
return static_cast<Gadget>(GetField<uint8_t>(VT_GADGET_TYPE, 0));
}
const void *gadget() const {
return GetPointer<const void *>(VT_GADGET);
}
template<typename T> const T *gadget_as() const;
const FallingTub *gadget_as_FallingTub() const {
return gadget_type() == Gadget_FallingTub ? static_cast<const FallingTub *>(gadget()) : nullptr;
}
const HandFan *gadget_as_HandFan() const {
return gadget_type() == Gadget_HandFan ? static_cast<const HandFan *>(gadget()) : nullptr;
}
void *mutable_gadget() {
return GetPointer<void *>(VT_GADGET);
}
template<typename T> T *mutable_gadget_as();
FallingTub *mutable_gadget_as_FallingTub() {
return gadget_type() == Gadget_FallingTub ? static_cast<FallingTub *>(mutable_gadget()) : nullptr;
}
HandFan *mutable_gadget_as_HandFan() {
return gadget_type() == Gadget_HandFan ? static_cast<HandFan *>(mutable_gadget()) : nullptr;
}
template <bool B = false>
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
return VerifyTableStart(verifier) &&
@@ -655,6 +681,9 @@ struct Movie FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
VerifyOffset(verifier, VT_CHARACTERS) &&
verifier.VerifyVector(characters()) &&
VerifyCharacterVector(verifier, characters(), characters_type()) &&
VerifyField<uint8_t>(verifier, VT_GADGET_TYPE, 1) &&
VerifyOffset(verifier, VT_GADGET) &&
VerifyGadget(verifier, gadget(), gadget_type()) &&
verifier.EndTable();
}
MovieT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
@@ -662,6 +691,22 @@ struct Movie FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
static ::flatbuffers::Offset<Movie> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const MovieT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
template<> inline const FallingTub *Movie::gadget_as<FallingTub>() const {
return gadget_as_FallingTub();
}
template<> inline FallingTub *Movie::mutable_gadget_as<FallingTub>() {
return mutable_gadget_as_FallingTub();
}
template<> inline const HandFan *Movie::gadget_as<HandFan>() const {
return gadget_as_HandFan();
}
template<> inline HandFan *Movie::mutable_gadget_as<HandFan>() {
return mutable_gadget_as_HandFan();
}
struct MovieBuilder {
typedef Movie Table;
::flatbuffers::FlatBufferBuilder &fbb_;
@@ -678,6 +723,12 @@ struct MovieBuilder {
void add_characters(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<void>>> characters) {
fbb_.AddOffset(Movie::VT_CHARACTERS, characters);
}
void add_gadget_type(Gadget gadget_type) {
fbb_.AddElement<uint8_t>(Movie::VT_GADGET_TYPE, static_cast<uint8_t>(gadget_type), 0);
}
void add_gadget(::flatbuffers::Offset<void> gadget) {
fbb_.AddOffset(Movie::VT_GADGET, gadget);
}
explicit MovieBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
@@ -694,11 +745,15 @@ inline ::flatbuffers::Offset<Movie> CreateMovie(
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) {
::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<void>>> characters = 0,
Gadget gadget_type = Gadget_NONE,
::flatbuffers::Offset<void> gadget = 0) {
MovieBuilder builder_(_fbb);
builder_.add_gadget(gadget);
builder_.add_characters(characters);
builder_.add_characters_type(characters_type);
builder_.add_main_character(main_character);
builder_.add_gadget_type(gadget_type);
builder_.add_main_character_type(main_character_type);
return builder_.Finish();
}
@@ -708,7 +763,9 @@ inline ::flatbuffers::Offset<Movie> CreateMovieDirect(
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) {
const std::vector<::flatbuffers::Offset<void>> *characters = nullptr,
Gadget gadget_type = Gadget_NONE,
::flatbuffers::Offset<void> gadget = 0) {
auto characters_type__ = characters_type ? _fbb.CreateVector<uint8_t>(*characters_type) : 0;
auto characters__ = characters ? _fbb.CreateVector<::flatbuffers::Offset<void>>(*characters) : 0;
return CreateMovie(
@@ -716,7 +773,9 @@ inline ::flatbuffers::Offset<Movie> CreateMovieDirect(
main_character_type,
main_character,
characters_type__,
characters__);
characters__,
gadget_type,
gadget);
}
::flatbuffers::Offset<Movie> CreateMovie(::flatbuffers::FlatBufferBuilder &_fbb, const MovieT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
@@ -799,7 +858,8 @@ inline ::flatbuffers::Offset<HandFan> HandFan::Pack(::flatbuffers::FlatBufferBui
inline bool operator==(const MovieT &lhs, const MovieT &rhs) {
return
(lhs.main_character == rhs.main_character) &&
(lhs.characters == rhs.characters);
(lhs.characters == rhs.characters) &&
(lhs.gadget == rhs.gadget);
}
inline bool operator!=(const MovieT &lhs, const MovieT &rhs) {
@@ -820,6 +880,8 @@ inline void Movie::UnPackTo(MovieT *_o, const ::flatbuffers::resolver_function_t
{ auto _e = main_character(); if (_e) _o->main_character.value = CharacterUnion::UnPack(_e, main_character_type(), _resolver); }
{ auto _e = characters_type(); if (_e) { _o->characters.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->characters[_i].type = static_cast<Character>(_e->Get(_i)); } } else { _o->characters.resize(0); } }
{ auto _e = characters(); if (_e) { _o->characters.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->characters[_i].value = CharacterUnion::UnPack(_e->Get(_i), characters_type()->GetEnum<Character>(_i), _resolver); } } else { _o->characters.resize(0); } }
{ auto _e = gadget_type(); _o->gadget.type = _e; }
{ auto _e = gadget(); if (_e) _o->gadget.value = GadgetUnion::UnPack(_e, gadget_type(), _resolver); }
}
inline ::flatbuffers::Offset<Movie> CreateMovie(::flatbuffers::FlatBufferBuilder &_fbb, const MovieT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
@@ -834,12 +896,16 @@ inline ::flatbuffers::Offset<Movie> Movie::Pack(::flatbuffers::FlatBufferBuilder
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 = _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 _gadget_type = _o->gadget.type;
auto _gadget = _o->gadget.Pack(_fbb);
return CreateMovie(
_fbb,
_main_character_type,
_main_character,
_characters_type,
_characters);
_characters,
_gadget_type,
_gadget);
}
template <bool B>
@@ -1234,19 +1300,24 @@ inline const ::flatbuffers::TypeTable *MovieTypeTable() {
{ ::flatbuffers::ET_UTYPE, 0, 0 },
{ ::flatbuffers::ET_SEQUENCE, 0, 0 },
{ ::flatbuffers::ET_UTYPE, 1, 0 },
{ ::flatbuffers::ET_SEQUENCE, 1, 0 }
{ ::flatbuffers::ET_SEQUENCE, 1, 0 },
{ ::flatbuffers::ET_UTYPE, 0, 1 },
{ ::flatbuffers::ET_SEQUENCE, 0, 1 }
};
static const ::flatbuffers::TypeFunction type_refs[] = {
CharacterTypeTable
CharacterTypeTable,
GadgetTypeTable
};
static const char * const names[] = {
"main_character_type",
"main_character",
"characters_type",
"characters"
"characters",
"gadget_type",
"gadget"
};
static const ::flatbuffers::TypeTable tt = {
::flatbuffers::ST_TABLE, 4, type_codes, type_refs, nullptr, nullptr, names
::flatbuffers::ST_TABLE, 6, type_codes, type_refs, nullptr, nullptr, names
};
return &tt;
}