tools/tflitefile_tool/tflite/Operator.py

   1 # automatically generated by the FlatBuffers compiler, do not modify
   2
   3 # namespace: onert_tflite
   4
   5 import flatbuffers
   6
   7
   8 class Operator(object):
   9     __slots__ = ['_tab']
  10
  11     @classmethod
  12     def GetRootAsOperator(cls, buf, offset):
  13         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
  14         x = Operator()
  15         x.Init(buf, n + offset)
  16         return x
  17
  18     # Operator
  19     def Init(self, buf, pos):
  20         self._tab = flatbuffers.table.Table(buf, pos)
  21
  22     # Operator
  23     def OpcodeIndex(self):
  24         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
  25         if o != 0:
  26             return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
  27         return 0
  28
  29     # Operator
  30     def Inputs(self, j):
  31         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
  32         if o != 0:
  33             a = self._tab.Vector(o)
  34             return self._tab.Get(
  35                 flatbuffers.number_types.Int32Flags,
  36                 a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
  37         return 0
  38
  39     # Operator
  40     def InputsAsNumpy(self):
  41         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
  42         if o != 0:
  43             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o)
  44         return 0
  45
  46     # Operator
  47     def InputsLength(self):
  48         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
  49         if o != 0:
  50             return self._tab.VectorLen(o)
  51         return 0
  52
  53     # Operator
  54     def Outputs(self, j):
  55         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
  56         if o != 0:
  57             a = self._tab.Vector(o)
  58             return self._tab.Get(
  59                 flatbuffers.number_types.Int32Flags,
  60                 a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
  61         return 0
  62
  63     # Operator
  64     def OutputsAsNumpy(self):
  65         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
  66         if o != 0:
  67             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o)
  68         return 0
  69
  70     # Operator
  71     def OutputsLength(self):
  72         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
  73         if o != 0:
  74             return self._tab.VectorLen(o)
  75         return 0
  76
  77     # Operator
  78     def BuiltinOptionsType(self):
  79         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
  80         if o != 0:
  81             return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
  82         return 0
  83
  84     # Operator
  85     def BuiltinOptions(self):
  86         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
  87         if o != 0:
  88             from flatbuffers.table import Table
  89             obj = Table(bytearray(), 0)
  90             self._tab.Union(obj, o)
  91             return obj
  92         return None
  93
  94     # Operator
  95     def CustomOptions(self, j):
  96         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
  97         if o != 0:
  98             a = self._tab.Vector(o)
  99             return self._tab.Get(
 100                 flatbuffers.number_types.Uint8Flags,
 101                 a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
 102         return 0
 103
 104     # Operator
 105     def CustomOptionsAsNumpy(self):
 106         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
 107         if o != 0:
 108             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
 109         return 0
 110
 111     # Operator
 112     def CustomOptionsLength(self):
 113         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
 114         if o != 0:
 115             return self._tab.VectorLen(o)
 116         return 0
 117
 118     # Operator
 119     def CustomOptionsFormat(self):
 120         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
 121         if o != 0:
 122             return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
 123         return 0
 124
 125     # Operator
 126     def MutatingVariableInputs(self, j):
 127         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
 128         if o != 0:
 129             a = self._tab.Vector(o)
 130             return self._tab.Get(
 131                 flatbuffers.number_types.BoolFlags,
 132                 a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
 133         return 0
 134
 135     # Operator
 136     def MutatingVariableInputsAsNumpy(self):
 137         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
 138         if o != 0:
 139             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.BoolFlags, o)
 140         return 0
 141
 142     # Operator
 143     def MutatingVariableInputsLength(self):
 144         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
 145         if o != 0:
 146             return self._tab.VectorLen(o)
 147         return 0
 148
 149     # Operator
 150     def Intermediates(self, j):
 151         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
 152         if o != 0:
 153             a = self._tab.Vector(o)
 154             return self._tab.Get(
 155                 flatbuffers.number_types.Int32Flags,
 156                 a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
 157         return 0
 158
 159     # Operator
 160     def IntermediatesAsNumpy(self):
 161         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
 162         if o != 0:
 163             return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o)
 164         return 0
 165
 166     # Operator
 167     def IntermediatesLength(self):
 168         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
 169         if o != 0:
 170             return self._tab.VectorLen(o)
 171         return 0
 172
 173
 174 def OperatorStart(builder):
 175     builder.StartObject(9)
 176
 177
 178 def OperatorAddOpcodeIndex(builder, opcodeIndex):
 179     builder.PrependUint32Slot(0, opcodeIndex, 0)
 180
 181
 182 def OperatorAddInputs(builder, inputs):
 183     builder.PrependUOffsetTRelativeSlot(
 184         1, flatbuffers.number_types.UOffsetTFlags.py_type(inputs), 0)
 185
 186
 187 def OperatorStartInputsVector(builder, numElems):
 188     return builder.StartVector(4, numElems, 4)
 189
 190
 191 def OperatorAddOutputs(builder, outputs):
 192     builder.PrependUOffsetTRelativeSlot(
 193         2, flatbuffers.number_types.UOffsetTFlags.py_type(outputs), 0)
 194
 195
 196 def OperatorStartOutputsVector(builder, numElems):
 197     return builder.StartVector(4, numElems, 4)
 198
 199
 200 def OperatorAddBuiltinOptionsType(builder, builtinOptionsType):
 201     builder.PrependUint8Slot(3, builtinOptionsType, 0)
 202
 203
 204 def OperatorAddBuiltinOptions(builder, builtinOptions):
 205     builder.PrependUOffsetTRelativeSlot(
 206         4, flatbuffers.number_types.UOffsetTFlags.py_type(builtinOptions), 0)
 207
 208
 209 def OperatorAddCustomOptions(builder, customOptions):
 210     builder.PrependUOffsetTRelativeSlot(
 211         5, flatbuffers.number_types.UOffsetTFlags.py_type(customOptions), 0)
 212
 213
 214 def OperatorStartCustomOptionsVector(builder, numElems):
 215     return builder.StartVector(1, numElems, 1)
 216
 217
 218 def OperatorAddCustomOptionsFormat(builder, customOptionsFormat):
 219     builder.PrependInt8Slot(6, customOptionsFormat, 0)
 220
 221
 222 def OperatorAddMutatingVariableInputs(builder, mutatingVariableInputs):
 223     builder.PrependUOffsetTRelativeSlot(
 224         7, flatbuffers.number_types.UOffsetTFlags.py_type(mutatingVariableInputs), 0)
 225
 226
 227 def OperatorStartMutatingVariableInputsVector(builder, numElems):
 228     return builder.StartVector(1, numElems, 1)
 229
 230
 231 def OperatorAddIntermediates(builder, intermediates):
 232     builder.PrependUOffsetTRelativeSlot(
 233         8, flatbuffers.number_types.UOffsetTFlags.py_type(intermediates), 0)
 234
 235
 236 def OperatorStartIntermediatesVector(builder, numElems):
 237     return builder.StartVector(4, numElems, 4)
 238
 239
 240 def OperatorEnd(builder):
 241     return builder.EndObject()