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

Keep methods with struct name and switch them to default (#6879)

Browse Source 
* Keep methods with struct name and switch them to default

This PR can help fix the following two issues:
1): A set of simplified API (without struct name) was added in
https://github.com/google/flatbuffers/pull/6336. It causes name
conflict when merging all generated python file into a single one
(the primary usage senario in Google).
2): Flatbuffers 2.0 generates absolute import path, which may cause
name space conflicts. See more details in
https://github.com/google/flatbuffers/issues/5840.

The solution for both is to generate the merged Python code, similar
C++. The merged code will not contain the simplied API, but only the
method with struct name. For issue (1), it will mimic the exactly
usage pattern for Google internal. For issue (2), users can generate
the merged flatbuffer code, without worrying about the imports.

The above idea will be implemented in the following steps:
Step 1 (this PR): revert changes in https://github.com/google/flatbuffers/pull/6336
that set the simplified API as default. Remove statements that the
original API will be deprecated, and reset the original API as default.
Step 2 (the following PR): create a flag to generate the merged code.
The Simplified API will be removed from the merged code, otherwise it
will cause name conflict.

* Update the generated sample code

* Update the generated example code

* Reverst the changes of GetRootAs

* Update examples from grpc/example/generate.sh
This commit is contained in:
lu-wang-g
2021-11-04 15:12:25 -07:00
committed by GitHub
parent f8b69e3308
commit fd4ff23da0
16 changed files with 730 additions and 822 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
grpc/examples/python/greeter/models/HelloReply.py
View File

@@ -31,15 +31,12 @@ class HelloReply(object):
return self._tab.String(o + self._tab.Pos)
return None
def Start(builder): builder.StartObject(1)
def HelloReplyStart(builder):
"""This method is deprecated. Please switch to Start."""
return Start(builder)
def AddMessage(builder, message): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(message), 0)
def HelloReplyAddMessage(builder, message):
"""This method is deprecated. Please switch to AddMessage."""
return AddMessage(builder, message)
def End(builder): return builder.EndObject()
def HelloReplyEnd(builder):
"""This method is deprecated. Please switch to End."""
return End(builder)
def HelloReplyStart(builder): builder.StartObject(1)
def Start(builder):
return HelloReplyStart(builder)
def HelloReplyAddMessage(builder, message): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(message), 0)
def AddMessage(builder, message):
return HelloReplyAddMessage(builder, message)
def HelloReplyEnd(builder): return builder.EndObject()
def End(builder):
return HelloReplyEnd(builder)

21
grpc/examples/python/greeter/models/HelloRequest.py
View File

@@ -31,15 +31,12 @@ class HelloRequest(object):
return self._tab.String(o + self._tab.Pos)
return None
def Start(builder): builder.StartObject(1)
def HelloRequestStart(builder):
"""This method is deprecated. Please switch to Start."""
return Start(builder)
def AddName(builder, name): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
def HelloRequestAddName(builder, name):
"""This method is deprecated. Please switch to AddName."""
return AddName(builder, name)
def End(builder): return builder.EndObject()
def HelloRequestEnd(builder):
"""This method is deprecated. Please switch to End."""
return End(builder)
def HelloRequestStart(builder): builder.StartObject(1)
def Start(builder):
return HelloRequestStart(builder)
def HelloRequestAddName(builder, name): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
def AddName(builder, name):
return HelloRequestAddName(builder, name)
def HelloRequestEnd(builder): return builder.EndObject()
def End(builder):
return HelloRequestEnd(builder)

259
src/idl_gen_python.cpp
View File

