NovaBryan/EVE_Dump
Log | Files | 📦 下载最新源码 (.zip) | Refs | README

contributionmethod_generated.py (13867B)

      1 #Embedded file name: C:\BuildAgent\work\20d73f1b24eed06e\eve\release\V24.01\packages\campaigns\client\v1\data_model\flatbuffer\contributionmethod_generated.py
      2 import flatbuffers
      3 from flatbuffers.compat import import_numpy
      4 np = import_numpy()
      5 
      6 class MatcherParameter(object):
      7     __slots__ = ['_tab']
      8 
      9     @classmethod
     10     def GetRootAs(cls, buf, offset = 0):
     11         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
     12         x = MatcherParameter()
     13         x.Init(buf, n + offset)
     14         return x
     15 
     16     @classmethod
     17     def GetRootAsMatcherParameter(cls, buf, offset = 0):
     18         return cls.GetRootAs(buf, offset)
     19 
     20     def Init(self, buf, pos):
     21         self._tab = flatbuffers.table.Table(buf, pos)
     22 
     23     def Key(self):
     24         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
     25         if o != 0:
     26             return self._tab.String(o + self._tab.Pos)
     27 
     28     def Type(self):
     29         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
     30         if o != 0:
     31             return self._tab.String(o + self._tab.Pos)
     32 
     33     def Icon(self):
     34         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
     35         if o != 0:
     36             return self._tab.String(o + self._tab.Pos)
     37 
     38     def AcceptedValueTypes(self, j):
     39         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
     40         if o != 0:
     41             a = self._tab.Vector(o)
     42             return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
     43         return ''
     44 
     45     def AcceptedValueTypesLength(self):
     46         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
     47         if o != 0:
     48             return self._tab.VectorLen(o)
     49         return 0
     50 
     51     def AcceptedValueTypesIsNone(self):
     52         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
     53         return o == 0
     54 
     55     def Title(self):
     56         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
     57         if o != 0:
     58             return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
     59         return 0
     60 
     61     def Description(self):
     62         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
     63         if o != 0:
     64             return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
     65         return 0
     66 
     67 
     68 def MatcherParameterStart(builder):
     69     builder.StartObject(6)
     70 
     71 
     72 def MatcherParameterAddKey(builder, key):
     73     builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(key), 0)
     74 
     75 
     76 def MatcherParameterAddType(builder, type):
     77     builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(type), 0)
     78 
     79 
     80 def MatcherParameterAddIcon(builder, icon):
     81     builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(icon), 0)
     82 
     83 
     84 def MatcherParameterAddAcceptedValueTypes(builder, acceptedValueTypes):
     85     builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(acceptedValueTypes), 0)
     86 
     87 
     88 def MatcherParameterStartAcceptedValueTypesVector(builder, numElems):
     89     return builder.StartVector(4, numElems, 4)
     90 
     91 
     92 def MatcherParameterCreateAcceptedValueTypesVector(builder, data):
     93     return builder.CreateVectorOfTables(data)
     94 
     95 
     96 def MatcherParameterAddTitle(builder, title):
     97     builder.PrependUint64Slot(4, title, 0)
     98 
     99 
    100 def MatcherParameterAddDescription(builder, description):
    101     builder.PrependUint64Slot(5, description, 0)
    102 
    103 
    104 def MatcherParameterEnd(builder):
    105     return builder.EndObject()
    106 
    107 
    108 class Definition(object):
    109     __slots__ = ['_tab']
    110 
    111     @classmethod
    112     def GetRootAs(cls, buf, offset = 0):
    113         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
    114         x = Definition()
    115         x.Init(buf, n + offset)
    116         return x
    117 
    118     @classmethod
    119     def GetRootAsDefinition(cls, buf, offset = 0):
    120         return cls.GetRootAs(buf, offset)
    121 
    122     def Init(self, buf, pos):
    123         self._tab = flatbuffers.table.Table(buf, pos)
    124 
    125     def Name(self):
    126         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
    127         if o != 0:
    128             return self._tab.String(o + self._tab.Pos)
    129 
    130     def Title(self):
    131         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
    132         if o != 0:
    133             return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
    134         return 0
    135 
    136     def ProgressDescription(self):
    137         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
    138         if o != 0:
    139             return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
    140         return 0
    141 
    142     def Icon(self):
    143         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
    144         if o != 0:
    145             return self._tab.String(o + self._tab.Pos)
    146 
    147     def MatcherParameters(self, j):
    148         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
    149         if o != 0:
    150             x = self._tab.Vector(o)
    151             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
    152             x = self._tab.Indirect(x)
    153             obj = MatcherParameter()
    154             obj.Init(self._tab.Bytes, x)
    155             return obj
    156 
    157     def MatcherParametersLength(self):
    158         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
    159         if o != 0:
    160             return self._tab.VectorLen(o)
    161         return 0
    162 
    163     def MatcherParametersIsNone(self):
    164         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
    165         return o == 0
    166 
    167 
    168 def DefinitionStart(builder):
    169     builder.StartObject(5)
    170 
    171 
    172 def DefinitionAddName(builder, name):
    173     builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
    174 
    175 
    176 def DefinitionAddTitle(builder, title):
    177     builder.PrependUint64Slot(1, title, 0)
    178 
    179 
    180 def DefinitionAddProgressDescription(builder, progressDescription):
    181     builder.PrependUint64Slot(2, progressDescription, 0)
    182 
    183 
    184 def DefinitionAddIcon(builder, icon):
    185     builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(icon), 0)
    186 
    187 
    188 def DefinitionAddMatcherParameters(builder, matcherParameters):
    189     builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(matcherParameters), 0)
    190 
    191 
    192 def DefinitionStartMatcherParametersVector(builder, numElems):
    193     return builder.StartVector(4, numElems, 4)
    194 
    195 
    196 def DefinitionCreateMatcherParametersVector(builder, data):
    197     return builder.CreateVectorOfTables(data)
    198 
    199 
    200 def DefinitionEnd(builder):
    201     return builder.EndObject()
    202 
    203 
    204 class SemanticVersion(object):
    205     __slots__ = ['_tab']
    206 
    207     @classmethod
    208     def GetRootAs(cls, buf, offset = 0):
    209         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
    210         x = SemanticVersion()
    211         x.Init(buf, n + offset)
    212         return x
    213 
    214     @classmethod
    215     def GetRootAsSemanticVersion(cls, buf, offset = 0):
    216         return cls.GetRootAs(buf, offset)
    217 
    218     def Init(self, buf, pos):
    219         self._tab = flatbuffers.table.Table(buf, pos)
    220 
    221     def Major(self):
    222         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
    223         if o != 0:
    224             return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
    225         return 0
    226 
    227     def Minor(self):
    228         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
    229         if o != 0:
    230             return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
    231         return 0
    232 
    233     def Patch(self):
    234         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
    235         if o != 0:
    236             return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
    237         return 0
    238 
    239     def PrereleaseTags(self, j):
    240         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
    241         if o != 0:
    242             a = self._tab.Vector(o)
    243             return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
    244         return ''
    245 
    246     def PrereleaseTagsLength(self):
    247         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
    248         if o != 0:
    249             return self._tab.VectorLen(o)
    250         return 0
    251 
    252     def PrereleaseTagsIsNone(self):
    253         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
    254         return o == 0
    255 
    256     def BuildTags(self, j):
    257         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
    258         if o != 0:
    259             a = self._tab.Vector(o)
    260             return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
    261         return ''
    262 
    263     def BuildTagsLength(self):
    264         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
    265         if o != 0:
    266             return self._tab.VectorLen(o)
    267         return 0
    268 
    269     def BuildTagsIsNone(self):
    270         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
    271         return o == 0
    272 
    273 
    274 def SemanticVersionStart(builder):
    275     builder.StartObject(5)
    276 
    277 
    278 def SemanticVersionAddMajor(builder, major):
    279     builder.PrependUint64Slot(0, major, 0)
    280 
    281 
    282 def SemanticVersionAddMinor(builder, minor):
    283     builder.PrependUint64Slot(1, minor, 0)
    284 
    285 
    286 def SemanticVersionAddPatch(builder, patch):
    287     builder.PrependUint64Slot(2, patch, 0)
    288 
    289 
    290 def SemanticVersionAddPrereleaseTags(builder, prereleaseTags):
    291     builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(prereleaseTags), 0)
    292 
    293 
    294 def SemanticVersionStartPrereleaseTagsVector(builder, numElems):
    295     return builder.StartVector(4, numElems, 4)
    296 
    297 
    298 def SemanticVersionCreatePrereleaseTagsVector(builder, data):
    299     return builder.CreateVectorOfTables(data)
    300 
    301 
    302 def SemanticVersionAddBuildTags(builder, buildTags):
    303     builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(buildTags), 0)
    304 
    305 
    306 def SemanticVersionStartBuildTagsVector(builder, numElems):
    307     return builder.StartVector(4, numElems, 4)
    308 
    309 
    310 def SemanticVersionCreateBuildTagsVector(builder, data):
    311     return builder.CreateVectorOfTables(data)
    312 
    313 
    314 def SemanticVersionEnd(builder):
    315     return builder.EndObject()
    316 
    317 
    318 class Definitions(object):
    319     __slots__ = ['_tab']
    320 
    321     @classmethod
    322     def GetRootAs(cls, buf, offset = 0):
    323         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
    324         x = Definitions()
    325         x.Init(buf, n + offset)
    326         return x
    327 
    328     @classmethod
    329     def GetRootAsDefinitions(cls, buf, offset = 0):
    330         return cls.GetRootAs(buf, offset)
    331 
    332     def Init(self, buf, pos):
    333         self._tab = flatbuffers.table.Table(buf, pos)
    334 
    335     def Version(self):
    336         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
    337         if o != 0:
    338             x = self._tab.Indirect(o + self._tab.Pos)
    339             obj = SemanticVersion()
    340             obj.Init(self._tab.Bytes, x)
    341             return obj
    342 
    343     def Methods(self, j):
    344         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
    345         if o != 0:
    346             x = self._tab.Vector(o)
    347             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
    348             x = self._tab.Indirect(x)
    349             obj = Definition()
    350             obj.Init(self._tab.Bytes, x)
    351             return obj
    352 
    353     def MethodsLength(self):
    354         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
    355         if o != 0:
    356             return self._tab.VectorLen(o)
    357         return 0
    358 
    359     def MethodsIsNone(self):
    360         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
    361         return o == 0
    362 
    363 
    364 def DefinitionsStart(builder):
    365     builder.StartObject(2)
    366 
    367 
    368 def DefinitionsAddVersion(builder, version):
    369     builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(version), 0)
    370 
    371 
    372 def DefinitionsAddMethods(builder, methods):
    373     builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(methods), 0)
    374 
    375 
    376 def DefinitionsStartMethodsVector(builder, numElems):
    377     return builder.StartVector(4, numElems, 4)
    378 
    379 
    380 def DefinitionsCreateMethodsVector(builder, data):
    381     return builder.CreateVectorOfTables(data)
    382 
    383 
    384 def DefinitionsEnd(builder):
    385     return builder.EndObject()
    386 
    387 
    388 class VersionedDefinitions(object):
    389     __slots__ = ['_tab']
    390 
    391     @classmethod
    392     def GetRootAs(cls, buf, offset = 0):
    393         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
    394         x = VersionedDefinitions()
    395         x.Init(buf, n + offset)
    396         return x
    397 
    398     @classmethod
    399     def GetRootAsVersionedDefinitions(cls, buf, offset = 0):
    400         return cls.GetRootAs(buf, offset)
    401 
    402     def Init(self, buf, pos):
    403         self._tab = flatbuffers.table.Table(buf, pos)
    404 
    405     def Definitions(self, j):
    406         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
    407         if o != 0:
    408             x = self._tab.Vector(o)
    409             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
    410             x = self._tab.Indirect(x)
    411             obj = Definitions()
    412             obj.Init(self._tab.Bytes, x)
    413             return obj
    414 
    415     def DefinitionsLength(self):
    416         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
    417         if o != 0:
    418             return self._tab.VectorLen(o)
    419         return 0
    420 
    421     def DefinitionsIsNone(self):
    422         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
    423         return o == 0
    424 
    425 
    426 def VersionedDefinitionsStart(builder):
    427     builder.StartObject(1)
    428 
    429 
    430 def VersionedDefinitionsAddDefinitions(builder, definitions):
    431     builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(definitions), 0)
    432 
    433 
    434 def VersionedDefinitionsStartDefinitionsVector(builder, numElems):
    435     return builder.StartVector(4, numElems, 4)
    436 
    437 
    438 def VersionedDefinitionsCreateDefinitionsVector(builder, data):
    439     return builder.CreateVectorOfTables(data)
    440 
    441 
    442 def VersionedDefinitionsEnd(builder):
    443     return builder.EndObject()