spacedatastandards.org 1.73.0__py3-none-any.whl

XTC/ParameterTypeSet.py

@@ -0,0 +1,660 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Collection of all parameter types
+class ParameterTypeSet(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = ParameterTypeSet()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsParameterTypeSet(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def ParameterTypeSetBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # ParameterTypeSet
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Integer parameter types
+    # ParameterTypeSet
+    def INTEGER_TYPES(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            from IntegerParameterType import IntegerParameterType
+            obj = IntegerParameterType()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # ParameterTypeSet
+    def INTEGER_TYPESLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # ParameterTypeSet
+    def INTEGER_TYPESIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        return o == 0
+
+    # Float parameter types
+    # ParameterTypeSet
+    def FLOAT_TYPES(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            from FloatParameterType import FloatParameterType
+            obj = FloatParameterType()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # ParameterTypeSet
+    def FLOAT_TYPESLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # ParameterTypeSet
+    def FLOAT_TYPESIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        return o == 0
+
+    # String parameter types
+    # ParameterTypeSet
+    def STRING_TYPES(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            from StringParameterType import StringParameterType
+            obj = StringParameterType()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # ParameterTypeSet
+    def STRING_TYPESLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # ParameterTypeSet
+    def STRING_TYPESIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        return o == 0
+
+    # Boolean parameter types
+    # ParameterTypeSet
+    def BOOLEAN_TYPES(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            from BooleanParameterType import BooleanParameterType
+            obj = BooleanParameterType()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # ParameterTypeSet
+    def BOOLEAN_TYPESLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # ParameterTypeSet
+    def BOOLEAN_TYPESIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        return o == 0
+
+    # Enumerated parameter types
+    # ParameterTypeSet
+    def ENUMERATED_TYPES(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            from EnumeratedParameterType import EnumeratedParameterType
+            obj = EnumeratedParameterType()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # ParameterTypeSet
+    def ENUMERATED_TYPESLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # ParameterTypeSet
+    def ENUMERATED_TYPESIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        return o == 0
+
+    # Binary parameter types
+    # ParameterTypeSet
+    def BINARY_TYPES(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            from BinaryParameterType import BinaryParameterType
+            obj = BinaryParameterType()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # ParameterTypeSet
+    def BINARY_TYPESLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # ParameterTypeSet
+    def BINARY_TYPESIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        return o == 0
+
+    # Absolute time parameter types
+    # ParameterTypeSet
+    def ABSOLUTE_TIME_TYPES(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            from AbsoluteTimeParameterType import AbsoluteTimeParameterType
+            obj = AbsoluteTimeParameterType()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # ParameterTypeSet
+    def ABSOLUTE_TIME_TYPESLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # ParameterTypeSet
+    def ABSOLUTE_TIME_TYPESIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        return o == 0
+
+    # Relative time parameter types
+    # ParameterTypeSet
+    def RELATIVE_TIME_TYPES(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            from RelativeTimeParameterType import RelativeTimeParameterType
+            obj = RelativeTimeParameterType()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # ParameterTypeSet
+    def RELATIVE_TIME_TYPESLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # ParameterTypeSet
+    def RELATIVE_TIME_TYPESIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        return o == 0
+
+    # Array parameter types
+    # ParameterTypeSet
+    def ARRAY_TYPES(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            from ArrayParameterType import ArrayParameterType
+            obj = ArrayParameterType()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # ParameterTypeSet
+    def ARRAY_TYPESLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # ParameterTypeSet
+    def ARRAY_TYPESIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        return o == 0
+
+    # Aggregate parameter types
+    # ParameterTypeSet
+    def AGGREGATE_TYPES(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            from AggregateParameterType import AggregateParameterType
+            obj = AggregateParameterType()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # ParameterTypeSet
+    def AGGREGATE_TYPESLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # ParameterTypeSet
+    def AGGREGATE_TYPESIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        return o == 0
+
+def ParameterTypeSetStart(builder):
+    builder.StartObject(10)
+
+def Start(builder):
+    ParameterTypeSetStart(builder)
+
+def ParameterTypeSetAddINTEGER_TYPES(builder, INTEGER_TYPES):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(INTEGER_TYPES), 0)
+
+def AddINTEGER_TYPES(builder, INTEGER_TYPES):
+    ParameterTypeSetAddINTEGER_TYPES(builder, INTEGER_TYPES)
+
+def ParameterTypeSetStartINTEGER_TYPESVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartINTEGER_TYPESVector(builder, numElems):
+    return ParameterTypeSetStartINTEGER_TYPESVector(builder, numElems)
+
+def ParameterTypeSetAddFLOAT_TYPES(builder, FLOAT_TYPES):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(FLOAT_TYPES), 0)
+
+def AddFLOAT_TYPES(builder, FLOAT_TYPES):
+    ParameterTypeSetAddFLOAT_TYPES(builder, FLOAT_TYPES)
+
+def ParameterTypeSetStartFLOAT_TYPESVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartFLOAT_TYPESVector(builder, numElems):
+    return ParameterTypeSetStartFLOAT_TYPESVector(builder, numElems)
+
+def ParameterTypeSetAddSTRING_TYPES(builder, STRING_TYPES):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(STRING_TYPES), 0)
+
+def AddSTRING_TYPES(builder, STRING_TYPES):
+    ParameterTypeSetAddSTRING_TYPES(builder, STRING_TYPES)
+
+def ParameterTypeSetStartSTRING_TYPESVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartSTRING_TYPESVector(builder, numElems):
+    return ParameterTypeSetStartSTRING_TYPESVector(builder, numElems)
+
+def ParameterTypeSetAddBOOLEAN_TYPES(builder, BOOLEAN_TYPES):
+    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(BOOLEAN_TYPES), 0)
+
+def AddBOOLEAN_TYPES(builder, BOOLEAN_TYPES):
+    ParameterTypeSetAddBOOLEAN_TYPES(builder, BOOLEAN_TYPES)
+
+def ParameterTypeSetStartBOOLEAN_TYPESVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartBOOLEAN_TYPESVector(builder, numElems):
+    return ParameterTypeSetStartBOOLEAN_TYPESVector(builder, numElems)
+
+def ParameterTypeSetAddENUMERATED_TYPES(builder, ENUMERATED_TYPES):
+    builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(ENUMERATED_TYPES), 0)
+
+def AddENUMERATED_TYPES(builder, ENUMERATED_TYPES):
+    ParameterTypeSetAddENUMERATED_TYPES(builder, ENUMERATED_TYPES)
+
+def ParameterTypeSetStartENUMERATED_TYPESVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartENUMERATED_TYPESVector(builder, numElems):
+    return ParameterTypeSetStartENUMERATED_TYPESVector(builder, numElems)
+
+def ParameterTypeSetAddBINARY_TYPES(builder, BINARY_TYPES):
+    builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(BINARY_TYPES), 0)
+
+def AddBINARY_TYPES(builder, BINARY_TYPES):
+    ParameterTypeSetAddBINARY_TYPES(builder, BINARY_TYPES)
+
+def ParameterTypeSetStartBINARY_TYPESVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartBINARY_TYPESVector(builder, numElems):
+    return ParameterTypeSetStartBINARY_TYPESVector(builder, numElems)
+
+def ParameterTypeSetAddABSOLUTE_TIME_TYPES(builder, ABSOLUTE_TIME_TYPES):
+    builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(ABSOLUTE_TIME_TYPES), 0)
+
+def AddABSOLUTE_TIME_TYPES(builder, ABSOLUTE_TIME_TYPES):
+    ParameterTypeSetAddABSOLUTE_TIME_TYPES(builder, ABSOLUTE_TIME_TYPES)
+
+def ParameterTypeSetStartABSOLUTE_TIME_TYPESVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartABSOLUTE_TIME_TYPESVector(builder, numElems):
+    return ParameterTypeSetStartABSOLUTE_TIME_TYPESVector(builder, numElems)
+
+def ParameterTypeSetAddRELATIVE_TIME_TYPES(builder, RELATIVE_TIME_TYPES):
+    builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(RELATIVE_TIME_TYPES), 0)
+
+def AddRELATIVE_TIME_TYPES(builder, RELATIVE_TIME_TYPES):
+    ParameterTypeSetAddRELATIVE_TIME_TYPES(builder, RELATIVE_TIME_TYPES)
+
+def ParameterTypeSetStartRELATIVE_TIME_TYPESVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartRELATIVE_TIME_TYPESVector(builder, numElems):
+    return ParameterTypeSetStartRELATIVE_TIME_TYPESVector(builder, numElems)
+
+def ParameterTypeSetAddARRAY_TYPES(builder, ARRAY_TYPES):
+    builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(ARRAY_TYPES), 0)
+
+def AddARRAY_TYPES(builder, ARRAY_TYPES):
+    ParameterTypeSetAddARRAY_TYPES(builder, ARRAY_TYPES)
+
+def ParameterTypeSetStartARRAY_TYPESVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartARRAY_TYPESVector(builder, numElems):
+    return ParameterTypeSetStartARRAY_TYPESVector(builder, numElems)
+
+def ParameterTypeSetAddAGGREGATE_TYPES(builder, AGGREGATE_TYPES):
+    builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(AGGREGATE_TYPES), 0)
+
+def AddAGGREGATE_TYPES(builder, AGGREGATE_TYPES):
+    ParameterTypeSetAddAGGREGATE_TYPES(builder, AGGREGATE_TYPES)
+
+def ParameterTypeSetStartAGGREGATE_TYPESVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartAGGREGATE_TYPESVector(builder, numElems):
+    return ParameterTypeSetStartAGGREGATE_TYPESVector(builder, numElems)
+
+def ParameterTypeSetEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return ParameterTypeSetEnd(builder)
+
+import AbsoluteTimeParameterType
+import AggregateParameterType
+import ArrayParameterType
+import BinaryParameterType
+import BooleanParameterType
+import EnumeratedParameterType
+import FloatParameterType
+import IntegerParameterType
+import RelativeTimeParameterType
+import StringParameterType
+try:
+    from typing import List
+except:
+    pass
+
+class ParameterTypeSetT(object):
+
+    # ParameterTypeSetT
+    def __init__(self):
+        self.INTEGER_TYPES = None  # type: List[IntegerParameterType.IntegerParameterTypeT]
+        self.FLOAT_TYPES = None  # type: List[FloatParameterType.FloatParameterTypeT]
+        self.STRING_TYPES = None  # type: List[StringParameterType.StringParameterTypeT]
+        self.BOOLEAN_TYPES = None  # type: List[BooleanParameterType.BooleanParameterTypeT]
+        self.ENUMERATED_TYPES = None  # type: List[EnumeratedParameterType.EnumeratedParameterTypeT]
+        self.BINARY_TYPES = None  # type: List[BinaryParameterType.BinaryParameterTypeT]
+        self.ABSOLUTE_TIME_TYPES = None  # type: List[AbsoluteTimeParameterType.AbsoluteTimeParameterTypeT]
+        self.RELATIVE_TIME_TYPES = None  # type: List[RelativeTimeParameterType.RelativeTimeParameterTypeT]
+        self.ARRAY_TYPES = None  # type: List[ArrayParameterType.ArrayParameterTypeT]
+        self.AGGREGATE_TYPES = None  # type: List[AggregateParameterType.AggregateParameterTypeT]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        parameterTypeSet = ParameterTypeSet()
+        parameterTypeSet.Init(buf, pos)
+        return cls.InitFromObj(parameterTypeSet)
+
+    @classmethod
+    def InitFromPackedBuf(cls, buf, pos=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos)
+        return cls.InitFromBuf(buf, pos+n)
+
+    @classmethod
+    def InitFromObj(cls, parameterTypeSet):
+        x = ParameterTypeSetT()
+        x._UnPack(parameterTypeSet)
+        return x
+
+    # ParameterTypeSetT
+    def _UnPack(self, parameterTypeSet):
+        if parameterTypeSet is None:
+            return
+        if not parameterTypeSet.INTEGER_TYPESIsNone():
+            self.INTEGER_TYPES = []
+            for i in range(parameterTypeSet.INTEGER_TYPESLength()):
+                if parameterTypeSet.INTEGER_TYPES(i) is None:
+                    self.INTEGER_TYPES.append(None)
+                else:
+                    integerParameterType_ = IntegerParameterType.IntegerParameterTypeT.InitFromObj(parameterTypeSet.INTEGER_TYPES(i))
+                    self.INTEGER_TYPES.append(integerParameterType_)
+        if not parameterTypeSet.FLOAT_TYPESIsNone():
+            self.FLOAT_TYPES = []
+            for i in range(parameterTypeSet.FLOAT_TYPESLength()):
+                if parameterTypeSet.FLOAT_TYPES(i) is None:
+                    self.FLOAT_TYPES.append(None)
+                else:
+                    floatParameterType_ = FloatParameterType.FloatParameterTypeT.InitFromObj(parameterTypeSet.FLOAT_TYPES(i))
+                    self.FLOAT_TYPES.append(floatParameterType_)
+        if not parameterTypeSet.STRING_TYPESIsNone():
+            self.STRING_TYPES = []
+            for i in range(parameterTypeSet.STRING_TYPESLength()):
+                if parameterTypeSet.STRING_TYPES(i) is None:
+                    self.STRING_TYPES.append(None)
+                else:
+                    stringParameterType_ = StringParameterType.StringParameterTypeT.InitFromObj(parameterTypeSet.STRING_TYPES(i))
+                    self.STRING_TYPES.append(stringParameterType_)
+        if not parameterTypeSet.BOOLEAN_TYPESIsNone():
+            self.BOOLEAN_TYPES = []
+            for i in range(parameterTypeSet.BOOLEAN_TYPESLength()):
+                if parameterTypeSet.BOOLEAN_TYPES(i) is None:
+                    self.BOOLEAN_TYPES.append(None)
+                else:
+                    booleanParameterType_ = BooleanParameterType.BooleanParameterTypeT.InitFromObj(parameterTypeSet.BOOLEAN_TYPES(i))
+                    self.BOOLEAN_TYPES.append(booleanParameterType_)
+        if not parameterTypeSet.ENUMERATED_TYPESIsNone():
+            self.ENUMERATED_TYPES = []
+            for i in range(parameterTypeSet.ENUMERATED_TYPESLength()):
+                if parameterTypeSet.ENUMERATED_TYPES(i) is None:
+                    self.ENUMERATED_TYPES.append(None)
+                else:
+                    enumeratedParameterType_ = EnumeratedParameterType.EnumeratedParameterTypeT.InitFromObj(parameterTypeSet.ENUMERATED_TYPES(i))
+                    self.ENUMERATED_TYPES.append(enumeratedParameterType_)
+        if not parameterTypeSet.BINARY_TYPESIsNone():
+            self.BINARY_TYPES = []
+            for i in range(parameterTypeSet.BINARY_TYPESLength()):
+                if parameterTypeSet.BINARY_TYPES(i) is None:
+                    self.BINARY_TYPES.append(None)
+                else:
+                    binaryParameterType_ = BinaryParameterType.BinaryParameterTypeT.InitFromObj(parameterTypeSet.BINARY_TYPES(i))
+                    self.BINARY_TYPES.append(binaryParameterType_)
+        if not parameterTypeSet.ABSOLUTE_TIME_TYPESIsNone():
+            self.ABSOLUTE_TIME_TYPES = []
+            for i in range(parameterTypeSet.ABSOLUTE_TIME_TYPESLength()):
+                if parameterTypeSet.ABSOLUTE_TIME_TYPES(i) is None:
+                    self.ABSOLUTE_TIME_TYPES.append(None)
+                else:
+                    absoluteTimeParameterType_ = AbsoluteTimeParameterType.AbsoluteTimeParameterTypeT.InitFromObj(parameterTypeSet.ABSOLUTE_TIME_TYPES(i))
+                    self.ABSOLUTE_TIME_TYPES.append(absoluteTimeParameterType_)
+        if not parameterTypeSet.RELATIVE_TIME_TYPESIsNone():
+            self.RELATIVE_TIME_TYPES = []
+            for i in range(parameterTypeSet.RELATIVE_TIME_TYPESLength()):
+                if parameterTypeSet.RELATIVE_TIME_TYPES(i) is None:
+                    self.RELATIVE_TIME_TYPES.append(None)
+                else:
+                    relativeTimeParameterType_ = RelativeTimeParameterType.RelativeTimeParameterTypeT.InitFromObj(parameterTypeSet.RELATIVE_TIME_TYPES(i))
+                    self.RELATIVE_TIME_TYPES.append(relativeTimeParameterType_)
+        if not parameterTypeSet.ARRAY_TYPESIsNone():
+            self.ARRAY_TYPES = []
+            for i in range(parameterTypeSet.ARRAY_TYPESLength()):
+                if parameterTypeSet.ARRAY_TYPES(i) is None:
+                    self.ARRAY_TYPES.append(None)
+                else:
+                    arrayParameterType_ = ArrayParameterType.ArrayParameterTypeT.InitFromObj(parameterTypeSet.ARRAY_TYPES(i))
+                    self.ARRAY_TYPES.append(arrayParameterType_)
+        if not parameterTypeSet.AGGREGATE_TYPESIsNone():
+            self.AGGREGATE_TYPES = []
+            for i in range(parameterTypeSet.AGGREGATE_TYPESLength()):
+                if parameterTypeSet.AGGREGATE_TYPES(i) is None:
+                    self.AGGREGATE_TYPES.append(None)
+                else:
+                    aggregateParameterType_ = AggregateParameterType.AggregateParameterTypeT.InitFromObj(parameterTypeSet.AGGREGATE_TYPES(i))
+                    self.AGGREGATE_TYPES.append(aggregateParameterType_)
+
+    # ParameterTypeSetT
+    def Pack(self, builder):
+        if self.INTEGER_TYPES is not None:
+            INTEGER_TYPESlist = []
+            for i in range(len(self.INTEGER_TYPES)):
+                INTEGER_TYPESlist.append(self.INTEGER_TYPES[i].Pack(builder))
+            ParameterTypeSetStartINTEGER_TYPESVector(builder, len(self.INTEGER_TYPES))
+            for i in reversed(range(len(self.INTEGER_TYPES))):
+                builder.PrependUOffsetTRelative(INTEGER_TYPESlist[i])
+            INTEGER_TYPES = builder.EndVector()
+        if self.FLOAT_TYPES is not None:
+            FLOAT_TYPESlist = []
+            for i in range(len(self.FLOAT_TYPES)):
+                FLOAT_TYPESlist.append(self.FLOAT_TYPES[i].Pack(builder))
+            ParameterTypeSetStartFLOAT_TYPESVector(builder, len(self.FLOAT_TYPES))
+            for i in reversed(range(len(self.FLOAT_TYPES))):
+                builder.PrependUOffsetTRelative(FLOAT_TYPESlist[i])
+            FLOAT_TYPES = builder.EndVector()
+        if self.STRING_TYPES is not None:
+            STRING_TYPESlist = []
+            for i in range(len(self.STRING_TYPES)):
+                STRING_TYPESlist.append(self.STRING_TYPES[i].Pack(builder))
+            ParameterTypeSetStartSTRING_TYPESVector(builder, len(self.STRING_TYPES))
+            for i in reversed(range(len(self.STRING_TYPES))):
+                builder.PrependUOffsetTRelative(STRING_TYPESlist[i])
+            STRING_TYPES = builder.EndVector()
+        if self.BOOLEAN_TYPES is not None:
+            BOOLEAN_TYPESlist = []
+            for i in range(len(self.BOOLEAN_TYPES)):
+                BOOLEAN_TYPESlist.append(self.BOOLEAN_TYPES[i].Pack(builder))
+            ParameterTypeSetStartBOOLEAN_TYPESVector(builder, len(self.BOOLEAN_TYPES))
+            for i in reversed(range(len(self.BOOLEAN_TYPES))):
+                builder.PrependUOffsetTRelative(BOOLEAN_TYPESlist[i])
+            BOOLEAN_TYPES = builder.EndVector()
+        if self.ENUMERATED_TYPES is not None:
+            ENUMERATED_TYPESlist = []
+            for i in range(len(self.ENUMERATED_TYPES)):
+                ENUMERATED_TYPESlist.append(self.ENUMERATED_TYPES[i].Pack(builder))
+            ParameterTypeSetStartENUMERATED_TYPESVector(builder, len(self.ENUMERATED_TYPES))
+            for i in reversed(range(len(self.ENUMERATED_TYPES))):
+                builder.PrependUOffsetTRelative(ENUMERATED_TYPESlist[i])
+            ENUMERATED_TYPES = builder.EndVector()
+        if self.BINARY_TYPES is not None:
+            BINARY_TYPESlist = []
+            for i in range(len(self.BINARY_TYPES)):
+                BINARY_TYPESlist.append(self.BINARY_TYPES[i].Pack(builder))
+            ParameterTypeSetStartBINARY_TYPESVector(builder, len(self.BINARY_TYPES))
+            for i in reversed(range(len(self.BINARY_TYPES))):
+                builder.PrependUOffsetTRelative(BINARY_TYPESlist[i])
+            BINARY_TYPES = builder.EndVector()
+        if self.ABSOLUTE_TIME_TYPES is not None:
+            ABSOLUTE_TIME_TYPESlist = []
+            for i in range(len(self.ABSOLUTE_TIME_TYPES)):
+                ABSOLUTE_TIME_TYPESlist.append(self.ABSOLUTE_TIME_TYPES[i].Pack(builder))
+            ParameterTypeSetStartABSOLUTE_TIME_TYPESVector(builder, len(self.ABSOLUTE_TIME_TYPES))
+            for i in reversed(range(len(self.ABSOLUTE_TIME_TYPES))):
+                builder.PrependUOffsetTRelative(ABSOLUTE_TIME_TYPESlist[i])
+            ABSOLUTE_TIME_TYPES = builder.EndVector()
+        if self.RELATIVE_TIME_TYPES is not None:
+            RELATIVE_TIME_TYPESlist = []
+            for i in range(len(self.RELATIVE_TIME_TYPES)):
+                RELATIVE_TIME_TYPESlist.append(self.RELATIVE_TIME_TYPES[i].Pack(builder))
+            ParameterTypeSetStartRELATIVE_TIME_TYPESVector(builder, len(self.RELATIVE_TIME_TYPES))
+            for i in reversed(range(len(self.RELATIVE_TIME_TYPES))):
+                builder.PrependUOffsetTRelative(RELATIVE_TIME_TYPESlist[i])
+            RELATIVE_TIME_TYPES = builder.EndVector()
+        if self.ARRAY_TYPES is not None:
+            ARRAY_TYPESlist = []
+            for i in range(len(self.ARRAY_TYPES)):
+                ARRAY_TYPESlist.append(self.ARRAY_TYPES[i].Pack(builder))
+            ParameterTypeSetStartARRAY_TYPESVector(builder, len(self.ARRAY_TYPES))
+            for i in reversed(range(len(self.ARRAY_TYPES))):
+                builder.PrependUOffsetTRelative(ARRAY_TYPESlist[i])
+            ARRAY_TYPES = builder.EndVector()
+        if self.AGGREGATE_TYPES is not None:
+            AGGREGATE_TYPESlist = []
+            for i in range(len(self.AGGREGATE_TYPES)):
+                AGGREGATE_TYPESlist.append(self.AGGREGATE_TYPES[i].Pack(builder))
+            ParameterTypeSetStartAGGREGATE_TYPESVector(builder, len(self.AGGREGATE_TYPES))
+            for i in reversed(range(len(self.AGGREGATE_TYPES))):
+                builder.PrependUOffsetTRelative(AGGREGATE_TYPESlist[i])
+            AGGREGATE_TYPES = builder.EndVector()
+        ParameterTypeSetStart(builder)
+        if self.INTEGER_TYPES is not None:
+            ParameterTypeSetAddINTEGER_TYPES(builder, INTEGER_TYPES)
+        if self.FLOAT_TYPES is not None:
+            ParameterTypeSetAddFLOAT_TYPES(builder, FLOAT_TYPES)
+        if self.STRING_TYPES is not None:
+            ParameterTypeSetAddSTRING_TYPES(builder, STRING_TYPES)
+        if self.BOOLEAN_TYPES is not None:
+            ParameterTypeSetAddBOOLEAN_TYPES(builder, BOOLEAN_TYPES)
+        if self.ENUMERATED_TYPES is not None:
+            ParameterTypeSetAddENUMERATED_TYPES(builder, ENUMERATED_TYPES)
+        if self.BINARY_TYPES is not None:
+            ParameterTypeSetAddBINARY_TYPES(builder, BINARY_TYPES)
+        if self.ABSOLUTE_TIME_TYPES is not None:
+            ParameterTypeSetAddABSOLUTE_TIME_TYPES(builder, ABSOLUTE_TIME_TYPES)
+        if self.RELATIVE_TIME_TYPES is not None:
+            ParameterTypeSetAddRELATIVE_TIME_TYPES(builder, RELATIVE_TIME_TYPES)
+        if self.ARRAY_TYPES is not None:
+            ParameterTypeSetAddARRAY_TYPES(builder, ARRAY_TYPES)
+        if self.AGGREGATE_TYPES is not None:
+            ParameterTypeSetAddAGGREGATE_TYPES(builder, AGGREGATE_TYPES)
+        parameterTypeSet = ParameterTypeSetEnd(builder)
+        return parameterTypeSet