@@ -31,7 +31,7 @@ namespace flatbuffers {
namespace python {
// Hardcode spaces per indentation.
const CommentConfig def_comment = { nullptr, "#", nullptr };
const CommentConfig def_comment = {nullptr, "#", nullptr};
const std::string Indent = " ";
class PythonGenerator : public BaseGenerator {
@@ -42,12 +42,11 @@ class PythonGenerator : public BaseGenerator {
"" /* not used */, "py"),
float_const_gen_("float('nan')", "float('inf')", "float('-inf')") {
static const char *const keywords[] = {
"False", "None", "True", "and", "as", "assert", "break",
"class", "continue", "def", "del", "elif", "else", "except",
"finally", "for", "from", "global", "if", "import", "in",
"is", "lambda", "nonlocal", "not", "or", "pass", "raise",
"return", "try", "while", "with", "yield"
};
"False", "None", "True", "and", "as", "assert", "break",
"class", "continue", "def", "del", "elif", "else", "except",
"finally", "for", "from", "global", "if", "import", "in",
"is", "lambda", "nonlocal", "not", "or", "pass", "raise",
"return", "try", "while", "with", "yield"};
keywords_.insert(std::begin(keywords), std::end(keywords));
}
@@ -142,8 +141,8 @@ class PythonGenerator : public BaseGenerator {
code += NormalizedName(struct_def);
code += "(cls, buf, offset=0):\n";
code +=
Indent + Indent +
"\"\"\"This method is deprecated. Please switch to GetRootAs.\"\"\"\n";
Indent + Indent +
"\"\"\"This method is deprecated. Please switch to GetRootAs.\"\"\"\n";
code += Indent + Indent + "return cls.GetRootAs(buf, offset)\n";
}
@@ -207,7 +206,9 @@ class PythonGenerator : public BaseGenerator {
code += OffsetPrefix(field);
getter += "o + self._tab.Pos)";
auto is_bool = IsBool(field.value.type.base_type);
if (is_bool) { getter = "bool(" + getter + ")"; }
if (is_bool) {
getter = "bool(" + getter + ")";
}
code += Indent + Indent + Indent + "return " + getter + "\n";
std::string default_value;
if (is_bool) {
@@ -397,7 +398,9 @@ class PythonGenerator : public BaseGenerator {
// Currently, we only support accessing as numpy array if
// the vector type is a scalar.
if (!(IsScalar(vectortype.base_type))) { return; }
if (!(IsScalar(vectortype.base_type))) {
return;
}
GenReceiver(struct_def, code_ptr);
code += MakeCamel(NormalizedName(field)) + "AsNumpy(self):";
@@ -422,7 +425,9 @@ class PythonGenerator : public BaseGenerator {
const FieldDef &field,
std::string *code_ptr) {
auto nested = field.attributes.Lookup("nested_flatbuffer");
if (!nested) { return; } // There is no nested flatbuffer.
if (!nested) {
return;
} // There is no nested flatbuffer.
std::string unqualified_name = nested->constant;
std::string qualified_name = nested->constant;
@@ -444,7 +449,7 @@ class PythonGenerator : public BaseGenerator {
code += Indent + Indent + Indent;
code += "from " + qualified_name + " import " + unqualified_name + "\n";
code += Indent + Indent + Indent + "return " + unqualified_name;
code += ".GetRootAs";
code += ".GetRootAs" + unqualified_name;
code += "(self._tab.Bytes, self._tab.Vector(o))\n";
code += Indent + Indent + "return 0\n";
code += "\n";
@@ -485,7 +490,9 @@ class PythonGenerator : public BaseGenerator {
} else {
auto &code = *code_ptr;
code += std::string(", ") + nameprefix;
if (has_field_name) { code += MakeCamel(NormalizedName(field), false); }
if (has_field_name) {
code += MakeCamel(NormalizedName(field), false);
}
code += namesuffix;
}
}
@@ -555,23 +562,27 @@ class PythonGenerator : public BaseGenerator {
// 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 Start(builder): ";
// Generate method with struct name.
code += "def " + NormalizedName(struct_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";
// Generate method without struct name.
code += "def Start(builder):\n";
code +=
Indent + "return " + NormalizedName(struct_def) + "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 Add" + MakeCamel(NormalizedName(field));
// Generate method with struct name.
code += "def " + NormalizedName(struct_def) + "Add" +
MakeCamel(NormalizedName(field));
code += "(builder, ";
code += MakeCamel(NormalizedName(field), false);
code += "): ";
@@ -591,27 +602,25 @@ class PythonGenerator : public BaseGenerator {
: field.value.constant;
code += ")\n";
// Add alias with the old name.
code += "def " + NormalizedName(struct_def) + "Add" +
MakeCamel(NormalizedName(field));
// Generate method without struct name.
code += "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 += Indent + "return " + NormalizedName(struct_def) + "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 Start";
// Generate method with struct name.
code += "def " + NormalizedName(struct_def) + "Start";
code += MakeCamel(NormalizedName(field));
code += "Vector(builder, numElems): return builder.StartVector(";
auto vector_type = field.value.type.VectorType();
@@ -621,13 +630,11 @@ class PythonGenerator : public BaseGenerator {
code += ", numElems, " + NumToString(alignment);
code += ")\n";
// Add alias with the old name.
code += "def " + NormalizedName(struct_def) + "Start";
// Generate method without struct name.
code += "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 += Indent + "return " + NormalizedName(struct_def) + "Start";
code += MakeCamel(NormalizedName(field));
code += "Vector(builder, numElems)\n";
}
@@ -635,10 +642,13 @@ class PythonGenerator : public BaseGenerator {
// 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 FieldDef &field,
void BuildVectorOfTableFromBytes(const StructDef &struct_def,
const FieldDef &field,
std::string *code_ptr) {
auto nested = field.attributes.Lookup("nested_flatbuffer");
if (!nested) { return; } // There is no nested flatbuffer.
if (!nested) {
return;
} // There is no nested flatbuffer.
std::string unqualified_name = nested->constant;
std::string qualified_name = nested->constant;
@@ -652,7 +662,11 @@ class PythonGenerator : public BaseGenerator {
(void)nested_root;
auto &code = *code_ptr;
code += "def MakeVectorFromBytes(builder, bytes):\n";
// Generate method with struct and field name.
code += "def " + NormalizedName(struct_def) + "Make";
code += MakeCamel(NormalizedName(field));
code += "VectorFromBytes(builder, bytes):\n";
code += Indent + "builder.StartVector(";
auto vector_type = field.value.type.VectorType();
auto alignment = InlineAlignment(vector_type);
@@ -665,29 +679,26 @@ class PythonGenerator : public BaseGenerator {
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";
// Generate method without struct and field name.
code += "def Make" + MakeCamel(NormalizedName(field)) +
"VectorFromBytes(builder, bytes):\n";
code += Indent + "return " + NormalizedName(struct_def) + "Make" +
MakeCamel(NormalizedName(field)) +
"VectorFromBytes(builder, bytes)\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 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 method with struct name.
code += "def " + NormalizedName(struct_def) + "End";
code += "(builder): ";
code += "return builder.EndObject()\n";
// Generate method without struct name.
code += "def End(builder):\n";
code += Indent + "return " + NormalizedName(struct_def) + "End(builder)";
}
// Generate the receiver for function signatures.
@@ -732,8 +743,11 @@ class PythonGenerator : public BaseGenerator {
}
break;
}
case BASE_TYPE_UNION: GetUnionField(struct_def, field, code_ptr); break;
default: FLATBUFFERS_ASSERT(0);
case BASE_TYPE_UNION:
GetUnionField(struct_def, field, code_ptr);
break;
default:
FLATBUFFERS_ASSERT(0);
}
}
if (IsVector(field.value.type) || IsArray(field.value.type)) {
@@ -765,7 +779,7 @@ class PythonGenerator : public BaseGenerator {
BuildFieldOfTable(struct_def, field, offset, code_ptr);
if (IsVector(field.value.type)) {
BuildVectorOfTable(struct_def, field, code_ptr);
BuildVectorOfTableFromBytes(field, code_ptr);
BuildVectorOfTableFromBytes(struct_def, field, code_ptr);
}
}
@@ -904,9 +918,14 @@ class PythonGenerator : public BaseGenerator {
import_list->insert("import " + package_reference);
}
break;
case BASE_TYPE_STRING: field_type += "str"; break;
case BASE_TYPE_NONE: field_type += "None"; break;
default: break;
case BASE_TYPE_STRING:
field_type += "str";
break;
case BASE_TYPE_NONE:
field_type += "None";
break;
default:
break;
}
field_types += field_type + separator_string;
}
@@ -1239,7 +1258,8 @@ class PythonGenerator : public BaseGenerator {
GenUnPackForScalarVector(struct_def, field, &code);
break;
}
default: GenUnPackForScalar(struct_def, field, &code);
default:
GenUnPackForScalar(struct_def, field, &code);
}
}
@@ -1294,8 +1314,9 @@ class PythonGenerator : public BaseGenerator {
code_prefix +=
GenIndents(2) + "if self." + field_instance_name + " is not None:";
if (field.value.type.struct_def->fixed) {
code_prefix += GenIndents(3) + "Start" + field_accessor_name +
"Vector(builder, len(self." + field_instance_name + "))";
code_prefix += GenIndents(3) + struct_name + "Start" +
field_accessor_name + "Vector(builder, len(self." +
field_instance_name + "))";
code_prefix += GenIndents(3) + "for i in reversed(range(len(self." +
field_instance_name + "))):";
code_prefix +=
@@ -1311,8 +1332,9 @@ class PythonGenerator : public BaseGenerator {
code_prefix += GenIndents(4) + field_instance_name + "list.append(self." +
field_instance_name + "[i].Pack(builder))";
code_prefix += GenIndents(3) + "Start" + field_accessor_name +
"Vector(builder, len(self." + field_instance_name + "))";
code_prefix += GenIndents(3) + struct_name + "Start" +
field_accessor_name + "Vector(builder, len(self." +
field_instance_name + "))";
code_prefix += GenIndents(3) + "for i in reversed(range(len(self." +
field_instance_name + "))):";
code_prefix += GenIndents(4) + "builder.PrependUOffsetTRelative" + "(" +
@@ -1323,8 +1345,8 @@ class PythonGenerator : public BaseGenerator {
// Adds the field into the struct.
code += GenIndents(2) + "if self." + field_instance_name + " is not None:";
code += GenIndents(3) + "Add" + field_accessor_name + "(builder, " +
field_instance_name + ")";
code += GenIndents(3) + struct_name + "Add" + field_accessor_name +
"(builder, " + field_instance_name + ")";
}
void GenPackForScalarVectorFieldHelper(const StructDef &struct_def,
@@ -1336,7 +1358,7 @@ class PythonGenerator : public BaseGenerator {
auto struct_name = NormalizedName(struct_def);
auto vectortype = field.value.type.VectorType();
code += GenIndents(indents) + "Start" + field_accessor_name +
code += GenIndents(indents) + struct_name + "Start" + field_accessor_name +
"Vector(builder, len(self." + field_instance_name + "))";
code += GenIndents(indents) + "for i in reversed(range(len(self." +
field_instance_name + "))):";
@@ -1344,19 +1366,45 @@ class PythonGenerator : public BaseGenerator {
std::string type_name;
switch (vectortype.base_type) {
case BASE_TYPE_BOOL: type_name = "Bool"; break;
case BASE_TYPE_CHAR: type_name = "Byte"; break;
case BASE_TYPE_UCHAR: type_name = "Uint8"; break;
case BASE_TYPE_SHORT: type_name = "Int16"; break;
case BASE_TYPE_USHORT: type_name = "Uint16"; break;
case BASE_TYPE_INT: type_name = "Int32"; break;
case BASE_TYPE_UINT: type_name = "Uint32"; break;
case BASE_TYPE_LONG: type_name = "Int64"; break;
case BASE_TYPE_ULONG: type_name = "Uint64"; break;
case BASE_TYPE_FLOAT: type_name = "Float32"; break;
case BASE_TYPE_DOUBLE: type_name = "Float64"; break;
case BASE_TYPE_STRING: type_name = "UOffsetTRelative"; break;
default: type_name = "VOffsetT"; break;
case BASE_TYPE_BOOL:
type_name = "Bool";
break;
case BASE_TYPE_CHAR:
type_name = "Byte";
break;
case BASE_TYPE_UCHAR:
type_name = "Uint8";
break;
case BASE_TYPE_SHORT:
type_name = "Int16";
break;
case BASE_TYPE_USHORT:
type_name = "Uint16";
break;
case BASE_TYPE_INT:
type_name = "Int32";
break;
case BASE_TYPE_UINT:
type_name = "Uint32";
break;
case BASE_TYPE_LONG:
type_name = "Int64";
break;
case BASE_TYPE_ULONG:
type_name = "Uint64";
break;
case BASE_TYPE_FLOAT:
type_name = "Float32";
break;
case BASE_TYPE_DOUBLE:
type_name = "Float64";
break;
case BASE_TYPE_STRING:
type_name = "UOffsetTRelative";
break;
default:
type_name = "VOffsetT";
break;
}
code += type_name;
}
@@ -1373,8 +1421,8 @@ class PythonGenerator : public BaseGenerator {
// Adds the field into the struct.
code += GenIndents(2) + "if self." + field_instance_name + " is not None:";
code += GenIndents(3) + "Add" + field_accessor_name + "(builder, " +
field_instance_name + ")";
code += GenIndents(3) + struct_name + "Add" + field_accessor_name +
"(builder, " + field_instance_name + ")";
// Creates the field.
code_prefix +=
@@ -1436,8 +1484,8 @@ class PythonGenerator : public BaseGenerator {
GenIndents(2) + "if self." + field_instance_name + " is not None:";
}
code += GenIndents(3) + "Add" + field_accessor_name + "(builder, " +
field_instance_name + ")";
code += GenIndents(3) + struct_name + "Add" + field_accessor_name +
"(builder, " + field_instance_name + ")";
}
void GenPackForUnionField(const StructDef &struct_def, const FieldDef &field,
@@ -1456,8 +1504,8 @@ class PythonGenerator : public BaseGenerator {
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) + "Add" + field_accessor_name + "(builder, " +
field_instance_name + ")";
code += GenIndents(3) + struct_name + "Add" + field_accessor_name +
"(builder, " + field_instance_name + ")";
}
void GenPackForTable(const StructDef &struct_def, std::string *code_ptr) {
@@ -1468,7 +1516,7 @@ class PythonGenerator : public BaseGenerator {
GenReceiverForObjectAPI(struct_def, code_ptr);
code_base += "Pack(self, builder):";
code += GenIndents(2) + "Start(builder)";
code += GenIndents(2) + struct_name + "Start(builder)";
for (auto it = struct_def.fields.vec.begin();
it != struct_def.fields.vec.end(); ++it) {
auto &field = **it;
@@ -1507,21 +1555,22 @@ class PythonGenerator : public BaseGenerator {
")";
code += GenIndents(2) + "if self." + field_instance_name +
" is not None:";
code += GenIndents(3) + "Add" + field_accessor_name + "(builder, " +
field_instance_name + ")";
code += GenIndents(3) + struct_name + "Add" + field_accessor_name +
"(builder, " + field_instance_name + ")";
break;
}
default:
// 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) + "Add" + field_accessor_name +
code += GenIndents(2) + struct_name + "Add" + field_accessor_name +
"(builder, self." + field_instance_name + ")";
break;
}
}
code += GenIndents(2) + struct_instance_name + " = " + "End(builder)";
code += GenIndents(2) + struct_instance_name + " = " + struct_name +
"End(builder)";
code += GenIndents(2) + "return " + struct_instance_name;
code_base += code_prefix + code;
@@ -1616,7 +1665,8 @@ class PythonGenerator : public BaseGenerator {
case BASE_TYPE_STRING:
GenUnionCreatorForString(enum_def, ev, &code);
break;
default: break;
default:
break;
}
}
code += GenIndents(1) + "return None";
@@ -1640,9 +1690,12 @@ class PythonGenerator : public BaseGenerator {
// Returns the function name that is able to read a value of the given type.
std::string GenGetter(const Type &type) {
switch (type.base_type) {
case BASE_TYPE_STRING: return "self._tab.String(";
case BASE_TYPE_UNION: return "self._tab.Union(";
case BASE_TYPE_VECTOR: return GenGetter(type.VectorType());
case BASE_TYPE_STRING:
return "self._tab.String(";
case BASE_TYPE_UNION:
return "self._tab.Union(";
case BASE_TYPE_VECTOR:
return GenGetter(type.VectorType());
default:
return "self._tab.Get(flatbuffers.number_types." +
MakeCamel(GenTypeGet(type)) + "Flags, ";
@@ -1672,12 +1725,16 @@ class PythonGenerator : public BaseGenerator {
std::string GenTypePointer(const Type &type) {
switch (type.base_type) {
case BASE_TYPE_STRING: return "string";
case BASE_TYPE_VECTOR: return GenTypeGet(type.VectorType());
case BASE_TYPE_STRUCT: return type.struct_def->name;
case BASE_TYPE_STRING:
return "string";
case BASE_TYPE_VECTOR:
return GenTypeGet(type.VectorType());
case BASE_TYPE_STRUCT:
return type.struct_def->name;
case BASE_TYPE_UNION:
// fall through
default: return "*flatbuffers.Table";
default:
return "*flatbuffers.Table";
}
}

27
tests/MyGame/Example/ArrayTable.py
View File

@@ -39,18 +39,15 @@ class ArrayTable(object):
return obj
return None
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)
def ArrayTableStart(builder): builder.StartObject(1)
def Start(builder):
return ArrayTableStart(builder)
def ArrayTableAddA(builder, a): builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(a), 0)
def AddA(builder, a):
return ArrayTableAddA(builder, a)
def ArrayTableEnd(builder): return builder.EndObject()
def End(builder):
return ArrayTableEnd(builder)
import MyGame.Example.ArrayStruct
try:
from typing import Optional
@@ -84,9 +81,9 @@ class ArrayTableT(object):
# ArrayTableT
def Pack(self, builder):
Start(builder)
ArrayTableStart(builder)
if self.a is not None:
a = self.a.Pack(builder)
AddA(builder, a)
arrayTable = End(builder)
ArrayTableAddA(builder, a)
arrayTable = ArrayTableEnd(builder)
return arrayTable

666
tests/MyGame/Example/Monster.py
View File

@@ -214,7 +214,7 @@ class Monster(object):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
if o != 0:
from MyGame.Example.Monster import Monster
return Monster.GetRootAs(self._tab.Bytes, self._tab.Vector(o))
return Monster.GetRootAsMonster(self._tab.Bytes, self._tab.Vector(o))
return 0
# Monster
@@ -751,7 +751,7 @@ class Monster(object):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
if o != 0:
from MyGame.Example.Monster import Monster
return Monster.GetRootAs(self._tab.Bytes, self._tab.Vector(o))
return Monster.GetRootAsMonster(self._tab.Bytes, self._tab.Vector(o))
return 0
# Monster
@@ -791,314 +791,236 @@ class Monster(object):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(104))
return o == 0
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):
def MonsterStart(builder): builder.StartObject(51)
def Start(builder):
return MonsterStart(builder)
def MonsterAddPos(builder, pos): builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(pos), 0)
def AddPos(builder, pos):
return MonsterAddPos(builder, pos)
def MonsterAddMana(builder, mana): builder.PrependInt16Slot(1, mana, 150)
def AddMana(builder, mana):
return MonsterAddMana(builder, mana)
def MonsterAddHp(builder, hp): builder.PrependInt16Slot(2, hp, 100)
def AddHp(builder, hp):
return MonsterAddHp(builder, hp)
def MonsterAddName(builder, name): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
def AddName(builder, name):
return MonsterAddName(builder, name)
def MonsterAddInventory(builder, inventory): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(inventory), 0)
def AddInventory(builder, inventory):
return MonsterAddInventory(builder, inventory)
def MonsterStartInventoryVector(builder, numElems): return builder.StartVector(1, numElems, 1)
def StartInventoryVector(builder, numElems):
return MonsterStartInventoryVector(builder, numElems)
def MonsterAddColor(builder, color): builder.PrependUint8Slot(6, color, 8)
def AddColor(builder, color):
return MonsterAddColor(builder, color)
def MonsterAddTestType(builder, testType): builder.PrependUint8Slot(7, testType, 0)
def AddTestType(builder, testType):
return MonsterAddTestType(builder, testType)
def MonsterAddTest(builder, test): builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(test), 0)
def AddTest(builder, test):
return MonsterAddTest(builder, test)
def MonsterAddTest4(builder, test4): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(test4), 0)
def AddTest4(builder, test4):
return MonsterAddTest4(builder, test4)
def MonsterStartTest4Vector(builder, numElems): return builder.StartVector(4, numElems, 2)
def StartTest4Vector(builder, numElems):
return MonsterStartTest4Vector(builder, numElems)
def MonsterAddTestarrayofstring(builder, testarrayofstring): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring), 0)
def AddTestarrayofstring(builder, testarrayofstring):
return MonsterAddTestarrayofstring(builder, testarrayofstring)
def MonsterStartTestarrayofstringVector(builder, numElems): return builder.StartVector(4, numElems, 4)
def StartTestarrayofstringVector(builder, numElems):
return MonsterStartTestarrayofstringVector(builder, numElems)
def MonsterAddTestarrayoftables(builder, testarrayoftables): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayoftables), 0)
def AddTestarrayoftables(builder, testarrayoftables):
return MonsterAddTestarrayoftables(builder, testarrayoftables)
def MonsterStartTestarrayoftablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
def StartTestarrayoftablesVector(builder, numElems):
return MonsterStartTestarrayoftablesVector(builder, numElems)
def MonsterAddEnemy(builder, enemy): builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(enemy), 0)
def AddEnemy(builder, enemy):
return MonsterAddEnemy(builder, enemy)
def MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer): builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(testnestedflatbuffer), 0)
def AddTestnestedflatbuffer(builder, testnestedflatbuffer):
return MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer)
def MonsterStartTestnestedflatbufferVector(builder, numElems): return builder.StartVector(1, numElems, 1)
def StartTestnestedflatbufferVector(builder, numElems):
return MonsterStartTestnestedflatbufferVector(builder, numElems)
def MonsterMakeTestnestedflatbufferVectorFromBytes(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 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 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):
return MonsterMakeTestnestedflatbufferVectorFromBytes(builder, bytes)
def MonsterAddTestempty(builder, testempty): builder.PrependUOffsetTRelativeSlot(14, flatbuffers.number_types.UOffsetTFlags.py_type(testempty), 0)
def AddTestempty(builder, testempty):
return MonsterAddTestempty(builder, testempty)
def MonsterAddTestbool(builder, testbool): builder.PrependBoolSlot(15, testbool, 0)
def AddTestbool(builder, testbool):
return MonsterAddTestbool(builder, testbool)
def MonsterAddTesthashs32Fnv1(builder, testhashs32Fnv1): builder.PrependInt32Slot(16, testhashs32Fnv1, 0)
def AddTesthashs32Fnv1(builder, testhashs32Fnv1):
return MonsterAddTesthashs32Fnv1(builder, testhashs32Fnv1)
def MonsterAddTesthashu32Fnv1(builder, testhashu32Fnv1): builder.PrependUint32Slot(17, testhashu32Fnv1, 0)
def AddTesthashu32Fnv1(builder, testhashu32Fnv1):
return MonsterAddTesthashu32Fnv1(builder, testhashu32Fnv1)
def MonsterAddTesthashs64Fnv1(builder, testhashs64Fnv1): builder.PrependInt64Slot(18, testhashs64Fnv1, 0)
def AddTesthashs64Fnv1(builder, testhashs64Fnv1):
return MonsterAddTesthashs64Fnv1(builder, testhashs64Fnv1)
def MonsterAddTesthashu64Fnv1(builder, testhashu64Fnv1): builder.PrependUint64Slot(19, testhashu64Fnv1, 0)
def AddTesthashu64Fnv1(builder, testhashu64Fnv1):
return MonsterAddTesthashu64Fnv1(builder, testhashu64Fnv1)
def MonsterAddTesthashs32Fnv1a(builder, testhashs32Fnv1a): builder.PrependInt32Slot(20, testhashs32Fnv1a, 0)
def AddTesthashs32Fnv1a(builder, testhashs32Fnv1a):
return MonsterAddTesthashs32Fnv1a(builder, testhashs32Fnv1a)
def MonsterAddTesthashu32Fnv1a(builder, testhashu32Fnv1a): builder.PrependUint32Slot(21, testhashu32Fnv1a, 0)
def AddTesthashu32Fnv1a(builder, testhashu32Fnv1a):
return MonsterAddTesthashu32Fnv1a(builder, testhashu32Fnv1a)
def MonsterAddTesthashs64Fnv1a(builder, testhashs64Fnv1a): builder.PrependInt64Slot(22, testhashs64Fnv1a, 0)
def AddTesthashs64Fnv1a(builder, testhashs64Fnv1a):
return MonsterAddTesthashs64Fnv1a(builder, testhashs64Fnv1a)
def MonsterAddTesthashu64Fnv1a(builder, testhashu64Fnv1a): builder.PrependUint64Slot(23, testhashu64Fnv1a, 0)
def AddTesthashu64Fnv1a(builder, testhashu64Fnv1a):
return MonsterAddTesthashu64Fnv1a(builder, testhashu64Fnv1a)
def MonsterAddTestarrayofbools(builder, testarrayofbools): builder.PrependUOffsetTRelativeSlot(24, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofbools), 0)
def AddTestarrayofbools(builder, testarrayofbools):
return MonsterAddTestarrayofbools(builder, testarrayofbools)
def MonsterStartTestarrayofboolsVector(builder, numElems): return builder.StartVector(1, numElems, 1)
def StartTestarrayofboolsVector(builder, numElems):
return MonsterStartTestarrayofboolsVector(builder, numElems)
def MonsterAddTestf(builder, testf): builder.PrependFloat32Slot(25, testf, 3.14159)
def AddTestf(builder, testf):
return MonsterAddTestf(builder, testf)
def MonsterAddTestf2(builder, testf2): builder.PrependFloat32Slot(26, testf2, 3.0)
def AddTestf2(builder, testf2):
return MonsterAddTestf2(builder, testf2)
def MonsterAddTestf3(builder, testf3): builder.PrependFloat32Slot(27, testf3, 0.0)
def AddTestf3(builder, testf3):
return MonsterAddTestf3(builder, testf3)
def MonsterAddTestarrayofstring2(builder, testarrayofstring2): builder.PrependUOffsetTRelativeSlot(28, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring2), 0)
def AddTestarrayofstring2(builder, testarrayofstring2):
return MonsterAddTestarrayofstring2(builder, testarrayofstring2)
def MonsterStartTestarrayofstring2Vector(builder, numElems): return builder.StartVector(4, numElems, 4)
def StartTestarrayofstring2Vector(builder, numElems):
return MonsterStartTestarrayofstring2Vector(builder, numElems)
def MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct): builder.PrependUOffsetTRelativeSlot(29, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofsortedstruct), 0)
def AddTestarrayofsortedstruct(builder, testarrayofsortedstruct):
return MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct)
def MonsterStartTestarrayofsortedstructVector(builder, numElems): return builder.StartVector(8, numElems, 4)
def StartTestarrayofsortedstructVector(builder, numElems):
return MonsterStartTestarrayofsortedstructVector(builder, numElems)
def MonsterAddFlex(builder, flex): builder.PrependUOffsetTRelativeSlot(30, flatbuffers.number_types.UOffsetTFlags.py_type(flex), 0)
def AddFlex(builder, flex):
return MonsterAddFlex(builder, flex)
def MonsterStartFlexVector(builder, numElems): return builder.StartVector(1, numElems, 1)
def StartFlexVector(builder, numElems):
return MonsterStartFlexVector(builder, numElems)
def MonsterAddTest5(builder, test5): builder.PrependUOffsetTRelativeSlot(31, flatbuffers.number_types.UOffsetTFlags.py_type(test5), 0)
def AddTest5(builder, test5):
return MonsterAddTest5(builder, test5)
def MonsterStartTest5Vector(builder, numElems): return builder.StartVector(4, numElems, 2)
def StartTest5Vector(builder, numElems):
return MonsterStartTest5Vector(builder, numElems)
def MonsterAddVectorOfLongs(builder, vectorOfLongs): builder.PrependUOffsetTRelativeSlot(32, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfLongs), 0)
def AddVectorOfLongs(builder, vectorOfLongs):
return MonsterAddVectorOfLongs(builder, vectorOfLongs)
def MonsterStartVectorOfLongsVector(builder, numElems): return builder.StartVector(8, numElems, 8)
def StartVectorOfLongsVector(builder, numElems):
return MonsterStartVectorOfLongsVector(builder, numElems)
def MonsterAddVectorOfDoubles(builder, vectorOfDoubles): builder.PrependUOffsetTRelativeSlot(33, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfDoubles), 0)
def AddVectorOfDoubles(builder, vectorOfDoubles):
return MonsterAddVectorOfDoubles(builder, vectorOfDoubles)
def MonsterStartVectorOfDoublesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
def StartVectorOfDoublesVector(builder, numElems):
return MonsterStartVectorOfDoublesVector(builder, numElems)
def MonsterAddParentNamespaceTest(builder, parentNamespaceTest): builder.PrependUOffsetTRelativeSlot(34, flatbuffers.number_types.UOffsetTFlags.py_type(parentNamespaceTest), 0)
def AddParentNamespaceTest(builder, parentNamespaceTest):
return MonsterAddParentNamespaceTest(builder, parentNamespaceTest)
def MonsterAddVectorOfReferrables(builder, vectorOfReferrables): builder.PrependUOffsetTRelativeSlot(35, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfReferrables), 0)
def AddVectorOfReferrables(builder, vectorOfReferrables):
return MonsterAddVectorOfReferrables(builder, vectorOfReferrables)
def MonsterStartVectorOfReferrablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
def StartVectorOfReferrablesVector(builder, numElems):
return MonsterStartVectorOfReferrablesVector(builder, numElems)
def MonsterAddSingleWeakReference(builder, singleWeakReference): builder.PrependUint64Slot(36, singleWeakReference, 0)
def AddSingleWeakReference(builder, singleWeakReference):
return MonsterAddSingleWeakReference(builder, singleWeakReference)
def MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences): builder.PrependUOffsetTRelativeSlot(37, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfWeakReferences), 0)
def AddVectorOfWeakReferences(builder, vectorOfWeakReferences):
return MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences)
def MonsterStartVectorOfWeakReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
def StartVectorOfWeakReferencesVector(builder, numElems):
return MonsterStartVectorOfWeakReferencesVector(builder, numElems)
def MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables): builder.PrependUOffsetTRelativeSlot(38, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfStrongReferrables), 0)
def AddVectorOfStrongReferrables(builder, vectorOfStrongReferrables):
return MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables)
def MonsterStartVectorOfStrongReferrablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
def StartVectorOfStrongReferrablesVector(builder, numElems):
return MonsterStartVectorOfStrongReferrablesVector(builder, numElems)
def MonsterAddCoOwningReference(builder, coOwningReference): builder.PrependUint64Slot(39, coOwningReference, 0)
def AddCoOwningReference(builder, coOwningReference):
return MonsterAddCoOwningReference(builder, coOwningReference)
def MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences): builder.PrependUOffsetTRelativeSlot(40, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfCoOwningReferences), 0)
def AddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences):
return MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences)
def MonsterStartVectorOfCoOwningReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
def StartVectorOfCoOwningReferencesVector(builder, numElems):
return MonsterStartVectorOfCoOwningReferencesVector(builder, numElems)
def MonsterAddNonOwningReference(builder, nonOwningReference): builder.PrependUint64Slot(41, nonOwningReference, 0)
def AddNonOwningReference(builder, nonOwningReference):
return MonsterAddNonOwningReference(builder, nonOwningReference)
def MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences): builder.PrependUOffsetTRelativeSlot(42, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfNonOwningReferences), 0)
def AddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences):
return MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences)
def MonsterStartVectorOfNonOwningReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
def StartVectorOfNonOwningReferencesVector(builder, numElems):
return MonsterStartVectorOfNonOwningReferencesVector(builder, numElems)
def MonsterAddAnyUniqueType(builder, anyUniqueType): builder.PrependUint8Slot(43, anyUniqueType, 0)
def AddAnyUniqueType(builder, anyUniqueType):
return MonsterAddAnyUniqueType(builder, anyUniqueType)
def MonsterAddAnyUnique(builder, anyUnique): builder.PrependUOffsetTRelativeSlot(44, flatbuffers.number_types.UOffsetTFlags.py_type(anyUnique), 0)
def AddAnyUnique(builder, anyUnique):
return MonsterAddAnyUnique(builder, anyUnique)
def MonsterAddAnyAmbiguousType(builder, anyAmbiguousType): builder.PrependUint8Slot(45, anyAmbiguousType, 0)
def AddAnyAmbiguousType(builder, anyAmbiguousType):
return MonsterAddAnyAmbiguousType(builder, anyAmbiguousType)
def MonsterAddAnyAmbiguous(builder, anyAmbiguous): builder.PrependUOffsetTRelativeSlot(46, flatbuffers.number_types.UOffsetTFlags.py_type(anyAmbiguous), 0)
def AddAnyAmbiguous(builder, anyAmbiguous):
return MonsterAddAnyAmbiguous(builder, anyAmbiguous)
def MonsterAddVectorOfEnums(builder, vectorOfEnums): builder.PrependUOffsetTRelativeSlot(47, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfEnums), 0)
def AddVectorOfEnums(builder, vectorOfEnums):
return MonsterAddVectorOfEnums(builder, vectorOfEnums)
def MonsterStartVectorOfEnumsVector(builder, numElems): return builder.StartVector(1, numElems, 1)
def StartVectorOfEnumsVector(builder, numElems):
return MonsterStartVectorOfEnumsVector(builder, numElems)
def MonsterAddSignedEnum(builder, signedEnum): builder.PrependInt8Slot(48, signedEnum, -1)
def AddSignedEnum(builder, signedEnum):
return MonsterAddSignedEnum(builder, signedEnum)
def MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer): builder.PrependUOffsetTRelativeSlot(49, flatbuffers.number_types.UOffsetTFlags.py_type(testrequirednestedflatbuffer), 0)
def AddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer):
return MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer)
def MonsterStartTestrequirednestedflatbufferVector(builder, numElems): return builder.StartVector(1, numElems, 1)
def StartTestrequirednestedflatbufferVector(builder, numElems):
return MonsterStartTestrequirednestedflatbufferVector(builder, numElems)
def MonsterMakeTestrequirednestedflatbufferVectorFromBytes(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)
return MonsterMakeTestrequirednestedflatbufferVectorFromBytes(builder, bytes)
def MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables): builder.PrependUOffsetTRelativeSlot(50, flatbuffers.number_types.UOffsetTFlags.py_type(scalarKeySortedTables), 0)
def AddScalarKeySortedTables(builder, scalarKeySortedTables):
return MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables)
def MonsterStartScalarKeySortedTablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
def StartScalarKeySortedTablesVector(builder, numElems):
return MonsterStartScalarKeySortedTablesVector(builder, numElems)
def MonsterEnd(builder): return builder.EndObject()
def End(builder):
return MonsterEnd(builder)
import MyGame.Example.Ability
import MyGame.Example.Any
import MyGame.Example.AnyAmbiguousAliases
@@ -1370,14 +1292,14 @@ class MonsterT(object):
if np is not None and type(self.inventory) is np.ndarray:
inventory = builder.CreateNumpyVector(self.inventory)
else:
StartInventoryVector(builder, len(self.inventory))
MonsterStartInventoryVector(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:
StartTest4Vector(builder, len(self.test4))
MonsterStartTest4Vector(builder, len(self.test4))
for i in reversed(range(len(self.test4))):
self.test4[i].Pack(builder)
test4 = builder.EndVector()
@@ -1385,7 +1307,7 @@ class MonsterT(object):
testarrayofstringlist = []
for i in range(len(self.testarrayofstring)):
testarrayofstringlist.append(builder.CreateString(self.testarrayofstring[i]))
StartTestarrayofstringVector(builder, len(self.testarrayofstring))
MonsterStartTestarrayofstringVector(builder, len(self.testarrayofstring))
for i in reversed(range(len(self.testarrayofstring))):
builder.PrependUOffsetTRelative(testarrayofstringlist[i])
testarrayofstring = builder.EndVector()
@@ -1393,7 +1315,7 @@ class MonsterT(object):
testarrayoftableslist = []
for i in range(len(self.testarrayoftables)):
testarrayoftableslist.append(self.testarrayoftables[i].Pack(builder))
StartTestarrayoftablesVector(builder, len(self.testarrayoftables))
MonsterStartTestarrayoftablesVector(builder, len(self.testarrayoftables))
for i in reversed(range(len(self.testarrayoftables))):
builder.PrependUOffsetTRelative(testarrayoftableslist[i])
testarrayoftables = builder.EndVector()
@@ -1403,7 +1325,7 @@ class MonsterT(object):
if np is not None and type(self.testnestedflatbuffer) is np.ndarray:
testnestedflatbuffer = builder.CreateNumpyVector(self.testnestedflatbuffer)
else:
StartTestnestedflatbufferVector(builder, len(self.testnestedflatbuffer))
MonsterStartTestnestedflatbufferVector(builder, len(self.testnestedflatbuffer))
for i in reversed(range(len(self.testnestedflatbuffer))):
builder.PrependUint8(self.testnestedflatbuffer[i])
testnestedflatbuffer = builder.EndVector()
@@ -1413,7 +1335,7 @@ class MonsterT(object):
if np is not None and type(self.testarrayofbools) is np.ndarray:
testarrayofbools = builder.CreateNumpyVector(self.testarrayofbools)
else:
StartTestarrayofboolsVector(builder, len(self.testarrayofbools))
MonsterStartTestarrayofboolsVector(builder, len(self.testarrayofbools))
for i in reversed(range(len(self.testarrayofbools))):
builder.PrependBool(self.testarrayofbools[i])
testarrayofbools = builder.EndVector()
@@ -1421,12 +1343,12 @@ class MonsterT(object):
testarrayofstring2list = []
for i in range(len(self.testarrayofstring2)):
testarrayofstring2list.append(builder.CreateString(self.testarrayofstring2[i]))
StartTestarrayofstring2Vector(builder, len(self.testarrayofstring2))
MonsterStartTestarrayofstring2Vector(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:
StartTestarrayofsortedstructVector(builder, len(self.testarrayofsortedstruct))
MonsterStartTestarrayofsortedstructVector(builder, len(self.testarrayofsortedstruct))
for i in reversed(range(len(self.testarrayofsortedstruct))):
self.testarrayofsortedstruct[i].Pack(builder)
testarrayofsortedstruct = builder.EndVector()
@@ -1434,12 +1356,12 @@ class MonsterT(object):
if np is not None and type(self.flex) is np.ndarray:
flex = builder.CreateNumpyVector(self.flex)
else:
StartFlexVector(builder, len(self.flex))
MonsterStartFlexVector(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:
StartTest5Vector(builder, len(self.test5))
MonsterStartTest5Vector(builder, len(self.test5))
for i in reversed(range(len(self.test5))):
self.test5[i].Pack(builder)
test5 = builder.EndVector()
@@ -1447,7 +1369,7 @@ class MonsterT(object):
if np is not None and type(self.vectorOfLongs) is np.ndarray:
vectorOfLongs = builder.CreateNumpyVector(self.vectorOfLongs)
else:
StartVectorOfLongsVector(builder, len(self.vectorOfLongs))
MonsterStartVectorOfLongsVector(builder, len(self.vectorOfLongs))
for i in reversed(range(len(self.vectorOfLongs))):
builder.PrependInt64(self.vectorOfLongs[i])
vectorOfLongs = builder.EndVector()
@@ -1455,7 +1377,7 @@ class MonsterT(object):
if np is not None and type(self.vectorOfDoubles) is np.ndarray:
vectorOfDoubles = builder.CreateNumpyVector(self.vectorOfDoubles)
else:
StartVectorOfDoublesVector(builder, len(self.vectorOfDoubles))
MonsterStartVectorOfDoublesVector(builder, len(self.vectorOfDoubles))
for i in reversed(range(len(self.vectorOfDoubles))):
builder.PrependFloat64(self.vectorOfDoubles[i])
vectorOfDoubles = builder.EndVector()
@@ -1465,7 +1387,7 @@ class MonsterT(object):
vectorOfReferrableslist = []
for i in range(len(self.vectorOfReferrables)):
vectorOfReferrableslist.append(self.vectorOfReferrables[i].Pack(builder))
StartVectorOfReferrablesVector(builder, len(self.vectorOfReferrables))
MonsterStartVectorOfReferrablesVector(builder, len(self.vectorOfReferrables))
for i in reversed(range(len(self.vectorOfReferrables))):
builder.PrependUOffsetTRelative(vectorOfReferrableslist[i])
vectorOfReferrables = builder.EndVector()
@@ -1473,7 +1395,7 @@ class MonsterT(object):
if np is not None and type(self.vectorOfWeakReferences) is np.ndarray:
vectorOfWeakReferences = builder.CreateNumpyVector(self.vectorOfWeakReferences)
else:
StartVectorOfWeakReferencesVector(builder, len(self.vectorOfWeakReferences))
MonsterStartVectorOfWeakReferencesVector(builder, len(self.vectorOfWeakReferences))
for i in reversed(range(len(self.vectorOfWeakReferences))):
builder.PrependUint64(self.vectorOfWeakReferences[i])
vectorOfWeakReferences = builder.EndVector()
@@ -1481,7 +1403,7 @@ class MonsterT(object):
vectorOfStrongReferrableslist = []
for i in range(len(self.vectorOfStrongReferrables)):
vectorOfStrongReferrableslist.append(self.vectorOfStrongReferrables[i].Pack(builder))
StartVectorOfStrongReferrablesVector(builder, len(self.vectorOfStrongReferrables))
MonsterStartVectorOfStrongReferrablesVector(builder, len(self.vectorOfStrongReferrables))
for i in reversed(range(len(self.vectorOfStrongReferrables))):
builder.PrependUOffsetTRelative(vectorOfStrongReferrableslist[i])
vectorOfStrongReferrables = builder.EndVector()
@@ -1489,7 +1411,7 @@ class MonsterT(object):
if np is not None and type(self.vectorOfCoOwningReferences) is np.ndarray:
vectorOfCoOwningReferences = builder.CreateNumpyVector(self.vectorOfCoOwningReferences)
else:
StartVectorOfCoOwningReferencesVector(builder, len(self.vectorOfCoOwningReferences))
MonsterStartVectorOfCoOwningReferencesVector(builder, len(self.vectorOfCoOwningReferences))
for i in reversed(range(len(self.vectorOfCoOwningReferences))):
builder.PrependUint64(self.vectorOfCoOwningReferences[i])
vectorOfCoOwningReferences = builder.EndVector()
@@ -1497,7 +1419,7 @@ class MonsterT(object):
if np is not None and type(self.vectorOfNonOwningReferences) is np.ndarray:
vectorOfNonOwningReferences = builder.CreateNumpyVector(self.vectorOfNonOwningReferences)
else:
StartVectorOfNonOwningReferencesVector(builder, len(self.vectorOfNonOwningReferences))
MonsterStartVectorOfNonOwningReferencesVector(builder, len(self.vectorOfNonOwningReferences))
for i in reversed(range(len(self.vectorOfNonOwningReferences))):
builder.PrependUint64(self.vectorOfNonOwningReferences[i])
vectorOfNonOwningReferences = builder.EndVector()
@@ -1509,7 +1431,7 @@ class MonsterT(object):
if np is not None and type(self.vectorOfEnums) is np.ndarray:
vectorOfEnums = builder.CreateNumpyVector(self.vectorOfEnums)
else:
StartVectorOfEnumsVector(builder, len(self.vectorOfEnums))
MonsterStartVectorOfEnumsVector(builder, len(self.vectorOfEnums))
for i in reversed(range(len(self.vectorOfEnums))):
builder.PrependUint8(self.vectorOfEnums[i])
vectorOfEnums = builder.EndVector()
@@ -1517,7 +1439,7 @@ class MonsterT(object):
if np is not None and type(self.testrequirednestedflatbuffer) is np.ndarray:
testrequirednestedflatbuffer = builder.CreateNumpyVector(self.testrequirednestedflatbuffer)
else:
StartTestrequirednestedflatbufferVector(builder, len(self.testrequirednestedflatbuffer))
MonsterStartTestrequirednestedflatbufferVector(builder, len(self.testrequirednestedflatbuffer))
for i in reversed(range(len(self.testrequirednestedflatbuffer))):
builder.PrependUint8(self.testrequirednestedflatbuffer[i])
testrequirednestedflatbuffer = builder.EndVector()
@@ -1525,89 +1447,89 @@ class MonsterT(object):
scalarKeySortedTableslist = []
for i in range(len(self.scalarKeySortedTables)):
scalarKeySortedTableslist.append(self.scalarKeySortedTables[i].Pack(builder))
StartScalarKeySortedTablesVector(builder, len(self.scalarKeySortedTables))
MonsterStartScalarKeySortedTablesVector(builder, len(self.scalarKeySortedTables))
for i in reversed(range(len(self.scalarKeySortedTables))):
builder.PrependUOffsetTRelative(scalarKeySortedTableslist[i])
scalarKeySortedTables = builder.EndVector()
Start(builder)
MonsterStart(builder)
if self.pos is not None:
pos = self.pos.Pack(builder)
AddPos(builder, pos)
AddMana(builder, self.mana)
AddHp(builder, self.hp)
MonsterAddPos(builder, pos)
MonsterAddMana(builder, self.mana)
MonsterAddHp(builder, self.hp)
if self.name is not None:
AddName(builder, name)
MonsterAddName(builder, name)
if self.inventory is not None:
AddInventory(builder, inventory)
AddColor(builder, self.color)
AddTestType(builder, self.testType)
MonsterAddInventory(builder, inventory)
MonsterAddColor(builder, self.color)
MonsterAddTestType(builder, self.testType)
if self.test is not None:
AddTest(builder, test)
MonsterAddTest(builder, test)
if self.test4 is not None:
AddTest4(builder, test4)
MonsterAddTest4(builder, test4)
if self.testarrayofstring is not None:
AddTestarrayofstring(builder, testarrayofstring)
MonsterAddTestarrayofstring(builder, testarrayofstring)
if self.testarrayoftables is not None:
AddTestarrayoftables(builder, testarrayoftables)
MonsterAddTestarrayoftables(builder, testarrayoftables)
if self.enemy is not None:
AddEnemy(builder, enemy)
MonsterAddEnemy(builder, enemy)
if self.testnestedflatbuffer is not None:
AddTestnestedflatbuffer(builder, testnestedflatbuffer)
MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer)
if self.testempty is not None:
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)
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)
if self.testarrayofbools is not None:
AddTestarrayofbools(builder, testarrayofbools)
AddTestf(builder, self.testf)
AddTestf2(builder, self.testf2)
AddTestf3(builder, self.testf3)
MonsterAddTestarrayofbools(builder, testarrayofbools)
MonsterAddTestf(builder, self.testf)
MonsterAddTestf2(builder, self.testf2)
MonsterAddTestf3(builder, self.testf3)
if self.testarrayofstring2 is not None:
AddTestarrayofstring2(builder, testarrayofstring2)
MonsterAddTestarrayofstring2(builder, testarrayofstring2)
if self.testarrayofsortedstruct is not None:
AddTestarrayofsortedstruct(builder, testarrayofsortedstruct)
MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct)
if self.flex is not None:
AddFlex(builder, flex)
MonsterAddFlex(builder, flex)
if self.test5 is not None:
AddTest5(builder, test5)
MonsterAddTest5(builder, test5)
if self.vectorOfLongs is not None:
AddVectorOfLongs(builder, vectorOfLongs)
MonsterAddVectorOfLongs(builder, vectorOfLongs)
if self.vectorOfDoubles is not None:
AddVectorOfDoubles(builder, vectorOfDoubles)
MonsterAddVectorOfDoubles(builder, vectorOfDoubles)
if self.parentNamespaceTest is not None:
AddParentNamespaceTest(builder, parentNamespaceTest)
MonsterAddParentNamespaceTest(builder, parentNamespaceTest)
if self.vectorOfReferrables is not None:
AddVectorOfReferrables(builder, vectorOfReferrables)
AddSingleWeakReference(builder, self.singleWeakReference)
MonsterAddVectorOfReferrables(builder, vectorOfReferrables)
MonsterAddSingleWeakReference(builder, self.singleWeakReference)
if self.vectorOfWeakReferences is not None:
AddVectorOfWeakReferences(builder, vectorOfWeakReferences)
MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences)
if self.vectorOfStrongReferrables is not None:
AddVectorOfStrongReferrables(builder, vectorOfStrongReferrables)
AddCoOwningReference(builder, self.coOwningReference)
MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables)
MonsterAddCoOwningReference(builder, self.coOwningReference)
if self.vectorOfCoOwningReferences is not None:
AddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences)
AddNonOwningReference(builder, self.nonOwningReference)
MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences)
MonsterAddNonOwningReference(builder, self.nonOwningReference)
if self.vectorOfNonOwningReferences is not None:
AddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences)
AddAnyUniqueType(builder, self.anyUniqueType)
MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences)
MonsterAddAnyUniqueType(builder, self.anyUniqueType)
if self.anyUnique is not None:
AddAnyUnique(builder, anyUnique)
AddAnyAmbiguousType(builder, self.anyAmbiguousType)
MonsterAddAnyUnique(builder, anyUnique)
MonsterAddAnyAmbiguousType(builder, self.anyAmbiguousType)
if self.anyAmbiguous is not None:
AddAnyAmbiguous(builder, anyAmbiguous)
MonsterAddAnyAmbiguous(builder, anyAmbiguous)
if self.vectorOfEnums is not None:
AddVectorOfEnums(builder, vectorOfEnums)
AddSignedEnum(builder, self.signedEnum)
MonsterAddVectorOfEnums(builder, vectorOfEnums)
MonsterAddSignedEnum(builder, self.signedEnum)
if self.testrequirednestedflatbuffer is not None:
AddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer)
MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer)
if self.scalarKeySortedTables is not None:
AddScalarKeySortedTables(builder, scalarKeySortedTables)
monster = End(builder)
MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables)
monster = MonsterEnd(builder)
return monster

