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

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

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

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

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

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

* Update the generated sample code

* Update the generated example code

* Reverst the changes of GetRootAs

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

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

@@ -31,18 +31,15 @@ class TableInNestedNS(object):
return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
return 0
def Start(builder): builder.StartObject(1)
def TableInNestedNSStart(builder):
"""This method is deprecated. Please switch to Start."""
return Start(builder)
def AddFoo(builder, foo): builder.PrependInt32Slot(0, foo, 0)
def TableInNestedNSAddFoo(builder, foo):
"""This method is deprecated. Please switch to AddFoo."""
return AddFoo(builder, foo)
def End(builder): return builder.EndObject()
def TableInNestedNSEnd(builder):
"""This method is deprecated. Please switch to End."""
return End(builder)
def TableInNestedNSStart(builder): builder.StartObject(1)
def Start(builder):
return TableInNestedNSStart(builder)
def TableInNestedNSAddFoo(builder, foo): builder.PrependInt32Slot(0, foo, 0)
def AddFoo(builder, foo):
return TableInNestedNSAddFoo(builder, foo)
def TableInNestedNSEnd(builder): return builder.EndObject()
def End(builder):
return TableInNestedNSEnd(builder)
class TableInNestedNST(object):
@@ -70,7 +67,7 @@ class TableInNestedNST(object):
# TableInNestedNST
def Pack(self, builder):
Start(builder)
AddFoo(builder, self.foo)
tableInNestedNS = End(builder)
TableInNestedNSStart(builder)
TableInNestedNSAddFoo(builder, self.foo)
tableInNestedNS = TableInNestedNSEnd(builder)
return tableInNestedNS

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

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

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

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

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

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