spacedatastandards.org 1.73.0__py3-none-any.whl

XTC/AbsoluteTimeParameterType.py

@@ -0,0 +1,321 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Absolute time parameter type
+class AbsoluteTimeParameterType(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = AbsoluteTimeParameterType()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsAbsoluteTimeParameterType(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def AbsoluteTimeParameterTypeBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # AbsoluteTimeParameterType
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Type name
+    # AbsoluteTimeParameterType
+    def NAME(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Short description
+    # AbsoluteTimeParameterType
+    def SHORT_DESCRIPTION(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Long description
+    # AbsoluteTimeParameterType
+    def LONG_DESCRIPTION(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Reference epoch
+    # AbsoluteTimeParameterType
+    def EPOCH(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+        return 2
+
+    # Custom epoch date (ISO 8601) when EPOCH=CUSTOM
+    # AbsoluteTimeParameterType
+    def EPOCH_DATE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Data encoding
+    # AbsoluteTimeParameterType
+    def DATA_ENCODING(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from IntegerDataEncoding import IntegerDataEncoding
+            obj = IntegerDataEncoding()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Time unit scale factor
+    # AbsoluteTimeParameterType
+    def SCALE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # Time unit offset
+    # AbsoluteTimeParameterType
+    def OFFSET(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # Default alarm
+    # AbsoluteTimeParameterType
+    def DEFAULT_ALARM(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from DefaultAlarm import DefaultAlarm
+            obj = DefaultAlarm()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Context alarms
+    # AbsoluteTimeParameterType
+    def CONTEXT_ALARMS(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 ContextAlarm import ContextAlarm
+            obj = ContextAlarm()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # AbsoluteTimeParameterType
+    def CONTEXT_ALARMSLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # AbsoluteTimeParameterType
+    def CONTEXT_ALARMSIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        return o == 0
+
+def AbsoluteTimeParameterTypeStart(builder):
+    builder.StartObject(10)
+
+def Start(builder):
+    AbsoluteTimeParameterTypeStart(builder)
+
+def AbsoluteTimeParameterTypeAddNAME(builder, NAME):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(NAME), 0)
+
+def AddNAME(builder, NAME):
+    AbsoluteTimeParameterTypeAddNAME(builder, NAME)
+
+def AbsoluteTimeParameterTypeAddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(SHORT_DESCRIPTION), 0)
+
+def AddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION):
+    AbsoluteTimeParameterTypeAddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION)
+
+def AbsoluteTimeParameterTypeAddLONG_DESCRIPTION(builder, LONG_DESCRIPTION):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(LONG_DESCRIPTION), 0)
+
+def AddLONG_DESCRIPTION(builder, LONG_DESCRIPTION):
+    AbsoluteTimeParameterTypeAddLONG_DESCRIPTION(builder, LONG_DESCRIPTION)
+
+def AbsoluteTimeParameterTypeAddEPOCH(builder, EPOCH):
+    builder.PrependInt8Slot(3, EPOCH, 2)
+
+def AddEPOCH(builder, EPOCH):
+    AbsoluteTimeParameterTypeAddEPOCH(builder, EPOCH)
+
+def AbsoluteTimeParameterTypeAddEPOCH_DATE(builder, EPOCH_DATE):
+    builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(EPOCH_DATE), 0)
+
+def AddEPOCH_DATE(builder, EPOCH_DATE):
+    AbsoluteTimeParameterTypeAddEPOCH_DATE(builder, EPOCH_DATE)
+
+def AbsoluteTimeParameterTypeAddDATA_ENCODING(builder, DATA_ENCODING):
+    builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(DATA_ENCODING), 0)
+
+def AddDATA_ENCODING(builder, DATA_ENCODING):
+    AbsoluteTimeParameterTypeAddDATA_ENCODING(builder, DATA_ENCODING)
+
+def AbsoluteTimeParameterTypeAddSCALE(builder, SCALE):
+    builder.PrependFloat64Slot(6, SCALE, 0.0)
+
+def AddSCALE(builder, SCALE):
+    AbsoluteTimeParameterTypeAddSCALE(builder, SCALE)
+
+def AbsoluteTimeParameterTypeAddOFFSET(builder, OFFSET):
+    builder.PrependFloat64Slot(7, OFFSET, 0.0)
+
+def AddOFFSET(builder, OFFSET):
+    AbsoluteTimeParameterTypeAddOFFSET(builder, OFFSET)
+
+def AbsoluteTimeParameterTypeAddDEFAULT_ALARM(builder, DEFAULT_ALARM):
+    builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(DEFAULT_ALARM), 0)
+
+def AddDEFAULT_ALARM(builder, DEFAULT_ALARM):
+    AbsoluteTimeParameterTypeAddDEFAULT_ALARM(builder, DEFAULT_ALARM)
+
+def AbsoluteTimeParameterTypeAddCONTEXT_ALARMS(builder, CONTEXT_ALARMS):
+    builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(CONTEXT_ALARMS), 0)
+
+def AddCONTEXT_ALARMS(builder, CONTEXT_ALARMS):
+    AbsoluteTimeParameterTypeAddCONTEXT_ALARMS(builder, CONTEXT_ALARMS)
+
+def AbsoluteTimeParameterTypeStartCONTEXT_ALARMSVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartCONTEXT_ALARMSVector(builder, numElems):
+    return AbsoluteTimeParameterTypeStartCONTEXT_ALARMSVector(builder, numElems)
+
+def AbsoluteTimeParameterTypeEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return AbsoluteTimeParameterTypeEnd(builder)
+
+import ContextAlarm
+import DefaultAlarm
+import IntegerDataEncoding
+try:
+    from typing import List, Optional
+except:
+    pass
+
+class AbsoluteTimeParameterTypeT(object):
+
+    # AbsoluteTimeParameterTypeT
+    def __init__(self):
+        self.NAME = None  # type: str
+        self.SHORT_DESCRIPTION = None  # type: str
+        self.LONG_DESCRIPTION = None  # type: str
+        self.EPOCH = 2  # type: int
+        self.EPOCH_DATE = None  # type: str
+        self.DATA_ENCODING = None  # type: Optional[IntegerDataEncoding.IntegerDataEncodingT]
+        self.SCALE = 0.0  # type: float
+        self.OFFSET = 0.0  # type: float
+        self.DEFAULT_ALARM = None  # type: Optional[DefaultAlarm.DefaultAlarmT]
+        self.CONTEXT_ALARMS = None  # type: List[ContextAlarm.ContextAlarmT]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        absoluteTimeParameterType = AbsoluteTimeParameterType()
+        absoluteTimeParameterType.Init(buf, pos)
+        return cls.InitFromObj(absoluteTimeParameterType)
+
+    @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, absoluteTimeParameterType):
+        x = AbsoluteTimeParameterTypeT()
+        x._UnPack(absoluteTimeParameterType)
+        return x
+
+    # AbsoluteTimeParameterTypeT
+    def _UnPack(self, absoluteTimeParameterType):
+        if absoluteTimeParameterType is None:
+            return
+        self.NAME = absoluteTimeParameterType.NAME()
+        self.SHORT_DESCRIPTION = absoluteTimeParameterType.SHORT_DESCRIPTION()
+        self.LONG_DESCRIPTION = absoluteTimeParameterType.LONG_DESCRIPTION()
+        self.EPOCH = absoluteTimeParameterType.EPOCH()
+        self.EPOCH_DATE = absoluteTimeParameterType.EPOCH_DATE()
+        if absoluteTimeParameterType.DATA_ENCODING() is not None:
+            self.DATA_ENCODING = IntegerDataEncoding.IntegerDataEncodingT.InitFromObj(absoluteTimeParameterType.DATA_ENCODING())
+        self.SCALE = absoluteTimeParameterType.SCALE()
+        self.OFFSET = absoluteTimeParameterType.OFFSET()
+        if absoluteTimeParameterType.DEFAULT_ALARM() is not None:
+            self.DEFAULT_ALARM = DefaultAlarm.DefaultAlarmT.InitFromObj(absoluteTimeParameterType.DEFAULT_ALARM())
+        if not absoluteTimeParameterType.CONTEXT_ALARMSIsNone():
+            self.CONTEXT_ALARMS = []
+            for i in range(absoluteTimeParameterType.CONTEXT_ALARMSLength()):
+                if absoluteTimeParameterType.CONTEXT_ALARMS(i) is None:
+                    self.CONTEXT_ALARMS.append(None)
+                else:
+                    contextAlarm_ = ContextAlarm.ContextAlarmT.InitFromObj(absoluteTimeParameterType.CONTEXT_ALARMS(i))
+                    self.CONTEXT_ALARMS.append(contextAlarm_)
+
+    # AbsoluteTimeParameterTypeT
+    def Pack(self, builder):
+        if self.NAME is not None:
+            NAME = builder.CreateString(self.NAME)
+        if self.SHORT_DESCRIPTION is not None:
+            SHORT_DESCRIPTION = builder.CreateString(self.SHORT_DESCRIPTION)
+        if self.LONG_DESCRIPTION is not None:
+            LONG_DESCRIPTION = builder.CreateString(self.LONG_DESCRIPTION)
+        if self.EPOCH_DATE is not None:
+            EPOCH_DATE = builder.CreateString(self.EPOCH_DATE)
+        if self.DATA_ENCODING is not None:
+            DATA_ENCODING = self.DATA_ENCODING.Pack(builder)
+        if self.DEFAULT_ALARM is not None:
+            DEFAULT_ALARM = self.DEFAULT_ALARM.Pack(builder)
+        if self.CONTEXT_ALARMS is not None:
+            CONTEXT_ALARMSlist = []
+            for i in range(len(self.CONTEXT_ALARMS)):
+                CONTEXT_ALARMSlist.append(self.CONTEXT_ALARMS[i].Pack(builder))
+            AbsoluteTimeParameterTypeStartCONTEXT_ALARMSVector(builder, len(self.CONTEXT_ALARMS))
+            for i in reversed(range(len(self.CONTEXT_ALARMS))):
+                builder.PrependUOffsetTRelative(CONTEXT_ALARMSlist[i])
+            CONTEXT_ALARMS = builder.EndVector()
+        AbsoluteTimeParameterTypeStart(builder)
+        if self.NAME is not None:
+            AbsoluteTimeParameterTypeAddNAME(builder, NAME)
+        if self.SHORT_DESCRIPTION is not None:
+            AbsoluteTimeParameterTypeAddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION)
+        if self.LONG_DESCRIPTION is not None:
+            AbsoluteTimeParameterTypeAddLONG_DESCRIPTION(builder, LONG_DESCRIPTION)
+        AbsoluteTimeParameterTypeAddEPOCH(builder, self.EPOCH)
+        if self.EPOCH_DATE is not None:
+            AbsoluteTimeParameterTypeAddEPOCH_DATE(builder, EPOCH_DATE)
+        if self.DATA_ENCODING is not None:
+            AbsoluteTimeParameterTypeAddDATA_ENCODING(builder, DATA_ENCODING)
+        AbsoluteTimeParameterTypeAddSCALE(builder, self.SCALE)
+        AbsoluteTimeParameterTypeAddOFFSET(builder, self.OFFSET)
+        if self.DEFAULT_ALARM is not None:
+            AbsoluteTimeParameterTypeAddDEFAULT_ALARM(builder, DEFAULT_ALARM)
+        if self.CONTEXT_ALARMS is not None:
+            AbsoluteTimeParameterTypeAddCONTEXT_ALARMS(builder, CONTEXT_ALARMS)
+        absoluteTimeParameterType = AbsoluteTimeParameterTypeEnd(builder)
+        return absoluteTimeParameterType

