diff --git a/grpc/examples/python/greeter/models/HelloReply.py b/grpc/examples/python/greeter/models/HelloReply.py index 95434dccf..301c84d9c 100644 --- a/grpc/examples/python/greeter/models/HelloReply.py +++ b/grpc/examples/python/greeter/models/HelloReply.py @@ -31,15 +31,12 @@ class HelloReply(object): return self._tab.String(o + self._tab.Pos) return None -def Start(builder): builder.StartObject(1) -def HelloReplyStart(builder): - """This method is deprecated. Please switch to Start.""" - return Start(builder) -def AddMessage(builder, message): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(message), 0) -def HelloReplyAddMessage(builder, message): - """This method is deprecated. Please switch to AddMessage.""" - return AddMessage(builder, message) -def End(builder): return builder.EndObject() -def HelloReplyEnd(builder): - """This method is deprecated. Please switch to End.""" - return End(builder) \ No newline at end of file +def HelloReplyStart(builder): builder.StartObject(1) +def Start(builder): + return HelloReplyStart(builder) +def HelloReplyAddMessage(builder, message): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(message), 0) +def AddMessage(builder, message): + return HelloReplyAddMessage(builder, message) +def HelloReplyEnd(builder): return builder.EndObject() +def End(builder): + return HelloReplyEnd(builder) \ No newline at end of file diff --git a/grpc/examples/python/greeter/models/HelloRequest.py b/grpc/examples/python/greeter/models/HelloRequest.py index 0263095ec..122568fd2 100644 --- a/grpc/examples/python/greeter/models/HelloRequest.py +++ b/grpc/examples/python/greeter/models/HelloRequest.py @@ -31,15 +31,12 @@ class HelloRequest(object): return self._tab.String(o + self._tab.Pos) return None -def Start(builder): builder.StartObject(1) -def HelloRequestStart(builder): - """This method is deprecated. Please switch to Start.""" - return Start(builder) -def AddName(builder, name): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) -def HelloRequestAddName(builder, name): - """This method is deprecated. Please switch to AddName.""" - return AddName(builder, name) -def End(builder): return builder.EndObject() -def HelloRequestEnd(builder): - """This method is deprecated. Please switch to End.""" - return End(builder) \ No newline at end of file +def HelloRequestStart(builder): builder.StartObject(1) +def Start(builder): + return HelloRequestStart(builder) +def HelloRequestAddName(builder, name): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) +def AddName(builder, name): + return HelloRequestAddName(builder, name) +def HelloRequestEnd(builder): return builder.EndObject() +def End(builder): + return HelloRequestEnd(builder) \ No newline at end of file diff --git a/src/idl_gen_python.cpp b/src/idl_gen_python.cpp index a1e4549c3..543c49842 100644 --- a/src/idl_gen_python.cpp +++ b/src/idl_gen_python.cpp @@ -31,7 +31,7 @@ namespace flatbuffers { namespace python { // Hardcode spaces per indentation. -const CommentConfig def_comment = { nullptr, "#", nullptr }; +const CommentConfig def_comment = {nullptr, "#", nullptr}; const std::string Indent = " "; class PythonGenerator : public BaseGenerator { @@ -42,12 +42,11 @@ class PythonGenerator : public BaseGenerator { "" /* not used */, "py"), float_const_gen_("float('nan')", "float('inf')", "float('-inf')") { static const char *const keywords[] = { - "False", "None", "True", "and", "as", "assert", "break", - "class", "continue", "def", "del", "elif", "else", "except", - "finally", "for", "from", "global", "if", "import", "in", - "is", "lambda", "nonlocal", "not", "or", "pass", "raise", - "return", "try", "while", "with", "yield" - }; + "False", "None", "True", "and", "as", "assert", "break", + "class", "continue", "def", "del", "elif", "else", "except", + "finally", "for", "from", "global", "if", "import", "in", + "is", "lambda", "nonlocal", "not", "or", "pass", "raise", + "return", "try", "while", "with", "yield"}; keywords_.insert(std::begin(keywords), std::end(keywords)); } @@ -142,8 +141,8 @@ class PythonGenerator : public BaseGenerator { code += NormalizedName(struct_def); code += "(cls, buf, offset=0):\n"; code += - Indent + Indent + - "\"\"\"This method is deprecated. Please switch to GetRootAs.\"\"\"\n"; + Indent + Indent + + "\"\"\"This method is deprecated. Please switch to GetRootAs.\"\"\"\n"; code += Indent + Indent + "return cls.GetRootAs(buf, offset)\n"; } @@ -207,7 +206,9 @@ class PythonGenerator : public BaseGenerator { code += OffsetPrefix(field); getter += "o + self._tab.Pos)"; auto is_bool = IsBool(field.value.type.base_type); - if (is_bool) { getter = "bool(" + getter + ")"; } + if (is_bool) { + getter = "bool(" + getter + ")"; + } code += Indent + Indent + Indent + "return " + getter + "\n"; std::string default_value; if (is_bool) { @@ -397,7 +398,9 @@ class PythonGenerator : public BaseGenerator { // Currently, we only support accessing as numpy array if // the vector type is a scalar. - if (!(IsScalar(vectortype.base_type))) { return; } + if (!(IsScalar(vectortype.base_type))) { + return; + } GenReceiver(struct_def, code_ptr); code += MakeCamel(NormalizedName(field)) + "AsNumpy(self):"; @@ -422,7 +425,9 @@ class PythonGenerator : public BaseGenerator { const FieldDef &field, std::string *code_ptr) { auto nested = field.attributes.Lookup("nested_flatbuffer"); - if (!nested) { return; } // There is no nested flatbuffer. + if (!nested) { + return; + } // There is no nested flatbuffer. std::string unqualified_name = nested->constant; std::string qualified_name = nested->constant; @@ -444,7 +449,7 @@ class PythonGenerator : public BaseGenerator { code += Indent + Indent + Indent; code += "from " + qualified_name + " import " + unqualified_name + "\n"; code += Indent + Indent + Indent + "return " + unqualified_name; - code += ".GetRootAs"; + code += ".GetRootAs" + unqualified_name; code += "(self._tab.Bytes, self._tab.Vector(o))\n"; code += Indent + Indent + "return 0\n"; code += "\n"; @@ -485,7 +490,9 @@ class PythonGenerator : public BaseGenerator { } else { auto &code = *code_ptr; code += std::string(", ") + nameprefix; - if (has_field_name) { code += MakeCamel(NormalizedName(field), false); } + if (has_field_name) { + code += MakeCamel(NormalizedName(field), false); + } code += namesuffix; } } @@ -555,23 +562,27 @@ class PythonGenerator : public BaseGenerator { // Get the value of a table's starting offset. void GetStartOfTable(const StructDef &struct_def, std::string *code_ptr) { auto &code = *code_ptr; - code += "def Start(builder): "; + + // Generate method with struct name. + code += "def " + NormalizedName(struct_def) + "Start(builder): "; code += "builder.StartObject("; code += NumToString(struct_def.fields.vec.size()); code += ")\n"; - // Add alias with the old name. - code += "def " + NormalizedName(struct_def) + "Start(builder):\n"; - code += Indent + - "\"\"\"This method is deprecated. Please switch to Start.\"\"\"\n"; - code += Indent + "return Start(builder)\n"; + // Generate method without struct name. + code += "def Start(builder):\n"; + code += + Indent + "return " + NormalizedName(struct_def) + "Start(builder)\n"; } // Set the value of a table's field. void BuildFieldOfTable(const StructDef &struct_def, const FieldDef &field, const size_t offset, std::string *code_ptr) { auto &code = *code_ptr; - code += "def Add" + MakeCamel(NormalizedName(field)); + + // Generate method with struct name. + code += "def " + NormalizedName(struct_def) + "Add" + + MakeCamel(NormalizedName(field)); code += "(builder, "; code += MakeCamel(NormalizedName(field), false); code += "): "; @@ -591,27 +602,25 @@ class PythonGenerator : public BaseGenerator { : field.value.constant; code += ")\n"; - // Add alias with the old name. - code += "def " + NormalizedName(struct_def) + "Add" + - MakeCamel(NormalizedName(field)); + // Generate method without struct name. + code += "def Add" + MakeCamel(NormalizedName(field)); code += "(builder, "; code += MakeCamel(NormalizedName(field), false); code += "):\n"; - code += Indent + "\"\"\"This method is deprecated. Please switch to Add"; - code += MakeCamel(NormalizedName(field)) + ".\"\"\"\n"; - code += Indent + "return Add" + MakeCamel(NormalizedName(field)); + code += Indent + "return " + NormalizedName(struct_def) + "Add" + + MakeCamel(NormalizedName(field)); code += "(builder, "; code += MakeCamel(NormalizedName(field), false); code += ")\n"; - - // Add alias with the old name. } // Set the value of one of the members of a table's vector. void BuildVectorOfTable(const StructDef &struct_def, const FieldDef &field, std::string *code_ptr) { auto &code = *code_ptr; - code += "def Start"; + + // Generate method with struct name. + code += "def " + NormalizedName(struct_def) + "Start"; code += MakeCamel(NormalizedName(field)); code += "Vector(builder, numElems): return builder.StartVector("; auto vector_type = field.value.type.VectorType(); @@ -621,13 +630,11 @@ class PythonGenerator : public BaseGenerator { code += ", numElems, " + NumToString(alignment); code += ")\n"; - // Add alias with the old name. - code += "def " + NormalizedName(struct_def) + "Start"; + // Generate method without struct name. + code += "def Start"; code += MakeCamel(NormalizedName(field)); code += "Vector(builder, numElems):\n"; - code += Indent + - "\"\"\"This method is deprecated. Please switch to Start.\"\"\"\n"; - code += Indent + "return Start"; + code += Indent + "return " + NormalizedName(struct_def) + "Start"; code += MakeCamel(NormalizedName(field)); code += "Vector(builder, numElems)\n"; } @@ -635,10 +642,13 @@ class PythonGenerator : public BaseGenerator { // Set the value of one of the members of a table's vector and fills in the // elements from a bytearray. This is for simplifying the use of nested // flatbuffers. - void BuildVectorOfTableFromBytes(const FieldDef &field, + void BuildVectorOfTableFromBytes(const StructDef &struct_def, + const FieldDef &field, std::string *code_ptr) { auto nested = field.attributes.Lookup("nested_flatbuffer"); - if (!nested) { return; } // There is no nested flatbuffer. + if (!nested) { + return; + } // There is no nested flatbuffer. std::string unqualified_name = nested->constant; std::string qualified_name = nested->constant; @@ -652,7 +662,11 @@ class PythonGenerator : public BaseGenerator { (void)nested_root; auto &code = *code_ptr; - code += "def MakeVectorFromBytes(builder, bytes):\n"; + + // Generate method with struct and field name. + code += "def " + NormalizedName(struct_def) + "Make"; + code += MakeCamel(NormalizedName(field)); + code += "VectorFromBytes(builder, bytes):\n"; code += Indent + "builder.StartVector("; auto vector_type = field.value.type.VectorType(); auto alignment = InlineAlignment(vector_type); @@ -665,29 +679,26 @@ class PythonGenerator : public BaseGenerator { code += " = bytes\n"; code += Indent + "return builder.EndVector()\n"; - // Add alias with the old name. - code += "def Make" + MakeCamel(NormalizedName(field)); - code += "VectorFromBytes(builder, bytes):\n"; - code += Indent + "builder.StartVector("; - code += NumToString(elem_size); - code += ", len(bytes), " + NumToString(alignment); - code += ")\n"; - code += Indent + "builder.head = builder.head - len(bytes)\n"; - code += Indent + "builder.Bytes[builder.head : builder.head + len(bytes)]"; - code += " = bytes\n"; - code += Indent + "return builder.EndVector()\n"; + // Generate method without struct and field name. + code += "def Make" + MakeCamel(NormalizedName(field)) + + "VectorFromBytes(builder, bytes):\n"; + code += Indent + "return " + NormalizedName(struct_def) + "Make" + + MakeCamel(NormalizedName(field)) + + "VectorFromBytes(builder, bytes)\n"; } // Get the offset of the end of a table. void GetEndOffsetOnTable(const StructDef &struct_def, std::string *code_ptr) { auto &code = *code_ptr; - code += "def End(builder): return builder.EndObject()\n"; - // Add alias with the old name. - code += "def " + NormalizedName(struct_def) + "End(builder):\n"; - code += Indent + - "\"\"\"This method is deprecated. Please switch to End.\"\"\"\n"; - code += Indent + "return End(builder)"; + // Generate method with struct name. + code += "def " + NormalizedName(struct_def) + "End"; + code += "(builder): "; + code += "return builder.EndObject()\n"; + + // Generate method without struct name. + code += "def End(builder):\n"; + code += Indent + "return " + NormalizedName(struct_def) + "End(builder)"; } // Generate the receiver for function signatures. @@ -732,8 +743,11 @@ class PythonGenerator : public BaseGenerator { } break; } - case BASE_TYPE_UNION: GetUnionField(struct_def, field, code_ptr); break; - default: FLATBUFFERS_ASSERT(0); + case BASE_TYPE_UNION: + GetUnionField(struct_def, field, code_ptr); + break; + default: + FLATBUFFERS_ASSERT(0); } } if (IsVector(field.value.type) || IsArray(field.value.type)) { @@ -765,7 +779,7 @@ class PythonGenerator : public BaseGenerator { BuildFieldOfTable(struct_def, field, offset, code_ptr); if (IsVector(field.value.type)) { BuildVectorOfTable(struct_def, field, code_ptr); - BuildVectorOfTableFromBytes(field, code_ptr); + BuildVectorOfTableFromBytes(struct_def, field, code_ptr); } } @@ -904,9 +918,14 @@ class PythonGenerator : public BaseGenerator { import_list->insert("import " + package_reference); } break; - case BASE_TYPE_STRING: field_type += "str"; break; - case BASE_TYPE_NONE: field_type += "None"; break; - default: break; + case BASE_TYPE_STRING: + field_type += "str"; + break; + case BASE_TYPE_NONE: + field_type += "None"; + break; + default: + break; } field_types += field_type + separator_string; } @@ -1239,7 +1258,8 @@ class PythonGenerator : public BaseGenerator { GenUnPackForScalarVector(struct_def, field, &code); break; } - default: GenUnPackForScalar(struct_def, field, &code); + default: + GenUnPackForScalar(struct_def, field, &code); } } @@ -1294,8 +1314,9 @@ class PythonGenerator : public BaseGenerator { code_prefix += GenIndents(2) + "if self." + field_instance_name + " is not None:"; if (field.value.type.struct_def->fixed) { - code_prefix += GenIndents(3) + "Start" + field_accessor_name + - "Vector(builder, len(self." + field_instance_name + "))"; + code_prefix += GenIndents(3) + struct_name + "Start" + + field_accessor_name + "Vector(builder, len(self." + + field_instance_name + "))"; code_prefix += GenIndents(3) + "for i in reversed(range(len(self." + field_instance_name + "))):"; code_prefix += @@ -1311,8 +1332,9 @@ class PythonGenerator : public BaseGenerator { code_prefix += GenIndents(4) + field_instance_name + "list.append(self." + field_instance_name + "[i].Pack(builder))"; - code_prefix += GenIndents(3) + "Start" + field_accessor_name + - "Vector(builder, len(self." + field_instance_name + "))"; + code_prefix += GenIndents(3) + struct_name + "Start" + + field_accessor_name + "Vector(builder, len(self." + + field_instance_name + "))"; code_prefix += GenIndents(3) + "for i in reversed(range(len(self." + field_instance_name + "))):"; code_prefix += GenIndents(4) + "builder.PrependUOffsetTRelative" + "(" + @@ -1323,8 +1345,8 @@ class PythonGenerator : public BaseGenerator { // Adds the field into the struct. code += GenIndents(2) + "if self." + field_instance_name + " is not None:"; - code += GenIndents(3) + "Add" + field_accessor_name + "(builder, " + - field_instance_name + ")"; + code += GenIndents(3) + struct_name + "Add" + field_accessor_name + + "(builder, " + field_instance_name + ")"; } void GenPackForScalarVectorFieldHelper(const StructDef &struct_def, @@ -1336,7 +1358,7 @@ class PythonGenerator : public BaseGenerator { auto struct_name = NormalizedName(struct_def); auto vectortype = field.value.type.VectorType(); - code += GenIndents(indents) + "Start" + field_accessor_name + + code += GenIndents(indents) + struct_name + "Start" + field_accessor_name + "Vector(builder, len(self." + field_instance_name + "))"; code += GenIndents(indents) + "for i in reversed(range(len(self." + field_instance_name + "))):"; @@ -1344,19 +1366,45 @@ class PythonGenerator : public BaseGenerator { std::string type_name; switch (vectortype.base_type) { - case BASE_TYPE_BOOL: type_name = "Bool"; break; - case BASE_TYPE_CHAR: type_name = "Byte"; break; - case BASE_TYPE_UCHAR: type_name = "Uint8"; break; - case BASE_TYPE_SHORT: type_name = "Int16"; break; - case BASE_TYPE_USHORT: type_name = "Uint16"; break; - case BASE_TYPE_INT: type_name = "Int32"; break; - case BASE_TYPE_UINT: type_name = "Uint32"; break; - case BASE_TYPE_LONG: type_name = "Int64"; break; - case BASE_TYPE_ULONG: type_name = "Uint64"; break; - case BASE_TYPE_FLOAT: type_name = "Float32"; break; - case BASE_TYPE_DOUBLE: type_name = "Float64"; break; - case BASE_TYPE_STRING: type_name = "UOffsetTRelative"; break; - default: type_name = "VOffsetT"; break; + case BASE_TYPE_BOOL: + type_name = "Bool"; + break; + case BASE_TYPE_CHAR: + type_name = "Byte"; + break; + case BASE_TYPE_UCHAR: + type_name = "Uint8"; + break; + case BASE_TYPE_SHORT: + type_name = "Int16"; + break; + case BASE_TYPE_USHORT: + type_name = "Uint16"; + break; + case BASE_TYPE_INT: + type_name = "Int32"; + break; + case BASE_TYPE_UINT: + type_name = "Uint32"; + break; + case BASE_TYPE_LONG: + type_name = "Int64"; + break; + case BASE_TYPE_ULONG: + type_name = "Uint64"; + break; + case BASE_TYPE_FLOAT: + type_name = "Float32"; + break; + case BASE_TYPE_DOUBLE: + type_name = "Float64"; + break; + case BASE_TYPE_STRING: + type_name = "UOffsetTRelative"; + break; + default: + type_name = "VOffsetT"; + break; } code += type_name; } @@ -1373,8 +1421,8 @@ class PythonGenerator : public BaseGenerator { // Adds the field into the struct. code += GenIndents(2) + "if self." + field_instance_name + " is not None:"; - code += GenIndents(3) + "Add" + field_accessor_name + "(builder, " + - field_instance_name + ")"; + code += GenIndents(3) + struct_name + "Add" + field_accessor_name + + "(builder, " + field_instance_name + ")"; // Creates the field. code_prefix += @@ -1436,8 +1484,8 @@ class PythonGenerator : public BaseGenerator { GenIndents(2) + "if self." + field_instance_name + " is not None:"; } - code += GenIndents(3) + "Add" + field_accessor_name + "(builder, " + - field_instance_name + ")"; + code += GenIndents(3) + struct_name + "Add" + field_accessor_name + + "(builder, " + field_instance_name + ")"; } void GenPackForUnionField(const StructDef &struct_def, const FieldDef &field, @@ -1456,8 +1504,8 @@ class PythonGenerator : public BaseGenerator { code_prefix += GenIndents(3) + field_instance_name + " = self." + field_instance_name + ".Pack(builder)"; code += GenIndents(2) + "if self." + field_instance_name + " is not None:"; - code += GenIndents(3) + "Add" + field_accessor_name + "(builder, " + - field_instance_name + ")"; + code += GenIndents(3) + struct_name + "Add" + field_accessor_name + + "(builder, " + field_instance_name + ")"; } void GenPackForTable(const StructDef &struct_def, std::string *code_ptr) { @@ -1468,7 +1516,7 @@ class PythonGenerator : public BaseGenerator { GenReceiverForObjectAPI(struct_def, code_ptr); code_base += "Pack(self, builder):"; - code += GenIndents(2) + "Start(builder)"; + code += GenIndents(2) + struct_name + "Start(builder)"; for (auto it = struct_def.fields.vec.begin(); it != struct_def.fields.vec.end(); ++it) { auto &field = **it; @@ -1507,21 +1555,22 @@ class PythonGenerator : public BaseGenerator { ")"; code += GenIndents(2) + "if self." + field_instance_name + " is not None:"; - code += GenIndents(3) + "Add" + field_accessor_name + "(builder, " + - field_instance_name + ")"; + code += GenIndents(3) + struct_name + "Add" + field_accessor_name + + "(builder, " + field_instance_name + ")"; break; } default: // Generates code for scalar values. If the value equals to the // default value, builder will automatically ignore it. So we don't // need to check the value ahead. - code += GenIndents(2) + "Add" + field_accessor_name + + code += GenIndents(2) + struct_name + "Add" + field_accessor_name + "(builder, self." + field_instance_name + ")"; break; } } - code += GenIndents(2) + struct_instance_name + " = " + "End(builder)"; + code += GenIndents(2) + struct_instance_name + " = " + struct_name + + "End(builder)"; code += GenIndents(2) + "return " + struct_instance_name; code_base += code_prefix + code; @@ -1616,7 +1665,8 @@ class PythonGenerator : public BaseGenerator { case BASE_TYPE_STRING: GenUnionCreatorForString(enum_def, ev, &code); break; - default: break; + default: + break; } } code += GenIndents(1) + "return None"; @@ -1640,9 +1690,12 @@ class PythonGenerator : public BaseGenerator { // Returns the function name that is able to read a value of the given type. std::string GenGetter(const Type &type) { switch (type.base_type) { - case BASE_TYPE_STRING: return "self._tab.String("; - case BASE_TYPE_UNION: return "self._tab.Union("; - case BASE_TYPE_VECTOR: return GenGetter(type.VectorType()); + case BASE_TYPE_STRING: + return "self._tab.String("; + case BASE_TYPE_UNION: + return "self._tab.Union("; + case BASE_TYPE_VECTOR: + return GenGetter(type.VectorType()); default: return "self._tab.Get(flatbuffers.number_types." + MakeCamel(GenTypeGet(type)) + "Flags, "; @@ -1672,12 +1725,16 @@ class PythonGenerator : public BaseGenerator { std::string GenTypePointer(const Type &type) { switch (type.base_type) { - case BASE_TYPE_STRING: return "string"; - case BASE_TYPE_VECTOR: return GenTypeGet(type.VectorType()); - case BASE_TYPE_STRUCT: return type.struct_def->name; + case BASE_TYPE_STRING: + return "string"; + case BASE_TYPE_VECTOR: + return GenTypeGet(type.VectorType()); + case BASE_TYPE_STRUCT: + return type.struct_def->name; case BASE_TYPE_UNION: // fall through - default: return "*flatbuffers.Table"; + default: + return "*flatbuffers.Table"; } } diff --git a/tests/MyGame/Example/ArrayTable.py b/tests/MyGame/Example/ArrayTable.py index 5ca8dad6c..62d71afa4 100644 --- a/tests/MyGame/Example/ArrayTable.py +++ b/tests/MyGame/Example/ArrayTable.py @@ -39,18 +39,15 @@ class ArrayTable(object): return obj return None -def Start(builder): builder.StartObject(1) -def ArrayTableStart(builder): - """This method is deprecated. Please switch to Start.""" - return Start(builder) -def AddA(builder, a): builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(a), 0) -def ArrayTableAddA(builder, a): - """This method is deprecated. Please switch to AddA.""" - return AddA(builder, a) -def End(builder): return builder.EndObject() -def ArrayTableEnd(builder): - """This method is deprecated. Please switch to End.""" - return End(builder) +def ArrayTableStart(builder): builder.StartObject(1) +def Start(builder): + return ArrayTableStart(builder) +def ArrayTableAddA(builder, a): builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(a), 0) +def AddA(builder, a): + return ArrayTableAddA(builder, a) +def ArrayTableEnd(builder): return builder.EndObject() +def End(builder): + return ArrayTableEnd(builder) import MyGame.Example.ArrayStruct try: from typing import Optional @@ -84,9 +81,9 @@ class ArrayTableT(object): # ArrayTableT def Pack(self, builder): - Start(builder) + ArrayTableStart(builder) if self.a is not None: a = self.a.Pack(builder) - AddA(builder, a) - arrayTable = End(builder) + ArrayTableAddA(builder, a) + arrayTable = ArrayTableEnd(builder) return arrayTable diff --git a/tests/MyGame/Example/Monster.py b/tests/MyGame/Example/Monster.py index 33f69a5ab..6a5a931cb 100644 --- a/tests/MyGame/Example/Monster.py +++ b/tests/MyGame/Example/Monster.py @@ -214,7 +214,7 @@ class Monster(object): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30)) if o != 0: from MyGame.Example.Monster import Monster - return Monster.GetRootAs(self._tab.Bytes, self._tab.Vector(o)) + return Monster.GetRootAsMonster(self._tab.Bytes, self._tab.Vector(o)) return 0 # Monster @@ -751,7 +751,7 @@ class Monster(object): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102)) if o != 0: from MyGame.Example.Monster import Monster - return Monster.GetRootAs(self._tab.Bytes, self._tab.Vector(o)) + return Monster.GetRootAsMonster(self._tab.Bytes, self._tab.Vector(o)) return 0 # Monster @@ -791,314 +791,236 @@ class Monster(object): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(104)) return o == 0 -def Start(builder): builder.StartObject(51) -def MonsterStart(builder): - """This method is deprecated. Please switch to Start.""" - return Start(builder) -def AddPos(builder, pos): builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(pos), 0) -def MonsterAddPos(builder, pos): - """This method is deprecated. Please switch to AddPos.""" - return AddPos(builder, pos) -def AddMana(builder, mana): builder.PrependInt16Slot(1, mana, 150) -def MonsterAddMana(builder, mana): - """This method is deprecated. Please switch to AddMana.""" - return AddMana(builder, mana) -def AddHp(builder, hp): builder.PrependInt16Slot(2, hp, 100) -def MonsterAddHp(builder, hp): - """This method is deprecated. Please switch to AddHp.""" - return AddHp(builder, hp) -def AddName(builder, name): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) -def MonsterAddName(builder, name): - """This method is deprecated. Please switch to AddName.""" - return AddName(builder, name) -def AddInventory(builder, inventory): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(inventory), 0) -def MonsterAddInventory(builder, inventory): - """This method is deprecated. Please switch to AddInventory.""" - return AddInventory(builder, inventory) -def StartInventoryVector(builder, numElems): return builder.StartVector(1, numElems, 1) -def MonsterStartInventoryVector(builder, numElems): - """This method is deprecated. Please switch to Start.""" - return StartInventoryVector(builder, numElems) -def AddColor(builder, color): builder.PrependUint8Slot(6, color, 8) -def MonsterAddColor(builder, color): - """This method is deprecated. Please switch to AddColor.""" - return AddColor(builder, color) -def AddTestType(builder, testType): builder.PrependUint8Slot(7, testType, 0) -def MonsterAddTestType(builder, testType): - """This method is deprecated. Please switch to AddTestType.""" - return AddTestType(builder, testType) -def AddTest(builder, test): builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(test), 0) -def MonsterAddTest(builder, test): - """This method is deprecated. Please switch to AddTest.""" - return AddTest(builder, test) -def AddTest4(builder, test4): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(test4), 0) -def MonsterAddTest4(builder, test4): - """This method is deprecated. Please switch to AddTest4.""" - return AddTest4(builder, test4) -def StartTest4Vector(builder, numElems): return builder.StartVector(4, numElems, 2) -def MonsterStartTest4Vector(builder, numElems): - """This method is deprecated. Please switch to Start.""" - return StartTest4Vector(builder, numElems) -def AddTestarrayofstring(builder, testarrayofstring): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring), 0) -def MonsterAddTestarrayofstring(builder, testarrayofstring): - """This method is deprecated. Please switch to AddTestarrayofstring.""" - return AddTestarrayofstring(builder, testarrayofstring) -def StartTestarrayofstringVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def MonsterStartTestarrayofstringVector(builder, numElems): - """This method is deprecated. Please switch to Start.""" - return StartTestarrayofstringVector(builder, numElems) -def AddTestarrayoftables(builder, testarrayoftables): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayoftables), 0) -def MonsterAddTestarrayoftables(builder, testarrayoftables): - """This method is deprecated. Please switch to AddTestarrayoftables.""" - return AddTestarrayoftables(builder, testarrayoftables) -def StartTestarrayoftablesVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def MonsterStartTestarrayoftablesVector(builder, numElems): - """This method is deprecated. Please switch to Start.""" - return StartTestarrayoftablesVector(builder, numElems) -def AddEnemy(builder, enemy): builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(enemy), 0) -def MonsterAddEnemy(builder, enemy): - """This method is deprecated. Please switch to AddEnemy.""" - return AddEnemy(builder, enemy) -def AddTestnestedflatbuffer(builder, testnestedflatbuffer): builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(testnestedflatbuffer), 0) -def MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer): - """This method is deprecated. Please switch to AddTestnestedflatbuffer.""" - return AddTestnestedflatbuffer(builder, testnestedflatbuffer) -def StartTestnestedflatbufferVector(builder, numElems): return builder.StartVector(1, numElems, 1) -def MonsterStartTestnestedflatbufferVector(builder, numElems): - """This method is deprecated. Please switch to Start.""" - return StartTestnestedflatbufferVector(builder, numElems) -def MakeVectorFromBytes(builder, bytes): +def MonsterStart(builder): builder.StartObject(51) +def Start(builder): + return MonsterStart(builder) +def MonsterAddPos(builder, pos): builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(pos), 0) +def AddPos(builder, pos): + return MonsterAddPos(builder, pos) +def MonsterAddMana(builder, mana): builder.PrependInt16Slot(1, mana, 150) +def AddMana(builder, mana): + return MonsterAddMana(builder, mana) +def MonsterAddHp(builder, hp): builder.PrependInt16Slot(2, hp, 100) +def AddHp(builder, hp): + return MonsterAddHp(builder, hp) +def MonsterAddName(builder, name): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) +def AddName(builder, name): + return MonsterAddName(builder, name) +def MonsterAddInventory(builder, inventory): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(inventory), 0) +def AddInventory(builder, inventory): + return MonsterAddInventory(builder, inventory) +def MonsterStartInventoryVector(builder, numElems): return builder.StartVector(1, numElems, 1) +def StartInventoryVector(builder, numElems): + return MonsterStartInventoryVector(builder, numElems) +def MonsterAddColor(builder, color): builder.PrependUint8Slot(6, color, 8) +def AddColor(builder, color): + return MonsterAddColor(builder, color) +def MonsterAddTestType(builder, testType): builder.PrependUint8Slot(7, testType, 0) +def AddTestType(builder, testType): + return MonsterAddTestType(builder, testType) +def MonsterAddTest(builder, test): builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(test), 0) +def AddTest(builder, test): + return MonsterAddTest(builder, test) +def MonsterAddTest4(builder, test4): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(test4), 0) +def AddTest4(builder, test4): + return MonsterAddTest4(builder, test4) +def MonsterStartTest4Vector(builder, numElems): return builder.StartVector(4, numElems, 2) +def StartTest4Vector(builder, numElems): + return MonsterStartTest4Vector(builder, numElems) +def MonsterAddTestarrayofstring(builder, testarrayofstring): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring), 0) +def AddTestarrayofstring(builder, testarrayofstring): + return MonsterAddTestarrayofstring(builder, testarrayofstring) +def MonsterStartTestarrayofstringVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def StartTestarrayofstringVector(builder, numElems): + return MonsterStartTestarrayofstringVector(builder, numElems) +def MonsterAddTestarrayoftables(builder, testarrayoftables): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayoftables), 0) +def AddTestarrayoftables(builder, testarrayoftables): + return MonsterAddTestarrayoftables(builder, testarrayoftables) +def MonsterStartTestarrayoftablesVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def StartTestarrayoftablesVector(builder, numElems): + return MonsterStartTestarrayoftablesVector(builder, numElems) +def MonsterAddEnemy(builder, enemy): builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(enemy), 0) +def AddEnemy(builder, enemy): + return MonsterAddEnemy(builder, enemy) +def MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer): builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(testnestedflatbuffer), 0) +def AddTestnestedflatbuffer(builder, testnestedflatbuffer): + return MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer) +def MonsterStartTestnestedflatbufferVector(builder, numElems): return builder.StartVector(1, numElems, 1) +def StartTestnestedflatbufferVector(builder, numElems): + return MonsterStartTestnestedflatbufferVector(builder, numElems) +def MonsterMakeTestnestedflatbufferVectorFromBytes(builder, bytes): builder.StartVector(1, len(bytes), 1) builder.head = builder.head - len(bytes) builder.Bytes[builder.head : builder.head + len(bytes)] = bytes return builder.EndVector() def MakeTestnestedflatbufferVectorFromBytes(builder, bytes): - builder.StartVector(1, len(bytes), 1) - builder.head = builder.head - len(bytes) - builder.Bytes[builder.head : builder.head + len(bytes)] = bytes - return builder.EndVector() -def AddTestempty(builder, testempty): builder.PrependUOffsetTRelativeSlot(14, flatbuffers.number_types.UOffsetTFlags.py_type(testempty), 0) -def MonsterAddTestempty(builder, testempty): - """This method is deprecated. Please switch to AddTestempty.""" - return AddTestempty(builder, testempty) -def AddTestbool(builder, testbool): builder.PrependBoolSlot(15, testbool, 0) -def MonsterAddTestbool(builder, testbool): - """This method is deprecated. Please switch to AddTestbool.""" - return AddTestbool(builder, testbool) -def AddTesthashs32Fnv1(builder, testhashs32Fnv1): builder.PrependInt32Slot(16, testhashs32Fnv1, 0) -def MonsterAddTesthashs32Fnv1(builder, testhashs32Fnv1): - """This method is deprecated. Please switch to AddTesthashs32Fnv1.""" - return AddTesthashs32Fnv1(builder, testhashs32Fnv1) -def AddTesthashu32Fnv1(builder, testhashu32Fnv1): builder.PrependUint32Slot(17, testhashu32Fnv1, 0) -def MonsterAddTesthashu32Fnv1(builder, testhashu32Fnv1): - """This method is deprecated. Please switch to AddTesthashu32Fnv1.""" - return AddTesthashu32Fnv1(builder, testhashu32Fnv1) -def AddTesthashs64Fnv1(builder, testhashs64Fnv1): builder.PrependInt64Slot(18, testhashs64Fnv1, 0) -def MonsterAddTesthashs64Fnv1(builder, testhashs64Fnv1): - """This method is deprecated. Please switch to AddTesthashs64Fnv1.""" - return AddTesthashs64Fnv1(builder, testhashs64Fnv1) -def AddTesthashu64Fnv1(builder, testhashu64Fnv1): builder.PrependUint64Slot(19, testhashu64Fnv1, 0) -def MonsterAddTesthashu64Fnv1(builder, testhashu64Fnv1): - """This method is deprecated. Please switch to AddTesthashu64Fnv1.""" - return AddTesthashu64Fnv1(builder, testhashu64Fnv1) -def AddTesthashs32Fnv1a(builder, testhashs32Fnv1a): builder.PrependInt32Slot(20, testhashs32Fnv1a, 0) -def MonsterAddTesthashs32Fnv1a(builder, testhashs32Fnv1a): - """This method is deprecated. Please switch to AddTesthashs32Fnv1a.""" - return AddTesthashs32Fnv1a(builder, testhashs32Fnv1a) -def AddTesthashu32Fnv1a(builder, testhashu32Fnv1a): builder.PrependUint32Slot(21, testhashu32Fnv1a, 0) -def MonsterAddTesthashu32Fnv1a(builder, testhashu32Fnv1a): - """This method is deprecated. Please switch to AddTesthashu32Fnv1a.""" - return AddTesthashu32Fnv1a(builder, testhashu32Fnv1a) -def AddTesthashs64Fnv1a(builder, testhashs64Fnv1a): builder.PrependInt64Slot(22, testhashs64Fnv1a, 0) -def MonsterAddTesthashs64Fnv1a(builder, testhashs64Fnv1a): - """This method is deprecated. Please switch to AddTesthashs64Fnv1a.""" - return AddTesthashs64Fnv1a(builder, testhashs64Fnv1a) -def AddTesthashu64Fnv1a(builder, testhashu64Fnv1a): builder.PrependUint64Slot(23, testhashu64Fnv1a, 0) -def MonsterAddTesthashu64Fnv1a(builder, testhashu64Fnv1a): - """This method is deprecated. Please switch to AddTesthashu64Fnv1a.""" - return AddTesthashu64Fnv1a(builder, testhashu64Fnv1a) -def AddTestarrayofbools(builder, testarrayofbools): builder.PrependUOffsetTRelativeSlot(24, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofbools), 0) -def MonsterAddTestarrayofbools(builder, testarrayofbools): - """This method is deprecated. Please switch to AddTestarrayofbools.""" - return AddTestarrayofbools(builder, testarrayofbools) -def StartTestarrayofboolsVector(builder, numElems): return builder.StartVector(1, numElems, 1) -def MonsterStartTestarrayofboolsVector(builder, numElems): - """This method is deprecated. Please switch to Start.""" - return StartTestarrayofboolsVector(builder, numElems) -def AddTestf(builder, testf): builder.PrependFloat32Slot(25, testf, 3.14159) -def MonsterAddTestf(builder, testf): - """This method is deprecated. Please switch to AddTestf.""" - return AddTestf(builder, testf) -def AddTestf2(builder, testf2): builder.PrependFloat32Slot(26, testf2, 3.0) -def MonsterAddTestf2(builder, testf2): - """This method is deprecated. Please switch to AddTestf2.""" - return AddTestf2(builder, testf2) -def AddTestf3(builder, testf3): builder.PrependFloat32Slot(27, testf3, 0.0) -def MonsterAddTestf3(builder, testf3): - """This method is deprecated. Please switch to AddTestf3.""" - return AddTestf3(builder, testf3) -def AddTestarrayofstring2(builder, testarrayofstring2): builder.PrependUOffsetTRelativeSlot(28, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring2), 0) -def MonsterAddTestarrayofstring2(builder, testarrayofstring2): - """This method is deprecated. Please switch to AddTestarrayofstring2.""" - return AddTestarrayofstring2(builder, testarrayofstring2) -def StartTestarrayofstring2Vector(builder, numElems): return builder.StartVector(4, numElems, 4) -def MonsterStartTestarrayofstring2Vector(builder, numElems): - """This method is deprecated. Please switch to Start.""" - return StartTestarrayofstring2Vector(builder, numElems) -def AddTestarrayofsortedstruct(builder, testarrayofsortedstruct): builder.PrependUOffsetTRelativeSlot(29, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofsortedstruct), 0) -def MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct): - """This method is deprecated. Please switch to AddTestarrayofsortedstruct.""" - return AddTestarrayofsortedstruct(builder, testarrayofsortedstruct) -def StartTestarrayofsortedstructVector(builder, numElems): return builder.StartVector(8, numElems, 4) -def MonsterStartTestarrayofsortedstructVector(builder, numElems): - """This method is deprecated. Please switch to Start.""" - return StartTestarrayofsortedstructVector(builder, numElems) -def AddFlex(builder, flex): builder.PrependUOffsetTRelativeSlot(30, flatbuffers.number_types.UOffsetTFlags.py_type(flex), 0) -def MonsterAddFlex(builder, flex): - """This method is deprecated. Please switch to AddFlex.""" - return AddFlex(builder, flex) -def StartFlexVector(builder, numElems): return builder.StartVector(1, numElems, 1) -def MonsterStartFlexVector(builder, numElems): - """This method is deprecated. Please switch to Start.""" - return StartFlexVector(builder, numElems) -def AddTest5(builder, test5): builder.PrependUOffsetTRelativeSlot(31, flatbuffers.number_types.UOffsetTFlags.py_type(test5), 0) -def MonsterAddTest5(builder, test5): - """This method is deprecated. Please switch to AddTest5.""" - return AddTest5(builder, test5) -def StartTest5Vector(builder, numElems): return builder.StartVector(4, numElems, 2) -def MonsterStartTest5Vector(builder, numElems): - """This method is deprecated. Please switch to Start.""" - return StartTest5Vector(builder, numElems) -def AddVectorOfLongs(builder, vectorOfLongs): builder.PrependUOffsetTRelativeSlot(32, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfLongs), 0) -def MonsterAddVectorOfLongs(builder, vectorOfLongs): - """This method is deprecated. Please switch to AddVectorOfLongs.""" - return AddVectorOfLongs(builder, vectorOfLongs) -def StartVectorOfLongsVector(builder, numElems): return builder.StartVector(8, numElems, 8) -def MonsterStartVectorOfLongsVector(builder, numElems): - """This method is deprecated. Please switch to Start.""" - return StartVectorOfLongsVector(builder, numElems) -def AddVectorOfDoubles(builder, vectorOfDoubles): builder.PrependUOffsetTRelativeSlot(33, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfDoubles), 0) -def MonsterAddVectorOfDoubles(builder, vectorOfDoubles): - """This method is deprecated. Please switch to AddVectorOfDoubles.""" - return AddVectorOfDoubles(builder, vectorOfDoubles) -def StartVectorOfDoublesVector(builder, numElems): return builder.StartVector(8, numElems, 8) -def MonsterStartVectorOfDoublesVector(builder, numElems): - """This method is deprecated. Please switch to Start.""" - return StartVectorOfDoublesVector(builder, numElems) -def AddParentNamespaceTest(builder, parentNamespaceTest): builder.PrependUOffsetTRelativeSlot(34, flatbuffers.number_types.UOffsetTFlags.py_type(parentNamespaceTest), 0) -def MonsterAddParentNamespaceTest(builder, parentNamespaceTest): - """This method is deprecated. Please switch to AddParentNamespaceTest.""" - return AddParentNamespaceTest(builder, parentNamespaceTest) -def AddVectorOfReferrables(builder, vectorOfReferrables): builder.PrependUOffsetTRelativeSlot(35, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfReferrables), 0) -def MonsterAddVectorOfReferrables(builder, vectorOfReferrables): - """This method is deprecated. Please switch to AddVectorOfReferrables.""" - return AddVectorOfReferrables(builder, vectorOfReferrables) -def StartVectorOfReferrablesVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def MonsterStartVectorOfReferrablesVector(builder, numElems): - """This method is deprecated. Please switch to Start.""" - return StartVectorOfReferrablesVector(builder, numElems) -def AddSingleWeakReference(builder, singleWeakReference): builder.PrependUint64Slot(36, singleWeakReference, 0) -def MonsterAddSingleWeakReference(builder, singleWeakReference): - """This method is deprecated. Please switch to AddSingleWeakReference.""" - return AddSingleWeakReference(builder, singleWeakReference) -def AddVectorOfWeakReferences(builder, vectorOfWeakReferences): builder.PrependUOffsetTRelativeSlot(37, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfWeakReferences), 0) -def MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences): - """This method is deprecated. Please switch to AddVectorOfWeakReferences.""" - return AddVectorOfWeakReferences(builder, vectorOfWeakReferences) -def StartVectorOfWeakReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8) -def MonsterStartVectorOfWeakReferencesVector(builder, numElems): - """This method is deprecated. Please switch to Start.""" - return StartVectorOfWeakReferencesVector(builder, numElems) -def AddVectorOfStrongReferrables(builder, vectorOfStrongReferrables): builder.PrependUOffsetTRelativeSlot(38, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfStrongReferrables), 0) -def MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables): - """This method is deprecated. Please switch to AddVectorOfStrongReferrables.""" - return AddVectorOfStrongReferrables(builder, vectorOfStrongReferrables) -def StartVectorOfStrongReferrablesVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def MonsterStartVectorOfStrongReferrablesVector(builder, numElems): - """This method is deprecated. Please switch to Start.""" - return StartVectorOfStrongReferrablesVector(builder, numElems) -def AddCoOwningReference(builder, coOwningReference): builder.PrependUint64Slot(39, coOwningReference, 0) -def MonsterAddCoOwningReference(builder, coOwningReference): - """This method is deprecated. Please switch to AddCoOwningReference.""" - return AddCoOwningReference(builder, coOwningReference) -def AddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences): builder.PrependUOffsetTRelativeSlot(40, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfCoOwningReferences), 0) -def MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences): - """This method is deprecated. Please switch to AddVectorOfCoOwningReferences.""" - return AddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences) -def StartVectorOfCoOwningReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8) -def MonsterStartVectorOfCoOwningReferencesVector(builder, numElems): - """This method is deprecated. Please switch to Start.""" - return StartVectorOfCoOwningReferencesVector(builder, numElems) -def AddNonOwningReference(builder, nonOwningReference): builder.PrependUint64Slot(41, nonOwningReference, 0) -def MonsterAddNonOwningReference(builder, nonOwningReference): - """This method is deprecated. Please switch to AddNonOwningReference.""" - return AddNonOwningReference(builder, nonOwningReference) -def AddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences): builder.PrependUOffsetTRelativeSlot(42, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfNonOwningReferences), 0) -def MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences): - """This method is deprecated. Please switch to AddVectorOfNonOwningReferences.""" - return AddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences) -def StartVectorOfNonOwningReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8) -def MonsterStartVectorOfNonOwningReferencesVector(builder, numElems): - """This method is deprecated. Please switch to Start.""" - return StartVectorOfNonOwningReferencesVector(builder, numElems) -def AddAnyUniqueType(builder, anyUniqueType): builder.PrependUint8Slot(43, anyUniqueType, 0) -def MonsterAddAnyUniqueType(builder, anyUniqueType): - """This method is deprecated. Please switch to AddAnyUniqueType.""" - return AddAnyUniqueType(builder, anyUniqueType) -def AddAnyUnique(builder, anyUnique): builder.PrependUOffsetTRelativeSlot(44, flatbuffers.number_types.UOffsetTFlags.py_type(anyUnique), 0) -def MonsterAddAnyUnique(builder, anyUnique): - """This method is deprecated. Please switch to AddAnyUnique.""" - return AddAnyUnique(builder, anyUnique) -def AddAnyAmbiguousType(builder, anyAmbiguousType): builder.PrependUint8Slot(45, anyAmbiguousType, 0) -def MonsterAddAnyAmbiguousType(builder, anyAmbiguousType): - """This method is deprecated. Please switch to AddAnyAmbiguousType.""" - return AddAnyAmbiguousType(builder, anyAmbiguousType) -def AddAnyAmbiguous(builder, anyAmbiguous): builder.PrependUOffsetTRelativeSlot(46, flatbuffers.number_types.UOffsetTFlags.py_type(anyAmbiguous), 0) -def MonsterAddAnyAmbiguous(builder, anyAmbiguous): - """This method is deprecated. Please switch to AddAnyAmbiguous.""" - return AddAnyAmbiguous(builder, anyAmbiguous) -def AddVectorOfEnums(builder, vectorOfEnums): builder.PrependUOffsetTRelativeSlot(47, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfEnums), 0) -def MonsterAddVectorOfEnums(builder, vectorOfEnums): - """This method is deprecated. Please switch to AddVectorOfEnums.""" - return AddVectorOfEnums(builder, vectorOfEnums) -def StartVectorOfEnumsVector(builder, numElems): return builder.StartVector(1, numElems, 1) -def MonsterStartVectorOfEnumsVector(builder, numElems): - """This method is deprecated. Please switch to Start.""" - return StartVectorOfEnumsVector(builder, numElems) -def AddSignedEnum(builder, signedEnum): builder.PrependInt8Slot(48, signedEnum, -1) -def MonsterAddSignedEnum(builder, signedEnum): - """This method is deprecated. Please switch to AddSignedEnum.""" - return AddSignedEnum(builder, signedEnum) -def AddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer): builder.PrependUOffsetTRelativeSlot(49, flatbuffers.number_types.UOffsetTFlags.py_type(testrequirednestedflatbuffer), 0) -def MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer): - """This method is deprecated. Please switch to AddTestrequirednestedflatbuffer.""" - return AddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer) -def StartTestrequirednestedflatbufferVector(builder, numElems): return builder.StartVector(1, numElems, 1) -def MonsterStartTestrequirednestedflatbufferVector(builder, numElems): - """This method is deprecated. Please switch to Start.""" - return StartTestrequirednestedflatbufferVector(builder, numElems) -def MakeVectorFromBytes(builder, bytes): + return MonsterMakeTestnestedflatbufferVectorFromBytes(builder, bytes) +def MonsterAddTestempty(builder, testempty): builder.PrependUOffsetTRelativeSlot(14, flatbuffers.number_types.UOffsetTFlags.py_type(testempty), 0) +def AddTestempty(builder, testempty): + return MonsterAddTestempty(builder, testempty) +def MonsterAddTestbool(builder, testbool): builder.PrependBoolSlot(15, testbool, 0) +def AddTestbool(builder, testbool): + return MonsterAddTestbool(builder, testbool) +def MonsterAddTesthashs32Fnv1(builder, testhashs32Fnv1): builder.PrependInt32Slot(16, testhashs32Fnv1, 0) +def AddTesthashs32Fnv1(builder, testhashs32Fnv1): + return MonsterAddTesthashs32Fnv1(builder, testhashs32Fnv1) +def MonsterAddTesthashu32Fnv1(builder, testhashu32Fnv1): builder.PrependUint32Slot(17, testhashu32Fnv1, 0) +def AddTesthashu32Fnv1(builder, testhashu32Fnv1): + return MonsterAddTesthashu32Fnv1(builder, testhashu32Fnv1) +def MonsterAddTesthashs64Fnv1(builder, testhashs64Fnv1): builder.PrependInt64Slot(18, testhashs64Fnv1, 0) +def AddTesthashs64Fnv1(builder, testhashs64Fnv1): + return MonsterAddTesthashs64Fnv1(builder, testhashs64Fnv1) +def MonsterAddTesthashu64Fnv1(builder, testhashu64Fnv1): builder.PrependUint64Slot(19, testhashu64Fnv1, 0) +def AddTesthashu64Fnv1(builder, testhashu64Fnv1): + return MonsterAddTesthashu64Fnv1(builder, testhashu64Fnv1) +def MonsterAddTesthashs32Fnv1a(builder, testhashs32Fnv1a): builder.PrependInt32Slot(20, testhashs32Fnv1a, 0) +def AddTesthashs32Fnv1a(builder, testhashs32Fnv1a): + return MonsterAddTesthashs32Fnv1a(builder, testhashs32Fnv1a) +def MonsterAddTesthashu32Fnv1a(builder, testhashu32Fnv1a): builder.PrependUint32Slot(21, testhashu32Fnv1a, 0) +def AddTesthashu32Fnv1a(builder, testhashu32Fnv1a): + return MonsterAddTesthashu32Fnv1a(builder, testhashu32Fnv1a) +def MonsterAddTesthashs64Fnv1a(builder, testhashs64Fnv1a): builder.PrependInt64Slot(22, testhashs64Fnv1a, 0) +def AddTesthashs64Fnv1a(builder, testhashs64Fnv1a): + return MonsterAddTesthashs64Fnv1a(builder, testhashs64Fnv1a) +def MonsterAddTesthashu64Fnv1a(builder, testhashu64Fnv1a): builder.PrependUint64Slot(23, testhashu64Fnv1a, 0) +def AddTesthashu64Fnv1a(builder, testhashu64Fnv1a): + return MonsterAddTesthashu64Fnv1a(builder, testhashu64Fnv1a) +def MonsterAddTestarrayofbools(builder, testarrayofbools): builder.PrependUOffsetTRelativeSlot(24, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofbools), 0) +def AddTestarrayofbools(builder, testarrayofbools): + return MonsterAddTestarrayofbools(builder, testarrayofbools) +def MonsterStartTestarrayofboolsVector(builder, numElems): return builder.StartVector(1, numElems, 1) +def StartTestarrayofboolsVector(builder, numElems): + return MonsterStartTestarrayofboolsVector(builder, numElems) +def MonsterAddTestf(builder, testf): builder.PrependFloat32Slot(25, testf, 3.14159) +def AddTestf(builder, testf): + return MonsterAddTestf(builder, testf) +def MonsterAddTestf2(builder, testf2): builder.PrependFloat32Slot(26, testf2, 3.0) +def AddTestf2(builder, testf2): + return MonsterAddTestf2(builder, testf2) +def MonsterAddTestf3(builder, testf3): builder.PrependFloat32Slot(27, testf3, 0.0) +def AddTestf3(builder, testf3): + return MonsterAddTestf3(builder, testf3) +def MonsterAddTestarrayofstring2(builder, testarrayofstring2): builder.PrependUOffsetTRelativeSlot(28, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring2), 0) +def AddTestarrayofstring2(builder, testarrayofstring2): + return MonsterAddTestarrayofstring2(builder, testarrayofstring2) +def MonsterStartTestarrayofstring2Vector(builder, numElems): return builder.StartVector(4, numElems, 4) +def StartTestarrayofstring2Vector(builder, numElems): + return MonsterStartTestarrayofstring2Vector(builder, numElems) +def MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct): builder.PrependUOffsetTRelativeSlot(29, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofsortedstruct), 0) +def AddTestarrayofsortedstruct(builder, testarrayofsortedstruct): + return MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct) +def MonsterStartTestarrayofsortedstructVector(builder, numElems): return builder.StartVector(8, numElems, 4) +def StartTestarrayofsortedstructVector(builder, numElems): + return MonsterStartTestarrayofsortedstructVector(builder, numElems) +def MonsterAddFlex(builder, flex): builder.PrependUOffsetTRelativeSlot(30, flatbuffers.number_types.UOffsetTFlags.py_type(flex), 0) +def AddFlex(builder, flex): + return MonsterAddFlex(builder, flex) +def MonsterStartFlexVector(builder, numElems): return builder.StartVector(1, numElems, 1) +def StartFlexVector(builder, numElems): + return MonsterStartFlexVector(builder, numElems) +def MonsterAddTest5(builder, test5): builder.PrependUOffsetTRelativeSlot(31, flatbuffers.number_types.UOffsetTFlags.py_type(test5), 0) +def AddTest5(builder, test5): + return MonsterAddTest5(builder, test5) +def MonsterStartTest5Vector(builder, numElems): return builder.StartVector(4, numElems, 2) +def StartTest5Vector(builder, numElems): + return MonsterStartTest5Vector(builder, numElems) +def MonsterAddVectorOfLongs(builder, vectorOfLongs): builder.PrependUOffsetTRelativeSlot(32, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfLongs), 0) +def AddVectorOfLongs(builder, vectorOfLongs): + return MonsterAddVectorOfLongs(builder, vectorOfLongs) +def MonsterStartVectorOfLongsVector(builder, numElems): return builder.StartVector(8, numElems, 8) +def StartVectorOfLongsVector(builder, numElems): + return MonsterStartVectorOfLongsVector(builder, numElems) +def MonsterAddVectorOfDoubles(builder, vectorOfDoubles): builder.PrependUOffsetTRelativeSlot(33, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfDoubles), 0) +def AddVectorOfDoubles(builder, vectorOfDoubles): + return MonsterAddVectorOfDoubles(builder, vectorOfDoubles) +def MonsterStartVectorOfDoublesVector(builder, numElems): return builder.StartVector(8, numElems, 8) +def StartVectorOfDoublesVector(builder, numElems): + return MonsterStartVectorOfDoublesVector(builder, numElems) +def MonsterAddParentNamespaceTest(builder, parentNamespaceTest): builder.PrependUOffsetTRelativeSlot(34, flatbuffers.number_types.UOffsetTFlags.py_type(parentNamespaceTest), 0) +def AddParentNamespaceTest(builder, parentNamespaceTest): + return MonsterAddParentNamespaceTest(builder, parentNamespaceTest) +def MonsterAddVectorOfReferrables(builder, vectorOfReferrables): builder.PrependUOffsetTRelativeSlot(35, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfReferrables), 0) +def AddVectorOfReferrables(builder, vectorOfReferrables): + return MonsterAddVectorOfReferrables(builder, vectorOfReferrables) +def MonsterStartVectorOfReferrablesVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def StartVectorOfReferrablesVector(builder, numElems): + return MonsterStartVectorOfReferrablesVector(builder, numElems) +def MonsterAddSingleWeakReference(builder, singleWeakReference): builder.PrependUint64Slot(36, singleWeakReference, 0) +def AddSingleWeakReference(builder, singleWeakReference): + return MonsterAddSingleWeakReference(builder, singleWeakReference) +def MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences): builder.PrependUOffsetTRelativeSlot(37, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfWeakReferences), 0) +def AddVectorOfWeakReferences(builder, vectorOfWeakReferences): + return MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences) +def MonsterStartVectorOfWeakReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8) +def StartVectorOfWeakReferencesVector(builder, numElems): + return MonsterStartVectorOfWeakReferencesVector(builder, numElems) +def MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables): builder.PrependUOffsetTRelativeSlot(38, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfStrongReferrables), 0) +def AddVectorOfStrongReferrables(builder, vectorOfStrongReferrables): + return MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables) +def MonsterStartVectorOfStrongReferrablesVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def StartVectorOfStrongReferrablesVector(builder, numElems): + return MonsterStartVectorOfStrongReferrablesVector(builder, numElems) +def MonsterAddCoOwningReference(builder, coOwningReference): builder.PrependUint64Slot(39, coOwningReference, 0) +def AddCoOwningReference(builder, coOwningReference): + return MonsterAddCoOwningReference(builder, coOwningReference) +def MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences): builder.PrependUOffsetTRelativeSlot(40, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfCoOwningReferences), 0) +def AddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences): + return MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences) +def MonsterStartVectorOfCoOwningReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8) +def StartVectorOfCoOwningReferencesVector(builder, numElems): + return MonsterStartVectorOfCoOwningReferencesVector(builder, numElems) +def MonsterAddNonOwningReference(builder, nonOwningReference): builder.PrependUint64Slot(41, nonOwningReference, 0) +def AddNonOwningReference(builder, nonOwningReference): + return MonsterAddNonOwningReference(builder, nonOwningReference) +def MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences): builder.PrependUOffsetTRelativeSlot(42, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfNonOwningReferences), 0) +def AddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences): + return MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences) +def MonsterStartVectorOfNonOwningReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8) +def StartVectorOfNonOwningReferencesVector(builder, numElems): + return MonsterStartVectorOfNonOwningReferencesVector(builder, numElems) +def MonsterAddAnyUniqueType(builder, anyUniqueType): builder.PrependUint8Slot(43, anyUniqueType, 0) +def AddAnyUniqueType(builder, anyUniqueType): + return MonsterAddAnyUniqueType(builder, anyUniqueType) +def MonsterAddAnyUnique(builder, anyUnique): builder.PrependUOffsetTRelativeSlot(44, flatbuffers.number_types.UOffsetTFlags.py_type(anyUnique), 0) +def AddAnyUnique(builder, anyUnique): + return MonsterAddAnyUnique(builder, anyUnique) +def MonsterAddAnyAmbiguousType(builder, anyAmbiguousType): builder.PrependUint8Slot(45, anyAmbiguousType, 0) +def AddAnyAmbiguousType(builder, anyAmbiguousType): + return MonsterAddAnyAmbiguousType(builder, anyAmbiguousType) +def MonsterAddAnyAmbiguous(builder, anyAmbiguous): builder.PrependUOffsetTRelativeSlot(46, flatbuffers.number_types.UOffsetTFlags.py_type(anyAmbiguous), 0) +def AddAnyAmbiguous(builder, anyAmbiguous): + return MonsterAddAnyAmbiguous(builder, anyAmbiguous) +def MonsterAddVectorOfEnums(builder, vectorOfEnums): builder.PrependUOffsetTRelativeSlot(47, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfEnums), 0) +def AddVectorOfEnums(builder, vectorOfEnums): + return MonsterAddVectorOfEnums(builder, vectorOfEnums) +def MonsterStartVectorOfEnumsVector(builder, numElems): return builder.StartVector(1, numElems, 1) +def StartVectorOfEnumsVector(builder, numElems): + return MonsterStartVectorOfEnumsVector(builder, numElems) +def MonsterAddSignedEnum(builder, signedEnum): builder.PrependInt8Slot(48, signedEnum, -1) +def AddSignedEnum(builder, signedEnum): + return MonsterAddSignedEnum(builder, signedEnum) +def MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer): builder.PrependUOffsetTRelativeSlot(49, flatbuffers.number_types.UOffsetTFlags.py_type(testrequirednestedflatbuffer), 0) +def AddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer): + return MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer) +def MonsterStartTestrequirednestedflatbufferVector(builder, numElems): return builder.StartVector(1, numElems, 1) +def StartTestrequirednestedflatbufferVector(builder, numElems): + return MonsterStartTestrequirednestedflatbufferVector(builder, numElems) +def MonsterMakeTestrequirednestedflatbufferVectorFromBytes(builder, bytes): builder.StartVector(1, len(bytes), 1) builder.head = builder.head - len(bytes) builder.Bytes[builder.head : builder.head + len(bytes)] = bytes return builder.EndVector() def MakeTestrequirednestedflatbufferVectorFromBytes(builder, bytes): - builder.StartVector(1, len(bytes), 1) - builder.head = builder.head - len(bytes) - builder.Bytes[builder.head : builder.head + len(bytes)] = bytes - return builder.EndVector() -def AddScalarKeySortedTables(builder, scalarKeySortedTables): builder.PrependUOffsetTRelativeSlot(50, flatbuffers.number_types.UOffsetTFlags.py_type(scalarKeySortedTables), 0) -def MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables): - """This method is deprecated. Please switch to AddScalarKeySortedTables.""" - return AddScalarKeySortedTables(builder, scalarKeySortedTables) -def StartScalarKeySortedTablesVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def MonsterStartScalarKeySortedTablesVector(builder, numElems): - """This method is deprecated. Please switch to Start.""" - return StartScalarKeySortedTablesVector(builder, numElems) -def End(builder): return builder.EndObject() -def MonsterEnd(builder): - """This method is deprecated. Please switch to End.""" - return End(builder) + return MonsterMakeTestrequirednestedflatbufferVectorFromBytes(builder, bytes) +def MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables): builder.PrependUOffsetTRelativeSlot(50, flatbuffers.number_types.UOffsetTFlags.py_type(scalarKeySortedTables), 0) +def AddScalarKeySortedTables(builder, scalarKeySortedTables): + return MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables) +def MonsterStartScalarKeySortedTablesVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def StartScalarKeySortedTablesVector(builder, numElems): + return MonsterStartScalarKeySortedTablesVector(builder, numElems) +def MonsterEnd(builder): return builder.EndObject() +def End(builder): + return MonsterEnd(builder) import MyGame.Example.Ability import MyGame.Example.Any import MyGame.Example.AnyAmbiguousAliases @@ -1370,14 +1292,14 @@ class MonsterT(object): if np is not None and type(self.inventory) is np.ndarray: inventory = builder.CreateNumpyVector(self.inventory) else: - StartInventoryVector(builder, len(self.inventory)) + MonsterStartInventoryVector(builder, len(self.inventory)) for i in reversed(range(len(self.inventory))): builder.PrependUint8(self.inventory[i]) inventory = builder.EndVector() if self.test is not None: test = self.test.Pack(builder) if self.test4 is not None: - StartTest4Vector(builder, len(self.test4)) + MonsterStartTest4Vector(builder, len(self.test4)) for i in reversed(range(len(self.test4))): self.test4[i].Pack(builder) test4 = builder.EndVector() @@ -1385,7 +1307,7 @@ class MonsterT(object): testarrayofstringlist = [] for i in range(len(self.testarrayofstring)): testarrayofstringlist.append(builder.CreateString(self.testarrayofstring[i])) - StartTestarrayofstringVector(builder, len(self.testarrayofstring)) + MonsterStartTestarrayofstringVector(builder, len(self.testarrayofstring)) for i in reversed(range(len(self.testarrayofstring))): builder.PrependUOffsetTRelative(testarrayofstringlist[i]) testarrayofstring = builder.EndVector() @@ -1393,7 +1315,7 @@ class MonsterT(object): testarrayoftableslist = [] for i in range(len(self.testarrayoftables)): testarrayoftableslist.append(self.testarrayoftables[i].Pack(builder)) - StartTestarrayoftablesVector(builder, len(self.testarrayoftables)) + MonsterStartTestarrayoftablesVector(builder, len(self.testarrayoftables)) for i in reversed(range(len(self.testarrayoftables))): builder.PrependUOffsetTRelative(testarrayoftableslist[i]) testarrayoftables = builder.EndVector() @@ -1403,7 +1325,7 @@ class MonsterT(object): if np is not None and type(self.testnestedflatbuffer) is np.ndarray: testnestedflatbuffer = builder.CreateNumpyVector(self.testnestedflatbuffer) else: - StartTestnestedflatbufferVector(builder, len(self.testnestedflatbuffer)) + MonsterStartTestnestedflatbufferVector(builder, len(self.testnestedflatbuffer)) for i in reversed(range(len(self.testnestedflatbuffer))): builder.PrependUint8(self.testnestedflatbuffer[i]) testnestedflatbuffer = builder.EndVector() @@ -1413,7 +1335,7 @@ class MonsterT(object): if np is not None and type(self.testarrayofbools) is np.ndarray: testarrayofbools = builder.CreateNumpyVector(self.testarrayofbools) else: - StartTestarrayofboolsVector(builder, len(self.testarrayofbools)) + MonsterStartTestarrayofboolsVector(builder, len(self.testarrayofbools)) for i in reversed(range(len(self.testarrayofbools))): builder.PrependBool(self.testarrayofbools[i]) testarrayofbools = builder.EndVector() @@ -1421,12 +1343,12 @@ class MonsterT(object): testarrayofstring2list = [] for i in range(len(self.testarrayofstring2)): testarrayofstring2list.append(builder.CreateString(self.testarrayofstring2[i])) - StartTestarrayofstring2Vector(builder, len(self.testarrayofstring2)) + MonsterStartTestarrayofstring2Vector(builder, len(self.testarrayofstring2)) for i in reversed(range(len(self.testarrayofstring2))): builder.PrependUOffsetTRelative(testarrayofstring2list[i]) testarrayofstring2 = builder.EndVector() if self.testarrayofsortedstruct is not None: - StartTestarrayofsortedstructVector(builder, len(self.testarrayofsortedstruct)) + MonsterStartTestarrayofsortedstructVector(builder, len(self.testarrayofsortedstruct)) for i in reversed(range(len(self.testarrayofsortedstruct))): self.testarrayofsortedstruct[i].Pack(builder) testarrayofsortedstruct = builder.EndVector() @@ -1434,12 +1356,12 @@ class MonsterT(object): if np is not None and type(self.flex) is np.ndarray: flex = builder.CreateNumpyVector(self.flex) else: - StartFlexVector(builder, len(self.flex)) + MonsterStartFlexVector(builder, len(self.flex)) for i in reversed(range(len(self.flex))): builder.PrependUint8(self.flex[i]) flex = builder.EndVector() if self.test5 is not None: - StartTest5Vector(builder, len(self.test5)) + MonsterStartTest5Vector(builder, len(self.test5)) for i in reversed(range(len(self.test5))): self.test5[i].Pack(builder) test5 = builder.EndVector() @@ -1447,7 +1369,7 @@ class MonsterT(object): if np is not None and type(self.vectorOfLongs) is np.ndarray: vectorOfLongs = builder.CreateNumpyVector(self.vectorOfLongs) else: - StartVectorOfLongsVector(builder, len(self.vectorOfLongs)) + MonsterStartVectorOfLongsVector(builder, len(self.vectorOfLongs)) for i in reversed(range(len(self.vectorOfLongs))): builder.PrependInt64(self.vectorOfLongs[i]) vectorOfLongs = builder.EndVector() @@ -1455,7 +1377,7 @@ class MonsterT(object): if np is not None and type(self.vectorOfDoubles) is np.ndarray: vectorOfDoubles = builder.CreateNumpyVector(self.vectorOfDoubles) else: - StartVectorOfDoublesVector(builder, len(self.vectorOfDoubles)) + MonsterStartVectorOfDoublesVector(builder, len(self.vectorOfDoubles)) for i in reversed(range(len(self.vectorOfDoubles))): builder.PrependFloat64(self.vectorOfDoubles[i]) vectorOfDoubles = builder.EndVector() @@ -1465,7 +1387,7 @@ class MonsterT(object): vectorOfReferrableslist = [] for i in range(len(self.vectorOfReferrables)): vectorOfReferrableslist.append(self.vectorOfReferrables[i].Pack(builder)) - StartVectorOfReferrablesVector(builder, len(self.vectorOfReferrables)) + MonsterStartVectorOfReferrablesVector(builder, len(self.vectorOfReferrables)) for i in reversed(range(len(self.vectorOfReferrables))): builder.PrependUOffsetTRelative(vectorOfReferrableslist[i]) vectorOfReferrables = builder.EndVector() @@ -1473,7 +1395,7 @@ class MonsterT(object): if np is not None and type(self.vectorOfWeakReferences) is np.ndarray: vectorOfWeakReferences = builder.CreateNumpyVector(self.vectorOfWeakReferences) else: - StartVectorOfWeakReferencesVector(builder, len(self.vectorOfWeakReferences)) + MonsterStartVectorOfWeakReferencesVector(builder, len(self.vectorOfWeakReferences)) for i in reversed(range(len(self.vectorOfWeakReferences))): builder.PrependUint64(self.vectorOfWeakReferences[i]) vectorOfWeakReferences = builder.EndVector() @@ -1481,7 +1403,7 @@ class MonsterT(object): vectorOfStrongReferrableslist = [] for i in range(len(self.vectorOfStrongReferrables)): vectorOfStrongReferrableslist.append(self.vectorOfStrongReferrables[i].Pack(builder)) - StartVectorOfStrongReferrablesVector(builder, len(self.vectorOfStrongReferrables)) + MonsterStartVectorOfStrongReferrablesVector(builder, len(self.vectorOfStrongReferrables)) for i in reversed(range(len(self.vectorOfStrongReferrables))): builder.PrependUOffsetTRelative(vectorOfStrongReferrableslist[i]) vectorOfStrongReferrables = builder.EndVector() @@ -1489,7 +1411,7 @@ class MonsterT(object): if np is not None and type(self.vectorOfCoOwningReferences) is np.ndarray: vectorOfCoOwningReferences = builder.CreateNumpyVector(self.vectorOfCoOwningReferences) else: - StartVectorOfCoOwningReferencesVector(builder, len(self.vectorOfCoOwningReferences)) + MonsterStartVectorOfCoOwningReferencesVector(builder, len(self.vectorOfCoOwningReferences)) for i in reversed(range(len(self.vectorOfCoOwningReferences))): builder.PrependUint64(self.vectorOfCoOwningReferences[i]) vectorOfCoOwningReferences = builder.EndVector() @@ -1497,7 +1419,7 @@ class MonsterT(object): if np is not None and type(self.vectorOfNonOwningReferences) is np.ndarray: vectorOfNonOwningReferences = builder.CreateNumpyVector(self.vectorOfNonOwningReferences) else: - StartVectorOfNonOwningReferencesVector(builder, len(self.vectorOfNonOwningReferences)) + MonsterStartVectorOfNonOwningReferencesVector(builder, len(self.vectorOfNonOwningReferences)) for i in reversed(range(len(self.vectorOfNonOwningReferences))): builder.PrependUint64(self.vectorOfNonOwningReferences[i]) vectorOfNonOwningReferences = builder.EndVector() @@ -1509,7 +1431,7 @@ class MonsterT(object): if np is not None and type(self.vectorOfEnums) is np.ndarray: vectorOfEnums = builder.CreateNumpyVector(self.vectorOfEnums) else: - StartVectorOfEnumsVector(builder, len(self.vectorOfEnums)) + MonsterStartVectorOfEnumsVector(builder, len(self.vectorOfEnums)) for i in reversed(range(len(self.vectorOfEnums))): builder.PrependUint8(self.vectorOfEnums[i]) vectorOfEnums = builder.EndVector() @@ -1517,7 +1439,7 @@ class MonsterT(object): if np is not None and type(self.testrequirednestedflatbuffer) is np.ndarray: testrequirednestedflatbuffer = builder.CreateNumpyVector(self.testrequirednestedflatbuffer) else: - StartTestrequirednestedflatbufferVector(builder, len(self.testrequirednestedflatbuffer)) + MonsterStartTestrequirednestedflatbufferVector(builder, len(self.testrequirednestedflatbuffer)) for i in reversed(range(len(self.testrequirednestedflatbuffer))): builder.PrependUint8(self.testrequirednestedflatbuffer[i]) testrequirednestedflatbuffer = builder.EndVector() @@ -1525,89 +1447,89 @@ class MonsterT(object): scalarKeySortedTableslist = [] for i in range(len(self.scalarKeySortedTables)): scalarKeySortedTableslist.append(self.scalarKeySortedTables[i].Pack(builder)) - StartScalarKeySortedTablesVector(builder, len(self.scalarKeySortedTables)) + MonsterStartScalarKeySortedTablesVector(builder, len(self.scalarKeySortedTables)) for i in reversed(range(len(self.scalarKeySortedTables))): builder.PrependUOffsetTRelative(scalarKeySortedTableslist[i]) scalarKeySortedTables = builder.EndVector() - Start(builder) + MonsterStart(builder) if self.pos is not None: pos = self.pos.Pack(builder) - AddPos(builder, pos) - AddMana(builder, self.mana) - AddHp(builder, self.hp) + MonsterAddPos(builder, pos) + MonsterAddMana(builder, self.mana) + MonsterAddHp(builder, self.hp) if self.name is not None: - AddName(builder, name) + MonsterAddName(builder, name) if self.inventory is not None: - AddInventory(builder, inventory) - AddColor(builder, self.color) - AddTestType(builder, self.testType) + MonsterAddInventory(builder, inventory) + MonsterAddColor(builder, self.color) + MonsterAddTestType(builder, self.testType) if self.test is not None: - AddTest(builder, test) + MonsterAddTest(builder, test) if self.test4 is not None: - AddTest4(builder, test4) + MonsterAddTest4(builder, test4) if self.testarrayofstring is not None: - AddTestarrayofstring(builder, testarrayofstring) + MonsterAddTestarrayofstring(builder, testarrayofstring) if self.testarrayoftables is not None: - AddTestarrayoftables(builder, testarrayoftables) + MonsterAddTestarrayoftables(builder, testarrayoftables) if self.enemy is not None: - AddEnemy(builder, enemy) + MonsterAddEnemy(builder, enemy) if self.testnestedflatbuffer is not None: - AddTestnestedflatbuffer(builder, testnestedflatbuffer) + MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer) if self.testempty is not None: - AddTestempty(builder, testempty) - AddTestbool(builder, self.testbool) - AddTesthashs32Fnv1(builder, self.testhashs32Fnv1) - AddTesthashu32Fnv1(builder, self.testhashu32Fnv1) - AddTesthashs64Fnv1(builder, self.testhashs64Fnv1) - AddTesthashu64Fnv1(builder, self.testhashu64Fnv1) - AddTesthashs32Fnv1a(builder, self.testhashs32Fnv1a) - AddTesthashu32Fnv1a(builder, self.testhashu32Fnv1a) - AddTesthashs64Fnv1a(builder, self.testhashs64Fnv1a) - AddTesthashu64Fnv1a(builder, self.testhashu64Fnv1a) + MonsterAddTestempty(builder, testempty) + MonsterAddTestbool(builder, self.testbool) + MonsterAddTesthashs32Fnv1(builder, self.testhashs32Fnv1) + MonsterAddTesthashu32Fnv1(builder, self.testhashu32Fnv1) + MonsterAddTesthashs64Fnv1(builder, self.testhashs64Fnv1) + MonsterAddTesthashu64Fnv1(builder, self.testhashu64Fnv1) + MonsterAddTesthashs32Fnv1a(builder, self.testhashs32Fnv1a) + MonsterAddTesthashu32Fnv1a(builder, self.testhashu32Fnv1a) + MonsterAddTesthashs64Fnv1a(builder, self.testhashs64Fnv1a) + MonsterAddTesthashu64Fnv1a(builder, self.testhashu64Fnv1a) if self.testarrayofbools is not None: - AddTestarrayofbools(builder, testarrayofbools) - AddTestf(builder, self.testf) - AddTestf2(builder, self.testf2) - AddTestf3(builder, self.testf3) + MonsterAddTestarrayofbools(builder, testarrayofbools) + MonsterAddTestf(builder, self.testf) + MonsterAddTestf2(builder, self.testf2) + MonsterAddTestf3(builder, self.testf3) if self.testarrayofstring2 is not None: - AddTestarrayofstring2(builder, testarrayofstring2) + MonsterAddTestarrayofstring2(builder, testarrayofstring2) if self.testarrayofsortedstruct is not None: - AddTestarrayofsortedstruct(builder, testarrayofsortedstruct) + MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct) if self.flex is not None: - AddFlex(builder, flex) + MonsterAddFlex(builder, flex) if self.test5 is not None: - AddTest5(builder, test5) + MonsterAddTest5(builder, test5) if self.vectorOfLongs is not None: - AddVectorOfLongs(builder, vectorOfLongs) + MonsterAddVectorOfLongs(builder, vectorOfLongs) if self.vectorOfDoubles is not None: - AddVectorOfDoubles(builder, vectorOfDoubles) + MonsterAddVectorOfDoubles(builder, vectorOfDoubles) if self.parentNamespaceTest is not None: - AddParentNamespaceTest(builder, parentNamespaceTest) + MonsterAddParentNamespaceTest(builder, parentNamespaceTest) if self.vectorOfReferrables is not None: - AddVectorOfReferrables(builder, vectorOfReferrables) - AddSingleWeakReference(builder, self.singleWeakReference) + MonsterAddVectorOfReferrables(builder, vectorOfReferrables) + MonsterAddSingleWeakReference(builder, self.singleWeakReference) if self.vectorOfWeakReferences is not None: - AddVectorOfWeakReferences(builder, vectorOfWeakReferences) + MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences) if self.vectorOfStrongReferrables is not None: - AddVectorOfStrongReferrables(builder, vectorOfStrongReferrables) - AddCoOwningReference(builder, self.coOwningReference) + MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables) + MonsterAddCoOwningReference(builder, self.coOwningReference) if self.vectorOfCoOwningReferences is not None: - AddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences) - AddNonOwningReference(builder, self.nonOwningReference) + MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences) + MonsterAddNonOwningReference(builder, self.nonOwningReference) if self.vectorOfNonOwningReferences is not None: - AddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences) - AddAnyUniqueType(builder, self.anyUniqueType) + MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences) + MonsterAddAnyUniqueType(builder, self.anyUniqueType) if self.anyUnique is not None: - AddAnyUnique(builder, anyUnique) - AddAnyAmbiguousType(builder, self.anyAmbiguousType) + MonsterAddAnyUnique(builder, anyUnique) + MonsterAddAnyAmbiguousType(builder, self.anyAmbiguousType) if self.anyAmbiguous is not None: - AddAnyAmbiguous(builder, anyAmbiguous) + MonsterAddAnyAmbiguous(builder, anyAmbiguous) if self.vectorOfEnums is not None: - AddVectorOfEnums(builder, vectorOfEnums) - AddSignedEnum(builder, self.signedEnum) + MonsterAddVectorOfEnums(builder, vectorOfEnums) + MonsterAddSignedEnum(builder, self.signedEnum) if self.testrequirednestedflatbuffer is not None: - AddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer) + MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer) if self.scalarKeySortedTables is not None: - AddScalarKeySortedTables(builder, scalarKeySortedTables) - monster = End(builder) + MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables) + monster = MonsterEnd(builder) return monster diff --git a/tests/MyGame/Example/Referrable.py b/tests/MyGame/Example/Referrable.py index d751c2733..4b1da6ae4 100644 --- a/tests/MyGame/Example/Referrable.py +++ b/tests/MyGame/Example/Referrable.py @@ -35,18 +35,15 @@ class Referrable(object): return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos) return 0 -def Start(builder): builder.StartObject(1) -def ReferrableStart(builder): - """This method is deprecated. Please switch to Start.""" - return Start(builder) -def AddId(builder, id): builder.PrependUint64Slot(0, id, 0) -def ReferrableAddId(builder, id): - """This method is deprecated. Please switch to AddId.""" - return AddId(builder, id) -def End(builder): return builder.EndObject() -def ReferrableEnd(builder): - """This method is deprecated. Please switch to End.""" - return End(builder) +def ReferrableStart(builder): builder.StartObject(1) +def Start(builder): + return ReferrableStart(builder) +def ReferrableAddId(builder, id): builder.PrependUint64Slot(0, id, 0) +def AddId(builder, id): + return ReferrableAddId(builder, id) +def ReferrableEnd(builder): return builder.EndObject() +def End(builder): + return ReferrableEnd(builder) class ReferrableT(object): @@ -74,7 +71,7 @@ class ReferrableT(object): # ReferrableT def Pack(self, builder): - Start(builder) - AddId(builder, self.id) - referrable = End(builder) + ReferrableStart(builder) + ReferrableAddId(builder, self.id) + referrable = ReferrableEnd(builder) return referrable diff --git a/tests/MyGame/Example/Stat.py b/tests/MyGame/Example/Stat.py index aae8b32d5..3b19a3b84 100644 --- a/tests/MyGame/Example/Stat.py +++ b/tests/MyGame/Example/Stat.py @@ -49,26 +49,21 @@ class Stat(object): return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos) return 0 -def Start(builder): builder.StartObject(3) -def StatStart(builder): - """This method is deprecated. Please switch to Start.""" - return Start(builder) -def AddId(builder, id): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(id), 0) -def StatAddId(builder, id): - """This method is deprecated. Please switch to AddId.""" - return AddId(builder, id) -def AddVal(builder, val): builder.PrependInt64Slot(1, val, 0) -def StatAddVal(builder, val): - """This method is deprecated. Please switch to AddVal.""" - return AddVal(builder, val) -def AddCount(builder, count): builder.PrependUint16Slot(2, count, 0) -def StatAddCount(builder, count): - """This method is deprecated. Please switch to AddCount.""" - return AddCount(builder, count) -def End(builder): return builder.EndObject() -def StatEnd(builder): - """This method is deprecated. Please switch to End.""" - return End(builder) +def StatStart(builder): builder.StartObject(3) +def Start(builder): + return StatStart(builder) +def StatAddId(builder, id): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(id), 0) +def AddId(builder, id): + return StatAddId(builder, id) +def StatAddVal(builder, val): builder.PrependInt64Slot(1, val, 0) +def AddVal(builder, val): + return StatAddVal(builder, val) +def StatAddCount(builder, count): builder.PrependUint16Slot(2, count, 0) +def AddCount(builder, count): + return StatAddCount(builder, count) +def StatEnd(builder): return builder.EndObject() +def End(builder): + return StatEnd(builder) class StatT(object): @@ -102,10 +97,10 @@ class StatT(object): def Pack(self, builder): if self.id is not None: id = builder.CreateString(self.id) - Start(builder) + StatStart(builder) if self.id is not None: - AddId(builder, id) - AddVal(builder, self.val) - AddCount(builder, self.count) - stat = End(builder) + StatAddId(builder, id) + StatAddVal(builder, self.val) + StatAddCount(builder, self.count) + stat = StatEnd(builder) return stat diff --git a/tests/MyGame/Example/TestSimpleTableWithEnum.py b/tests/MyGame/Example/TestSimpleTableWithEnum.py index 1e1e904aa..7f18ed24e 100644 --- a/tests/MyGame/Example/TestSimpleTableWithEnum.py +++ b/tests/MyGame/Example/TestSimpleTableWithEnum.py @@ -35,18 +35,15 @@ class TestSimpleTableWithEnum(object): return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos) return 2 -def Start(builder): builder.StartObject(1) -def TestSimpleTableWithEnumStart(builder): - """This method is deprecated. Please switch to Start.""" - return Start(builder) -def AddColor(builder, color): builder.PrependUint8Slot(0, color, 2) -def TestSimpleTableWithEnumAddColor(builder, color): - """This method is deprecated. Please switch to AddColor.""" - return AddColor(builder, color) -def End(builder): return builder.EndObject() -def TestSimpleTableWithEnumEnd(builder): - """This method is deprecated. Please switch to End.""" - return End(builder) +def TestSimpleTableWithEnumStart(builder): builder.StartObject(1) +def Start(builder): + return TestSimpleTableWithEnumStart(builder) +def TestSimpleTableWithEnumAddColor(builder, color): builder.PrependUint8Slot(0, color, 2) +def AddColor(builder, color): + return TestSimpleTableWithEnumAddColor(builder, color) +def TestSimpleTableWithEnumEnd(builder): return builder.EndObject() +def End(builder): + return TestSimpleTableWithEnumEnd(builder) class TestSimpleTableWithEnumT(object): @@ -74,7 +71,7 @@ class TestSimpleTableWithEnumT(object): # TestSimpleTableWithEnumT def Pack(self, builder): - Start(builder) - AddColor(builder, self.color) - testSimpleTableWithEnum = End(builder) + TestSimpleTableWithEnumStart(builder) + TestSimpleTableWithEnumAddColor(builder, self.color) + testSimpleTableWithEnum = TestSimpleTableWithEnumEnd(builder) return testSimpleTableWithEnum diff --git a/tests/MyGame/Example/TypeAliases.py b/tests/MyGame/Example/TypeAliases.py index 290897540..8b0ea19c5 100644 --- a/tests/MyGame/Example/TypeAliases.py +++ b/tests/MyGame/Example/TypeAliases.py @@ -152,70 +152,54 @@ class TypeAliases(object): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26)) return o == 0 -def Start(builder): builder.StartObject(12) -def TypeAliasesStart(builder): - """This method is deprecated. Please switch to Start.""" - return Start(builder) -def AddI8(builder, i8): builder.PrependInt8Slot(0, i8, 0) -def TypeAliasesAddI8(builder, i8): - """This method is deprecated. Please switch to AddI8.""" - return AddI8(builder, i8) -def AddU8(builder, u8): builder.PrependUint8Slot(1, u8, 0) -def TypeAliasesAddU8(builder, u8): - """This method is deprecated. Please switch to AddU8.""" - return AddU8(builder, u8) -def AddI16(builder, i16): builder.PrependInt16Slot(2, i16, 0) -def TypeAliasesAddI16(builder, i16): - """This method is deprecated. Please switch to AddI16.""" - return AddI16(builder, i16) -def AddU16(builder, u16): builder.PrependUint16Slot(3, u16, 0) -def TypeAliasesAddU16(builder, u16): - """This method is deprecated. Please switch to AddU16.""" - return AddU16(builder, u16) -def AddI32(builder, i32): builder.PrependInt32Slot(4, i32, 0) -def TypeAliasesAddI32(builder, i32): - """This method is deprecated. Please switch to AddI32.""" - return AddI32(builder, i32) -def AddU32(builder, u32): builder.PrependUint32Slot(5, u32, 0) -def TypeAliasesAddU32(builder, u32): - """This method is deprecated. Please switch to AddU32.""" - return AddU32(builder, u32) -def AddI64(builder, i64): builder.PrependInt64Slot(6, i64, 0) -def TypeAliasesAddI64(builder, i64): - """This method is deprecated. Please switch to AddI64.""" - return AddI64(builder, i64) -def AddU64(builder, u64): builder.PrependUint64Slot(7, u64, 0) -def TypeAliasesAddU64(builder, u64): - """This method is deprecated. Please switch to AddU64.""" - return AddU64(builder, u64) -def AddF32(builder, f32): builder.PrependFloat32Slot(8, f32, 0.0) -def TypeAliasesAddF32(builder, f32): - """This method is deprecated. Please switch to AddF32.""" - return AddF32(builder, f32) -def AddF64(builder, f64): builder.PrependFloat64Slot(9, f64, 0.0) -def TypeAliasesAddF64(builder, f64): - """This method is deprecated. Please switch to AddF64.""" - return AddF64(builder, f64) -def AddV8(builder, v8): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(v8), 0) -def TypeAliasesAddV8(builder, v8): - """This method is deprecated. Please switch to AddV8.""" - return AddV8(builder, v8) -def StartV8Vector(builder, numElems): return builder.StartVector(1, numElems, 1) -def TypeAliasesStartV8Vector(builder, numElems): - """This method is deprecated. Please switch to Start.""" - return StartV8Vector(builder, numElems) -def AddVf64(builder, vf64): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(vf64), 0) -def TypeAliasesAddVf64(builder, vf64): - """This method is deprecated. Please switch to AddVf64.""" - return AddVf64(builder, vf64) -def StartVf64Vector(builder, numElems): return builder.StartVector(8, numElems, 8) -def TypeAliasesStartVf64Vector(builder, numElems): - """This method is deprecated. Please switch to Start.""" - return StartVf64Vector(builder, numElems) -def End(builder): return builder.EndObject() -def TypeAliasesEnd(builder): - """This method is deprecated. Please switch to End.""" - return End(builder) +def TypeAliasesStart(builder): builder.StartObject(12) +def Start(builder): + return TypeAliasesStart(builder) +def TypeAliasesAddI8(builder, i8): builder.PrependInt8Slot(0, i8, 0) +def AddI8(builder, i8): + return TypeAliasesAddI8(builder, i8) +def TypeAliasesAddU8(builder, u8): builder.PrependUint8Slot(1, u8, 0) +def AddU8(builder, u8): + return TypeAliasesAddU8(builder, u8) +def TypeAliasesAddI16(builder, i16): builder.PrependInt16Slot(2, i16, 0) +def AddI16(builder, i16): + return TypeAliasesAddI16(builder, i16) +def TypeAliasesAddU16(builder, u16): builder.PrependUint16Slot(3, u16, 0) +def AddU16(builder, u16): + return TypeAliasesAddU16(builder, u16) +def TypeAliasesAddI32(builder, i32): builder.PrependInt32Slot(4, i32, 0) +def AddI32(builder, i32): + return TypeAliasesAddI32(builder, i32) +def TypeAliasesAddU32(builder, u32): builder.PrependUint32Slot(5, u32, 0) +def AddU32(builder, u32): + return TypeAliasesAddU32(builder, u32) +def TypeAliasesAddI64(builder, i64): builder.PrependInt64Slot(6, i64, 0) +def AddI64(builder, i64): + return TypeAliasesAddI64(builder, i64) +def TypeAliasesAddU64(builder, u64): builder.PrependUint64Slot(7, u64, 0) +def AddU64(builder, u64): + return TypeAliasesAddU64(builder, u64) +def TypeAliasesAddF32(builder, f32): builder.PrependFloat32Slot(8, f32, 0.0) +def AddF32(builder, f32): + return TypeAliasesAddF32(builder, f32) +def TypeAliasesAddF64(builder, f64): builder.PrependFloat64Slot(9, f64, 0.0) +def AddF64(builder, f64): + return TypeAliasesAddF64(builder, f64) +def TypeAliasesAddV8(builder, v8): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(v8), 0) +def AddV8(builder, v8): + return TypeAliasesAddV8(builder, v8) +def TypeAliasesStartV8Vector(builder, numElems): return builder.StartVector(1, numElems, 1) +def StartV8Vector(builder, numElems): + return TypeAliasesStartV8Vector(builder, numElems) +def TypeAliasesAddVf64(builder, vf64): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(vf64), 0) +def AddVf64(builder, vf64): + return TypeAliasesAddVf64(builder, vf64) +def TypeAliasesStartVf64Vector(builder, numElems): return builder.StartVector(8, numElems, 8) +def StartVf64Vector(builder, numElems): + return TypeAliasesStartVf64Vector(builder, numElems) +def TypeAliasesEnd(builder): return builder.EndObject() +def End(builder): + return TypeAliasesEnd(builder) try: from typing import List except: @@ -285,7 +269,7 @@ class TypeAliasesT(object): if np is not None and type(self.v8) is np.ndarray: v8 = builder.CreateNumpyVector(self.v8) else: - StartV8Vector(builder, len(self.v8)) + TypeAliasesStartV8Vector(builder, len(self.v8)) for i in reversed(range(len(self.v8))): builder.PrependByte(self.v8[i]) v8 = builder.EndVector() @@ -293,24 +277,24 @@ class TypeAliasesT(object): if np is not None and type(self.vf64) is np.ndarray: vf64 = builder.CreateNumpyVector(self.vf64) else: - StartVf64Vector(builder, len(self.vf64)) + TypeAliasesStartVf64Vector(builder, len(self.vf64)) for i in reversed(range(len(self.vf64))): builder.PrependFloat64(self.vf64[i]) vf64 = builder.EndVector() - Start(builder) - AddI8(builder, self.i8) - AddU8(builder, self.u8) - AddI16(builder, self.i16) - AddU16(builder, self.u16) - AddI32(builder, self.i32) - AddU32(builder, self.u32) - AddI64(builder, self.i64) - AddU64(builder, self.u64) - AddF32(builder, self.f32) - AddF64(builder, self.f64) + TypeAliasesStart(builder) + TypeAliasesAddI8(builder, self.i8) + TypeAliasesAddU8(builder, self.u8) + TypeAliasesAddI16(builder, self.i16) + TypeAliasesAddU16(builder, self.u16) + TypeAliasesAddI32(builder, self.i32) + TypeAliasesAddU32(builder, self.u32) + TypeAliasesAddI64(builder, self.i64) + TypeAliasesAddU64(builder, self.u64) + TypeAliasesAddF32(builder, self.f32) + TypeAliasesAddF64(builder, self.f64) if self.v8 is not None: - AddV8(builder, v8) + TypeAliasesAddV8(builder, v8) if self.vf64 is not None: - AddVf64(builder, vf64) - typeAliases = End(builder) + TypeAliasesAddVf64(builder, vf64) + typeAliases = TypeAliasesEnd(builder) return typeAliases diff --git a/tests/MyGame/Example2/Monster.py b/tests/MyGame/Example2/Monster.py index f1cafe6a5..893ea9bbb 100644 --- a/tests/MyGame/Example2/Monster.py +++ b/tests/MyGame/Example2/Monster.py @@ -28,14 +28,12 @@ class Monster(object): def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def Start(builder): builder.StartObject(0) -def MonsterStart(builder): - """This method is deprecated. Please switch to Start.""" - return Start(builder) -def End(builder): return builder.EndObject() -def MonsterEnd(builder): - """This method is deprecated. Please switch to End.""" - return End(builder) +def MonsterStart(builder): builder.StartObject(0) +def Start(builder): + return MonsterStart(builder) +def MonsterEnd(builder): return builder.EndObject() +def End(builder): + return MonsterEnd(builder) class MonsterT(object): @@ -62,6 +60,6 @@ class MonsterT(object): # MonsterT def Pack(self, builder): - Start(builder) - monster = End(builder) + MonsterStart(builder) + monster = MonsterEnd(builder) return monster diff --git a/tests/MyGame/InParentNamespace.py b/tests/MyGame/InParentNamespace.py index b76a37b44..197072b84 100644 --- a/tests/MyGame/InParentNamespace.py +++ b/tests/MyGame/InParentNamespace.py @@ -28,14 +28,12 @@ class InParentNamespace(object): def Init(self, buf, pos): self._tab = flatbuffers.table.Table(buf, pos) -def Start(builder): builder.StartObject(0) -def InParentNamespaceStart(builder): - """This method is deprecated. Please switch to Start.""" - return Start(builder) -def End(builder): return builder.EndObject() -def InParentNamespaceEnd(builder): - """This method is deprecated. Please switch to End.""" - return End(builder) +def InParentNamespaceStart(builder): builder.StartObject(0) +def Start(builder): + return InParentNamespaceStart(builder) +def InParentNamespaceEnd(builder): return builder.EndObject() +def End(builder): + return InParentNamespaceEnd(builder) class InParentNamespaceT(object): @@ -62,6 +60,6 @@ class InParentNamespaceT(object): # InParentNamespaceT def Pack(self, builder): - Start(builder) - inParentNamespace = End(builder) + InParentNamespaceStart(builder) + inParentNamespace = InParentNamespaceEnd(builder) return inParentNamespace diff --git a/tests/MyGame/MonsterExtra.py b/tests/MyGame/MonsterExtra.py index f36244016..f7288b6c9 100644 --- a/tests/MyGame/MonsterExtra.py +++ b/tests/MyGame/MonsterExtra.py @@ -138,62 +138,48 @@ class MonsterExtra(object): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22)) return o == 0 -def Start(builder): builder.StartObject(11) -def MonsterExtraStart(builder): - """This method is deprecated. Please switch to Start.""" - return Start(builder) -def AddD0(builder, d0): builder.PrependFloat64Slot(0, d0, float('nan')) -def MonsterExtraAddD0(builder, d0): - """This method is deprecated. Please switch to AddD0.""" - return AddD0(builder, d0) -def AddD1(builder, d1): builder.PrependFloat64Slot(1, d1, float('nan')) -def MonsterExtraAddD1(builder, d1): - """This method is deprecated. Please switch to AddD1.""" - return AddD1(builder, d1) -def AddD2(builder, d2): builder.PrependFloat64Slot(2, d2, float('inf')) -def MonsterExtraAddD2(builder, d2): - """This method is deprecated. Please switch to AddD2.""" - return AddD2(builder, d2) -def AddD3(builder, d3): builder.PrependFloat64Slot(3, d3, float('-inf')) -def MonsterExtraAddD3(builder, d3): - """This method is deprecated. Please switch to AddD3.""" - return AddD3(builder, d3) -def AddF0(builder, f0): builder.PrependFloat32Slot(4, f0, float('nan')) -def MonsterExtraAddF0(builder, f0): - """This method is deprecated. Please switch to AddF0.""" - return AddF0(builder, f0) -def AddF1(builder, f1): builder.PrependFloat32Slot(5, f1, float('nan')) -def MonsterExtraAddF1(builder, f1): - """This method is deprecated. Please switch to AddF1.""" - return AddF1(builder, f1) -def AddF2(builder, f2): builder.PrependFloat32Slot(6, f2, float('inf')) -def MonsterExtraAddF2(builder, f2): - """This method is deprecated. Please switch to AddF2.""" - return AddF2(builder, f2) -def AddF3(builder, f3): builder.PrependFloat32Slot(7, f3, float('-inf')) -def MonsterExtraAddF3(builder, f3): - """This method is deprecated. Please switch to AddF3.""" - return AddF3(builder, f3) -def AddDvec(builder, dvec): builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(dvec), 0) -def MonsterExtraAddDvec(builder, dvec): - """This method is deprecated. Please switch to AddDvec.""" - return AddDvec(builder, dvec) -def StartDvecVector(builder, numElems): return builder.StartVector(8, numElems, 8) -def MonsterExtraStartDvecVector(builder, numElems): - """This method is deprecated. Please switch to Start.""" - return StartDvecVector(builder, numElems) -def AddFvec(builder, fvec): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(fvec), 0) -def MonsterExtraAddFvec(builder, fvec): - """This method is deprecated. Please switch to AddFvec.""" - return AddFvec(builder, fvec) -def StartFvecVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def MonsterExtraStartFvecVector(builder, numElems): - """This method is deprecated. Please switch to Start.""" - return StartFvecVector(builder, numElems) -def End(builder): return builder.EndObject() -def MonsterExtraEnd(builder): - """This method is deprecated. Please switch to End.""" - return End(builder) +def MonsterExtraStart(builder): builder.StartObject(11) +def Start(builder): + return MonsterExtraStart(builder) +def MonsterExtraAddD0(builder, d0): builder.PrependFloat64Slot(0, d0, float('nan')) +def AddD0(builder, d0): + return MonsterExtraAddD0(builder, d0) +def MonsterExtraAddD1(builder, d1): builder.PrependFloat64Slot(1, d1, float('nan')) +def AddD1(builder, d1): + return MonsterExtraAddD1(builder, d1) +def MonsterExtraAddD2(builder, d2): builder.PrependFloat64Slot(2, d2, float('inf')) +def AddD2(builder, d2): + return MonsterExtraAddD2(builder, d2) +def MonsterExtraAddD3(builder, d3): builder.PrependFloat64Slot(3, d3, float('-inf')) +def AddD3(builder, d3): + return MonsterExtraAddD3(builder, d3) +def MonsterExtraAddF0(builder, f0): builder.PrependFloat32Slot(4, f0, float('nan')) +def AddF0(builder, f0): + return MonsterExtraAddF0(builder, f0) +def MonsterExtraAddF1(builder, f1): builder.PrependFloat32Slot(5, f1, float('nan')) +def AddF1(builder, f1): + return MonsterExtraAddF1(builder, f1) +def MonsterExtraAddF2(builder, f2): builder.PrependFloat32Slot(6, f2, float('inf')) +def AddF2(builder, f2): + return MonsterExtraAddF2(builder, f2) +def MonsterExtraAddF3(builder, f3): builder.PrependFloat32Slot(7, f3, float('-inf')) +def AddF3(builder, f3): + return MonsterExtraAddF3(builder, f3) +def MonsterExtraAddDvec(builder, dvec): builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(dvec), 0) +def AddDvec(builder, dvec): + return MonsterExtraAddDvec(builder, dvec) +def MonsterExtraStartDvecVector(builder, numElems): return builder.StartVector(8, numElems, 8) +def StartDvecVector(builder, numElems): + return MonsterExtraStartDvecVector(builder, numElems) +def MonsterExtraAddFvec(builder, fvec): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(fvec), 0) +def AddFvec(builder, fvec): + return MonsterExtraAddFvec(builder, fvec) +def MonsterExtraStartFvecVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def StartFvecVector(builder, numElems): + return MonsterExtraStartFvecVector(builder, numElems) +def MonsterExtraEnd(builder): return builder.EndObject() +def End(builder): + return MonsterExtraEnd(builder) try: from typing import List except: @@ -259,7 +245,7 @@ class MonsterExtraT(object): if np is not None and type(self.dvec) is np.ndarray: dvec = builder.CreateNumpyVector(self.dvec) else: - StartDvecVector(builder, len(self.dvec)) + MonsterExtraStartDvecVector(builder, len(self.dvec)) for i in reversed(range(len(self.dvec))): builder.PrependFloat64(self.dvec[i]) dvec = builder.EndVector() @@ -267,22 +253,22 @@ class MonsterExtraT(object): if np is not None and type(self.fvec) is np.ndarray: fvec = builder.CreateNumpyVector(self.fvec) else: - StartFvecVector(builder, len(self.fvec)) + MonsterExtraStartFvecVector(builder, len(self.fvec)) for i in reversed(range(len(self.fvec))): builder.PrependFloat32(self.fvec[i]) fvec = builder.EndVector() - Start(builder) - AddD0(builder, self.d0) - AddD1(builder, self.d1) - AddD2(builder, self.d2) - AddD3(builder, self.d3) - AddF0(builder, self.f0) - AddF1(builder, self.f1) - AddF2(builder, self.f2) - AddF3(builder, self.f3) + MonsterExtraStart(builder) + MonsterExtraAddD0(builder, self.d0) + MonsterExtraAddD1(builder, self.d1) + MonsterExtraAddD2(builder, self.d2) + MonsterExtraAddD3(builder, self.d3) + MonsterExtraAddF0(builder, self.f0) + MonsterExtraAddF1(builder, self.f1) + MonsterExtraAddF2(builder, self.f2) + MonsterExtraAddF3(builder, self.f3) if self.dvec is not None: - AddDvec(builder, dvec) + MonsterExtraAddDvec(builder, dvec) if self.fvec is not None: - AddFvec(builder, fvec) - monsterExtra = End(builder) + MonsterExtraAddFvec(builder, fvec) + monsterExtra = MonsterExtraEnd(builder) return monsterExtra diff --git a/tests/namespace_test/NamespaceA/NamespaceB/TableInNestedNS.py b/tests/namespace_test/NamespaceA/NamespaceB/TableInNestedNS.py index 7a4ff9d75..a9848d801 100644 --- a/tests/namespace_test/NamespaceA/NamespaceB/TableInNestedNS.py +++ b/tests/namespace_test/NamespaceA/NamespaceB/TableInNestedNS.py @@ -31,18 +31,15 @@ class TableInNestedNS(object): return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) return 0 -def Start(builder): builder.StartObject(1) -def TableInNestedNSStart(builder): - """This method is deprecated. Please switch to Start.""" - return Start(builder) -def AddFoo(builder, foo): builder.PrependInt32Slot(0, foo, 0) -def TableInNestedNSAddFoo(builder, foo): - """This method is deprecated. Please switch to AddFoo.""" - return AddFoo(builder, foo) -def End(builder): return builder.EndObject() -def TableInNestedNSEnd(builder): - """This method is deprecated. Please switch to End.""" - return End(builder) +def TableInNestedNSStart(builder): builder.StartObject(1) +def Start(builder): + return TableInNestedNSStart(builder) +def TableInNestedNSAddFoo(builder, foo): builder.PrependInt32Slot(0, foo, 0) +def AddFoo(builder, foo): + return TableInNestedNSAddFoo(builder, foo) +def TableInNestedNSEnd(builder): return builder.EndObject() +def End(builder): + return TableInNestedNSEnd(builder) class TableInNestedNST(object): @@ -70,7 +67,7 @@ class TableInNestedNST(object): # TableInNestedNST def Pack(self, builder): - Start(builder) - AddFoo(builder, self.foo) - tableInNestedNS = End(builder) + TableInNestedNSStart(builder) + TableInNestedNSAddFoo(builder, self.foo) + tableInNestedNS = TableInNestedNSEnd(builder) return tableInNestedNS diff --git a/tests/namespace_test/NamespaceA/SecondTableInA.py b/tests/namespace_test/NamespaceA/SecondTableInA.py index f97cf062a..474f44d4d 100644 --- a/tests/namespace_test/NamespaceA/SecondTableInA.py +++ b/tests/namespace_test/NamespaceA/SecondTableInA.py @@ -34,18 +34,15 @@ class SecondTableInA(object): return obj return None -def Start(builder): builder.StartObject(1) -def SecondTableInAStart(builder): - """This method is deprecated. Please switch to Start.""" - return Start(builder) -def AddReferToC(builder, referToC): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(referToC), 0) -def SecondTableInAAddReferToC(builder, referToC): - """This method is deprecated. Please switch to AddReferToC.""" - return AddReferToC(builder, referToC) -def End(builder): return builder.EndObject() -def SecondTableInAEnd(builder): - """This method is deprecated. Please switch to End.""" - return End(builder) +def SecondTableInAStart(builder): builder.StartObject(1) +def Start(builder): + return SecondTableInAStart(builder) +def SecondTableInAAddReferToC(builder, referToC): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(referToC), 0) +def AddReferToC(builder, referToC): + return SecondTableInAAddReferToC(builder, referToC) +def SecondTableInAEnd(builder): return builder.EndObject() +def End(builder): + return SecondTableInAEnd(builder) try: from typing import Optional except: @@ -80,8 +77,8 @@ class SecondTableInAT(object): def Pack(self, builder): if self.referToC is not None: referToC = self.referToC.Pack(builder) - Start(builder) + SecondTableInAStart(builder) if self.referToC is not None: - AddReferToC(builder, referToC) - secondTableInA = End(builder) + SecondTableInAAddReferToC(builder, referToC) + secondTableInA = SecondTableInAEnd(builder) return secondTableInA diff --git a/tests/namespace_test/NamespaceA/TableInFirstNS.py b/tests/namespace_test/NamespaceA/TableInFirstNS.py index d2c7e4aad..8f191f8ad 100644 --- a/tests/namespace_test/NamespaceA/TableInFirstNS.py +++ b/tests/namespace_test/NamespaceA/TableInFirstNS.py @@ -68,34 +68,27 @@ class TableInFirstNS(object): return obj return None -def Start(builder): builder.StartObject(5) -def TableInFirstNSStart(builder): - """This method is deprecated. Please switch to Start.""" - return Start(builder) -def AddFooTable(builder, fooTable): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(fooTable), 0) -def TableInFirstNSAddFooTable(builder, fooTable): - """This method is deprecated. Please switch to AddFooTable.""" - return AddFooTable(builder, fooTable) -def AddFooEnum(builder, fooEnum): builder.PrependInt8Slot(1, fooEnum, 0) -def TableInFirstNSAddFooEnum(builder, fooEnum): - """This method is deprecated. Please switch to AddFooEnum.""" - return AddFooEnum(builder, fooEnum) -def AddFooUnionType(builder, fooUnionType): builder.PrependUint8Slot(2, fooUnionType, 0) -def TableInFirstNSAddFooUnionType(builder, fooUnionType): - """This method is deprecated. Please switch to AddFooUnionType.""" - return AddFooUnionType(builder, fooUnionType) -def AddFooUnion(builder, fooUnion): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(fooUnion), 0) -def TableInFirstNSAddFooUnion(builder, fooUnion): - """This method is deprecated. Please switch to AddFooUnion.""" - return AddFooUnion(builder, fooUnion) -def AddFooStruct(builder, fooStruct): builder.PrependStructSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(fooStruct), 0) -def TableInFirstNSAddFooStruct(builder, fooStruct): - """This method is deprecated. Please switch to AddFooStruct.""" - return AddFooStruct(builder, fooStruct) -def End(builder): return builder.EndObject() -def TableInFirstNSEnd(builder): - """This method is deprecated. Please switch to End.""" - return End(builder) +def TableInFirstNSStart(builder): builder.StartObject(5) +def Start(builder): + return TableInFirstNSStart(builder) +def TableInFirstNSAddFooTable(builder, fooTable): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(fooTable), 0) +def AddFooTable(builder, fooTable): + return TableInFirstNSAddFooTable(builder, fooTable) +def TableInFirstNSAddFooEnum(builder, fooEnum): builder.PrependInt8Slot(1, fooEnum, 0) +def AddFooEnum(builder, fooEnum): + return TableInFirstNSAddFooEnum(builder, fooEnum) +def TableInFirstNSAddFooUnionType(builder, fooUnionType): builder.PrependUint8Slot(2, fooUnionType, 0) +def AddFooUnionType(builder, fooUnionType): + return TableInFirstNSAddFooUnionType(builder, fooUnionType) +def TableInFirstNSAddFooUnion(builder, fooUnion): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(fooUnion), 0) +def AddFooUnion(builder, fooUnion): + return TableInFirstNSAddFooUnion(builder, fooUnion) +def TableInFirstNSAddFooStruct(builder, fooStruct): builder.PrependStructSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(fooStruct), 0) +def AddFooStruct(builder, fooStruct): + return TableInFirstNSAddFooStruct(builder, fooStruct) +def TableInFirstNSEnd(builder): return builder.EndObject() +def End(builder): + return TableInFirstNSEnd(builder) try: from typing import Optional, Union except: @@ -141,15 +134,15 @@ class TableInFirstNST(object): fooTable = self.fooTable.Pack(builder) if self.fooUnion is not None: fooUnion = self.fooUnion.Pack(builder) - Start(builder) + TableInFirstNSStart(builder) if self.fooTable is not None: - AddFooTable(builder, fooTable) - AddFooEnum(builder, self.fooEnum) - AddFooUnionType(builder, self.fooUnionType) + TableInFirstNSAddFooTable(builder, fooTable) + TableInFirstNSAddFooEnum(builder, self.fooEnum) + TableInFirstNSAddFooUnionType(builder, self.fooUnionType) if self.fooUnion is not None: - AddFooUnion(builder, fooUnion) + TableInFirstNSAddFooUnion(builder, fooUnion) if self.fooStruct is not None: fooStruct = self.fooStruct.Pack(builder) - AddFooStruct(builder, fooStruct) - tableInFirstNS = End(builder) + TableInFirstNSAddFooStruct(builder, fooStruct) + tableInFirstNS = TableInFirstNSEnd(builder) return tableInFirstNS diff --git a/tests/namespace_test/NamespaceC/TableInC.py b/tests/namespace_test/NamespaceC/TableInC.py index b8d3b94fc..762e1a1ae 100644 --- a/tests/namespace_test/NamespaceC/TableInC.py +++ b/tests/namespace_test/NamespaceC/TableInC.py @@ -44,22 +44,18 @@ class TableInC(object): return obj return None -def Start(builder): builder.StartObject(2) -def TableInCStart(builder): - """This method is deprecated. Please switch to Start.""" - return Start(builder) -def AddReferToA1(builder, referToA1): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(referToA1), 0) -def TableInCAddReferToA1(builder, referToA1): - """This method is deprecated. Please switch to AddReferToA1.""" - return AddReferToA1(builder, referToA1) -def AddReferToA2(builder, referToA2): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(referToA2), 0) -def TableInCAddReferToA2(builder, referToA2): - """This method is deprecated. Please switch to AddReferToA2.""" - return AddReferToA2(builder, referToA2) -def End(builder): return builder.EndObject() -def TableInCEnd(builder): - """This method is deprecated. Please switch to End.""" - return End(builder) +def TableInCStart(builder): builder.StartObject(2) +def Start(builder): + return TableInCStart(builder) +def TableInCAddReferToA1(builder, referToA1): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(referToA1), 0) +def AddReferToA1(builder, referToA1): + return TableInCAddReferToA1(builder, referToA1) +def TableInCAddReferToA2(builder, referToA2): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(referToA2), 0) +def AddReferToA2(builder, referToA2): + return TableInCAddReferToA2(builder, referToA2) +def TableInCEnd(builder): return builder.EndObject() +def End(builder): + return TableInCEnd(builder) try: from typing import Optional except: @@ -99,10 +95,10 @@ class TableInCT(object): referToA1 = self.referToA1.Pack(builder) if self.referToA2 is not None: referToA2 = self.referToA2.Pack(builder) - Start(builder) + TableInCStart(builder) if self.referToA1 is not None: - AddReferToA1(builder, referToA1) + TableInCAddReferToA1(builder, referToA1) if self.referToA2 is not None: - AddReferToA2(builder, referToA2) - tableInC = End(builder) + TableInCAddReferToA2(builder, referToA2) + tableInC = TableInCEnd(builder) return tableInC