BigfootDev/flatbuffers
1
0
Fork 1
mirror of https://github.com/google/flatbuffers.git synced 2026-06-27 05:52:19 +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 self._tab.String(o + self._tab.Pos)
return None return None
def Start(builder): builder.StartObject(1) def HelloReplyStart(builder): builder.StartObject(1)
def HelloReplyStart(builder): def Start(builder):
"""This method is deprecated. Please switch to Start.""" return HelloReplyStart(builder)
return Start(builder) def HelloReplyAddMessage(builder, message): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(message), 0)
def AddMessage(builder, message): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(message), 0) def AddMessage(builder, message):
def HelloReplyAddMessage(builder, message): return HelloReplyAddMessage(builder, message)
"""This method is deprecated. Please switch to AddMessage.""" def HelloReplyEnd(builder): return builder.EndObject()
return AddMessage(builder, message) def End(builder):
def End(builder): return builder.EndObject() return HelloReplyEnd(builder)
def HelloReplyEnd(builder):
"""This method is deprecated. Please switch to End."""
return End(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 self._tab.String(o + self._tab.Pos)
return None return None
def Start(builder): builder.StartObject(1) def HelloRequestStart(builder): builder.StartObject(1)
def HelloRequestStart(builder): def Start(builder):
"""This method is deprecated. Please switch to Start.""" return HelloRequestStart(builder)
return Start(builder) def HelloRequestAddName(builder, name): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
def AddName(builder, name): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) def AddName(builder, name):
def HelloRequestAddName(builder, name): return HelloRequestAddName(builder, name)
"""This method is deprecated. Please switch to AddName.""" def HelloRequestEnd(builder): return builder.EndObject()
return AddName(builder, name) def End(builder):
def End(builder): return builder.EndObject() return HelloRequestEnd(builder)
def HelloRequestEnd(builder):
"""This method is deprecated. Please switch to End."""
return End(builder)

259
src/idl_gen_python.cpp
View File

