spacedatastandards.org 1.73.0__py3-none-any.whl

XTC/AggregateParameterType.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 parameter type (structure)
+class AggregateParameterType(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = AggregateParameterType()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsAggregateParameterType(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def AggregateParameterTypeBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # AggregateParameterType
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Type name
+    # AggregateParameterType
+    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
+    # AggregateParameterType
+    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
+    # AggregateParameterType
+    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
+    # AggregateParameterType
+    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
+
+    # AggregateParameterType
+    def MEMBERSLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # AggregateParameterType
+    def MEMBERSIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        return o == 0
+
+def AggregateParameterTypeStart(builder):
+    builder.StartObject(4)
+
+def Start(builder):
+    AggregateParameterTypeStart(builder)
+
+def AggregateParameterTypeAddNAME(builder, NAME):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(NAME), 0)
+
+def AddNAME(builder, NAME):
+    AggregateParameterTypeAddNAME(builder, NAME)
+
+def AggregateParameterTypeAddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(SHORT_DESCRIPTION), 0)
+
+def AddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION):
+    AggregateParameterTypeAddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION)
+
+def AggregateParameterTypeAddLONG_DESCRIPTION(builder, LONG_DESCRIPTION):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(LONG_DESCRIPTION), 0)
+
+def AddLONG_DESCRIPTION(builder, LONG_DESCRIPTION):
+    AggregateParameterTypeAddLONG_DESCRIPTION(builder, LONG_DESCRIPTION)
+
+def AggregateParameterTypeAddMEMBERS(builder, MEMBERS):
+    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(MEMBERS), 0)
+
+def AddMEMBERS(builder, MEMBERS):
+    AggregateParameterTypeAddMEMBERS(builder, MEMBERS)
+
+def AggregateParameterTypeStartMEMBERSVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartMEMBERSVector(builder, numElems):
+    return AggregateParameterTypeStartMEMBERSVector(builder, numElems)
+
+def AggregateParameterTypeEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return AggregateParameterTypeEnd(builder)
+
+import AggregateMember
+try:
+    from typing import List
+except:
+    pass
+
+class AggregateParameterTypeT(object):
+
+    # AggregateParameterTypeT
+    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):
+        aggregateParameterType = AggregateParameterType()
+        aggregateParameterType.Init(buf, pos)
+        return cls.InitFromObj(aggregateParameterType)
+
+    @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, aggregateParameterType):
+        x = AggregateParameterTypeT()
+        x._UnPack(aggregateParameterType)
+        return x
+
+    # AggregateParameterTypeT
+    def _UnPack(self, aggregateParameterType):
+        if aggregateParameterType is None:
+            return
+        self.NAME = aggregateParameterType.NAME()
+        self.SHORT_DESCRIPTION = aggregateParameterType.SHORT_DESCRIPTION()
+        self.LONG_DESCRIPTION = aggregateParameterType.LONG_DESCRIPTION()
+        if not aggregateParameterType.MEMBERSIsNone():
+            self.MEMBERS = []
+            for i in range(aggregateParameterType.MEMBERSLength()):
+                if aggregateParameterType.MEMBERS(i) is None:
+                    self.MEMBERS.append(None)
+                else:
+                    aggregateMember_ = AggregateMember.AggregateMemberT.InitFromObj(aggregateParameterType.MEMBERS(i))
+                    self.MEMBERS.append(aggregateMember_)
+
+    # AggregateParameterTypeT
+    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))
+            AggregateParameterTypeStartMEMBERSVector(builder, len(self.MEMBERS))
+            for i in reversed(range(len(self.MEMBERS))):
+                builder.PrependUOffsetTRelative(MEMBERSlist[i])
+            MEMBERS = builder.EndVector()
+        AggregateParameterTypeStart(builder)
+        if self.NAME is not None:
+            AggregateParameterTypeAddNAME(builder, NAME)
+        if self.SHORT_DESCRIPTION is not None:
+            AggregateParameterTypeAddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION)
+        if self.LONG_DESCRIPTION is not None:
+            AggregateParameterTypeAddLONG_DESCRIPTION(builder, LONG_DESCRIPTION)
+        if self.MEMBERS is not None:
+            AggregateParameterTypeAddMEMBERS(builder, MEMBERS)
+        aggregateParameterType = AggregateParameterTypeEnd(builder)
+        return aggregateParameterType

XTC/AlarmRange.py

