google_appengine/google/appengine/base/capabilities_pb.py

   1 #!/usr/bin/env python
   2 #
   3 # Copyright 2007 Google Inc.
   4 #
   5 # Licensed under the Apache License, Version 2.0 (the "License");
   6 # you may not use this file except in compliance with the License.
   7 # You may obtain a copy of the License at
   8 #
   9 #     http://www.apache.org/licenses/LICENSE-2.0
  10 #
  11 # Unless required by applicable law or agreed to in writing, software
  12 # distributed under the License is distributed on an "AS IS" BASIS,
  13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 # See the License for the specific language governing permissions and
  15 # limitations under the License.
  16 #
  17
  18 from google.net.proto import ProtocolBuffer
  19 import array
  20 import dummy_thread as thread
  21
  22 __pychecker__ = """maxreturns=0 maxbranches=0 no-callinit
  23                    unusednames=printElemNumber,debug_strs no-special"""
  24
  25 class CapabilityConfigList(ProtocolBuffer.ProtocolMessage):
  26   has_default_config_ = 0
  27   default_config_ = None
  28
  29   def __init__(self, contents=None):
  30     self.config_ = []
  31     self.lazy_init_lock_ = thread.allocate_lock()
  32     if contents is not None: self.MergeFromString(contents)
  33
  34   def config_size(self): return len(self.config_)
  35   def config_list(self): return self.config_
  36
  37   def config(self, i):
  38     return self.config_[i]
  39
  40   def mutable_config(self, i):
  41     return self.config_[i]
  42
  43   def add_config(self):
  44     x = CapabilityConfig()
  45     self.config_.append(x)
  46     return x
  47
  48   def clear_config(self):
  49     self.config_ = []
  50   def default_config(self):
  51     if self.default_config_ is None:
  52       self.lazy_init_lock_.acquire()
  53       try:
  54         if self.default_config_ is None: self.default_config_ = CapabilityConfig()
  55       finally:
  56         self.lazy_init_lock_.release()
  57     return self.default_config_
  58
  59   def mutable_default_config(self): self.has_default_config_ = 1; return self.default_config()
  60
  61   def clear_default_config(self):
  62     if self.has_default_config_:
  63       self.has_default_config_ = 0;
  64       if self.default_config_ is not None: self.default_config_.Clear()
  65
  66   def has_default_config(self): return self.has_default_config_
  67
  68
  69   def MergeFrom(self, x):
  70     assert x is not self
  71     for i in xrange(x.config_size()): self.add_config().CopyFrom(x.config(i))
  72     if (x.has_default_config()): self.mutable_default_config().MergeFrom(x.default_config())
  73
  74   def Equals(self, x):
  75     if x is self: return 1
  76     if len(self.config_) != len(x.config_): return 0
  77     for e1, e2 in zip(self.config_, x.config_):
  78       if e1 != e2: return 0
  79     if self.has_default_config_ != x.has_default_config_: return 0
  80     if self.has_default_config_ and self.default_config_ != x.default_config_: return 0
  81     return 1
  82
  83   def IsInitialized(self, debug_strs=None):
  84     initialized = 1
  85     for p in self.config_:
  86       if not p.IsInitialized(debug_strs): initialized=0
  87     if (self.has_default_config_ and not self.default_config_.IsInitialized(debug_strs)): initialized = 0
  88     return initialized
  89
  90   def ByteSize(self):
  91     n = 0
  92     n += 1 * len(self.config_)
  93     for i in xrange(len(self.config_)): n += self.lengthString(self.config_[i].ByteSize())
  94     if (self.has_default_config_): n += 1 + self.lengthString(self.default_config_.ByteSize())
  95     return n + 0
  96
  97   def Clear(self):
  98     self.clear_config()
  99     self.clear_default_config()
 100
 101   def OutputUnchecked(self, out):
 102     for i in xrange(len(self.config_)):
 103       out.putVarInt32(10)
 104       out.putVarInt32(self.config_[i].ByteSize())
 105       self.config_[i].OutputUnchecked(out)
 106     if (self.has_default_config_):
 107       out.putVarInt32(18)
 108       out.putVarInt32(self.default_config_.ByteSize())
 109       self.default_config_.OutputUnchecked(out)
 110
 111   def TryMerge(self, d):
 112     while d.avail() > 0:
 113       tt = d.getVarInt32()
 114       if tt == 10:
 115         length = d.getVarInt32()
 116         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
 117         d.skip(length)
 118         self.add_config().TryMerge(tmp)
 119         continue
 120       if tt == 18:
 121         length = d.getVarInt32()
 122         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
 123         d.skip(length)
 124         self.mutable_default_config().TryMerge(tmp)
 125         continue
 126       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 127       d.skipData(tt)
 128
 129
 130   def __str__(self, prefix="", printElemNumber=0):
 131     res=""
 132     cnt=0
 133     for e in self.config_:
 134       elm=""
 135       if printElemNumber: elm="(%d)" % cnt
 136       res+=prefix+("config%s <\n" % elm)
 137       res+=e.__str__(prefix + "  ", printElemNumber)
 138       res+=prefix+">\n"
 139       cnt+=1
 140     if self.has_default_config_:
 141       res+=prefix+"default_config <\n"
 142       res+=self.default_config_.__str__(prefix + "  ", printElemNumber)
 143       res+=prefix+">\n"
 144     return res
 145
 146
 147   def _BuildTagLookupTable(sparse, maxtag, default=None):
 148     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
 149
 150   kconfig = 1
 151   kdefault_config = 2
 152
 153   _TEXT = _BuildTagLookupTable({
 154     0: "ErrorCode",
 155     1: "config",
 156     2: "default_config",
 157   }, 2)
 158
 159   _TYPES = _BuildTagLookupTable({
 160     0: ProtocolBuffer.Encoder.NUMERIC,
 161     1: ProtocolBuffer.Encoder.STRING,
 162     2: ProtocolBuffer.Encoder.STRING,
 163   }, 2, ProtocolBuffer.Encoder.MAX_TYPE)
 164
 165   _STYLE = """"""
 166   _STYLE_CONTENT_TYPE = """"""
 167 class CapabilityConfig(ProtocolBuffer.ProtocolMessage):
 168
 169   ENABLED      =    1
 170   SCHEDULED    =    2
 171   DISABLED     =    3
 172   UNKNOWN      =    4
 173
 174   _Status_NAMES = {
 175     1: "ENABLED",
 176     2: "SCHEDULED",
 177     3: "DISABLED",
 178     4: "UNKNOWN",
 179   }
 180
 181   def Status_Name(cls, x): return cls._Status_NAMES.get(x, "")
 182   Status_Name = classmethod(Status_Name)
 183
 184   has_package_ = 0
 185   package_ = ""
 186   has_capability_ = 0
 187   capability_ = ""
 188   has_status_ = 0
 189   status_ = 4
 190   has_scheduled_time_ = 0
 191   scheduled_time_ = ""
 192   has_internal_message_ = 0
 193   internal_message_ = ""
 194   has_admin_message_ = 0
 195   admin_message_ = ""
 196   has_error_message_ = 0
 197   error_message_ = ""
 198
 199   def __init__(self, contents=None):
 200     if contents is not None: self.MergeFromString(contents)
 201
 202   def package(self): return self.package_
 203
 204   def set_package(self, x):
 205     self.has_package_ = 1
 206     self.package_ = x
 207
 208   def clear_package(self):
 209     if self.has_package_:
 210       self.has_package_ = 0
 211       self.package_ = ""
 212
 213   def has_package(self): return self.has_package_
 214
 215   def capability(self): return self.capability_
 216
 217   def set_capability(self, x):
 218     self.has_capability_ = 1
 219     self.capability_ = x
 220
 221   def clear_capability(self):
 222     if self.has_capability_:
 223       self.has_capability_ = 0
 224       self.capability_ = ""
 225
 226   def has_capability(self): return self.has_capability_
 227
 228   def status(self): return self.status_
 229
 230   def set_status(self, x):
 231     self.has_status_ = 1
 232     self.status_ = x
 233
 234   def clear_status(self):
 235     if self.has_status_:
 236       self.has_status_ = 0
 237       self.status_ = 4
 238
 239   def has_status(self): return self.has_status_
 240
 241   def scheduled_time(self): return self.scheduled_time_
 242
 243   def set_scheduled_time(self, x):
 244     self.has_scheduled_time_ = 1
 245     self.scheduled_time_ = x
 246
 247   def clear_scheduled_time(self):
 248     if self.has_scheduled_time_:
 249       self.has_scheduled_time_ = 0
 250       self.scheduled_time_ = ""
 251
 252   def has_scheduled_time(self): return self.has_scheduled_time_
 253
 254   def internal_message(self): return self.internal_message_
 255
 256   def set_internal_message(self, x):
 257     self.has_internal_message_ = 1
 258     self.internal_message_ = x
 259
 260   def clear_internal_message(self):
 261     if self.has_internal_message_:
 262       self.has_internal_message_ = 0
 263       self.internal_message_ = ""
 264
 265   def has_internal_message(self): return self.has_internal_message_
 266
 267   def admin_message(self): return self.admin_message_
 268
 269   def set_admin_message(self, x):
 270     self.has_admin_message_ = 1
 271     self.admin_message_ = x
 272
 273   def clear_admin_message(self):
 274     if self.has_admin_message_:
 275       self.has_admin_message_ = 0
 276       self.admin_message_ = ""
 277
 278   def has_admin_message(self): return self.has_admin_message_
 279
 280   def error_message(self): return self.error_message_
 281
 282   def set_error_message(self, x):
 283     self.has_error_message_ = 1
 284     self.error_message_ = x
 285
 286   def clear_error_message(self):
 287     if self.has_error_message_:
 288       self.has_error_message_ = 0
 289       self.error_message_ = ""
 290
 291   def has_error_message(self): return self.has_error_message_
 292
 293
 294   def MergeFrom(self, x):
 295     assert x is not self
 296     if (x.has_package()): self.set_package(x.package())
 297     if (x.has_capability()): self.set_capability(x.capability())
 298     if (x.has_status()): self.set_status(x.status())
 299     if (x.has_scheduled_time()): self.set_scheduled_time(x.scheduled_time())
 300     if (x.has_internal_message()): self.set_internal_message(x.internal_message())
 301     if (x.has_admin_message()): self.set_admin_message(x.admin_message())
 302     if (x.has_error_message()): self.set_error_message(x.error_message())
 303
 304   def Equals(self, x):
 305     if x is self: return 1
 306     if self.has_package_ != x.has_package_: return 0
 307     if self.has_package_ and self.package_ != x.package_: return 0
 308     if self.has_capability_ != x.has_capability_: return 0
 309     if self.has_capability_ and self.capability_ != x.capability_: return 0
 310     if self.has_status_ != x.has_status_: return 0
 311     if self.has_status_ and self.status_ != x.status_: return 0
 312     if self.has_scheduled_time_ != x.has_scheduled_time_: return 0
 313     if self.has_scheduled_time_ and self.scheduled_time_ != x.scheduled_time_: return 0
 314     if self.has_internal_message_ != x.has_internal_message_: return 0
 315     if self.has_internal_message_ and self.internal_message_ != x.internal_message_: return 0
 316     if self.has_admin_message_ != x.has_admin_message_: return 0
 317     if self.has_admin_message_ and self.admin_message_ != x.admin_message_: return 0
 318     if self.has_error_message_ != x.has_error_message_: return 0
 319     if self.has_error_message_ and self.error_message_ != x.error_message_: return 0
 320     return 1
 321
 322   def IsInitialized(self, debug_strs=None):
 323     initialized = 1
 324     if (not self.has_package_):
 325       initialized = 0
 326       if debug_strs is not None:
 327         debug_strs.append('Required field: package not set.')
 328     if (not self.has_capability_):
 329       initialized = 0
 330       if debug_strs is not None:
 331         debug_strs.append('Required field: capability not set.')
 332     return initialized
 333
 334   def ByteSize(self):
 335     n = 0
 336     n += self.lengthString(len(self.package_))
 337     n += self.lengthString(len(self.capability_))
 338     if (self.has_status_): n += 1 + self.lengthVarInt64(self.status_)
 339     if (self.has_scheduled_time_): n += 1 + self.lengthString(len(self.scheduled_time_))
 340     if (self.has_internal_message_): n += 1 + self.lengthString(len(self.internal_message_))
 341     if (self.has_admin_message_): n += 1 + self.lengthString(len(self.admin_message_))
 342     if (self.has_error_message_): n += 1 + self.lengthString(len(self.error_message_))
 343     return n + 2
 344
 345   def Clear(self):
 346     self.clear_package()
 347     self.clear_capability()
 348     self.clear_status()
 349     self.clear_scheduled_time()
 350     self.clear_internal_message()
 351     self.clear_admin_message()
 352     self.clear_error_message()
 353
 354   def OutputUnchecked(self, out):
 355     out.putVarInt32(10)
 356     out.putPrefixedString(self.package_)
 357     out.putVarInt32(18)
 358     out.putPrefixedString(self.capability_)
 359     if (self.has_status_):
 360       out.putVarInt32(24)
 361       out.putVarInt32(self.status_)
 362     if (self.has_internal_message_):
 363       out.putVarInt32(34)
 364       out.putPrefixedString(self.internal_message_)
 365     if (self.has_admin_message_):
 366       out.putVarInt32(42)
 367       out.putPrefixedString(self.admin_message_)
 368     if (self.has_error_message_):
 369       out.putVarInt32(50)
 370       out.putPrefixedString(self.error_message_)
 371     if (self.has_scheduled_time_):
 372       out.putVarInt32(58)
 373       out.putPrefixedString(self.scheduled_time_)
 374
 375   def TryMerge(self, d):
 376     while d.avail() > 0:
 377       tt = d.getVarInt32()
 378       if tt == 10:
 379         self.set_package(d.getPrefixedString())
 380         continue
 381       if tt == 18:
 382         self.set_capability(d.getPrefixedString())
 383         continue
 384       if tt == 24:
 385         self.set_status(d.getVarInt32())
 386         continue
 387       if tt == 34:
 388         self.set_internal_message(d.getPrefixedString())
 389         continue
 390       if tt == 42:
 391         self.set_admin_message(d.getPrefixedString())
 392         continue
 393       if tt == 50:
 394         self.set_error_message(d.getPrefixedString())
 395         continue
 396       if tt == 58:
 397         self.set_scheduled_time(d.getPrefixedString())
 398         continue
 399       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 400       d.skipData(tt)
 401
 402
 403   def __str__(self, prefix="", printElemNumber=0):
 404     res=""
 405     if self.has_package_: res+=prefix+("package: %s\n" % self.DebugFormatString(self.package_))
 406     if self.has_capability_: res+=prefix+("capability: %s\n" % self.DebugFormatString(self.capability_))
 407     if self.has_status_: res+=prefix+("status: %s\n" % self.DebugFormatInt32(self.status_))
 408     if self.has_scheduled_time_: res+=prefix+("scheduled_time: %s\n" % self.DebugFormatString(self.scheduled_time_))
 409     if self.has_internal_message_: res+=prefix+("internal_message: %s\n" % self.DebugFormatString(self.internal_message_))
 410     if self.has_admin_message_: res+=prefix+("admin_message: %s\n" % self.DebugFormatString(self.admin_message_))
 411     if self.has_error_message_: res+=prefix+("error_message: %s\n" % self.DebugFormatString(self.error_message_))
 412     return res
 413
 414
 415   def _BuildTagLookupTable(sparse, maxtag, default=None):
 416     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
 417
 418   kpackage = 1
 419   kcapability = 2
 420   kstatus = 3
 421   kscheduled_time = 7
 422   kinternal_message = 4
 423   kadmin_message = 5
 424   kerror_message = 6
 425
 426   _TEXT = _BuildTagLookupTable({
 427     0: "ErrorCode",
 428     1: "package",
 429     2: "capability",
 430     3: "status",
 431     4: "internal_message",
 432     5: "admin_message",
 433     6: "error_message",
 434     7: "scheduled_time",
 435   }, 7)
 436
 437   _TYPES = _BuildTagLookupTable({
 438     0: ProtocolBuffer.Encoder.NUMERIC,
 439     1: ProtocolBuffer.Encoder.STRING,
 440     2: ProtocolBuffer.Encoder.STRING,
 441     3: ProtocolBuffer.Encoder.NUMERIC,
 442     4: ProtocolBuffer.Encoder.STRING,
 443     5: ProtocolBuffer.Encoder.STRING,
 444     6: ProtocolBuffer.Encoder.STRING,
 445     7: ProtocolBuffer.Encoder.STRING,
 446   }, 7, ProtocolBuffer.Encoder.MAX_TYPE)
 447
 448   _STYLE = """"""
 449   _STYLE_CONTENT_TYPE = """"""
 450
 451 __all__ = ['CapabilityConfigList','CapabilityConfig']