27
tests/MyGame/Example/Referrable.py
View File

@@ -35,18 +35,15 @@ class Referrable(object):
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0
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)
def ReferrableStart(builder): builder.StartObject(1)
def Start(builder):
return ReferrableStart(builder)
def ReferrableAddId(builder, id): builder.PrependUint64Slot(0, id, 0)
def AddId(builder, id):
return ReferrableAddId(builder, id)
def ReferrableEnd(builder): return builder.EndObject()
def End(builder):
return ReferrableEnd(builder)
class ReferrableT(object):
@@ -74,7 +71,7 @@ class ReferrableT(object):
# ReferrableT
def Pack(self, builder):
Start(builder)
AddId(builder, self.id)
referrable = End(builder)
ReferrableStart(builder)
ReferrableAddId(builder, self.id)
referrable = ReferrableEnd(builder)
return referrable

45
tests/MyGame/Example/Stat.py
View File

@@ -49,26 +49,21 @@ class Stat(object):
return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
return 0
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)
def StatStart(builder): builder.StartObject(3)
def Start(builder):
return StatStart(builder)
def StatAddId(builder, id): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(id), 0)
def AddId(builder, id):
return StatAddId(builder, id)
def StatAddVal(builder, val): builder.PrependInt64Slot(1, val, 0)
def AddVal(builder, val):
return StatAddVal(builder, val)
def StatAddCount(builder, count): builder.PrependUint16Slot(2, count, 0)
def AddCount(builder, count):
return StatAddCount(builder, count)
def StatEnd(builder): return builder.EndObject()
def End(builder):
return StatEnd(builder)
class StatT(object):
@@ -102,10 +97,10 @@ class StatT(object):
def Pack(self, builder):
if self.id is not None:
id = builder.CreateString(self.id)
Start(builder)
StatStart(builder)
if self.id is not None:
AddId(builder, id)
AddVal(builder, self.val)
AddCount(builder, self.count)
stat = End(builder)
StatAddId(builder, id)
StatAddVal(builder, self.val)
StatAddCount(builder, self.count)
stat = StatEnd(builder)
return stat