XTC/AggregateArgumentType.py

@@ -0,0 +1,198 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Aggregate argument type
+class AggregateArgumentType(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = AggregateArgumentType()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsAggregateArgumentType(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def AggregateArgumentTypeBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # AggregateArgumentType
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Type name
+    # AggregateArgumentType
+    def NAME(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Short description
+    # AggregateArgumentType
+    def SHORT_DESCRIPTION(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Long description
+    # AggregateArgumentType
+    def LONG_DESCRIPTION(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Member list
+    # AggregateArgumentType
+    def MEMBERS(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 AggregateMember import AggregateMember
+            obj = AggregateMember()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # AggregateArgumentType
+    def MEMBERSLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # AggregateArgumentType
+    def MEMBERSIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        return o == 0
+
+def AggregateArgumentTypeStart(builder):
+    builder.StartObject(4)
+
+def Start(builder):
+    AggregateArgumentTypeStart(builder)
+
+def AggregateArgumentTypeAddNAME(builder, NAME):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(NAME), 0)
+
+def AddNAME(builder, NAME):
+    AggregateArgumentTypeAddNAME(builder, NAME)
+
+def AggregateArgumentTypeAddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(SHORT_DESCRIPTION), 0)
+
+def AddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION):
+    AggregateArgumentTypeAddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION)
+
+def AggregateArgumentTypeAddLONG_DESCRIPTION(builder, LONG_DESCRIPTION):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(LONG_DESCRIPTION), 0)
+
+def AddLONG_DESCRIPTION(builder, LONG_DESCRIPTION):
+    AggregateArgumentTypeAddLONG_DESCRIPTION(builder, LONG_DESCRIPTION)
+
+def AggregateArgumentTypeAddMEMBERS(builder, MEMBERS):
+    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(MEMBERS), 0)
+
+def AddMEMBERS(builder, MEMBERS):
+    AggregateArgumentTypeAddMEMBERS(builder, MEMBERS)
+
+def AggregateArgumentTypeStartMEMBERSVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartMEMBERSVector(builder, numElems):
+    return AggregateArgumentTypeStartMEMBERSVector(builder, numElems)
+
+def AggregateArgumentTypeEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return AggregateArgumentTypeEnd(builder)
+
+import AggregateMember
+try:
+    from typing import List
+except:
+    pass
+
+class AggregateArgumentTypeT(object):
+
+    # AggregateArgumentTypeT
+    def __init__(self):
+        self.NAME = None  # type: str
+        self.SHORT_DESCRIPTION = None  # type: str
+        self.LONG_DESCRIPTION = None  # type: str
+        self.MEMBERS = None  # type: List[AggregateMember.AggregateMemberT]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        aggregateArgumentType = AggregateArgumentType()
+        aggregateArgumentType.Init(buf, pos)
+        return cls.InitFromObj(aggregateArgumentType)
+
+    @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, aggregateArgumentType):
+        x = AggregateArgumentTypeT()
+        x._UnPack(aggregateArgumentType)
+        return x
+
+    # AggregateArgumentTypeT
+    def _UnPack(self, aggregateArgumentType):
+        if aggregateArgumentType is None:
+            return
+        self.NAME = aggregateArgumentType.NAME()
+        self.SHORT_DESCRIPTION = aggregateArgumentType.SHORT_DESCRIPTION()
+        self.LONG_DESCRIPTION = aggregateArgumentType.LONG_DESCRIPTION()
+        if not aggregateArgumentType.MEMBERSIsNone():
+            self.MEMBERS = []
+            for i in range(aggregateArgumentType.MEMBERSLength()):
+                if aggregateArgumentType.MEMBERS(i) is None:
+                    self.MEMBERS.append(None)
+                else:
+                    aggregateMember_ = AggregateMember.AggregateMemberT.InitFromObj(aggregateArgumentType.MEMBERS(i))
+                    self.MEMBERS.append(aggregateMember_)
+
+    # AggregateArgumentTypeT
+    def Pack(self, builder):
+        if self.NAME is not None:
+            NAME = builder.CreateString(self.NAME)
+        if self.SHORT_DESCRIPTION is not None:
+            SHORT_DESCRIPTION = builder.CreateString(self.SHORT_DESCRIPTION)
+        if self.LONG_DESCRIPTION is not None:
+            LONG_DESCRIPTION = builder.CreateString(self.LONG_DESCRIPTION)
+        if self.MEMBERS is not None:
+            MEMBERSlist = []
+            for i in range(len(self.MEMBERS)):
+                MEMBERSlist.append(self.MEMBERS[i].Pack(builder))
+            AggregateArgumentTypeStartMEMBERSVector(builder, len(self.MEMBERS))
+            for i in reversed(range(len(self.MEMBERS))):
+                builder.PrependUOffsetTRelative(MEMBERSlist[i])
+            MEMBERS = builder.EndVector()
+        AggregateArgumentTypeStart(builder)
+        if self.NAME is not None:
+            AggregateArgumentTypeAddNAME(builder, NAME)
+        if self.SHORT_DESCRIPTION is not None:
+            AggregateArgumentTypeAddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION)
+        if self.LONG_DESCRIPTION is not None:
+            AggregateArgumentTypeAddLONG_DESCRIPTION(builder, LONG_DESCRIPTION)
+        if self.MEMBERS is not None:
+            AggregateArgumentTypeAddMEMBERS(builder, MEMBERS)
+        aggregateArgumentType = AggregateArgumentTypeEnd(builder)
+        return aggregateArgumentType