@@ -0,0 +1,144 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Numeric alarm range
+class AlarmRange(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = AlarmRange()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsAlarmRange(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def AlarmRangeBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # AlarmRange
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Minimum value (inclusive)
+    # AlarmRange
+    def MIN_INCLUSIVE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # Maximum value (inclusive)
+    # AlarmRange
+    def MAX_INCLUSIVE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # Minimum value (exclusive)
+    # AlarmRange
+    def MIN_EXCLUSIVE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # Maximum value (exclusive)
+    # AlarmRange
+    def MAX_EXCLUSIVE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+def AlarmRangeStart(builder):
+    builder.StartObject(4)
+
+def Start(builder):
+    AlarmRangeStart(builder)
+
+def AlarmRangeAddMIN_INCLUSIVE(builder, MIN_INCLUSIVE):
+    builder.PrependFloat64Slot(0, MIN_INCLUSIVE, 0.0)
+
+def AddMIN_INCLUSIVE(builder, MIN_INCLUSIVE):
+    AlarmRangeAddMIN_INCLUSIVE(builder, MIN_INCLUSIVE)
+
+def AlarmRangeAddMAX_INCLUSIVE(builder, MAX_INCLUSIVE):
+    builder.PrependFloat64Slot(1, MAX_INCLUSIVE, 0.0)
+
+def AddMAX_INCLUSIVE(builder, MAX_INCLUSIVE):
+    AlarmRangeAddMAX_INCLUSIVE(builder, MAX_INCLUSIVE)
+
+def AlarmRangeAddMIN_EXCLUSIVE(builder, MIN_EXCLUSIVE):
+    builder.PrependFloat64Slot(2, MIN_EXCLUSIVE, 0.0)
+
+def AddMIN_EXCLUSIVE(builder, MIN_EXCLUSIVE):
+    AlarmRangeAddMIN_EXCLUSIVE(builder, MIN_EXCLUSIVE)
+
+def AlarmRangeAddMAX_EXCLUSIVE(builder, MAX_EXCLUSIVE):
+    builder.PrependFloat64Slot(3, MAX_EXCLUSIVE, 0.0)
+
+def AddMAX_EXCLUSIVE(builder, MAX_EXCLUSIVE):
+    AlarmRangeAddMAX_EXCLUSIVE(builder, MAX_EXCLUSIVE)
+
+def AlarmRangeEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return AlarmRangeEnd(builder)
+
+
+class AlarmRangeT(object):
+
+    # AlarmRangeT
+    def __init__(self):
+        self.MIN_INCLUSIVE = 0.0  # type: float
+        self.MAX_INCLUSIVE = 0.0  # type: float
+        self.MIN_EXCLUSIVE = 0.0  # type: float
+        self.MAX_EXCLUSIVE = 0.0  # type: float
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        alarmRange = AlarmRange()
+        alarmRange.Init(buf, pos)
+        return cls.InitFromObj(alarmRange)
+
+    @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, alarmRange):
+        x = AlarmRangeT()
+        x._UnPack(alarmRange)
+        return x
+
+    # AlarmRangeT
+    def _UnPack(self, alarmRange):
+        if alarmRange is None:
+            return
+        self.MIN_INCLUSIVE = alarmRange.MIN_INCLUSIVE()
+        self.MAX_INCLUSIVE = alarmRange.MAX_INCLUSIVE()
+        self.MIN_EXCLUSIVE = alarmRange.MIN_EXCLUSIVE()
+        self.MAX_EXCLUSIVE = alarmRange.MAX_EXCLUSIVE()
+
+    # AlarmRangeT
+    def Pack(self, builder):
+        AlarmRangeStart(builder)
+        AlarmRangeAddMIN_INCLUSIVE(builder, self.MIN_INCLUSIVE)
+        AlarmRangeAddMAX_INCLUSIVE(builder, self.MAX_INCLUSIVE)
+        AlarmRangeAddMIN_EXCLUSIVE(builder, self.MIN_EXCLUSIVE)
+        AlarmRangeAddMAX_EXCLUSIVE(builder, self.MAX_EXCLUSIVE)
+        alarmRange = AlarmRangeEnd(builder)
+        return alarmRange

XTC/AlarmSeverityType.py

@@ -0,0 +1,18 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+# Alarm severity levels
+class AlarmSeverityType(object):
+    # Normal operation
+    NORMAL = 0
+    # Watch level - early warning
+    WATCH = 1
+    # Warning level
+    WARNING = 2
+    # Distress level - significant issue
+    DISTRESS = 3
+    # Critical level - immediate action required
+    CRITICAL = 4
+    # Severe level - system failure
+    SEVERE = 5

XTC/AlgorithmInput.py

@@ -0,0 +1,116 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Algorithm input binding
+class AlgorithmInput(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = AlgorithmInput()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsAlgorithmInput(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def AlgorithmInputBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # AlgorithmInput
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Parameter reference
+    # AlgorithmInput
+    def PARAMETER_REF(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
+
+    # Input name in algorithm
+    # AlgorithmInput
+    def INPUT_NAME(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
+
+def AlgorithmInputStart(builder):
+    builder.StartObject(2)
+
+def Start(builder):
+    AlgorithmInputStart(builder)
+
+def AlgorithmInputAddPARAMETER_REF(builder, PARAMETER_REF):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(PARAMETER_REF), 0)
+
+def AddPARAMETER_REF(builder, PARAMETER_REF):
+    AlgorithmInputAddPARAMETER_REF(builder, PARAMETER_REF)
+
+def AlgorithmInputAddINPUT_NAME(builder, INPUT_NAME):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(INPUT_NAME), 0)
+
+def AddINPUT_NAME(builder, INPUT_NAME):
+    AlgorithmInputAddINPUT_NAME(builder, INPUT_NAME)
+
+def AlgorithmInputEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return AlgorithmInputEnd(builder)
+
+
+class AlgorithmInputT(object):
+
+    # AlgorithmInputT
+    def __init__(self):
+        self.PARAMETER_REF = None  # type: str
+        self.INPUT_NAME = None  # type: str
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        algorithmInput = AlgorithmInput()
+        algorithmInput.Init(buf, pos)
+        return cls.InitFromObj(algorithmInput)
+
+    @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, algorithmInput):
+        x = AlgorithmInputT()
+        x._UnPack(algorithmInput)
+        return x
+
+    # AlgorithmInputT
+    def _UnPack(self, algorithmInput):
+        if algorithmInput is None:
+            return
+        self.PARAMETER_REF = algorithmInput.PARAMETER_REF()
+        self.INPUT_NAME = algorithmInput.INPUT_NAME()
+
+    # AlgorithmInputT
+    def Pack(self, builder):
+        if self.PARAMETER_REF is not None:
+            PARAMETER_REF = builder.CreateString(self.PARAMETER_REF)
+        if self.INPUT_NAME is not None:
+            INPUT_NAME = builder.CreateString(self.INPUT_NAME)
+        AlgorithmInputStart(builder)
+        if self.PARAMETER_REF is not None:
+            AlgorithmInputAddPARAMETER_REF(builder, PARAMETER_REF)
+        if self.INPUT_NAME is not None:
+            AlgorithmInputAddINPUT_NAME(builder, INPUT_NAME)
+        algorithmInput = AlgorithmInputEnd(builder)
+        return algorithmInput

XTC/AlgorithmOutput.py

@@ -0,0 +1,116 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Algorithm output binding
+class AlgorithmOutput(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = AlgorithmOutput()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsAlgorithmOutput(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def AlgorithmOutputBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # AlgorithmOutput
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Parameter reference
+    # AlgorithmOutput
+    def PARAMETER_REF(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
+
+    # Output name in algorithm
+    # AlgorithmOutput
+    def OUTPUT_NAME(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
+
+def AlgorithmOutputStart(builder):
+    builder.StartObject(2)
+
+def Start(builder):
+    AlgorithmOutputStart(builder)
+
+def AlgorithmOutputAddPARAMETER_REF(builder, PARAMETER_REF):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(PARAMETER_REF), 0)
+
+def AddPARAMETER_REF(builder, PARAMETER_REF):
+    AlgorithmOutputAddPARAMETER_REF(builder, PARAMETER_REF)
+
+def AlgorithmOutputAddOUTPUT_NAME(builder, OUTPUT_NAME):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(OUTPUT_NAME), 0)
+
+def AddOUTPUT_NAME(builder, OUTPUT_NAME):
+    AlgorithmOutputAddOUTPUT_NAME(builder, OUTPUT_NAME)
+
+def AlgorithmOutputEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return AlgorithmOutputEnd(builder)
+
+
+class AlgorithmOutputT(object):
+
+    # AlgorithmOutputT
+    def __init__(self):
+        self.PARAMETER_REF = None  # type: str
+        self.OUTPUT_NAME = None  # type: str
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        algorithmOutput = AlgorithmOutput()
+        algorithmOutput.Init(buf, pos)
+        return cls.InitFromObj(algorithmOutput)
+
+    @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, algorithmOutput):
+        x = AlgorithmOutputT()
+        x._UnPack(algorithmOutput)
+        return x
+
+    # AlgorithmOutputT
+    def _UnPack(self, algorithmOutput):
+        if algorithmOutput is None:
+            return
+        self.PARAMETER_REF = algorithmOutput.PARAMETER_REF()
+        self.OUTPUT_NAME = algorithmOutput.OUTPUT_NAME()
+
+    # AlgorithmOutputT
+    def Pack(self, builder):
+        if self.PARAMETER_REF is not None:
+            PARAMETER_REF = builder.CreateString(self.PARAMETER_REF)
+        if self.OUTPUT_NAME is not None:
+            OUTPUT_NAME = builder.CreateString(self.OUTPUT_NAME)
+        AlgorithmOutputStart(builder)
+        if self.PARAMETER_REF is not None:
+            AlgorithmOutputAddPARAMETER_REF(builder, PARAMETER_REF)
+        if self.OUTPUT_NAME is not None:
+            AlgorithmOutputAddOUTPUT_NAME(builder, OUTPUT_NAME)
+        algorithmOutput = AlgorithmOutputEnd(builder)
+        return algorithmOutput