27
tests/MyGame/Example/TestSimpleTableWithEnum.py
View File

@@ -35,18 +35,15 @@ class TestSimpleTableWithEnum(object):
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
return 2
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)
def TestSimpleTableWithEnumStart(builder): builder.StartObject(1)
def Start(builder):
return TestSimpleTableWithEnumStart(builder)
def TestSimpleTableWithEnumAddColor(builder, color): builder.PrependUint8Slot(0, color, 2)
def AddColor(builder, color):
return TestSimpleTableWithEnumAddColor(builder, color)
def TestSimpleTableWithEnumEnd(builder): return builder.EndObject()
def End(builder):
return TestSimpleTableWithEnumEnd(builder)
class TestSimpleTableWithEnumT(object):
@@ -74,7 +71,7 @@ class TestSimpleTableWithEnumT(object):
# TestSimpleTableWithEnumT
def Pack(self, builder):
Start(builder)
AddColor(builder, self.color)
testSimpleTableWithEnum = End(builder)
TestSimpleTableWithEnumStart(builder)
TestSimpleTableWithEnumAddColor(builder, self.color)
testSimpleTableWithEnum = TestSimpleTableWithEnumEnd(builder)
return testSimpleTableWithEnum

144
tests/MyGame/Example/TypeAliases.py
View File

