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

campaigndefinition_generated.py (44342B)

      1 #Embedded file name: C:\BuildAgent\work\20d73f1b24eed06e\eve\release\V24.01\packages\campaigns\client\v1\data_model\flatbuffer\campaigndefinition_generated.py
      2 import flatbuffers
      3 from flatbuffers.compat import import_numpy
      4 np = import_numpy()
      5 
      6 class CampaignState(object):
      7     Unspecified = 0
      8     Active = 1
      9     Completed = 2
     10     Expired = 3
     11     Cancelled = 4
     12 
     13 
     14 class ObjectiveState(object):
     15     Unspecified = 0
     16     Active = 1
     17     Completed = 2
     18     Expired = 3
     19     Cancelled = 4
     20 
     21 
     22 class FinishedTime(object):
     23     NONE = 0
     24     FinishedTime = 1
     25 
     26 
     27 class IskReward(object):
     28     NONE = 0
     29     details = 1
     30 
     31 
     32 class LpReward(object):
     33     NONE = 0
     34     details = 1
     35 
     36 
     37 class StandingReward(object):
     38     NONE = 0
     39     details = 1
     40 
     41 
     42 class UUID(object):
     43     __slots__ = ['_tab']
     44 
     45     @classmethod
     46     def SizeOf(cls):
     47         return 16
     48 
     49     def Init(self, buf, pos):
     50         self._tab = flatbuffers.table.Table(buf, pos)
     51 
     52     def Bytes(self, j = None):
     53         if j is None:
     54             return [ self._tab.Get(flatbuffers.number_types.Uint8Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(0 + i * 1)) for i in range(self.BytesLength()) ]
     55         elif j >= 0 and j < self.BytesLength():
     56             return self._tab.Get(flatbuffers.number_types.Uint8Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(0 + j * 1))
     57         else:
     58             return
     59 
     60     def BytesAsNumpy(self):
     61         return self._tab.GetArrayAsNumpy(flatbuffers.number_types.Uint8Flags, self._tab.Pos + 0, self.BytesLength())
     62 
     63     def BytesLength(self):
     64         return 16
     65 
     66     def BytesIsNone(self):
     67         return False
     68 
     69 
     70 def CreateUuid(builder, bytes):
     71     builder.Prep(1, 16)
     72     for _idx0 in range(16, 0, -1):
     73         builder.PrependUint8(bytes[_idx0 - 1])
     74 
     75     return builder.Offset()
     76 
     77 
     78 class SemanticVersion(object):
     79     __slots__ = ['_tab']
     80 
     81     @classmethod
     82     def GetRootAs(cls, buf, offset = 0):
     83         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
     84         x = SemanticVersion()
     85         x.Init(buf, n + offset)
     86         return x
     87 
     88     @classmethod
     89     def GetRootAsSemanticVersion(cls, buf, offset = 0):
     90         return cls.GetRootAs(buf, offset)
     91 
     92     def Init(self, buf, pos):
     93         self._tab = flatbuffers.table.Table(buf, pos)
     94 
     95     def Major(self):
     96         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
     97         if o != 0:
     98             return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
     99         return 0
    100 
    101     def Minor(self):
    102         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
    103         if o != 0:
    104             return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
    105         return 0
    106 
    107     def Patch(self):
    108         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
    109         if o != 0:
    110             return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
    111         return 0
    112 
    113     def PrereleaseTags(self, j):
    114         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
    115         if o != 0:
    116             a = self._tab.Vector(o)
    117             return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
    118         return ''
    119 
    120     def PrereleaseTagsLength(self):
    121         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
    122         if o != 0:
    123             return self._tab.VectorLen(o)
    124         return 0
    125 
    126     def PrereleaseTagsIsNone(self):
    127         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
    128         return o == 0
    129 
    130     def BuildTags(self, j):
    131         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
    132         if o != 0:
    133             a = self._tab.Vector(o)
    134             return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
    135         return ''
    136 
    137     def BuildTagsLength(self):
    138         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
    139         if o != 0:
    140             return self._tab.VectorLen(o)
    141         return 0
    142 
    143     def BuildTagsIsNone(self):
    144         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
    145         return o == 0
    146 
    147 
    148 def SemanticVersionStart(builder):
    149     builder.StartObject(5)
    150 
    151 
    152 def SemanticVersionAddMajor(builder, major):
    153     builder.PrependUint64Slot(0, major, 0)
    154 
    155 
    156 def SemanticVersionAddMinor(builder, minor):
    157     builder.PrependUint64Slot(1, minor, 0)
    158 
    159 
    160 def SemanticVersionAddPatch(builder, patch):
    161     builder.PrependUint64Slot(2, patch, 0)
    162 
    163 
    164 def SemanticVersionAddPrereleaseTags(builder, prereleaseTags):
    165     builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(prereleaseTags), 0)
    166 
    167 
    168 def SemanticVersionStartPrereleaseTagsVector(builder, numElems):
    169     return builder.StartVector(4, numElems, 4)
    170 
    171 
    172 def SemanticVersionCreatePrereleaseTagsVector(builder, data):
    173     return builder.CreateVectorOfTables(data)
    174 
    175 
    176 def SemanticVersionAddBuildTags(builder, buildTags):
    177     builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(buildTags), 0)
    178 
    179 
    180 def SemanticVersionStartBuildTagsVector(builder, numElems):
    181     return builder.StartVector(4, numElems, 4)
    182 
    183 
    184 def SemanticVersionCreateBuildTagsVector(builder, data):
    185     return builder.CreateVectorOfTables(data)
    186 
    187 
    188 def SemanticVersionEnd(builder):
    189     return builder.EndObject()
    190 
    191 
    192 class CampaignVersion(object):
    193     __slots__ = ['_tab']
    194 
    195     @classmethod
    196     def GetRootAs(cls, buf, offset = 0):
    197         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
    198         x = CampaignVersion()
    199         x.Init(buf, n + offset)
    200         return x
    201 
    202     @classmethod
    203     def GetRootAsCampaignVersion(cls, buf, offset = 0):
    204         return cls.GetRootAs(buf, offset)
    205 
    206     def Init(self, buf, pos):
    207         self._tab = flatbuffers.table.Table(buf, pos)
    208 
    209     def DefinitionVersion(self):
    210         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
    211         if o != 0:
    212             x = self._tab.Indirect(o + self._tab.Pos)
    213             obj = SemanticVersion()
    214             obj.Init(self._tab.Bytes, x)
    215             return obj
    216 
    217     def Etag(self):
    218         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
    219         if o != 0:
    220             return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
    221         return 0
    222 
    223 
    224 def CampaignVersionStart(builder):
    225     builder.StartObject(2)
    226 
    227 
    228 def CampaignVersionAddDefinitionVersion(builder, definitionVersion):
    229     builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(definitionVersion), 0)
    230 
    231 
    232 def CampaignVersionAddEtag(builder, etag):
    233     builder.PrependUint64Slot(1, etag, 0)
    234 
    235 
    236 def CampaignVersionEnd(builder):
    237     return builder.EndObject()
    238 
    239 
    240 class ImageDefinition(object):
    241     __slots__ = ['_tab']
    242 
    243     @classmethod
    244     def GetRootAs(cls, buf, offset = 0):
    245         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
    246         x = ImageDefinition()
    247         x.Init(buf, n + offset)
    248         return x
    249 
    250     @classmethod
    251     def GetRootAsImageDefinition(cls, buf, offset = 0):
    252         return cls.GetRootAs(buf, offset)
    253 
    254     def Init(self, buf, pos):
    255         self._tab = flatbuffers.table.Table(buf, pos)
    256 
    257     def Path(self):
    258         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
    259         if o != 0:
    260             return self._tab.String(o + self._tab.Pos)
    261 
    262     def Width(self):
    263         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
    264         if o != 0:
    265             return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
    266         return 0
    267 
    268     def Height(self):
    269         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
    270         if o != 0:
    271             return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
    272         return 0
    273 
    274 
    275 def ImageDefinitionStart(builder):
    276     builder.StartObject(3)
    277 
    278 
    279 def ImageDefinitionAddPath(builder, path):
    280     builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(path), 0)
    281 
    282 
    283 def ImageDefinitionAddWidth(builder, width):
    284     builder.PrependUint32Slot(1, width, 0)
    285 
    286 
    287 def ImageDefinitionAddHeight(builder, height):
    288     builder.PrependUint32Slot(2, height, 0)
    289 
    290 
    291 def ImageDefinitionEnd(builder):
    292     return builder.EndObject()
    293 
    294 
    295 class Annotation(object):
    296     __slots__ = ['_tab']
    297 
    298     @classmethod
    299     def GetRootAs(cls, buf, offset = 0):
    300         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
    301         x = Annotation()
    302         x.Init(buf, n + offset)
    303         return x
    304 
    305     @classmethod
    306     def GetRootAsAnnotation(cls, buf, offset = 0):
    307         return cls.GetRootAs(buf, offset)
    308 
    309     def Init(self, buf, pos):
    310         self._tab = flatbuffers.table.Table(buf, pos)
    311 
    312     def Key(self):
    313         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
    314         if o != 0:
    315             return self._tab.String(o + self._tab.Pos)
    316 
    317     def Value(self):
    318         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
    319         if o != 0:
    320             return self._tab.String(o + self._tab.Pos)
    321 
    322 
    323 def AnnotationStart(builder):
    324     builder.StartObject(2)
    325 
    326 
    327 def AnnotationAddKey(builder, key):
    328     builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(key), 0)
    329 
    330 
    331 def AnnotationAddValue(builder, value):
    332     builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(value), 0)
    333 
    334 
    335 def AnnotationEnd(builder):
    336     return builder.EndObject()
    337 
    338 
    339 class ValueEntry(object):
    340     __slots__ = ['_tab']
    341 
    342     @classmethod
    343     def GetRootAs(cls, buf, offset = 0):
    344         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
    345         x = ValueEntry()
    346         x.Init(buf, n + offset)
    347         return x
    348 
    349     @classmethod
    350     def GetRootAsValueEntry(cls, buf, offset = 0):
    351         return cls.GetRootAs(buf, offset)
    352 
    353     def Init(self, buf, pos):
    354         self._tab = flatbuffers.table.Table(buf, pos)
    355 
    356     def Type(self):
    357         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
    358         if o != 0:
    359             return self._tab.String(o + self._tab.Pos)
    360 
    361     def Values(self, j):
    362         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
    363         if o != 0:
    364             a = self._tab.Vector(o)
    365             return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
    366         return ''
    367 
    368     def ValuesLength(self):
    369         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
    370         if o != 0:
    371             return self._tab.VectorLen(o)
    372         return 0
    373 
    374     def ValuesIsNone(self):
    375         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
    376         return o == 0
    377 
    378 
    379 def ValueEntryStart(builder):
    380     builder.StartObject(2)
    381 
    382 
    383 def ValueEntryAddType(builder, type):
    384     builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(type), 0)
    385 
    386 
    387 def ValueEntryAddValues(builder, values):
    388     builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(values), 0)
    389 
    390 
    391 def ValueEntryStartValuesVector(builder, numElems):
    392     return builder.StartVector(4, numElems, 4)
    393 
    394 
    395 def ValueEntryCreateValuesVector(builder, data):
    396     return builder.CreateVectorOfTables(data)
    397 
    398 
    399 def ValueEntryEnd(builder):
    400     return builder.EndObject()
    401 
    402 
    403 class MatcherParameterConfiguration(object):
    404     __slots__ = ['_tab']
    405 
    406     @classmethod
    407     def GetRootAs(cls, buf, offset = 0):
    408         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
    409         x = MatcherParameterConfiguration()
    410         x.Init(buf, n + offset)
    411         return x
    412 
    413     @classmethod
    414     def GetRootAsMatcherParameterConfiguration(cls, buf, offset = 0):
    415         return cls.GetRootAs(buf, offset)
    416 
    417     def Init(self, buf, pos):
    418         self._tab = flatbuffers.table.Table(buf, pos)
    419 
    420     def Key(self):
    421         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
    422         if o != 0:
    423             return self._tab.String(o + self._tab.Pos)
    424 
    425     def Values(self, j):
    426         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
    427         if o != 0:
    428             x = self._tab.Vector(o)
    429             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
    430             x = self._tab.Indirect(x)
    431             obj = ValueEntry()
    432             obj.Init(self._tab.Bytes, x)
    433             return obj
    434 
    435     def ValuesLength(self):
    436         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
    437         if o != 0:
    438             return self._tab.VectorLen(o)
    439         return 0
    440 
    441     def ValuesIsNone(self):
    442         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
    443         return o == 0
    444 
    445 
    446 def MatcherParameterConfigurationStart(builder):
    447     builder.StartObject(2)
    448 
    449 
    450 def MatcherParameterConfigurationAddKey(builder, key):
    451     builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(key), 0)
    452 
    453 
    454 def MatcherParameterConfigurationAddValues(builder, values):
    455     builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(values), 0)
    456 
    457 
    458 def MatcherParameterConfigurationStartValuesVector(builder, numElems):
    459     return builder.StartVector(4, numElems, 4)
    460 
    461 
    462 def MatcherParameterConfigurationCreateValuesVector(builder, data):
    463     return builder.CreateVectorOfTables(data)
    464 
    465 
    466 def MatcherParameterConfigurationEnd(builder):
    467     return builder.EndObject()
    468 
    469 
    470 class ContributionMethodConfiguration(object):
    471     __slots__ = ['_tab']
    472 
    473     @classmethod
    474     def GetRootAs(cls, buf, offset = 0):
    475         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
    476         x = ContributionMethodConfiguration()
    477         x.Init(buf, n + offset)
    478         return x
    479 
    480     @classmethod
    481     def GetRootAsContributionMethodConfiguration(cls, buf, offset = 0):
    482         return cls.GetRootAs(buf, offset)
    483 
    484     def Init(self, buf, pos):
    485         self._tab = flatbuffers.table.Table(buf, pos)
    486 
    487     def Name(self):
    488         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
    489         if o != 0:
    490             return self._tab.String(o + self._tab.Pos)
    491 
    492     def Parameters(self, j):
    493         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
    494         if o != 0:
    495             x = self._tab.Vector(o)
    496             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
    497             x = self._tab.Indirect(x)
    498             obj = MatcherParameterConfiguration()
    499             obj.Init(self._tab.Bytes, x)
    500             return obj
    501 
    502     def ParametersLength(self):
    503         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
    504         if o != 0:
    505             return self._tab.VectorLen(o)
    506         return 0
    507 
    508     def ParametersIsNone(self):
    509         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
    510         return o == 0
    511 
    512 
    513 def ContributionMethodConfigurationStart(builder):
    514     builder.StartObject(2)
    515 
    516 
    517 def ContributionMethodConfigurationAddName(builder, name):
    518     builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
    519 
    520 
    521 def ContributionMethodConfigurationAddParameters(builder, parameters):
    522     builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(parameters), 0)
    523 
    524 
    525 def ContributionMethodConfigurationStartParametersVector(builder, numElems):
    526     return builder.StartVector(4, numElems, 4)
    527 
    528 
    529 def ContributionMethodConfigurationCreateParametersVector(builder, data):
    530     return builder.CreateVectorOfTables(data)
    531 
    532 
    533 def ContributionMethodConfigurationEnd(builder):
    534     return builder.EndObject()
    535 
    536 
    537 class Finished(object):
    538     __slots__ = ['_tab']
    539 
    540     @classmethod
    541     def GetRootAs(cls, buf, offset = 0):
    542         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
    543         x = Finished()
    544         x.Init(buf, n + offset)
    545         return x
    546 
    547     @classmethod
    548     def GetRootAsFinished(cls, buf, offset = 0):
    549         return cls.GetRootAs(buf, offset)
    550 
    551     def Init(self, buf, pos):
    552         self._tab = flatbuffers.table.Table(buf, pos)
    553 
    554     def Timestamp(self):
    555         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
    556         if o != 0:
    557             return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
    558         return 0
    559 
    560 
    561 def FinishedStart(builder):
    562     builder.StartObject(1)
    563 
    564 
    565 def FinishedAddTimestamp(builder, timestamp):
    566     builder.PrependUint64Slot(0, timestamp, 0)
    567 
    568 
    569 def FinishedEnd(builder):
    570     return builder.EndObject()
    571 
    572 
    573 class FutureObjective(object):
    574     __slots__ = ['_tab']
    575 
    576     @classmethod
    577     def GetRootAs(cls, buf, offset = 0):
    578         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
    579         x = FutureObjective()
    580         x.Init(buf, n + offset)
    581         return x
    582 
    583     @classmethod
    584     def GetRootAsFutureObjective(cls, buf, offset = 0):
    585         return cls.GetRootAs(buf, offset)
    586 
    587     def Init(self, buf, pos):
    588         self._tab = flatbuffers.table.Table(buf, pos)
    589 
    590     def ScheduledStartTime(self):
    591         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
    592         if o != 0:
    593             return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
    594         return 0
    595 
    596     def Career(self):
    597         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
    598         if o != 0:
    599             return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
    600         return 0
    601 
    602     def ContributionMethod(self):
    603         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
    604         if o != 0:
    605             return self._tab.String(o + self._tab.Pos)
    606 
    607 
    608 def FutureObjectiveStart(builder):
    609     builder.StartObject(3)
    610 
    611 
    612 def FutureObjectiveAddScheduledStartTime(builder, scheduledStartTime):
    613     builder.PrependUint64Slot(0, scheduledStartTime, 0)
    614 
    615 
    616 def FutureObjectiveAddCareer(builder, career):
    617     builder.PrependUint32Slot(1, career, 0)
    618 
    619 
    620 def FutureObjectiveAddContributionMethod(builder, contributionMethod):
    621     builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(contributionMethod), 0)
    622 
    623 
    624 def FutureObjectiveEnd(builder):
    625     return builder.EndObject()
    626 
    627 
    628 class RewardDetails(object):
    629     __slots__ = ['_tab']
    630 
    631     @classmethod
    632     def GetRootAs(cls, buf, offset = 0):
    633         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
    634         x = RewardDetails()
    635         x.Init(buf, n + offset)
    636         return x
    637 
    638     @classmethod
    639     def GetRootAsRewardDetails(cls, buf, offset = 0):
    640         return cls.GetRootAs(buf, offset)
    641 
    642     def Init(self, buf, pos):
    643         self._tab = flatbuffers.table.Table(buf, pos)
    644 
    645     def AmountPerInterval(self):
    646         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
    647         if o != 0:
    648             return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
    649         return 0.0
    650 
    651     def Issuer(self):
    652         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
    653         if o != 0:
    654             return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
    655         return 0
    656 
    657     def IntervalSize(self):
    658         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
    659         if o != 0:
    660             return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
    661         return 0
    662 
    663 
    664 def RewardDetailsStart(builder):
    665     builder.StartObject(3)
    666 
    667 
    668 def RewardDetailsAddAmountPerInterval(builder, amountPerInterval):
    669     builder.PrependFloat64Slot(0, amountPerInterval, 0.0)
    670 
    671 
    672 def RewardDetailsAddIssuer(builder, issuer):
    673     builder.PrependUint64Slot(1, issuer, 0)
    674 
    675 
    676 def RewardDetailsAddIntervalSize(builder, intervalSize):
    677     builder.PrependUint64Slot(2, intervalSize, 0)
    678 
    679 
    680 def RewardDetailsEnd(builder):
    681     return builder.EndObject()
    682 
    683 
    684 class Rewards(object):
    685     __slots__ = ['_tab']
    686 
    687     @classmethod
    688     def GetRootAs(cls, buf, offset = 0):
    689         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
    690         x = Rewards()
    691         x.Init(buf, n + offset)
    692         return x
    693 
    694     @classmethod
    695     def GetRootAsRewards(cls, buf, offset = 0):
    696         return cls.GetRootAs(buf, offset)
    697 
    698     def Init(self, buf, pos):
    699         self._tab = flatbuffers.table.Table(buf, pos)
    700 
    701     def IskType(self):
    702         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
    703         if o != 0:
    704             return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
    705         return 0
    706 
    707     def Isk(self):
    708         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
    709         if o != 0:
    710             from flatbuffers.table import Table
    711             obj = Table(bytearray(), 0)
    712             self._tab.Union(obj, o)
    713             return obj
    714 
    715     def LpType(self):
    716         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
    717         if o != 0:
    718             return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
    719         return 0
    720 
    721     def Lp(self):
    722         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
    723         if o != 0:
    724             from flatbuffers.table import Table
    725             obj = Table(bytearray(), 0)
    726             self._tab.Union(obj, o)
    727             return obj
    728 
    729     def StandingType(self):
    730         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
    731         if o != 0:
    732             return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
    733         return 0
    734 
    735     def Standing(self):
    736         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
    737         if o != 0:
    738             from flatbuffers.table import Table
    739             obj = Table(bytearray(), 0)
    740             self._tab.Union(obj, o)
    741             return obj
    742 
    743 
    744 def RewardsStart(builder):
    745     builder.StartObject(6)
    746 
    747 
    748 def RewardsAddIskType(builder, iskType):
    749     builder.PrependUint8Slot(0, iskType, 0)
    750 
    751 
    752 def RewardsAddIsk(builder, isk):
    753     builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(isk), 0)
    754 
    755 
    756 def RewardsAddLpType(builder, lpType):
    757     builder.PrependUint8Slot(2, lpType, 0)
    758 
    759 
    760 def RewardsAddLp(builder, lp):
    761     builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(lp), 0)
    762 
    763 
    764 def RewardsAddStandingType(builder, standingType):
    765     builder.PrependUint8Slot(4, standingType, 0)
    766 
    767 
    768 def RewardsAddStanding(builder, standing):
    769     builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(standing), 0)
    770 
    771 
    772 def RewardsEnd(builder):
    773     return builder.EndObject()
    774 
    775 
    776 class Objective(object):
    777     __slots__ = ['_tab']
    778 
    779     @classmethod
    780     def GetRootAs(cls, buf, offset = 0):
    781         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
    782         x = Objective()
    783         x.Init(buf, n + offset)
    784         return x
    785 
    786     @classmethod
    787     def GetRootAsObjective(cls, buf, offset = 0):
    788         return cls.GetRootAs(buf, offset)
    789 
    790     def Init(self, buf, pos):
    791         self._tab = flatbuffers.table.Table(buf, pos)
    792 
    793     def Uuid(self):
    794         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
    795         if o != 0:
    796             x = o + self._tab.Pos
    797             obj = UUID()
    798             obj.Init(self._tab.Bytes, x)
    799             return obj
    800 
    801     def Title(self):
    802         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
    803         if o != 0:
    804             return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
    805         return 0
    806 
    807     def Subtitle(self):
    808         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
    809         if o != 0:
    810             return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
    811         return 0
    812 
    813     def Issuer(self):
    814         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
    815         if o != 0:
    816             return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
    817         return 0
    818 
    819     def PresentingCharacter(self):
    820         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
    821         if o != 0:
    822             return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
    823         return 0
    824 
    825     def ContentTags(self, j):
    826         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
    827         if o != 0:
    828             a = self._tab.Vector(o)
    829             return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
    830         return ''
    831 
    832     def ContentTagsLength(self):
    833         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
    834         if o != 0:
    835             return self._tab.VectorLen(o)
    836         return 0
    837 
    838     def ContentTagsIsNone(self):
    839         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
    840         return o == 0
    841 
    842     def ScheduledStartTime(self):
    843         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
    844         if o != 0:
    845             return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
    846         return 0
    847 
    848     def FinishedTimeType(self):
    849         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
    850         if o != 0:
    851             return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
    852         return 0
    853 
    854     def FinishedTime(self):
    855         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
    856         if o != 0:
    857             from flatbuffers.table import Table
    858             obj = Table(bytearray(), 0)
    859             self._tab.Union(obj, o)
    860             return obj
    861 
    862     def Career(self):
    863         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
    864         if o != 0:
    865             return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
    866         return 0
    867 
    868     def TargetProgress(self):
    869         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
    870         if o != 0:
    871             return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
    872         return 0
    873 
    874     def MaxProgressPerParticipant(self):
    875         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
    876         if o != 0:
    877             return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
    878         return 0
    879 
    880     def ContributionMethodConfig(self):
    881         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
    882         if o != 0:
    883             x = self._tab.Indirect(o + self._tab.Pos)
    884             obj = ContributionMethodConfiguration()
    885             obj.Init(self._tab.Bytes, x)
    886             return obj
    887 
    888     def Rewards(self):
    889         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
    890         if o != 0:
    891             x = self._tab.Indirect(o + self._tab.Pos)
    892             obj = Rewards()
    893             obj.Init(self._tab.Bytes, x)
    894             return obj
    895 
    896     def ObjectiveState(self):
    897         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
    898         if o != 0:
    899             return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
    900         return 0
    901 
    902     def Annotations(self, j):
    903         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
    904         if o != 0:
    905             x = self._tab.Vector(o)
    906             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
    907             x = self._tab.Indirect(x)
    908             obj = Annotation()
    909             obj.Init(self._tab.Bytes, x)
    910             return obj
    911 
    912     def AnnotationsLength(self):
    913         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
    914         if o != 0:
    915             return self._tab.VectorLen(o)
    916         return 0
    917 
    918     def AnnotationsIsNone(self):
    919         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
    920         return o == 0
    921 
    922 
    923 def ObjectiveStart(builder):
    924     builder.StartObject(16)
    925 
    926 
    927 def ObjectiveAddUuid(builder, uuid):
    928     builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(uuid), 0)
    929 
    930 
    931 def ObjectiveAddTitle(builder, title):
    932     builder.PrependUint64Slot(1, title, 0)
    933 
    934 
    935 def ObjectiveAddSubtitle(builder, subtitle):
    936     builder.PrependUint64Slot(2, subtitle, 0)
    937 
    938 
    939 def ObjectiveAddIssuer(builder, issuer):
    940     builder.PrependUint64Slot(3, issuer, 0)
    941 
    942 
    943 def ObjectiveAddPresentingCharacter(builder, presentingCharacter):
    944     builder.PrependUint64Slot(4, presentingCharacter, 0)
    945 
    946 
    947 def ObjectiveAddContentTags(builder, contentTags):
    948     builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(contentTags), 0)
    949 
    950 
    951 def ObjectiveStartContentTagsVector(builder, numElems):
    952     return builder.StartVector(4, numElems, 4)
    953 
    954 
    955 def ObjectiveCreateContentTagsVector(builder, data):
    956     return builder.CreateVectorOfTables(data)
    957 
    958 
    959 def ObjectiveAddScheduledStartTime(builder, scheduledStartTime):
    960     builder.PrependUint64Slot(6, scheduledStartTime, 0)
    961 
    962 
    963 def ObjectiveAddFinishedTimeType(builder, finishedTimeType):
    964     builder.PrependUint8Slot(7, finishedTimeType, 0)
    965 
    966 
    967 def ObjectiveAddFinishedTime(builder, finishedTime):
    968     builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(finishedTime), 0)
    969 
    970 
    971 def ObjectiveAddCareer(builder, career):
    972     builder.PrependUint32Slot(9, career, 0)
    973 
    974 
    975 def ObjectiveAddTargetProgress(builder, targetProgress):
    976     builder.PrependUint64Slot(10, targetProgress, 0)
    977 
    978 
    979 def ObjectiveAddMaxProgressPerParticipant(builder, maxProgressPerParticipant):
    980     builder.PrependUint64Slot(11, maxProgressPerParticipant, 0)
    981 
    982 
    983 def ObjectiveAddContributionMethodConfig(builder, contributionMethodConfig):
    984     builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(contributionMethodConfig), 0)
    985 
    986 
    987 def ObjectiveAddRewards(builder, rewards):
    988     builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(rewards), 0)
    989 
    990 
    991 def ObjectiveAddObjectiveState(builder, objectiveState):
    992     builder.PrependUint32Slot(14, objectiveState, 0)
    993 
    994 
    995 def ObjectiveAddAnnotations(builder, annotations):
    996     builder.PrependUOffsetTRelativeSlot(15, flatbuffers.number_types.UOffsetTFlags.py_type(annotations), 0)
    997 
    998 
    999 def ObjectiveStartAnnotationsVector(builder, numElems):
   1000     return builder.StartVector(4, numElems, 4)
   1001 
   1002 
   1003 def ObjectiveCreateAnnotationsVector(builder, data):
   1004     return builder.CreateVectorOfTables(data)
   1005 
   1006 
   1007 def ObjectiveEnd(builder):
   1008     return builder.EndObject()
   1009 
   1010 
   1011 class Campaign(object):
   1012     __slots__ = ['_tab']
   1013 
   1014     @classmethod
   1015     def GetRootAs(cls, buf, offset = 0):
   1016         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
   1017         x = Campaign()
   1018         x.Init(buf, n + offset)
   1019         return x
   1020 
   1021     @classmethod
   1022     def GetRootAsCampaign(cls, buf, offset = 0):
   1023         return cls.GetRootAs(buf, offset)
   1024 
   1025     def Init(self, buf, pos):
   1026         self._tab = flatbuffers.table.Table(buf, pos)
   1027 
   1028     def Uuid(self):
   1029         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
   1030         if o != 0:
   1031             x = o + self._tab.Pos
   1032             obj = UUID()
   1033             obj.Init(self._tab.Bytes, x)
   1034             return obj
   1035 
   1036     def Version(self):
   1037         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
   1038         if o != 0:
   1039             x = self._tab.Indirect(o + self._tab.Pos)
   1040             obj = CampaignVersion()
   1041             obj.Init(self._tab.Bytes, x)
   1042             return obj
   1043 
   1044     def Title(self):
   1045         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
   1046         if o != 0:
   1047             return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
   1048         return 0
   1049 
   1050     def Subtitle(self):
   1051         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
   1052         if o != 0:
   1053             return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
   1054         return 0
   1055 
   1056     def BriefingGoalDescription(self):
   1057         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
   1058         if o != 0:
   1059             return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
   1060         return 0
   1061 
   1062     def BriefingSuccessDescription(self):
   1063         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
   1064         if o != 0:
   1065             return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
   1066         return 0
   1067 
   1068     def BriefingFailureDescription(self):
   1069         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
   1070         if o != 0:
   1071             return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
   1072         return 0
   1073 
   1074     def Icon(self):
   1075         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
   1076         if o != 0:
   1077             return self._tab.String(o + self._tab.Pos)
   1078 
   1079     def Logo(self):
   1080         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
   1081         if o != 0:
   1082             x = self._tab.Indirect(o + self._tab.Pos)
   1083             obj = ImageDefinition()
   1084             obj.Init(self._tab.Bytes, x)
   1085             return obj
   1086 
   1087     def DashboardBackground(self):
   1088         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
   1089         if o != 0:
   1090             return self._tab.String(o + self._tab.Pos)
   1091 
   1092     def AoFeaturePage(self):
   1093         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
   1094         if o != 0:
   1095             return self._tab.String(o + self._tab.Pos)
   1096 
   1097     def ObjectiveBackground(self):
   1098         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
   1099         if o != 0:
   1100             return self._tab.String(o + self._tab.Pos)
   1101 
   1102     def Issuer(self):
   1103         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
   1104         if o != 0:
   1105             return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
   1106         return 0
   1107 
   1108     def PresentingCharacter(self):
   1109         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
   1110         if o != 0:
   1111             return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
   1112         return 0
   1113 
   1114     def Annotations(self, j):
   1115         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
   1116         if o != 0:
   1117             x = self._tab.Vector(o)
   1118             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
   1119             x = self._tab.Indirect(x)
   1120             obj = Annotation()
   1121             obj.Init(self._tab.Bytes, x)
   1122             return obj
   1123 
   1124     def AnnotationsLength(self):
   1125         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
   1126         if o != 0:
   1127             return self._tab.VectorLen(o)
   1128         return 0
   1129 
   1130     def AnnotationsIsNone(self):
   1131         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
   1132         return o == 0
   1133 
   1134     def TotalObjectives(self):
   1135         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
   1136         if o != 0:
   1137             return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
   1138         return 0
   1139 
   1140     def State(self):
   1141         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
   1142         if o != 0:
   1143             return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
   1144         return 0
   1145 
   1146     def ScheduledStartTime(self):
   1147         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(38))
   1148         if o != 0:
   1149             return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
   1150         return 0
   1151 
   1152     def ScheduledExpiryTime(self):
   1153         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(40))
   1154         if o != 0:
   1155             return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
   1156         return 0
   1157 
   1158     def FinishedTimeType(self):
   1159         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(42))
   1160         if o != 0:
   1161             return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
   1162         return 0
   1163 
   1164     def FinishedTime(self):
   1165         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(44))
   1166         if o != 0:
   1167             from flatbuffers.table import Table
   1168             obj = Table(bytearray(), 0)
   1169             self._tab.Union(obj, o)
   1170             return obj
   1171 
   1172     def TargetProgress(self):
   1173         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(46))
   1174         if o != 0:
   1175             return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
   1176         return 0
   1177 
   1178     def ContributionMethodConfig(self):
   1179         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(48))
   1180         if o != 0:
   1181             x = self._tab.Indirect(o + self._tab.Pos)
   1182             obj = ContributionMethodConfiguration()
   1183             obj.Init(self._tab.Bytes, x)
   1184             return obj
   1185 
   1186     def FutureObjectives(self, j):
   1187         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(50))
   1188         if o != 0:
   1189             x = self._tab.Vector(o)
   1190             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
   1191             x = self._tab.Indirect(x)
   1192             obj = FutureObjective()
   1193             obj.Init(self._tab.Bytes, x)
   1194             return obj
   1195 
   1196     def FutureObjectivesLength(self):
   1197         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(50))
   1198         if o != 0:
   1199             return self._tab.VectorLen(o)
   1200         return 0
   1201 
   1202     def FutureObjectivesIsNone(self):
   1203         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(50))
   1204         return o == 0
   1205 
   1206     def CurrentObjectives(self, j):
   1207         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
   1208         if o != 0:
   1209             x = self._tab.Vector(o)
   1210             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
   1211             x = self._tab.Indirect(x)
   1212             obj = Objective()
   1213             obj.Init(self._tab.Bytes, x)
   1214             return obj
   1215 
   1216     def CurrentObjectivesLength(self):
   1217         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
   1218         if o != 0:
   1219             return self._tab.VectorLen(o)
   1220         return 0
   1221 
   1222     def CurrentObjectivesIsNone(self):
   1223         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
   1224         return o == 0
   1225 
   1226     def DefinitionName(self):
   1227         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(54))
   1228         if o != 0:
   1229             return self._tab.String(o + self._tab.Pos)
   1230 
   1231 
   1232 def CampaignStart(builder):
   1233     builder.StartObject(26)
   1234 
   1235 
   1236 def CampaignAddUuid(builder, uuid):
   1237     builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(uuid), 0)
   1238 
   1239 
   1240 def CampaignAddVersion(builder, version):
   1241     builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(version), 0)
   1242 
   1243 
   1244 def CampaignAddTitle(builder, title):
   1245     builder.PrependUint64Slot(2, title, 0)
   1246 
   1247 
   1248 def CampaignAddSubtitle(builder, subtitle):
   1249     builder.PrependUint64Slot(3, subtitle, 0)
   1250 
   1251 
   1252 def CampaignAddBriefingGoalDescription(builder, briefingGoalDescription):
   1253     builder.PrependUint64Slot(4, briefingGoalDescription, 0)
   1254 
   1255 
   1256 def CampaignAddBriefingSuccessDescription(builder, briefingSuccessDescription):
   1257     builder.PrependUint64Slot(5, briefingSuccessDescription, 0)
   1258 
   1259 
   1260 def CampaignAddBriefingFailureDescription(builder, briefingFailureDescription):
   1261     builder.PrependUint64Slot(6, briefingFailureDescription, 0)
   1262 
   1263 
   1264 def CampaignAddIcon(builder, icon):
   1265     builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(icon), 0)
   1266 
   1267 
   1268 def CampaignAddLogo(builder, logo):
   1269     builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(logo), 0)
   1270 
   1271 
   1272 def CampaignAddDashboardBackground(builder, dashboardBackground):
   1273     builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(dashboardBackground), 0)
   1274 
   1275 
   1276 def CampaignAddAoFeaturePage(builder, aoFeaturePage):
   1277     builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(aoFeaturePage), 0)
   1278 
   1279 
   1280 def CampaignAddObjectiveBackground(builder, objectiveBackground):
   1281     builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(objectiveBackground), 0)
   1282 
   1283 
   1284 def CampaignAddIssuer(builder, issuer):
   1285     builder.PrependUint64Slot(12, issuer, 0)
   1286 
   1287 
   1288 def CampaignAddPresentingCharacter(builder, presentingCharacter):
   1289     builder.PrependUint64Slot(13, presentingCharacter, 0)
   1290 
   1291 
   1292 def CampaignAddAnnotations(builder, annotations):
   1293     builder.PrependUOffsetTRelativeSlot(14, flatbuffers.number_types.UOffsetTFlags.py_type(annotations), 0)
   1294 
   1295 
   1296 def CampaignStartAnnotationsVector(builder, numElems):
   1297     return builder.StartVector(4, numElems, 4)
   1298 
   1299 
   1300 def CampaignCreateAnnotationsVector(builder, data):
   1301     return builder.CreateVectorOfTables(data)
   1302 
   1303 
   1304 def CampaignAddTotalObjectives(builder, totalObjectives):
   1305     builder.PrependUint32Slot(15, totalObjectives, 0)
   1306 
   1307 
   1308 def CampaignAddState(builder, state):
   1309     builder.PrependUint32Slot(16, state, 0)
   1310 
   1311 
   1312 def CampaignAddScheduledStartTime(builder, scheduledStartTime):
   1313     builder.PrependUint64Slot(17, scheduledStartTime, 0)
   1314 
   1315 
   1316 def CampaignAddScheduledExpiryTime(builder, scheduledExpiryTime):
   1317     builder.PrependUint64Slot(18, scheduledExpiryTime, 0)
   1318 
   1319 
   1320 def CampaignAddFinishedTimeType(builder, finishedTimeType):
   1321     builder.PrependUint8Slot(19, finishedTimeType, 0)
   1322 
   1323 
   1324 def CampaignAddFinishedTime(builder, finishedTime):
   1325     builder.PrependUOffsetTRelativeSlot(20, flatbuffers.number_types.UOffsetTFlags.py_type(finishedTime), 0)
   1326 
   1327 
   1328 def CampaignAddTargetProgress(builder, targetProgress):
   1329     builder.PrependUint64Slot(21, targetProgress, 0)
   1330 
   1331 
   1332 def CampaignAddContributionMethodConfig(builder, contributionMethodConfig):
   1333     builder.PrependUOffsetTRelativeSlot(22, flatbuffers.number_types.UOffsetTFlags.py_type(contributionMethodConfig), 0)
   1334 
   1335 
   1336 def CampaignAddFutureObjectives(builder, futureObjectives):
   1337     builder.PrependUOffsetTRelativeSlot(23, flatbuffers.number_types.UOffsetTFlags.py_type(futureObjectives), 0)
   1338 
   1339 
   1340 def CampaignStartFutureObjectivesVector(builder, numElems):
   1341     return builder.StartVector(4, numElems, 4)
   1342 
   1343 
   1344 def CampaignCreateFutureObjectivesVector(builder, data):
   1345     return builder.CreateVectorOfTables(data)
   1346 
   1347 
   1348 def CampaignAddCurrentObjectives(builder, currentObjectives):
   1349     builder.PrependUOffsetTRelativeSlot(24, flatbuffers.number_types.UOffsetTFlags.py_type(currentObjectives), 0)
   1350 
   1351 
   1352 def CampaignStartCurrentObjectivesVector(builder, numElems):
   1353     return builder.StartVector(4, numElems, 4)
   1354 
   1355 
   1356 def CampaignCreateCurrentObjectivesVector(builder, data):
   1357     return builder.CreateVectorOfTables(data)
   1358 
   1359 
   1360 def CampaignAddDefinitionName(builder, definitionName):
   1361     builder.PrependUOffsetTRelativeSlot(25, flatbuffers.number_types.UOffsetTFlags.py_type(definitionName), 0)
   1362 
   1363 
   1364 def CampaignEnd(builder):
   1365     return builder.EndObject()
   1366 
   1367 
   1368 class CampaignList(object):
   1369     __slots__ = ['_tab']
   1370 
   1371     @classmethod
   1372     def GetRootAs(cls, buf, offset = 0):
   1373         n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
   1374         x = CampaignList()
   1375         x.Init(buf, n + offset)
   1376         return x
   1377 
   1378     @classmethod
   1379     def GetRootAsCampaignList(cls, buf, offset = 0):
   1380         return cls.GetRootAs(buf, offset)
   1381 
   1382     def Init(self, buf, pos):
   1383         self._tab = flatbuffers.table.Table(buf, pos)
   1384 
   1385     def Campaigns(self, j):
   1386         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
   1387         if o != 0:
   1388             x = self._tab.Vector(o)
   1389             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
   1390             x = self._tab.Indirect(x)
   1391             obj = Campaign()
   1392             obj.Init(self._tab.Bytes, x)
   1393             return obj
   1394 
   1395     def CampaignsLength(self):
   1396         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
   1397         if o != 0:
   1398             return self._tab.VectorLen(o)
   1399         return 0
   1400 
   1401     def CampaignsIsNone(self):
   1402         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
   1403         return o == 0
   1404 
   1405 
   1406 def CampaignListStart(builder):
   1407     builder.StartObject(1)
   1408 
   1409 
   1410 def CampaignListAddCampaigns(builder, campaigns):
   1411     builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(campaigns), 0)
   1412 
   1413 
   1414 def CampaignListStartCampaignsVector(builder, numElems):
   1415     return builder.StartVector(4, numElems, 4)
   1416 
   1417 
   1418 def CampaignListCreateCampaignsVector(builder, data):
   1419     return builder.CreateVectorOfTables(data)
   1420 
   1421 
   1422 def CampaignListEnd(builder):
   1423     return builder.EndObject()