@@ -31,7 +31,7 @@ namespace flatbuffers {
namespace python { namespace python {
// Hardcode spaces per indentation. // Hardcode spaces per indentation.
const CommentConfig def_comment = { nullptr, "#", nullptr }; const CommentConfig def_comment = {nullptr, "#", nullptr};
const std::string Indent = " "; const std::string Indent = " ";
class PythonGenerator : public BaseGenerator { class PythonGenerator : public BaseGenerator {
@@ -42,12 +42,11 @@ class PythonGenerator : public BaseGenerator {
"" /* not used */, "py"), "" /* not used */, "py"),
float_const_gen_("float('nan')", "float('inf')", "float('-inf')") { float_const_gen_("float('nan')", "float('inf')", "float('-inf')") {
static const char *const keywords[] = { static const char *const keywords[] = {
"False", "None", "True", "and", "as", "assert", "break", "False", "None", "True", "and", "as", "assert", "break",
"class", "continue", "def", "del", "elif", "else", "except", "class", "continue", "def", "del", "elif", "else", "except",
"finally", "for", "from", "global", "if", "import", "in", "finally", "for", "from", "global", "if", "import", "in",
"is", "lambda", "nonlocal", "not", "or", "pass", "raise", "is", "lambda", "nonlocal", "not", "or", "pass", "raise",
"return", "try", "while", "with", "yield" "return", "try", "while", "with", "yield"};
};
keywords_.insert(std::begin(keywords), std::end(keywords)); keywords_.insert(std::begin(keywords), std::end(keywords));
} }
@@ -142,8 +141,8 @@ class PythonGenerator : public BaseGenerator {
code += NormalizedName(struct_def); code += NormalizedName(struct_def);
code += "(cls, buf, offset=0):\n"; code += "(cls, buf, offset=0):\n";
code += code +=
Indent + Indent + Indent + Indent +
"\"\"\"This method is deprecated. Please switch to GetRootAs.\"\"\"\n"; "\"\"\"This method is deprecated. Please switch to GetRootAs.\"\"\"\n";
code += Indent + Indent + "return cls.GetRootAs(buf, offset)\n"; code += Indent + Indent + "return cls.GetRootAs(buf, offset)\n";
} }
@@ -207,7 +206,9 @@ class PythonGenerator : public BaseGenerator {
code += OffsetPrefix(field); code += OffsetPrefix(field);
getter += "o + self._tab.Pos)"; getter += "o + self._tab.Pos)";
auto is_bool = IsBool(field.value.type.base_type); 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"; code += Indent + Indent + Indent + "return " + getter + "\n";
std::string default_value; std::string default_value;
if (is_bool) { if (is_bool) {
@@ -397,7 +398,9 @@ class PythonGenerator : public BaseGenerator {
// Currently, we only support accessing as numpy array if // Currently, we only support accessing as numpy array if
// the vector type is a scalar. // the vector type is a scalar.
if (!(IsScalar(vectortype.base_type))) { return; } if (!(IsScalar(vectortype.base_type))) {
return;
}
GenReceiver(struct_def, code_ptr); GenReceiver(struct_def, code_ptr);
code += MakeCamel(NormalizedName(field)) + "AsNumpy(self):"; code += MakeCamel(NormalizedName(field)) + "AsNumpy(self):";
@@ -422,7 +425,9 @@ class PythonGenerator : public BaseGenerator {
const FieldDef &field, const FieldDef &field,
std::string *code_ptr) { std::string *code_ptr) {
auto nested = field.attributes.Lookup("nested_flatbuffer"); 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 unqualified_name = nested->constant;
std::string qualified_name = nested->constant; std::string qualified_name = nested->constant;
@@ -444,7 +449,7 @@ class PythonGenerator : public BaseGenerator {
code += Indent + Indent + Indent; code += Indent + Indent + Indent;
code += "from " + qualified_name + " import " + unqualified_name + "\n"; code += "from " + qualified_name + " import " + unqualified_name + "\n";
code += Indent + Indent + Indent + "return " + unqualified_name; code += Indent + Indent + Indent + "return " + unqualified_name;
code += ".GetRootAs"; code += ".GetRootAs" + unqualified_name;
code += "(self._tab.Bytes, self._tab.Vector(o))\n"; code += "(self._tab.Bytes, self._tab.Vector(o))\n";
code += Indent + Indent + "return 0\n"; code += Indent + Indent + "return 0\n";
code += "\n"; code += "\n";
@@ -485,7 +490,9 @@ class PythonGenerator : public BaseGenerator {
} else { } else {
auto &code = *code_ptr; auto &code = *code_ptr;
code += std::string(", ") + nameprefix; code += std::string(", ") + nameprefix;
if (has_field_name) { code += MakeCamel(NormalizedName(field), false); } if (has_field_name) {
code += MakeCamel(NormalizedName(field), false);
}
code += namesuffix; code += namesuffix;
} }
} }
@@ -555,23 +562,27 @@ class PythonGenerator : public BaseGenerator {
// Get the value of a table's starting offset. // Get the value of a table's starting offset.
void GetStartOfTable(const StructDef &struct_def, std::string *code_ptr) { void GetStartOfTable(const StructDef &struct_def, std::string *code_ptr) {
auto &code = *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 += "builder.StartObject(";
code += NumToString(struct_def.fields.vec.size()); code += NumToString(struct_def.fields.vec.size());
code += ")\n"; code += ")\n";
// Add alias with the old name. // Generate method without struct name.
code += "def " + NormalizedName(struct_def) + "Start(builder):\n"; code += "def Start(builder):\n";
code += Indent + code +=
"\"\"\"This method is deprecated. Please switch to Start.\"\"\"\n"; Indent + "return " + NormalizedName(struct_def) + "Start(builder)\n";
code += Indent + "return Start(builder)\n";
} }
// Set the value of a table's field. // Set the value of a table's field.
void BuildFieldOfTable(const StructDef &struct_def, const FieldDef &field, void BuildFieldOfTable(const StructDef &struct_def, const FieldDef &field,
const size_t offset, std::string *code_ptr) { const size_t offset, std::string *code_ptr) {
auto &code = *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 += "(builder, ";
code += MakeCamel(NormalizedName(field), false); code += MakeCamel(NormalizedName(field), false);
code += "): "; code += "): ";
@@ -591,27 +602,25 @@ class PythonGenerator : public BaseGenerator {
: field.value.constant; : field.value.constant;
code += ")\n"; code += ")\n";
// Add alias with the old name. // Generate method without struct name.
code += "def " + NormalizedName(struct_def) + "Add" + code += "def Add" + MakeCamel(NormalizedName(field));
MakeCamel(NormalizedName(field));
code += "(builder, "; code += "(builder, ";
code += MakeCamel(NormalizedName(field), false); code += MakeCamel(NormalizedName(field), false);
code += "):\n"; code += "):\n";
code += Indent + "\"\"\"This method is deprecated. Please switch to Add"; code += Indent + "return " + NormalizedName(struct_def) + "Add" +
code += MakeCamel(NormalizedName(field)) + ".\"\"\"\n"; MakeCamel(NormalizedName(field));
code += Indent + "return Add" + MakeCamel(NormalizedName(field));
code += "(builder, "; code += "(builder, ";
code += MakeCamel(NormalizedName(field), false); code += MakeCamel(NormalizedName(field), false);
code += ")\n"; code += ")\n";
// Add alias with the old name.
} }
// Set the value of one of the members of a table's vector. // Set the value of one of the members of a table's vector.
void BuildVectorOfTable(const StructDef &struct_def, const FieldDef &field, void BuildVectorOfTable(const StructDef &struct_def, const FieldDef &field,
std::string *code_ptr) { std::string *code_ptr) {
auto &code = *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 += MakeCamel(NormalizedName(field));
code += "Vector(builder, numElems): return builder.StartVector("; code += "Vector(builder, numElems): return builder.StartVector(";
auto vector_type = field.value.type.VectorType(); auto vector_type = field.value.type.VectorType();
@@ -621,13 +630,11 @@ class PythonGenerator : public BaseGenerator {
code += ", numElems, " + NumToString(alignment); code += ", numElems, " + NumToString(alignment);
code += ")\n"; code += ")\n";
// Add alias with the old name. // Generate method without struct name.
code += "def " + NormalizedName(struct_def) + "Start"; code += "def Start";
code += MakeCamel(NormalizedName(field)); code += MakeCamel(NormalizedName(field));
code += "Vector(builder, numElems):\n"; code += "Vector(builder, numElems):\n";
code += Indent + code += Indent + "return " + NormalizedName(struct_def) + "Start";
"\"\"\"This method is deprecated. Please switch to Start.\"\"\"\n";
code += Indent + "return Start";
code += MakeCamel(NormalizedName(field)); code += MakeCamel(NormalizedName(field));
code += "Vector(builder, numElems)\n"; 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 // 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 // elements from a bytearray. This is for simplifying the use of nested
// flatbuffers. // flatbuffers.
void BuildVectorOfTableFromBytes(const FieldDef &field, void BuildVectorOfTableFromBytes(const StructDef &struct_def,
const FieldDef &field,
std::string *code_ptr) { std::string *code_ptr) {
auto nested = field.attributes.Lookup("nested_flatbuffer"); 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 unqualified_name = nested->constant;
std::string qualified_name = nested->constant; std::string qualified_name = nested->constant;
@@ -652,7 +662,11 @@ class PythonGenerator : public BaseGenerator {
(void)nested_root; (void)nested_root;
auto &code = *code_ptr; 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("; code += Indent + "builder.StartVector(";
auto vector_type = field.value.type.VectorType(); auto vector_type = field.value.type.VectorType();
auto alignment = InlineAlignment(vector_type); auto alignment = InlineAlignment(vector_type);
@@ -665,29 +679,26 @@ class PythonGenerator : public BaseGenerator {
code += " = bytes\n"; code += " = bytes\n";
code += Indent + "return builder.EndVector()\n"; code += Indent + "return builder.EndVector()\n";
// Add alias with the old name. // Generate method without struct and field name.
code += "def Make" + MakeCamel(NormalizedName(field)); code += "def Make" + MakeCamel(NormalizedName(field)) +
code += "VectorFromBytes(builder, bytes):\n"; "VectorFromBytes(builder, bytes):\n";
code += Indent + "builder.StartVector("; code += Indent + "return " + NormalizedName(struct_def) + "Make" +
code += NumToString(elem_size); MakeCamel(NormalizedName(field)) +
code += ", len(bytes), " + NumToString(alignment); "VectorFromBytes(builder, bytes)\n";
code += ")\n";
code += Indent + "builder.head = builder.head - len(bytes)\n";
code += Indent + "builder.Bytes[builder.head : builder.head + len(bytes)]";
code += " = bytes\n";
code += Indent + "return builder.EndVector()\n";
} }
// Get the offset of the end of a table. // Get the offset of the end of a table.
void GetEndOffsetOnTable(const StructDef &struct_def, std::string *code_ptr) { void GetEndOffsetOnTable(const StructDef &struct_def, std::string *code_ptr) {
auto &code = *code_ptr; auto &code = *code_ptr;
code += "def End(builder): return builder.EndObject()\n";
// Add alias with the old name. // Generate method with struct name.
code += "def " + NormalizedName(struct_def) + "End(builder):\n"; code += "def " + NormalizedName(struct_def) + "End";
code += Indent + code += "(builder): ";
"\"\"\"This method is deprecated. Please switch to End.\"\"\"\n"; code += "return builder.EndObject()\n";
code += Indent + "return End(builder)";
// Generate method without struct name.
code += "def End(builder):\n";
code += Indent + "return " + NormalizedName(struct_def) + "End(builder)";
} }
// Generate the receiver for function signatures. // Generate the receiver for function signatures.
@@ -732,8 +743,11 @@ class PythonGenerator : public BaseGenerator {
} }
break; break;
} }
case BASE_TYPE_UNION: GetUnionField(struct_def, field, code_ptr); break; case BASE_TYPE_UNION:
default: FLATBUFFERS_ASSERT(0); GetUnionField(struct_def, field, code_ptr);
break;
default:
FLATBUFFERS_ASSERT(0);
} }
} }
if (IsVector(field.value.type) || IsArray(field.value.type)) { if (IsVector(field.value.type) || IsArray(field.value.type)) {
@@ -765,7 +779,7 @@ class PythonGenerator : public BaseGenerator {
BuildFieldOfTable(struct_def, field, offset, code_ptr); BuildFieldOfTable(struct_def, field, offset, code_ptr);
if (IsVector(field.value.type)) { if (IsVector(field.value.type)) {
BuildVectorOfTable(struct_def, field, code_ptr); 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); import_list->insert("import " + package_reference);
} }
break; break;
case BASE_TYPE_STRING: field_type += "str"; break; case BASE_TYPE_STRING:
case BASE_TYPE_NONE: field_type += "None"; break; field_type += "str";
default: break; break;
case BASE_TYPE_NONE:
field_type += "None";
break;
default:
break;
} }
field_types += field_type + separator_string; field_types += field_type + separator_string;
} }
@@ -1239,7 +1258,8 @@ class PythonGenerator : public BaseGenerator {
GenUnPackForScalarVector(struct_def, field, &code); GenUnPackForScalarVector(struct_def, field, &code);
break; break;
} }
default: GenUnPackForScalar(struct_def, field, &code); default:
GenUnPackForScalar(struct_def, field, &code);
} }
} }
@@ -1294,8 +1314,9 @@ class PythonGenerator : public BaseGenerator {
code_prefix += code_prefix +=
GenIndents(2) + "if self." + field_instance_name + " is not None:"; GenIndents(2) + "if self." + field_instance_name + " is not None:";
if (field.value.type.struct_def->fixed) { if (field.value.type.struct_def->fixed) {
code_prefix += GenIndents(3) + "Start" + field_accessor_name + code_prefix += GenIndents(3) + struct_name + "Start" +
"Vector(builder, len(self." + field_instance_name + "))"; field_accessor_name + "Vector(builder, len(self." +
field_instance_name + "))";
code_prefix += GenIndents(3) + "for i in reversed(range(len(self." + code_prefix += GenIndents(3) + "for i in reversed(range(len(self." +
field_instance_name + "))):"; field_instance_name + "))):";
code_prefix += code_prefix +=
@@ -1311,8 +1332,9 @@ class PythonGenerator : public BaseGenerator {
code_prefix += GenIndents(4) + field_instance_name + "list.append(self." + code_prefix += GenIndents(4) + field_instance_name + "list.append(self." +
field_instance_name + "[i].Pack(builder))"; field_instance_name + "[i].Pack(builder))";
code_prefix += GenIndents(3) + "Start" + field_accessor_name + code_prefix += GenIndents(3) + struct_name + "Start" +
"Vector(builder, len(self." + field_instance_name + "))"; field_accessor_name + "Vector(builder, len(self." +
field_instance_name + "))";
code_prefix += GenIndents(3) + "for i in reversed(range(len(self." + code_prefix += GenIndents(3) + "for i in reversed(range(len(self." +
field_instance_name + "))):"; field_instance_name + "))):";
code_prefix += GenIndents(4) + "builder.PrependUOffsetTRelative" + "(" + code_prefix += GenIndents(4) + "builder.PrependUOffsetTRelative" + "(" +
@@ -1323,8 +1345,8 @@ class PythonGenerator : public BaseGenerator {
// Adds the field into the struct. // Adds the field into the struct.
code += GenIndents(2) + "if self." + field_instance_name + " is not None:"; code += GenIndents(2) + "if self." + field_instance_name + " is not None:";
code += GenIndents(3) + "Add" + field_accessor_name + "(builder, " + code += GenIndents(3) + struct_name + "Add" + field_accessor_name +
field_instance_name + ")"; "(builder, " + field_instance_name + ")";
} }
void GenPackForScalarVectorFieldHelper(const StructDef &struct_def, void GenPackForScalarVectorFieldHelper(const StructDef &struct_def,
@@ -1336,7 +1358,7 @@ class PythonGenerator : public BaseGenerator {
auto struct_name = NormalizedName(struct_def); auto struct_name = NormalizedName(struct_def);
auto vectortype = field.value.type.VectorType(); 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 + "))"; "Vector(builder, len(self." + field_instance_name + "))";
code += GenIndents(indents) + "for i in reversed(range(len(self." + code += GenIndents(indents) + "for i in reversed(range(len(self." +
field_instance_name + "))):"; field_instance_name + "))):";
@@ -1344,19 +1366,45 @@ class PythonGenerator : public BaseGenerator {
std::string type_name; std::string type_name;
switch (vectortype.base_type) { switch (vectortype.base_type) {
case BASE_TYPE_BOOL: type_name = "Bool"; break; case BASE_TYPE_BOOL:
case BASE_TYPE_CHAR: type_name = "Byte"; break; type_name = "Bool";
case BASE_TYPE_UCHAR: type_name = "Uint8"; break; break;
case BASE_TYPE_SHORT: type_name = "Int16"; break; case BASE_TYPE_CHAR:
case BASE_TYPE_USHORT: type_name = "Uint16"; break; type_name = "Byte";
case BASE_TYPE_INT: type_name = "Int32"; break; break;
case BASE_TYPE_UINT: type_name = "Uint32"; break; case BASE_TYPE_UCHAR:
case BASE_TYPE_LONG: type_name = "Int64"; break; type_name = "Uint8";
case BASE_TYPE_ULONG: type_name = "Uint64"; break; break;
case BASE_TYPE_FLOAT: type_name = "Float32"; break; case BASE_TYPE_SHORT:
case BASE_TYPE_DOUBLE: type_name = "Float64"; break; type_name = "Int16";
case BASE_TYPE_STRING: type_name = "UOffsetTRelative"; break; break;
default: type_name = "VOffsetT"; 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; code += type_name;
} }
@@ -1373,8 +1421,8 @@ class PythonGenerator : public BaseGenerator {
// Adds the field into the struct. // Adds the field into the struct.
code += GenIndents(2) + "if self." + field_instance_name + " is not None:"; code += GenIndents(2) + "if self." + field_instance_name + " is not None:";
code += GenIndents(3) + "Add" + field_accessor_name + "(builder, " + code += GenIndents(3) + struct_name + "Add" + field_accessor_name +
field_instance_name + ")"; "(builder, " + field_instance_name + ")";
// Creates the field. // Creates the field.
code_prefix += code_prefix +=
@@ -1436,8 +1484,8 @@ class PythonGenerator : public BaseGenerator {
GenIndents(2) + "if self." + field_instance_name + " is not None:"; GenIndents(2) + "if self." + field_instance_name + " is not None:";
} }
code += GenIndents(3) + "Add" + field_accessor_name + "(builder, " + code += GenIndents(3) + struct_name + "Add" + field_accessor_name +
field_instance_name + ")"; "(builder, " + field_instance_name + ")";
} }
void GenPackForUnionField(const StructDef &struct_def, const FieldDef &field, 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." + code_prefix += GenIndents(3) + field_instance_name + " = self." +
field_instance_name + ".Pack(builder)"; field_instance_name + ".Pack(builder)";
code += GenIndents(2) + "if self." + field_instance_name + " is not None:"; code += GenIndents(2) + "if self." + field_instance_name + " is not None:";
code += GenIndents(3) + "Add" + field_accessor_name + "(builder, " + code += GenIndents(3) + struct_name + "Add" + field_accessor_name +
field_instance_name + ")"; "(builder, " + field_instance_name + ")";
} }
void GenPackForTable(const StructDef &struct_def, std::string *code_ptr) { void GenPackForTable(const StructDef &struct_def, std::string *code_ptr) {
@@ -1468,7 +1516,7 @@ class PythonGenerator : public BaseGenerator {
GenReceiverForObjectAPI(struct_def, code_ptr); GenReceiverForObjectAPI(struct_def, code_ptr);
code_base += "Pack(self, builder):"; 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(); for (auto it = struct_def.fields.vec.begin();
it != struct_def.fields.vec.end(); ++it) { it != struct_def.fields.vec.end(); ++it) {
auto &field = **it; auto &field = **it;
@@ -1507,21 +1555,22 @@ class PythonGenerator : public BaseGenerator {
")"; ")";
code += GenIndents(2) + "if self." + field_instance_name + code += GenIndents(2) + "if self." + field_instance_name +
" is not None:"; " is not None:";
code += GenIndents(3) + "Add" + field_accessor_name + "(builder, " + code += GenIndents(3) + struct_name + "Add" + field_accessor_name +
field_instance_name + ")"; "(builder, " + field_instance_name + ")";
break; break;
} }
default: default:
// Generates code for scalar values. If the value equals to the // Generates code for scalar values. If the value equals to the
// default value, builder will automatically ignore it. So we don't // default value, builder will automatically ignore it. So we don't
// need to check the value ahead. // 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 + ")"; "(builder, self." + field_instance_name + ")";
break; 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 += GenIndents(2) + "return " + struct_instance_name;
code_base += code_prefix + code; code_base += code_prefix + code;
@@ -1616,7 +1665,8 @@ class PythonGenerator : public BaseGenerator {
case BASE_TYPE_STRING: case BASE_TYPE_STRING:
GenUnionCreatorForString(enum_def, ev, &code); GenUnionCreatorForString(enum_def, ev, &code);
break; break;
default: break; default:
break;
} }
} }
code += GenIndents(1) + "return None"; 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. // Returns the function name that is able to read a value of the given type.
std::string GenGetter(const Type &type) { std::string GenGetter(const Type &type) {
switch (type.base_type) { switch (type.base_type) {
case BASE_TYPE_STRING: return "self._tab.String("; case BASE_TYPE_STRING:
case BASE_TYPE_UNION: return "self._tab.Union("; return "self._tab.String(";
case BASE_TYPE_VECTOR: return GenGetter(type.VectorType()); case BASE_TYPE_UNION:
return "self._tab.Union(";
case BASE_TYPE_VECTOR:
return GenGetter(type.VectorType());
default: default:
return "self._tab.Get(flatbuffers.number_types." + return "self._tab.Get(flatbuffers.number_types." +
MakeCamel(GenTypeGet(type)) + "Flags, "; MakeCamel(GenTypeGet(type)) + "Flags, ";
@@ -1672,12 +1725,16 @@ class PythonGenerator : public BaseGenerator {
std::string GenTypePointer(const Type &type) { std::string GenTypePointer(const Type &type) {
switch (type.base_type) { switch (type.base_type) {
case BASE_TYPE_STRING: return "string"; case BASE_TYPE_STRING:
case BASE_TYPE_VECTOR: return GenTypeGet(type.VectorType()); return "string";
case BASE_TYPE_STRUCT: return type.struct_def->name; case BASE_TYPE_VECTOR:
return GenTypeGet(type.VectorType());
case BASE_TYPE_STRUCT:
return type.struct_def->name;
case BASE_TYPE_UNION: case BASE_TYPE_UNION:
// fall through // 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 obj
return None return None
def Start(builder): builder.StartObject(1) def ArrayTableStart(builder): builder.StartObject(1)
def ArrayTableStart(builder): def Start(builder):
"""This method is deprecated. Please switch to Start.""" return ArrayTableStart(builder)
return Start(builder) def ArrayTableAddA(builder, a): builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(a), 0)
def AddA(builder, a): builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(a), 0) def AddA(builder, a):
def ArrayTableAddA(builder, a): return ArrayTableAddA(builder, a)
"""This method is deprecated. Please switch to AddA.""" def ArrayTableEnd(builder): return builder.EndObject()
return AddA(builder, a) def End(builder):
def End(builder): return builder.EndObject() return ArrayTableEnd(builder)
def ArrayTableEnd(builder):
"""This method is deprecated. Please switch to End."""
return End(builder)
import MyGame.Example.ArrayStruct import MyGame.Example.ArrayStruct
try: try:
from typing import Optional from typing import Optional
@@ -84,9 +81,9 @@ class ArrayTableT(object):
# ArrayTableT # ArrayTableT
def Pack(self, builder): def Pack(self, builder):
Start(builder) ArrayTableStart(builder)
if self.a is not None: if self.a is not None:
a = self.a.Pack(builder) a = self.a.Pack(builder)
AddA(builder, a) ArrayTableAddA(builder, a)
arrayTable = End(builder) arrayTable = ArrayTableEnd(builder)
return arrayTable 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)) o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
if o != 0: if o != 0:
from MyGame.Example.Monster import Monster 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 return 0
# Monster # Monster
@@ -751,7 +751,7 @@ class Monster(object):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102)) o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
if o != 0: if o != 0:
from MyGame.Example.Monster import Monster 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 return 0
# Monster # Monster
@@ -791,314 +791,236 @@ class Monster(object):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(104)) o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(104))
return o == 0 return o == 0
def Start(builder): builder.StartObject(51) def MonsterStart(builder): builder.StartObject(51)
def MonsterStart(builder): def Start(builder):
"""This method is deprecated. Please switch to Start.""" return MonsterStart(builder)
return Start(builder) def MonsterAddPos(builder, pos): builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(pos), 0)
def AddPos(builder, pos): builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(pos), 0) def AddPos(builder, pos):
def MonsterAddPos(builder, pos): return MonsterAddPos(builder, pos)
"""This method is deprecated. Please switch to AddPos.""" def MonsterAddMana(builder, mana): builder.PrependInt16Slot(1, mana, 150)
return AddPos(builder, pos) def AddMana(builder, mana):
def AddMana(builder, mana): builder.PrependInt16Slot(1, mana, 150) return MonsterAddMana(builder, mana)
def MonsterAddMana(builder, mana): def MonsterAddHp(builder, hp): builder.PrependInt16Slot(2, hp, 100)
"""This method is deprecated. Please switch to AddMana.""" def AddHp(builder, hp):
return AddMana(builder, mana) return MonsterAddHp(builder, hp)
def AddHp(builder, hp): builder.PrependInt16Slot(2, hp, 100) def MonsterAddName(builder, name): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
def MonsterAddHp(builder, hp): def AddName(builder, name):
"""This method is deprecated. Please switch to AddHp.""" return MonsterAddName(builder, name)
return AddHp(builder, hp) def MonsterAddInventory(builder, inventory): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(inventory), 0)
def AddName(builder, name): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) def AddInventory(builder, inventory):
def MonsterAddName(builder, name): return MonsterAddInventory(builder, inventory)
"""This method is deprecated. Please switch to AddName.""" def MonsterStartInventoryVector(builder, numElems): return builder.StartVector(1, numElems, 1)
return AddName(builder, name) def StartInventoryVector(builder, numElems):
def AddInventory(builder, inventory): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(inventory), 0) return MonsterStartInventoryVector(builder, numElems)
def MonsterAddInventory(builder, inventory): def MonsterAddColor(builder, color): builder.PrependUint8Slot(6, color, 8)
"""This method is deprecated. Please switch to AddInventory.""" def AddColor(builder, color):
return AddInventory(builder, inventory) return MonsterAddColor(builder, color)
def StartInventoryVector(builder, numElems): return builder.StartVector(1, numElems, 1) def MonsterAddTestType(builder, testType): builder.PrependUint8Slot(7, testType, 0)
def MonsterStartInventoryVector(builder, numElems): def AddTestType(builder, testType):
"""This method is deprecated. Please switch to Start.""" return MonsterAddTestType(builder, testType)
return StartInventoryVector(builder, numElems) def MonsterAddTest(builder, test): builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(test), 0)
def AddColor(builder, color): builder.PrependUint8Slot(6, color, 8) def AddTest(builder, test):
def MonsterAddColor(builder, color): return MonsterAddTest(builder, test)
"""This method is deprecated. Please switch to AddColor.""" def MonsterAddTest4(builder, test4): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(test4), 0)
return AddColor(builder, color) def AddTest4(builder, test4):
def AddTestType(builder, testType): builder.PrependUint8Slot(7, testType, 0) return MonsterAddTest4(builder, test4)
def MonsterAddTestType(builder, testType): def MonsterStartTest4Vector(builder, numElems): return builder.StartVector(4, numElems, 2)
"""This method is deprecated. Please switch to AddTestType.""" def StartTest4Vector(builder, numElems):
return AddTestType(builder, testType) return MonsterStartTest4Vector(builder, numElems)
def AddTest(builder, test): builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(test), 0) def MonsterAddTestarrayofstring(builder, testarrayofstring): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring), 0)
def MonsterAddTest(builder, test): def AddTestarrayofstring(builder, testarrayofstring):
"""This method is deprecated. Please switch to AddTest.""" return MonsterAddTestarrayofstring(builder, testarrayofstring)
return AddTest(builder, test) def MonsterStartTestarrayofstringVector(builder, numElems): return builder.StartVector(4, numElems, 4)
def AddTest4(builder, test4): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(test4), 0) def StartTestarrayofstringVector(builder, numElems):
def MonsterAddTest4(builder, test4): return MonsterStartTestarrayofstringVector(builder, numElems)
"""This method is deprecated. Please switch to AddTest4.""" def MonsterAddTestarrayoftables(builder, testarrayoftables): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayoftables), 0)
return AddTest4(builder, test4) def AddTestarrayoftables(builder, testarrayoftables):
def StartTest4Vector(builder, numElems): return builder.StartVector(4, numElems, 2) return MonsterAddTestarrayoftables(builder, testarrayoftables)
def MonsterStartTest4Vector(builder, numElems): def MonsterStartTestarrayoftablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
"""This method is deprecated. Please switch to Start.""" def StartTestarrayoftablesVector(builder, numElems):
return StartTest4Vector(builder, numElems) return MonsterStartTestarrayoftablesVector(builder, numElems)
def AddTestarrayofstring(builder, testarrayofstring): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring), 0) def MonsterAddEnemy(builder, enemy): builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(enemy), 0)
def MonsterAddTestarrayofstring(builder, testarrayofstring): def AddEnemy(builder, enemy):
"""This method is deprecated. Please switch to AddTestarrayofstring.""" return MonsterAddEnemy(builder, enemy)
return AddTestarrayofstring(builder, testarrayofstring) def MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer): builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(testnestedflatbuffer), 0)
def StartTestarrayofstringVector(builder, numElems): return builder.StartVector(4, numElems, 4) def AddTestnestedflatbuffer(builder, testnestedflatbuffer):
def MonsterStartTestarrayofstringVector(builder, numElems): return MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer)
"""This method is deprecated. Please switch to Start.""" def MonsterStartTestnestedflatbufferVector(builder, numElems): return builder.StartVector(1, numElems, 1)
return StartTestarrayofstringVector(builder, numElems) def StartTestnestedflatbufferVector(builder, numElems):
def AddTestarrayoftables(builder, testarrayoftables): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayoftables), 0) return MonsterStartTestnestedflatbufferVector(builder, numElems)
def MonsterAddTestarrayoftables(builder, testarrayoftables): def MonsterMakeTestnestedflatbufferVectorFromBytes(builder, bytes):
"""This method is deprecated. Please switch to AddTestarrayoftables."""
return AddTestarrayoftables(builder, testarrayoftables)
def StartTestarrayoftablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
def MonsterStartTestarrayoftablesVector(builder, numElems):
"""This method is deprecated. Please switch to Start."""
return StartTestarrayoftablesVector(builder, numElems)
def AddEnemy(builder, enemy): builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(enemy), 0)
def MonsterAddEnemy(builder, enemy):
"""This method is deprecated. Please switch to AddEnemy."""
return AddEnemy(builder, enemy)
def AddTestnestedflatbuffer(builder, testnestedflatbuffer): builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(testnestedflatbuffer), 0)
def MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer):
"""This method is deprecated. Please switch to AddTestnestedflatbuffer."""
return AddTestnestedflatbuffer(builder, testnestedflatbuffer)
def StartTestnestedflatbufferVector(builder, numElems): return builder.StartVector(1, numElems, 1)
def MonsterStartTestnestedflatbufferVector(builder, numElems):
"""This method is deprecated. Please switch to Start."""
return StartTestnestedflatbufferVector(builder, numElems)
def MakeVectorFromBytes(builder, bytes):
builder.StartVector(1, len(bytes), 1) builder.StartVector(1, len(bytes), 1)
builder.head = builder.head - len(bytes) builder.head = builder.head - len(bytes)
builder.Bytes[builder.head : builder.head + len(bytes)] = bytes builder.Bytes[builder.head : builder.head + len(bytes)] = bytes
return builder.EndVector() return builder.EndVector()
def MakeTestnestedflatbufferVectorFromBytes(builder, bytes): def MakeTestnestedflatbufferVectorFromBytes(builder, bytes):
builder.StartVector(1, len(bytes), 1) return MonsterMakeTestnestedflatbufferVectorFromBytes(builder, bytes)
builder.head = builder.head - len(bytes) def MonsterAddTestempty(builder, testempty): builder.PrependUOffsetTRelativeSlot(14, flatbuffers.number_types.UOffsetTFlags.py_type(testempty), 0)
builder.Bytes[builder.head : builder.head + len(bytes)] = bytes def AddTestempty(builder, testempty):
return builder.EndVector() return MonsterAddTestempty(builder, testempty)
def AddTestempty(builder, testempty): builder.PrependUOffsetTRelativeSlot(14, flatbuffers.number_types.UOffsetTFlags.py_type(testempty), 0) def MonsterAddTestbool(builder, testbool): builder.PrependBoolSlot(15, testbool, 0)
def MonsterAddTestempty(builder, testempty): def AddTestbool(builder, testbool):
"""This method is deprecated. Please switch to AddTestempty.""" return MonsterAddTestbool(builder, testbool)
return AddTestempty(builder, testempty) def MonsterAddTesthashs32Fnv1(builder, testhashs32Fnv1): builder.PrependInt32Slot(16, testhashs32Fnv1, 0)
def AddTestbool(builder, testbool): builder.PrependBoolSlot(15, testbool, 0) def AddTesthashs32Fnv1(builder, testhashs32Fnv1):
def MonsterAddTestbool(builder, testbool): return MonsterAddTesthashs32Fnv1(builder, testhashs32Fnv1)
"""This method is deprecated. Please switch to AddTestbool.""" def MonsterAddTesthashu32Fnv1(builder, testhashu32Fnv1): builder.PrependUint32Slot(17, testhashu32Fnv1, 0)
return AddTestbool(builder, testbool) def AddTesthashu32Fnv1(builder, testhashu32Fnv1):
def AddTesthashs32Fnv1(builder, testhashs32Fnv1): builder.PrependInt32Slot(16, testhashs32Fnv1, 0) return MonsterAddTesthashu32Fnv1(builder, testhashu32Fnv1)
def MonsterAddTesthashs32Fnv1(builder, testhashs32Fnv1): def MonsterAddTesthashs64Fnv1(builder, testhashs64Fnv1): builder.PrependInt64Slot(18, testhashs64Fnv1, 0)
"""This method is deprecated. Please switch to AddTesthashs32Fnv1.""" def AddTesthashs64Fnv1(builder, testhashs64Fnv1):
return AddTesthashs32Fnv1(builder, testhashs32Fnv1) return MonsterAddTesthashs64Fnv1(builder, testhashs64Fnv1)
def AddTesthashu32Fnv1(builder, testhashu32Fnv1): builder.PrependUint32Slot(17, testhashu32Fnv1, 0) def MonsterAddTesthashu64Fnv1(builder, testhashu64Fnv1): builder.PrependUint64Slot(19, testhashu64Fnv1, 0)
def MonsterAddTesthashu32Fnv1(builder, testhashu32Fnv1): def AddTesthashu64Fnv1(builder, testhashu64Fnv1):
"""This method is deprecated. Please switch to AddTesthashu32Fnv1.""" return MonsterAddTesthashu64Fnv1(builder, testhashu64Fnv1)
return AddTesthashu32Fnv1(builder, testhashu32Fnv1) def MonsterAddTesthashs32Fnv1a(builder, testhashs32Fnv1a): builder.PrependInt32Slot(20, testhashs32Fnv1a, 0)
def AddTesthashs64Fnv1(builder, testhashs64Fnv1): builder.PrependInt64Slot(18, testhashs64Fnv1, 0) def AddTesthashs32Fnv1a(builder, testhashs32Fnv1a):
def MonsterAddTesthashs64Fnv1(builder, testhashs64Fnv1): return MonsterAddTesthashs32Fnv1a(builder, testhashs32Fnv1a)
"""This method is deprecated. Please switch to AddTesthashs64Fnv1.""" def MonsterAddTesthashu32Fnv1a(builder, testhashu32Fnv1a): builder.PrependUint32Slot(21, testhashu32Fnv1a, 0)
return AddTesthashs64Fnv1(builder, testhashs64Fnv1) def AddTesthashu32Fnv1a(builder, testhashu32Fnv1a):
def AddTesthashu64Fnv1(builder, testhashu64Fnv1): builder.PrependUint64Slot(19, testhashu64Fnv1, 0) return MonsterAddTesthashu32Fnv1a(builder, testhashu32Fnv1a)
def MonsterAddTesthashu64Fnv1(builder, testhashu64Fnv1): def MonsterAddTesthashs64Fnv1a(builder, testhashs64Fnv1a): builder.PrependInt64Slot(22, testhashs64Fnv1a, 0)
"""This method is deprecated. Please switch to AddTesthashu64Fnv1.""" def AddTesthashs64Fnv1a(builder, testhashs64Fnv1a):
return AddTesthashu64Fnv1(builder, testhashu64Fnv1) return MonsterAddTesthashs64Fnv1a(builder, testhashs64Fnv1a)
def AddTesthashs32Fnv1a(builder, testhashs32Fnv1a): builder.PrependInt32Slot(20, testhashs32Fnv1a, 0) def MonsterAddTesthashu64Fnv1a(builder, testhashu64Fnv1a): builder.PrependUint64Slot(23, testhashu64Fnv1a, 0)
def MonsterAddTesthashs32Fnv1a(builder, testhashs32Fnv1a): def AddTesthashu64Fnv1a(builder, testhashu64Fnv1a):
"""This method is deprecated. Please switch to AddTesthashs32Fnv1a.""" return MonsterAddTesthashu64Fnv1a(builder, testhashu64Fnv1a)
return AddTesthashs32Fnv1a(builder, testhashs32Fnv1a) def MonsterAddTestarrayofbools(builder, testarrayofbools): builder.PrependUOffsetTRelativeSlot(24, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofbools), 0)
def AddTesthashu32Fnv1a(builder, testhashu32Fnv1a): builder.PrependUint32Slot(21, testhashu32Fnv1a, 0) def AddTestarrayofbools(builder, testarrayofbools):
def MonsterAddTesthashu32Fnv1a(builder, testhashu32Fnv1a): return MonsterAddTestarrayofbools(builder, testarrayofbools)
"""This method is deprecated. Please switch to AddTesthashu32Fnv1a.""" def MonsterStartTestarrayofboolsVector(builder, numElems): return builder.StartVector(1, numElems, 1)
return AddTesthashu32Fnv1a(builder, testhashu32Fnv1a) def StartTestarrayofboolsVector(builder, numElems):
def AddTesthashs64Fnv1a(builder, testhashs64Fnv1a): builder.PrependInt64Slot(22, testhashs64Fnv1a, 0) return MonsterStartTestarrayofboolsVector(builder, numElems)
def MonsterAddTesthashs64Fnv1a(builder, testhashs64Fnv1a): def MonsterAddTestf(builder, testf): builder.PrependFloat32Slot(25, testf, 3.14159)
"""This method is deprecated. Please switch to AddTesthashs64Fnv1a.""" def AddTestf(builder, testf):
return AddTesthashs64Fnv1a(builder, testhashs64Fnv1a) return MonsterAddTestf(builder, testf)
def AddTesthashu64Fnv1a(builder, testhashu64Fnv1a): builder.PrependUint64Slot(23, testhashu64Fnv1a, 0) def MonsterAddTestf2(builder, testf2): builder.PrependFloat32Slot(26, testf2, 3.0)
def MonsterAddTesthashu64Fnv1a(builder, testhashu64Fnv1a): def AddTestf2(builder, testf2):
"""This method is deprecated. Please switch to AddTesthashu64Fnv1a.""" return MonsterAddTestf2(builder, testf2)
return AddTesthashu64Fnv1a(builder, testhashu64Fnv1a) def MonsterAddTestf3(builder, testf3): builder.PrependFloat32Slot(27, testf3, 0.0)
def AddTestarrayofbools(builder, testarrayofbools): builder.PrependUOffsetTRelativeSlot(24, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofbools), 0) def AddTestf3(builder, testf3):
def MonsterAddTestarrayofbools(builder, testarrayofbools): return MonsterAddTestf3(builder, testf3)
"""This method is deprecated. Please switch to AddTestarrayofbools.""" def MonsterAddTestarrayofstring2(builder, testarrayofstring2): builder.PrependUOffsetTRelativeSlot(28, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring2), 0)
return AddTestarrayofbools(builder, testarrayofbools) def AddTestarrayofstring2(builder, testarrayofstring2):
def StartTestarrayofboolsVector(builder, numElems): return builder.StartVector(1, numElems, 1) return MonsterAddTestarrayofstring2(builder, testarrayofstring2)
def MonsterStartTestarrayofboolsVector(builder, numElems): def MonsterStartTestarrayofstring2Vector(builder, numElems): return builder.StartVector(4, numElems, 4)
"""This method is deprecated. Please switch to Start.""" def StartTestarrayofstring2Vector(builder, numElems):
return StartTestarrayofboolsVector(builder, numElems) return MonsterStartTestarrayofstring2Vector(builder, numElems)
def AddTestf(builder, testf): builder.PrependFloat32Slot(25, testf, 3.14159) def MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct): builder.PrependUOffsetTRelativeSlot(29, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofsortedstruct), 0)
def MonsterAddTestf(builder, testf): def AddTestarrayofsortedstruct(builder, testarrayofsortedstruct):
"""This method is deprecated. Please switch to AddTestf.""" return MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct)
return AddTestf(builder, testf) def MonsterStartTestarrayofsortedstructVector(builder, numElems): return builder.StartVector(8, numElems, 4)
def AddTestf2(builder, testf2): builder.PrependFloat32Slot(26, testf2, 3.0) def StartTestarrayofsortedstructVector(builder, numElems):
def MonsterAddTestf2(builder, testf2): return MonsterStartTestarrayofsortedstructVector(builder, numElems)
"""This method is deprecated. Please switch to AddTestf2.""" def MonsterAddFlex(builder, flex): builder.PrependUOffsetTRelativeSlot(30, flatbuffers.number_types.UOffsetTFlags.py_type(flex), 0)
return AddTestf2(builder, testf2) def AddFlex(builder, flex):
def AddTestf3(builder, testf3): builder.PrependFloat32Slot(27, testf3, 0.0) return MonsterAddFlex(builder, flex)
def MonsterAddTestf3(builder, testf3): def MonsterStartFlexVector(builder, numElems): return builder.StartVector(1, numElems, 1)
"""This method is deprecated. Please switch to AddTestf3.""" def StartFlexVector(builder, numElems):
return AddTestf3(builder, testf3) return MonsterStartFlexVector(builder, numElems)
def AddTestarrayofstring2(builder, testarrayofstring2): builder.PrependUOffsetTRelativeSlot(28, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring2), 0) def MonsterAddTest5(builder, test5): builder.PrependUOffsetTRelativeSlot(31, flatbuffers.number_types.UOffsetTFlags.py_type(test5), 0)
def MonsterAddTestarrayofstring2(builder, testarrayofstring2): def AddTest5(builder, test5):
"""This method is deprecated. Please switch to AddTestarrayofstring2.""" return MonsterAddTest5(builder, test5)
return AddTestarrayofstring2(builder, testarrayofstring2) def MonsterStartTest5Vector(builder, numElems): return builder.StartVector(4, numElems, 2)
def StartTestarrayofstring2Vector(builder, numElems): return builder.StartVector(4, numElems, 4) def StartTest5Vector(builder, numElems):
def MonsterStartTestarrayofstring2Vector(builder, numElems): return MonsterStartTest5Vector(builder, numElems)
"""This method is deprecated. Please switch to Start.""" def MonsterAddVectorOfLongs(builder, vectorOfLongs): builder.PrependUOffsetTRelativeSlot(32, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfLongs), 0)
return StartTestarrayofstring2Vector(builder, numElems) def AddVectorOfLongs(builder, vectorOfLongs):
def AddTestarrayofsortedstruct(builder, testarrayofsortedstruct): builder.PrependUOffsetTRelativeSlot(29, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofsortedstruct), 0) return MonsterAddVectorOfLongs(builder, vectorOfLongs)
def MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct): def MonsterStartVectorOfLongsVector(builder, numElems): return builder.StartVector(8, numElems, 8)
"""This method is deprecated. Please switch to AddTestarrayofsortedstruct.""" def StartVectorOfLongsVector(builder, numElems):
return AddTestarrayofsortedstruct(builder, testarrayofsortedstruct) return MonsterStartVectorOfLongsVector(builder, numElems)
def StartTestarrayofsortedstructVector(builder, numElems): return builder.StartVector(8, numElems, 4) def MonsterAddVectorOfDoubles(builder, vectorOfDoubles): builder.PrependUOffsetTRelativeSlot(33, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfDoubles), 0)
def MonsterStartTestarrayofsortedstructVector(builder, numElems): def AddVectorOfDoubles(builder, vectorOfDoubles):
"""This method is deprecated. Please switch to Start.""" return MonsterAddVectorOfDoubles(builder, vectorOfDoubles)
return StartTestarrayofsortedstructVector(builder, numElems) def MonsterStartVectorOfDoublesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
def AddFlex(builder, flex): builder.PrependUOffsetTRelativeSlot(30, flatbuffers.number_types.UOffsetTFlags.py_type(flex), 0) def StartVectorOfDoublesVector(builder, numElems):
def MonsterAddFlex(builder, flex): return MonsterStartVectorOfDoublesVector(builder, numElems)
"""This method is deprecated. Please switch to AddFlex.""" def MonsterAddParentNamespaceTest(builder, parentNamespaceTest): builder.PrependUOffsetTRelativeSlot(34, flatbuffers.number_types.UOffsetTFlags.py_type(parentNamespaceTest), 0)
return AddFlex(builder, flex) def AddParentNamespaceTest(builder, parentNamespaceTest):
def StartFlexVector(builder, numElems): return builder.StartVector(1, numElems, 1) return MonsterAddParentNamespaceTest(builder, parentNamespaceTest)
def MonsterStartFlexVector(builder, numElems): def MonsterAddVectorOfReferrables(builder, vectorOfReferrables): builder.PrependUOffsetTRelativeSlot(35, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfReferrables), 0)
"""This method is deprecated. Please switch to Start.""" def AddVectorOfReferrables(builder, vectorOfReferrables):
return StartFlexVector(builder, numElems) return MonsterAddVectorOfReferrables(builder, vectorOfReferrables)
def AddTest5(builder, test5): builder.PrependUOffsetTRelativeSlot(31, flatbuffers.number_types.UOffsetTFlags.py_type(test5), 0) def MonsterStartVectorOfReferrablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
def MonsterAddTest5(builder, test5): def StartVectorOfReferrablesVector(builder, numElems):
"""This method is deprecated. Please switch to AddTest5.""" return MonsterStartVectorOfReferrablesVector(builder, numElems)
return AddTest5(builder, test5) def MonsterAddSingleWeakReference(builder, singleWeakReference): builder.PrependUint64Slot(36, singleWeakReference, 0)
def StartTest5Vector(builder, numElems): return builder.StartVector(4, numElems, 2) def AddSingleWeakReference(builder, singleWeakReference):
def MonsterStartTest5Vector(builder, numElems): return MonsterAddSingleWeakReference(builder, singleWeakReference)
"""This method is deprecated. Please switch to Start.""" def MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences): builder.PrependUOffsetTRelativeSlot(37, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfWeakReferences), 0)
return StartTest5Vector(builder, numElems) def AddVectorOfWeakReferences(builder, vectorOfWeakReferences):
def AddVectorOfLongs(builder, vectorOfLongs): builder.PrependUOffsetTRelativeSlot(32, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfLongs), 0) return MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences)
def MonsterAddVectorOfLongs(builder, vectorOfLongs): def MonsterStartVectorOfWeakReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
"""This method is deprecated. Please switch to AddVectorOfLongs.""" def StartVectorOfWeakReferencesVector(builder, numElems):
return AddVectorOfLongs(builder, vectorOfLongs) return MonsterStartVectorOfWeakReferencesVector(builder, numElems)
def StartVectorOfLongsVector(builder, numElems): return builder.StartVector(8, numElems, 8) def MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables): builder.PrependUOffsetTRelativeSlot(38, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfStrongReferrables), 0)
def MonsterStartVectorOfLongsVector(builder, numElems): def AddVectorOfStrongReferrables(builder, vectorOfStrongReferrables):
"""This method is deprecated. Please switch to Start.""" return MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables)
return StartVectorOfLongsVector(builder, numElems) def MonsterStartVectorOfStrongReferrablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
def AddVectorOfDoubles(builder, vectorOfDoubles): builder.PrependUOffsetTRelativeSlot(33, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfDoubles), 0) def StartVectorOfStrongReferrablesVector(builder, numElems):
def MonsterAddVectorOfDoubles(builder, vectorOfDoubles): return MonsterStartVectorOfStrongReferrablesVector(builder, numElems)
"""This method is deprecated. Please switch to AddVectorOfDoubles.""" def MonsterAddCoOwningReference(builder, coOwningReference): builder.PrependUint64Slot(39, coOwningReference, 0)
return AddVectorOfDoubles(builder, vectorOfDoubles) def AddCoOwningReference(builder, coOwningReference):
def StartVectorOfDoublesVector(builder, numElems): return builder.StartVector(8, numElems, 8) return MonsterAddCoOwningReference(builder, coOwningReference)
def MonsterStartVectorOfDoublesVector(builder, numElems): def MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences): builder.PrependUOffsetTRelativeSlot(40, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfCoOwningReferences), 0)
"""This method is deprecated. Please switch to Start.""" def AddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences):
return StartVectorOfDoublesVector(builder, numElems) return MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences)
def AddParentNamespaceTest(builder, parentNamespaceTest): builder.PrependUOffsetTRelativeSlot(34, flatbuffers.number_types.UOffsetTFlags.py_type(parentNamespaceTest), 0) def MonsterStartVectorOfCoOwningReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
def MonsterAddParentNamespaceTest(builder, parentNamespaceTest): def StartVectorOfCoOwningReferencesVector(builder, numElems):
"""This method is deprecated. Please switch to AddParentNamespaceTest.""" return MonsterStartVectorOfCoOwningReferencesVector(builder, numElems)
return AddParentNamespaceTest(builder, parentNamespaceTest) def MonsterAddNonOwningReference(builder, nonOwningReference): builder.PrependUint64Slot(41, nonOwningReference, 0)
def AddVectorOfReferrables(builder, vectorOfReferrables): builder.PrependUOffsetTRelativeSlot(35, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfReferrables), 0) def AddNonOwningReference(builder, nonOwningReference):
def MonsterAddVectorOfReferrables(builder, vectorOfReferrables): return MonsterAddNonOwningReference(builder, nonOwningReference)
"""This method is deprecated. Please switch to AddVectorOfReferrables.""" def MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences): builder.PrependUOffsetTRelativeSlot(42, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfNonOwningReferences), 0)
return AddVectorOfReferrables(builder, vectorOfReferrables) def AddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences):
def StartVectorOfReferrablesVector(builder, numElems): return builder.StartVector(4, numElems, 4) return MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences)
def MonsterStartVectorOfReferrablesVector(builder, numElems): def MonsterStartVectorOfNonOwningReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
"""This method is deprecated. Please switch to Start.""" def StartVectorOfNonOwningReferencesVector(builder, numElems):
return StartVectorOfReferrablesVector(builder, numElems) return MonsterStartVectorOfNonOwningReferencesVector(builder, numElems)
def AddSingleWeakReference(builder, singleWeakReference): builder.PrependUint64Slot(36, singleWeakReference, 0) def MonsterAddAnyUniqueType(builder, anyUniqueType): builder.PrependUint8Slot(43, anyUniqueType, 0)
def MonsterAddSingleWeakReference(builder, singleWeakReference): def AddAnyUniqueType(builder, anyUniqueType):
"""This method is deprecated. Please switch to AddSingleWeakReference.""" return MonsterAddAnyUniqueType(builder, anyUniqueType)
return AddSingleWeakReference(builder, singleWeakReference) def MonsterAddAnyUnique(builder, anyUnique): builder.PrependUOffsetTRelativeSlot(44, flatbuffers.number_types.UOffsetTFlags.py_type(anyUnique), 0)
def AddVectorOfWeakReferences(builder, vectorOfWeakReferences): builder.PrependUOffsetTRelativeSlot(37, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfWeakReferences), 0) def AddAnyUnique(builder, anyUnique):
def MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences): return MonsterAddAnyUnique(builder, anyUnique)
"""This method is deprecated. Please switch to AddVectorOfWeakReferences.""" def MonsterAddAnyAmbiguousType(builder, anyAmbiguousType): builder.PrependUint8Slot(45, anyAmbiguousType, 0)
return AddVectorOfWeakReferences(builder, vectorOfWeakReferences) def AddAnyAmbiguousType(builder, anyAmbiguousType):
def StartVectorOfWeakReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8) return MonsterAddAnyAmbiguousType(builder, anyAmbiguousType)
def MonsterStartVectorOfWeakReferencesVector(builder, numElems): def MonsterAddAnyAmbiguous(builder, anyAmbiguous): builder.PrependUOffsetTRelativeSlot(46, flatbuffers.number_types.UOffsetTFlags.py_type(anyAmbiguous), 0)
"""This method is deprecated. Please switch to Start.""" def AddAnyAmbiguous(builder, anyAmbiguous):
return StartVectorOfWeakReferencesVector(builder, numElems) return MonsterAddAnyAmbiguous(builder, anyAmbiguous)
def AddVectorOfStrongReferrables(builder, vectorOfStrongReferrables): builder.PrependUOffsetTRelativeSlot(38, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfStrongReferrables), 0) def MonsterAddVectorOfEnums(builder, vectorOfEnums): builder.PrependUOffsetTRelativeSlot(47, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfEnums), 0)
def MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables): def AddVectorOfEnums(builder, vectorOfEnums):
"""This method is deprecated. Please switch to AddVectorOfStrongReferrables.""" return MonsterAddVectorOfEnums(builder, vectorOfEnums)
return AddVectorOfStrongReferrables(builder, vectorOfStrongReferrables) def MonsterStartVectorOfEnumsVector(builder, numElems): return builder.StartVector(1, numElems, 1)
def StartVectorOfStrongReferrablesVector(builder, numElems): return builder.StartVector(4, numElems, 4) def StartVectorOfEnumsVector(builder, numElems):
def MonsterStartVectorOfStrongReferrablesVector(builder, numElems): return MonsterStartVectorOfEnumsVector(builder, numElems)
"""This method is deprecated. Please switch to Start.""" def MonsterAddSignedEnum(builder, signedEnum): builder.PrependInt8Slot(48, signedEnum, -1)
return StartVectorOfStrongReferrablesVector(builder, numElems) def AddSignedEnum(builder, signedEnum):
def AddCoOwningReference(builder, coOwningReference): builder.PrependUint64Slot(39, coOwningReference, 0) return MonsterAddSignedEnum(builder, signedEnum)
def MonsterAddCoOwningReference(builder, coOwningReference): def MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer): builder.PrependUOffsetTRelativeSlot(49, flatbuffers.number_types.UOffsetTFlags.py_type(testrequirednestedflatbuffer), 0)
"""This method is deprecated. Please switch to AddCoOwningReference.""" def AddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer):
return AddCoOwningReference(builder, coOwningReference) return MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer)
def AddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences): builder.PrependUOffsetTRelativeSlot(40, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfCoOwningReferences), 0) def MonsterStartTestrequirednestedflatbufferVector(builder, numElems): return builder.StartVector(1, numElems, 1)
def MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences): def StartTestrequirednestedflatbufferVector(builder, numElems):
"""This method is deprecated. Please switch to AddVectorOfCoOwningReferences.""" return MonsterStartTestrequirednestedflatbufferVector(builder, numElems)
return AddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences) def MonsterMakeTestrequirednestedflatbufferVectorFromBytes(builder, bytes):
def StartVectorOfCoOwningReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
def MonsterStartVectorOfCoOwningReferencesVector(builder, numElems):
"""This method is deprecated. Please switch to Start."""
return StartVectorOfCoOwningReferencesVector(builder, numElems)
def AddNonOwningReference(builder, nonOwningReference): builder.PrependUint64Slot(41, nonOwningReference, 0)
def MonsterAddNonOwningReference(builder, nonOwningReference):
"""This method is deprecated. Please switch to AddNonOwningReference."""
return AddNonOwningReference(builder, nonOwningReference)
def AddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences): builder.PrependUOffsetTRelativeSlot(42, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfNonOwningReferences), 0)
def MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences):
"""This method is deprecated. Please switch to AddVectorOfNonOwningReferences."""
return AddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences)
def StartVectorOfNonOwningReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
def MonsterStartVectorOfNonOwningReferencesVector(builder, numElems):
"""This method is deprecated. Please switch to Start."""
return StartVectorOfNonOwningReferencesVector(builder, numElems)
def AddAnyUniqueType(builder, anyUniqueType): builder.PrependUint8Slot(43, anyUniqueType, 0)
def MonsterAddAnyUniqueType(builder, anyUniqueType):
"""This method is deprecated. Please switch to AddAnyUniqueType."""
return AddAnyUniqueType(builder, anyUniqueType)
def AddAnyUnique(builder, anyUnique): builder.PrependUOffsetTRelativeSlot(44, flatbuffers.number_types.UOffsetTFlags.py_type(anyUnique), 0)
def MonsterAddAnyUnique(builder, anyUnique):
"""This method is deprecated. Please switch to AddAnyUnique."""
return AddAnyUnique(builder, anyUnique)
def AddAnyAmbiguousType(builder, anyAmbiguousType): builder.PrependUint8Slot(45, anyAmbiguousType, 0)
def MonsterAddAnyAmbiguousType(builder, anyAmbiguousType):
"""This method is deprecated. Please switch to AddAnyAmbiguousType."""
return AddAnyAmbiguousType(builder, anyAmbiguousType)
def AddAnyAmbiguous(builder, anyAmbiguous): builder.PrependUOffsetTRelativeSlot(46, flatbuffers.number_types.UOffsetTFlags.py_type(anyAmbiguous), 0)
def MonsterAddAnyAmbiguous(builder, anyAmbiguous):
"""This method is deprecated. Please switch to AddAnyAmbiguous."""
return AddAnyAmbiguous(builder, anyAmbiguous)
def AddVectorOfEnums(builder, vectorOfEnums): builder.PrependUOffsetTRelativeSlot(47, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfEnums), 0)
def MonsterAddVectorOfEnums(builder, vectorOfEnums):
"""This method is deprecated. Please switch to AddVectorOfEnums."""
return AddVectorOfEnums(builder, vectorOfEnums)
def StartVectorOfEnumsVector(builder, numElems): return builder.StartVector(1, numElems, 1)
def MonsterStartVectorOfEnumsVector(builder, numElems):
"""This method is deprecated. Please switch to Start."""
return StartVectorOfEnumsVector(builder, numElems)
def AddSignedEnum(builder, signedEnum): builder.PrependInt8Slot(48, signedEnum, -1)
def MonsterAddSignedEnum(builder, signedEnum):
"""This method is deprecated. Please switch to AddSignedEnum."""
return AddSignedEnum(builder, signedEnum)
def AddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer): builder.PrependUOffsetTRelativeSlot(49, flatbuffers.number_types.UOffsetTFlags.py_type(testrequirednestedflatbuffer), 0)
def MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer):
"""This method is deprecated. Please switch to AddTestrequirednestedflatbuffer."""
return AddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer)
def StartTestrequirednestedflatbufferVector(builder, numElems): return builder.StartVector(1, numElems, 1)
def MonsterStartTestrequirednestedflatbufferVector(builder, numElems):
"""This method is deprecated. Please switch to Start."""
return StartTestrequirednestedflatbufferVector(builder, numElems)
def MakeVectorFromBytes(builder, bytes):
builder.StartVector(1, len(bytes), 1) builder.StartVector(1, len(bytes), 1)
builder.head = builder.head - len(bytes) builder.head = builder.head - len(bytes)
builder.Bytes[builder.head : builder.head + len(bytes)] = bytes builder.Bytes[builder.head : builder.head + len(bytes)] = bytes
return builder.EndVector() return builder.EndVector()
def MakeTestrequirednestedflatbufferVectorFromBytes(builder, bytes): def MakeTestrequirednestedflatbufferVectorFromBytes(builder, bytes):
builder.StartVector(1, len(bytes), 1) return MonsterMakeTestrequirednestedflatbufferVectorFromBytes(builder, bytes)
builder.head = builder.head - len(bytes) def MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables): builder.PrependUOffsetTRelativeSlot(50, flatbuffers.number_types.UOffsetTFlags.py_type(scalarKeySortedTables), 0)
builder.Bytes[builder.head : builder.head + len(bytes)] = bytes def AddScalarKeySortedTables(builder, scalarKeySortedTables):
return builder.EndVector() return MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables)
def AddScalarKeySortedTables(builder, scalarKeySortedTables): builder.PrependUOffsetTRelativeSlot(50, flatbuffers.number_types.UOffsetTFlags.py_type(scalarKeySortedTables), 0) def MonsterStartScalarKeySortedTablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
def MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables): def StartScalarKeySortedTablesVector(builder, numElems):
"""This method is deprecated. Please switch to AddScalarKeySortedTables.""" return MonsterStartScalarKeySortedTablesVector(builder, numElems)
return AddScalarKeySortedTables(builder, scalarKeySortedTables) def MonsterEnd(builder): return builder.EndObject()
def StartScalarKeySortedTablesVector(builder, numElems): return builder.StartVector(4, numElems, 4) def End(builder):
def MonsterStartScalarKeySortedTablesVector(builder, numElems): return MonsterEnd(builder)
"""This method is deprecated. Please switch to Start."""
return StartScalarKeySortedTablesVector(builder, numElems)
def End(builder): return builder.EndObject()
def MonsterEnd(builder):
"""This method is deprecated. Please switch to End."""
return End(builder)
import MyGame.Example.Ability import MyGame.Example.Ability
import MyGame.Example.Any import MyGame.Example.Any
import MyGame.Example.AnyAmbiguousAliases import MyGame.Example.AnyAmbiguousAliases
@@ -1370,14 +1292,14 @@ class MonsterT(object):
if np is not None and type(self.inventory) is np.ndarray: if np is not None and type(self.inventory) is np.ndarray:
inventory = builder.CreateNumpyVector(self.inventory) inventory = builder.CreateNumpyVector(self.inventory)
else: else:
StartInventoryVector(builder, len(self.inventory)) MonsterStartInventoryVector(builder, len(self.inventory))
for i in reversed(range(len(self.inventory))): for i in reversed(range(len(self.inventory))):
builder.PrependUint8(self.inventory[i]) builder.PrependUint8(self.inventory[i])
inventory = builder.EndVector() inventory = builder.EndVector()
if self.test is not None: if self.test is not None:
test = self.test.Pack(builder) test = self.test.Pack(builder)
if self.test4 is not None: if self.test4 is not None:
StartTest4Vector(builder, len(self.test4)) MonsterStartTest4Vector(builder, len(self.test4))
for i in reversed(range(len(self.test4))): for i in reversed(range(len(self.test4))):
self.test4[i].Pack(builder) self.test4[i].Pack(builder)
test4 = builder.EndVector() test4 = builder.EndVector()
@@ -1385,7 +1307,7 @@ class MonsterT(object):
testarrayofstringlist = [] testarrayofstringlist = []
for i in range(len(self.testarrayofstring)): for i in range(len(self.testarrayofstring)):
testarrayofstringlist.append(builder.CreateString(self.testarrayofstring[i])) 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))): for i in reversed(range(len(self.testarrayofstring))):
builder.PrependUOffsetTRelative(testarrayofstringlist[i]) builder.PrependUOffsetTRelative(testarrayofstringlist[i])
testarrayofstring = builder.EndVector() testarrayofstring = builder.EndVector()
@@ -1393,7 +1315,7 @@ class MonsterT(object):
testarrayoftableslist = [] testarrayoftableslist = []
for i in range(len(self.testarrayoftables)): for i in range(len(self.testarrayoftables)):
testarrayoftableslist.append(self.testarrayoftables[i].Pack(builder)) 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))): for i in reversed(range(len(self.testarrayoftables))):
builder.PrependUOffsetTRelative(testarrayoftableslist[i]) builder.PrependUOffsetTRelative(testarrayoftableslist[i])
testarrayoftables = builder.EndVector() testarrayoftables = builder.EndVector()
@@ -1403,7 +1325,7 @@ class MonsterT(object):
if np is not None and type(self.testnestedflatbuffer) is np.ndarray: if np is not None and type(self.testnestedflatbuffer) is np.ndarray:
testnestedflatbuffer = builder.CreateNumpyVector(self.testnestedflatbuffer) testnestedflatbuffer = builder.CreateNumpyVector(self.testnestedflatbuffer)
else: else:
StartTestnestedflatbufferVector(builder, len(self.testnestedflatbuffer)) MonsterStartTestnestedflatbufferVector(builder, len(self.testnestedflatbuffer))
for i in reversed(range(len(self.testnestedflatbuffer))): for i in reversed(range(len(self.testnestedflatbuffer))):
builder.PrependUint8(self.testnestedflatbuffer[i]) builder.PrependUint8(self.testnestedflatbuffer[i])
testnestedflatbuffer = builder.EndVector() testnestedflatbuffer = builder.EndVector()
@@ -1413,7 +1335,7 @@ class MonsterT(object):
if np is not None and type(self.testarrayofbools) is np.ndarray: if np is not None and type(self.testarrayofbools) is np.ndarray:
testarrayofbools = builder.CreateNumpyVector(self.testarrayofbools) testarrayofbools = builder.CreateNumpyVector(self.testarrayofbools)
else: else:
StartTestarrayofboolsVector(builder, len(self.testarrayofbools)) MonsterStartTestarrayofboolsVector(builder, len(self.testarrayofbools))
for i in reversed(range(len(self.testarrayofbools))): for i in reversed(range(len(self.testarrayofbools))):
builder.PrependBool(self.testarrayofbools[i]) builder.PrependBool(self.testarrayofbools[i])
testarrayofbools = builder.EndVector() testarrayofbools = builder.EndVector()
@@ -1421,12 +1343,12 @@ class MonsterT(object):
testarrayofstring2list = [] testarrayofstring2list = []
for i in range(len(self.testarrayofstring2)): for i in range(len(self.testarrayofstring2)):
testarrayofstring2list.append(builder.CreateString(self.testarrayofstring2[i])) 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))): for i in reversed(range(len(self.testarrayofstring2))):
builder.PrependUOffsetTRelative(testarrayofstring2list[i]) builder.PrependUOffsetTRelative(testarrayofstring2list[i])
testarrayofstring2 = builder.EndVector() testarrayofstring2 = builder.EndVector()
if self.testarrayofsortedstruct is not None: if self.testarrayofsortedstruct is not None:
StartTestarrayofsortedstructVector(builder, len(self.testarrayofsortedstruct)) MonsterStartTestarrayofsortedstructVector(builder, len(self.testarrayofsortedstruct))
for i in reversed(range(len(self.testarrayofsortedstruct))): for i in reversed(range(len(self.testarrayofsortedstruct))):
self.testarrayofsortedstruct[i].Pack(builder) self.testarrayofsortedstruct[i].Pack(builder)
testarrayofsortedstruct = builder.EndVector() testarrayofsortedstruct = builder.EndVector()
@@ -1434,12 +1356,12 @@ class MonsterT(object):
if np is not None and type(self.flex) is np.ndarray: if np is not None and type(self.flex) is np.ndarray:
flex = builder.CreateNumpyVector(self.flex) flex = builder.CreateNumpyVector(self.flex)
else: else:
StartFlexVector(builder, len(self.flex)) MonsterStartFlexVector(builder, len(self.flex))
for i in reversed(range(len(self.flex))): for i in reversed(range(len(self.flex))):
builder.PrependUint8(self.flex[i]) builder.PrependUint8(self.flex[i])
flex = builder.EndVector() flex = builder.EndVector()
if self.test5 is not None: if self.test5 is not None:
StartTest5Vector(builder, len(self.test5)) MonsterStartTest5Vector(builder, len(self.test5))
for i in reversed(range(len(self.test5))): for i in reversed(range(len(self.test5))):
self.test5[i].Pack(builder) self.test5[i].Pack(builder)
test5 = builder.EndVector() test5 = builder.EndVector()
@@ -1447,7 +1369,7 @@ class MonsterT(object):
if np is not None and type(self.vectorOfLongs) is np.ndarray: if np is not None and type(self.vectorOfLongs) is np.ndarray:
vectorOfLongs = builder.CreateNumpyVector(self.vectorOfLongs) vectorOfLongs = builder.CreateNumpyVector(self.vectorOfLongs)
else: else:
StartVectorOfLongsVector(builder, len(self.vectorOfLongs)) MonsterStartVectorOfLongsVector(builder, len(self.vectorOfLongs))
for i in reversed(range(len(self.vectorOfLongs))): for i in reversed(range(len(self.vectorOfLongs))):
builder.PrependInt64(self.vectorOfLongs[i]) builder.PrependInt64(self.vectorOfLongs[i])
vectorOfLongs = builder.EndVector() vectorOfLongs = builder.EndVector()
@@ -1455,7 +1377,7 @@ class MonsterT(object):
if np is not None and type(self.vectorOfDoubles) is np.ndarray: if np is not None and type(self.vectorOfDoubles) is np.ndarray:
vectorOfDoubles = builder.CreateNumpyVector(self.vectorOfDoubles) vectorOfDoubles = builder.CreateNumpyVector(self.vectorOfDoubles)
else: else:
StartVectorOfDoublesVector(builder, len(self.vectorOfDoubles)) MonsterStartVectorOfDoublesVector(builder, len(self.vectorOfDoubles))
for i in reversed(range(len(self.vectorOfDoubles))): for i in reversed(range(len(self.vectorOfDoubles))):
builder.PrependFloat64(self.vectorOfDoubles[i]) builder.PrependFloat64(self.vectorOfDoubles[i])
vectorOfDoubles = builder.EndVector() vectorOfDoubles = builder.EndVector()
@@ -1465,7 +1387,7 @@ class MonsterT(object):
vectorOfReferrableslist = [] vectorOfReferrableslist = []
for i in range(len(self.vectorOfReferrables)): for i in range(len(self.vectorOfReferrables)):
vectorOfReferrableslist.append(self.vectorOfReferrables[i].Pack(builder)) 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))): for i in reversed(range(len(self.vectorOfReferrables))):
builder.PrependUOffsetTRelative(vectorOfReferrableslist[i]) builder.PrependUOffsetTRelative(vectorOfReferrableslist[i])
vectorOfReferrables = builder.EndVector() vectorOfReferrables = builder.EndVector()
@@ -1473,7 +1395,7 @@ class MonsterT(object):
if np is not None and type(self.vectorOfWeakReferences) is np.ndarray: if np is not None and type(self.vectorOfWeakReferences) is np.ndarray:
vectorOfWeakReferences = builder.CreateNumpyVector(self.vectorOfWeakReferences) vectorOfWeakReferences = builder.CreateNumpyVector(self.vectorOfWeakReferences)
else: else:
StartVectorOfWeakReferencesVector(builder, len(self.vectorOfWeakReferences)) MonsterStartVectorOfWeakReferencesVector(builder, len(self.vectorOfWeakReferences))
for i in reversed(range(len(self.vectorOfWeakReferences))): for i in reversed(range(len(self.vectorOfWeakReferences))):
builder.PrependUint64(self.vectorOfWeakReferences[i]) builder.PrependUint64(self.vectorOfWeakReferences[i])
vectorOfWeakReferences = builder.EndVector() vectorOfWeakReferences = builder.EndVector()
@@ -1481,7 +1403,7 @@ class MonsterT(object):
vectorOfStrongReferrableslist = [] vectorOfStrongReferrableslist = []
for i in range(len(self.vectorOfStrongReferrables)): for i in range(len(self.vectorOfStrongReferrables)):
vectorOfStrongReferrableslist.append(self.vectorOfStrongReferrables[i].Pack(builder)) 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))): for i in reversed(range(len(self.vectorOfStrongReferrables))):
builder.PrependUOffsetTRelative(vectorOfStrongReferrableslist[i]) builder.PrependUOffsetTRelative(vectorOfStrongReferrableslist[i])
vectorOfStrongReferrables = builder.EndVector() vectorOfStrongReferrables = builder.EndVector()
@@ -1489,7 +1411,7 @@ class MonsterT(object):
if np is not None and type(self.vectorOfCoOwningReferences) is np.ndarray: if np is not None and type(self.vectorOfCoOwningReferences) is np.ndarray:
vectorOfCoOwningReferences = builder.CreateNumpyVector(self.vectorOfCoOwningReferences) vectorOfCoOwningReferences = builder.CreateNumpyVector(self.vectorOfCoOwningReferences)
else: else:
StartVectorOfCoOwningReferencesVector(builder, len(self.vectorOfCoOwningReferences)) MonsterStartVectorOfCoOwningReferencesVector(builder, len(self.vectorOfCoOwningReferences))
for i in reversed(range(len(self.vectorOfCoOwningReferences))): for i in reversed(range(len(self.vectorOfCoOwningReferences))):
builder.PrependUint64(self.vectorOfCoOwningReferences[i]) builder.PrependUint64(self.vectorOfCoOwningReferences[i])
vectorOfCoOwningReferences = builder.EndVector() vectorOfCoOwningReferences = builder.EndVector()
@@ -1497,7 +1419,7 @@ class MonsterT(object):
if np is not None and type(self.vectorOfNonOwningReferences) is np.ndarray: if np is not None and type(self.vectorOfNonOwningReferences) is np.ndarray:
vectorOfNonOwningReferences = builder.CreateNumpyVector(self.vectorOfNonOwningReferences) vectorOfNonOwningReferences = builder.CreateNumpyVector(self.vectorOfNonOwningReferences)
else: else:
StartVectorOfNonOwningReferencesVector(builder, len(self.vectorOfNonOwningReferences)) MonsterStartVectorOfNonOwningReferencesVector(builder, len(self.vectorOfNonOwningReferences))
for i in reversed(range(len(self.vectorOfNonOwningReferences))): for i in reversed(range(len(self.vectorOfNonOwningReferences))):
builder.PrependUint64(self.vectorOfNonOwningReferences[i]) builder.PrependUint64(self.vectorOfNonOwningReferences[i])
vectorOfNonOwningReferences = builder.EndVector() vectorOfNonOwningReferences = builder.EndVector()
@@ -1509,7 +1431,7 @@ class MonsterT(object):
if np is not None and type(self.vectorOfEnums) is np.ndarray: if np is not None and type(self.vectorOfEnums) is np.ndarray:
vectorOfEnums = builder.CreateNumpyVector(self.vectorOfEnums) vectorOfEnums = builder.CreateNumpyVector(self.vectorOfEnums)
else: else:
StartVectorOfEnumsVector(builder, len(self.vectorOfEnums)) MonsterStartVectorOfEnumsVector(builder, len(self.vectorOfEnums))
for i in reversed(range(len(self.vectorOfEnums))): for i in reversed(range(len(self.vectorOfEnums))):
builder.PrependUint8(self.vectorOfEnums[i]) builder.PrependUint8(self.vectorOfEnums[i])
vectorOfEnums = builder.EndVector() vectorOfEnums = builder.EndVector()
@@ -1517,7 +1439,7 @@ class MonsterT(object):
if np is not None and type(self.testrequirednestedflatbuffer) is np.ndarray: if np is not None and type(self.testrequirednestedflatbuffer) is np.ndarray:
testrequirednestedflatbuffer = builder.CreateNumpyVector(self.testrequirednestedflatbuffer) testrequirednestedflatbuffer = builder.CreateNumpyVector(self.testrequirednestedflatbuffer)
else: else:
StartTestrequirednestedflatbufferVector(builder, len(self.testrequirednestedflatbuffer)) MonsterStartTestrequirednestedflatbufferVector(builder, len(self.testrequirednestedflatbuffer))
for i in reversed(range(len(self.testrequirednestedflatbuffer))): for i in reversed(range(len(self.testrequirednestedflatbuffer))):
builder.PrependUint8(self.testrequirednestedflatbuffer[i]) builder.PrependUint8(self.testrequirednestedflatbuffer[i])
testrequirednestedflatbuffer = builder.EndVector() testrequirednestedflatbuffer = builder.EndVector()
@@ -1525,89 +1447,89 @@ class MonsterT(object):
scalarKeySortedTableslist = [] scalarKeySortedTableslist = []
for i in range(len(self.scalarKeySortedTables)): for i in range(len(self.scalarKeySortedTables)):
scalarKeySortedTableslist.append(self.scalarKeySortedTables[i].Pack(builder)) 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))): for i in reversed(range(len(self.scalarKeySortedTables))):
builder.PrependUOffsetTRelative(scalarKeySortedTableslist[i]) builder.PrependUOffsetTRelative(scalarKeySortedTableslist[i])
scalarKeySortedTables = builder.EndVector() scalarKeySortedTables = builder.EndVector()
Start(builder) MonsterStart(builder)
if self.pos is not None: if self.pos is not None:
pos = self.pos.Pack(builder) pos = self.pos.Pack(builder)
AddPos(builder, pos) MonsterAddPos(builder, pos)
AddMana(builder, self.mana) MonsterAddMana(builder, self.mana)
AddHp(builder, self.hp) MonsterAddHp(builder, self.hp)
if self.name is not None: if self.name is not None:
AddName(builder, name) MonsterAddName(builder, name)
if self.inventory is not None: if self.inventory is not None:
AddInventory(builder, inventory) MonsterAddInventory(builder, inventory)
AddColor(builder, self.color) MonsterAddColor(builder, self.color)
AddTestType(builder, self.testType) MonsterAddTestType(builder, self.testType)
if self.test is not None: if self.test is not None:
AddTest(builder, test) MonsterAddTest(builder, test)
if self.test4 is not None: if self.test4 is not None:
AddTest4(builder, test4) MonsterAddTest4(builder, test4)
if self.testarrayofstring is not None: if self.testarrayofstring is not None:
AddTestarrayofstring(builder, testarrayofstring) MonsterAddTestarrayofstring(builder, testarrayofstring)
if self.testarrayoftables is not None: if self.testarrayoftables is not None:
AddTestarrayoftables(builder, testarrayoftables) MonsterAddTestarrayoftables(builder, testarrayoftables)
if self.enemy is not None: if self.enemy is not None:
AddEnemy(builder, enemy) MonsterAddEnemy(builder, enemy)
if self.testnestedflatbuffer is not None: if self.testnestedflatbuffer is not None:
AddTestnestedflatbuffer(builder, testnestedflatbuffer) MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer)
if self.testempty is not None: if self.testempty is not None:
AddTestempty(builder, testempty) MonsterAddTestempty(builder, testempty)
AddTestbool(builder, self.testbool) MonsterAddTestbool(builder, self.testbool)
AddTesthashs32Fnv1(builder, self.testhashs32Fnv1) MonsterAddTesthashs32Fnv1(builder, self.testhashs32Fnv1)
AddTesthashu32Fnv1(builder, self.testhashu32Fnv1) MonsterAddTesthashu32Fnv1(builder, self.testhashu32Fnv1)
AddTesthashs64Fnv1(builder, self.testhashs64Fnv1) MonsterAddTesthashs64Fnv1(builder, self.testhashs64Fnv1)
AddTesthashu64Fnv1(builder, self.testhashu64Fnv1) MonsterAddTesthashu64Fnv1(builder, self.testhashu64Fnv1)
AddTesthashs32Fnv1a(builder, self.testhashs32Fnv1a) MonsterAddTesthashs32Fnv1a(builder, self.testhashs32Fnv1a)
AddTesthashu32Fnv1a(builder, self.testhashu32Fnv1a) MonsterAddTesthashu32Fnv1a(builder, self.testhashu32Fnv1a)
AddTesthashs64Fnv1a(builder, self.testhashs64Fnv1a) MonsterAddTesthashs64Fnv1a(builder, self.testhashs64Fnv1a)
AddTesthashu64Fnv1a(builder, self.testhashu64Fnv1a) MonsterAddTesthashu64Fnv1a(builder, self.testhashu64Fnv1a)
if self.testarrayofbools is not None: if self.testarrayofbools is not None:
AddTestarrayofbools(builder, testarrayofbools) MonsterAddTestarrayofbools(builder, testarrayofbools)
AddTestf(builder, self.testf) MonsterAddTestf(builder, self.testf)
AddTestf2(builder, self.testf2) MonsterAddTestf2(builder, self.testf2)
AddTestf3(builder, self.testf3) MonsterAddTestf3(builder, self.testf3)
if self.testarrayofstring2 is not None: if self.testarrayofstring2 is not None:
AddTestarrayofstring2(builder, testarrayofstring2) MonsterAddTestarrayofstring2(builder, testarrayofstring2)
if self.testarrayofsortedstruct is not None: if self.testarrayofsortedstruct is not None:
AddTestarrayofsortedstruct(builder, testarrayofsortedstruct) MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct)
if self.flex is not None: if self.flex is not None:
AddFlex(builder, flex) MonsterAddFlex(builder, flex)
if self.test5 is not None: if self.test5 is not None:
AddTest5(builder, test5) MonsterAddTest5(builder, test5)
if self.vectorOfLongs is not None: if self.vectorOfLongs is not None:
AddVectorOfLongs(builder, vectorOfLongs) MonsterAddVectorOfLongs(builder, vectorOfLongs)
if self.vectorOfDoubles is not None: if self.vectorOfDoubles is not None:
AddVectorOfDoubles(builder, vectorOfDoubles) MonsterAddVectorOfDoubles(builder, vectorOfDoubles)
if self.parentNamespaceTest is not None: if self.parentNamespaceTest is not None:
AddParentNamespaceTest(builder, parentNamespaceTest) MonsterAddParentNamespaceTest(builder, parentNamespaceTest)
if self.vectorOfReferrables is not None: if self.vectorOfReferrables is not None:
AddVectorOfReferrables(builder, vectorOfReferrables) MonsterAddVectorOfReferrables(builder, vectorOfReferrables)
AddSingleWeakReference(builder, self.singleWeakReference) MonsterAddSingleWeakReference(builder, self.singleWeakReference)
if self.vectorOfWeakReferences is not None: if self.vectorOfWeakReferences is not None:
AddVectorOfWeakReferences(builder, vectorOfWeakReferences) MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences)
if self.vectorOfStrongReferrables is not None: if self.vectorOfStrongReferrables is not None:
AddVectorOfStrongReferrables(builder, vectorOfStrongReferrables) MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables)
AddCoOwningReference(builder, self.coOwningReference) MonsterAddCoOwningReference(builder, self.coOwningReference)
if self.vectorOfCoOwningReferences is not None: if self.vectorOfCoOwningReferences is not None:
AddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences) MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences)
AddNonOwningReference(builder, self.nonOwningReference) MonsterAddNonOwningReference(builder, self.nonOwningReference)
if self.vectorOfNonOwningReferences is not None: if self.vectorOfNonOwningReferences is not None:
AddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences) MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences)
AddAnyUniqueType(builder, self.anyUniqueType) MonsterAddAnyUniqueType(builder, self.anyUniqueType)
if self.anyUnique is not None: if self.anyUnique is not None:
AddAnyUnique(builder, anyUnique) MonsterAddAnyUnique(builder, anyUnique)
AddAnyAmbiguousType(builder, self.anyAmbiguousType) MonsterAddAnyAmbiguousType(builder, self.anyAmbiguousType)
if self.anyAmbiguous is not None: if self.anyAmbiguous is not None:
AddAnyAmbiguous(builder, anyAmbiguous) MonsterAddAnyAmbiguous(builder, anyAmbiguous)
if self.vectorOfEnums is not None: if self.vectorOfEnums is not None:
AddVectorOfEnums(builder, vectorOfEnums) MonsterAddVectorOfEnums(builder, vectorOfEnums)
AddSignedEnum(builder, self.signedEnum) MonsterAddSignedEnum(builder, self.signedEnum)
if self.testrequirednestedflatbuffer is not None: if self.testrequirednestedflatbuffer is not None:
AddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer) MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer)
if self.scalarKeySortedTables is not None: if self.scalarKeySortedTables is not None:
AddScalarKeySortedTables(builder, scalarKeySortedTables) MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables)
monster = End(builder) monster = MonsterEnd(builder)
return monster 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 self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
return 0 return 0
def Start(builder): builder.StartObject(1) def ReferrableStart(builder): builder.StartObject(1)
def ReferrableStart(builder): def Start(builder):
"""This method is deprecated. Please switch to Start.""" return ReferrableStart(builder)
return Start(builder) def ReferrableAddId(builder, id): builder.PrependUint64Slot(0, id, 0)
def AddId(builder, id): builder.PrependUint64Slot(0, id, 0) def AddId(builder, id):
def ReferrableAddId(builder, id): return ReferrableAddId(builder, id)
"""This method is deprecated. Please switch to AddId.""" def ReferrableEnd(builder): return builder.EndObject()
return AddId(builder, id) def End(builder):
def End(builder): return builder.EndObject() return ReferrableEnd(builder)
def ReferrableEnd(builder):
"""This method is deprecated. Please switch to End."""
return End(builder)
class ReferrableT(object): class ReferrableT(object):
@@ -74,7 +71,7 @@ class ReferrableT(object):
# ReferrableT # ReferrableT
def Pack(self, builder): def Pack(self, builder):
Start(builder) ReferrableStart(builder)
AddId(builder, self.id) ReferrableAddId(builder, self.id)
referrable = End(builder) referrable = ReferrableEnd(builder)
return referrable 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 self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
return 0 return 0
def Start(builder): builder.StartObject(3) def StatStart(builder): builder.StartObject(3)
def StatStart(builder): def Start(builder):
"""This method is deprecated. Please switch to Start.""" return StatStart(builder)
return Start(builder) def StatAddId(builder, id): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(id), 0)
def AddId(builder, id): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(id), 0) def AddId(builder, id):
def StatAddId(builder, id): return StatAddId(builder, id)
"""This method is deprecated. Please switch to AddId.""" def StatAddVal(builder, val): builder.PrependInt64Slot(1, val, 0)
return AddId(builder, id) def AddVal(builder, val):
def AddVal(builder, val): builder.PrependInt64Slot(1, val, 0) return StatAddVal(builder, val)
def StatAddVal(builder, val): def StatAddCount(builder, count): builder.PrependUint16Slot(2, count, 0)
"""This method is deprecated. Please switch to AddVal.""" def AddCount(builder, count):
return AddVal(builder, val) return StatAddCount(builder, count)
def AddCount(builder, count): builder.PrependUint16Slot(2, count, 0) def StatEnd(builder): return builder.EndObject()
def StatAddCount(builder, count): def End(builder):
"""This method is deprecated. Please switch to AddCount.""" return StatEnd(builder)
return AddCount(builder, count)
def End(builder): return builder.EndObject()
def StatEnd(builder):
"""This method is deprecated. Please switch to End."""
return End(builder)
class StatT(object): class StatT(object):
@@ -102,10 +97,10 @@ class StatT(object):
def Pack(self, builder): def Pack(self, builder):
if self.id is not None: if self.id is not None:
id = builder.CreateString(self.id) id = builder.CreateString(self.id)
Start(builder) StatStart(builder)
if self.id is not None: if self.id is not None:
AddId(builder, id) StatAddId(builder, id)
AddVal(builder, self.val) StatAddVal(builder, self.val)
AddCount(builder, self.count) StatAddCount(builder, self.count)
stat = End(builder) stat = StatEnd(builder)
return stat 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 self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
return 2 return 2
def Start(builder): builder.StartObject(1) def TestSimpleTableWithEnumStart(builder): builder.StartObject(1)
def TestSimpleTableWithEnumStart(builder): def Start(builder):
"""This method is deprecated. Please switch to Start.""" return TestSimpleTableWithEnumStart(builder)
return Start(builder) def TestSimpleTableWithEnumAddColor(builder, color): builder.PrependUint8Slot(0, color, 2)
def AddColor(builder, color): builder.PrependUint8Slot(0, color, 2) def AddColor(builder, color):
def TestSimpleTableWithEnumAddColor(builder, color): return TestSimpleTableWithEnumAddColor(builder, color)
"""This method is deprecated. Please switch to AddColor.""" def TestSimpleTableWithEnumEnd(builder): return builder.EndObject()
return AddColor(builder, color) def End(builder):
def End(builder): return builder.EndObject() return TestSimpleTableWithEnumEnd(builder)
def TestSimpleTableWithEnumEnd(builder):
"""This method is deprecated. Please switch to End."""
return End(builder)
class TestSimpleTableWithEnumT(object): class TestSimpleTableWithEnumT(object):
@@ -74,7 +71,7 @@ class TestSimpleTableWithEnumT(object):
# TestSimpleTableWithEnumT # TestSimpleTableWithEnumT
def Pack(self, builder): def Pack(self, builder):
Start(builder) TestSimpleTableWithEnumStart(builder)
AddColor(builder, self.color) TestSimpleTableWithEnumAddColor(builder, self.color)
testSimpleTableWithEnum = End(builder) testSimpleTableWithEnum = TestSimpleTableWithEnumEnd(builder)
return testSimpleTableWithEnum 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)) o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
return o == 0 return o == 0
def Start(builder): builder.StartObject(12) def TypeAliasesStart(builder): builder.StartObject(12)
def TypeAliasesStart(builder): def Start(builder):
"""This method is deprecated. Please switch to Start.""" return TypeAliasesStart(builder)
return Start(builder) def TypeAliasesAddI8(builder, i8): builder.PrependInt8Slot(0, i8, 0)
def AddI8(builder, i8): builder.PrependInt8Slot(0, i8, 0) def AddI8(builder, i8):
def TypeAliasesAddI8(builder, i8): return TypeAliasesAddI8(builder, i8)
"""This method is deprecated. Please switch to AddI8.""" def TypeAliasesAddU8(builder, u8): builder.PrependUint8Slot(1, u8, 0)
return AddI8(builder, i8) def AddU8(builder, u8):
def AddU8(builder, u8): builder.PrependUint8Slot(1, u8, 0) return TypeAliasesAddU8(builder, u8)
def TypeAliasesAddU8(builder, u8): def TypeAliasesAddI16(builder, i16): builder.PrependInt16Slot(2, i16, 0)
"""This method is deprecated. Please switch to AddU8.""" def AddI16(builder, i16):
return AddU8(builder, u8) return TypeAliasesAddI16(builder, i16)
def AddI16(builder, i16): builder.PrependInt16Slot(2, i16, 0) def TypeAliasesAddU16(builder, u16): builder.PrependUint16Slot(3, u16, 0)
def TypeAliasesAddI16(builder, i16): def AddU16(builder, u16):
"""This method is deprecated. Please switch to AddI16.""" return TypeAliasesAddU16(builder, u16)
return AddI16(builder, i16) def TypeAliasesAddI32(builder, i32): builder.PrependInt32Slot(4, i32, 0)
def AddU16(builder, u16): builder.PrependUint16Slot(3, u16, 0) def AddI32(builder, i32):
def TypeAliasesAddU16(builder, u16): return TypeAliasesAddI32(builder, i32)
"""This method is deprecated. Please switch to AddU16.""" def TypeAliasesAddU32(builder, u32): builder.PrependUint32Slot(5, u32, 0)
return AddU16(builder, u16) def AddU32(builder, u32):
def AddI32(builder, i32): builder.PrependInt32Slot(4, i32, 0) return TypeAliasesAddU32(builder, u32)
def TypeAliasesAddI32(builder, i32): def TypeAliasesAddI64(builder, i64): builder.PrependInt64Slot(6, i64, 0)
"""This method is deprecated. Please switch to AddI32.""" def AddI64(builder, i64):
return AddI32(builder, i32) return TypeAliasesAddI64(builder, i64)
def AddU32(builder, u32): builder.PrependUint32Slot(5, u32, 0) def TypeAliasesAddU64(builder, u64): builder.PrependUint64Slot(7, u64, 0)
def TypeAliasesAddU32(builder, u32): def AddU64(builder, u64):
"""This method is deprecated. Please switch to AddU32.""" return TypeAliasesAddU64(builder, u64)
return AddU32(builder, u32) def TypeAliasesAddF32(builder, f32): builder.PrependFloat32Slot(8, f32, 0.0)
def AddI64(builder, i64): builder.PrependInt64Slot(6, i64, 0) def AddF32(builder, f32):
def TypeAliasesAddI64(builder, i64): return TypeAliasesAddF32(builder, f32)
"""This method is deprecated. Please switch to AddI64.""" def TypeAliasesAddF64(builder, f64): builder.PrependFloat64Slot(9, f64, 0.0)
return AddI64(builder, i64) def AddF64(builder, f64):
def AddU64(builder, u64): builder.PrependUint64Slot(7, u64, 0) return TypeAliasesAddF64(builder, f64)
def TypeAliasesAddU64(builder, u64): def TypeAliasesAddV8(builder, v8): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(v8), 0)
"""This method is deprecated. Please switch to AddU64.""" def AddV8(builder, v8):
return AddU64(builder, u64) return TypeAliasesAddV8(builder, v8)
def AddF32(builder, f32): builder.PrependFloat32Slot(8, f32, 0.0) def TypeAliasesStartV8Vector(builder, numElems): return builder.StartVector(1, numElems, 1)
def TypeAliasesAddF32(builder, f32): def StartV8Vector(builder, numElems):
"""This method is deprecated. Please switch to AddF32.""" return TypeAliasesStartV8Vector(builder, numElems)
return AddF32(builder, f32) def TypeAliasesAddVf64(builder, vf64): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(vf64), 0)
def AddF64(builder, f64): builder.PrependFloat64Slot(9, f64, 0.0) def AddVf64(builder, vf64):
def TypeAliasesAddF64(builder, f64): return TypeAliasesAddVf64(builder, vf64)
"""This method is deprecated. Please switch to AddF64.""" def TypeAliasesStartVf64Vector(builder, numElems): return builder.StartVector(8, numElems, 8)
return AddF64(builder, f64) def StartVf64Vector(builder, numElems):
def AddV8(builder, v8): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(v8), 0) return TypeAliasesStartVf64Vector(builder, numElems)
def TypeAliasesAddV8(builder, v8): def TypeAliasesEnd(builder): return builder.EndObject()
"""This method is deprecated. Please switch to AddV8.""" def End(builder):
return AddV8(builder, v8) return TypeAliasesEnd(builder)
def StartV8Vector(builder, numElems): return builder.StartVector(1, numElems, 1)
def TypeAliasesStartV8Vector(builder, numElems):
"""This method is deprecated. Please switch to Start."""
return StartV8Vector(builder, numElems)
def AddVf64(builder, vf64): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(vf64), 0)
def TypeAliasesAddVf64(builder, vf64):
"""This method is deprecated. Please switch to AddVf64."""
return AddVf64(builder, vf64)
def StartVf64Vector(builder, numElems): return builder.StartVector(8, numElems, 8)
def TypeAliasesStartVf64Vector(builder, numElems):
"""This method is deprecated. Please switch to Start."""
return StartVf64Vector(builder, numElems)
def End(builder): return builder.EndObject()
def TypeAliasesEnd(builder):
"""This method is deprecated. Please switch to End."""
return End(builder)
try: try:
from typing import List from typing import List
except: except:
@@ -285,7 +269,7 @@ class TypeAliasesT(object):
if np is not None and type(self.v8) is np.ndarray: if np is not None and type(self.v8) is np.ndarray:
v8 = builder.CreateNumpyVector(self.v8) v8 = builder.CreateNumpyVector(self.v8)
else: else:
StartV8Vector(builder, len(self.v8)) TypeAliasesStartV8Vector(builder, len(self.v8))
for i in reversed(range(len(self.v8))): for i in reversed(range(len(self.v8))):
builder.PrependByte(self.v8[i]) builder.PrependByte(self.v8[i])
v8 = builder.EndVector() v8 = builder.EndVector()
@@ -293,24 +277,24 @@ class TypeAliasesT(object):
if np is not None and type(self.vf64) is np.ndarray: if np is not None and type(self.vf64) is np.ndarray:
vf64 = builder.CreateNumpyVector(self.vf64) vf64 = builder.CreateNumpyVector(self.vf64)
else: else:
StartVf64Vector(builder, len(self.vf64)) TypeAliasesStartVf64Vector(builder, len(self.vf64))
for i in reversed(range(len(self.vf64))): for i in reversed(range(len(self.vf64))):
builder.PrependFloat64(self.vf64[i]) builder.PrependFloat64(self.vf64[i])
vf64 = builder.EndVector() vf64 = builder.EndVector()
Start(builder) TypeAliasesStart(builder)
AddI8(builder, self.i8) TypeAliasesAddI8(builder, self.i8)
AddU8(builder, self.u8) TypeAliasesAddU8(builder, self.u8)
AddI16(builder, self.i16) TypeAliasesAddI16(builder, self.i16)
AddU16(builder, self.u16) TypeAliasesAddU16(builder, self.u16)
AddI32(builder, self.i32) TypeAliasesAddI32(builder, self.i32)
AddU32(builder, self.u32) TypeAliasesAddU32(builder, self.u32)
AddI64(builder, self.i64) TypeAliasesAddI64(builder, self.i64)
AddU64(builder, self.u64) TypeAliasesAddU64(builder, self.u64)
AddF32(builder, self.f32) TypeAliasesAddF32(builder, self.f32)
AddF64(builder, self.f64) TypeAliasesAddF64(builder, self.f64)
if self.v8 is not None: if self.v8 is not None:
AddV8(builder, v8) TypeAliasesAddV8(builder, v8)
if self.vf64 is not None: if self.vf64 is not None:
AddVf64(builder, vf64) TypeAliasesAddVf64(builder, vf64)
typeAliases = End(builder) typeAliases = TypeAliasesEnd(builder)
return typeAliases return typeAliases

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