@@ -152,70 +152,54 @@ class TypeAliases(object):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
return o == 0
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)
def TypeAliasesStart(builder): builder.StartObject(12)
def Start(builder):
return TypeAliasesStart(builder)
def TypeAliasesAddI8(builder, i8): builder.PrependInt8Slot(0, i8, 0)
def AddI8(builder, i8):
return TypeAliasesAddI8(builder, i8)
def TypeAliasesAddU8(builder, u8): builder.PrependUint8Slot(1, u8, 0)
def AddU8(builder, u8):
return TypeAliasesAddU8(builder, u8)
def TypeAliasesAddI16(builder, i16): builder.PrependInt16Slot(2, i16, 0)
def AddI16(builder, i16):
return TypeAliasesAddI16(builder, i16)
def TypeAliasesAddU16(builder, u16): builder.PrependUint16Slot(3, u16, 0)
def AddU16(builder, u16):
return TypeAliasesAddU16(builder, u16)
def TypeAliasesAddI32(builder, i32): builder.PrependInt32Slot(4, i32, 0)
def AddI32(builder, i32):
return TypeAliasesAddI32(builder, i32)
def TypeAliasesAddU32(builder, u32): builder.PrependUint32Slot(5, u32, 0)
def AddU32(builder, u32):
return TypeAliasesAddU32(builder, u32)
def TypeAliasesAddI64(builder, i64): builder.PrependInt64Slot(6, i64, 0)
def AddI64(builder, i64):
return TypeAliasesAddI64(builder, i64)
def TypeAliasesAddU64(builder, u64): builder.PrependUint64Slot(7, u64, 0)
def AddU64(builder, u64):
return TypeAliasesAddU64(builder, u64)
def TypeAliasesAddF32(builder, f32): builder.PrependFloat32Slot(8, f32, 0.0)
def AddF32(builder, f32):
return TypeAliasesAddF32(builder, f32)
def TypeAliasesAddF64(builder, f64): builder.PrependFloat64Slot(9, f64, 0.0)
def AddF64(builder, f64):
return TypeAliasesAddF64(builder, f64)
def TypeAliasesAddV8(builder, v8): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(v8), 0)
def AddV8(builder, v8):
return TypeAliasesAddV8(builder, v8)
def TypeAliasesStartV8Vector(builder, numElems): return builder.StartVector(1, numElems, 1)
def StartV8Vector(builder, numElems):
return TypeAliasesStartV8Vector(builder, numElems)
def TypeAliasesAddVf64(builder, vf64): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(vf64), 0)
def AddVf64(builder, vf64):
return TypeAliasesAddVf64(builder, vf64)
def TypeAliasesStartVf64Vector(builder, numElems): return builder.StartVector(8, numElems, 8)
def StartVf64Vector(builder, numElems):
return TypeAliasesStartVf64Vector(builder, numElems)
def TypeAliasesEnd(builder): return builder.EndObject()
def End(builder):
return TypeAliasesEnd(builder)
try:
from typing import List
except:
@@ -285,7 +269,7 @@ class TypeAliasesT(object):
if np is not None and type(self.v8) is np.ndarray:
v8 = builder.CreateNumpyVector(self.v8)
else:
StartV8Vector(builder, len(self.v8))
TypeAliasesStartV8Vector(builder, len(self.v8))
for i in reversed(range(len(self.v8))):
builder.PrependByte(self.v8[i])
v8 = builder.EndVector()
@@ -293,24 +277,24 @@ class TypeAliasesT(object):
if np is not None and type(self.vf64) is np.ndarray:
vf64 = builder.CreateNumpyVector(self.vf64)
else:
StartVf64Vector(builder, len(self.vf64))
TypeAliasesStartVf64Vector(builder, len(self.vf64))
for i in reversed(range(len(self.vf64))):
builder.PrependFloat64(self.vf64[i])
vf64 = builder.EndVector()
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)
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)
if self.v8 is not None:
AddV8(builder, v8)
TypeAliasesAddV8(builder, v8)
if self.vf64 is not None:
AddVf64(builder, vf64)
typeAliases = End(builder)
TypeAliasesAddVf64(builder, vf64)
typeAliases = TypeAliasesEnd(builder)
return typeAliases