XTC/AggregateMember.py

@@ -0,0 +1,136 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Aggregate member definition
+class AggregateMember(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = AggregateMember()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsAggregateMember(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def AggregateMemberBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # AggregateMember
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Member name
+    # AggregateMember
+    def NAME(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Reference to parameter type
+    # AggregateMember
+    def TYPE_REF(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Short description
+    # AggregateMember
+    def SHORT_DESCRIPTION(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+def AggregateMemberStart(builder):
+    builder.StartObject(3)
+
+def Start(builder):
+    AggregateMemberStart(builder)
+
+def AggregateMemberAddNAME(builder, NAME):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(NAME), 0)
+
+def AddNAME(builder, NAME):
+    AggregateMemberAddNAME(builder, NAME)
+
+def AggregateMemberAddTYPE_REF(builder, TYPE_REF):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(TYPE_REF), 0)
+
+def AddTYPE_REF(builder, TYPE_REF):
+    AggregateMemberAddTYPE_REF(builder, TYPE_REF)
+
+def AggregateMemberAddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(SHORT_DESCRIPTION), 0)
+
+def AddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION):
+    AggregateMemberAddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION)
+
+def AggregateMemberEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return AggregateMemberEnd(builder)
+
+
+class AggregateMemberT(object):
+
+    # AggregateMemberT
+    def __init__(self):
+        self.NAME = None  # type: str
+        self.TYPE_REF = None  # type: str
+        self.SHORT_DESCRIPTION = None  # type: str
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        aggregateMember = AggregateMember()
+        aggregateMember.Init(buf, pos)
+        return cls.InitFromObj(aggregateMember)
+
+    @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, aggregateMember):
+        x = AggregateMemberT()
+        x._UnPack(aggregateMember)
+        return x
+
+    # AggregateMemberT
+    def _UnPack(self, aggregateMember):
+        if aggregateMember is None:
+            return
+        self.NAME = aggregateMember.NAME()
+        self.TYPE_REF = aggregateMember.TYPE_REF()
+        self.SHORT_DESCRIPTION = aggregateMember.SHORT_DESCRIPTION()
+
+    # AggregateMemberT
+    def Pack(self, builder):
+        if self.NAME is not None:
+            NAME = builder.CreateString(self.NAME)
+        if self.TYPE_REF is not None:
+            TYPE_REF = builder.CreateString(self.TYPE_REF)
+        if self.SHORT_DESCRIPTION is not None:
+            SHORT_DESCRIPTION = builder.CreateString(self.SHORT_DESCRIPTION)
+        AggregateMemberStart(builder)
+        if self.NAME is not None:
+            AggregateMemberAddNAME(builder, NAME)
+        if self.TYPE_REF is not None:
+            AggregateMemberAddTYPE_REF(builder, TYPE_REF)
+        if self.SHORT_DESCRIPTION is not None:
+            AggregateMemberAddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION)
+        aggregateMember = AggregateMemberEnd(builder)
+        return aggregateMember