@@ -28,14 +28,12 @@ class Monster(object):
def Init(self, buf, pos): def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos) self._tab = flatbuffers.table.Table(buf, pos)
def Start(builder): builder.StartObject(0) def MonsterStart(builder): builder.StartObject(0)
def MonsterStart(builder): def Start(builder):
"""This method is deprecated. Please switch to Start.""" return MonsterStart(builder)
return Start(builder) def MonsterEnd(builder): return builder.EndObject()
def End(builder): return builder.EndObject() def End(builder):
def MonsterEnd(builder): return MonsterEnd(builder)
"""This method is deprecated. Please switch to End."""
return End(builder)
class MonsterT(object): class MonsterT(object):
@@ -62,6 +60,6 @@ class MonsterT(object):
# MonsterT # MonsterT
def Pack(self, builder): def Pack(self, builder):
Start(builder) MonsterStart(builder)
monster = End(builder) monster = MonsterEnd(builder)
return monster return monster

18
tests/MyGame/InParentNamespace.py
View File

@@ -28,14 +28,12 @@ class InParentNamespace(object):
def Init(self, buf, pos): def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos) self._tab = flatbuffers.table.Table(buf, pos)
def Start(builder): builder.StartObject(0) def InParentNamespaceStart(builder): builder.StartObject(0)
def InParentNamespaceStart(builder): def Start(builder):
"""This method is deprecated. Please switch to Start.""" return InParentNamespaceStart(builder)
return Start(builder) def InParentNamespaceEnd(builder): return builder.EndObject()
def End(builder): return builder.EndObject() def End(builder):
def InParentNamespaceEnd(builder): return InParentNamespaceEnd(builder)
"""This method is deprecated. Please switch to End."""
return End(builder)
class InParentNamespaceT(object): class InParentNamespaceT(object):
@@ -62,6 +60,6 @@ class InParentNamespaceT(object):
# InParentNamespaceT # InParentNamespaceT
def Pack(self, builder): def Pack(self, builder):
Start(builder) InParentNamespaceStart(builder)
inParentNamespace = End(builder) inParentNamespace = InParentNamespaceEnd(builder)
return inParentNamespace 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)) o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
return o == 0 return o == 0
def Start(builder): builder.StartObject(11) def MonsterExtraStart(builder): builder.StartObject(11)
def MonsterExtraStart(builder): def Start(builder):
"""This method is deprecated. Please switch to Start.""" return MonsterExtraStart(builder)
return Start(builder) def MonsterExtraAddD0(builder, d0): builder.PrependFloat64Slot(0, d0, float('nan'))
def AddD0(builder, d0): builder.PrependFloat64Slot(0, d0, float('nan')) def AddD0(builder, d0):
def MonsterExtraAddD0(builder, d0): return MonsterExtraAddD0(builder, d0)
"""This method is deprecated. Please switch to AddD0.""" def MonsterExtraAddD1(builder, d1): builder.PrependFloat64Slot(1, d1, float('nan'))
return AddD0(builder, d0) def AddD1(builder, d1):
def AddD1(builder, d1): builder.PrependFloat64Slot(1, d1, float('nan')) return MonsterExtraAddD1(builder, d1)
def MonsterExtraAddD1(builder, d1): def MonsterExtraAddD2(builder, d2): builder.PrependFloat64Slot(2, d2, float('inf'))
"""This method is deprecated. Please switch to AddD1.""" def AddD2(builder, d2):
return AddD1(builder, d1) return MonsterExtraAddD2(builder, d2)
def AddD2(builder, d2): builder.PrependFloat64Slot(2, d2, float('inf')) def MonsterExtraAddD3(builder, d3): builder.PrependFloat64Slot(3, d3, float('-inf'))
def MonsterExtraAddD2(builder, d2): def AddD3(builder, d3):
"""This method is deprecated. Please switch to AddD2.""" return MonsterExtraAddD3(builder, d3)
return AddD2(builder, d2) def MonsterExtraAddF0(builder, f0): builder.PrependFloat32Slot(4, f0, float('nan'))
def AddD3(builder, d3): builder.PrependFloat64Slot(3, d3, float('-inf')) def AddF0(builder, f0):
def MonsterExtraAddD3(builder, d3): return MonsterExtraAddF0(builder, f0)
"""This method is deprecated. Please switch to AddD3.""" def MonsterExtraAddF1(builder, f1): builder.PrependFloat32Slot(5, f1, float('nan'))
return AddD3(builder, d3) def AddF1(builder, f1):
def AddF0(builder, f0): builder.PrependFloat32Slot(4, f0, float('nan')) return MonsterExtraAddF1(builder, f1)
def MonsterExtraAddF0(builder, f0): def MonsterExtraAddF2(builder, f2): builder.PrependFloat32Slot(6, f2, float('inf'))
"""This method is deprecated. Please switch to AddF0.""" def AddF2(builder, f2):
return AddF0(builder, f0) return MonsterExtraAddF2(builder, f2)
def AddF1(builder, f1): builder.PrependFloat32Slot(5, f1, float('nan')) def MonsterExtraAddF3(builder, f3): builder.PrependFloat32Slot(7, f3, float('-inf'))
def MonsterExtraAddF1(builder, f1): def AddF3(builder, f3):
"""This method is deprecated. Please switch to AddF1.""" return MonsterExtraAddF3(builder, f3)
return AddF1(builder, f1) def MonsterExtraAddDvec(builder, dvec): builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(dvec), 0)
def AddF2(builder, f2): builder.PrependFloat32Slot(6, f2, float('inf')) def AddDvec(builder, dvec):
def MonsterExtraAddF2(builder, f2): return MonsterExtraAddDvec(builder, dvec)
"""This method is deprecated. Please switch to AddF2.""" def MonsterExtraStartDvecVector(builder, numElems): return builder.StartVector(8, numElems, 8)
return AddF2(builder, f2) def StartDvecVector(builder, numElems):
def AddF3(builder, f3): builder.PrependFloat32Slot(7, f3, float('-inf')) return MonsterExtraStartDvecVector(builder, numElems)
def MonsterExtraAddF3(builder, f3): def MonsterExtraAddFvec(builder, fvec): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(fvec), 0)
"""This method is deprecated. Please switch to AddF3.""" def AddFvec(builder, fvec):
return AddF3(builder, f3) return MonsterExtraAddFvec(builder, fvec)
def AddDvec(builder, dvec): builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(dvec), 0) def MonsterExtraStartFvecVector(builder, numElems): return builder.StartVector(4, numElems, 4)
def MonsterExtraAddDvec(builder, dvec): def StartFvecVector(builder, numElems):
"""This method is deprecated. Please switch to AddDvec.""" return MonsterExtraStartFvecVector(builder, numElems)
return AddDvec(builder, dvec) def MonsterExtraEnd(builder): return builder.EndObject()
def StartDvecVector(builder, numElems): return builder.StartVector(8, numElems, 8) def End(builder):
def MonsterExtraStartDvecVector(builder, numElems): return MonsterExtraEnd(builder)
"""This method is deprecated. Please switch to Start."""
return StartDvecVector(builder, numElems)
def AddFvec(builder, fvec): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(fvec), 0)
def MonsterExtraAddFvec(builder, fvec):
"""This method is deprecated. Please switch to AddFvec."""
return AddFvec(builder, fvec)
def StartFvecVector(builder, numElems): return builder.StartVector(4, numElems, 4)
def MonsterExtraStartFvecVector(builder, numElems):
"""This method is deprecated. Please switch to Start."""
return StartFvecVector(builder, numElems)
def End(builder): return builder.EndObject()
def MonsterExtraEnd(builder):
"""This method is deprecated. Please switch to End."""
return End(builder)
try: try:
from typing import List from typing import List
except: except:
@@ -259,7 +245,7 @@ class MonsterExtraT(object):
if np is not None and type(self.dvec) is np.ndarray: if np is not None and type(self.dvec) is np.ndarray:
dvec = builder.CreateNumpyVector(self.dvec) dvec = builder.CreateNumpyVector(self.dvec)
else: else:
StartDvecVector(builder, len(self.dvec)) MonsterExtraStartDvecVector(builder, len(self.dvec))
for i in reversed(range(len(self.dvec))): for i in reversed(range(len(self.dvec))):
builder.PrependFloat64(self.dvec[i]) builder.PrependFloat64(self.dvec[i])
dvec = builder.EndVector() dvec = builder.EndVector()
@@ -267,22 +253,22 @@ class MonsterExtraT(object):
if np is not None and type(self.fvec) is np.ndarray: if np is not None and type(self.fvec) is np.ndarray:
fvec = builder.CreateNumpyVector(self.fvec) fvec = builder.CreateNumpyVector(self.fvec)
else: else:
StartFvecVector(builder, len(self.fvec)) MonsterExtraStartFvecVector(builder, len(self.fvec))
for i in reversed(range(len(self.fvec))): for i in reversed(range(len(self.fvec))):
builder.PrependFloat32(self.fvec[i]) builder.PrependFloat32(self.fvec[i])
fvec = builder.EndVector() fvec = builder.EndVector()
Start(builder) MonsterExtraStart(builder)
AddD0(builder, self.d0) MonsterExtraAddD0(builder, self.d0)
AddD1(builder, self.d1) MonsterExtraAddD1(builder, self.d1)
AddD2(builder, self.d2) MonsterExtraAddD2(builder, self.d2)
AddD3(builder, self.d3) MonsterExtraAddD3(builder, self.d3)
AddF0(builder, self.f0) MonsterExtraAddF0(builder, self.f0)
AddF1(builder, self.f1) MonsterExtraAddF1(builder, self.f1)
AddF2(builder, self.f2) MonsterExtraAddF2(builder, self.f2)
AddF3(builder, self.f3) MonsterExtraAddF3(builder, self.f3)
if self.dvec is not None: if self.dvec is not None:
AddDvec(builder, dvec) MonsterExtraAddDvec(builder, dvec)
if self.fvec is not None: if self.fvec is not None:
AddFvec(builder, fvec) MonsterExtraAddFvec(builder, fvec)
monsterExtra = End(builder) monsterExtra = MonsterExtraEnd(builder)
return monsterExtra 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 self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
return 0 return 0
def Start(builder): builder.StartObject(1) def TableInNestedNSStart(builder): builder.StartObject(1)
def TableInNestedNSStart(builder): def Start(builder):
"""This method is deprecated. Please switch to Start.""" return TableInNestedNSStart(builder)
return Start(builder) def TableInNestedNSAddFoo(builder, foo): builder.PrependInt32Slot(0, foo, 0)
def AddFoo(builder, foo): builder.PrependInt32Slot(0, foo, 0) def AddFoo(builder, foo):
def TableInNestedNSAddFoo(builder, foo): return TableInNestedNSAddFoo(builder, foo)
"""This method is deprecated. Please switch to AddFoo.""" def TableInNestedNSEnd(builder): return builder.EndObject()
return AddFoo(builder, foo) def End(builder):
def End(builder): return builder.EndObject() return TableInNestedNSEnd(builder)
def TableInNestedNSEnd(builder):
"""This method is deprecated. Please switch to End."""
return End(builder)
class TableInNestedNST(object): class TableInNestedNST(object):
@@ -70,7 +67,7 @@ class TableInNestedNST(object):
# TableInNestedNST # TableInNestedNST
def Pack(self, builder): def Pack(self, builder):
Start(builder) TableInNestedNSStart(builder)
AddFoo(builder, self.foo) TableInNestedNSAddFoo(builder, self.foo)
tableInNestedNS = End(builder) tableInNestedNS = TableInNestedNSEnd(builder)
return tableInNestedNS return tableInNestedNS

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