18
tests/MyGame/Example2/Monster.py
View File

@@ -28,14 +28,12 @@ class Monster(object):
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
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)
def MonsterStart(builder): builder.StartObject(0)
def Start(builder):
return MonsterStart(builder)
def MonsterEnd(builder): return builder.EndObject()
def End(builder):
return MonsterEnd(builder)
class MonsterT(object):
@@ -62,6 +60,6 @@ class MonsterT(object):
# MonsterT
def Pack(self, builder):
Start(builder)
monster = End(builder)
MonsterStart(builder)
monster = MonsterEnd(builder)
return monster

18
tests/MyGame/InParentNamespace.py
View File

@@ -28,14 +28,12 @@ class InParentNamespace(object):
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
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)
def InParentNamespaceStart(builder): builder.StartObject(0)
def Start(builder):
return InParentNamespaceStart(builder)
def InParentNamespaceEnd(builder): return builder.EndObject()
def End(builder):
return InParentNamespaceEnd(builder)
class InParentNamespaceT(object):
@@ -62,6 +60,6 @@ class InParentNamespaceT(object):
# InParentNamespaceT
def Pack(self, builder):
Start(builder)
inParentNamespace = End(builder)
InParentNamespaceStart(builder)
inParentNamespace = InParentNamespaceEnd(builder)
return inParentNamespace

