BigfootDev/flatbuffers
1
0
Fork 1
mirror of https://github.com/google/flatbuffers.git synced 2026-06-21 09:15:44 +00:00
Code Issues Packages Projects Releases Wiki 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

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;
}