@@ -34,18 +34,15 @@ class SecondTableInA(object):
return obj return obj
return None return None
def Start(builder): builder.StartObject(1) def SecondTableInAStart(builder): builder.StartObject(1)
def SecondTableInAStart(builder): def Start(builder):
"""This method is deprecated. Please switch to Start.""" return SecondTableInAStart(builder)
return Start(builder) def SecondTableInAAddReferToC(builder, referToC): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(referToC), 0)
def AddReferToC(builder, referToC): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(referToC), 0) def AddReferToC(builder, referToC):
def SecondTableInAAddReferToC(builder, referToC): return SecondTableInAAddReferToC(builder, referToC)
"""This method is deprecated. Please switch to AddReferToC.""" def SecondTableInAEnd(builder): return builder.EndObject()
return AddReferToC(builder, referToC) def End(builder):
def End(builder): return builder.EndObject() return SecondTableInAEnd(builder)
def SecondTableInAEnd(builder):
"""This method is deprecated. Please switch to End."""
return End(builder)
try: try:
from typing import Optional from typing import Optional
except: except:
@@ -80,8 +77,8 @@ class SecondTableInAT(object):
def Pack(self, builder): def Pack(self, builder):
if self.referToC is not None: if self.referToC is not None:
referToC = self.referToC.Pack(builder) referToC = self.referToC.Pack(builder)
Start(builder) SecondTableInAStart(builder)
if self.referToC is not None: if self.referToC is not None:
AddReferToC(builder, referToC) SecondTableInAAddReferToC(builder, referToC)
secondTableInA = End(builder) secondTableInA = SecondTableInAEnd(builder)
return secondTableInA return secondTableInA

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

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

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

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