126
tests/MyGame/MonsterExtra.py
View File

@@ -138,62 +138,48 @@ class MonsterExtra(object):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
return o == 0
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)
def MonsterExtraStart(builder): builder.StartObject(11)
def Start(builder):
return MonsterExtraStart(builder)
def MonsterExtraAddD0(builder, d0): builder.PrependFloat64Slot(0, d0, float('nan'))
def AddD0(builder, d0):
return MonsterExtraAddD0(builder, d0)
def MonsterExtraAddD1(builder, d1): builder.PrependFloat64Slot(1, d1, float('nan'))
def AddD1(builder, d1):
return MonsterExtraAddD1(builder, d1)
def MonsterExtraAddD2(builder, d2): builder.PrependFloat64Slot(2, d2, float('inf'))
def AddD2(builder, d2):
return MonsterExtraAddD2(builder, d2)
def MonsterExtraAddD3(builder, d3): builder.PrependFloat64Slot(3, d3, float('-inf'))
def AddD3(builder, d3):
return MonsterExtraAddD3(builder, d3)
def MonsterExtraAddF0(builder, f0): builder.PrependFloat32Slot(4, f0, float('nan'))
def AddF0(builder, f0):
return MonsterExtraAddF0(builder, f0)
def MonsterExtraAddF1(builder, f1): builder.PrependFloat32Slot(5, f1, float('nan'))
def AddF1(builder, f1):
return MonsterExtraAddF1(builder, f1)
def MonsterExtraAddF2(builder, f2): builder.PrependFloat32Slot(6, f2, float('inf'))
def AddF2(builder, f2):
return MonsterExtraAddF2(builder, f2)
def MonsterExtraAddF3(builder, f3): builder.PrependFloat32Slot(7, f3, float('-inf'))
def AddF3(builder, f3):
return MonsterExtraAddF3(builder, f3)
def MonsterExtraAddDvec(builder, dvec): builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(dvec), 0)
def AddDvec(builder, dvec):
return MonsterExtraAddDvec(builder, dvec)
def MonsterExtraStartDvecVector(builder, numElems): return builder.StartVector(8, numElems, 8)
def StartDvecVector(builder, numElems):
return MonsterExtraStartDvecVector(builder, numElems)
def MonsterExtraAddFvec(builder, fvec): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(fvec), 0)
def AddFvec(builder, fvec):
return MonsterExtraAddFvec(builder, fvec)
def MonsterExtraStartFvecVector(builder, numElems): return builder.StartVector(4, numElems, 4)
def StartFvecVector(builder, numElems):
return MonsterExtraStartFvecVector(builder, numElems)
def MonsterExtraEnd(builder): return builder.EndObject()
def End(builder):
return MonsterExtraEnd(builder)
try:
from typing import List
except:
@@ -259,7 +245,7 @@ class MonsterExtraT(object):
if np is not None and type(self.dvec) is np.ndarray:
dvec = builder.CreateNumpyVector(self.dvec)
else:
StartDvecVector(builder, len(self.dvec))
MonsterExtraStartDvecVector(builder, len(self.dvec))
for i in reversed(range(len(self.dvec))):
builder.PrependFloat64(self.dvec[i])
dvec = builder.EndVector()
@@ -267,22 +253,22 @@ class MonsterExtraT(object):
if np is not None and type(self.fvec) is np.ndarray:
fvec = builder.CreateNumpyVector(self.fvec)
else:
StartFvecVector(builder, len(self.fvec))
MonsterExtraStartFvecVector(builder, len(self.fvec))
for i in reversed(range(len(self.fvec))):
builder.PrependFloat32(self.fvec[i])
fvec = builder.EndVector()
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)
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)
if self.dvec is not None:
AddDvec(builder, dvec)
MonsterExtraAddDvec(builder, dvec)
if self.fvec is not None:
AddFvec(builder, fvec)
monsterExtra = End(builder)
MonsterExtraAddFvec(builder, fvec)
monsterExtra = MonsterExtraEnd(builder)
return monsterExtra

