* Remove a lot of redundancy from the Python generated code.
Update tutorial to reflect new Python generated code.
* Add aliases for newly deprecated Python generated methods.
This should help with backwards compatibility.
* Fix incorrect names in deprecated comments.
weapon_two = builder.CreateString('Axe')
# Create the first `Weapon` ('Sword').
- MyGame.Sample.Weapon.WeaponStart(builder)
- MyGame.Sample.Weapon.WeaponAddName(builder, weapon_one)
- MyGame.Sample.Weapon.WeaponAddDamage(builder, 3)
- sword = MyGame.Sample.Weapon.WeaponEnd(builder)
+ MyGame.Sample.Weapon.Start(builder)
+ MyGame.Sample.Weapon.AddName(builder, weapon_one)
+ MyGame.Sample.Weapon.AddDamage(builder, 3)
+ sword = MyGame.Sample.Weapon.End(builder)
# Create the second `Weapon` ('Axe').
- MyGame.Sample.Weapon.WeaponStart(builder)
- MyGame.Sample.Weapon.WeaponAddName(builder, weapon_two)
- MyGame.Sample.Weapon.WeaponAddDamage(builder, 5)
- axe = MyGame.Sample.Weapon.WeaponEnd(builder)
+ MyGame.Sample.Weapon.Start(builder)
+ MyGame.Sample.Weapon.AddName(builder, weapon_two)
+ MyGame.Sample.Weapon.AddDamage(builder, 5)
+ axe = MyGame.Sample.Weapon.End(builder)
~~~
</div>
<div class="language-javascript">
# Create a `vector` representing the inventory of the Orc. Each number
# could correspond to an item that can be claimed after he is slain.
# Note: Since we prepend the bytes, this loop iterates in reverse.
- MyGame.Sample.Monster.MonsterStartInventoryVector(builder, 10)
+ MyGame.Sample.Monster.StartInventoryVector(builder, 10)
for i in reversed(range(0, 10)):
builder.PrependByte(i)
inv = builder.EndVector()
~~~{.py}
# Create a FlatBuffer vector and prepend the weapons.
# Note: Since we prepend the data, prepend them in reverse order.
- MyGame.Sample.Monster.MonsterStartWeaponsVector(builder, 2)
+ MyGame.Sample.Monster.StartWeaponsVector(builder, 2)
builder.PrependUOffsetTRelative(axe)
builder.PrependUOffsetTRelative(sword)
weapons = builder.EndVector()
</div>
<div class="language-python">
~~~{.py}
- MyGame.Sample.Monster.MonsterStartPathVector(builder, 2)
+ MyGame.Sample.Monster.StartPathVector(builder, 2)
MyGame.Sample.Vec3.CreateVec3(builder, 1.0, 2.0, 3.0)
MyGame.Sample.Vec3.CreateVec3(builder, 4.0, 5.0, 6.0)
path = builder.EndVector()
</div>
<div class="language-python">
~~~{.py}
- # Create our monster by using `MonsterStart()` and `MonsterEnd()`.
- MyGame.Sample.Monster.MonsterStart(builder)
- MyGame.Sample.Monster.MonsterAddPos(builder,
+ # Create our monster by using `Monster.Start()` and `Monster.End()`.
+ MyGame.Sample.Monster.Start(builder)
+ MyGame.Sample.Monster.AddPos(builder,
MyGame.Sample.Vec3.CreateVec3(builder, 1.0, 2.0, 3.0))
- MyGame.Sample.Monster.MonsterAddHp(builder, 300)
- MyGame.Sample.Monster.MonsterAddName(builder, name)
- MyGame.Sample.Monster.MonsterAddInventory(builder, inv)
- MyGame.Sample.Monster.MonsterAddColor(builder,
+ MyGame.Sample.Monster.AddHp(builder, 300)
+ MyGame.Sample.Monster.AddName(builder, name)
+ MyGame.Sample.Monster.AddInventory(builder, inv)
+ MyGame.Sample.Monster.AddColor(builder,
MyGame.Sample.Color.Color().Red)
- MyGame.Sample.Monster.MonsterAddWeapons(builder, weapons)
- MyGame.Sample.Monster.MonsterAddEquippedType(
+ MyGame.Sample.Monster.AddWeapons(builder, weapons)
+ MyGame.Sample.Monster.AddEquippedType(
builder, MyGame.Sample.Equipment.Equipment().Weapon)
- MyGame.Sample.Monster.MonsterAddEquipped(builder, axe)
- MyGame.Sample.Monster.MonsterAddPath(builder, path)
- orc = MyGame.Sample.Monster.MonsterEnd(builder)
+ MyGame.Sample.Monster.AddEquipped(builder, axe)
+ MyGame.Sample.Monster.AddPath(builder, path)
+ orc = MyGame.Sample.Monster.End(builder)
~~~
</div>
<div class="language-javascript">
</div>
<div class="language-python">
~~~{.py}
- MyGame.Sample.Monster.MonsterAddEquippedType( # Union type
+ MyGame.Sample.Monster.AddEquippedType( # Union type
builder, MyGame.Sample.Equipment.Equipment().Weapon)
- MyGame.Sample.Monster.MonsterAddEquipped(builder, axe) # Union data
+ MyGame.Sample.Monster.AddEquipped(builder, axe) # Union data
~~~
</div>
<div class="language-javascript">
buf = /* the data you just read, in an object of type "bytearray" */
// Get an accessor to the root object inside the buffer.
- monster = MyGame.Sample.Monster.Monster.GetRootAsMonster(buf, 0)
+ monster = MyGame.Sample.Monster.Monster.GetRootAs(buf, 0)
# Note: We use `0` for the offset here, which is typical for most buffers
# you would read. If you wanted to read from the `builder.Bytes` directly,
code += Indent + "@classmethod\n";
code += Indent + "def GetRootAs";
- code += NormalizedName(struct_def);
code += "(cls, buf, offset=0):";
code += "\n";
code += Indent + Indent;
code += Indent + Indent + "x.Init(buf, n + offset)\n";
code += Indent + Indent + "return x\n";
code += "\n";
+
+ // Add an alias with the old name
+ code += Indent + "@classmethod\n";
+ code += Indent + "def GetRootAs";
+ code += NormalizedName(struct_def);
+ code += "(cls, buf, offset=0):\n";
+ code += Indent + Indent + "\"\"\"This method is deprecated. Please switch to GetRootAs.\"\"\"\n";
+ code += Indent + Indent + "return cls.GetRootAs(buf, offset)\n";
}
// Initialize an existing object with other data, to avoid an allocation.
code += Indent + Indent + Indent;
code += "from " + qualified_name + " import " + unqualified_name + "\n";
code += Indent + Indent + Indent + "return " + unqualified_name;
- code += ".GetRootAs" + unqualified_name;
+ code += ".GetRootAs";
code += "(self._tab.Bytes, self._tab.Vector(o))\n";
code += Indent + Indent + "return 0\n";
code += "\n";
// Get the value of a table's starting offset.
void GetStartOfTable(const StructDef &struct_def, std::string *code_ptr) {
auto &code = *code_ptr;
- code += "def " + NormalizedName(struct_def) + "Start";
- code += "(builder): ";
+ code += "def Start(builder): ";
code += "builder.StartObject(";
code += NumToString(struct_def.fields.vec.size());
code += ")\n";
+
+ // Add alias with the old name.
+ code += "def " + NormalizedName(struct_def) + "Start(builder):\n";
+ code += Indent + "\"\"\"This method is deprecated. Please switch to Start.\"\"\"\n";
+ code += Indent + "return Start(builder)\n";
}
// Set the value of a table's field.
void BuildFieldOfTable(const StructDef &struct_def, const FieldDef &field,
const size_t offset, std::string *code_ptr) {
auto &code = *code_ptr;
- code += "def " + NormalizedName(struct_def) + "Add" +
- MakeCamel(NormalizedName(field));
+ code += "def Add" + MakeCamel(NormalizedName(field));
code += "(builder, ";
code += MakeCamel(NormalizedName(field), false);
code += "): ";
? float_const_gen_.GenFloatConstant(field)
: field.value.constant;
code += ")\n";
+
+ // Add alias with the old name.
+ code += "def " + NormalizedName(struct_def) + "Add" + MakeCamel(NormalizedName(field));
+ code += "(builder, ";
+ code += MakeCamel(NormalizedName(field), false);
+ code += "):\n";
+ code += Indent + "\"\"\"This method is deprecated. Please switch to Add";
+ code += MakeCamel(NormalizedName(field)) + ".\"\"\"\n";
+ code += Indent + "return Add" + MakeCamel(NormalizedName(field));
+ code += "(builder, ";
+ code += MakeCamel(NormalizedName(field), false);
+ code += ")\n";
+
+ // Add alias with the old name.
}
// Set the value of one of the members of a table's vector.
void BuildVectorOfTable(const StructDef &struct_def, const FieldDef &field,
std::string *code_ptr) {
auto &code = *code_ptr;
- code += "def " + NormalizedName(struct_def) + "Start";
+ code += "def Start";
code += MakeCamel(NormalizedName(field));
code += "Vector(builder, numElems): return builder.StartVector(";
auto vector_type = field.value.type.VectorType();
code += NumToString(elem_size);
code += ", numElems, " + NumToString(alignment);
code += ")\n";
+
+ // Add alias with the old name.
+ code += "def " + NormalizedName(struct_def) + "Start";
+ code += MakeCamel(NormalizedName(field));
+ code += "Vector(builder, numElems):\n";
+ code += Indent + "\"\"\"This method is deprecated. Please switch to Start.\"\"\"\n";
+ code += Indent + "return Start";
+ code += MakeCamel(NormalizedName(field));
+ code += "Vector(builder, numElems)\n";
}
// Set the value of one of the members of a table's vector and fills in the
// elements from a bytearray. This is for simplifying the use of nested
// flatbuffers.
- void BuildVectorOfTableFromBytes(const StructDef &struct_def,
- const FieldDef &field,
- std::string *code_ptr) {
+ void BuildVectorOfTableFromBytes(const FieldDef &field, std::string *code_ptr) {
auto nested = field.attributes.Lookup("nested_flatbuffer");
if (!nested) { return; } // There is no nested flatbuffer.
(void)nested_root;
auto &code = *code_ptr;
- code += "def " + NormalizedName(struct_def) + "Make";
- code += MakeCamel(NormalizedName(field));
- code += "VectorFromBytes(builder, bytes):\n";
+ code += "def MakeVectorFromBytes(builder, bytes):\n";
code += Indent + "builder.StartVector(";
auto vector_type = field.value.type.VectorType();
auto alignment = InlineAlignment(vector_type);
code += Indent + "builder.Bytes[builder.head : builder.head + len(bytes)]";
code += " = bytes\n";
code += Indent + "return builder.EndVector()\n";
+
+ // Add alias with the old name.
+ code += "def Make" + MakeCamel(NormalizedName(field));
+ code += "VectorFromBytes(builder, bytes):\n";
+ code += Indent + "builder.StartVector(";
+ code += NumToString(elem_size);
+ code += ", len(bytes), " + NumToString(alignment);
+ code += ")\n";
+ code += Indent + "builder.head = builder.head - len(bytes)\n";
+ code += Indent + "builder.Bytes[builder.head : builder.head + len(bytes)]";
+ code += " = bytes\n";
+ code += Indent + "return builder.EndVector()\n";
}
// Get the offset of the end of a table.
void GetEndOffsetOnTable(const StructDef &struct_def, std::string *code_ptr) {
auto &code = *code_ptr;
- code += "def " + NormalizedName(struct_def) + "End";
- code += "(builder): ";
- code += "return builder.EndObject()\n";
+ code += "def End(builder): return builder.EndObject()\n";
+
+ // Add alias with the old name.
+ code += "def " + NormalizedName(struct_def) + "End(builder):\n";
+ code += Indent + "\"\"\"This method is deprecated. Please switch to End.\"\"\"\n";
+ code += Indent + "return End(builder)";
}
// Generate the receiver for function signatures.
BuildFieldOfTable(struct_def, field, offset, code_ptr);
if (IsVector(field.value.type)) {
BuildVectorOfTable(struct_def, field, code_ptr);
- BuildVectorOfTableFromBytes(struct_def, field, code_ptr);
+ BuildVectorOfTableFromBytes(field, code_ptr);
}
}
code_prefix +=
GenIndents(2) + "if self." + field_instance_name + " is not None:";
if (field.value.type.struct_def->fixed) {
- code_prefix += GenIndents(3) + struct_name + "Start" +
+ code_prefix += GenIndents(3) + "Start" +
field_accessor_name + "Vector(builder, len(self." +
field_instance_name + "))";
code_prefix += GenIndents(3) + "for i in reversed(range(len(self." +
code_prefix += GenIndents(4) + field_instance_name + "list.append(self." +
field_instance_name + "[i].Pack(builder))";
- code_prefix += GenIndents(3) + struct_name + "Start" +
+ code_prefix += GenIndents(3) + "Start" +
field_accessor_name + "Vector(builder, len(self." +
field_instance_name + "))";
code_prefix += GenIndents(3) + "for i in reversed(range(len(self." +
// Adds the field into the struct.
code += GenIndents(2) + "if self." + field_instance_name + " is not None:";
- code += GenIndents(3) + struct_name + "Add" + field_accessor_name +
+ code += GenIndents(3) + "Add" + field_accessor_name +
"(builder, " + field_instance_name + ")";
}
auto struct_name = NormalizedName(struct_def);
auto vectortype = field.value.type.VectorType();
- code += GenIndents(indents) + struct_name + "Start" + field_accessor_name +
+ code += GenIndents(indents) + "Start" + field_accessor_name +
"Vector(builder, len(self." + field_instance_name + "))";
code += GenIndents(indents) + "for i in reversed(range(len(self." +
field_instance_name + "))):";
// Adds the field into the struct.
code += GenIndents(2) + "if self." + field_instance_name + " is not None:";
- code += GenIndents(3) + struct_name + "Add" + field_accessor_name +
+ code += GenIndents(3) + "Add" + field_accessor_name +
"(builder, " + field_instance_name + ")";
// Creates the field.
GenIndents(2) + "if self." + field_instance_name + " is not None:";
}
- code += GenIndents(3) + struct_name + "Add" + field_accessor_name +
+ code += GenIndents(3) + "Add" + field_accessor_name +
"(builder, " + field_instance_name + ")";
}
code_prefix += GenIndents(3) + field_instance_name + " = self." +
field_instance_name + ".Pack(builder)";
code += GenIndents(2) + "if self." + field_instance_name + " is not None:";
- code += GenIndents(3) + struct_name + "Add" + field_accessor_name +
+ code += GenIndents(3) + "Add" + field_accessor_name +
"(builder, " + field_instance_name + ")";
}
GenReceiverForObjectAPI(struct_def, code_ptr);
code_base += "Pack(self, builder):";
- code += GenIndents(2) + struct_name + "Start(builder)";
+ code += GenIndents(2) + "Start(builder)";
for (auto it = struct_def.fields.vec.begin();
it != struct_def.fields.vec.end(); ++it) {
auto &field = **it;
")";
code += GenIndents(2) + "if self." + field_instance_name +
" is not None:";
- code += GenIndents(3) + struct_name + "Add" + field_accessor_name +
+ code += GenIndents(3) + "Add" + field_accessor_name +
"(builder, " + field_instance_name + ")";
break;
}
// Generates code for scalar values. If the value equals to the
// default value, builder will automatically ignore it. So we don't
// need to check the value ahead.
- code += GenIndents(2) + struct_name + "Add" + field_accessor_name +
+ code += GenIndents(2) + "Add" + field_accessor_name +
"(builder, self." + field_instance_name + ")";
break;
}
}
- code += GenIndents(2) + struct_instance_name + " = " + struct_name +
- "End(builder)";
+ code += GenIndents(2) + struct_instance_name + " = " + "End(builder)";
code += GenIndents(2) + "return " + struct_instance_name;
code_base += code_prefix + code;
__slots__ = ['_tab']
@classmethod
- def GetRootAsArrayTable(cls, buf, offset=0):
+ def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = ArrayTable()
x.Init(buf, n + offset)
return x
@classmethod
+ def GetRootAsArrayTable(cls, buf, offset=0):
+ """This method is deprecated. Please switch to GetRootAs."""
+ return cls.GetRootAs(buf, offset)
+ @classmethod
def ArrayTableBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x41\x52\x52\x54", size_prefixed=size_prefixed)
return obj
return None
-def ArrayTableStart(builder): builder.StartObject(1)
-def ArrayTableAddA(builder, a): builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(a), 0)
-def ArrayTableEnd(builder): return builder.EndObject()
-
+def Start(builder): builder.StartObject(1)
+def ArrayTableStart(builder):
+ """This method is deprecated. Please switch to Start."""
+ return Start(builder)
+def AddA(builder, a): builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(a), 0)
+def ArrayTableAddA(builder, a):
+ """This method is deprecated. Please switch to AddA."""
+ return AddA(builder, a)
+def End(builder): return builder.EndObject()
+def ArrayTableEnd(builder):
+ """This method is deprecated. Please switch to End."""
+ return End(builder)
import MyGame.Example.ArrayStruct
try:
from typing import Optional
# ArrayTableT
def Pack(self, builder):
- ArrayTableStart(builder)
+ Start(builder)
if self.a is not None:
a = self.a.Pack(builder)
- ArrayTableAddA(builder, a)
- arrayTable = ArrayTableEnd(builder)
+ AddA(builder, a)
+ arrayTable = End(builder)
return arrayTable
__slots__ = ['_tab']
@classmethod
- def GetRootAsMonster(cls, buf, offset=0):
+ def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = Monster()
x.Init(buf, n + offset)
return x
@classmethod
+ def GetRootAsMonster(cls, buf, offset=0):
+ """This method is deprecated. Please switch to GetRootAs."""
+ return cls.GetRootAs(buf, offset)
+ @classmethod
def MonsterBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4D\x4F\x4E\x53", size_prefixed=size_prefixed)
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
if o != 0:
from MyGame.Example.Monster import Monster
- return Monster.GetRootAsMonster(self._tab.Bytes, self._tab.Vector(o))
+ return Monster.GetRootAs(self._tab.Bytes, self._tab.Vector(o))
return 0
# Monster
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
if o != 0:
from MyGame.Example.Monster import Monster
- return Monster.GetRootAsMonster(self._tab.Bytes, self._tab.Vector(o))
+ return Monster.GetRootAs(self._tab.Bytes, self._tab.Vector(o))
return 0
# Monster
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(104))
return o == 0
-def MonsterStart(builder): builder.StartObject(51)
-def MonsterAddPos(builder, pos): builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(pos), 0)
-def MonsterAddMana(builder, mana): builder.PrependInt16Slot(1, mana, 150)
-def MonsterAddHp(builder, hp): builder.PrependInt16Slot(2, hp, 100)
-def MonsterAddName(builder, name): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
-def MonsterAddInventory(builder, inventory): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(inventory), 0)
-def MonsterStartInventoryVector(builder, numElems): return builder.StartVector(1, numElems, 1)
-def MonsterAddColor(builder, color): builder.PrependUint8Slot(6, color, 8)
-def MonsterAddTestType(builder, testType): builder.PrependUint8Slot(7, testType, 0)
-def MonsterAddTest(builder, test): builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(test), 0)
-def MonsterAddTest4(builder, test4): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(test4), 0)
-def MonsterStartTest4Vector(builder, numElems): return builder.StartVector(4, numElems, 2)
-def MonsterAddTestarrayofstring(builder, testarrayofstring): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring), 0)
-def MonsterStartTestarrayofstringVector(builder, numElems): return builder.StartVector(4, numElems, 4)
-def MonsterAddTestarrayoftables(builder, testarrayoftables): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayoftables), 0)
-def MonsterStartTestarrayoftablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
-def MonsterAddEnemy(builder, enemy): builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(enemy), 0)
-def MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer): builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(testnestedflatbuffer), 0)
-def MonsterStartTestnestedflatbufferVector(builder, numElems): return builder.StartVector(1, numElems, 1)
-def MonsterMakeTestnestedflatbufferVectorFromBytes(builder, bytes):
+def Start(builder): builder.StartObject(51)
+def MonsterStart(builder):
+ """This method is deprecated. Please switch to Start."""
+ return Start(builder)
+def AddPos(builder, pos): builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(pos), 0)
+def MonsterAddPos(builder, pos):
+ """This method is deprecated. Please switch to AddPos."""
+ return AddPos(builder, pos)
+def AddMana(builder, mana): builder.PrependInt16Slot(1, mana, 150)
+def MonsterAddMana(builder, mana):
+ """This method is deprecated. Please switch to AddMana."""
+ return AddMana(builder, mana)
+def AddHp(builder, hp): builder.PrependInt16Slot(2, hp, 100)
+def MonsterAddHp(builder, hp):
+ """This method is deprecated. Please switch to AddHp."""
+ return AddHp(builder, hp)
+def AddName(builder, name): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
+def MonsterAddName(builder, name):
+ """This method is deprecated. Please switch to AddName."""
+ return AddName(builder, name)
+def AddInventory(builder, inventory): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(inventory), 0)
+def MonsterAddInventory(builder, inventory):
+ """This method is deprecated. Please switch to AddInventory."""
+ return AddInventory(builder, inventory)
+def StartInventoryVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def MonsterStartInventoryVector(builder, numElems):
+ """This method is deprecated. Please switch to Start."""
+ return StartInventoryVector(builder, numElems)
+def AddColor(builder, color): builder.PrependUint8Slot(6, color, 8)
+def MonsterAddColor(builder, color):
+ """This method is deprecated. Please switch to AddColor."""
+ return AddColor(builder, color)
+def AddTestType(builder, testType): builder.PrependUint8Slot(7, testType, 0)
+def MonsterAddTestType(builder, testType):
+ """This method is deprecated. Please switch to AddTestType."""
+ return AddTestType(builder, testType)
+def AddTest(builder, test): builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(test), 0)
+def MonsterAddTest(builder, test):
+ """This method is deprecated. Please switch to AddTest."""
+ return AddTest(builder, test)
+def AddTest4(builder, test4): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(test4), 0)
+def MonsterAddTest4(builder, test4):
+ """This method is deprecated. Please switch to AddTest4."""
+ return AddTest4(builder, test4)
+def StartTest4Vector(builder, numElems): return builder.StartVector(4, numElems, 2)
+def MonsterStartTest4Vector(builder, numElems):
+ """This method is deprecated. Please switch to Start."""
+ return StartTest4Vector(builder, numElems)
+def AddTestarrayofstring(builder, testarrayofstring): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring), 0)
+def MonsterAddTestarrayofstring(builder, testarrayofstring):
+ """This method is deprecated. Please switch to AddTestarrayofstring."""
+ return AddTestarrayofstring(builder, testarrayofstring)
+def StartTestarrayofstringVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def MonsterStartTestarrayofstringVector(builder, numElems):
+ """This method is deprecated. Please switch to Start."""
+ return StartTestarrayofstringVector(builder, numElems)
+def AddTestarrayoftables(builder, testarrayoftables): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayoftables), 0)
+def MonsterAddTestarrayoftables(builder, testarrayoftables):
+ """This method is deprecated. Please switch to AddTestarrayoftables."""
+ return AddTestarrayoftables(builder, testarrayoftables)
+def StartTestarrayoftablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def MonsterStartTestarrayoftablesVector(builder, numElems):
+ """This method is deprecated. Please switch to Start."""
+ return StartTestarrayoftablesVector(builder, numElems)
+def AddEnemy(builder, enemy): builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(enemy), 0)
+def MonsterAddEnemy(builder, enemy):
+ """This method is deprecated. Please switch to AddEnemy."""
+ return AddEnemy(builder, enemy)
+def AddTestnestedflatbuffer(builder, testnestedflatbuffer): builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(testnestedflatbuffer), 0)
+def MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer):
+ """This method is deprecated. Please switch to AddTestnestedflatbuffer."""
+ return AddTestnestedflatbuffer(builder, testnestedflatbuffer)
+def StartTestnestedflatbufferVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def MonsterStartTestnestedflatbufferVector(builder, numElems):
+ """This method is deprecated. Please switch to Start."""
+ return StartTestnestedflatbufferVector(builder, numElems)
+def MakeVectorFromBytes(builder, bytes):
builder.StartVector(1, len(bytes), 1)
builder.head = builder.head - len(bytes)
builder.Bytes[builder.head : builder.head + len(bytes)] = bytes
return builder.EndVector()
-def MonsterAddTestempty(builder, testempty): builder.PrependUOffsetTRelativeSlot(14, flatbuffers.number_types.UOffsetTFlags.py_type(testempty), 0)
-def MonsterAddTestbool(builder, testbool): builder.PrependBoolSlot(15, testbool, 0)
-def MonsterAddTesthashs32Fnv1(builder, testhashs32Fnv1): builder.PrependInt32Slot(16, testhashs32Fnv1, 0)
-def MonsterAddTesthashu32Fnv1(builder, testhashu32Fnv1): builder.PrependUint32Slot(17, testhashu32Fnv1, 0)
-def MonsterAddTesthashs64Fnv1(builder, testhashs64Fnv1): builder.PrependInt64Slot(18, testhashs64Fnv1, 0)
-def MonsterAddTesthashu64Fnv1(builder, testhashu64Fnv1): builder.PrependUint64Slot(19, testhashu64Fnv1, 0)
-def MonsterAddTesthashs32Fnv1a(builder, testhashs32Fnv1a): builder.PrependInt32Slot(20, testhashs32Fnv1a, 0)
-def MonsterAddTesthashu32Fnv1a(builder, testhashu32Fnv1a): builder.PrependUint32Slot(21, testhashu32Fnv1a, 0)
-def MonsterAddTesthashs64Fnv1a(builder, testhashs64Fnv1a): builder.PrependInt64Slot(22, testhashs64Fnv1a, 0)
-def MonsterAddTesthashu64Fnv1a(builder, testhashu64Fnv1a): builder.PrependUint64Slot(23, testhashu64Fnv1a, 0)
-def MonsterAddTestarrayofbools(builder, testarrayofbools): builder.PrependUOffsetTRelativeSlot(24, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofbools), 0)
-def MonsterStartTestarrayofboolsVector(builder, numElems): return builder.StartVector(1, numElems, 1)
-def MonsterAddTestf(builder, testf): builder.PrependFloat32Slot(25, testf, 3.14159)
-def MonsterAddTestf2(builder, testf2): builder.PrependFloat32Slot(26, testf2, 3.0)
-def MonsterAddTestf3(builder, testf3): builder.PrependFloat32Slot(27, testf3, 0.0)
-def MonsterAddTestarrayofstring2(builder, testarrayofstring2): builder.PrependUOffsetTRelativeSlot(28, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring2), 0)
-def MonsterStartTestarrayofstring2Vector(builder, numElems): return builder.StartVector(4, numElems, 4)
-def MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct): builder.PrependUOffsetTRelativeSlot(29, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofsortedstruct), 0)
-def MonsterStartTestarrayofsortedstructVector(builder, numElems): return builder.StartVector(8, numElems, 4)
-def MonsterAddFlex(builder, flex): builder.PrependUOffsetTRelativeSlot(30, flatbuffers.number_types.UOffsetTFlags.py_type(flex), 0)
-def MonsterStartFlexVector(builder, numElems): return builder.StartVector(1, numElems, 1)
-def MonsterAddTest5(builder, test5): builder.PrependUOffsetTRelativeSlot(31, flatbuffers.number_types.UOffsetTFlags.py_type(test5), 0)
-def MonsterStartTest5Vector(builder, numElems): return builder.StartVector(4, numElems, 2)
-def MonsterAddVectorOfLongs(builder, vectorOfLongs): builder.PrependUOffsetTRelativeSlot(32, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfLongs), 0)
-def MonsterStartVectorOfLongsVector(builder, numElems): return builder.StartVector(8, numElems, 8)
-def MonsterAddVectorOfDoubles(builder, vectorOfDoubles): builder.PrependUOffsetTRelativeSlot(33, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfDoubles), 0)
-def MonsterStartVectorOfDoublesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
-def MonsterAddParentNamespaceTest(builder, parentNamespaceTest): builder.PrependUOffsetTRelativeSlot(34, flatbuffers.number_types.UOffsetTFlags.py_type(parentNamespaceTest), 0)
-def MonsterAddVectorOfReferrables(builder, vectorOfReferrables): builder.PrependUOffsetTRelativeSlot(35, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfReferrables), 0)
-def MonsterStartVectorOfReferrablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
-def MonsterAddSingleWeakReference(builder, singleWeakReference): builder.PrependUint64Slot(36, singleWeakReference, 0)
-def MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences): builder.PrependUOffsetTRelativeSlot(37, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfWeakReferences), 0)
-def MonsterStartVectorOfWeakReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
-def MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables): builder.PrependUOffsetTRelativeSlot(38, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfStrongReferrables), 0)
-def MonsterStartVectorOfStrongReferrablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
-def MonsterAddCoOwningReference(builder, coOwningReference): builder.PrependUint64Slot(39, coOwningReference, 0)
-def MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences): builder.PrependUOffsetTRelativeSlot(40, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfCoOwningReferences), 0)
-def MonsterStartVectorOfCoOwningReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
-def MonsterAddNonOwningReference(builder, nonOwningReference): builder.PrependUint64Slot(41, nonOwningReference, 0)
-def MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences): builder.PrependUOffsetTRelativeSlot(42, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfNonOwningReferences), 0)
-def MonsterStartVectorOfNonOwningReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
-def MonsterAddAnyUniqueType(builder, anyUniqueType): builder.PrependUint8Slot(43, anyUniqueType, 0)
-def MonsterAddAnyUnique(builder, anyUnique): builder.PrependUOffsetTRelativeSlot(44, flatbuffers.number_types.UOffsetTFlags.py_type(anyUnique), 0)
-def MonsterAddAnyAmbiguousType(builder, anyAmbiguousType): builder.PrependUint8Slot(45, anyAmbiguousType, 0)
-def MonsterAddAnyAmbiguous(builder, anyAmbiguous): builder.PrependUOffsetTRelativeSlot(46, flatbuffers.number_types.UOffsetTFlags.py_type(anyAmbiguous), 0)
-def MonsterAddVectorOfEnums(builder, vectorOfEnums): builder.PrependUOffsetTRelativeSlot(47, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfEnums), 0)
-def MonsterStartVectorOfEnumsVector(builder, numElems): return builder.StartVector(1, numElems, 1)
-def MonsterAddSignedEnum(builder, signedEnum): builder.PrependInt8Slot(48, signedEnum, -1)
-def MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer): builder.PrependUOffsetTRelativeSlot(49, flatbuffers.number_types.UOffsetTFlags.py_type(testrequirednestedflatbuffer), 0)
-def MonsterStartTestrequirednestedflatbufferVector(builder, numElems): return builder.StartVector(1, numElems, 1)
-def MonsterMakeTestrequirednestedflatbufferVectorFromBytes(builder, bytes):
+def MakeTestnestedflatbufferVectorFromBytes(builder, bytes):
builder.StartVector(1, len(bytes), 1)
builder.head = builder.head - len(bytes)
builder.Bytes[builder.head : builder.head + len(bytes)] = bytes
return builder.EndVector()
-def MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables): builder.PrependUOffsetTRelativeSlot(50, flatbuffers.number_types.UOffsetTFlags.py_type(scalarKeySortedTables), 0)
-def MonsterStartScalarKeySortedTablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
-def MonsterEnd(builder): return builder.EndObject()
-
+def AddTestempty(builder, testempty): builder.PrependUOffsetTRelativeSlot(14, flatbuffers.number_types.UOffsetTFlags.py_type(testempty), 0)
+def MonsterAddTestempty(builder, testempty):
+ """This method is deprecated. Please switch to AddTestempty."""
+ return AddTestempty(builder, testempty)
+def AddTestbool(builder, testbool): builder.PrependBoolSlot(15, testbool, 0)
+def MonsterAddTestbool(builder, testbool):
+ """This method is deprecated. Please switch to AddTestbool."""
+ return AddTestbool(builder, testbool)
+def AddTesthashs32Fnv1(builder, testhashs32Fnv1): builder.PrependInt32Slot(16, testhashs32Fnv1, 0)
+def MonsterAddTesthashs32Fnv1(builder, testhashs32Fnv1):
+ """This method is deprecated. Please switch to AddTesthashs32Fnv1."""
+ return AddTesthashs32Fnv1(builder, testhashs32Fnv1)
+def AddTesthashu32Fnv1(builder, testhashu32Fnv1): builder.PrependUint32Slot(17, testhashu32Fnv1, 0)
+def MonsterAddTesthashu32Fnv1(builder, testhashu32Fnv1):
+ """This method is deprecated. Please switch to AddTesthashu32Fnv1."""
+ return AddTesthashu32Fnv1(builder, testhashu32Fnv1)
+def AddTesthashs64Fnv1(builder, testhashs64Fnv1): builder.PrependInt64Slot(18, testhashs64Fnv1, 0)
+def MonsterAddTesthashs64Fnv1(builder, testhashs64Fnv1):
+ """This method is deprecated. Please switch to AddTesthashs64Fnv1."""
+ return AddTesthashs64Fnv1(builder, testhashs64Fnv1)
+def AddTesthashu64Fnv1(builder, testhashu64Fnv1): builder.PrependUint64Slot(19, testhashu64Fnv1, 0)
+def MonsterAddTesthashu64Fnv1(builder, testhashu64Fnv1):
+ """This method is deprecated. Please switch to AddTesthashu64Fnv1."""
+ return AddTesthashu64Fnv1(builder, testhashu64Fnv1)
+def AddTesthashs32Fnv1a(builder, testhashs32Fnv1a): builder.PrependInt32Slot(20, testhashs32Fnv1a, 0)
+def MonsterAddTesthashs32Fnv1a(builder, testhashs32Fnv1a):
+ """This method is deprecated. Please switch to AddTesthashs32Fnv1a."""
+ return AddTesthashs32Fnv1a(builder, testhashs32Fnv1a)
+def AddTesthashu32Fnv1a(builder, testhashu32Fnv1a): builder.PrependUint32Slot(21, testhashu32Fnv1a, 0)
+def MonsterAddTesthashu32Fnv1a(builder, testhashu32Fnv1a):
+ """This method is deprecated. Please switch to AddTesthashu32Fnv1a."""
+ return AddTesthashu32Fnv1a(builder, testhashu32Fnv1a)
+def AddTesthashs64Fnv1a(builder, testhashs64Fnv1a): builder.PrependInt64Slot(22, testhashs64Fnv1a, 0)
+def MonsterAddTesthashs64Fnv1a(builder, testhashs64Fnv1a):
+ """This method is deprecated. Please switch to AddTesthashs64Fnv1a."""
+ return AddTesthashs64Fnv1a(builder, testhashs64Fnv1a)
+def AddTesthashu64Fnv1a(builder, testhashu64Fnv1a): builder.PrependUint64Slot(23, testhashu64Fnv1a, 0)
+def MonsterAddTesthashu64Fnv1a(builder, testhashu64Fnv1a):
+ """This method is deprecated. Please switch to AddTesthashu64Fnv1a."""
+ return AddTesthashu64Fnv1a(builder, testhashu64Fnv1a)
+def AddTestarrayofbools(builder, testarrayofbools): builder.PrependUOffsetTRelativeSlot(24, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofbools), 0)
+def MonsterAddTestarrayofbools(builder, testarrayofbools):
+ """This method is deprecated. Please switch to AddTestarrayofbools."""
+ return AddTestarrayofbools(builder, testarrayofbools)
+def StartTestarrayofboolsVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def MonsterStartTestarrayofboolsVector(builder, numElems):
+ """This method is deprecated. Please switch to Start."""
+ return StartTestarrayofboolsVector(builder, numElems)
+def AddTestf(builder, testf): builder.PrependFloat32Slot(25, testf, 3.14159)
+def MonsterAddTestf(builder, testf):
+ """This method is deprecated. Please switch to AddTestf."""
+ return AddTestf(builder, testf)
+def AddTestf2(builder, testf2): builder.PrependFloat32Slot(26, testf2, 3.0)
+def MonsterAddTestf2(builder, testf2):
+ """This method is deprecated. Please switch to AddTestf2."""
+ return AddTestf2(builder, testf2)
+def AddTestf3(builder, testf3): builder.PrependFloat32Slot(27, testf3, 0.0)
+def MonsterAddTestf3(builder, testf3):
+ """This method is deprecated. Please switch to AddTestf3."""
+ return AddTestf3(builder, testf3)
+def AddTestarrayofstring2(builder, testarrayofstring2): builder.PrependUOffsetTRelativeSlot(28, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring2), 0)
+def MonsterAddTestarrayofstring2(builder, testarrayofstring2):
+ """This method is deprecated. Please switch to AddTestarrayofstring2."""
+ return AddTestarrayofstring2(builder, testarrayofstring2)
+def StartTestarrayofstring2Vector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def MonsterStartTestarrayofstring2Vector(builder, numElems):
+ """This method is deprecated. Please switch to Start."""
+ return StartTestarrayofstring2Vector(builder, numElems)
+def AddTestarrayofsortedstruct(builder, testarrayofsortedstruct): builder.PrependUOffsetTRelativeSlot(29, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofsortedstruct), 0)
+def MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct):
+ """This method is deprecated. Please switch to AddTestarrayofsortedstruct."""
+ return AddTestarrayofsortedstruct(builder, testarrayofsortedstruct)
+def StartTestarrayofsortedstructVector(builder, numElems): return builder.StartVector(8, numElems, 4)
+def MonsterStartTestarrayofsortedstructVector(builder, numElems):
+ """This method is deprecated. Please switch to Start."""
+ return StartTestarrayofsortedstructVector(builder, numElems)
+def AddFlex(builder, flex): builder.PrependUOffsetTRelativeSlot(30, flatbuffers.number_types.UOffsetTFlags.py_type(flex), 0)
+def MonsterAddFlex(builder, flex):
+ """This method is deprecated. Please switch to AddFlex."""
+ return AddFlex(builder, flex)
+def StartFlexVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def MonsterStartFlexVector(builder, numElems):
+ """This method is deprecated. Please switch to Start."""
+ return StartFlexVector(builder, numElems)
+def AddTest5(builder, test5): builder.PrependUOffsetTRelativeSlot(31, flatbuffers.number_types.UOffsetTFlags.py_type(test5), 0)
+def MonsterAddTest5(builder, test5):
+ """This method is deprecated. Please switch to AddTest5."""
+ return AddTest5(builder, test5)
+def StartTest5Vector(builder, numElems): return builder.StartVector(4, numElems, 2)
+def MonsterStartTest5Vector(builder, numElems):
+ """This method is deprecated. Please switch to Start."""
+ return StartTest5Vector(builder, numElems)
+def AddVectorOfLongs(builder, vectorOfLongs): builder.PrependUOffsetTRelativeSlot(32, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfLongs), 0)
+def MonsterAddVectorOfLongs(builder, vectorOfLongs):
+ """This method is deprecated. Please switch to AddVectorOfLongs."""
+ return AddVectorOfLongs(builder, vectorOfLongs)
+def StartVectorOfLongsVector(builder, numElems): return builder.StartVector(8, numElems, 8)
+def MonsterStartVectorOfLongsVector(builder, numElems):
+ """This method is deprecated. Please switch to Start."""
+ return StartVectorOfLongsVector(builder, numElems)
+def AddVectorOfDoubles(builder, vectorOfDoubles): builder.PrependUOffsetTRelativeSlot(33, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfDoubles), 0)
+def MonsterAddVectorOfDoubles(builder, vectorOfDoubles):
+ """This method is deprecated. Please switch to AddVectorOfDoubles."""
+ return AddVectorOfDoubles(builder, vectorOfDoubles)
+def StartVectorOfDoublesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
+def MonsterStartVectorOfDoublesVector(builder, numElems):
+ """This method is deprecated. Please switch to Start."""
+ return StartVectorOfDoublesVector(builder, numElems)
+def AddParentNamespaceTest(builder, parentNamespaceTest): builder.PrependUOffsetTRelativeSlot(34, flatbuffers.number_types.UOffsetTFlags.py_type(parentNamespaceTest), 0)
+def MonsterAddParentNamespaceTest(builder, parentNamespaceTest):
+ """This method is deprecated. Please switch to AddParentNamespaceTest."""
+ return AddParentNamespaceTest(builder, parentNamespaceTest)
+def AddVectorOfReferrables(builder, vectorOfReferrables): builder.PrependUOffsetTRelativeSlot(35, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfReferrables), 0)
+def MonsterAddVectorOfReferrables(builder, vectorOfReferrables):
+ """This method is deprecated. Please switch to AddVectorOfReferrables."""
+ return AddVectorOfReferrables(builder, vectorOfReferrables)
+def StartVectorOfReferrablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def MonsterStartVectorOfReferrablesVector(builder, numElems):
+ """This method is deprecated. Please switch to Start."""
+ return StartVectorOfReferrablesVector(builder, numElems)
+def AddSingleWeakReference(builder, singleWeakReference): builder.PrependUint64Slot(36, singleWeakReference, 0)
+def MonsterAddSingleWeakReference(builder, singleWeakReference):
+ """This method is deprecated. Please switch to AddSingleWeakReference."""
+ return AddSingleWeakReference(builder, singleWeakReference)
+def AddVectorOfWeakReferences(builder, vectorOfWeakReferences): builder.PrependUOffsetTRelativeSlot(37, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfWeakReferences), 0)
+def MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences):
+ """This method is deprecated. Please switch to AddVectorOfWeakReferences."""
+ return AddVectorOfWeakReferences(builder, vectorOfWeakReferences)
+def StartVectorOfWeakReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
+def MonsterStartVectorOfWeakReferencesVector(builder, numElems):
+ """This method is deprecated. Please switch to Start."""
+ return StartVectorOfWeakReferencesVector(builder, numElems)
+def AddVectorOfStrongReferrables(builder, vectorOfStrongReferrables): builder.PrependUOffsetTRelativeSlot(38, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfStrongReferrables), 0)
+def MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables):
+ """This method is deprecated. Please switch to AddVectorOfStrongReferrables."""
+ return AddVectorOfStrongReferrables(builder, vectorOfStrongReferrables)
+def StartVectorOfStrongReferrablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def MonsterStartVectorOfStrongReferrablesVector(builder, numElems):
+ """This method is deprecated. Please switch to Start."""
+ return StartVectorOfStrongReferrablesVector(builder, numElems)
+def AddCoOwningReference(builder, coOwningReference): builder.PrependUint64Slot(39, coOwningReference, 0)
+def MonsterAddCoOwningReference(builder, coOwningReference):
+ """This method is deprecated. Please switch to AddCoOwningReference."""
+ return AddCoOwningReference(builder, coOwningReference)
+def AddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences): builder.PrependUOffsetTRelativeSlot(40, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfCoOwningReferences), 0)
+def MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences):
+ """This method is deprecated. Please switch to AddVectorOfCoOwningReferences."""
+ return AddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences)
+def StartVectorOfCoOwningReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
+def MonsterStartVectorOfCoOwningReferencesVector(builder, numElems):
+ """This method is deprecated. Please switch to Start."""
+ return StartVectorOfCoOwningReferencesVector(builder, numElems)
+def AddNonOwningReference(builder, nonOwningReference): builder.PrependUint64Slot(41, nonOwningReference, 0)
+def MonsterAddNonOwningReference(builder, nonOwningReference):
+ """This method is deprecated. Please switch to AddNonOwningReference."""
+ return AddNonOwningReference(builder, nonOwningReference)
+def AddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences): builder.PrependUOffsetTRelativeSlot(42, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfNonOwningReferences), 0)
+def MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences):
+ """This method is deprecated. Please switch to AddVectorOfNonOwningReferences."""
+ return AddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences)
+def StartVectorOfNonOwningReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
+def MonsterStartVectorOfNonOwningReferencesVector(builder, numElems):
+ """This method is deprecated. Please switch to Start."""
+ return StartVectorOfNonOwningReferencesVector(builder, numElems)
+def AddAnyUniqueType(builder, anyUniqueType): builder.PrependUint8Slot(43, anyUniqueType, 0)
+def MonsterAddAnyUniqueType(builder, anyUniqueType):
+ """This method is deprecated. Please switch to AddAnyUniqueType."""
+ return AddAnyUniqueType(builder, anyUniqueType)
+def AddAnyUnique(builder, anyUnique): builder.PrependUOffsetTRelativeSlot(44, flatbuffers.number_types.UOffsetTFlags.py_type(anyUnique), 0)
+def MonsterAddAnyUnique(builder, anyUnique):
+ """This method is deprecated. Please switch to AddAnyUnique."""
+ return AddAnyUnique(builder, anyUnique)
+def AddAnyAmbiguousType(builder, anyAmbiguousType): builder.PrependUint8Slot(45, anyAmbiguousType, 0)
+def MonsterAddAnyAmbiguousType(builder, anyAmbiguousType):
+ """This method is deprecated. Please switch to AddAnyAmbiguousType."""
+ return AddAnyAmbiguousType(builder, anyAmbiguousType)
+def AddAnyAmbiguous(builder, anyAmbiguous): builder.PrependUOffsetTRelativeSlot(46, flatbuffers.number_types.UOffsetTFlags.py_type(anyAmbiguous), 0)
+def MonsterAddAnyAmbiguous(builder, anyAmbiguous):
+ """This method is deprecated. Please switch to AddAnyAmbiguous."""
+ return AddAnyAmbiguous(builder, anyAmbiguous)
+def AddVectorOfEnums(builder, vectorOfEnums): builder.PrependUOffsetTRelativeSlot(47, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfEnums), 0)
+def MonsterAddVectorOfEnums(builder, vectorOfEnums):
+ """This method is deprecated. Please switch to AddVectorOfEnums."""
+ return AddVectorOfEnums(builder, vectorOfEnums)
+def StartVectorOfEnumsVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def MonsterStartVectorOfEnumsVector(builder, numElems):
+ """This method is deprecated. Please switch to Start."""
+ return StartVectorOfEnumsVector(builder, numElems)
+def AddSignedEnum(builder, signedEnum): builder.PrependInt8Slot(48, signedEnum, -1)
+def MonsterAddSignedEnum(builder, signedEnum):
+ """This method is deprecated. Please switch to AddSignedEnum."""
+ return AddSignedEnum(builder, signedEnum)
+def AddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer): builder.PrependUOffsetTRelativeSlot(49, flatbuffers.number_types.UOffsetTFlags.py_type(testrequirednestedflatbuffer), 0)
+def MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer):
+ """This method is deprecated. Please switch to AddTestrequirednestedflatbuffer."""
+ return AddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer)
+def StartTestrequirednestedflatbufferVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def MonsterStartTestrequirednestedflatbufferVector(builder, numElems):
+ """This method is deprecated. Please switch to Start."""
+ return StartTestrequirednestedflatbufferVector(builder, numElems)
+def MakeVectorFromBytes(builder, bytes):
+ builder.StartVector(1, len(bytes), 1)
+ builder.head = builder.head - len(bytes)
+ builder.Bytes[builder.head : builder.head + len(bytes)] = bytes
+ return builder.EndVector()
+def MakeTestrequirednestedflatbufferVectorFromBytes(builder, bytes):
+ builder.StartVector(1, len(bytes), 1)
+ builder.head = builder.head - len(bytes)
+ builder.Bytes[builder.head : builder.head + len(bytes)] = bytes
+ return builder.EndVector()
+def AddScalarKeySortedTables(builder, scalarKeySortedTables): builder.PrependUOffsetTRelativeSlot(50, flatbuffers.number_types.UOffsetTFlags.py_type(scalarKeySortedTables), 0)
+def MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables):
+ """This method is deprecated. Please switch to AddScalarKeySortedTables."""
+ return AddScalarKeySortedTables(builder, scalarKeySortedTables)
+def StartScalarKeySortedTablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def MonsterStartScalarKeySortedTablesVector(builder, numElems):
+ """This method is deprecated. Please switch to Start."""
+ return StartScalarKeySortedTablesVector(builder, numElems)
+def End(builder): return builder.EndObject()
+def MonsterEnd(builder):
+ """This method is deprecated. Please switch to End."""
+ return End(builder)
import MyGame.Example.Ability
import MyGame.Example.Any
import MyGame.Example.AnyAmbiguousAliases
if np is not None and type(self.inventory) is np.ndarray:
inventory = builder.CreateNumpyVector(self.inventory)
else:
- MonsterStartInventoryVector(builder, len(self.inventory))
+ StartInventoryVector(builder, len(self.inventory))
for i in reversed(range(len(self.inventory))):
builder.PrependUint8(self.inventory[i])
inventory = builder.EndVector()
if self.test is not None:
test = self.test.Pack(builder)
if self.test4 is not None:
- MonsterStartTest4Vector(builder, len(self.test4))
+ StartTest4Vector(builder, len(self.test4))
for i in reversed(range(len(self.test4))):
self.test4[i].Pack(builder)
test4 = builder.EndVector()
testarrayofstringlist = []
for i in range(len(self.testarrayofstring)):
testarrayofstringlist.append(builder.CreateString(self.testarrayofstring[i]))
- MonsterStartTestarrayofstringVector(builder, len(self.testarrayofstring))
+ StartTestarrayofstringVector(builder, len(self.testarrayofstring))
for i in reversed(range(len(self.testarrayofstring))):
builder.PrependUOffsetTRelative(testarrayofstringlist[i])
testarrayofstring = builder.EndVector()
testarrayoftableslist = []
for i in range(len(self.testarrayoftables)):
testarrayoftableslist.append(self.testarrayoftables[i].Pack(builder))
- MonsterStartTestarrayoftablesVector(builder, len(self.testarrayoftables))
+ StartTestarrayoftablesVector(builder, len(self.testarrayoftables))
for i in reversed(range(len(self.testarrayoftables))):
builder.PrependUOffsetTRelative(testarrayoftableslist[i])
testarrayoftables = builder.EndVector()
if np is not None and type(self.testnestedflatbuffer) is np.ndarray:
testnestedflatbuffer = builder.CreateNumpyVector(self.testnestedflatbuffer)
else:
- MonsterStartTestnestedflatbufferVector(builder, len(self.testnestedflatbuffer))
+ StartTestnestedflatbufferVector(builder, len(self.testnestedflatbuffer))
for i in reversed(range(len(self.testnestedflatbuffer))):
builder.PrependUint8(self.testnestedflatbuffer[i])
testnestedflatbuffer = builder.EndVector()
if np is not None and type(self.testarrayofbools) is np.ndarray:
testarrayofbools = builder.CreateNumpyVector(self.testarrayofbools)
else:
- MonsterStartTestarrayofboolsVector(builder, len(self.testarrayofbools))
+ StartTestarrayofboolsVector(builder, len(self.testarrayofbools))
for i in reversed(range(len(self.testarrayofbools))):
builder.PrependBool(self.testarrayofbools[i])
testarrayofbools = builder.EndVector()
testarrayofstring2list = []
for i in range(len(self.testarrayofstring2)):
testarrayofstring2list.append(builder.CreateString(self.testarrayofstring2[i]))
- MonsterStartTestarrayofstring2Vector(builder, len(self.testarrayofstring2))
+ StartTestarrayofstring2Vector(builder, len(self.testarrayofstring2))
for i in reversed(range(len(self.testarrayofstring2))):
builder.PrependUOffsetTRelative(testarrayofstring2list[i])
testarrayofstring2 = builder.EndVector()
if self.testarrayofsortedstruct is not None:
- MonsterStartTestarrayofsortedstructVector(builder, len(self.testarrayofsortedstruct))
+ StartTestarrayofsortedstructVector(builder, len(self.testarrayofsortedstruct))
for i in reversed(range(len(self.testarrayofsortedstruct))):
self.testarrayofsortedstruct[i].Pack(builder)
testarrayofsortedstruct = builder.EndVector()
if np is not None and type(self.flex) is np.ndarray:
flex = builder.CreateNumpyVector(self.flex)
else:
- MonsterStartFlexVector(builder, len(self.flex))
+ StartFlexVector(builder, len(self.flex))
for i in reversed(range(len(self.flex))):
builder.PrependUint8(self.flex[i])
flex = builder.EndVector()
if self.test5 is not None:
- MonsterStartTest5Vector(builder, len(self.test5))
+ StartTest5Vector(builder, len(self.test5))
for i in reversed(range(len(self.test5))):
self.test5[i].Pack(builder)
test5 = builder.EndVector()
if np is not None and type(self.vectorOfLongs) is np.ndarray:
vectorOfLongs = builder.CreateNumpyVector(self.vectorOfLongs)
else:
- MonsterStartVectorOfLongsVector(builder, len(self.vectorOfLongs))
+ StartVectorOfLongsVector(builder, len(self.vectorOfLongs))
for i in reversed(range(len(self.vectorOfLongs))):
builder.PrependInt64(self.vectorOfLongs[i])
vectorOfLongs = builder.EndVector()
if np is not None and type(self.vectorOfDoubles) is np.ndarray:
vectorOfDoubles = builder.CreateNumpyVector(self.vectorOfDoubles)
else:
- MonsterStartVectorOfDoublesVector(builder, len(self.vectorOfDoubles))
+ StartVectorOfDoublesVector(builder, len(self.vectorOfDoubles))
for i in reversed(range(len(self.vectorOfDoubles))):
builder.PrependFloat64(self.vectorOfDoubles[i])
vectorOfDoubles = builder.EndVector()
vectorOfReferrableslist = []
for i in range(len(self.vectorOfReferrables)):
vectorOfReferrableslist.append(self.vectorOfReferrables[i].Pack(builder))
- MonsterStartVectorOfReferrablesVector(builder, len(self.vectorOfReferrables))
+ StartVectorOfReferrablesVector(builder, len(self.vectorOfReferrables))
for i in reversed(range(len(self.vectorOfReferrables))):
builder.PrependUOffsetTRelative(vectorOfReferrableslist[i])
vectorOfReferrables = builder.EndVector()
if np is not None and type(self.vectorOfWeakReferences) is np.ndarray:
vectorOfWeakReferences = builder.CreateNumpyVector(self.vectorOfWeakReferences)
else:
- MonsterStartVectorOfWeakReferencesVector(builder, len(self.vectorOfWeakReferences))
+ StartVectorOfWeakReferencesVector(builder, len(self.vectorOfWeakReferences))
for i in reversed(range(len(self.vectorOfWeakReferences))):
builder.PrependUint64(self.vectorOfWeakReferences[i])
vectorOfWeakReferences = builder.EndVector()
vectorOfStrongReferrableslist = []
for i in range(len(self.vectorOfStrongReferrables)):
vectorOfStrongReferrableslist.append(self.vectorOfStrongReferrables[i].Pack(builder))
- MonsterStartVectorOfStrongReferrablesVector(builder, len(self.vectorOfStrongReferrables))
+ StartVectorOfStrongReferrablesVector(builder, len(self.vectorOfStrongReferrables))
for i in reversed(range(len(self.vectorOfStrongReferrables))):
builder.PrependUOffsetTRelative(vectorOfStrongReferrableslist[i])
vectorOfStrongReferrables = builder.EndVector()
if np is not None and type(self.vectorOfCoOwningReferences) is np.ndarray:
vectorOfCoOwningReferences = builder.CreateNumpyVector(self.vectorOfCoOwningReferences)
else:
- MonsterStartVectorOfCoOwningReferencesVector(builder, len(self.vectorOfCoOwningReferences))
+ StartVectorOfCoOwningReferencesVector(builder, len(self.vectorOfCoOwningReferences))
for i in reversed(range(len(self.vectorOfCoOwningReferences))):
builder.PrependUint64(self.vectorOfCoOwningReferences[i])
vectorOfCoOwningReferences = builder.EndVector()
if np is not None and type(self.vectorOfNonOwningReferences) is np.ndarray:
vectorOfNonOwningReferences = builder.CreateNumpyVector(self.vectorOfNonOwningReferences)
else:
- MonsterStartVectorOfNonOwningReferencesVector(builder, len(self.vectorOfNonOwningReferences))
+ StartVectorOfNonOwningReferencesVector(builder, len(self.vectorOfNonOwningReferences))
for i in reversed(range(len(self.vectorOfNonOwningReferences))):
builder.PrependUint64(self.vectorOfNonOwningReferences[i])
vectorOfNonOwningReferences = builder.EndVector()
if np is not None and type(self.vectorOfEnums) is np.ndarray:
vectorOfEnums = builder.CreateNumpyVector(self.vectorOfEnums)
else:
- MonsterStartVectorOfEnumsVector(builder, len(self.vectorOfEnums))
+ StartVectorOfEnumsVector(builder, len(self.vectorOfEnums))
for i in reversed(range(len(self.vectorOfEnums))):
builder.PrependUint8(self.vectorOfEnums[i])
vectorOfEnums = builder.EndVector()
if np is not None and type(self.testrequirednestedflatbuffer) is np.ndarray:
testrequirednestedflatbuffer = builder.CreateNumpyVector(self.testrequirednestedflatbuffer)
else:
- MonsterStartTestrequirednestedflatbufferVector(builder, len(self.testrequirednestedflatbuffer))
+ StartTestrequirednestedflatbufferVector(builder, len(self.testrequirednestedflatbuffer))
for i in reversed(range(len(self.testrequirednestedflatbuffer))):
builder.PrependUint8(self.testrequirednestedflatbuffer[i])
testrequirednestedflatbuffer = builder.EndVector()
scalarKeySortedTableslist = []
for i in range(len(self.scalarKeySortedTables)):
scalarKeySortedTableslist.append(self.scalarKeySortedTables[i].Pack(builder))
- MonsterStartScalarKeySortedTablesVector(builder, len(self.scalarKeySortedTables))
+ StartScalarKeySortedTablesVector(builder, len(self.scalarKeySortedTables))
for i in reversed(range(len(self.scalarKeySortedTables))):
builder.PrependUOffsetTRelative(scalarKeySortedTableslist[i])
scalarKeySortedTables = builder.EndVector()
- MonsterStart(builder)
+ Start(builder)
if self.pos is not None:
pos = self.pos.Pack(builder)
- MonsterAddPos(builder, pos)
- MonsterAddMana(builder, self.mana)
- MonsterAddHp(builder, self.hp)
+ AddPos(builder, pos)
+ AddMana(builder, self.mana)
+ AddHp(builder, self.hp)
if self.name is not None:
- MonsterAddName(builder, name)
+ AddName(builder, name)
if self.inventory is not None:
- MonsterAddInventory(builder, inventory)
- MonsterAddColor(builder, self.color)
- MonsterAddTestType(builder, self.testType)
+ AddInventory(builder, inventory)
+ AddColor(builder, self.color)
+ AddTestType(builder, self.testType)
if self.test is not None:
- MonsterAddTest(builder, test)
+ AddTest(builder, test)
if self.test4 is not None:
- MonsterAddTest4(builder, test4)
+ AddTest4(builder, test4)
if self.testarrayofstring is not None:
- MonsterAddTestarrayofstring(builder, testarrayofstring)
+ AddTestarrayofstring(builder, testarrayofstring)
if self.testarrayoftables is not None:
- MonsterAddTestarrayoftables(builder, testarrayoftables)
+ AddTestarrayoftables(builder, testarrayoftables)
if self.enemy is not None:
- MonsterAddEnemy(builder, enemy)
+ AddEnemy(builder, enemy)
if self.testnestedflatbuffer is not None:
- MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer)
+ AddTestnestedflatbuffer(builder, testnestedflatbuffer)
if self.testempty is not None:
- MonsterAddTestempty(builder, testempty)
- MonsterAddTestbool(builder, self.testbool)
- MonsterAddTesthashs32Fnv1(builder, self.testhashs32Fnv1)
- MonsterAddTesthashu32Fnv1(builder, self.testhashu32Fnv1)
- MonsterAddTesthashs64Fnv1(builder, self.testhashs64Fnv1)
- MonsterAddTesthashu64Fnv1(builder, self.testhashu64Fnv1)
- MonsterAddTesthashs32Fnv1a(builder, self.testhashs32Fnv1a)
- MonsterAddTesthashu32Fnv1a(builder, self.testhashu32Fnv1a)
- MonsterAddTesthashs64Fnv1a(builder, self.testhashs64Fnv1a)
- MonsterAddTesthashu64Fnv1a(builder, self.testhashu64Fnv1a)
+ AddTestempty(builder, testempty)
+ AddTestbool(builder, self.testbool)
+ AddTesthashs32Fnv1(builder, self.testhashs32Fnv1)
+ AddTesthashu32Fnv1(builder, self.testhashu32Fnv1)
+ AddTesthashs64Fnv1(builder, self.testhashs64Fnv1)
+ AddTesthashu64Fnv1(builder, self.testhashu64Fnv1)
+ AddTesthashs32Fnv1a(builder, self.testhashs32Fnv1a)
+ AddTesthashu32Fnv1a(builder, self.testhashu32Fnv1a)
+ AddTesthashs64Fnv1a(builder, self.testhashs64Fnv1a)
+ AddTesthashu64Fnv1a(builder, self.testhashu64Fnv1a)
if self.testarrayofbools is not None:
- MonsterAddTestarrayofbools(builder, testarrayofbools)
- MonsterAddTestf(builder, self.testf)
- MonsterAddTestf2(builder, self.testf2)
- MonsterAddTestf3(builder, self.testf3)
+ AddTestarrayofbools(builder, testarrayofbools)
+ AddTestf(builder, self.testf)
+ AddTestf2(builder, self.testf2)
+ AddTestf3(builder, self.testf3)
if self.testarrayofstring2 is not None:
- MonsterAddTestarrayofstring2(builder, testarrayofstring2)
+ AddTestarrayofstring2(builder, testarrayofstring2)
if self.testarrayofsortedstruct is not None:
- MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct)
+ AddTestarrayofsortedstruct(builder, testarrayofsortedstruct)
if self.flex is not None:
- MonsterAddFlex(builder, flex)
+ AddFlex(builder, flex)
if self.test5 is not None:
- MonsterAddTest5(builder, test5)
+ AddTest5(builder, test5)
if self.vectorOfLongs is not None:
- MonsterAddVectorOfLongs(builder, vectorOfLongs)
+ AddVectorOfLongs(builder, vectorOfLongs)
if self.vectorOfDoubles is not None:
- MonsterAddVectorOfDoubles(builder, vectorOfDoubles)
+ AddVectorOfDoubles(builder, vectorOfDoubles)
if self.parentNamespaceTest is not None:
- MonsterAddParentNamespaceTest(builder, parentNamespaceTest)
+ AddParentNamespaceTest(builder, parentNamespaceTest)
if self.vectorOfReferrables is not None:
- MonsterAddVectorOfReferrables(builder, vectorOfReferrables)
- MonsterAddSingleWeakReference(builder, self.singleWeakReference)
+ AddVectorOfReferrables(builder, vectorOfReferrables)
+ AddSingleWeakReference(builder, self.singleWeakReference)
if self.vectorOfWeakReferences is not None:
- MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences)
+ AddVectorOfWeakReferences(builder, vectorOfWeakReferences)
if self.vectorOfStrongReferrables is not None:
- MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables)
- MonsterAddCoOwningReference(builder, self.coOwningReference)
+ AddVectorOfStrongReferrables(builder, vectorOfStrongReferrables)
+ AddCoOwningReference(builder, self.coOwningReference)
if self.vectorOfCoOwningReferences is not None:
- MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences)
- MonsterAddNonOwningReference(builder, self.nonOwningReference)
+ AddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences)
+ AddNonOwningReference(builder, self.nonOwningReference)
if self.vectorOfNonOwningReferences is not None:
- MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences)
- MonsterAddAnyUniqueType(builder, self.anyUniqueType)
+ AddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences)
+ AddAnyUniqueType(builder, self.anyUniqueType)
if self.anyUnique is not None:
- MonsterAddAnyUnique(builder, anyUnique)
- MonsterAddAnyAmbiguousType(builder, self.anyAmbiguousType)
+ AddAnyUnique(builder, anyUnique)
+ AddAnyAmbiguousType(builder, self.anyAmbiguousType)
if self.anyAmbiguous is not None:
- MonsterAddAnyAmbiguous(builder, anyAmbiguous)
+ AddAnyAmbiguous(builder, anyAmbiguous)
if self.vectorOfEnums is not None:
- MonsterAddVectorOfEnums(builder, vectorOfEnums)
- MonsterAddSignedEnum(builder, self.signedEnum)
+ AddVectorOfEnums(builder, vectorOfEnums)
+ AddSignedEnum(builder, self.signedEnum)
if self.testrequirednestedflatbuffer is not None:
- MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer)
+ AddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer)
if self.scalarKeySortedTables is not None:
- MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables)
- monster = MonsterEnd(builder)
+ AddScalarKeySortedTables(builder, scalarKeySortedTables)
+ monster = End(builder)
return monster
__slots__ = ['_tab']
@classmethod
- def GetRootAsReferrable(cls, buf, offset=0):
+ def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = Referrable()
x.Init(buf, n + offset)
return x
@classmethod
+ def GetRootAsReferrable(cls, buf, offset=0):
+ """This method is deprecated. Please switch to GetRootAs."""
+ return cls.GetRootAs(buf, offset)
+ @classmethod
def ReferrableBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4D\x4F\x4E\x53", size_prefixed=size_prefixed)
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
-def ReferrableStart(builder): builder.StartObject(1)
-def ReferrableAddId(builder, id): builder.PrependUint64Slot(0, id, 0)
-def ReferrableEnd(builder): return builder.EndObject()
-
+def Start(builder): builder.StartObject(1)
+def ReferrableStart(builder):
+ """This method is deprecated. Please switch to Start."""
+ return Start(builder)
+def AddId(builder, id): builder.PrependUint64Slot(0, id, 0)
+def ReferrableAddId(builder, id):
+ """This method is deprecated. Please switch to AddId."""
+ return AddId(builder, id)
+def End(builder): return builder.EndObject()
+def ReferrableEnd(builder):
+ """This method is deprecated. Please switch to End."""
+ return End(builder)
class ReferrableT(object):
# ReferrableT
def Pack(self, builder):
- ReferrableStart(builder)
- ReferrableAddId(builder, self.id)
- referrable = ReferrableEnd(builder)
+ Start(builder)
+ AddId(builder, self.id)
+ referrable = End(builder)
return referrable
__slots__ = ['_tab']
@classmethod
- def GetRootAsStat(cls, buf, offset=0):
+ def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = Stat()
x.Init(buf, n + offset)
return x
@classmethod
+ def GetRootAsStat(cls, buf, offset=0):
+ """This method is deprecated. Please switch to GetRootAs."""
+ return cls.GetRootAs(buf, offset)
+ @classmethod
def StatBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4D\x4F\x4E\x53", size_prefixed=size_prefixed)
return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
return 0
-def StatStart(builder): builder.StartObject(3)
-def StatAddId(builder, id): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(id), 0)
-def StatAddVal(builder, val): builder.PrependInt64Slot(1, val, 0)
-def StatAddCount(builder, count): builder.PrependUint16Slot(2, count, 0)
-def StatEnd(builder): return builder.EndObject()
-
+def Start(builder): builder.StartObject(3)
+def StatStart(builder):
+ """This method is deprecated. Please switch to Start."""
+ return Start(builder)
+def AddId(builder, id): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(id), 0)
+def StatAddId(builder, id):
+ """This method is deprecated. Please switch to AddId."""
+ return AddId(builder, id)
+def AddVal(builder, val): builder.PrependInt64Slot(1, val, 0)
+def StatAddVal(builder, val):
+ """This method is deprecated. Please switch to AddVal."""
+ return AddVal(builder, val)
+def AddCount(builder, count): builder.PrependUint16Slot(2, count, 0)
+def StatAddCount(builder, count):
+ """This method is deprecated. Please switch to AddCount."""
+ return AddCount(builder, count)
+def End(builder): return builder.EndObject()
+def StatEnd(builder):
+ """This method is deprecated. Please switch to End."""
+ return End(builder)
class StatT(object):
def Pack(self, builder):
if self.id is not None:
id = builder.CreateString(self.id)
- StatStart(builder)
+ Start(builder)
if self.id is not None:
- StatAddId(builder, id)
- StatAddVal(builder, self.val)
- StatAddCount(builder, self.count)
- stat = StatEnd(builder)
+ AddId(builder, id)
+ AddVal(builder, self.val)
+ AddCount(builder, self.count)
+ stat = End(builder)
return stat
__slots__ = ['_tab']
@classmethod
- def GetRootAsTestSimpleTableWithEnum(cls, buf, offset=0):
+ def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = TestSimpleTableWithEnum()
x.Init(buf, n + offset)
return x
@classmethod
+ def GetRootAsTestSimpleTableWithEnum(cls, buf, offset=0):
+ """This method is deprecated. Please switch to GetRootAs."""
+ return cls.GetRootAs(buf, offset)
+ @classmethod
def TestSimpleTableWithEnumBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4D\x4F\x4E\x53", size_prefixed=size_prefixed)
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
return 2
-def TestSimpleTableWithEnumStart(builder): builder.StartObject(1)
-def TestSimpleTableWithEnumAddColor(builder, color): builder.PrependUint8Slot(0, color, 2)
-def TestSimpleTableWithEnumEnd(builder): return builder.EndObject()
-
+def Start(builder): builder.StartObject(1)
+def TestSimpleTableWithEnumStart(builder):
+ """This method is deprecated. Please switch to Start."""
+ return Start(builder)
+def AddColor(builder, color): builder.PrependUint8Slot(0, color, 2)
+def TestSimpleTableWithEnumAddColor(builder, color):
+ """This method is deprecated. Please switch to AddColor."""
+ return AddColor(builder, color)
+def End(builder): return builder.EndObject()
+def TestSimpleTableWithEnumEnd(builder):
+ """This method is deprecated. Please switch to End."""
+ return End(builder)
class TestSimpleTableWithEnumT(object):
# TestSimpleTableWithEnumT
def Pack(self, builder):
- TestSimpleTableWithEnumStart(builder)
- TestSimpleTableWithEnumAddColor(builder, self.color)
- testSimpleTableWithEnum = TestSimpleTableWithEnumEnd(builder)
+ Start(builder)
+ AddColor(builder, self.color)
+ testSimpleTableWithEnum = End(builder)
return testSimpleTableWithEnum
__slots__ = ['_tab']
@classmethod
- def GetRootAsTypeAliases(cls, buf, offset=0):
+ def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = TypeAliases()
x.Init(buf, n + offset)
return x
@classmethod
+ def GetRootAsTypeAliases(cls, buf, offset=0):
+ """This method is deprecated. Please switch to GetRootAs."""
+ return cls.GetRootAs(buf, offset)
+ @classmethod
def TypeAliasesBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4D\x4F\x4E\x53", size_prefixed=size_prefixed)
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
return o == 0
-def TypeAliasesStart(builder): builder.StartObject(12)
-def TypeAliasesAddI8(builder, i8): builder.PrependInt8Slot(0, i8, 0)
-def TypeAliasesAddU8(builder, u8): builder.PrependUint8Slot(1, u8, 0)
-def TypeAliasesAddI16(builder, i16): builder.PrependInt16Slot(2, i16, 0)
-def TypeAliasesAddU16(builder, u16): builder.PrependUint16Slot(3, u16, 0)
-def TypeAliasesAddI32(builder, i32): builder.PrependInt32Slot(4, i32, 0)
-def TypeAliasesAddU32(builder, u32): builder.PrependUint32Slot(5, u32, 0)
-def TypeAliasesAddI64(builder, i64): builder.PrependInt64Slot(6, i64, 0)
-def TypeAliasesAddU64(builder, u64): builder.PrependUint64Slot(7, u64, 0)
-def TypeAliasesAddF32(builder, f32): builder.PrependFloat32Slot(8, f32, 0.0)
-def TypeAliasesAddF64(builder, f64): builder.PrependFloat64Slot(9, f64, 0.0)
-def TypeAliasesAddV8(builder, v8): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(v8), 0)
-def TypeAliasesStartV8Vector(builder, numElems): return builder.StartVector(1, numElems, 1)
-def TypeAliasesAddVf64(builder, vf64): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(vf64), 0)
-def TypeAliasesStartVf64Vector(builder, numElems): return builder.StartVector(8, numElems, 8)
-def TypeAliasesEnd(builder): return builder.EndObject()
-
+def Start(builder): builder.StartObject(12)
+def TypeAliasesStart(builder):
+ """This method is deprecated. Please switch to Start."""
+ return Start(builder)
+def AddI8(builder, i8): builder.PrependInt8Slot(0, i8, 0)
+def TypeAliasesAddI8(builder, i8):
+ """This method is deprecated. Please switch to AddI8."""
+ return AddI8(builder, i8)
+def AddU8(builder, u8): builder.PrependUint8Slot(1, u8, 0)
+def TypeAliasesAddU8(builder, u8):
+ """This method is deprecated. Please switch to AddU8."""
+ return AddU8(builder, u8)
+def AddI16(builder, i16): builder.PrependInt16Slot(2, i16, 0)
+def TypeAliasesAddI16(builder, i16):
+ """This method is deprecated. Please switch to AddI16."""
+ return AddI16(builder, i16)
+def AddU16(builder, u16): builder.PrependUint16Slot(3, u16, 0)
+def TypeAliasesAddU16(builder, u16):
+ """This method is deprecated. Please switch to AddU16."""
+ return AddU16(builder, u16)
+def AddI32(builder, i32): builder.PrependInt32Slot(4, i32, 0)
+def TypeAliasesAddI32(builder, i32):
+ """This method is deprecated. Please switch to AddI32."""
+ return AddI32(builder, i32)
+def AddU32(builder, u32): builder.PrependUint32Slot(5, u32, 0)
+def TypeAliasesAddU32(builder, u32):
+ """This method is deprecated. Please switch to AddU32."""
+ return AddU32(builder, u32)
+def AddI64(builder, i64): builder.PrependInt64Slot(6, i64, 0)
+def TypeAliasesAddI64(builder, i64):
+ """This method is deprecated. Please switch to AddI64."""
+ return AddI64(builder, i64)
+def AddU64(builder, u64): builder.PrependUint64Slot(7, u64, 0)
+def TypeAliasesAddU64(builder, u64):
+ """This method is deprecated. Please switch to AddU64."""
+ return AddU64(builder, u64)
+def AddF32(builder, f32): builder.PrependFloat32Slot(8, f32, 0.0)
+def TypeAliasesAddF32(builder, f32):
+ """This method is deprecated. Please switch to AddF32."""
+ return AddF32(builder, f32)
+def AddF64(builder, f64): builder.PrependFloat64Slot(9, f64, 0.0)
+def TypeAliasesAddF64(builder, f64):
+ """This method is deprecated. Please switch to AddF64."""
+ return AddF64(builder, f64)
+def AddV8(builder, v8): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(v8), 0)
+def TypeAliasesAddV8(builder, v8):
+ """This method is deprecated. Please switch to AddV8."""
+ return AddV8(builder, v8)
+def StartV8Vector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def TypeAliasesStartV8Vector(builder, numElems):
+ """This method is deprecated. Please switch to Start."""
+ return StartV8Vector(builder, numElems)
+def AddVf64(builder, vf64): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(vf64), 0)
+def TypeAliasesAddVf64(builder, vf64):
+ """This method is deprecated. Please switch to AddVf64."""
+ return AddVf64(builder, vf64)
+def StartVf64Vector(builder, numElems): return builder.StartVector(8, numElems, 8)
+def TypeAliasesStartVf64Vector(builder, numElems):
+ """This method is deprecated. Please switch to Start."""
+ return StartVf64Vector(builder, numElems)
+def End(builder): return builder.EndObject()
+def TypeAliasesEnd(builder):
+ """This method is deprecated. Please switch to End."""
+ return End(builder)
try:
from typing import List
except:
if np is not None and type(self.v8) is np.ndarray:
v8 = builder.CreateNumpyVector(self.v8)
else:
- TypeAliasesStartV8Vector(builder, len(self.v8))
+ StartV8Vector(builder, len(self.v8))
for i in reversed(range(len(self.v8))):
builder.PrependByte(self.v8[i])
v8 = builder.EndVector()
if np is not None and type(self.vf64) is np.ndarray:
vf64 = builder.CreateNumpyVector(self.vf64)
else:
- TypeAliasesStartVf64Vector(builder, len(self.vf64))
+ StartVf64Vector(builder, len(self.vf64))
for i in reversed(range(len(self.vf64))):
builder.PrependFloat64(self.vf64[i])
vf64 = builder.EndVector()
- TypeAliasesStart(builder)
- TypeAliasesAddI8(builder, self.i8)
- TypeAliasesAddU8(builder, self.u8)
- TypeAliasesAddI16(builder, self.i16)
- TypeAliasesAddU16(builder, self.u16)
- TypeAliasesAddI32(builder, self.i32)
- TypeAliasesAddU32(builder, self.u32)
- TypeAliasesAddI64(builder, self.i64)
- TypeAliasesAddU64(builder, self.u64)
- TypeAliasesAddF32(builder, self.f32)
- TypeAliasesAddF64(builder, self.f64)
+ Start(builder)
+ AddI8(builder, self.i8)
+ AddU8(builder, self.u8)
+ AddI16(builder, self.i16)
+ AddU16(builder, self.u16)
+ AddI32(builder, self.i32)
+ AddU32(builder, self.u32)
+ AddI64(builder, self.i64)
+ AddU64(builder, self.u64)
+ AddF32(builder, self.f32)
+ AddF64(builder, self.f64)
if self.v8 is not None:
- TypeAliasesAddV8(builder, v8)
+ AddV8(builder, v8)
if self.vf64 is not None:
- TypeAliasesAddVf64(builder, vf64)
- typeAliases = TypeAliasesEnd(builder)
+ AddVf64(builder, vf64)
+ typeAliases = End(builder)
return typeAliases
__slots__ = ['_tab']
@classmethod
- def GetRootAsMonster(cls, buf, offset=0):
+ def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = Monster()
x.Init(buf, n + offset)
return x
@classmethod
+ def GetRootAsMonster(cls, buf, offset=0):
+ """This method is deprecated. Please switch to GetRootAs."""
+ return cls.GetRootAs(buf, offset)
+ @classmethod
def MonsterBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4D\x4F\x4E\x53", size_prefixed=size_prefixed)
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
-def MonsterStart(builder): builder.StartObject(0)
-def MonsterEnd(builder): return builder.EndObject()
-
+def Start(builder): builder.StartObject(0)
+def MonsterStart(builder):
+ """This method is deprecated. Please switch to Start."""
+ return Start(builder)
+def End(builder): return builder.EndObject()
+def MonsterEnd(builder):
+ """This method is deprecated. Please switch to End."""
+ return End(builder)
class MonsterT(object):
# MonsterT
def Pack(self, builder):
- MonsterStart(builder)
- monster = MonsterEnd(builder)
+ Start(builder)
+ monster = End(builder)
return monster
__slots__ = ['_tab']
@classmethod
- def GetRootAsInParentNamespace(cls, buf, offset=0):
+ def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = InParentNamespace()
x.Init(buf, n + offset)
return x
@classmethod
+ def GetRootAsInParentNamespace(cls, buf, offset=0):
+ """This method is deprecated. Please switch to GetRootAs."""
+ return cls.GetRootAs(buf, offset)
+ @classmethod
def InParentNamespaceBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4D\x4F\x4E\x53", size_prefixed=size_prefixed)
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
-def InParentNamespaceStart(builder): builder.StartObject(0)
-def InParentNamespaceEnd(builder): return builder.EndObject()
-
+def Start(builder): builder.StartObject(0)
+def InParentNamespaceStart(builder):
+ """This method is deprecated. Please switch to Start."""
+ return Start(builder)
+def End(builder): return builder.EndObject()
+def InParentNamespaceEnd(builder):
+ """This method is deprecated. Please switch to End."""
+ return End(builder)
class InParentNamespaceT(object):
# InParentNamespaceT
def Pack(self, builder):
- InParentNamespaceStart(builder)
- inParentNamespace = InParentNamespaceEnd(builder)
+ Start(builder)
+ inParentNamespace = End(builder)
return inParentNamespace
__slots__ = ['_tab']
@classmethod
- def GetRootAsMonsterExtra(cls, buf, offset=0):
+ def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = MonsterExtra()
x.Init(buf, n + offset)
return x
@classmethod
+ def GetRootAsMonsterExtra(cls, buf, offset=0):
+ """This method is deprecated. Please switch to GetRootAs."""
+ return cls.GetRootAs(buf, offset)
+ @classmethod
def MonsterExtraBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4D\x4F\x4E\x45", size_prefixed=size_prefixed)
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
return o == 0
-def MonsterExtraStart(builder): builder.StartObject(11)
-def MonsterExtraAddD0(builder, d0): builder.PrependFloat64Slot(0, d0, float('nan'))
-def MonsterExtraAddD1(builder, d1): builder.PrependFloat64Slot(1, d1, float('nan'))
-def MonsterExtraAddD2(builder, d2): builder.PrependFloat64Slot(2, d2, float('inf'))
-def MonsterExtraAddD3(builder, d3): builder.PrependFloat64Slot(3, d3, float('-inf'))
-def MonsterExtraAddF0(builder, f0): builder.PrependFloat32Slot(4, f0, float('nan'))
-def MonsterExtraAddF1(builder, f1): builder.PrependFloat32Slot(5, f1, float('nan'))
-def MonsterExtraAddF2(builder, f2): builder.PrependFloat32Slot(6, f2, float('inf'))
-def MonsterExtraAddF3(builder, f3): builder.PrependFloat32Slot(7, f3, float('-inf'))
-def MonsterExtraAddDvec(builder, dvec): builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(dvec), 0)
-def MonsterExtraStartDvecVector(builder, numElems): return builder.StartVector(8, numElems, 8)
-def MonsterExtraAddFvec(builder, fvec): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(fvec), 0)
-def MonsterExtraStartFvecVector(builder, numElems): return builder.StartVector(4, numElems, 4)
-def MonsterExtraEnd(builder): return builder.EndObject()
-
+def Start(builder): builder.StartObject(11)
+def MonsterExtraStart(builder):
+ """This method is deprecated. Please switch to Start."""
+ return Start(builder)
+def AddD0(builder, d0): builder.PrependFloat64Slot(0, d0, float('nan'))
+def MonsterExtraAddD0(builder, d0):
+ """This method is deprecated. Please switch to AddD0."""
+ return AddD0(builder, d0)
+def AddD1(builder, d1): builder.PrependFloat64Slot(1, d1, float('nan'))
+def MonsterExtraAddD1(builder, d1):
+ """This method is deprecated. Please switch to AddD1."""
+ return AddD1(builder, d1)
+def AddD2(builder, d2): builder.PrependFloat64Slot(2, d2, float('inf'))
+def MonsterExtraAddD2(builder, d2):
+ """This method is deprecated. Please switch to AddD2."""
+ return AddD2(builder, d2)
+def AddD3(builder, d3): builder.PrependFloat64Slot(3, d3, float('-inf'))
+def MonsterExtraAddD3(builder, d3):
+ """This method is deprecated. Please switch to AddD3."""
+ return AddD3(builder, d3)
+def AddF0(builder, f0): builder.PrependFloat32Slot(4, f0, float('nan'))
+def MonsterExtraAddF0(builder, f0):
+ """This method is deprecated. Please switch to AddF0."""
+ return AddF0(builder, f0)
+def AddF1(builder, f1): builder.PrependFloat32Slot(5, f1, float('nan'))
+def MonsterExtraAddF1(builder, f1):
+ """This method is deprecated. Please switch to AddF1."""
+ return AddF1(builder, f1)
+def AddF2(builder, f2): builder.PrependFloat32Slot(6, f2, float('inf'))
+def MonsterExtraAddF2(builder, f2):
+ """This method is deprecated. Please switch to AddF2."""
+ return AddF2(builder, f2)
+def AddF3(builder, f3): builder.PrependFloat32Slot(7, f3, float('-inf'))
+def MonsterExtraAddF3(builder, f3):
+ """This method is deprecated. Please switch to AddF3."""
+ return AddF3(builder, f3)
+def AddDvec(builder, dvec): builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(dvec), 0)
+def MonsterExtraAddDvec(builder, dvec):
+ """This method is deprecated. Please switch to AddDvec."""
+ return AddDvec(builder, dvec)
+def StartDvecVector(builder, numElems): return builder.StartVector(8, numElems, 8)
+def MonsterExtraStartDvecVector(builder, numElems):
+ """This method is deprecated. Please switch to Start."""
+ return StartDvecVector(builder, numElems)
+def AddFvec(builder, fvec): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(fvec), 0)
+def MonsterExtraAddFvec(builder, fvec):
+ """This method is deprecated. Please switch to AddFvec."""
+ return AddFvec(builder, fvec)
+def StartFvecVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def MonsterExtraStartFvecVector(builder, numElems):
+ """This method is deprecated. Please switch to Start."""
+ return StartFvecVector(builder, numElems)
+def End(builder): return builder.EndObject()
+def MonsterExtraEnd(builder):
+ """This method is deprecated. Please switch to End."""
+ return End(builder)
try:
from typing import List
except:
if np is not None and type(self.dvec) is np.ndarray:
dvec = builder.CreateNumpyVector(self.dvec)
else:
- MonsterExtraStartDvecVector(builder, len(self.dvec))
+ StartDvecVector(builder, len(self.dvec))
for i in reversed(range(len(self.dvec))):
builder.PrependFloat64(self.dvec[i])
dvec = builder.EndVector()
if np is not None and type(self.fvec) is np.ndarray:
fvec = builder.CreateNumpyVector(self.fvec)
else:
- MonsterExtraStartFvecVector(builder, len(self.fvec))
+ StartFvecVector(builder, len(self.fvec))
for i in reversed(range(len(self.fvec))):
builder.PrependFloat32(self.fvec[i])
fvec = builder.EndVector()
- MonsterExtraStart(builder)
- MonsterExtraAddD0(builder, self.d0)
- MonsterExtraAddD1(builder, self.d1)
- MonsterExtraAddD2(builder, self.d2)
- MonsterExtraAddD3(builder, self.d3)
- MonsterExtraAddF0(builder, self.f0)
- MonsterExtraAddF1(builder, self.f1)
- MonsterExtraAddF2(builder, self.f2)
- MonsterExtraAddF3(builder, self.f3)
+ Start(builder)
+ AddD0(builder, self.d0)
+ AddD1(builder, self.d1)
+ AddD2(builder, self.d2)
+ AddD3(builder, self.d3)
+ AddF0(builder, self.f0)
+ AddF1(builder, self.f1)
+ AddF2(builder, self.f2)
+ AddF3(builder, self.f3)
if self.dvec is not None:
- MonsterExtraAddDvec(builder, dvec)
+ AddDvec(builder, dvec)
if self.fvec is not None:
- MonsterExtraAddFvec(builder, fvec)
- monsterExtra = MonsterExtraEnd(builder)
+ AddFvec(builder, fvec)
+ monsterExtra = End(builder)
return monsterExtra
# Emit Python code for the example schema in the test dir:
${test_dir}/../flatc -p -o ${gen_code_path} -I include_test monster_test.fbs --gen-object-api
+${test_dir}/../flatc -p -o ${gen_code_path} -I include_test monster_extra.fbs --gen-object-api
# Syntax: run_tests <interpreter> <benchmark vtable dedupes>
# <benchmark read count> <benchmark build count>
__slots__ = ['_tab']
@classmethod
- def GetRootAsTableInNestedNS(cls, buf, offset=0):
+ def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = TableInNestedNS()
x.Init(buf, n + offset)
return x
+ @classmethod
+ def GetRootAsTableInNestedNS(cls, buf, offset=0):
+ """This method is deprecated. Please switch to GetRootAs."""
+ return cls.GetRootAs(buf, offset)
# TableInNestedNS
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
return 0
-def TableInNestedNSStart(builder): builder.StartObject(1)
-def TableInNestedNSAddFoo(builder, foo): builder.PrependInt32Slot(0, foo, 0)
-def TableInNestedNSEnd(builder): return builder.EndObject()
-
+def Start(builder): builder.StartObject(1)
+def TableInNestedNSStart(builder):
+ """This method is deprecated. Please switch to Start."""
+ return Start(builder)
+def AddFoo(builder, foo): builder.PrependInt32Slot(0, foo, 0)
+def TableInNestedNSAddFoo(builder, foo):
+ """This method is deprecated. Please switch to AddFoo."""
+ return AddFoo(builder, foo)
+def End(builder): return builder.EndObject()
+def TableInNestedNSEnd(builder):
+ """This method is deprecated. Please switch to End."""
+ return End(builder)
class TableInNestedNST(object):
# TableInNestedNST
def Pack(self, builder):
- TableInNestedNSStart(builder)
- TableInNestedNSAddFoo(builder, self.foo)
- tableInNestedNS = TableInNestedNSEnd(builder)
+ Start(builder)
+ AddFoo(builder, self.foo)
+ tableInNestedNS = End(builder)
return tableInNestedNS
__slots__ = ['_tab']
@classmethod
- def GetRootAsSecondTableInA(cls, buf, offset=0):
+ def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = SecondTableInA()
x.Init(buf, n + offset)
return x
+ @classmethod
+ def GetRootAsSecondTableInA(cls, buf, offset=0):
+ """This method is deprecated. Please switch to GetRootAs."""
+ return cls.GetRootAs(buf, offset)
# SecondTableInA
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
return obj
return None
-def SecondTableInAStart(builder): builder.StartObject(1)
-def SecondTableInAAddReferToC(builder, referToC): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(referToC), 0)
-def SecondTableInAEnd(builder): return builder.EndObject()
-
+def Start(builder): builder.StartObject(1)
+def SecondTableInAStart(builder):
+ """This method is deprecated. Please switch to Start."""
+ return Start(builder)
+def AddReferToC(builder, referToC): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(referToC), 0)
+def SecondTableInAAddReferToC(builder, referToC):
+ """This method is deprecated. Please switch to AddReferToC."""
+ return AddReferToC(builder, referToC)
+def End(builder): return builder.EndObject()
+def SecondTableInAEnd(builder):
+ """This method is deprecated. Please switch to End."""
+ return End(builder)
try:
from typing import Optional
except:
def Pack(self, builder):
if self.referToC is not None:
referToC = self.referToC.Pack(builder)
- SecondTableInAStart(builder)
+ Start(builder)
if self.referToC is not None:
- SecondTableInAAddReferToC(builder, referToC)
- secondTableInA = SecondTableInAEnd(builder)
+ AddReferToC(builder, referToC)
+ secondTableInA = End(builder)
return secondTableInA
__slots__ = ['_tab']
@classmethod
- def GetRootAsTableInFirstNS(cls, buf, offset=0):
+ def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = TableInFirstNS()
x.Init(buf, n + offset)
return x
+ @classmethod
+ def GetRootAsTableInFirstNS(cls, buf, offset=0):
+ """This method is deprecated. Please switch to GetRootAs."""
+ return cls.GetRootAs(buf, offset)
# TableInFirstNS
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
return obj
return None
-def TableInFirstNSStart(builder): builder.StartObject(5)
-def TableInFirstNSAddFooTable(builder, fooTable): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(fooTable), 0)
-def TableInFirstNSAddFooEnum(builder, fooEnum): builder.PrependInt8Slot(1, fooEnum, 0)
-def TableInFirstNSAddFooUnionType(builder, fooUnionType): builder.PrependUint8Slot(2, fooUnionType, 0)
-def TableInFirstNSAddFooUnion(builder, fooUnion): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(fooUnion), 0)
-def TableInFirstNSAddFooStruct(builder, fooStruct): builder.PrependStructSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(fooStruct), 0)
-def TableInFirstNSEnd(builder): return builder.EndObject()
-
+def Start(builder): builder.StartObject(5)
+def TableInFirstNSStart(builder):
+ """This method is deprecated. Please switch to Start."""
+ return Start(builder)
+def AddFooTable(builder, fooTable): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(fooTable), 0)
+def TableInFirstNSAddFooTable(builder, fooTable):
+ """This method is deprecated. Please switch to AddFooTable."""
+ return AddFooTable(builder, fooTable)
+def AddFooEnum(builder, fooEnum): builder.PrependInt8Slot(1, fooEnum, 0)
+def TableInFirstNSAddFooEnum(builder, fooEnum):
+ """This method is deprecated. Please switch to AddFooEnum."""
+ return AddFooEnum(builder, fooEnum)
+def AddFooUnionType(builder, fooUnionType): builder.PrependUint8Slot(2, fooUnionType, 0)
+def TableInFirstNSAddFooUnionType(builder, fooUnionType):
+ """This method is deprecated. Please switch to AddFooUnionType."""
+ return AddFooUnionType(builder, fooUnionType)
+def AddFooUnion(builder, fooUnion): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(fooUnion), 0)
+def TableInFirstNSAddFooUnion(builder, fooUnion):
+ """This method is deprecated. Please switch to AddFooUnion."""
+ return AddFooUnion(builder, fooUnion)
+def AddFooStruct(builder, fooStruct): builder.PrependStructSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(fooStruct), 0)
+def TableInFirstNSAddFooStruct(builder, fooStruct):
+ """This method is deprecated. Please switch to AddFooStruct."""
+ return AddFooStruct(builder, fooStruct)
+def End(builder): return builder.EndObject()
+def TableInFirstNSEnd(builder):
+ """This method is deprecated. Please switch to End."""
+ return End(builder)
try:
from typing import Optional, Union
except:
fooTable = self.fooTable.Pack(builder)
if self.fooUnion is not None:
fooUnion = self.fooUnion.Pack(builder)
- TableInFirstNSStart(builder)
+ Start(builder)
if self.fooTable is not None:
- TableInFirstNSAddFooTable(builder, fooTable)
- TableInFirstNSAddFooEnum(builder, self.fooEnum)
- TableInFirstNSAddFooUnionType(builder, self.fooUnionType)
+ AddFooTable(builder, fooTable)
+ AddFooEnum(builder, self.fooEnum)
+ AddFooUnionType(builder, self.fooUnionType)
if self.fooUnion is not None:
- TableInFirstNSAddFooUnion(builder, fooUnion)
+ AddFooUnion(builder, fooUnion)
if self.fooStruct is not None:
fooStruct = self.fooStruct.Pack(builder)
- TableInFirstNSAddFooStruct(builder, fooStruct)
- tableInFirstNS = TableInFirstNSEnd(builder)
+ AddFooStruct(builder, fooStruct)
+ tableInFirstNS = End(builder)
return tableInFirstNS
__slots__ = ['_tab']
@classmethod
- def GetRootAsTableInC(cls, buf, offset=0):
+ def GetRootAs(cls, buf, offset=0):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = TableInC()
x.Init(buf, n + offset)
return x
+ @classmethod
+ def GetRootAsTableInC(cls, buf, offset=0):
+ """This method is deprecated. Please switch to GetRootAs."""
+ return cls.GetRootAs(buf, offset)
# TableInC
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
return obj
return None
-def TableInCStart(builder): builder.StartObject(2)
-def TableInCAddReferToA1(builder, referToA1): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(referToA1), 0)
-def TableInCAddReferToA2(builder, referToA2): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(referToA2), 0)
-def TableInCEnd(builder): return builder.EndObject()
-
+def Start(builder): builder.StartObject(2)
+def TableInCStart(builder):
+ """This method is deprecated. Please switch to Start."""
+ return Start(builder)
+def AddReferToA1(builder, referToA1): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(referToA1), 0)
+def TableInCAddReferToA1(builder, referToA1):
+ """This method is deprecated. Please switch to AddReferToA1."""
+ return AddReferToA1(builder, referToA1)
+def AddReferToA2(builder, referToA2): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(referToA2), 0)
+def TableInCAddReferToA2(builder, referToA2):
+ """This method is deprecated. Please switch to AddReferToA2."""
+ return AddReferToA2(builder, referToA2)
+def End(builder): return builder.EndObject()
+def TableInCEnd(builder):
+ """This method is deprecated. Please switch to End."""
+ return End(builder)
try:
from typing import Optional
except:
referToA1 = self.referToA1.Pack(builder)
if self.referToA2 is not None:
referToA2 = self.referToA2.Pack(builder)
- TableInCStart(builder)
+ Start(builder)
if self.referToA1 is not None:
- TableInCAddReferToA1(builder, referToA1)
+ AddReferToA1(builder, referToA1)
if self.referToA2 is not None:
- TableInCAddReferToA2(builder, referToA2)
- tableInC = TableInCEnd(builder)
+ AddReferToA2(builder, referToA2)
+ tableInC = End(builder)
return tableInC
buf, off = make_monster_from_generated_code()
# Turns a buffer into Python object (T class).
- monster1 = MyGame.Example.Monster.Monster.GetRootAsMonster(buf, off)
+ monster1 = MyGame.Example.Monster.Monster.GetRootAs(buf, off)
monsterT1 = MyGame.Example.Monster.MonsterT.InitFromObj(monster1)
for sizePrefix in [True, False]:
CheckReadBuffer(b1.Bytes, b1.Head(), sizePrefix)
# Deserializes the buffer into Python object again.
- monster2 = MyGame.Example.Monster.Monster.GetRootAsMonster(b1.Bytes,
+ monster2 = MyGame.Example.Monster.Monster.GetRootAs(b1.Bytes,
b1.Head())
# Re-serializes the data into a buffer for one more time.
monsterT2 = MyGame.Example.Monster.MonsterT.InitFromObj(monster2)
object. '''
# Creates a flatbuffer with default values.
b1 = flatbuffers.Builder(0)
- MyGame.Example.Monster.MonsterStart(b1)
- gen_mon = MyGame.Example.Monster.MonsterEnd(b1)
+ MyGame.Example.Monster.Start(b1)
+ gen_mon = MyGame.Example.Monster.End(b1)
b1.Finish(gen_mon)
# Converts the flatbuffer into the object class.
- monster1 = MyGame.Example.Monster.Monster.GetRootAsMonster(b1.Bytes,
+ monster1 = MyGame.Example.Monster.Monster.GetRootAs(b1.Bytes,
b1.Head())
monsterT1 = MyGame.Example.Monster.MonsterT.InitFromObj(monster1)
# Packs the object class into another flatbuffer.
b2 = flatbuffers.Builder(0)
b2.Finish(monsterT1.Pack(b2))
- monster2 = MyGame.Example.Monster.Monster.GetRootAsMonster(b2.Bytes,
+ monster2 = MyGame.Example.Monster.Monster.GetRootAs(b2.Bytes,
b2.Head())
# Checks the default values.
self.assertTrue(monster2.Pos() is None)
# Creates an empty monster flatbuffer, and loads it into the object
# class for future tests.
b = flatbuffers.Builder(0)
- MyGame.Example.Monster.MonsterStart(b)
+ MyGame.Example.Monster.Start(b)
self.monsterT = self._create_and_load_object_class(b)
def _pack_and_load_buf_class(self, monsterT):
class.'''
b = flatbuffers.Builder(0)
b.Finish(monsterT.Pack(b))
- monster = MyGame.Example.Monster.Monster.GetRootAsMonster(b.Bytes,
+ monster = MyGame.Example.Monster.Monster.GetRootAs(b.Bytes,
b.Head())
return monster
def _create_and_load_object_class(self, b):
''' Finishs the creation of a monster flatbuffer and loads it into an
object class.'''
- gen_mon = MyGame.Example.Monster.MonsterEnd(b)
+ gen_mon = MyGame.Example.Monster.End(b)
b.Finish(gen_mon)
- monster = MyGame.Example.Monster.Monster.GetRootAsMonster(b.Bytes,
+ monster = MyGame.Example.Monster.Monster.GetRootAs(b.Bytes,
b.Head())
monsterT = MyGame.Example.Monster.MonsterT()
monsterT.InitFromObj(monster)
asserter(MyGame.Example.Monster.Monster.MonsterBufferHasIdentifier(buf, offset))
else:
asserter(not MyGame.Example.Monster.Monster.MonsterBufferHasIdentifier(buf, offset))
- monster = MyGame.Example.Monster.Monster.GetRootAsMonster(buf, offset)
+ monster = MyGame.Example.Monster.Monster.GetRootAs(buf, offset)
asserter(monster.Hp() == 80)
asserter(monster.Mana() == 150)
test2 = b.CreateString("test2")
fred = b.CreateString("Fred")
- MyGame.Example.Monster.MonsterStartInventoryVector(b, 5)
+ MyGame.Example.Monster.StartInventoryVector(b, 5)
b.PrependByte(4)
b.PrependByte(3)
b.PrependByte(2)
b.PrependByte(0)
inv = b.EndVector()
- MyGame.Example.Monster.MonsterStart(b)
- MyGame.Example.Monster.MonsterAddName(b, fred)
- mon2 = MyGame.Example.Monster.MonsterEnd(b)
+ MyGame.Example.Monster.Start(b)
+ MyGame.Example.Monster.AddName(b, fred)
+ mon2 = MyGame.Example.Monster.End(b)
- MyGame.Example.Monster.MonsterStartTest4Vector(b, 2)
+ MyGame.Example.Monster.StartTest4Vector(b, 2)
MyGame.Example.Test.CreateTest(b, 10, 20)
MyGame.Example.Test.CreateTest(b, 30, 40)
test4 = b.EndVector()
- MyGame.Example.Monster.MonsterStartTestarrayofstringVector(b, 2)
+ MyGame.Example.Monster.StartTestarrayofstringVector(b, 2)
b.PrependUOffsetTRelative(test2)
b.PrependUOffsetTRelative(test1)
testArrayOfString = b.EndVector()
- MyGame.Example.Monster.MonsterStartVectorOfLongsVector(b, 5)
+ MyGame.Example.Monster.StartVectorOfLongsVector(b, 5)
b.PrependInt64(100000000)
b.PrependInt64(1000000)
b.PrependInt64(10000)
b.PrependInt64(1)
VectorOfLongs = b.EndVector()
- MyGame.Example.Monster.MonsterStartVectorOfDoublesVector(b, 3)
+ MyGame.Example.Monster.StartVectorOfDoublesVector(b, 3)
b.PrependFloat64(1.7976931348623157e+308)
b.PrependFloat64(0)
b.PrependFloat64(-1.7976931348623157e+308)
VectorOfDoubles = b.EndVector()
- MyGame.Example.Monster.MonsterStart(b)
+ MyGame.Example.Monster.Start(b)
pos = MyGame.Example.Vec3.CreateVec3(b, 1.0, 2.0, 3.0, 3.0, 2, 5, 6)
- MyGame.Example.Monster.MonsterAddPos(b, pos)
-
- MyGame.Example.Monster.MonsterAddHp(b, 80)
- MyGame.Example.Monster.MonsterAddName(b, string)
- MyGame.Example.Monster.MonsterAddInventory(b, inv)
- MyGame.Example.Monster.MonsterAddTestType(b, 1)
- MyGame.Example.Monster.MonsterAddTest(b, mon2)
- MyGame.Example.Monster.MonsterAddTest4(b, test4)
- MyGame.Example.Monster.MonsterAddTestarrayofstring(b, testArrayOfString)
- MyGame.Example.Monster.MonsterAddVectorOfLongs(b, VectorOfLongs)
- MyGame.Example.Monster.MonsterAddVectorOfDoubles(b, VectorOfDoubles)
- mon = MyGame.Example.Monster.MonsterEnd(b)
+ MyGame.Example.Monster.AddPos(b, pos)
+
+ MyGame.Example.Monster.AddHp(b, 80)
+ MyGame.Example.Monster.AddName(b, string)
+ MyGame.Example.Monster.AddInventory(b, inv)
+ MyGame.Example.Monster.AddTestType(b, 1)
+ MyGame.Example.Monster.AddTest(b, mon2)
+ MyGame.Example.Monster.AddTest4(b, test4)
+ MyGame.Example.Monster.AddTestarrayofstring(b, testArrayOfString)
+ MyGame.Example.Monster.AddVectorOfLongs(b, VectorOfLongs)
+ MyGame.Example.Monster.AddVectorOfDoubles(b, VectorOfDoubles)
+ mon = MyGame.Example.Monster.End(b)
if sizePrefix:
b.FinishSizePrefixed(mon, file_identifier)
super(TestAllCodePathsOfExampleSchema, self).setUp(*args, **kwargs)
b = flatbuffers.Builder(0)
- MyGame.Example.Monster.MonsterStart(b)
- gen_mon = MyGame.Example.Monster.MonsterEnd(b)
+ MyGame.Example.Monster.Start(b)
+ gen_mon = MyGame.Example.Monster.End(b)
b.Finish(gen_mon)
- self.mon = MyGame.Example.Monster.Monster.GetRootAsMonster(b.Bytes,
+ self.mon = MyGame.Example.Monster.Monster.GetRootAs(b.Bytes,
b.Head())
def test_default_monster_pos(self):
def test_nondefault_monster_mana(self):
b = flatbuffers.Builder(0)
- MyGame.Example.Monster.MonsterStart(b)
- MyGame.Example.Monster.MonsterAddMana(b, 50)
- mon = MyGame.Example.Monster.MonsterEnd(b)
+ MyGame.Example.Monster.Start(b)
+ MyGame.Example.Monster.AddMana(b, 50)
+ mon = MyGame.Example.Monster.End(b)
b.Finish(mon)
- got_mon = MyGame.Example.Monster.Monster.GetRootAsMonster(b.Bytes,
+ got_mon = MyGame.Example.Monster.Monster.GetRootAs(b.Bytes,
b.Head())
self.assertEqual(50, got_mon.Mana())
def test_empty_monster_inventory_vector(self):
b = flatbuffers.Builder(0)
- MyGame.Example.Monster.MonsterStartInventoryVector(b, 0)
+ MyGame.Example.Monster.StartInventoryVector(b, 0)
inv = b.EndVector()
- MyGame.Example.Monster.MonsterStart(b)
- MyGame.Example.Monster.MonsterAddInventory(b, inv)
- mon = MyGame.Example.Monster.MonsterEnd(b)
+ MyGame.Example.Monster.Start(b)
+ MyGame.Example.Monster.AddInventory(b, inv)
+ mon = MyGame.Example.Monster.End(b)
b.Finish(mon)
- mon2 = MyGame.Example.Monster.Monster.GetRootAsMonster(b.Bytes,
+ mon2 = MyGame.Example.Monster.Monster.GetRootAs(b.Bytes,
b.Head())
self.assertFalse(mon2.InventoryIsNone())
def test_nondefault_monster_color(self):
b = flatbuffers.Builder(0)
color = MyGame.Example.Color.Color.Red
- MyGame.Example.Monster.MonsterStart(b)
- MyGame.Example.Monster.MonsterAddColor(b, color)
- mon = MyGame.Example.Monster.MonsterEnd(b)
+ MyGame.Example.Monster.Start(b)
+ MyGame.Example.Monster.AddColor(b, color)
+ mon = MyGame.Example.Monster.End(b)
b.Finish(mon)
- mon2 = MyGame.Example.Monster.Monster.GetRootAsMonster(b.Bytes,
+ mon2 = MyGame.Example.Monster.Monster.GetRootAs(b.Bytes,
b.Head())
self.assertEqual(MyGame.Example.Color.Color.Red, mon2.Color())
def test_empty_monster_test4_vector(self):
b = flatbuffers.Builder(0)
- MyGame.Example.Monster.MonsterStartTest4Vector(b, 0)
+ MyGame.Example.Monster.StartTest4Vector(b, 0)
test4 = b.EndVector()
- MyGame.Example.Monster.MonsterStart(b)
- MyGame.Example.Monster.MonsterAddTest4(b, test4)
- mon = MyGame.Example.Monster.MonsterEnd(b)
+ MyGame.Example.Monster.Start(b)
+ MyGame.Example.Monster.AddTest4(b, test4)
+ mon = MyGame.Example.Monster.End(b)
b.Finish(mon)
- mon2 = MyGame.Example.Monster.Monster.GetRootAsMonster(b.Bytes,
+ mon2 = MyGame.Example.Monster.Monster.GetRootAs(b.Bytes,
b.Head())
self.assertFalse(mon2.Test4IsNone())
def test_empty_monster_testarrayofstring_vector(self):
b = flatbuffers.Builder(0)
- MyGame.Example.Monster.MonsterStartTestarrayofstringVector(b, 0)
+ MyGame.Example.Monster.StartTestarrayofstringVector(b, 0)
testarrayofstring = b.EndVector()
- MyGame.Example.Monster.MonsterStart(b)
- MyGame.Example.Monster.MonsterAddTestarrayofstring(b, testarrayofstring)
- mon = MyGame.Example.Monster.MonsterEnd(b)
+ MyGame.Example.Monster.Start(b)
+ MyGame.Example.Monster.AddTestarrayofstring(b, testarrayofstring)
+ mon = MyGame.Example.Monster.End(b)
b.Finish(mon)
- mon2 = MyGame.Example.Monster.Monster.GetRootAsMonster(b.Bytes,
+ mon2 = MyGame.Example.Monster.Monster.GetRootAs(b.Bytes,
b.Head())
self.assertFalse(mon2.TestarrayofstringIsNone())
b = flatbuffers.Builder(0)
# make a child Monster within a vector of Monsters:
- MyGame.Example.Monster.MonsterStart(b)
- MyGame.Example.Monster.MonsterAddHp(b, 99)
- sub_monster = MyGame.Example.Monster.MonsterEnd(b)
+ MyGame.Example.Monster.Start(b)
+ MyGame.Example.Monster.AddHp(b, 99)
+ sub_monster = MyGame.Example.Monster.End(b)
# build the vector:
- MyGame.Example.Monster.MonsterStartTestarrayoftablesVector(b, 1)
+ MyGame.Example.Monster.StartTestarrayoftablesVector(b, 1)
b.PrependUOffsetTRelative(sub_monster)
vec = b.EndVector()
# make the parent monster and include the vector of Monster:
- MyGame.Example.Monster.MonsterStart(b)
- MyGame.Example.Monster.MonsterAddTestarrayoftables(b, vec)
- mon = MyGame.Example.Monster.MonsterEnd(b)
+ MyGame.Example.Monster.Start(b)
+ MyGame.Example.Monster.AddTestarrayoftables(b, vec)
+ mon = MyGame.Example.Monster.End(b)
b.Finish(mon)
# inspect the resulting data:
- mon2 = MyGame.Example.Monster.Monster.GetRootAsMonster(b.Output(), 0)
+ mon2 = MyGame.Example.Monster.Monster.GetRootAs(b.Output(), 0)
self.assertEqual(99, mon2.Testarrayoftables(0).Hp())
self.assertEqual(1, mon2.TestarrayoftablesLength())
self.assertFalse(mon2.TestarrayoftablesIsNone())
def test_empty_monster_testarrayoftables_vector(self):
b = flatbuffers.Builder(0)
- MyGame.Example.Monster.MonsterStartTestarrayoftablesVector(b, 0)
+ MyGame.Example.Monster.StartTestarrayoftablesVector(b, 0)
testarrayoftables = b.EndVector()
- MyGame.Example.Monster.MonsterStart(b)
- MyGame.Example.Monster.MonsterAddTestarrayoftables(b, testarrayoftables)
- mon = MyGame.Example.Monster.MonsterEnd(b)
+ MyGame.Example.Monster.Start(b)
+ MyGame.Example.Monster.AddTestarrayoftables(b, testarrayoftables)
+ mon = MyGame.Example.Monster.End(b)
b.Finish(mon)
- mon2 = MyGame.Example.Monster.Monster.GetRootAsMonster(b.Bytes,
+ mon2 = MyGame.Example.Monster.Monster.GetRootAs(b.Bytes,
b.Head())
self.assertFalse(mon2.TestarrayoftablesIsNone())
b = flatbuffers.Builder(0)
# make an Enemy object:
- MyGame.Example.Monster.MonsterStart(b)
- MyGame.Example.Monster.MonsterAddHp(b, 88)
- enemy = MyGame.Example.Monster.MonsterEnd(b)
+ MyGame.Example.Monster.Start(b)
+ MyGame.Example.Monster.AddHp(b, 88)
+ enemy = MyGame.Example.Monster.End(b)
b.Finish(enemy)
# make the parent monster and include the vector of Monster:
- MyGame.Example.Monster.MonsterStart(b)
- MyGame.Example.Monster.MonsterAddEnemy(b, enemy)
- mon = MyGame.Example.Monster.MonsterEnd(b)
+ MyGame.Example.Monster.Start(b)
+ MyGame.Example.Monster.AddEnemy(b, enemy)
+ mon = MyGame.Example.Monster.End(b)
b.Finish(mon)
# inspect the resulting data:
- mon2 = MyGame.Example.Monster.Monster.GetRootAsMonster(b.Bytes,
+ mon2 = MyGame.Example.Monster.Monster.GetRootAs(b.Bytes,
b.Head())
self.assertEqual(88, mon2.Enemy().Hp())
def test_empty_monster_testnestedflatbuffer_vector(self):
b = flatbuffers.Builder(0)
- MyGame.Example.Monster.MonsterStartTestnestedflatbufferVector(b, 0)
+ MyGame.Example.Monster.StartTestnestedflatbufferVector(b, 0)
testnestedflatbuffer = b.EndVector()
- MyGame.Example.Monster.MonsterStart(b)
- MyGame.Example.Monster.MonsterAddTestnestedflatbuffer(b, testnestedflatbuffer)
- mon = MyGame.Example.Monster.MonsterEnd(b)
+ MyGame.Example.Monster.Start(b)
+ MyGame.Example.Monster.AddTestnestedflatbuffer(b, testnestedflatbuffer)
+ mon = MyGame.Example.Monster.End(b)
b.Finish(mon)
- mon2 = MyGame.Example.Monster.Monster.GetRootAsMonster(b.Bytes,
+ mon2 = MyGame.Example.Monster.Monster.GetRootAs(b.Bytes,
b.Head())
self.assertFalse(mon2.TestnestedflatbufferIsNone())
def test_nondefault_monster_testnestedflatbuffer(self):
b = flatbuffers.Builder(0)
- MyGame.Example.Monster.MonsterStartTestnestedflatbufferVector(b, 3)
+ MyGame.Example.Monster.StartTestnestedflatbufferVector(b, 3)
b.PrependByte(4)
b.PrependByte(2)
b.PrependByte(0)
sub_buf = b.EndVector()
# make the parent monster and include the vector of Monster:
- MyGame.Example.Monster.MonsterStart(b)
- MyGame.Example.Monster.MonsterAddTestnestedflatbuffer(b, sub_buf)
- mon = MyGame.Example.Monster.MonsterEnd(b)
+ MyGame.Example.Monster.Start(b)
+ MyGame.Example.Monster.AddTestnestedflatbuffer(b, sub_buf)
+ mon = MyGame.Example.Monster.End(b)
b.Finish(mon)
# inspect the resulting data:
- mon2 = MyGame.Example.Monster.Monster.GetRootAsMonster(b.Bytes,
+ mon2 = MyGame.Example.Monster.Monster.GetRootAs(b.Bytes,
b.Head())
self.assertEqual(3, mon2.TestnestedflatbufferLength())
self.assertFalse(mon2.TestnestedflatbufferIsNone())
# build another monster to nest inside testnestedflatbuffer
nestedB = flatbuffers.Builder(0)
nameStr = nestedB.CreateString("Nested Monster")
- MyGame.Example.Monster.MonsterStart(nestedB)
- MyGame.Example.Monster.MonsterAddHp(nestedB, 30)
- MyGame.Example.Monster.MonsterAddName(nestedB, nameStr)
- nestedMon = MyGame.Example.Monster.MonsterEnd(nestedB)
+ MyGame.Example.Monster.Start(nestedB)
+ MyGame.Example.Monster.AddHp(nestedB, 30)
+ MyGame.Example.Monster.AddName(nestedB, nameStr)
+ nestedMon = MyGame.Example.Monster.End(nestedB)
nestedB.Finish(nestedMon)
# write the nested FB bytes
- sub_buf = MyGame.Example.Monster.MonsterMakeTestnestedflatbufferVectorFromBytes(
+ sub_buf = MyGame.Example.Monster.MakeTestnestedflatbufferVectorFromBytes(
b, nestedB.Output())
# make the parent monster and include the bytes of the nested monster
- MyGame.Example.Monster.MonsterStart(b)
- MyGame.Example.Monster.MonsterAddTestnestedflatbuffer(b, sub_buf)
- mon = MyGame.Example.Monster.MonsterEnd(b)
+ MyGame.Example.Monster.Start(b)
+ MyGame.Example.Monster.AddTestnestedflatbuffer(b, sub_buf)
+ mon = MyGame.Example.Monster.End(b)
b.Finish(mon)
# inspect the resulting data:
- mon2 = MyGame.Example.Monster.Monster.GetRootAsMonster(b.Bytes,
+ mon2 = MyGame.Example.Monster.Monster.GetRootAs(b.Bytes,
b.Head())
nestedMon2 = mon2.TestnestedflatbufferNestedRoot()
self.assertEqual(b"Nested Monster", nestedMon2.Name())
b = flatbuffers.Builder(0)
# make a Stat object:
- MyGame.Example.Stat.StatStart(b)
- MyGame.Example.Stat.StatAddVal(b, 123)
- my_stat = MyGame.Example.Stat.StatEnd(b)
+ MyGame.Example.Stat.Start(b)
+ MyGame.Example.Stat.AddVal(b, 123)
+ my_stat = MyGame.Example.Stat.End(b)
b.Finish(my_stat)
# include the stat object in a monster:
- MyGame.Example.Monster.MonsterStart(b)
- MyGame.Example.Monster.MonsterAddTestempty(b, my_stat)
- mon = MyGame.Example.Monster.MonsterEnd(b)
+ MyGame.Example.Monster.Start(b)
+ MyGame.Example.Monster.AddTestempty(b, my_stat)
+ mon = MyGame.Example.Monster.End(b)
b.Finish(mon)
# inspect the resulting data:
- mon2 = MyGame.Example.Monster.Monster.GetRootAsMonster(b.Bytes,
+ mon2 = MyGame.Example.Monster.Monster.GetRootAs(b.Bytes,
b.Head())
self.assertEqual(123, mon2.Testempty().Val())
def test_nondefault_monster_testbool(self):
b = flatbuffers.Builder(0)
- MyGame.Example.Monster.MonsterStart(b)
- MyGame.Example.Monster.MonsterAddTestbool(b, True)
- mon = MyGame.Example.Monster.MonsterEnd(b)
+ MyGame.Example.Monster.Start(b)
+ MyGame.Example.Monster.AddTestbool(b, True)
+ mon = MyGame.Example.Monster.End(b)
b.Finish(mon)
# inspect the resulting data:
- mon2 = MyGame.Example.Monster.Monster.GetRootAsMonster(b.Bytes,
+ mon2 = MyGame.Example.Monster.Monster.GetRootAs(b.Bytes,
b.Head())
self.assertTrue(mon2.Testbool())
def test_nondefault_monster_testhashes(self):
b = flatbuffers.Builder(0)
- MyGame.Example.Monster.MonsterStart(b)
- MyGame.Example.Monster.MonsterAddTesthashs32Fnv1(b, 1)
- MyGame.Example.Monster.MonsterAddTesthashu32Fnv1(b, 2)
- MyGame.Example.Monster.MonsterAddTesthashs64Fnv1(b, 3)
- MyGame.Example.Monster.MonsterAddTesthashu64Fnv1(b, 4)
- MyGame.Example.Monster.MonsterAddTesthashs32Fnv1a(b, 5)
- MyGame.Example.Monster.MonsterAddTesthashu32Fnv1a(b, 6)
- MyGame.Example.Monster.MonsterAddTesthashs64Fnv1a(b, 7)
- MyGame.Example.Monster.MonsterAddTesthashu64Fnv1a(b, 8)
- mon = MyGame.Example.Monster.MonsterEnd(b)
+ MyGame.Example.Monster.Start(b)
+ MyGame.Example.Monster.AddTesthashs32Fnv1(b, 1)
+ MyGame.Example.Monster.AddTesthashu32Fnv1(b, 2)
+ MyGame.Example.Monster.AddTesthashs64Fnv1(b, 3)
+ MyGame.Example.Monster.AddTesthashu64Fnv1(b, 4)
+ MyGame.Example.Monster.AddTesthashs32Fnv1a(b, 5)
+ MyGame.Example.Monster.AddTesthashu32Fnv1a(b, 6)
+ MyGame.Example.Monster.AddTesthashs64Fnv1a(b, 7)
+ MyGame.Example.Monster.AddTesthashu64Fnv1a(b, 8)
+ mon = MyGame.Example.Monster.End(b)
b.Finish(mon)
# inspect the resulting data:
- mon2 = MyGame.Example.Monster.Monster.GetRootAsMonster(b.Bytes,
+ mon2 = MyGame.Example.Monster.Monster.GetRootAs(b.Bytes,
b.Head())
self.assertEqual(1, mon2.Testhashs32Fnv1())
self.assertEqual(2, mon2.Testhashu32Fnv1())
def test_nondefault_monster_parent_namespace_test(self):
b = flatbuffers.Builder(0)
- MyGame.InParentNamespace.InParentNamespaceStart(b)
- parent = MyGame.InParentNamespace.InParentNamespaceEnd(b)
- MyGame.Example.Monster.MonsterStart(b)
- MyGame.Example.Monster.MonsterAddParentNamespaceTest(b, parent)
- mon = MyGame.Example.Monster.MonsterEnd(b)
+ MyGame.InParentNamespace.Start(b)
+ parent = MyGame.InParentNamespace.End(b)
+ MyGame.Example.Monster.Start(b)
+ MyGame.Example.Monster.AddParentNamespaceTest(b, parent)
+ mon = MyGame.Example.Monster.End(b)
b.Finish(mon)
# Inspect the resulting data.
- monster = MyGame.Example.Monster.Monster.GetRootAsMonster(b.Bytes,
+ monster = MyGame.Example.Monster.Monster.GetRootAs(b.Bytes,
b.Head())
self.assertTrue(isinstance(monster.ParentNamespaceTest(),
MyGame.InParentNamespace.InParentNamespace))
b = flatbuffers.Builder(0)
string = b.CreateString("MyStat")
- MyGame.Example.Stat.StatStart(b)
- MyGame.Example.Stat.StatAddId(b, string)
- MyGame.Example.Stat.StatAddVal(b, 12345678)
- MyGame.Example.Stat.StatAddCount(b, 12345)
- stat = MyGame.Example.Stat.StatEnd(b)
+ MyGame.Example.Stat.Start(b)
+ MyGame.Example.Stat.AddId(b, string)
+ MyGame.Example.Stat.AddVal(b, 12345678)
+ MyGame.Example.Stat.AddCount(b, 12345)
+ stat = MyGame.Example.Stat.End(b)
b.Finish(stat)
- stat2 = MyGame.Example.Stat.Stat.GetRootAsStat(b.Bytes, b.Head())
+ stat2 = MyGame.Example.Stat.Stat.GetRootAs(b.Bytes, b.Head())
self.assertEqual(b"MyStat", stat2.Id())
self.assertEqual(12345678, stat2.Val())
super(TestAllCodePathsOfMonsterExtraSchema, self).setUp(*args, **kwargs)
b = flatbuffers.Builder(0)
- MyGame.MonsterExtra.MonsterExtraStart(b)
- gen_mon = MyGame.MonsterExtra.MonsterExtraEnd(b)
+ MyGame.MonsterExtra.Start(b)
+ gen_mon = MyGame.MonsterExtra.End(b)
b.Finish(gen_mon)
- self.mon = MyGame.MonsterExtra.MonsterExtra.GetRootAsMonsterExtra(b.Bytes, b.Head())
+ self.mon = MyGame.MonsterExtra.MonsterExtra.GetRootAs(b.Bytes, b.Head())
def test_default_nan_inf(self):
self.assertTrue(math.isnan(self.mon.F1()))
a, b, c, d_a, d_b, d_c, d_d, e, f)
# Create a table with the ArrayStruct.
- MyGame.Example.ArrayTable.ArrayTableStart(builder)
- MyGame.Example.ArrayTable.ArrayTableAddA(builder, arrayOffset)
- tableOffset = MyGame.Example.ArrayTable.ArrayTableEnd(builder)
+ MyGame.Example.ArrayTable.Start(builder)
+ MyGame.Example.ArrayTable.AddA(builder, arrayOffset)
+ tableOffset = MyGame.Example.ArrayTable.End(builder)
builder.Finish(tableOffset)
buf = builder.Output()
- table = MyGame.Example.ArrayTable.ArrayTable.GetRootAsArrayTable(buf, 0)
+ table = MyGame.Example.ArrayTable.ArrayTable.GetRootAs(buf)
# Verify structure.
nested = MyGame.Example.NestedStruct.NestedStruct()
projects / platform / upstream / flatbuffers.git / commitdiff