event_matcher_definitions_generated.py

event_matcher_definitions_generated.py (31152B)
      1 #Embedded file name: C:\BuildAgent\work\20d73f1b24eed06e\eve\release\V24.01\packages\campaigns\client\v2\data_model\flatbuffer\event_matcher_definitions_generated.py
      2 import flatbuffers
      3 from flatbuffers.compat import import_numpy
      4 np = import_numpy()
      5 
      6 class FormattedMessageParameterValue(object):
      7     NONE = 0
      8     String = 1
      9     UInt = 2
     10     Int = 3
     11     Double = 4
     12     Timestamp = 5
     13     Duration = 6
     14 
     15 
     16 class ParameterType(object):
     17     SingleValue = 0
     18     Set = 1
     19     MultiValue = 2
     20 
     21 
     22 class StringParameterValue(object):
     23     __slots__ = ['_tab']
     24 
     25     @classmethod
     26     def GetRootAs(cls, buf, offset = 0):
     27         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
     28         x = StringParameterValue()
     29         x.Init(buf, n + offset)
     30         return x
     31 
     32     @classmethod
     33     def GetRootAsStringParameterValue(cls, buf, offset = 0):
     34         return cls.GetRootAs(buf, offset)
     35 
     36     def Init(self, buf, pos):
     37         self._tab = flatbuffers.table.Table(buf, pos)
     38 
     39     def Value(self):
     40         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
     41         if o != 0:
     42             return self._tab.String(o + self._tab.Pos)
     43 
     44 
     45 def StringParameterValueStart(builder):
     46     builder.StartObject(1)
     47 
     48 
     49 def StringParameterValueAddValue(builder, value):
     50     builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(value), 0)
     51 
     52 
     53 def StringParameterValueEnd(builder):
     54     return builder.EndObject()
     55 
     56 
     57 class UIntParameterValue(object):
     58     __slots__ = ['_tab']
     59 
     60     @classmethod
     61     def GetRootAs(cls, buf, offset = 0):
     62         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
     63         x = UIntParameterValue()
     64         x.Init(buf, n + offset)
     65         return x
     66 
     67     @classmethod
     68     def GetRootAsUIntParameterValue(cls, buf, offset = 0):
     69         return cls.GetRootAs(buf, offset)
     70 
     71     def Init(self, buf, pos):
     72         self._tab = flatbuffers.table.Table(buf, pos)
     73 
     74     def Value(self):
     75         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
     76         if o != 0:
     77             return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
     78         return 0
     79 
     80 
     81 def UIntParameterValueStart(builder):
     82     builder.StartObject(1)
     83 
     84 
     85 def UIntParameterValueAddValue(builder, value):
     86     builder.PrependUint64Slot(0, value, 0)
     87 
     88 
     89 def UIntParameterValueEnd(builder):
     90     return builder.EndObject()
     91 
     92 
     93 class IntParameterValue(object):
     94     __slots__ = ['_tab']
     95 
     96     @classmethod
     97     def GetRootAs(cls, buf, offset = 0):
     98         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
     99         x = IntParameterValue()
    100         x.Init(buf, n + offset)
    101         return x
    102 
    103     @classmethod
    104     def GetRootAsIntParameterValue(cls, buf, offset = 0):
    105         return cls.GetRootAs(buf, offset)
    106 
    107     def Init(self, buf, pos):
    108         self._tab = flatbuffers.table.Table(buf, pos)
    109 
    110     def Value(self):
    111         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
    112         if o != 0:
    113             return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
    114         return 0
    115 
    116 
    117 def IntParameterValueStart(builder):
    118     builder.StartObject(1)
    119 
    120 
    121 def IntParameterValueAddValue(builder, value):
    122     builder.PrependInt32Slot(0, value, 0)
    123 
    124 
    125 def IntParameterValueEnd(builder):
    126     return builder.EndObject()
    127 
    128 
    129 class DoubleParameterValue(object):
    130     __slots__ = ['_tab']
    131 
    132     @classmethod
    133     def GetRootAs(cls, buf, offset = 0):
    134         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
    135         x = DoubleParameterValue()
    136         x.Init(buf, n + offset)
    137         return x
    138 
    139     @classmethod
    140     def GetRootAsDoubleParameterValue(cls, buf, offset = 0):
    141         return cls.GetRootAs(buf, offset)
    142 
    143     def Init(self, buf, pos):
    144         self._tab = flatbuffers.table.Table(buf, pos)
    145 
    146     def Value(self):
    147         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
    148         if o != 0:
    149             return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
    150         return 0.0
    151 
    152 
    153 def DoubleParameterValueStart(builder):
    154     builder.StartObject(1)
    155 
    156 
    157 def DoubleParameterValueAddValue(builder, value):
    158     builder.PrependFloat64Slot(0, value, 0.0)
    159 
    160 
    161 def DoubleParameterValueEnd(builder):
    162     return builder.EndObject()
    163 
    164 
    165 class TimestampParameterValue(object):
    166     __slots__ = ['_tab']
    167 
    168     @classmethod
    169     def GetRootAs(cls, buf, offset = 0):
    170         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
    171         x = TimestampParameterValue()
    172         x.Init(buf, n + offset)
    173         return x
    174 
    175     @classmethod
    176     def GetRootAsTimestampParameterValue(cls, buf, offset = 0):
    177         return cls.GetRootAs(buf, offset)
    178 
    179     def Init(self, buf, pos):
    180         self._tab = flatbuffers.table.Table(buf, pos)
    181 
    182     def Seconds(self):
    183         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
    184         if o != 0:
    185             return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
    186         return 0
    187 
    188     def Nanos(self):
    189         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
    190         if o != 0:
    191             return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
    192         return 0
    193 
    194 
    195 def TimestampParameterValueStart(builder):
    196     builder.StartObject(2)
    197 
    198 
    199 def TimestampParameterValueAddSeconds(builder, seconds):
    200     builder.PrependInt64Slot(0, seconds, 0)
    201 
    202 
    203 def TimestampParameterValueAddNanos(builder, nanos):
    204     builder.PrependInt64Slot(1, nanos, 0)
    205 
    206 
    207 def TimestampParameterValueEnd(builder):
    208     return builder.EndObject()
    209 
    210 
    211 class DurationParameterValue(object):
    212     __slots__ = ['_tab']
    213 
    214     @classmethod
    215     def GetRootAs(cls, buf, offset = 0):
    216         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
    217         x = DurationParameterValue()
    218         x.Init(buf, n + offset)
    219         return x
    220 
    221     @classmethod
    222     def GetRootAsDurationParameterValue(cls, buf, offset = 0):
    223         return cls.GetRootAs(buf, offset)
    224 
    225     def Init(self, buf, pos):
    226         self._tab = flatbuffers.table.Table(buf, pos)
    227 
    228     def Seconds(self):
    229         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
    230         if o != 0:
    231             return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
    232         return 0
    233 
    234     def Nanos(self):
    235         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
    236         if o != 0:
    237             return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
    238         return 0
    239 
    240 
    241 def DurationParameterValueStart(builder):
    242     builder.StartObject(2)
    243 
    244 
    245 def DurationParameterValueAddSeconds(builder, seconds):
    246     builder.PrependInt64Slot(0, seconds, 0)
    247 
    248 
    249 def DurationParameterValueAddNanos(builder, nanos):
    250     builder.PrependInt64Slot(1, nanos, 0)
    251 
    252 
    253 def DurationParameterValueEnd(builder):
    254     return builder.EndObject()
    255 
    256 
    257 class FormattedMessageParameter(object):
    258     __slots__ = ['_tab']
    259 
    260     @classmethod
    261     def GetRootAs(cls, buf, offset = 0):
    262         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
    263         x = FormattedMessageParameter()
    264         x.Init(buf, n + offset)
    265         return x
    266 
    267     @classmethod
    268     def GetRootAsFormattedMessageParameter(cls, buf, offset = 0):
    269         return cls.GetRootAs(buf, offset)
    270 
    271     def Init(self, buf, pos):
    272         self._tab = flatbuffers.table.Table(buf, pos)
    273 
    274     def Key(self):
    275         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
    276         if o != 0:
    277             return self._tab.String(o + self._tab.Pos)
    278 
    279     def ValueType(self):
    280         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
    281         if o != 0:
    282             return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
    283         return 0
    284 
    285     def Value(self):
    286         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
    287         if o != 0:
    288             from flatbuffers.table import Table
    289             obj = Table(bytearray(), 0)
    290             self._tab.Union(obj, o)
    291             return obj
    292 
    293 
    294 def FormattedMessageParameterStart(builder):
    295     builder.StartObject(3)
    296 
    297 
    298 def FormattedMessageParameterAddKey(builder, key):
    299     builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(key), 0)
    300 
    301 
    302 def FormattedMessageParameterAddValueType(builder, valueType):
    303     builder.PrependUint8Slot(1, valueType, 0)
    304 
    305 
    306 def FormattedMessageParameterAddValue(builder, value):
    307     builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(value), 0)
    308 
    309 
    310 def FormattedMessageParameterEnd(builder):
    311     return builder.EndObject()
    312 
    313 
    314 class FormattedMessage(object):
    315     __slots__ = ['_tab']
    316 
    317     @classmethod
    318     def GetRootAs(cls, buf, offset = 0):
    319         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
    320         x = FormattedMessage()
    321         x.Init(buf, n + offset)
    322         return x
    323 
    324     @classmethod
    325     def GetRootAsFormattedMessage(cls, buf, offset = 0):
    326         return cls.GetRootAs(buf, offset)
    327 
    328     def Init(self, buf, pos):
    329         self._tab = flatbuffers.table.Table(buf, pos)
    330 
    331     def Id(self):
    332         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
    333         if o != 0:
    334             return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
    335         return 0
    336 
    337     def Parameters(self, j):
    338         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
    339         if o != 0:
    340             x = self._tab.Vector(o)
    341             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
    342             x = self._tab.Indirect(x)
    343             obj = FormattedMessageParameter()
    344             obj.Init(self._tab.Bytes, x)
    345             return obj
    346 
    347     def ParametersLength(self):
    348         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
    349         if o != 0:
    350             return self._tab.VectorLen(o)
    351         return 0
    352 
    353     def ParametersIsNone(self):
    354         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
    355         return o == 0
    356 
    357 
    358 def FormattedMessageStart(builder):
    359     builder.StartObject(2)
    360 
    361 
    362 def FormattedMessageAddId(builder, id):
    363     builder.PrependUint64Slot(0, id, 0)
    364 
    365 
    366 def FormattedMessageAddParameters(builder, parameters):
    367     builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(parameters), 0)
    368 
    369 
    370 def FormattedMessageStartParametersVector(builder, numElems):
    371     return builder.StartVector(4, numElems, 4)
    372 
    373 
    374 def FormattedMessageCreateParametersVector(builder, data):
    375     return builder.CreateVectorOfTables(data)
    376 
    377 
    378 def FormattedMessageEnd(builder):
    379     return builder.EndObject()
    380 
    381 
    382 class Text(object):
    383     __slots__ = ['_tab']
    384 
    385     @classmethod
    386     def GetRootAs(cls, buf, offset = 0):
    387         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
    388         x = Text()
    389         x.Init(buf, n + offset)
    390         return x
    391 
    392     @classmethod
    393     def GetRootAsText(cls, buf, offset = 0):
    394         return cls.GetRootAs(buf, offset)
    395 
    396     def Init(self, buf, pos):
    397         self._tab = flatbuffers.table.Table(buf, pos)
    398 
    399     def Key(self):
    400         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
    401         if o != 0:
    402             return self._tab.String(o + self._tab.Pos)
    403 
    404     def Message(self):
    405         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
    406         if o != 0:
    407             x = self._tab.Indirect(o + self._tab.Pos)
    408             obj = FormattedMessage()
    409             obj.Init(self._tab.Bytes, x)
    410             return obj
    411 
    412 
    413 def TextStart(builder):
    414     builder.StartObject(2)
    415 
    416 
    417 def TextAddKey(builder, key):
    418     builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(key), 0)
    419 
    420 
    421 def TextAddMessage(builder, message):
    422     builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(message), 0)
    423 
    424 
    425 def TextEnd(builder):
    426     return builder.EndObject()
    427 
    428 
    429 class Resource(object):
    430     __slots__ = ['_tab']
    431 
    432     @classmethod
    433     def GetRootAs(cls, buf, offset = 0):
    434         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
    435         x = Resource()
    436         x.Init(buf, n + offset)
    437         return x
    438 
    439     @classmethod
    440     def GetRootAsResource(cls, buf, offset = 0):
    441         return cls.GetRootAs(buf, offset)
    442 
    443     def Init(self, buf, pos):
    444         self._tab = flatbuffers.table.Table(buf, pos)
    445 
    446     def Key(self):
    447         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
    448         if o != 0:
    449             return self._tab.String(o + self._tab.Pos)
    450 
    451     def Path(self):
    452         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
    453         if o != 0:
    454             return self._tab.String(o + self._tab.Pos)
    455 
    456 
    457 def ResourceStart(builder):
    458     builder.StartObject(2)
    459 
    460 
    461 def ResourceAddKey(builder, key):
    462     builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(key), 0)
    463 
    464 
    465 def ResourceAddPath(builder, path):
    466     builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(path), 0)
    467 
    468 
    469 def ResourceEnd(builder):
    470     return builder.EndObject()
    471 
    472 
    473 class Annotation(object):
    474     __slots__ = ['_tab']
    475 
    476     @classmethod
    477     def GetRootAs(cls, buf, offset = 0):
    478         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
    479         x = Annotation()
    480         x.Init(buf, n + offset)
    481         return x
    482 
    483     @classmethod
    484     def GetRootAsAnnotation(cls, buf, offset = 0):
    485         return cls.GetRootAs(buf, offset)
    486 
    487     def Init(self, buf, pos):
    488         self._tab = flatbuffers.table.Table(buf, pos)
    489 
    490     def Key(self):
    491         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
    492         if o != 0:
    493             return self._tab.String(o + self._tab.Pos)
    494 
    495     def Value(self):
    496         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
    497         if o != 0:
    498             return self._tab.String(o + self._tab.Pos)
    499 
    500 
    501 def AnnotationStart(builder):
    502     builder.StartObject(2)
    503 
    504 
    505 def AnnotationAddKey(builder, key):
    506     builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(key), 0)
    507 
    508 
    509 def AnnotationAddValue(builder, value):
    510     builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(value), 0)
    511 
    512 
    513 def AnnotationEnd(builder):
    514     return builder.EndObject()
    515 
    516 
    517 class UIDefinition(object):
    518     __slots__ = ['_tab']
    519 
    520     @classmethod
    521     def GetRootAs(cls, buf, offset = 0):
    522         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
    523         x = UIDefinition()
    524         x.Init(buf, n + offset)
    525         return x
    526 
    527     @classmethod
    528     def GetRootAsUIDefinition(cls, buf, offset = 0):
    529         return cls.GetRootAs(buf, offset)
    530 
    531     def Init(self, buf, pos):
    532         self._tab = flatbuffers.table.Table(buf, pos)
    533 
    534     def Texts(self, j):
    535         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
    536         if o != 0:
    537             x = self._tab.Vector(o)
    538             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
    539             x = self._tab.Indirect(x)
    540             obj = Text()
    541             obj.Init(self._tab.Bytes, x)
    542             return obj
    543 
    544     def TextsLength(self):
    545         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
    546         if o != 0:
    547             return self._tab.VectorLen(o)
    548         return 0
    549 
    550     def TextsIsNone(self):
    551         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
    552         return o == 0
    553 
    554     def Resources(self, j):
    555         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
    556         if o != 0:
    557             x = self._tab.Vector(o)
    558             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
    559             x = self._tab.Indirect(x)
    560             obj = Resource()
    561             obj.Init(self._tab.Bytes, x)
    562             return obj
    563 
    564     def ResourcesLength(self):
    565         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
    566         if o != 0:
    567             return self._tab.VectorLen(o)
    568         return 0
    569 
    570     def ResourcesIsNone(self):
    571         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
    572         return o == 0
    573 
    574     def Annotations(self, j):
    575         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
    576         if o != 0:
    577             x = self._tab.Vector(o)
    578             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
    579             x = self._tab.Indirect(x)
    580             obj = Annotation()
    581             obj.Init(self._tab.Bytes, x)
    582             return obj
    583 
    584     def AnnotationsLength(self):
    585         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
    586         if o != 0:
    587             return self._tab.VectorLen(o)
    588         return 0
    589 
    590     def AnnotationsIsNone(self):
    591         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
    592         return o == 0
    593 
    594     def Tags(self, j):
    595         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
    596         if o != 0:
    597             a = self._tab.Vector(o)
    598             return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
    599         return ''
    600 
    601     def TagsLength(self):
    602         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
    603         if o != 0:
    604             return self._tab.VectorLen(o)
    605         return 0
    606 
    607     def TagsIsNone(self):
    608         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
    609         return o == 0
    610 
    611 
    612 def UIDefinitionStart(builder):
    613     builder.StartObject(4)
    614 
    615 
    616 def UIDefinitionAddTexts(builder, texts):
    617     builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(texts), 0)
    618 
    619 
    620 def UIDefinitionStartTextsVector(builder, numElems):
    621     return builder.StartVector(4, numElems, 4)
    622 
    623 
    624 def UIDefinitionCreateTextsVector(builder, data):
    625     return builder.CreateVectorOfTables(data)
    626 
    627 
    628 def UIDefinitionAddResources(builder, resources):
    629     builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(resources), 0)
    630 
    631 
    632 def UIDefinitionStartResourcesVector(builder, numElems):
    633     return builder.StartVector(4, numElems, 4)
    634 
    635 
    636 def UIDefinitionCreateResourcesVector(builder, data):
    637     return builder.CreateVectorOfTables(data)
    638 
    639 
    640 def UIDefinitionAddAnnotations(builder, annotations):
    641     builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(annotations), 0)
    642 
    643 
    644 def UIDefinitionStartAnnotationsVector(builder, numElems):
    645     return builder.StartVector(4, numElems, 4)
    646 
    647 
    648 def UIDefinitionCreateAnnotationsVector(builder, data):
    649     return builder.CreateVectorOfTables(data)
    650 
    651 
    652 def UIDefinitionAddTags(builder, tags):
    653     builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(tags), 0)
    654 
    655 
    656 def UIDefinitionStartTagsVector(builder, numElems):
    657     return builder.StartVector(4, numElems, 4)
    658 
    659 
    660 def UIDefinitionCreateTagsVector(builder, data):
    661     return builder.CreateVectorOfTables(data)
    662 
    663 
    664 def UIDefinitionEnd(builder):
    665     return builder.EndObject()
    666 
    667 
    668 class Parameter(object):
    669     __slots__ = ['_tab']
    670 
    671     @classmethod
    672     def GetRootAs(cls, buf, offset = 0):
    673         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
    674         x = Parameter()
    675         x.Init(buf, n + offset)
    676         return x
    677 
    678     @classmethod
    679     def GetRootAsParameter(cls, buf, offset = 0):
    680         return cls.GetRootAs(buf, offset)
    681 
    682     def Init(self, buf, pos):
    683         self._tab = flatbuffers.table.Table(buf, pos)
    684 
    685     def Key(self):
    686         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
    687         if o != 0:
    688             return self._tab.String(o + self._tab.Pos)
    689 
    690     def Ui(self):
    691         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
    692         if o != 0:
    693             x = self._tab.Indirect(o + self._tab.Pos)
    694             obj = UIDefinition()
    695             obj.Init(self._tab.Bytes, x)
    696             return obj
    697 
    698     def Type(self):
    699         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
    700         if o != 0:
    701             return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
    702         return 0
    703 
    704     def Values(self, j):
    705         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
    706         if o != 0:
    707             a = self._tab.Vector(o)
    708             return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
    709         return ''
    710 
    711     def ValuesLength(self):
    712         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
    713         if o != 0:
    714             return self._tab.VectorLen(o)
    715         return 0
    716 
    717     def ValuesIsNone(self):
    718         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
    719         return o == 0
    720 
    721 
    722 def ParameterStart(builder):
    723     builder.StartObject(4)
    724 
    725 
    726 def ParameterAddKey(builder, key):
    727     builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(key), 0)
    728 
    729 
    730 def ParameterAddUi(builder, ui):
    731     builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(ui), 0)
    732 
    733 
    734 def ParameterAddType(builder, type):
    735     builder.PrependInt8Slot(2, type, 0)
    736 
    737 
    738 def ParameterAddValues(builder, values):
    739     builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(values), 0)
    740 
    741 
    742 def ParameterStartValuesVector(builder, numElems):
    743     return builder.StartVector(4, numElems, 4)
    744 
    745 
    746 def ParameterCreateValuesVector(builder, data):
    747     return builder.CreateVectorOfTables(data)
    748 
    749 
    750 def ParameterEnd(builder):
    751     return builder.EndObject()
    752 
    753 
    754 class Definition(object):
    755     __slots__ = ['_tab']
    756 
    757     @classmethod
    758     def GetRootAs(cls, buf, offset = 0):
    759         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
    760         x = Definition()
    761         x.Init(buf, n + offset)
    762         return x
    763 
    764     @classmethod
    765     def GetRootAsDefinition(cls, buf, offset = 0):
    766         return cls.GetRootAs(buf, offset)
    767 
    768     def Init(self, buf, pos):
    769         self._tab = flatbuffers.table.Table(buf, pos)
    770 
    771     def Name(self):
    772         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
    773         if o != 0:
    774             return self._tab.String(o + self._tab.Pos)
    775 
    776     def Ui(self):
    777         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
    778         if o != 0:
    779             x = self._tab.Indirect(o + self._tab.Pos)
    780             obj = UIDefinition()
    781             obj.Init(self._tab.Bytes, x)
    782             return obj
    783 
    784     def Parameters(self, j):
    785         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
    786         if o != 0:
    787             x = self._tab.Vector(o)
    788             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
    789             x = self._tab.Indirect(x)
    790             obj = Parameter()
    791             obj.Init(self._tab.Bytes, x)
    792             return obj
    793 
    794     def ParametersLength(self):
    795         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
    796         if o != 0:
    797             return self._tab.VectorLen(o)
    798         return 0
    799 
    800     def ParametersIsNone(self):
    801         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
    802         return o == 0
    803 
    804 
    805 def DefinitionStart(builder):
    806     builder.StartObject(3)
    807 
    808 
    809 def DefinitionAddName(builder, name):
    810     builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
    811 
    812 
    813 def DefinitionAddUi(builder, ui):
    814     builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(ui), 0)
    815 
    816 
    817 def DefinitionAddParameters(builder, parameters):
    818     builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(parameters), 0)
    819 
    820 
    821 def DefinitionStartParametersVector(builder, numElems):
    822     return builder.StartVector(4, numElems, 4)
    823 
    824 
    825 def DefinitionCreateParametersVector(builder, data):
    826     return builder.CreateVectorOfTables(data)
    827 
    828 
    829 def DefinitionEnd(builder):
    830     return builder.EndObject()
    831 
    832 
    833 class SemanticVersion(object):
    834     __slots__ = ['_tab']
    835 
    836     @classmethod
    837     def GetRootAs(cls, buf, offset = 0):
    838         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
    839         x = SemanticVersion()
    840         x.Init(buf, n + offset)
    841         return x
    842 
    843     @classmethod
    844     def GetRootAsSemanticVersion(cls, buf, offset = 0):
    845         return cls.GetRootAs(buf, offset)
    846 
    847     def Init(self, buf, pos):
    848         self._tab = flatbuffers.table.Table(buf, pos)
    849 
    850     def Major(self):
    851         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
    852         if o != 0:
    853             return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
    854         return 0
    855 
    856     def Minor(self):
    857         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
    858         if o != 0:
    859             return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
    860         return 0
    861 
    862     def Patch(self):
    863         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
    864         if o != 0:
    865             return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
    866         return 0
    867 
    868     def PrereleaseTags(self, j):
    869         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
    870         if o != 0:
    871             a = self._tab.Vector(o)
    872             return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
    873         return ''
    874 
    875     def PrereleaseTagsLength(self):
    876         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
    877         if o != 0:
    878             return self._tab.VectorLen(o)
    879         return 0
    880 
    881     def PrereleaseTagsIsNone(self):
    882         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
    883         return o == 0
    884 
    885     def BuildTags(self, j):
    886         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
    887         if o != 0:
    888             a = self._tab.Vector(o)
    889             return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
    890         return ''
    891 
    892     def BuildTagsLength(self):
    893         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
    894         if o != 0:
    895             return self._tab.VectorLen(o)
    896         return 0
    897 
    898     def BuildTagsIsNone(self):
    899         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
    900         return o == 0
    901 
    902 
    903 def SemanticVersionStart(builder):
    904     builder.StartObject(5)
    905 
    906 
    907 def SemanticVersionAddMajor(builder, major):
    908     builder.PrependUint64Slot(0, major, 0)
    909 
    910 
    911 def SemanticVersionAddMinor(builder, minor):
    912     builder.PrependUint64Slot(1, minor, 0)
    913 
    914 
    915 def SemanticVersionAddPatch(builder, patch):
    916     builder.PrependUint64Slot(2, patch, 0)
    917 
    918 
    919 def SemanticVersionAddPrereleaseTags(builder, prereleaseTags):
    920     builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(prereleaseTags), 0)
    921 
    922 
    923 def SemanticVersionStartPrereleaseTagsVector(builder, numElems):
    924     return builder.StartVector(4, numElems, 4)
    925 
    926 
    927 def SemanticVersionCreatePrereleaseTagsVector(builder, data):
    928     return builder.CreateVectorOfTables(data)
    929 
    930 
    931 def SemanticVersionAddBuildTags(builder, buildTags):
    932     builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(buildTags), 0)
    933 
    934 
    935 def SemanticVersionStartBuildTagsVector(builder, numElems):
    936     return builder.StartVector(4, numElems, 4)
    937 
    938 
    939 def SemanticVersionCreateBuildTagsVector(builder, data):
    940     return builder.CreateVectorOfTables(data)
    941 
    942 
    943 def SemanticVersionEnd(builder):
    944     return builder.EndObject()
    945 
    946 
    947 class Definitions(object):
    948     __slots__ = ['_tab']
    949 
    950     @classmethod
    951     def GetRootAs(cls, buf, offset = 0):
    952         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
    953         x = Definitions()
    954         x.Init(buf, n + offset)
    955         return x
    956 
    957     @classmethod
    958     def GetRootAsDefinitions(cls, buf, offset = 0):
    959         return cls.GetRootAs(buf, offset)
    960 
    961     def Init(self, buf, pos):
    962         self._tab = flatbuffers.table.Table(buf, pos)
    963 
    964     def Version(self):
    965         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
    966         if o != 0:
    967             x = self._tab.Indirect(o + self._tab.Pos)
    968             obj = SemanticVersion()
    969             obj.Init(self._tab.Bytes, x)
    970             return obj
    971 
    972     def Methods(self, j):
    973         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
    974         if o != 0:
    975             x = self._tab.Vector(o)
    976             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
    977             x = self._tab.Indirect(x)
    978             obj = Definition()
    979             obj.Init(self._tab.Bytes, x)
    980             return obj
    981 
    982     def MethodsLength(self):
    983         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
    984         if o != 0:
    985             return self._tab.VectorLen(o)
    986         return 0
    987 
    988     def MethodsIsNone(self):
    989         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
    990         return o == 0
    991 
    992 
    993 def DefinitionsStart(builder):
    994     builder.StartObject(2)
    995 
    996 
    997 def DefinitionsAddVersion(builder, version):
    998     builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(version), 0)
    999 
   1000 
   1001 def DefinitionsAddMethods(builder, methods):
   1002     builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(methods), 0)
   1003 
   1004 
   1005 def DefinitionsStartMethodsVector(builder, numElems):
   1006     return builder.StartVector(4, numElems, 4)
   1007 
   1008 
   1009 def DefinitionsCreateMethodsVector(builder, data):
   1010     return builder.CreateVectorOfTables(data)
   1011 
   1012 
   1013 def DefinitionsEnd(builder):
   1014     return builder.EndObject()
   1015 
   1016 
   1017 class VersionedDefinitions(object):
   1018     __slots__ = ['_tab']
   1019 
   1020     @classmethod
   1021     def GetRootAs(cls, buf, offset = 0):
   1022         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
   1023         x = VersionedDefinitions()
   1024         x.Init(buf, n + offset)
   1025         return x
   1026 
   1027     @classmethod
   1028     def GetRootAsVersionedDefinitions(cls, buf, offset = 0):
   1029         return cls.GetRootAs(buf, offset)
   1030 
   1031     def Init(self, buf, pos):
   1032         self._tab = flatbuffers.table.Table(buf, pos)
   1033 
   1034     def Definitions(self, j):
   1035         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
   1036         if o != 0:
   1037             x = self._tab.Vector(o)
   1038             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
   1039             x = self._tab.Indirect(x)
   1040             obj = Definitions()
   1041             obj.Init(self._tab.Bytes, x)
   1042             return obj
   1043 
   1044     def DefinitionsLength(self):
   1045         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
   1046         if o != 0:
   1047             return self._tab.VectorLen(o)
   1048         return 0
   1049 
   1050     def DefinitionsIsNone(self):
   1051         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
   1052         return o == 0
   1053 
   1054 
   1055 def VersionedDefinitionsStart(builder):
   1056     builder.StartObject(1)
   1057 
   1058 
   1059 def VersionedDefinitionsAddDefinitions(builder, definitions):
   1060     builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(definitions), 0)
   1061 
   1062 
   1063 def VersionedDefinitionsStartDefinitionsVector(builder, numElems):
   1064     return builder.StartVector(4, numElems, 4)
   1065 
   1066 
   1067 def VersionedDefinitionsCreateDefinitionsVector(builder, data):
   1068     return builder.CreateVectorOfTables(data)
   1069 
   1070 
   1071 def VersionedDefinitionsEnd(builder):
   1072     return builder.EndObject()
	NovaBryan/EVE_Dump
	Log \| Files \| 📦 下载最新源码 (.zip) \| Refs \| README