27
tests/namespace_test/NamespaceA/NamespaceB/TableInNestedNS.py
View File

@@ -31,18 +31,15 @@ class TableInNestedNS(object):
return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
return 0
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)
def TableInNestedNSStart(builder): builder.StartObject(1)
def Start(builder):
return TableInNestedNSStart(builder)
def TableInNestedNSAddFoo(builder, foo): builder.PrependInt32Slot(0, foo, 0)
def AddFoo(builder, foo):
return TableInNestedNSAddFoo(builder, foo)
def TableInNestedNSEnd(builder): return builder.EndObject()
def End(builder):
return TableInNestedNSEnd(builder)
class TableInNestedNST(object):
@@ -70,7 +67,7 @@ class TableInNestedNST(object):
# TableInNestedNST
def Pack(self, builder):
Start(builder)
AddFoo(builder, self.foo)
tableInNestedNS = End(builder)
TableInNestedNSStart(builder)
TableInNestedNSAddFoo(builder, self.foo)
tableInNestedNS = TableInNestedNSEnd(builder)
return tableInNestedNS

27
tests/namespace_test/NamespaceA/SecondTableInA.py
View File

@@ -34,18 +34,15 @@ class SecondTableInA(object):
return obj
return None
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)
def SecondTableInAStart(builder): builder.StartObject(1)
def Start(builder):
return SecondTableInAStart(builder)
def SecondTableInAAddReferToC(builder, referToC): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(referToC), 0)
def AddReferToC(builder, referToC):
return SecondTableInAAddReferToC(builder, referToC)
def SecondTableInAEnd(builder): return builder.EndObject()
def End(builder):
return SecondTableInAEnd(builder)
try:
from typing import Optional
except:
@@ -80,8 +77,8 @@ class SecondTableInAT(object):
def Pack(self, builder):
if self.referToC is not None:
referToC = self.referToC.Pack(builder)
Start(builder)
SecondTableInAStart(builder)
if self.referToC is not None:
AddReferToC(builder, referToC)
secondTableInA = End(builder)
SecondTableInAAddReferToC(builder, referToC)
secondTableInA = SecondTableInAEnd(builder)
return secondTableInA

63
tests/namespace_test/NamespaceA/TableInFirstNS.py
View File

@@ -68,34 +68,27 @@ class TableInFirstNS(object):
return obj
return None
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)
def TableInFirstNSStart(builder): builder.StartObject(5)
def Start(builder):
return TableInFirstNSStart(builder)
def TableInFirstNSAddFooTable(builder, fooTable): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(fooTable), 0)
def AddFooTable(builder, fooTable):
return TableInFirstNSAddFooTable(builder, fooTable)
def TableInFirstNSAddFooEnum(builder, fooEnum): builder.PrependInt8Slot(1, fooEnum, 0)
def AddFooEnum(builder, fooEnum):
return TableInFirstNSAddFooEnum(builder, fooEnum)
def TableInFirstNSAddFooUnionType(builder, fooUnionType): builder.PrependUint8Slot(2, fooUnionType, 0)
def AddFooUnionType(builder, fooUnionType):
return TableInFirstNSAddFooUnionType(builder, fooUnionType)
def TableInFirstNSAddFooUnion(builder, fooUnion): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(fooUnion), 0)
def AddFooUnion(builder, fooUnion):
return TableInFirstNSAddFooUnion(builder, fooUnion)
def TableInFirstNSAddFooStruct(builder, fooStruct): builder.PrependStructSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(fooStruct), 0)
def AddFooStruct(builder, fooStruct):
return TableInFirstNSAddFooStruct(builder, fooStruct)
def TableInFirstNSEnd(builder): return builder.EndObject()
def End(builder):
return TableInFirstNSEnd(builder)
try:
from typing import Optional, Union
except:
@@ -141,15 +134,15 @@ class TableInFirstNST(object):
fooTable = self.fooTable.Pack(builder)
if self.fooUnion is not None:
fooUnion = self.fooUnion.Pack(builder)
Start(builder)
TableInFirstNSStart(builder)
if self.fooTable is not None:
AddFooTable(builder, fooTable)
AddFooEnum(builder, self.fooEnum)
AddFooUnionType(builder, self.fooUnionType)
TableInFirstNSAddFooTable(builder, fooTable)
TableInFirstNSAddFooEnum(builder, self.fooEnum)
TableInFirstNSAddFooUnionType(builder, self.fooUnionType)
if self.fooUnion is not None:
AddFooUnion(builder, fooUnion)
TableInFirstNSAddFooUnion(builder, fooUnion)
if self.fooStruct is not None:
fooStruct = self.fooStruct.Pack(builder)
AddFooStruct(builder, fooStruct)
tableInFirstNS = End(builder)
TableInFirstNSAddFooStruct(builder, fooStruct)
tableInFirstNS = TableInFirstNSEnd(builder)
return tableInFirstNS

36
tests/namespace_test/NamespaceC/TableInC.py
View File

@@ -44,22 +44,18 @@ class TableInC(object):
return obj
return None
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)
def TableInCStart(builder): builder.StartObject(2)
def Start(builder):
return TableInCStart(builder)
def TableInCAddReferToA1(builder, referToA1): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(referToA1), 0)
def AddReferToA1(builder, referToA1):
return TableInCAddReferToA1(builder, referToA1)
def TableInCAddReferToA2(builder, referToA2): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(referToA2), 0)
def AddReferToA2(builder, referToA2):
return TableInCAddReferToA2(builder, referToA2)
def TableInCEnd(builder): return builder.EndObject()
def End(builder):
return TableInCEnd(builder)
try:
from typing import Optional
except:
@@ -99,10 +95,10 @@ class TableInCT(object):
referToA1 = self.referToA1.Pack(builder)
if self.referToA2 is not None:
referToA2 = self.referToA2.Pack(builder)
Start(builder)
TableInCStart(builder)
if self.referToA1 is not None:
AddReferToA1(builder, referToA1)
TableInCAddReferToA1(builder, referToA1)
if self.referToA2 is not None:
AddReferToA2(builder, referToA2)
tableInC = End(builder)
TableInCAddReferToA2(builder, referToA2)
tableInC = TableInCEnd(builder)
return tableInC