python/google/appengine/api/memcache/memcache_service_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
  19
  20 from google.net.proto import ProtocolBuffer
  21 import array
  22 import dummy_thread as thread
  23
  24 __pychecker__ = """maxreturns=0 maxbranches=0 no-callinit
  25                    unusednames=printElemNumber,debug_strs no-special"""
  26
  27 if hasattr(ProtocolBuffer, 'ExtendableProtocolMessage'):
  28   _extension_runtime = True
  29   _ExtendableProtocolMessage = ProtocolBuffer.ExtendableProtocolMessage
  30 else:
  31   _extension_runtime = False
  32   _ExtendableProtocolMessage = ProtocolBuffer.ProtocolMessage
  33
  34 class MemcacheServiceError(ProtocolBuffer.ProtocolMessage):
  35
  36
  37   OK           =    0
  38   UNSPECIFIED_ERROR =    1
  39   NAMESPACE_NOT_SET =    2
  40   PERMISSION_DENIED =    3
  41   INVALID_VALUE =    6
  42   UNAVAILABLE  =    9
  43
  44   _ErrorCode_NAMES = {
  45     0: "OK",
  46     1: "UNSPECIFIED_ERROR",
  47     2: "NAMESPACE_NOT_SET",
  48     3: "PERMISSION_DENIED",
  49     6: "INVALID_VALUE",
  50     9: "UNAVAILABLE",
  51   }
  52
  53   def ErrorCode_Name(cls, x): return cls._ErrorCode_NAMES.get(x, "")
  54   ErrorCode_Name = classmethod(ErrorCode_Name)
  55
  56
  57   def __init__(self, contents=None):
  58     pass
  59     if contents is not None: self.MergeFromString(contents)
  60
  61
  62   def MergeFrom(self, x):
  63     assert x is not self
  64
  65   def Equals(self, x):
  66     if x is self: return 1
  67     return 1
  68
  69   def IsInitialized(self, debug_strs=None):
  70     initialized = 1
  71     return initialized
  72
  73   def ByteSize(self):
  74     n = 0
  75     return n
  76
  77   def ByteSizePartial(self):
  78     n = 0
  79     return n
  80
  81   def Clear(self):
  82     pass
  83
  84   def OutputUnchecked(self, out):
  85     pass
  86
  87   def OutputPartial(self, out):
  88     pass
  89
  90   def TryMerge(self, d):
  91     while d.avail() > 0:
  92       tt = d.getVarInt32()
  93
  94
  95       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
  96       d.skipData(tt)
  97
  98
  99   def __str__(self, prefix="", printElemNumber=0):
 100     res=""
 101     return res
 102
 103
 104   def _BuildTagLookupTable(sparse, maxtag, default=None):
 105     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
 106
 107
 108   _TEXT = _BuildTagLookupTable({
 109     0: "ErrorCode",
 110   }, 0)
 111
 112   _TYPES = _BuildTagLookupTable({
 113     0: ProtocolBuffer.Encoder.NUMERIC,
 114   }, 0, ProtocolBuffer.Encoder.MAX_TYPE)
 115
 116
 117   _STYLE = """"""
 118   _STYLE_CONTENT_TYPE = """"""
 119   _PROTO_DESCRIPTOR_NAME = 'apphosting.MemcacheServiceError'
 120 class AppOverride(ProtocolBuffer.ProtocolMessage):
 121   has_app_id_ = 0
 122   app_id_ = ""
 123   has_num_memcacheg_backends_ = 0
 124   num_memcacheg_backends_ = 0
 125   has_ignore_shardlock_ = 0
 126   ignore_shardlock_ = 0
 127   has_memcache_pool_hint_ = 0
 128   memcache_pool_hint_ = ""
 129   has_memcache_sharding_strategy_ = 0
 130   memcache_sharding_strategy_ = ""
 131
 132   def __init__(self, contents=None):
 133     if contents is not None: self.MergeFromString(contents)
 134
 135   def app_id(self): return self.app_id_
 136
 137   def set_app_id(self, x):
 138     self.has_app_id_ = 1
 139     self.app_id_ = x
 140
 141   def clear_app_id(self):
 142     if self.has_app_id_:
 143       self.has_app_id_ = 0
 144       self.app_id_ = ""
 145
 146   def has_app_id(self): return self.has_app_id_
 147
 148   def num_memcacheg_backends(self): return self.num_memcacheg_backends_
 149
 150   def set_num_memcacheg_backends(self, x):
 151     self.has_num_memcacheg_backends_ = 1
 152     self.num_memcacheg_backends_ = x
 153
 154   def clear_num_memcacheg_backends(self):
 155     if self.has_num_memcacheg_backends_:
 156       self.has_num_memcacheg_backends_ = 0
 157       self.num_memcacheg_backends_ = 0
 158
 159   def has_num_memcacheg_backends(self): return self.has_num_memcacheg_backends_
 160
 161   def ignore_shardlock(self): return self.ignore_shardlock_
 162
 163   def set_ignore_shardlock(self, x):
 164     self.has_ignore_shardlock_ = 1
 165     self.ignore_shardlock_ = x
 166
 167   def clear_ignore_shardlock(self):
 168     if self.has_ignore_shardlock_:
 169       self.has_ignore_shardlock_ = 0
 170       self.ignore_shardlock_ = 0
 171
 172   def has_ignore_shardlock(self): return self.has_ignore_shardlock_
 173
 174   def memcache_pool_hint(self): return self.memcache_pool_hint_
 175
 176   def set_memcache_pool_hint(self, x):
 177     self.has_memcache_pool_hint_ = 1
 178     self.memcache_pool_hint_ = x
 179
 180   def clear_memcache_pool_hint(self):
 181     if self.has_memcache_pool_hint_:
 182       self.has_memcache_pool_hint_ = 0
 183       self.memcache_pool_hint_ = ""
 184
 185   def has_memcache_pool_hint(self): return self.has_memcache_pool_hint_
 186
 187   def memcache_sharding_strategy(self): return self.memcache_sharding_strategy_
 188
 189   def set_memcache_sharding_strategy(self, x):
 190     self.has_memcache_sharding_strategy_ = 1
 191     self.memcache_sharding_strategy_ = x
 192
 193   def clear_memcache_sharding_strategy(self):
 194     if self.has_memcache_sharding_strategy_:
 195       self.has_memcache_sharding_strategy_ = 0
 196       self.memcache_sharding_strategy_ = ""
 197
 198   def has_memcache_sharding_strategy(self): return self.has_memcache_sharding_strategy_
 199
 200
 201   def MergeFrom(self, x):
 202     assert x is not self
 203     if (x.has_app_id()): self.set_app_id(x.app_id())
 204     if (x.has_num_memcacheg_backends()): self.set_num_memcacheg_backends(x.num_memcacheg_backends())
 205     if (x.has_ignore_shardlock()): self.set_ignore_shardlock(x.ignore_shardlock())
 206     if (x.has_memcache_pool_hint()): self.set_memcache_pool_hint(x.memcache_pool_hint())
 207     if (x.has_memcache_sharding_strategy()): self.set_memcache_sharding_strategy(x.memcache_sharding_strategy())
 208
 209   def Equals(self, x):
 210     if x is self: return 1
 211     if self.has_app_id_ != x.has_app_id_: return 0
 212     if self.has_app_id_ and self.app_id_ != x.app_id_: return 0
 213     if self.has_num_memcacheg_backends_ != x.has_num_memcacheg_backends_: return 0
 214     if self.has_num_memcacheg_backends_ and self.num_memcacheg_backends_ != x.num_memcacheg_backends_: return 0
 215     if self.has_ignore_shardlock_ != x.has_ignore_shardlock_: return 0
 216     if self.has_ignore_shardlock_ and self.ignore_shardlock_ != x.ignore_shardlock_: return 0
 217     if self.has_memcache_pool_hint_ != x.has_memcache_pool_hint_: return 0
 218     if self.has_memcache_pool_hint_ and self.memcache_pool_hint_ != x.memcache_pool_hint_: return 0
 219     if self.has_memcache_sharding_strategy_ != x.has_memcache_sharding_strategy_: return 0
 220     if self.has_memcache_sharding_strategy_ and self.memcache_sharding_strategy_ != x.memcache_sharding_strategy_: return 0
 221     return 1
 222
 223   def IsInitialized(self, debug_strs=None):
 224     initialized = 1
 225     if (not self.has_app_id_):
 226       initialized = 0
 227       if debug_strs is not None:
 228         debug_strs.append('Required field: app_id not set.')
 229     return initialized
 230
 231   def ByteSize(self):
 232     n = 0
 233     n += self.lengthString(len(self.app_id_))
 234     if (self.has_num_memcacheg_backends_): n += 1 + self.lengthVarInt64(self.num_memcacheg_backends_)
 235     if (self.has_ignore_shardlock_): n += 2
 236     if (self.has_memcache_pool_hint_): n += 1 + self.lengthString(len(self.memcache_pool_hint_))
 237     if (self.has_memcache_sharding_strategy_): n += 1 + self.lengthString(len(self.memcache_sharding_strategy_))
 238     return n + 1
 239
 240   def ByteSizePartial(self):
 241     n = 0
 242     if (self.has_app_id_):
 243       n += 1
 244       n += self.lengthString(len(self.app_id_))
 245     if (self.has_num_memcacheg_backends_): n += 1 + self.lengthVarInt64(self.num_memcacheg_backends_)
 246     if (self.has_ignore_shardlock_): n += 2
 247     if (self.has_memcache_pool_hint_): n += 1 + self.lengthString(len(self.memcache_pool_hint_))
 248     if (self.has_memcache_sharding_strategy_): n += 1 + self.lengthString(len(self.memcache_sharding_strategy_))
 249     return n
 250
 251   def Clear(self):
 252     self.clear_app_id()
 253     self.clear_num_memcacheg_backends()
 254     self.clear_ignore_shardlock()
 255     self.clear_memcache_pool_hint()
 256     self.clear_memcache_sharding_strategy()
 257
 258   def OutputUnchecked(self, out):
 259     out.putVarInt32(10)
 260     out.putPrefixedString(self.app_id_)
 261     if (self.has_num_memcacheg_backends_):
 262       out.putVarInt32(16)
 263       out.putVarInt32(self.num_memcacheg_backends_)
 264     if (self.has_ignore_shardlock_):
 265       out.putVarInt32(24)
 266       out.putBoolean(self.ignore_shardlock_)
 267     if (self.has_memcache_pool_hint_):
 268       out.putVarInt32(34)
 269       out.putPrefixedString(self.memcache_pool_hint_)
 270     if (self.has_memcache_sharding_strategy_):
 271       out.putVarInt32(42)
 272       out.putPrefixedString(self.memcache_sharding_strategy_)
 273
 274   def OutputPartial(self, out):
 275     if (self.has_app_id_):
 276       out.putVarInt32(10)
 277       out.putPrefixedString(self.app_id_)
 278     if (self.has_num_memcacheg_backends_):
 279       out.putVarInt32(16)
 280       out.putVarInt32(self.num_memcacheg_backends_)
 281     if (self.has_ignore_shardlock_):
 282       out.putVarInt32(24)
 283       out.putBoolean(self.ignore_shardlock_)
 284     if (self.has_memcache_pool_hint_):
 285       out.putVarInt32(34)
 286       out.putPrefixedString(self.memcache_pool_hint_)
 287     if (self.has_memcache_sharding_strategy_):
 288       out.putVarInt32(42)
 289       out.putPrefixedString(self.memcache_sharding_strategy_)
 290
 291   def TryMerge(self, d):
 292     while d.avail() > 0:
 293       tt = d.getVarInt32()
 294       if tt == 10:
 295         self.set_app_id(d.getPrefixedString())
 296         continue
 297       if tt == 16:
 298         self.set_num_memcacheg_backends(d.getVarInt32())
 299         continue
 300       if tt == 24:
 301         self.set_ignore_shardlock(d.getBoolean())
 302         continue
 303       if tt == 34:
 304         self.set_memcache_pool_hint(d.getPrefixedString())
 305         continue
 306       if tt == 42:
 307         self.set_memcache_sharding_strategy(d.getPrefixedString())
 308         continue
 309
 310
 311       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 312       d.skipData(tt)
 313
 314
 315   def __str__(self, prefix="", printElemNumber=0):
 316     res=""
 317     if self.has_app_id_: res+=prefix+("app_id: %s\n" % self.DebugFormatString(self.app_id_))
 318     if self.has_num_memcacheg_backends_: res+=prefix+("num_memcacheg_backends: %s\n" % self.DebugFormatInt32(self.num_memcacheg_backends_))
 319     if self.has_ignore_shardlock_: res+=prefix+("ignore_shardlock: %s\n" % self.DebugFormatBool(self.ignore_shardlock_))
 320     if self.has_memcache_pool_hint_: res+=prefix+("memcache_pool_hint: %s\n" % self.DebugFormatString(self.memcache_pool_hint_))
 321     if self.has_memcache_sharding_strategy_: res+=prefix+("memcache_sharding_strategy: %s\n" % self.DebugFormatString(self.memcache_sharding_strategy_))
 322     return res
 323
 324
 325   def _BuildTagLookupTable(sparse, maxtag, default=None):
 326     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
 327
 328   kapp_id = 1
 329   knum_memcacheg_backends = 2
 330   kignore_shardlock = 3
 331   kmemcache_pool_hint = 4
 332   kmemcache_sharding_strategy = 5
 333
 334   _TEXT = _BuildTagLookupTable({
 335     0: "ErrorCode",
 336     1: "app_id",
 337     2: "num_memcacheg_backends",
 338     3: "ignore_shardlock",
 339     4: "memcache_pool_hint",
 340     5: "memcache_sharding_strategy",
 341   }, 5)
 342
 343   _TYPES = _BuildTagLookupTable({
 344     0: ProtocolBuffer.Encoder.NUMERIC,
 345     1: ProtocolBuffer.Encoder.STRING,
 346     2: ProtocolBuffer.Encoder.NUMERIC,
 347     3: ProtocolBuffer.Encoder.NUMERIC,
 348     4: ProtocolBuffer.Encoder.STRING,
 349     5: ProtocolBuffer.Encoder.STRING,
 350   }, 5, ProtocolBuffer.Encoder.MAX_TYPE)
 351
 352
 353   _STYLE = """"""
 354   _STYLE_CONTENT_TYPE = """"""
 355   _PROTO_DESCRIPTOR_NAME = 'apphosting.AppOverride'
 356 class MemcacheGetRequest(ProtocolBuffer.ProtocolMessage):
 357   has_name_space_ = 0
 358   name_space_ = ""
 359   has_for_cas_ = 0
 360   for_cas_ = 0
 361   has_override_ = 0
 362   override_ = None
 363
 364   def __init__(self, contents=None):
 365     self.key_ = []
 366     self.lazy_init_lock_ = thread.allocate_lock()
 367     if contents is not None: self.MergeFromString(contents)
 368
 369   def key_size(self): return len(self.key_)
 370   def key_list(self): return self.key_
 371
 372   def key(self, i):
 373     return self.key_[i]
 374
 375   def set_key(self, i, x):
 376     self.key_[i] = x
 377
 378   def add_key(self, x):
 379     self.key_.append(x)
 380
 381   def clear_key(self):
 382     self.key_ = []
 383
 384   def name_space(self): return self.name_space_
 385
 386   def set_name_space(self, x):
 387     self.has_name_space_ = 1
 388     self.name_space_ = x
 389
 390   def clear_name_space(self):
 391     if self.has_name_space_:
 392       self.has_name_space_ = 0
 393       self.name_space_ = ""
 394
 395   def has_name_space(self): return self.has_name_space_
 396
 397   def for_cas(self): return self.for_cas_
 398
 399   def set_for_cas(self, x):
 400     self.has_for_cas_ = 1
 401     self.for_cas_ = x
 402
 403   def clear_for_cas(self):
 404     if self.has_for_cas_:
 405       self.has_for_cas_ = 0
 406       self.for_cas_ = 0
 407
 408   def has_for_cas(self): return self.has_for_cas_
 409
 410   def override(self):
 411     if self.override_ is None:
 412       self.lazy_init_lock_.acquire()
 413       try:
 414         if self.override_ is None: self.override_ = AppOverride()
 415       finally:
 416         self.lazy_init_lock_.release()
 417     return self.override_
 418
 419   def mutable_override(self): self.has_override_ = 1; return self.override()
 420
 421   def clear_override(self):
 422
 423     if self.has_override_:
 424       self.has_override_ = 0;
 425       if self.override_ is not None: self.override_.Clear()
 426
 427   def has_override(self): return self.has_override_
 428
 429
 430   def MergeFrom(self, x):
 431     assert x is not self
 432     for i in xrange(x.key_size()): self.add_key(x.key(i))
 433     if (x.has_name_space()): self.set_name_space(x.name_space())
 434     if (x.has_for_cas()): self.set_for_cas(x.for_cas())
 435     if (x.has_override()): self.mutable_override().MergeFrom(x.override())
 436
 437   def Equals(self, x):
 438     if x is self: return 1
 439     if len(self.key_) != len(x.key_): return 0
 440     for e1, e2 in zip(self.key_, x.key_):
 441       if e1 != e2: return 0
 442     if self.has_name_space_ != x.has_name_space_: return 0
 443     if self.has_name_space_ and self.name_space_ != x.name_space_: return 0
 444     if self.has_for_cas_ != x.has_for_cas_: return 0
 445     if self.has_for_cas_ and self.for_cas_ != x.for_cas_: return 0
 446     if self.has_override_ != x.has_override_: return 0
 447     if self.has_override_ and self.override_ != x.override_: return 0
 448     return 1
 449
 450   def IsInitialized(self, debug_strs=None):
 451     initialized = 1
 452     if (self.has_override_ and not self.override_.IsInitialized(debug_strs)): initialized = 0
 453     return initialized
 454
 455   def ByteSize(self):
 456     n = 0
 457     n += 1 * len(self.key_)
 458     for i in xrange(len(self.key_)): n += self.lengthString(len(self.key_[i]))
 459     if (self.has_name_space_): n += 1 + self.lengthString(len(self.name_space_))
 460     if (self.has_for_cas_): n += 2
 461     if (self.has_override_): n += 1 + self.lengthString(self.override_.ByteSize())
 462     return n
 463
 464   def ByteSizePartial(self):
 465     n = 0
 466     n += 1 * len(self.key_)
 467     for i in xrange(len(self.key_)): n += self.lengthString(len(self.key_[i]))
 468     if (self.has_name_space_): n += 1 + self.lengthString(len(self.name_space_))
 469     if (self.has_for_cas_): n += 2
 470     if (self.has_override_): n += 1 + self.lengthString(self.override_.ByteSizePartial())
 471     return n
 472
 473   def Clear(self):
 474     self.clear_key()
 475     self.clear_name_space()
 476     self.clear_for_cas()
 477     self.clear_override()
 478
 479   def OutputUnchecked(self, out):
 480     for i in xrange(len(self.key_)):
 481       out.putVarInt32(10)
 482       out.putPrefixedString(self.key_[i])
 483     if (self.has_name_space_):
 484       out.putVarInt32(18)
 485       out.putPrefixedString(self.name_space_)
 486     if (self.has_for_cas_):
 487       out.putVarInt32(32)
 488       out.putBoolean(self.for_cas_)
 489     if (self.has_override_):
 490       out.putVarInt32(42)
 491       out.putVarInt32(self.override_.ByteSize())
 492       self.override_.OutputUnchecked(out)
 493
 494   def OutputPartial(self, out):
 495     for i in xrange(len(self.key_)):
 496       out.putVarInt32(10)
 497       out.putPrefixedString(self.key_[i])
 498     if (self.has_name_space_):
 499       out.putVarInt32(18)
 500       out.putPrefixedString(self.name_space_)
 501     if (self.has_for_cas_):
 502       out.putVarInt32(32)
 503       out.putBoolean(self.for_cas_)
 504     if (self.has_override_):
 505       out.putVarInt32(42)
 506       out.putVarInt32(self.override_.ByteSizePartial())
 507       self.override_.OutputPartial(out)
 508
 509   def TryMerge(self, d):
 510     while d.avail() > 0:
 511       tt = d.getVarInt32()
 512       if tt == 10:
 513         self.add_key(d.getPrefixedString())
 514         continue
 515       if tt == 18:
 516         self.set_name_space(d.getPrefixedString())
 517         continue
 518       if tt == 32:
 519         self.set_for_cas(d.getBoolean())
 520         continue
 521       if tt == 42:
 522         length = d.getVarInt32()
 523         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
 524         d.skip(length)
 525         self.mutable_override().TryMerge(tmp)
 526         continue
 527
 528
 529       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 530       d.skipData(tt)
 531
 532
 533   def __str__(self, prefix="", printElemNumber=0):
 534     res=""
 535     cnt=0
 536     for e in self.key_:
 537       elm=""
 538       if printElemNumber: elm="(%d)" % cnt
 539       res+=prefix+("key%s: %s\n" % (elm, self.DebugFormatString(e)))
 540       cnt+=1
 541     if self.has_name_space_: res+=prefix+("name_space: %s\n" % self.DebugFormatString(self.name_space_))
 542     if self.has_for_cas_: res+=prefix+("for_cas: %s\n" % self.DebugFormatBool(self.for_cas_))
 543     if self.has_override_:
 544       res+=prefix+"override <\n"
 545       res+=self.override_.__str__(prefix + "  ", printElemNumber)
 546       res+=prefix+">\n"
 547     return res
 548
 549
 550   def _BuildTagLookupTable(sparse, maxtag, default=None):
 551     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
 552
 553   kkey = 1
 554   kname_space = 2
 555   kfor_cas = 4
 556   koverride = 5
 557
 558   _TEXT = _BuildTagLookupTable({
 559     0: "ErrorCode",
 560     1: "key",
 561     2: "name_space",
 562     4: "for_cas",
 563     5: "override",
 564   }, 5)
 565
 566   _TYPES = _BuildTagLookupTable({
 567     0: ProtocolBuffer.Encoder.NUMERIC,
 568     1: ProtocolBuffer.Encoder.STRING,
 569     2: ProtocolBuffer.Encoder.STRING,
 570     4: ProtocolBuffer.Encoder.NUMERIC,
 571     5: ProtocolBuffer.Encoder.STRING,
 572   }, 5, ProtocolBuffer.Encoder.MAX_TYPE)
 573
 574
 575   _STYLE = """"""
 576   _STYLE_CONTENT_TYPE = """"""
 577   _PROTO_DESCRIPTOR_NAME = 'apphosting.MemcacheGetRequest'
 578 class MemcacheGetResponse_Item(ProtocolBuffer.ProtocolMessage):
 579   has_key_ = 0
 580   key_ = ""
 581   has_value_ = 0
 582   value_ = ""
 583   has_flags_ = 0
 584   flags_ = 0
 585   has_cas_id_ = 0
 586   cas_id_ = 0
 587   has_expires_in_seconds_ = 0
 588   expires_in_seconds_ = 0
 589
 590   def __init__(self, contents=None):
 591     if contents is not None: self.MergeFromString(contents)
 592
 593   def key(self): return self.key_
 594
 595   def set_key(self, x):
 596     self.has_key_ = 1
 597     self.key_ = x
 598
 599   def clear_key(self):
 600     if self.has_key_:
 601       self.has_key_ = 0
 602       self.key_ = ""
 603
 604   def has_key(self): return self.has_key_
 605
 606   def value(self): return self.value_
 607
 608   def set_value(self, x):
 609     self.has_value_ = 1
 610     self.value_ = x
 611
 612   def clear_value(self):
 613     if self.has_value_:
 614       self.has_value_ = 0
 615       self.value_ = ""
 616
 617   def has_value(self): return self.has_value_
 618
 619   def flags(self): return self.flags_
 620
 621   def set_flags(self, x):
 622     self.has_flags_ = 1
 623     self.flags_ = x
 624
 625   def clear_flags(self):
 626     if self.has_flags_:
 627       self.has_flags_ = 0
 628       self.flags_ = 0
 629
 630   def has_flags(self): return self.has_flags_
 631
 632   def cas_id(self): return self.cas_id_
 633
 634   def set_cas_id(self, x):
 635     self.has_cas_id_ = 1
 636     self.cas_id_ = x
 637
 638   def clear_cas_id(self):
 639     if self.has_cas_id_:
 640       self.has_cas_id_ = 0
 641       self.cas_id_ = 0
 642
 643   def has_cas_id(self): return self.has_cas_id_
 644
 645   def expires_in_seconds(self): return self.expires_in_seconds_
 646
 647   def set_expires_in_seconds(self, x):
 648     self.has_expires_in_seconds_ = 1
 649     self.expires_in_seconds_ = x
 650
 651   def clear_expires_in_seconds(self):
 652     if self.has_expires_in_seconds_:
 653       self.has_expires_in_seconds_ = 0
 654       self.expires_in_seconds_ = 0
 655
 656   def has_expires_in_seconds(self): return self.has_expires_in_seconds_
 657
 658
 659   def MergeFrom(self, x):
 660     assert x is not self
 661     if (x.has_key()): self.set_key(x.key())
 662     if (x.has_value()): self.set_value(x.value())
 663     if (x.has_flags()): self.set_flags(x.flags())
 664     if (x.has_cas_id()): self.set_cas_id(x.cas_id())
 665     if (x.has_expires_in_seconds()): self.set_expires_in_seconds(x.expires_in_seconds())
 666
 667   def Equals(self, x):
 668     if x is self: return 1
 669     if self.has_key_ != x.has_key_: return 0
 670     if self.has_key_ and self.key_ != x.key_: return 0
 671     if self.has_value_ != x.has_value_: return 0
 672     if self.has_value_ and self.value_ != x.value_: return 0
 673     if self.has_flags_ != x.has_flags_: return 0
 674     if self.has_flags_ and self.flags_ != x.flags_: return 0
 675     if self.has_cas_id_ != x.has_cas_id_: return 0
 676     if self.has_cas_id_ and self.cas_id_ != x.cas_id_: return 0
 677     if self.has_expires_in_seconds_ != x.has_expires_in_seconds_: return 0
 678     if self.has_expires_in_seconds_ and self.expires_in_seconds_ != x.expires_in_seconds_: return 0
 679     return 1
 680
 681   def IsInitialized(self, debug_strs=None):
 682     initialized = 1
 683     if (not self.has_key_):
 684       initialized = 0
 685       if debug_strs is not None:
 686         debug_strs.append('Required field: key not set.')
 687     if (not self.has_value_):
 688       initialized = 0
 689       if debug_strs is not None:
 690         debug_strs.append('Required field: value not set.')
 691     return initialized
 692
 693   def ByteSize(self):
 694     n = 0
 695     n += self.lengthString(len(self.key_))
 696     n += self.lengthString(len(self.value_))
 697     if (self.has_flags_): n += 5
 698     if (self.has_cas_id_): n += 9
 699     if (self.has_expires_in_seconds_): n += 1 + self.lengthVarInt64(self.expires_in_seconds_)
 700     return n + 2
 701
 702   def ByteSizePartial(self):
 703     n = 0
 704     if (self.has_key_):
 705       n += 1
 706       n += self.lengthString(len(self.key_))
 707     if (self.has_value_):
 708       n += 1
 709       n += self.lengthString(len(self.value_))
 710     if (self.has_flags_): n += 5
 711     if (self.has_cas_id_): n += 9
 712     if (self.has_expires_in_seconds_): n += 1 + self.lengthVarInt64(self.expires_in_seconds_)
 713     return n
 714
 715   def Clear(self):
 716     self.clear_key()
 717     self.clear_value()
 718     self.clear_flags()
 719     self.clear_cas_id()
 720     self.clear_expires_in_seconds()
 721
 722   def OutputUnchecked(self, out):
 723     out.putVarInt32(18)
 724     out.putPrefixedString(self.key_)
 725     out.putVarInt32(26)
 726     out.putPrefixedString(self.value_)
 727     if (self.has_flags_):
 728       out.putVarInt32(37)
 729       out.put32(self.flags_)
 730     if (self.has_cas_id_):
 731       out.putVarInt32(41)
 732       out.put64(self.cas_id_)
 733     if (self.has_expires_in_seconds_):
 734       out.putVarInt32(48)
 735       out.putVarInt32(self.expires_in_seconds_)
 736
 737   def OutputPartial(self, out):
 738     if (self.has_key_):
 739       out.putVarInt32(18)
 740       out.putPrefixedString(self.key_)
 741     if (self.has_value_):
 742       out.putVarInt32(26)
 743       out.putPrefixedString(self.value_)
 744     if (self.has_flags_):
 745       out.putVarInt32(37)
 746       out.put32(self.flags_)
 747     if (self.has_cas_id_):
 748       out.putVarInt32(41)
 749       out.put64(self.cas_id_)
 750     if (self.has_expires_in_seconds_):
 751       out.putVarInt32(48)
 752       out.putVarInt32(self.expires_in_seconds_)
 753
 754   def TryMerge(self, d):
 755     while 1:
 756       tt = d.getVarInt32()
 757       if tt == 12: break
 758       if tt == 18:
 759         self.set_key(d.getPrefixedString())
 760         continue
 761       if tt == 26:
 762         self.set_value(d.getPrefixedString())
 763         continue
 764       if tt == 37:
 765         self.set_flags(d.get32())
 766         continue
 767       if tt == 41:
 768         self.set_cas_id(d.get64())
 769         continue
 770       if tt == 48:
 771         self.set_expires_in_seconds(d.getVarInt32())
 772         continue
 773
 774
 775       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 776       d.skipData(tt)
 777
 778
 779   def __str__(self, prefix="", printElemNumber=0):
 780     res=""
 781     if self.has_key_: res+=prefix+("key: %s\n" % self.DebugFormatString(self.key_))
 782     if self.has_value_: res+=prefix+("value: %s\n" % self.DebugFormatString(self.value_))
 783     if self.has_flags_: res+=prefix+("flags: %s\n" % self.DebugFormatFixed32(self.flags_))
 784     if self.has_cas_id_: res+=prefix+("cas_id: %s\n" % self.DebugFormatFixed64(self.cas_id_))
 785     if self.has_expires_in_seconds_: res+=prefix+("expires_in_seconds: %s\n" % self.DebugFormatInt32(self.expires_in_seconds_))
 786     return res
 787
 788 class MemcacheGetResponse(ProtocolBuffer.ProtocolMessage):
 789
 790   def __init__(self, contents=None):
 791     self.item_ = []
 792     if contents is not None: self.MergeFromString(contents)
 793
 794   def item_size(self): return len(self.item_)
 795   def item_list(self): return self.item_
 796
 797   def item(self, i):
 798     return self.item_[i]
 799
 800   def mutable_item(self, i):
 801     return self.item_[i]
 802
 803   def add_item(self):
 804     x = MemcacheGetResponse_Item()
 805     self.item_.append(x)
 806     return x
 807
 808   def clear_item(self):
 809     self.item_ = []
 810
 811   def MergeFrom(self, x):
 812     assert x is not self
 813     for i in xrange(x.item_size()): self.add_item().CopyFrom(x.item(i))
 814
 815   def Equals(self, x):
 816     if x is self: return 1
 817     if len(self.item_) != len(x.item_): return 0
 818     for e1, e2 in zip(self.item_, x.item_):
 819       if e1 != e2: return 0
 820     return 1
 821
 822   def IsInitialized(self, debug_strs=None):
 823     initialized = 1
 824     for p in self.item_:
 825       if not p.IsInitialized(debug_strs): initialized=0
 826     return initialized
 827
 828   def ByteSize(self):
 829     n = 0
 830     n += 2 * len(self.item_)
 831     for i in xrange(len(self.item_)): n += self.item_[i].ByteSize()
 832     return n
 833
 834   def ByteSizePartial(self):
 835     n = 0
 836     n += 2 * len(self.item_)
 837     for i in xrange(len(self.item_)): n += self.item_[i].ByteSizePartial()
 838     return n
 839
 840   def Clear(self):
 841     self.clear_item()
 842
 843   def OutputUnchecked(self, out):
 844     for i in xrange(len(self.item_)):
 845       out.putVarInt32(11)
 846       self.item_[i].OutputUnchecked(out)
 847       out.putVarInt32(12)
 848
 849   def OutputPartial(self, out):
 850     for i in xrange(len(self.item_)):
 851       out.putVarInt32(11)
 852       self.item_[i].OutputPartial(out)
 853       out.putVarInt32(12)
 854
 855   def TryMerge(self, d):
 856     while d.avail() > 0:
 857       tt = d.getVarInt32()
 858       if tt == 11:
 859         self.add_item().TryMerge(d)
 860         continue
 861
 862
 863       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 864       d.skipData(tt)
 865
 866
 867   def __str__(self, prefix="", printElemNumber=0):
 868     res=""
 869     cnt=0
 870     for e in self.item_:
 871       elm=""
 872       if printElemNumber: elm="(%d)" % cnt
 873       res+=prefix+("Item%s {\n" % elm)
 874       res+=e.__str__(prefix + "  ", printElemNumber)
 875       res+=prefix+"}\n"
 876       cnt+=1
 877     return res
 878
 879
 880   def _BuildTagLookupTable(sparse, maxtag, default=None):
 881     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
 882
 883   kItemGroup = 1
 884   kItemkey = 2
 885   kItemvalue = 3
 886   kItemflags = 4
 887   kItemcas_id = 5
 888   kItemexpires_in_seconds = 6
 889
 890   _TEXT = _BuildTagLookupTable({
 891     0: "ErrorCode",
 892     1: "Item",
 893     2: "key",
 894     3: "value",
 895     4: "flags",
 896     5: "cas_id",
 897     6: "expires_in_seconds",
 898   }, 6)
 899
 900   _TYPES = _BuildTagLookupTable({
 901     0: ProtocolBuffer.Encoder.NUMERIC,
 902     1: ProtocolBuffer.Encoder.STARTGROUP,
 903     2: ProtocolBuffer.Encoder.STRING,
 904     3: ProtocolBuffer.Encoder.STRING,
 905     4: ProtocolBuffer.Encoder.FLOAT,
 906     5: ProtocolBuffer.Encoder.DOUBLE,
 907     6: ProtocolBuffer.Encoder.NUMERIC,
 908   }, 6, ProtocolBuffer.Encoder.MAX_TYPE)
 909
 910
 911   _STYLE = """"""
 912   _STYLE_CONTENT_TYPE = """"""
 913   _PROTO_DESCRIPTOR_NAME = 'apphosting.MemcacheGetResponse'
 914 class MemcacheSetRequest_Item(ProtocolBuffer.ProtocolMessage):
 915   has_key_ = 0
 916   key_ = ""
 917   has_value_ = 0
 918   value_ = ""
 919   has_flags_ = 0
 920   flags_ = 0
 921   has_set_policy_ = 0
 922   set_policy_ = 1
 923   has_expiration_time_ = 0
 924   expiration_time_ = 0
 925   has_cas_id_ = 0
 926   cas_id_ = 0
 927   has_for_cas_ = 0
 928   for_cas_ = 0
 929
 930   def __init__(self, contents=None):
 931     if contents is not None: self.MergeFromString(contents)
 932
 933   def key(self): return self.key_
 934
 935   def set_key(self, x):
 936     self.has_key_ = 1
 937     self.key_ = x
 938
 939   def clear_key(self):
 940     if self.has_key_:
 941       self.has_key_ = 0
 942       self.key_ = ""
 943
 944   def has_key(self): return self.has_key_
 945
 946   def value(self): return self.value_
 947
 948   def set_value(self, x):
 949     self.has_value_ = 1
 950     self.value_ = x
 951
 952   def clear_value(self):
 953     if self.has_value_:
 954       self.has_value_ = 0
 955       self.value_ = ""
 956
 957   def has_value(self): return self.has_value_
 958
 959   def flags(self): return self.flags_
 960
 961   def set_flags(self, x):
 962     self.has_flags_ = 1
 963     self.flags_ = x
 964
 965   def clear_flags(self):
 966     if self.has_flags_:
 967       self.has_flags_ = 0
 968       self.flags_ = 0
 969
 970   def has_flags(self): return self.has_flags_
 971
 972   def set_policy(self): return self.set_policy_
 973
 974   def set_set_policy(self, x):
 975     self.has_set_policy_ = 1
 976     self.set_policy_ = x
 977
 978   def clear_set_policy(self):
 979     if self.has_set_policy_:
 980       self.has_set_policy_ = 0
 981       self.set_policy_ = 1
 982
 983   def has_set_policy(self): return self.has_set_policy_
 984
 985   def expiration_time(self): return self.expiration_time_
 986
 987   def set_expiration_time(self, x):
 988     self.has_expiration_time_ = 1
 989     self.expiration_time_ = x
 990
 991   def clear_expiration_time(self):
 992     if self.has_expiration_time_:
 993       self.has_expiration_time_ = 0
 994       self.expiration_time_ = 0
 995
 996   def has_expiration_time(self): return self.has_expiration_time_
 997
 998   def cas_id(self): return self.cas_id_
 999
1000   def set_cas_id(self, x):
1001     self.has_cas_id_ = 1
1002     self.cas_id_ = x
1003
1004   def clear_cas_id(self):
1005     if self.has_cas_id_:
1006       self.has_cas_id_ = 0
1007       self.cas_id_ = 0
1008
1009   def has_cas_id(self): return self.has_cas_id_
1010
1011   def for_cas(self): return self.for_cas_
1012
1013   def set_for_cas(self, x):
1014     self.has_for_cas_ = 1
1015     self.for_cas_ = x
1016
1017   def clear_for_cas(self):
1018     if self.has_for_cas_:
1019       self.has_for_cas_ = 0
1020       self.for_cas_ = 0
1021
1022   def has_for_cas(self): return self.has_for_cas_
1023
1024
1025   def MergeFrom(self, x):
1026     assert x is not self
1027     if (x.has_key()): self.set_key(x.key())
1028     if (x.has_value()): self.set_value(x.value())
1029     if (x.has_flags()): self.set_flags(x.flags())
1030     if (x.has_set_policy()): self.set_set_policy(x.set_policy())
1031     if (x.has_expiration_time()): self.set_expiration_time(x.expiration_time())
1032     if (x.has_cas_id()): self.set_cas_id(x.cas_id())
1033     if (x.has_for_cas()): self.set_for_cas(x.for_cas())
1034
1035   def Equals(self, x):
1036     if x is self: return 1
1037     if self.has_key_ != x.has_key_: return 0
1038     if self.has_key_ and self.key_ != x.key_: return 0
1039     if self.has_value_ != x.has_value_: return 0
1040     if self.has_value_ and self.value_ != x.value_: return 0
1041     if self.has_flags_ != x.has_flags_: return 0
1042     if self.has_flags_ and self.flags_ != x.flags_: return 0
1043     if self.has_set_policy_ != x.has_set_policy_: return 0
1044     if self.has_set_policy_ and self.set_policy_ != x.set_policy_: return 0
1045     if self.has_expiration_time_ != x.has_expiration_time_: return 0
1046     if self.has_expiration_time_ and self.expiration_time_ != x.expiration_time_: return 0
1047     if self.has_cas_id_ != x.has_cas_id_: return 0
1048     if self.has_cas_id_ and self.cas_id_ != x.cas_id_: return 0
1049     if self.has_for_cas_ != x.has_for_cas_: return 0
1050     if self.has_for_cas_ and self.for_cas_ != x.for_cas_: return 0
1051     return 1
1052
1053   def IsInitialized(self, debug_strs=None):
1054     initialized = 1
1055     if (not self.has_key_):
1056       initialized = 0
1057       if debug_strs is not None:
1058         debug_strs.append('Required field: key not set.')
1059     if (not self.has_value_):
1060       initialized = 0
1061       if debug_strs is not None:
1062         debug_strs.append('Required field: value not set.')
1063     return initialized
1064
1065   def ByteSize(self):
1066     n = 0
1067     n += self.lengthString(len(self.key_))
1068     n += self.lengthString(len(self.value_))
1069     if (self.has_flags_): n += 5
1070     if (self.has_set_policy_): n += 1 + self.lengthVarInt64(self.set_policy_)
1071     if (self.has_expiration_time_): n += 5
1072     if (self.has_cas_id_): n += 9
1073     if (self.has_for_cas_): n += 2
1074     return n + 2
1075
1076   def ByteSizePartial(self):
1077     n = 0
1078     if (self.has_key_):
1079       n += 1
1080       n += self.lengthString(len(self.key_))
1081     if (self.has_value_):
1082       n += 1
1083       n += self.lengthString(len(self.value_))
1084     if (self.has_flags_): n += 5
1085     if (self.has_set_policy_): n += 1 + self.lengthVarInt64(self.set_policy_)
1086     if (self.has_expiration_time_): n += 5
1087     if (self.has_cas_id_): n += 9
1088     if (self.has_for_cas_): n += 2
1089     return n
1090
1091   def Clear(self):
1092     self.clear_key()
1093     self.clear_value()
1094     self.clear_flags()
1095     self.clear_set_policy()
1096     self.clear_expiration_time()
1097     self.clear_cas_id()
1098     self.clear_for_cas()
1099
1100   def OutputUnchecked(self, out):
1101     out.putVarInt32(18)
1102     out.putPrefixedString(self.key_)
1103     out.putVarInt32(26)
1104     out.putPrefixedString(self.value_)
1105     if (self.has_flags_):
1106       out.putVarInt32(37)
1107       out.put32(self.flags_)
1108     if (self.has_set_policy_):
1109       out.putVarInt32(40)
1110       out.putVarInt32(self.set_policy_)
1111     if (self.has_expiration_time_):
1112       out.putVarInt32(53)
1113       out.put32(self.expiration_time_)
1114     if (self.has_cas_id_):
1115       out.putVarInt32(65)
1116       out.put64(self.cas_id_)
1117     if (self.has_for_cas_):
1118       out.putVarInt32(72)
1119       out.putBoolean(self.for_cas_)
1120
1121   def OutputPartial(self, out):
1122     if (self.has_key_):
1123       out.putVarInt32(18)
1124       out.putPrefixedString(self.key_)
1125     if (self.has_value_):
1126       out.putVarInt32(26)
1127       out.putPrefixedString(self.value_)
1128     if (self.has_flags_):
1129       out.putVarInt32(37)
1130       out.put32(self.flags_)
1131     if (self.has_set_policy_):
1132       out.putVarInt32(40)
1133       out.putVarInt32(self.set_policy_)
1134     if (self.has_expiration_time_):
1135       out.putVarInt32(53)
1136       out.put32(self.expiration_time_)
1137     if (self.has_cas_id_):
1138       out.putVarInt32(65)
1139       out.put64(self.cas_id_)
1140     if (self.has_for_cas_):
1141       out.putVarInt32(72)
1142       out.putBoolean(self.for_cas_)
1143
1144   def TryMerge(self, d):
1145     while 1:
1146       tt = d.getVarInt32()
1147       if tt == 12: break
1148       if tt == 18:
1149         self.set_key(d.getPrefixedString())
1150         continue
1151       if tt == 26:
1152         self.set_value(d.getPrefixedString())
1153         continue
1154       if tt == 37:
1155         self.set_flags(d.get32())
1156         continue
1157       if tt == 40:
1158         self.set_set_policy(d.getVarInt32())
1159         continue
1160       if tt == 53:
1161         self.set_expiration_time(d.get32())
1162         continue
1163       if tt == 65:
1164         self.set_cas_id(d.get64())
1165         continue
1166       if tt == 72:
1167         self.set_for_cas(d.getBoolean())
1168         continue
1169
1170
1171       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1172       d.skipData(tt)
1173
1174
1175   def __str__(self, prefix="", printElemNumber=0):
1176     res=""
1177     if self.has_key_: res+=prefix+("key: %s\n" % self.DebugFormatString(self.key_))
1178     if self.has_value_: res+=prefix+("value: %s\n" % self.DebugFormatString(self.value_))
1179     if self.has_flags_: res+=prefix+("flags: %s\n" % self.DebugFormatFixed32(self.flags_))
1180     if self.has_set_policy_: res+=prefix+("set_policy: %s\n" % self.DebugFormatInt32(self.set_policy_))
1181     if self.has_expiration_time_: res+=prefix+("expiration_time: %s\n" % self.DebugFormatFixed32(self.expiration_time_))
1182     if self.has_cas_id_: res+=prefix+("cas_id: %s\n" % self.DebugFormatFixed64(self.cas_id_))
1183     if self.has_for_cas_: res+=prefix+("for_cas: %s\n" % self.DebugFormatBool(self.for_cas_))
1184     return res
1185
1186 class MemcacheSetRequest(ProtocolBuffer.ProtocolMessage):
1187
1188
1189   SET          =    1
1190   ADD          =    2
1191   REPLACE      =    3
1192   CAS          =    4
1193
1194   _SetPolicy_NAMES = {
1195     1: "SET",
1196     2: "ADD",
1197     3: "REPLACE",
1198     4: "CAS",
1199   }
1200
1201   def SetPolicy_Name(cls, x): return cls._SetPolicy_NAMES.get(x, "")
1202   SetPolicy_Name = classmethod(SetPolicy_Name)
1203
1204   has_name_space_ = 0
1205   name_space_ = ""
1206   has_override_ = 0
1207   override_ = None
1208
1209   def __init__(self, contents=None):
1210     self.item_ = []
1211     self.lazy_init_lock_ = thread.allocate_lock()
1212     if contents is not None: self.MergeFromString(contents)
1213
1214   def item_size(self): return len(self.item_)
1215   def item_list(self): return self.item_
1216
1217   def item(self, i):
1218     return self.item_[i]
1219
1220   def mutable_item(self, i):
1221     return self.item_[i]
1222
1223   def add_item(self):
1224     x = MemcacheSetRequest_Item()
1225     self.item_.append(x)
1226     return x
1227
1228   def clear_item(self):
1229     self.item_ = []
1230   def name_space(self): return self.name_space_
1231
1232   def set_name_space(self, x):
1233     self.has_name_space_ = 1
1234     self.name_space_ = x
1235
1236   def clear_name_space(self):
1237     if self.has_name_space_:
1238       self.has_name_space_ = 0
1239       self.name_space_ = ""
1240
1241   def has_name_space(self): return self.has_name_space_
1242
1243   def override(self):
1244     if self.override_ is None:
1245       self.lazy_init_lock_.acquire()
1246       try:
1247         if self.override_ is None: self.override_ = AppOverride()
1248       finally:
1249         self.lazy_init_lock_.release()
1250     return self.override_
1251
1252   def mutable_override(self): self.has_override_ = 1; return self.override()
1253
1254   def clear_override(self):
1255
1256     if self.has_override_:
1257       self.has_override_ = 0;
1258       if self.override_ is not None: self.override_.Clear()
1259
1260   def has_override(self): return self.has_override_
1261
1262
1263   def MergeFrom(self, x):
1264     assert x is not self
1265     for i in xrange(x.item_size()): self.add_item().CopyFrom(x.item(i))
1266     if (x.has_name_space()): self.set_name_space(x.name_space())
1267     if (x.has_override()): self.mutable_override().MergeFrom(x.override())
1268
1269   def Equals(self, x):
1270     if x is self: return 1
1271     if len(self.item_) != len(x.item_): return 0
1272     for e1, e2 in zip(self.item_, x.item_):
1273       if e1 != e2: return 0
1274     if self.has_name_space_ != x.has_name_space_: return 0
1275     if self.has_name_space_ and self.name_space_ != x.name_space_: return 0
1276     if self.has_override_ != x.has_override_: return 0
1277     if self.has_override_ and self.override_ != x.override_: return 0
1278     return 1
1279
1280   def IsInitialized(self, debug_strs=None):
1281     initialized = 1
1282     for p in self.item_:
1283       if not p.IsInitialized(debug_strs): initialized=0
1284     if (self.has_override_ and not self.override_.IsInitialized(debug_strs)): initialized = 0
1285     return initialized
1286
1287   def ByteSize(self):
1288     n = 0
1289     n += 2 * len(self.item_)
1290     for i in xrange(len(self.item_)): n += self.item_[i].ByteSize()
1291     if (self.has_name_space_): n += 1 + self.lengthString(len(self.name_space_))
1292     if (self.has_override_): n += 1 + self.lengthString(self.override_.ByteSize())
1293     return n
1294
1295   def ByteSizePartial(self):
1296     n = 0
1297     n += 2 * len(self.item_)
1298     for i in xrange(len(self.item_)): n += self.item_[i].ByteSizePartial()
1299     if (self.has_name_space_): n += 1 + self.lengthString(len(self.name_space_))
1300     if (self.has_override_): n += 1 + self.lengthString(self.override_.ByteSizePartial())
1301     return n
1302
1303   def Clear(self):
1304     self.clear_item()
1305     self.clear_name_space()
1306     self.clear_override()
1307
1308   def OutputUnchecked(self, out):
1309     for i in xrange(len(self.item_)):
1310       out.putVarInt32(11)
1311       self.item_[i].OutputUnchecked(out)
1312       out.putVarInt32(12)
1313     if (self.has_name_space_):
1314       out.putVarInt32(58)
1315       out.putPrefixedString(self.name_space_)
1316     if (self.has_override_):
1317       out.putVarInt32(82)
1318       out.putVarInt32(self.override_.ByteSize())
1319       self.override_.OutputUnchecked(out)
1320
1321   def OutputPartial(self, out):
1322     for i in xrange(len(self.item_)):
1323       out.putVarInt32(11)
1324       self.item_[i].OutputPartial(out)
1325       out.putVarInt32(12)
1326     if (self.has_name_space_):
1327       out.putVarInt32(58)
1328       out.putPrefixedString(self.name_space_)
1329     if (self.has_override_):
1330       out.putVarInt32(82)
1331       out.putVarInt32(self.override_.ByteSizePartial())
1332       self.override_.OutputPartial(out)
1333
1334   def TryMerge(self, d):
1335     while d.avail() > 0:
1336       tt = d.getVarInt32()
1337       if tt == 11:
1338         self.add_item().TryMerge(d)
1339         continue
1340       if tt == 58:
1341         self.set_name_space(d.getPrefixedString())
1342         continue
1343       if tt == 82:
1344         length = d.getVarInt32()
1345         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
1346         d.skip(length)
1347         self.mutable_override().TryMerge(tmp)
1348         continue
1349
1350
1351       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1352       d.skipData(tt)
1353
1354
1355   def __str__(self, prefix="", printElemNumber=0):
1356     res=""
1357     cnt=0
1358     for e in self.item_:
1359       elm=""
1360       if printElemNumber: elm="(%d)" % cnt
1361       res+=prefix+("Item%s {\n" % elm)
1362       res+=e.__str__(prefix + "  ", printElemNumber)
1363       res+=prefix+"}\n"
1364       cnt+=1
1365     if self.has_name_space_: res+=prefix+("name_space: %s\n" % self.DebugFormatString(self.name_space_))
1366     if self.has_override_:
1367       res+=prefix+"override <\n"
1368       res+=self.override_.__str__(prefix + "  ", printElemNumber)
1369       res+=prefix+">\n"
1370     return res
1371
1372
1373   def _BuildTagLookupTable(sparse, maxtag, default=None):
1374     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
1375
1376   kItemGroup = 1
1377   kItemkey = 2
1378   kItemvalue = 3
1379   kItemflags = 4
1380   kItemset_policy = 5
1381   kItemexpiration_time = 6
1382   kItemcas_id = 8
1383   kItemfor_cas = 9
1384   kname_space = 7
1385   koverride = 10
1386
1387   _TEXT = _BuildTagLookupTable({
1388     0: "ErrorCode",
1389     1: "Item",
1390     2: "key",
1391     3: "value",
1392     4: "flags",
1393     5: "set_policy",
1394     6: "expiration_time",
1395     7: "name_space",
1396     8: "cas_id",
1397     9: "for_cas",
1398     10: "override",
1399   }, 10)
1400
1401   _TYPES = _BuildTagLookupTable({
1402     0: ProtocolBuffer.Encoder.NUMERIC,
1403     1: ProtocolBuffer.Encoder.STARTGROUP,
1404     2: ProtocolBuffer.Encoder.STRING,
1405     3: ProtocolBuffer.Encoder.STRING,
1406     4: ProtocolBuffer.Encoder.FLOAT,
1407     5: ProtocolBuffer.Encoder.NUMERIC,
1408     6: ProtocolBuffer.Encoder.FLOAT,
1409     7: ProtocolBuffer.Encoder.STRING,
1410     8: ProtocolBuffer.Encoder.DOUBLE,
1411     9: ProtocolBuffer.Encoder.NUMERIC,
1412     10: ProtocolBuffer.Encoder.STRING,
1413   }, 10, ProtocolBuffer.Encoder.MAX_TYPE)
1414
1415
1416   _STYLE = """"""
1417   _STYLE_CONTENT_TYPE = """"""
1418   _PROTO_DESCRIPTOR_NAME = 'apphosting.MemcacheSetRequest'
1419 class MemcacheSetResponse(ProtocolBuffer.ProtocolMessage):
1420
1421
1422   STORED       =    1
1423   NOT_STORED   =    2
1424   ERROR        =    3
1425   EXISTS       =    4
1426
1427   _SetStatusCode_NAMES = {
1428     1: "STORED",
1429     2: "NOT_STORED",
1430     3: "ERROR",
1431     4: "EXISTS",
1432   }
1433
1434   def SetStatusCode_Name(cls, x): return cls._SetStatusCode_NAMES.get(x, "")
1435   SetStatusCode_Name = classmethod(SetStatusCode_Name)
1436
1437
1438   def __init__(self, contents=None):
1439     self.set_status_ = []
1440     if contents is not None: self.MergeFromString(contents)
1441
1442   def set_status_size(self): return len(self.set_status_)
1443   def set_status_list(self): return self.set_status_
1444
1445   def set_status(self, i):
1446     return self.set_status_[i]
1447
1448   def set_set_status(self, i, x):
1449     self.set_status_[i] = x
1450
1451   def add_set_status(self, x):
1452     self.set_status_.append(x)
1453
1454   def clear_set_status(self):
1455     self.set_status_ = []
1456
1457
1458   def MergeFrom(self, x):
1459     assert x is not self
1460     for i in xrange(x.set_status_size()): self.add_set_status(x.set_status(i))
1461
1462   def Equals(self, x):
1463     if x is self: return 1
1464     if len(self.set_status_) != len(x.set_status_): return 0
1465     for e1, e2 in zip(self.set_status_, x.set_status_):
1466       if e1 != e2: return 0
1467     return 1
1468
1469   def IsInitialized(self, debug_strs=None):
1470     initialized = 1
1471     return initialized
1472
1473   def ByteSize(self):
1474     n = 0
1475     n += 1 * len(self.set_status_)
1476     for i in xrange(len(self.set_status_)): n += self.lengthVarInt64(self.set_status_[i])
1477     return n
1478
1479   def ByteSizePartial(self):
1480     n = 0
1481     n += 1 * len(self.set_status_)
1482     for i in xrange(len(self.set_status_)): n += self.lengthVarInt64(self.set_status_[i])
1483     return n
1484
1485   def Clear(self):
1486     self.clear_set_status()
1487
1488   def OutputUnchecked(self, out):
1489     for i in xrange(len(self.set_status_)):
1490       out.putVarInt32(8)
1491       out.putVarInt32(self.set_status_[i])
1492
1493   def OutputPartial(self, out):
1494     for i in xrange(len(self.set_status_)):
1495       out.putVarInt32(8)
1496       out.putVarInt32(self.set_status_[i])
1497
1498   def TryMerge(self, d):
1499     while d.avail() > 0:
1500       tt = d.getVarInt32()
1501       if tt == 8:
1502         self.add_set_status(d.getVarInt32())
1503         continue
1504
1505
1506       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1507       d.skipData(tt)
1508
1509
1510   def __str__(self, prefix="", printElemNumber=0):
1511     res=""
1512     cnt=0
1513     for e in self.set_status_:
1514       elm=""
1515       if printElemNumber: elm="(%d)" % cnt
1516       res+=prefix+("set_status%s: %s\n" % (elm, self.DebugFormatInt32(e)))
1517       cnt+=1
1518     return res
1519
1520
1521   def _BuildTagLookupTable(sparse, maxtag, default=None):
1522     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
1523
1524   kset_status = 1
1525
1526   _TEXT = _BuildTagLookupTable({
1527     0: "ErrorCode",
1528     1: "set_status",
1529   }, 1)
1530
1531   _TYPES = _BuildTagLookupTable({
1532     0: ProtocolBuffer.Encoder.NUMERIC,
1533     1: ProtocolBuffer.Encoder.NUMERIC,
1534   }, 1, ProtocolBuffer.Encoder.MAX_TYPE)
1535
1536
1537   _STYLE = """"""
1538   _STYLE_CONTENT_TYPE = """"""
1539   _PROTO_DESCRIPTOR_NAME = 'apphosting.MemcacheSetResponse'
1540 class MemcacheDeleteRequest_Item(ProtocolBuffer.ProtocolMessage):
1541   has_key_ = 0
1542   key_ = ""
1543   has_delete_time_ = 0
1544   delete_time_ = 0
1545
1546   def __init__(self, contents=None):
1547     if contents is not None: self.MergeFromString(contents)
1548
1549   def key(self): return self.key_
1550
1551   def set_key(self, x):
1552     self.has_key_ = 1
1553     self.key_ = x
1554
1555   def clear_key(self):
1556     if self.has_key_:
1557       self.has_key_ = 0
1558       self.key_ = ""
1559
1560   def has_key(self): return self.has_key_
1561
1562   def delete_time(self): return self.delete_time_
1563
1564   def set_delete_time(self, x):
1565     self.has_delete_time_ = 1
1566     self.delete_time_ = x
1567
1568   def clear_delete_time(self):
1569     if self.has_delete_time_:
1570       self.has_delete_time_ = 0
1571       self.delete_time_ = 0
1572
1573   def has_delete_time(self): return self.has_delete_time_
1574
1575
1576   def MergeFrom(self, x):
1577     assert x is not self
1578     if (x.has_key()): self.set_key(x.key())
1579     if (x.has_delete_time()): self.set_delete_time(x.delete_time())
1580
1581   def Equals(self, x):
1582     if x is self: return 1
1583     if self.has_key_ != x.has_key_: return 0
1584     if self.has_key_ and self.key_ != x.key_: return 0
1585     if self.has_delete_time_ != x.has_delete_time_: return 0
1586     if self.has_delete_time_ and self.delete_time_ != x.delete_time_: return 0
1587     return 1
1588
1589   def IsInitialized(self, debug_strs=None):
1590     initialized = 1
1591     if (not self.has_key_):
1592       initialized = 0
1593       if debug_strs is not None:
1594         debug_strs.append('Required field: key not set.')
1595     return initialized
1596
1597   def ByteSize(self):
1598     n = 0
1599     n += self.lengthString(len(self.key_))
1600     if (self.has_delete_time_): n += 5
1601     return n + 1
1602
1603   def ByteSizePartial(self):
1604     n = 0
1605     if (self.has_key_):
1606       n += 1
1607       n += self.lengthString(len(self.key_))
1608     if (self.has_delete_time_): n += 5
1609     return n
1610
1611   def Clear(self):
1612     self.clear_key()
1613     self.clear_delete_time()
1614
1615   def OutputUnchecked(self, out):
1616     out.putVarInt32(18)
1617     out.putPrefixedString(self.key_)
1618     if (self.has_delete_time_):
1619       out.putVarInt32(29)
1620       out.put32(self.delete_time_)
1621
1622   def OutputPartial(self, out):
1623     if (self.has_key_):
1624       out.putVarInt32(18)
1625       out.putPrefixedString(self.key_)
1626     if (self.has_delete_time_):
1627       out.putVarInt32(29)
1628       out.put32(self.delete_time_)
1629
1630   def TryMerge(self, d):
1631     while 1:
1632       tt = d.getVarInt32()
1633       if tt == 12: break
1634       if tt == 18:
1635         self.set_key(d.getPrefixedString())
1636         continue
1637       if tt == 29:
1638         self.set_delete_time(d.get32())
1639         continue
1640
1641
1642       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1643       d.skipData(tt)
1644
1645
1646   def __str__(self, prefix="", printElemNumber=0):
1647     res=""
1648     if self.has_key_: res+=prefix+("key: %s\n" % self.DebugFormatString(self.key_))
1649     if self.has_delete_time_: res+=prefix+("delete_time: %s\n" % self.DebugFormatFixed32(self.delete_time_))
1650     return res
1651
1652 class MemcacheDeleteRequest(ProtocolBuffer.ProtocolMessage):
1653   has_name_space_ = 0
1654   name_space_ = ""
1655   has_override_ = 0
1656   override_ = None
1657
1658   def __init__(self, contents=None):
1659     self.item_ = []
1660     self.lazy_init_lock_ = thread.allocate_lock()
1661     if contents is not None: self.MergeFromString(contents)
1662
1663   def item_size(self): return len(self.item_)
1664   def item_list(self): return self.item_
1665
1666   def item(self, i):
1667     return self.item_[i]
1668
1669   def mutable_item(self, i):
1670     return self.item_[i]
1671
1672   def add_item(self):
1673     x = MemcacheDeleteRequest_Item()
1674     self.item_.append(x)
1675     return x
1676
1677   def clear_item(self):
1678     self.item_ = []
1679   def name_space(self): return self.name_space_
1680
1681   def set_name_space(self, x):
1682     self.has_name_space_ = 1
1683     self.name_space_ = x
1684
1685   def clear_name_space(self):
1686     if self.has_name_space_:
1687       self.has_name_space_ = 0
1688       self.name_space_ = ""
1689
1690   def has_name_space(self): return self.has_name_space_
1691
1692   def override(self):
1693     if self.override_ is None:
1694       self.lazy_init_lock_.acquire()
1695       try:
1696         if self.override_ is None: self.override_ = AppOverride()
1697       finally:
1698         self.lazy_init_lock_.release()
1699     return self.override_
1700
1701   def mutable_override(self): self.has_override_ = 1; return self.override()
1702
1703   def clear_override(self):
1704
1705     if self.has_override_:
1706       self.has_override_ = 0;
1707       if self.override_ is not None: self.override_.Clear()
1708
1709   def has_override(self): return self.has_override_
1710
1711
1712   def MergeFrom(self, x):
1713     assert x is not self
1714     for i in xrange(x.item_size()): self.add_item().CopyFrom(x.item(i))
1715     if (x.has_name_space()): self.set_name_space(x.name_space())
1716     if (x.has_override()): self.mutable_override().MergeFrom(x.override())
1717
1718   def Equals(self, x):
1719     if x is self: return 1
1720     if len(self.item_) != len(x.item_): return 0
1721     for e1, e2 in zip(self.item_, x.item_):
1722       if e1 != e2: return 0
1723     if self.has_name_space_ != x.has_name_space_: return 0
1724     if self.has_name_space_ and self.name_space_ != x.name_space_: return 0
1725     if self.has_override_ != x.has_override_: return 0
1726     if self.has_override_ and self.override_ != x.override_: return 0
1727     return 1
1728
1729   def IsInitialized(self, debug_strs=None):
1730     initialized = 1
1731     for p in self.item_:
1732       if not p.IsInitialized(debug_strs): initialized=0
1733     if (self.has_override_ and not self.override_.IsInitialized(debug_strs)): initialized = 0
1734     return initialized
1735
1736   def ByteSize(self):
1737     n = 0
1738     n += 2 * len(self.item_)
1739     for i in xrange(len(self.item_)): n += self.item_[i].ByteSize()
1740     if (self.has_name_space_): n += 1 + self.lengthString(len(self.name_space_))
1741     if (self.has_override_): n += 1 + self.lengthString(self.override_.ByteSize())
1742     return n
1743
1744   def ByteSizePartial(self):
1745     n = 0
1746     n += 2 * len(self.item_)
1747     for i in xrange(len(self.item_)): n += self.item_[i].ByteSizePartial()
1748     if (self.has_name_space_): n += 1 + self.lengthString(len(self.name_space_))
1749     if (self.has_override_): n += 1 + self.lengthString(self.override_.ByteSizePartial())
1750     return n
1751
1752   def Clear(self):
1753     self.clear_item()
1754     self.clear_name_space()
1755     self.clear_override()
1756
1757   def OutputUnchecked(self, out):
1758     for i in xrange(len(self.item_)):
1759       out.putVarInt32(11)
1760       self.item_[i].OutputUnchecked(out)
1761       out.putVarInt32(12)
1762     if (self.has_name_space_):
1763       out.putVarInt32(34)
1764       out.putPrefixedString(self.name_space_)
1765     if (self.has_override_):
1766       out.putVarInt32(42)
1767       out.putVarInt32(self.override_.ByteSize())
1768       self.override_.OutputUnchecked(out)
1769
1770   def OutputPartial(self, out):
1771     for i in xrange(len(self.item_)):
1772       out.putVarInt32(11)
1773       self.item_[i].OutputPartial(out)
1774       out.putVarInt32(12)
1775     if (self.has_name_space_):
1776       out.putVarInt32(34)
1777       out.putPrefixedString(self.name_space_)
1778     if (self.has_override_):
1779       out.putVarInt32(42)
1780       out.putVarInt32(self.override_.ByteSizePartial())
1781       self.override_.OutputPartial(out)
1782
1783   def TryMerge(self, d):
1784     while d.avail() > 0:
1785       tt = d.getVarInt32()
1786       if tt == 11:
1787         self.add_item().TryMerge(d)
1788         continue
1789       if tt == 34:
1790         self.set_name_space(d.getPrefixedString())
1791         continue
1792       if tt == 42:
1793         length = d.getVarInt32()
1794         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
1795         d.skip(length)
1796         self.mutable_override().TryMerge(tmp)
1797         continue
1798
1799
1800       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1801       d.skipData(tt)
1802
1803
1804   def __str__(self, prefix="", printElemNumber=0):
1805     res=""
1806     cnt=0
1807     for e in self.item_:
1808       elm=""
1809       if printElemNumber: elm="(%d)" % cnt
1810       res+=prefix+("Item%s {\n" % elm)
1811       res+=e.__str__(prefix + "  ", printElemNumber)
1812       res+=prefix+"}\n"
1813       cnt+=1
1814     if self.has_name_space_: res+=prefix+("name_space: %s\n" % self.DebugFormatString(self.name_space_))
1815     if self.has_override_:
1816       res+=prefix+"override <\n"
1817       res+=self.override_.__str__(prefix + "  ", printElemNumber)
1818       res+=prefix+">\n"
1819     return res
1820
1821
1822   def _BuildTagLookupTable(sparse, maxtag, default=None):
1823     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
1824
1825   kItemGroup = 1
1826   kItemkey = 2
1827   kItemdelete_time = 3
1828   kname_space = 4
1829   koverride = 5
1830
1831   _TEXT = _BuildTagLookupTable({
1832     0: "ErrorCode",
1833     1: "Item",
1834     2: "key",
1835     3: "delete_time",
1836     4: "name_space",
1837     5: "override",
1838   }, 5)
1839
1840   _TYPES = _BuildTagLookupTable({
1841     0: ProtocolBuffer.Encoder.NUMERIC,
1842     1: ProtocolBuffer.Encoder.STARTGROUP,
1843     2: ProtocolBuffer.Encoder.STRING,
1844     3: ProtocolBuffer.Encoder.FLOAT,
1845     4: ProtocolBuffer.Encoder.STRING,
1846     5: ProtocolBuffer.Encoder.STRING,
1847   }, 5, ProtocolBuffer.Encoder.MAX_TYPE)
1848
1849
1850   _STYLE = """"""
1851   _STYLE_CONTENT_TYPE = """"""
1852   _PROTO_DESCRIPTOR_NAME = 'apphosting.MemcacheDeleteRequest'
1853 class MemcacheDeleteResponse(ProtocolBuffer.ProtocolMessage):
1854
1855
1856   DELETED      =    1
1857   NOT_FOUND    =    2
1858
1859   _DeleteStatusCode_NAMES = {
1860     1: "DELETED",
1861     2: "NOT_FOUND",
1862   }
1863
1864   def DeleteStatusCode_Name(cls, x): return cls._DeleteStatusCode_NAMES.get(x, "")
1865   DeleteStatusCode_Name = classmethod(DeleteStatusCode_Name)
1866
1867
1868   def __init__(self, contents=None):
1869     self.delete_status_ = []
1870     if contents is not None: self.MergeFromString(contents)
1871
1872   def delete_status_size(self): return len(self.delete_status_)
1873   def delete_status_list(self): return self.delete_status_
1874
1875   def delete_status(self, i):
1876     return self.delete_status_[i]
1877
1878   def set_delete_status(self, i, x):
1879     self.delete_status_[i] = x
1880
1881   def add_delete_status(self, x):
1882     self.delete_status_.append(x)
1883
1884   def clear_delete_status(self):
1885     self.delete_status_ = []
1886
1887
1888   def MergeFrom(self, x):
1889     assert x is not self
1890     for i in xrange(x.delete_status_size()): self.add_delete_status(x.delete_status(i))
1891
1892   def Equals(self, x):
1893     if x is self: return 1
1894     if len(self.delete_status_) != len(x.delete_status_): return 0
1895     for e1, e2 in zip(self.delete_status_, x.delete_status_):
1896       if e1 != e2: return 0
1897     return 1
1898
1899   def IsInitialized(self, debug_strs=None):
1900     initialized = 1
1901     return initialized
1902
1903   def ByteSize(self):
1904     n = 0
1905     n += 1 * len(self.delete_status_)
1906     for i in xrange(len(self.delete_status_)): n += self.lengthVarInt64(self.delete_status_[i])
1907     return n
1908
1909   def ByteSizePartial(self):
1910     n = 0
1911     n += 1 * len(self.delete_status_)
1912     for i in xrange(len(self.delete_status_)): n += self.lengthVarInt64(self.delete_status_[i])
1913     return n
1914
1915   def Clear(self):
1916     self.clear_delete_status()
1917
1918   def OutputUnchecked(self, out):
1919     for i in xrange(len(self.delete_status_)):
1920       out.putVarInt32(8)
1921       out.putVarInt32(self.delete_status_[i])
1922
1923   def OutputPartial(self, out):
1924     for i in xrange(len(self.delete_status_)):
1925       out.putVarInt32(8)
1926       out.putVarInt32(self.delete_status_[i])
1927
1928   def TryMerge(self, d):
1929     while d.avail() > 0:
1930       tt = d.getVarInt32()
1931       if tt == 8:
1932         self.add_delete_status(d.getVarInt32())
1933         continue
1934
1935
1936       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1937       d.skipData(tt)
1938
1939
1940   def __str__(self, prefix="", printElemNumber=0):
1941     res=""
1942     cnt=0
1943     for e in self.delete_status_:
1944       elm=""
1945       if printElemNumber: elm="(%d)" % cnt
1946       res+=prefix+("delete_status%s: %s\n" % (elm, self.DebugFormatInt32(e)))
1947       cnt+=1
1948     return res
1949
1950
1951   def _BuildTagLookupTable(sparse, maxtag, default=None):
1952     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
1953
1954   kdelete_status = 1
1955
1956   _TEXT = _BuildTagLookupTable({
1957     0: "ErrorCode",
1958     1: "delete_status",
1959   }, 1)
1960
1961   _TYPES = _BuildTagLookupTable({
1962     0: ProtocolBuffer.Encoder.NUMERIC,
1963     1: ProtocolBuffer.Encoder.NUMERIC,
1964   }, 1, ProtocolBuffer.Encoder.MAX_TYPE)
1965
1966
1967   _STYLE = """"""
1968   _STYLE_CONTENT_TYPE = """"""
1969   _PROTO_DESCRIPTOR_NAME = 'apphosting.MemcacheDeleteResponse'
1970 class MemcacheIncrementRequest(ProtocolBuffer.ProtocolMessage):
1971
1972
1973   INCREMENT    =    1
1974   DECREMENT    =    2
1975
1976   _Direction_NAMES = {
1977     1: "INCREMENT",
1978     2: "DECREMENT",
1979   }
1980
1981   def Direction_Name(cls, x): return cls._Direction_NAMES.get(x, "")
1982   Direction_Name = classmethod(Direction_Name)
1983
1984   has_key_ = 0
1985   key_ = ""
1986   has_name_space_ = 0
1987   name_space_ = ""
1988   has_delta_ = 0
1989   delta_ = 1
1990   has_direction_ = 0
1991   direction_ = 1
1992   has_initial_value_ = 0
1993   initial_value_ = 0
1994   has_initial_flags_ = 0
1995   initial_flags_ = 0
1996   has_override_ = 0
1997   override_ = None
1998
1999   def __init__(self, contents=None):
2000     self.lazy_init_lock_ = thread.allocate_lock()
2001     if contents is not None: self.MergeFromString(contents)
2002
2003   def key(self): return self.key_
2004
2005   def set_key(self, x):
2006     self.has_key_ = 1
2007     self.key_ = x
2008
2009   def clear_key(self):
2010     if self.has_key_:
2011       self.has_key_ = 0
2012       self.key_ = ""
2013
2014   def has_key(self): return self.has_key_
2015
2016   def name_space(self): return self.name_space_
2017
2018   def set_name_space(self, x):
2019     self.has_name_space_ = 1
2020     self.name_space_ = x
2021
2022   def clear_name_space(self):
2023     if self.has_name_space_:
2024       self.has_name_space_ = 0
2025       self.name_space_ = ""
2026
2027   def has_name_space(self): return self.has_name_space_
2028
2029   def delta(self): return self.delta_
2030
2031   def set_delta(self, x):
2032     self.has_delta_ = 1
2033     self.delta_ = x
2034
2035   def clear_delta(self):
2036     if self.has_delta_:
2037       self.has_delta_ = 0
2038       self.delta_ = 1
2039
2040   def has_delta(self): return self.has_delta_
2041
2042   def direction(self): return self.direction_
2043
2044   def set_direction(self, x):
2045     self.has_direction_ = 1
2046     self.direction_ = x
2047
2048   def clear_direction(self):
2049     if self.has_direction_:
2050       self.has_direction_ = 0
2051       self.direction_ = 1
2052
2053   def has_direction(self): return self.has_direction_
2054
2055   def initial_value(self): return self.initial_value_
2056
2057   def set_initial_value(self, x):
2058     self.has_initial_value_ = 1
2059     self.initial_value_ = x
2060
2061   def clear_initial_value(self):
2062     if self.has_initial_value_:
2063       self.has_initial_value_ = 0
2064       self.initial_value_ = 0
2065
2066   def has_initial_value(self): return self.has_initial_value_
2067
2068   def initial_flags(self): return self.initial_flags_
2069
2070   def set_initial_flags(self, x):
2071     self.has_initial_flags_ = 1
2072     self.initial_flags_ = x
2073
2074   def clear_initial_flags(self):
2075     if self.has_initial_flags_:
2076       self.has_initial_flags_ = 0
2077       self.initial_flags_ = 0
2078
2079   def has_initial_flags(self): return self.has_initial_flags_
2080
2081   def override(self):
2082     if self.override_ is None:
2083       self.lazy_init_lock_.acquire()
2084       try:
2085         if self.override_ is None: self.override_ = AppOverride()
2086       finally:
2087         self.lazy_init_lock_.release()
2088     return self.override_
2089
2090   def mutable_override(self): self.has_override_ = 1; return self.override()
2091
2092   def clear_override(self):
2093
2094     if self.has_override_:
2095       self.has_override_ = 0;
2096       if self.override_ is not None: self.override_.Clear()
2097
2098   def has_override(self): return self.has_override_
2099
2100
2101   def MergeFrom(self, x):
2102     assert x is not self
2103     if (x.has_key()): self.set_key(x.key())
2104     if (x.has_name_space()): self.set_name_space(x.name_space())
2105     if (x.has_delta()): self.set_delta(x.delta())
2106     if (x.has_direction()): self.set_direction(x.direction())
2107     if (x.has_initial_value()): self.set_initial_value(x.initial_value())
2108     if (x.has_initial_flags()): self.set_initial_flags(x.initial_flags())
2109     if (x.has_override()): self.mutable_override().MergeFrom(x.override())
2110
2111   def Equals(self, x):
2112     if x is self: return 1
2113     if self.has_key_ != x.has_key_: return 0
2114     if self.has_key_ and self.key_ != x.key_: return 0
2115     if self.has_name_space_ != x.has_name_space_: return 0
2116     if self.has_name_space_ and self.name_space_ != x.name_space_: return 0
2117     if self.has_delta_ != x.has_delta_: return 0
2118     if self.has_delta_ and self.delta_ != x.delta_: return 0
2119     if self.has_direction_ != x.has_direction_: return 0
2120     if self.has_direction_ and self.direction_ != x.direction_: return 0
2121     if self.has_initial_value_ != x.has_initial_value_: return 0
2122     if self.has_initial_value_ and self.initial_value_ != x.initial_value_: return 0
2123     if self.has_initial_flags_ != x.has_initial_flags_: return 0
2124     if self.has_initial_flags_ and self.initial_flags_ != x.initial_flags_: return 0
2125     if self.has_override_ != x.has_override_: return 0
2126     if self.has_override_ and self.override_ != x.override_: return 0
2127     return 1
2128
2129   def IsInitialized(self, debug_strs=None):
2130     initialized = 1
2131     if (not self.has_key_):
2132       initialized = 0
2133       if debug_strs is not None:
2134         debug_strs.append('Required field: key not set.')
2135     if (self.has_override_ and not self.override_.IsInitialized(debug_strs)): initialized = 0
2136     return initialized
2137
2138   def ByteSize(self):
2139     n = 0
2140     n += self.lengthString(len(self.key_))
2141     if (self.has_name_space_): n += 1 + self.lengthString(len(self.name_space_))
2142     if (self.has_delta_): n += 1 + self.lengthVarInt64(self.delta_)
2143     if (self.has_direction_): n += 1 + self.lengthVarInt64(self.direction_)
2144     if (self.has_initial_value_): n += 1 + self.lengthVarInt64(self.initial_value_)
2145     if (self.has_initial_flags_): n += 5
2146     if (self.has_override_): n += 1 + self.lengthString(self.override_.ByteSize())
2147     return n + 1
2148
2149   def ByteSizePartial(self):
2150     n = 0
2151     if (self.has_key_):
2152       n += 1
2153       n += self.lengthString(len(self.key_))
2154     if (self.has_name_space_): n += 1 + self.lengthString(len(self.name_space_))
2155     if (self.has_delta_): n += 1 + self.lengthVarInt64(self.delta_)
2156     if (self.has_direction_): n += 1 + self.lengthVarInt64(self.direction_)
2157     if (self.has_initial_value_): n += 1 + self.lengthVarInt64(self.initial_value_)
2158     if (self.has_initial_flags_): n += 5
2159     if (self.has_override_): n += 1 + self.lengthString(self.override_.ByteSizePartial())
2160     return n
2161
2162   def Clear(self):
2163     self.clear_key()
2164     self.clear_name_space()
2165     self.clear_delta()
2166     self.clear_direction()
2167     self.clear_initial_value()
2168     self.clear_initial_flags()
2169     self.clear_override()
2170
2171   def OutputUnchecked(self, out):
2172     out.putVarInt32(10)
2173     out.putPrefixedString(self.key_)
2174     if (self.has_delta_):
2175       out.putVarInt32(16)
2176       out.putVarUint64(self.delta_)
2177     if (self.has_direction_):
2178       out.putVarInt32(24)
2179       out.putVarInt32(self.direction_)
2180     if (self.has_name_space_):
2181       out.putVarInt32(34)
2182       out.putPrefixedString(self.name_space_)
2183     if (self.has_initial_value_):
2184       out.putVarInt32(40)
2185       out.putVarUint64(self.initial_value_)
2186     if (self.has_initial_flags_):
2187       out.putVarInt32(53)
2188       out.put32(self.initial_flags_)
2189     if (self.has_override_):
2190       out.putVarInt32(58)
2191       out.putVarInt32(self.override_.ByteSize())
2192       self.override_.OutputUnchecked(out)
2193
2194   def OutputPartial(self, out):
2195     if (self.has_key_):
2196       out.putVarInt32(10)
2197       out.putPrefixedString(self.key_)
2198     if (self.has_delta_):
2199       out.putVarInt32(16)
2200       out.putVarUint64(self.delta_)
2201     if (self.has_direction_):
2202       out.putVarInt32(24)
2203       out.putVarInt32(self.direction_)
2204     if (self.has_name_space_):
2205       out.putVarInt32(34)
2206       out.putPrefixedString(self.name_space_)
2207     if (self.has_initial_value_):
2208       out.putVarInt32(40)
2209       out.putVarUint64(self.initial_value_)
2210     if (self.has_initial_flags_):
2211       out.putVarInt32(53)
2212       out.put32(self.initial_flags_)
2213     if (self.has_override_):
2214       out.putVarInt32(58)
2215       out.putVarInt32(self.override_.ByteSizePartial())
2216       self.override_.OutputPartial(out)
2217
2218   def TryMerge(self, d):
2219     while d.avail() > 0:
2220       tt = d.getVarInt32()
2221       if tt == 10:
2222         self.set_key(d.getPrefixedString())
2223         continue
2224       if tt == 16:
2225         self.set_delta(d.getVarUint64())
2226         continue
2227       if tt == 24:
2228         self.set_direction(d.getVarInt32())
2229         continue
2230       if tt == 34:
2231         self.set_name_space(d.getPrefixedString())
2232         continue
2233       if tt == 40:
2234         self.set_initial_value(d.getVarUint64())
2235         continue
2236       if tt == 53:
2237         self.set_initial_flags(d.get32())
2238         continue
2239       if tt == 58:
2240         length = d.getVarInt32()
2241         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
2242         d.skip(length)
2243         self.mutable_override().TryMerge(tmp)
2244         continue
2245
2246
2247       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
2248       d.skipData(tt)
2249
2250
2251   def __str__(self, prefix="", printElemNumber=0):
2252     res=""
2253     if self.has_key_: res+=prefix+("key: %s\n" % self.DebugFormatString(self.key_))
2254     if self.has_name_space_: res+=prefix+("name_space: %s\n" % self.DebugFormatString(self.name_space_))
2255     if self.has_delta_: res+=prefix+("delta: %s\n" % self.DebugFormatInt64(self.delta_))
2256     if self.has_direction_: res+=prefix+("direction: %s\n" % self.DebugFormatInt32(self.direction_))
2257     if self.has_initial_value_: res+=prefix+("initial_value: %s\n" % self.DebugFormatInt64(self.initial_value_))
2258     if self.has_initial_flags_: res+=prefix+("initial_flags: %s\n" % self.DebugFormatFixed32(self.initial_flags_))
2259     if self.has_override_:
2260       res+=prefix+"override <\n"
2261       res+=self.override_.__str__(prefix + "  ", printElemNumber)
2262       res+=prefix+">\n"
2263     return res
2264
2265
2266   def _BuildTagLookupTable(sparse, maxtag, default=None):
2267     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
2268
2269   kkey = 1
2270   kname_space = 4
2271   kdelta = 2
2272   kdirection = 3
2273   kinitial_value = 5
2274   kinitial_flags = 6
2275   koverride = 7
2276
2277   _TEXT = _BuildTagLookupTable({
2278     0: "ErrorCode",
2279     1: "key",
2280     2: "delta",
2281     3: "direction",
2282     4: "name_space",
2283     5: "initial_value",
2284     6: "initial_flags",
2285     7: "override",
2286   }, 7)
2287
2288   _TYPES = _BuildTagLookupTable({
2289     0: ProtocolBuffer.Encoder.NUMERIC,
2290     1: ProtocolBuffer.Encoder.STRING,
2291     2: ProtocolBuffer.Encoder.NUMERIC,
2292     3: ProtocolBuffer.Encoder.NUMERIC,
2293     4: ProtocolBuffer.Encoder.STRING,
2294     5: ProtocolBuffer.Encoder.NUMERIC,
2295     6: ProtocolBuffer.Encoder.FLOAT,
2296     7: ProtocolBuffer.Encoder.STRING,
2297   }, 7, ProtocolBuffer.Encoder.MAX_TYPE)
2298
2299
2300   _STYLE = """"""
2301   _STYLE_CONTENT_TYPE = """"""
2302   _PROTO_DESCRIPTOR_NAME = 'apphosting.MemcacheIncrementRequest'
2303 class MemcacheIncrementResponse(ProtocolBuffer.ProtocolMessage):
2304
2305
2306   OK           =    1
2307   NOT_CHANGED  =    2
2308   ERROR        =    3
2309
2310   _IncrementStatusCode_NAMES = {
2311     1: "OK",
2312     2: "NOT_CHANGED",
2313     3: "ERROR",
2314   }
2315
2316   def IncrementStatusCode_Name(cls, x): return cls._IncrementStatusCode_NAMES.get(x, "")
2317   IncrementStatusCode_Name = classmethod(IncrementStatusCode_Name)
2318
2319   has_new_value_ = 0
2320   new_value_ = 0
2321   has_increment_status_ = 0
2322   increment_status_ = 0
2323
2324   def __init__(self, contents=None):
2325     if contents is not None: self.MergeFromString(contents)
2326
2327   def new_value(self): return self.new_value_
2328
2329   def set_new_value(self, x):
2330     self.has_new_value_ = 1
2331     self.new_value_ = x
2332
2333   def clear_new_value(self):
2334     if self.has_new_value_:
2335       self.has_new_value_ = 0
2336       self.new_value_ = 0
2337
2338   def has_new_value(self): return self.has_new_value_
2339
2340   def increment_status(self): return self.increment_status_
2341
2342   def set_increment_status(self, x):
2343     self.has_increment_status_ = 1
2344     self.increment_status_ = x
2345
2346   def clear_increment_status(self):
2347     if self.has_increment_status_:
2348       self.has_increment_status_ = 0
2349       self.increment_status_ = 0
2350
2351   def has_increment_status(self): return self.has_increment_status_
2352
2353
2354   def MergeFrom(self, x):
2355     assert x is not self
2356     if (x.has_new_value()): self.set_new_value(x.new_value())
2357     if (x.has_increment_status()): self.set_increment_status(x.increment_status())
2358
2359   def Equals(self, x):
2360     if x is self: return 1
2361     if self.has_new_value_ != x.has_new_value_: return 0
2362     if self.has_new_value_ and self.new_value_ != x.new_value_: return 0
2363     if self.has_increment_status_ != x.has_increment_status_: return 0
2364     if self.has_increment_status_ and self.increment_status_ != x.increment_status_: return 0
2365     return 1
2366
2367   def IsInitialized(self, debug_strs=None):
2368     initialized = 1
2369     return initialized
2370
2371   def ByteSize(self):
2372     n = 0
2373     if (self.has_new_value_): n += 1 + self.lengthVarInt64(self.new_value_)
2374     if (self.has_increment_status_): n += 1 + self.lengthVarInt64(self.increment_status_)
2375     return n
2376
2377   def ByteSizePartial(self):
2378     n = 0
2379     if (self.has_new_value_): n += 1 + self.lengthVarInt64(self.new_value_)
2380     if (self.has_increment_status_): n += 1 + self.lengthVarInt64(self.increment_status_)
2381     return n
2382
2383   def Clear(self):
2384     self.clear_new_value()
2385     self.clear_increment_status()
2386
2387   def OutputUnchecked(self, out):
2388     if (self.has_new_value_):
2389       out.putVarInt32(8)
2390       out.putVarUint64(self.new_value_)
2391     if (self.has_increment_status_):
2392       out.putVarInt32(16)
2393       out.putVarInt32(self.increment_status_)
2394
2395   def OutputPartial(self, out):
2396     if (self.has_new_value_):
2397       out.putVarInt32(8)
2398       out.putVarUint64(self.new_value_)
2399     if (self.has_increment_status_):
2400       out.putVarInt32(16)
2401       out.putVarInt32(self.increment_status_)
2402
2403   def TryMerge(self, d):
2404     while d.avail() > 0:
2405       tt = d.getVarInt32()
2406       if tt == 8:
2407         self.set_new_value(d.getVarUint64())
2408         continue
2409       if tt == 16:
2410         self.set_increment_status(d.getVarInt32())
2411         continue
2412
2413
2414       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
2415       d.skipData(tt)
2416
2417
2418   def __str__(self, prefix="", printElemNumber=0):
2419     res=""
2420     if self.has_new_value_: res+=prefix+("new_value: %s\n" % self.DebugFormatInt64(self.new_value_))
2421     if self.has_increment_status_: res+=prefix+("increment_status: %s\n" % self.DebugFormatInt32(self.increment_status_))
2422     return res
2423
2424
2425   def _BuildTagLookupTable(sparse, maxtag, default=None):
2426     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
2427
2428   knew_value = 1
2429   kincrement_status = 2
2430
2431   _TEXT = _BuildTagLookupTable({
2432     0: "ErrorCode",
2433     1: "new_value",
2434     2: "increment_status",
2435   }, 2)
2436
2437   _TYPES = _BuildTagLookupTable({
2438     0: ProtocolBuffer.Encoder.NUMERIC,
2439     1: ProtocolBuffer.Encoder.NUMERIC,
2440     2: ProtocolBuffer.Encoder.NUMERIC,
2441   }, 2, ProtocolBuffer.Encoder.MAX_TYPE)
2442
2443
2444   _STYLE = """"""
2445   _STYLE_CONTENT_TYPE = """"""
2446   _PROTO_DESCRIPTOR_NAME = 'apphosting.MemcacheIncrementResponse'
2447 class MemcacheBatchIncrementRequest(ProtocolBuffer.ProtocolMessage):
2448   has_name_space_ = 0
2449   name_space_ = ""
2450   has_override_ = 0
2451   override_ = None
2452
2453   def __init__(self, contents=None):
2454     self.item_ = []
2455     self.lazy_init_lock_ = thread.allocate_lock()
2456     if contents is not None: self.MergeFromString(contents)
2457
2458   def name_space(self): return self.name_space_
2459
2460   def set_name_space(self, x):
2461     self.has_name_space_ = 1
2462     self.name_space_ = x
2463
2464   def clear_name_space(self):
2465     if self.has_name_space_:
2466       self.has_name_space_ = 0
2467       self.name_space_ = ""
2468
2469   def has_name_space(self): return self.has_name_space_
2470
2471   def item_size(self): return len(self.item_)
2472   def item_list(self): return self.item_
2473
2474   def item(self, i):
2475     return self.item_[i]
2476
2477   def mutable_item(self, i):
2478     return self.item_[i]
2479
2480   def add_item(self):
2481     x = MemcacheIncrementRequest()
2482     self.item_.append(x)
2483     return x
2484
2485   def clear_item(self):
2486     self.item_ = []
2487   def override(self):
2488     if self.override_ is None:
2489       self.lazy_init_lock_.acquire()
2490       try:
2491         if self.override_ is None: self.override_ = AppOverride()
2492       finally:
2493         self.lazy_init_lock_.release()
2494     return self.override_
2495
2496   def mutable_override(self): self.has_override_ = 1; return self.override()
2497
2498   def clear_override(self):
2499
2500     if self.has_override_:
2501       self.has_override_ = 0;
2502       if self.override_ is not None: self.override_.Clear()
2503
2504   def has_override(self): return self.has_override_
2505
2506
2507   def MergeFrom(self, x):
2508     assert x is not self
2509     if (x.has_name_space()): self.set_name_space(x.name_space())
2510     for i in xrange(x.item_size()): self.add_item().CopyFrom(x.item(i))
2511     if (x.has_override()): self.mutable_override().MergeFrom(x.override())
2512
2513   def Equals(self, x):
2514     if x is self: return 1
2515     if self.has_name_space_ != x.has_name_space_: return 0
2516     if self.has_name_space_ and self.name_space_ != x.name_space_: return 0
2517     if len(self.item_) != len(x.item_): return 0
2518     for e1, e2 in zip(self.item_, x.item_):
2519       if e1 != e2: return 0
2520     if self.has_override_ != x.has_override_: return 0
2521     if self.has_override_ and self.override_ != x.override_: return 0
2522     return 1
2523
2524   def IsInitialized(self, debug_strs=None):
2525     initialized = 1
2526     for p in self.item_:
2527       if not p.IsInitialized(debug_strs): initialized=0
2528     if (self.has_override_ and not self.override_.IsInitialized(debug_strs)): initialized = 0
2529     return initialized
2530
2531   def ByteSize(self):
2532     n = 0
2533     if (self.has_name_space_): n += 1 + self.lengthString(len(self.name_space_))
2534     n += 1 * len(self.item_)
2535     for i in xrange(len(self.item_)): n += self.lengthString(self.item_[i].ByteSize())
2536     if (self.has_override_): n += 1 + self.lengthString(self.override_.ByteSize())
2537     return n
2538
2539   def ByteSizePartial(self):
2540     n = 0
2541     if (self.has_name_space_): n += 1 + self.lengthString(len(self.name_space_))
2542     n += 1 * len(self.item_)
2543     for i in xrange(len(self.item_)): n += self.lengthString(self.item_[i].ByteSizePartial())
2544     if (self.has_override_): n += 1 + self.lengthString(self.override_.ByteSizePartial())
2545     return n
2546
2547   def Clear(self):
2548     self.clear_name_space()
2549     self.clear_item()
2550     self.clear_override()
2551
2552   def OutputUnchecked(self, out):
2553     if (self.has_name_space_):
2554       out.putVarInt32(10)
2555       out.putPrefixedString(self.name_space_)
2556     for i in xrange(len(self.item_)):
2557       out.putVarInt32(18)
2558       out.putVarInt32(self.item_[i].ByteSize())
2559       self.item_[i].OutputUnchecked(out)
2560     if (self.has_override_):
2561       out.putVarInt32(26)
2562       out.putVarInt32(self.override_.ByteSize())
2563       self.override_.OutputUnchecked(out)
2564
2565   def OutputPartial(self, out):
2566     if (self.has_name_space_):
2567       out.putVarInt32(10)
2568       out.putPrefixedString(self.name_space_)
2569     for i in xrange(len(self.item_)):
2570       out.putVarInt32(18)
2571       out.putVarInt32(self.item_[i].ByteSizePartial())
2572       self.item_[i].OutputPartial(out)
2573     if (self.has_override_):
2574       out.putVarInt32(26)
2575       out.putVarInt32(self.override_.ByteSizePartial())
2576       self.override_.OutputPartial(out)
2577
2578   def TryMerge(self, d):
2579     while d.avail() > 0:
2580       tt = d.getVarInt32()
2581       if tt == 10:
2582         self.set_name_space(d.getPrefixedString())
2583         continue
2584       if tt == 18:
2585         length = d.getVarInt32()
2586         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
2587         d.skip(length)
2588         self.add_item().TryMerge(tmp)
2589         continue
2590       if tt == 26:
2591         length = d.getVarInt32()
2592         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
2593         d.skip(length)
2594         self.mutable_override().TryMerge(tmp)
2595         continue
2596
2597
2598       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
2599       d.skipData(tt)
2600
2601
2602   def __str__(self, prefix="", printElemNumber=0):
2603     res=""
2604     if self.has_name_space_: res+=prefix+("name_space: %s\n" % self.DebugFormatString(self.name_space_))
2605     cnt=0
2606     for e in self.item_:
2607       elm=""
2608       if printElemNumber: elm="(%d)" % cnt
2609       res+=prefix+("item%s <\n" % elm)
2610       res+=e.__str__(prefix + "  ", printElemNumber)
2611       res+=prefix+">\n"
2612       cnt+=1
2613     if self.has_override_:
2614       res+=prefix+"override <\n"
2615       res+=self.override_.__str__(prefix + "  ", printElemNumber)
2616       res+=prefix+">\n"
2617     return res
2618
2619
2620   def _BuildTagLookupTable(sparse, maxtag, default=None):
2621     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
2622
2623   kname_space = 1
2624   kitem = 2
2625   koverride = 3
2626
2627   _TEXT = _BuildTagLookupTable({
2628     0: "ErrorCode",
2629     1: "name_space",
2630     2: "item",
2631     3: "override",
2632   }, 3)
2633
2634   _TYPES = _BuildTagLookupTable({
2635     0: ProtocolBuffer.Encoder.NUMERIC,
2636     1: ProtocolBuffer.Encoder.STRING,
2637     2: ProtocolBuffer.Encoder.STRING,
2638     3: ProtocolBuffer.Encoder.STRING,
2639   }, 3, ProtocolBuffer.Encoder.MAX_TYPE)
2640
2641
2642   _STYLE = """"""
2643   _STYLE_CONTENT_TYPE = """"""
2644   _PROTO_DESCRIPTOR_NAME = 'apphosting.MemcacheBatchIncrementRequest'
2645 class MemcacheBatchIncrementResponse(ProtocolBuffer.ProtocolMessage):
2646
2647   def __init__(self, contents=None):
2648     self.item_ = []
2649     if contents is not None: self.MergeFromString(contents)
2650
2651   def item_size(self): return len(self.item_)
2652   def item_list(self): return self.item_
2653
2654   def item(self, i):
2655     return self.item_[i]
2656
2657   def mutable_item(self, i):
2658     return self.item_[i]
2659
2660   def add_item(self):
2661     x = MemcacheIncrementResponse()
2662     self.item_.append(x)
2663     return x
2664
2665   def clear_item(self):
2666     self.item_ = []
2667
2668   def MergeFrom(self, x):
2669     assert x is not self
2670     for i in xrange(x.item_size()): self.add_item().CopyFrom(x.item(i))
2671
2672   def Equals(self, x):
2673     if x is self: return 1
2674     if len(self.item_) != len(x.item_): return 0
2675     for e1, e2 in zip(self.item_, x.item_):
2676       if e1 != e2: return 0
2677     return 1
2678
2679   def IsInitialized(self, debug_strs=None):
2680     initialized = 1
2681     for p in self.item_:
2682       if not p.IsInitialized(debug_strs): initialized=0
2683     return initialized
2684
2685   def ByteSize(self):
2686     n = 0
2687     n += 1 * len(self.item_)
2688     for i in xrange(len(self.item_)): n += self.lengthString(self.item_[i].ByteSize())
2689     return n
2690
2691   def ByteSizePartial(self):
2692     n = 0
2693     n += 1 * len(self.item_)
2694     for i in xrange(len(self.item_)): n += self.lengthString(self.item_[i].ByteSizePartial())
2695     return n
2696
2697   def Clear(self):
2698     self.clear_item()
2699
2700   def OutputUnchecked(self, out):
2701     for i in xrange(len(self.item_)):
2702       out.putVarInt32(10)
2703       out.putVarInt32(self.item_[i].ByteSize())
2704       self.item_[i].OutputUnchecked(out)
2705
2706   def OutputPartial(self, out):
2707     for i in xrange(len(self.item_)):
2708       out.putVarInt32(10)
2709       out.putVarInt32(self.item_[i].ByteSizePartial())
2710       self.item_[i].OutputPartial(out)
2711
2712   def TryMerge(self, d):
2713     while d.avail() > 0:
2714       tt = d.getVarInt32()
2715       if tt == 10:
2716         length = d.getVarInt32()
2717         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
2718         d.skip(length)
2719         self.add_item().TryMerge(tmp)
2720         continue
2721
2722
2723       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
2724       d.skipData(tt)
2725
2726
2727   def __str__(self, prefix="", printElemNumber=0):
2728     res=""
2729     cnt=0
2730     for e in self.item_:
2731       elm=""
2732       if printElemNumber: elm="(%d)" % cnt
2733       res+=prefix+("item%s <\n" % elm)
2734       res+=e.__str__(prefix + "  ", printElemNumber)
2735       res+=prefix+">\n"
2736       cnt+=1
2737     return res
2738
2739
2740   def _BuildTagLookupTable(sparse, maxtag, default=None):
2741     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
2742
2743   kitem = 1
2744
2745   _TEXT = _BuildTagLookupTable({
2746     0: "ErrorCode",
2747     1: "item",
2748   }, 1)
2749
2750   _TYPES = _BuildTagLookupTable({
2751     0: ProtocolBuffer.Encoder.NUMERIC,
2752     1: ProtocolBuffer.Encoder.STRING,
2753   }, 1, ProtocolBuffer.Encoder.MAX_TYPE)
2754
2755
2756   _STYLE = """"""
2757   _STYLE_CONTENT_TYPE = """"""
2758   _PROTO_DESCRIPTOR_NAME = 'apphosting.MemcacheBatchIncrementResponse'
2759 class MemcacheFlushRequest(ProtocolBuffer.ProtocolMessage):
2760   has_override_ = 0
2761   override_ = None
2762
2763   def __init__(self, contents=None):
2764     self.lazy_init_lock_ = thread.allocate_lock()
2765     if contents is not None: self.MergeFromString(contents)
2766
2767   def override(self):
2768     if self.override_ is None:
2769       self.lazy_init_lock_.acquire()
2770       try:
2771         if self.override_ is None: self.override_ = AppOverride()
2772       finally:
2773         self.lazy_init_lock_.release()
2774     return self.override_
2775
2776   def mutable_override(self): self.has_override_ = 1; return self.override()
2777
2778   def clear_override(self):
2779
2780     if self.has_override_:
2781       self.has_override_ = 0;
2782       if self.override_ is not None: self.override_.Clear()
2783
2784   def has_override(self): return self.has_override_
2785
2786
2787   def MergeFrom(self, x):
2788     assert x is not self
2789     if (x.has_override()): self.mutable_override().MergeFrom(x.override())
2790
2791   def Equals(self, x):
2792     if x is self: return 1
2793     if self.has_override_ != x.has_override_: return 0
2794     if self.has_override_ and self.override_ != x.override_: return 0
2795     return 1
2796
2797   def IsInitialized(self, debug_strs=None):
2798     initialized = 1
2799     if (self.has_override_ and not self.override_.IsInitialized(debug_strs)): initialized = 0
2800     return initialized
2801
2802   def ByteSize(self):
2803     n = 0
2804     if (self.has_override_): n += 1 + self.lengthString(self.override_.ByteSize())
2805     return n
2806
2807   def ByteSizePartial(self):
2808     n = 0
2809     if (self.has_override_): n += 1 + self.lengthString(self.override_.ByteSizePartial())
2810     return n
2811
2812   def Clear(self):
2813     self.clear_override()
2814
2815   def OutputUnchecked(self, out):
2816     if (self.has_override_):
2817       out.putVarInt32(10)
2818       out.putVarInt32(self.override_.ByteSize())
2819       self.override_.OutputUnchecked(out)
2820
2821   def OutputPartial(self, out):
2822     if (self.has_override_):
2823       out.putVarInt32(10)
2824       out.putVarInt32(self.override_.ByteSizePartial())
2825       self.override_.OutputPartial(out)
2826
2827   def TryMerge(self, d):
2828     while d.avail() > 0:
2829       tt = d.getVarInt32()
2830       if tt == 10:
2831         length = d.getVarInt32()
2832         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
2833         d.skip(length)
2834         self.mutable_override().TryMerge(tmp)
2835         continue
2836
2837
2838       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
2839       d.skipData(tt)
2840
2841
2842   def __str__(self, prefix="", printElemNumber=0):
2843     res=""
2844     if self.has_override_:
2845       res+=prefix+"override <\n"
2846       res+=self.override_.__str__(prefix + "  ", printElemNumber)
2847       res+=prefix+">\n"
2848     return res
2849
2850
2851   def _BuildTagLookupTable(sparse, maxtag, default=None):
2852     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
2853
2854   koverride = 1
2855
2856   _TEXT = _BuildTagLookupTable({
2857     0: "ErrorCode",
2858     1: "override",
2859   }, 1)
2860
2861   _TYPES = _BuildTagLookupTable({
2862     0: ProtocolBuffer.Encoder.NUMERIC,
2863     1: ProtocolBuffer.Encoder.STRING,
2864   }, 1, ProtocolBuffer.Encoder.MAX_TYPE)
2865
2866
2867   _STYLE = """"""
2868   _STYLE_CONTENT_TYPE = """"""
2869   _PROTO_DESCRIPTOR_NAME = 'apphosting.MemcacheFlushRequest'
2870 class MemcacheFlushResponse(ProtocolBuffer.ProtocolMessage):
2871
2872   def __init__(self, contents=None):
2873     pass
2874     if contents is not None: self.MergeFromString(contents)
2875
2876
2877   def MergeFrom(self, x):
2878     assert x is not self
2879
2880   def Equals(self, x):
2881     if x is self: return 1
2882     return 1
2883
2884   def IsInitialized(self, debug_strs=None):
2885     initialized = 1
2886     return initialized
2887
2888   def ByteSize(self):
2889     n = 0
2890     return n
2891
2892   def ByteSizePartial(self):
2893     n = 0
2894     return n
2895
2896   def Clear(self):
2897     pass
2898
2899   def OutputUnchecked(self, out):
2900     pass
2901
2902   def OutputPartial(self, out):
2903     pass
2904
2905   def TryMerge(self, d):
2906     while d.avail() > 0:
2907       tt = d.getVarInt32()
2908
2909
2910       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
2911       d.skipData(tt)
2912
2913
2914   def __str__(self, prefix="", printElemNumber=0):
2915     res=""
2916     return res
2917
2918
2919   def _BuildTagLookupTable(sparse, maxtag, default=None):
2920     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
2921
2922
2923   _TEXT = _BuildTagLookupTable({
2924     0: "ErrorCode",
2925   }, 0)
2926
2927   _TYPES = _BuildTagLookupTable({
2928     0: ProtocolBuffer.Encoder.NUMERIC,
2929   }, 0, ProtocolBuffer.Encoder.MAX_TYPE)
2930
2931
2932   _STYLE = """"""
2933   _STYLE_CONTENT_TYPE = """"""
2934   _PROTO_DESCRIPTOR_NAME = 'apphosting.MemcacheFlushResponse'
2935 class MemcacheStatsRequest(ProtocolBuffer.ProtocolMessage):
2936   has_override_ = 0
2937   override_ = None
2938
2939   def __init__(self, contents=None):
2940     self.lazy_init_lock_ = thread.allocate_lock()
2941     if contents is not None: self.MergeFromString(contents)
2942
2943   def override(self):
2944     if self.override_ is None:
2945       self.lazy_init_lock_.acquire()
2946       try:
2947         if self.override_ is None: self.override_ = AppOverride()
2948       finally:
2949         self.lazy_init_lock_.release()
2950     return self.override_
2951
2952   def mutable_override(self): self.has_override_ = 1; return self.override()
2953
2954   def clear_override(self):
2955
2956     if self.has_override_:
2957       self.has_override_ = 0;
2958       if self.override_ is not None: self.override_.Clear()
2959
2960   def has_override(self): return self.has_override_
2961
2962
2963   def MergeFrom(self, x):
2964     assert x is not self
2965     if (x.has_override()): self.mutable_override().MergeFrom(x.override())
2966
2967   def Equals(self, x):
2968     if x is self: return 1
2969     if self.has_override_ != x.has_override_: return 0
2970     if self.has_override_ and self.override_ != x.override_: return 0
2971     return 1
2972
2973   def IsInitialized(self, debug_strs=None):
2974     initialized = 1
2975     if (self.has_override_ and not self.override_.IsInitialized(debug_strs)): initialized = 0
2976     return initialized
2977
2978   def ByteSize(self):
2979     n = 0
2980     if (self.has_override_): n += 1 + self.lengthString(self.override_.ByteSize())
2981     return n
2982
2983   def ByteSizePartial(self):
2984     n = 0
2985     if (self.has_override_): n += 1 + self.lengthString(self.override_.ByteSizePartial())
2986     return n
2987
2988   def Clear(self):
2989     self.clear_override()
2990
2991   def OutputUnchecked(self, out):
2992     if (self.has_override_):
2993       out.putVarInt32(10)
2994       out.putVarInt32(self.override_.ByteSize())
2995       self.override_.OutputUnchecked(out)
2996
2997   def OutputPartial(self, out):
2998     if (self.has_override_):
2999       out.putVarInt32(10)
3000       out.putVarInt32(self.override_.ByteSizePartial())
3001       self.override_.OutputPartial(out)
3002
3003   def TryMerge(self, d):
3004     while d.avail() > 0:
3005       tt = d.getVarInt32()
3006       if tt == 10:
3007         length = d.getVarInt32()
3008         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
3009         d.skip(length)
3010         self.mutable_override().TryMerge(tmp)
3011         continue
3012
3013
3014       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
3015       d.skipData(tt)
3016
3017
3018   def __str__(self, prefix="", printElemNumber=0):
3019     res=""
3020     if self.has_override_:
3021       res+=prefix+"override <\n"
3022       res+=self.override_.__str__(prefix + "  ", printElemNumber)
3023       res+=prefix+">\n"
3024     return res
3025
3026
3027   def _BuildTagLookupTable(sparse, maxtag, default=None):
3028     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
3029
3030   koverride = 1
3031
3032   _TEXT = _BuildTagLookupTable({
3033     0: "ErrorCode",
3034     1: "override",
3035   }, 1)
3036
3037   _TYPES = _BuildTagLookupTable({
3038     0: ProtocolBuffer.Encoder.NUMERIC,
3039     1: ProtocolBuffer.Encoder.STRING,
3040   }, 1, ProtocolBuffer.Encoder.MAX_TYPE)
3041
3042
3043   _STYLE = """"""
3044   _STYLE_CONTENT_TYPE = """"""
3045   _PROTO_DESCRIPTOR_NAME = 'apphosting.MemcacheStatsRequest'
3046 class MergedNamespaceStats(ProtocolBuffer.ProtocolMessage):
3047   has_hits_ = 0
3048   hits_ = 0
3049   has_misses_ = 0
3050   misses_ = 0
3051   has_byte_hits_ = 0
3052   byte_hits_ = 0
3053   has_items_ = 0
3054   items_ = 0
3055   has_bytes_ = 0
3056   bytes_ = 0
3057   has_oldest_item_age_ = 0
3058   oldest_item_age_ = 0
3059
3060   def __init__(self, contents=None):
3061     if contents is not None: self.MergeFromString(contents)
3062
3063   def hits(self): return self.hits_
3064
3065   def set_hits(self, x):
3066     self.has_hits_ = 1
3067     self.hits_ = x
3068
3069   def clear_hits(self):
3070     if self.has_hits_:
3071       self.has_hits_ = 0
3072       self.hits_ = 0
3073
3074   def has_hits(self): return self.has_hits_
3075
3076   def misses(self): return self.misses_
3077
3078   def set_misses(self, x):
3079     self.has_misses_ = 1
3080     self.misses_ = x
3081
3082   def clear_misses(self):
3083     if self.has_misses_:
3084       self.has_misses_ = 0
3085       self.misses_ = 0
3086
3087   def has_misses(self): return self.has_misses_
3088
3089   def byte_hits(self): return self.byte_hits_
3090
3091   def set_byte_hits(self, x):
3092     self.has_byte_hits_ = 1
3093     self.byte_hits_ = x
3094
3095   def clear_byte_hits(self):
3096     if self.has_byte_hits_:
3097       self.has_byte_hits_ = 0
3098       self.byte_hits_ = 0
3099
3100   def has_byte_hits(self): return self.has_byte_hits_
3101
3102   def items(self): return self.items_
3103
3104   def set_items(self, x):
3105     self.has_items_ = 1
3106     self.items_ = x
3107
3108   def clear_items(self):
3109     if self.has_items_:
3110       self.has_items_ = 0
3111       self.items_ = 0
3112
3113   def has_items(self): return self.has_items_
3114
3115   def bytes(self): return self.bytes_
3116
3117   def set_bytes(self, x):
3118     self.has_bytes_ = 1
3119     self.bytes_ = x
3120
3121   def clear_bytes(self):
3122     if self.has_bytes_:
3123       self.has_bytes_ = 0
3124       self.bytes_ = 0
3125
3126   def has_bytes(self): return self.has_bytes_
3127
3128   def oldest_item_age(self): return self.oldest_item_age_
3129
3130   def set_oldest_item_age(self, x):
3131     self.has_oldest_item_age_ = 1
3132     self.oldest_item_age_ = x
3133
3134   def clear_oldest_item_age(self):
3135     if self.has_oldest_item_age_:
3136       self.has_oldest_item_age_ = 0
3137       self.oldest_item_age_ = 0
3138
3139   def has_oldest_item_age(self): return self.has_oldest_item_age_
3140
3141
3142   def MergeFrom(self, x):
3143     assert x is not self
3144     if (x.has_hits()): self.set_hits(x.hits())
3145     if (x.has_misses()): self.set_misses(x.misses())
3146     if (x.has_byte_hits()): self.set_byte_hits(x.byte_hits())
3147     if (x.has_items()): self.set_items(x.items())
3148     if (x.has_bytes()): self.set_bytes(x.bytes())
3149     if (x.has_oldest_item_age()): self.set_oldest_item_age(x.oldest_item_age())
3150
3151   def Equals(self, x):
3152     if x is self: return 1
3153     if self.has_hits_ != x.has_hits_: return 0
3154     if self.has_hits_ and self.hits_ != x.hits_: return 0
3155     if self.has_misses_ != x.has_misses_: return 0
3156     if self.has_misses_ and self.misses_ != x.misses_: return 0
3157     if self.has_byte_hits_ != x.has_byte_hits_: return 0
3158     if self.has_byte_hits_ and self.byte_hits_ != x.byte_hits_: return 0
3159     if self.has_items_ != x.has_items_: return 0
3160     if self.has_items_ and self.items_ != x.items_: return 0
3161     if self.has_bytes_ != x.has_bytes_: return 0
3162     if self.has_bytes_ and self.bytes_ != x.bytes_: return 0
3163     if self.has_oldest_item_age_ != x.has_oldest_item_age_: return 0
3164     if self.has_oldest_item_age_ and self.oldest_item_age_ != x.oldest_item_age_: return 0
3165     return 1
3166
3167   def IsInitialized(self, debug_strs=None):
3168     initialized = 1
3169     if (not self.has_hits_):
3170       initialized = 0
3171       if debug_strs is not None:
3172         debug_strs.append('Required field: hits not set.')
3173     if (not self.has_misses_):
3174       initialized = 0
3175       if debug_strs is not None:
3176         debug_strs.append('Required field: misses not set.')
3177     if (not self.has_byte_hits_):
3178       initialized = 0
3179       if debug_strs is not None:
3180         debug_strs.append('Required field: byte_hits not set.')
3181     if (not self.has_items_):
3182       initialized = 0
3183       if debug_strs is not None:
3184         debug_strs.append('Required field: items not set.')
3185     if (not self.has_bytes_):
3186       initialized = 0
3187       if debug_strs is not None:
3188         debug_strs.append('Required field: bytes not set.')
3189     if (not self.has_oldest_item_age_):
3190       initialized = 0
3191       if debug_strs is not None:
3192         debug_strs.append('Required field: oldest_item_age not set.')
3193     return initialized
3194
3195   def ByteSize(self):
3196     n = 0
3197     n += self.lengthVarInt64(self.hits_)
3198     n += self.lengthVarInt64(self.misses_)
3199     n += self.lengthVarInt64(self.byte_hits_)
3200     n += self.lengthVarInt64(self.items_)
3201     n += self.lengthVarInt64(self.bytes_)
3202     return n + 10
3203
3204   def ByteSizePartial(self):
3205     n = 0
3206     if (self.has_hits_):
3207       n += 1
3208       n += self.lengthVarInt64(self.hits_)
3209     if (self.has_misses_):
3210       n += 1
3211       n += self.lengthVarInt64(self.misses_)
3212     if (self.has_byte_hits_):
3213       n += 1
3214       n += self.lengthVarInt64(self.byte_hits_)
3215     if (self.has_items_):
3216       n += 1
3217       n += self.lengthVarInt64(self.items_)
3218     if (self.has_bytes_):
3219       n += 1
3220       n += self.lengthVarInt64(self.bytes_)
3221     if (self.has_oldest_item_age_):
3222       n += 5
3223     return n
3224
3225   def Clear(self):
3226     self.clear_hits()
3227     self.clear_misses()
3228     self.clear_byte_hits()
3229     self.clear_items()
3230     self.clear_bytes()
3231     self.clear_oldest_item_age()
3232
3233   def OutputUnchecked(self, out):
3234     out.putVarInt32(8)
3235     out.putVarUint64(self.hits_)
3236     out.putVarInt32(16)
3237     out.putVarUint64(self.misses_)
3238     out.putVarInt32(24)
3239     out.putVarUint64(self.byte_hits_)
3240     out.putVarInt32(32)
3241     out.putVarUint64(self.items_)
3242     out.putVarInt32(40)
3243     out.putVarUint64(self.bytes_)
3244     out.putVarInt32(53)
3245     out.put32(self.oldest_item_age_)
3246
3247   def OutputPartial(self, out):
3248     if (self.has_hits_):
3249       out.putVarInt32(8)
3250       out.putVarUint64(self.hits_)
3251     if (self.has_misses_):
3252       out.putVarInt32(16)
3253       out.putVarUint64(self.misses_)
3254     if (self.has_byte_hits_):
3255       out.putVarInt32(24)
3256       out.putVarUint64(self.byte_hits_)
3257     if (self.has_items_):
3258       out.putVarInt32(32)
3259       out.putVarUint64(self.items_)
3260     if (self.has_bytes_):
3261       out.putVarInt32(40)
3262       out.putVarUint64(self.bytes_)
3263     if (self.has_oldest_item_age_):
3264       out.putVarInt32(53)
3265       out.put32(self.oldest_item_age_)
3266
3267   def TryMerge(self, d):
3268     while d.avail() > 0:
3269       tt = d.getVarInt32()
3270       if tt == 8:
3271         self.set_hits(d.getVarUint64())
3272         continue
3273       if tt == 16:
3274         self.set_misses(d.getVarUint64())
3275         continue
3276       if tt == 24:
3277         self.set_byte_hits(d.getVarUint64())
3278         continue
3279       if tt == 32:
3280         self.set_items(d.getVarUint64())
3281         continue
3282       if tt == 40:
3283         self.set_bytes(d.getVarUint64())
3284         continue
3285       if tt == 53:
3286         self.set_oldest_item_age(d.get32())
3287         continue
3288
3289
3290       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
3291       d.skipData(tt)
3292
3293
3294   def __str__(self, prefix="", printElemNumber=0):
3295     res=""
3296     if self.has_hits_: res+=prefix+("hits: %s\n" % self.DebugFormatInt64(self.hits_))
3297     if self.has_misses_: res+=prefix+("misses: %s\n" % self.DebugFormatInt64(self.misses_))
3298     if self.has_byte_hits_: res+=prefix+("byte_hits: %s\n" % self.DebugFormatInt64(self.byte_hits_))
3299     if self.has_items_: res+=prefix+("items: %s\n" % self.DebugFormatInt64(self.items_))
3300     if self.has_bytes_: res+=prefix+("bytes: %s\n" % self.DebugFormatInt64(self.bytes_))
3301     if self.has_oldest_item_age_: res+=prefix+("oldest_item_age: %s\n" % self.DebugFormatFixed32(self.oldest_item_age_))
3302     return res
3303
3304
3305   def _BuildTagLookupTable(sparse, maxtag, default=None):
3306     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
3307
3308   khits = 1
3309   kmisses = 2
3310   kbyte_hits = 3
3311   kitems = 4
3312   kbytes = 5
3313   koldest_item_age = 6
3314
3315   _TEXT = _BuildTagLookupTable({
3316     0: "ErrorCode",
3317     1: "hits",
3318     2: "misses",
3319     3: "byte_hits",
3320     4: "items",
3321     5: "bytes",
3322     6: "oldest_item_age",
3323   }, 6)
3324
3325   _TYPES = _BuildTagLookupTable({
3326     0: ProtocolBuffer.Encoder.NUMERIC,
3327     1: ProtocolBuffer.Encoder.NUMERIC,
3328     2: ProtocolBuffer.Encoder.NUMERIC,
3329     3: ProtocolBuffer.Encoder.NUMERIC,
3330     4: ProtocolBuffer.Encoder.NUMERIC,
3331     5: ProtocolBuffer.Encoder.NUMERIC,
3332     6: ProtocolBuffer.Encoder.FLOAT,
3333   }, 6, ProtocolBuffer.Encoder.MAX_TYPE)
3334
3335
3336   _STYLE = """"""
3337   _STYLE_CONTENT_TYPE = """"""
3338   _PROTO_DESCRIPTOR_NAME = 'apphosting.MergedNamespaceStats'
3339 class MemcacheStatsResponse(ProtocolBuffer.ProtocolMessage):
3340   has_stats_ = 0
3341   stats_ = None
3342
3343   def __init__(self, contents=None):
3344     self.lazy_init_lock_ = thread.allocate_lock()
3345     if contents is not None: self.MergeFromString(contents)
3346
3347   def stats(self):
3348     if self.stats_ is None:
3349       self.lazy_init_lock_.acquire()
3350       try:
3351         if self.stats_ is None: self.stats_ = MergedNamespaceStats()
3352       finally:
3353         self.lazy_init_lock_.release()
3354     return self.stats_
3355
3356   def mutable_stats(self): self.has_stats_ = 1; return self.stats()
3357
3358   def clear_stats(self):
3359
3360     if self.has_stats_:
3361       self.has_stats_ = 0;
3362       if self.stats_ is not None: self.stats_.Clear()
3363
3364   def has_stats(self): return self.has_stats_
3365
3366
3367   def MergeFrom(self, x):
3368     assert x is not self
3369     if (x.has_stats()): self.mutable_stats().MergeFrom(x.stats())
3370
3371   def Equals(self, x):
3372     if x is self: return 1
3373     if self.has_stats_ != x.has_stats_: return 0
3374     if self.has_stats_ and self.stats_ != x.stats_: return 0
3375     return 1
3376
3377   def IsInitialized(self, debug_strs=None):
3378     initialized = 1
3379     if (self.has_stats_ and not self.stats_.IsInitialized(debug_strs)): initialized = 0
3380     return initialized
3381
3382   def ByteSize(self):
3383     n = 0
3384     if (self.has_stats_): n += 1 + self.lengthString(self.stats_.ByteSize())
3385     return n
3386
3387   def ByteSizePartial(self):
3388     n = 0
3389     if (self.has_stats_): n += 1 + self.lengthString(self.stats_.ByteSizePartial())
3390     return n
3391
3392   def Clear(self):
3393     self.clear_stats()
3394
3395   def OutputUnchecked(self, out):
3396     if (self.has_stats_):
3397       out.putVarInt32(10)
3398       out.putVarInt32(self.stats_.ByteSize())
3399       self.stats_.OutputUnchecked(out)
3400
3401   def OutputPartial(self, out):
3402     if (self.has_stats_):
3403       out.putVarInt32(10)
3404       out.putVarInt32(self.stats_.ByteSizePartial())
3405       self.stats_.OutputPartial(out)
3406
3407   def TryMerge(self, d):
3408     while d.avail() > 0:
3409       tt = d.getVarInt32()
3410       if tt == 10:
3411         length = d.getVarInt32()
3412         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
3413         d.skip(length)
3414         self.mutable_stats().TryMerge(tmp)
3415         continue
3416
3417
3418       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
3419       d.skipData(tt)
3420
3421
3422   def __str__(self, prefix="", printElemNumber=0):
3423     res=""
3424     if self.has_stats_:
3425       res+=prefix+"stats <\n"
3426       res+=self.stats_.__str__(prefix + "  ", printElemNumber)
3427       res+=prefix+">\n"
3428     return res
3429
3430
3431   def _BuildTagLookupTable(sparse, maxtag, default=None):
3432     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
3433
3434   kstats = 1
3435
3436   _TEXT = _BuildTagLookupTable({
3437     0: "ErrorCode",
3438     1: "stats",
3439   }, 1)
3440
3441   _TYPES = _BuildTagLookupTable({
3442     0: ProtocolBuffer.Encoder.NUMERIC,
3443     1: ProtocolBuffer.Encoder.STRING,
3444   }, 1, ProtocolBuffer.Encoder.MAX_TYPE)
3445
3446
3447   _STYLE = """"""
3448   _STYLE_CONTENT_TYPE = """"""
3449   _PROTO_DESCRIPTOR_NAME = 'apphosting.MemcacheStatsResponse'
3450 class MemcacheGrabTailRequest(ProtocolBuffer.ProtocolMessage):
3451   has_item_count_ = 0
3452   item_count_ = 0
3453   has_name_space_ = 0
3454   name_space_ = ""
3455   has_override_ = 0
3456   override_ = None
3457
3458   def __init__(self, contents=None):
3459     self.lazy_init_lock_ = thread.allocate_lock()
3460     if contents is not None: self.MergeFromString(contents)
3461
3462   def item_count(self): return self.item_count_
3463
3464   def set_item_count(self, x):
3465     self.has_item_count_ = 1
3466     self.item_count_ = x
3467
3468   def clear_item_count(self):
3469     if self.has_item_count_:
3470       self.has_item_count_ = 0
3471       self.item_count_ = 0
3472
3473   def has_item_count(self): return self.has_item_count_
3474
3475   def name_space(self): return self.name_space_
3476
3477   def set_name_space(self, x):
3478     self.has_name_space_ = 1
3479     self.name_space_ = x
3480
3481   def clear_name_space(self):
3482     if self.has_name_space_:
3483       self.has_name_space_ = 0
3484       self.name_space_ = ""
3485
3486   def has_name_space(self): return self.has_name_space_
3487
3488   def override(self):
3489     if self.override_ is None:
3490       self.lazy_init_lock_.acquire()
3491       try:
3492         if self.override_ is None: self.override_ = AppOverride()
3493       finally:
3494         self.lazy_init_lock_.release()
3495     return self.override_
3496
3497   def mutable_override(self): self.has_override_ = 1; return self.override()
3498
3499   def clear_override(self):
3500
3501     if self.has_override_:
3502       self.has_override_ = 0;
3503       if self.override_ is not None: self.override_.Clear()
3504
3505   def has_override(self): return self.has_override_
3506
3507
3508   def MergeFrom(self, x):
3509     assert x is not self
3510     if (x.has_item_count()): self.set_item_count(x.item_count())
3511     if (x.has_name_space()): self.set_name_space(x.name_space())
3512     if (x.has_override()): self.mutable_override().MergeFrom(x.override())
3513
3514   def Equals(self, x):
3515     if x is self: return 1
3516     if self.has_item_count_ != x.has_item_count_: return 0
3517     if self.has_item_count_ and self.item_count_ != x.item_count_: return 0
3518     if self.has_name_space_ != x.has_name_space_: return 0
3519     if self.has_name_space_ and self.name_space_ != x.name_space_: return 0
3520     if self.has_override_ != x.has_override_: return 0
3521     if self.has_override_ and self.override_ != x.override_: return 0
3522     return 1
3523
3524   def IsInitialized(self, debug_strs=None):
3525     initialized = 1
3526     if (not self.has_item_count_):
3527       initialized = 0
3528       if debug_strs is not None:
3529         debug_strs.append('Required field: item_count not set.')
3530     if (self.has_override_ and not self.override_.IsInitialized(debug_strs)): initialized = 0
3531     return initialized
3532
3533   def ByteSize(self):
3534     n = 0
3535     n += self.lengthVarInt64(self.item_count_)
3536     if (self.has_name_space_): n += 1 + self.lengthString(len(self.name_space_))
3537     if (self.has_override_): n += 1 + self.lengthString(self.override_.ByteSize())
3538     return n + 1
3539
3540   def ByteSizePartial(self):
3541     n = 0
3542     if (self.has_item_count_):
3543       n += 1
3544       n += self.lengthVarInt64(self.item_count_)
3545     if (self.has_name_space_): n += 1 + self.lengthString(len(self.name_space_))
3546     if (self.has_override_): n += 1 + self.lengthString(self.override_.ByteSizePartial())
3547     return n
3548
3549   def Clear(self):
3550     self.clear_item_count()
3551     self.clear_name_space()
3552     self.clear_override()
3553
3554   def OutputUnchecked(self, out):
3555     out.putVarInt32(8)
3556     out.putVarInt32(self.item_count_)
3557     if (self.has_name_space_):
3558       out.putVarInt32(18)
3559       out.putPrefixedString(self.name_space_)
3560     if (self.has_override_):
3561       out.putVarInt32(26)
3562       out.putVarInt32(self.override_.ByteSize())
3563       self.override_.OutputUnchecked(out)
3564
3565   def OutputPartial(self, out):
3566     if (self.has_item_count_):
3567       out.putVarInt32(8)
3568       out.putVarInt32(self.item_count_)
3569     if (self.has_name_space_):
3570       out.putVarInt32(18)
3571       out.putPrefixedString(self.name_space_)
3572     if (self.has_override_):
3573       out.putVarInt32(26)
3574       out.putVarInt32(self.override_.ByteSizePartial())
3575       self.override_.OutputPartial(out)
3576
3577   def TryMerge(self, d):
3578     while d.avail() > 0:
3579       tt = d.getVarInt32()
3580       if tt == 8:
3581         self.set_item_count(d.getVarInt32())
3582         continue
3583       if tt == 18:
3584         self.set_name_space(d.getPrefixedString())
3585         continue
3586       if tt == 26:
3587         length = d.getVarInt32()
3588         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
3589         d.skip(length)
3590         self.mutable_override().TryMerge(tmp)
3591         continue
3592
3593
3594       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
3595       d.skipData(tt)
3596
3597
3598   def __str__(self, prefix="", printElemNumber=0):
3599     res=""
3600     if self.has_item_count_: res+=prefix+("item_count: %s\n" % self.DebugFormatInt32(self.item_count_))
3601     if self.has_name_space_: res+=prefix+("name_space: %s\n" % self.DebugFormatString(self.name_space_))
3602     if self.has_override_:
3603       res+=prefix+"override <\n"
3604       res+=self.override_.__str__(prefix + "  ", printElemNumber)
3605       res+=prefix+">\n"
3606     return res
3607
3608
3609   def _BuildTagLookupTable(sparse, maxtag, default=None):
3610     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
3611
3612   kitem_count = 1
3613   kname_space = 2
3614   koverride = 3
3615
3616   _TEXT = _BuildTagLookupTable({
3617     0: "ErrorCode",
3618     1: "item_count",
3619     2: "name_space",
3620     3: "override",
3621   }, 3)
3622
3623   _TYPES = _BuildTagLookupTable({
3624     0: ProtocolBuffer.Encoder.NUMERIC,
3625     1: ProtocolBuffer.Encoder.NUMERIC,
3626     2: ProtocolBuffer.Encoder.STRING,
3627     3: ProtocolBuffer.Encoder.STRING,
3628   }, 3, ProtocolBuffer.Encoder.MAX_TYPE)
3629
3630
3631   _STYLE = """"""
3632   _STYLE_CONTENT_TYPE = """"""
3633   _PROTO_DESCRIPTOR_NAME = 'apphosting.MemcacheGrabTailRequest'
3634 class MemcacheGrabTailResponse_Item(ProtocolBuffer.ProtocolMessage):
3635   has_value_ = 0
3636   value_ = ""
3637   has_flags_ = 0
3638   flags_ = 0
3639
3640   def __init__(self, contents=None):
3641     if contents is not None: self.MergeFromString(contents)
3642
3643   def value(self): return self.value_
3644
3645   def set_value(self, x):
3646     self.has_value_ = 1
3647     self.value_ = x
3648
3649   def clear_value(self):
3650     if self.has_value_:
3651       self.has_value_ = 0
3652       self.value_ = ""
3653
3654   def has_value(self): return self.has_value_
3655
3656   def flags(self): return self.flags_
3657
3658   def set_flags(self, x):
3659     self.has_flags_ = 1
3660     self.flags_ = x
3661
3662   def clear_flags(self):
3663     if self.has_flags_:
3664       self.has_flags_ = 0
3665       self.flags_ = 0
3666
3667   def has_flags(self): return self.has_flags_
3668
3669
3670   def MergeFrom(self, x):
3671     assert x is not self
3672     if (x.has_value()): self.set_value(x.value())
3673     if (x.has_flags()): self.set_flags(x.flags())
3674
3675   def Equals(self, x):
3676     if x is self: return 1
3677     if self.has_value_ != x.has_value_: return 0
3678     if self.has_value_ and self.value_ != x.value_: return 0
3679     if self.has_flags_ != x.has_flags_: return 0
3680     if self.has_flags_ and self.flags_ != x.flags_: return 0
3681     return 1
3682
3683   def IsInitialized(self, debug_strs=None):
3684     initialized = 1
3685     if (not self.has_value_):
3686       initialized = 0
3687       if debug_strs is not None:
3688         debug_strs.append('Required field: value not set.')
3689     return initialized
3690
3691   def ByteSize(self):
3692     n = 0
3693     n += self.lengthString(len(self.value_))
3694     if (self.has_flags_): n += 5
3695     return n + 1
3696
3697   def ByteSizePartial(self):
3698     n = 0
3699     if (self.has_value_):
3700       n += 1
3701       n += self.lengthString(len(self.value_))
3702     if (self.has_flags_): n += 5
3703     return n
3704
3705   def Clear(self):
3706     self.clear_value()
3707     self.clear_flags()
3708
3709   def OutputUnchecked(self, out):
3710     out.putVarInt32(18)
3711     out.putPrefixedString(self.value_)
3712     if (self.has_flags_):
3713       out.putVarInt32(29)
3714       out.put32(self.flags_)
3715
3716   def OutputPartial(self, out):
3717     if (self.has_value_):
3718       out.putVarInt32(18)
3719       out.putPrefixedString(self.value_)
3720     if (self.has_flags_):
3721       out.putVarInt32(29)
3722       out.put32(self.flags_)
3723
3724   def TryMerge(self, d):
3725     while 1:
3726       tt = d.getVarInt32()
3727       if tt == 12: break
3728       if tt == 18:
3729         self.set_value(d.getPrefixedString())
3730         continue
3731       if tt == 29:
3732         self.set_flags(d.get32())
3733         continue
3734
3735
3736       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
3737       d.skipData(tt)
3738
3739
3740   def __str__(self, prefix="", printElemNumber=0):
3741     res=""
3742     if self.has_value_: res+=prefix+("value: %s\n" % self.DebugFormatString(self.value_))
3743     if self.has_flags_: res+=prefix+("flags: %s\n" % self.DebugFormatFixed32(self.flags_))
3744     return res
3745
3746 class MemcacheGrabTailResponse(ProtocolBuffer.ProtocolMessage):
3747
3748   def __init__(self, contents=None):
3749     self.item_ = []
3750     if contents is not None: self.MergeFromString(contents)
3751
3752   def item_size(self): return len(self.item_)
3753   def item_list(self): return self.item_
3754
3755   def item(self, i):
3756     return self.item_[i]
3757
3758   def mutable_item(self, i):
3759     return self.item_[i]
3760
3761   def add_item(self):
3762     x = MemcacheGrabTailResponse_Item()
3763     self.item_.append(x)
3764     return x
3765
3766   def clear_item(self):
3767     self.item_ = []
3768
3769   def MergeFrom(self, x):
3770     assert x is not self
3771     for i in xrange(x.item_size()): self.add_item().CopyFrom(x.item(i))
3772
3773   def Equals(self, x):
3774     if x is self: return 1
3775     if len(self.item_) != len(x.item_): return 0
3776     for e1, e2 in zip(self.item_, x.item_):
3777       if e1 != e2: return 0
3778     return 1
3779
3780   def IsInitialized(self, debug_strs=None):
3781     initialized = 1
3782     for p in self.item_:
3783       if not p.IsInitialized(debug_strs): initialized=0
3784     return initialized
3785
3786   def ByteSize(self):
3787     n = 0
3788     n += 2 * len(self.item_)
3789     for i in xrange(len(self.item_)): n += self.item_[i].ByteSize()
3790     return n
3791
3792   def ByteSizePartial(self):
3793     n = 0
3794     n += 2 * len(self.item_)
3795     for i in xrange(len(self.item_)): n += self.item_[i].ByteSizePartial()
3796     return n
3797
3798   def Clear(self):
3799     self.clear_item()
3800
3801   def OutputUnchecked(self, out):
3802     for i in xrange(len(self.item_)):
3803       out.putVarInt32(11)
3804       self.item_[i].OutputUnchecked(out)
3805       out.putVarInt32(12)
3806
3807   def OutputPartial(self, out):
3808     for i in xrange(len(self.item_)):
3809       out.putVarInt32(11)
3810       self.item_[i].OutputPartial(out)
3811       out.putVarInt32(12)
3812
3813   def TryMerge(self, d):
3814     while d.avail() > 0:
3815       tt = d.getVarInt32()
3816       if tt == 11:
3817         self.add_item().TryMerge(d)
3818         continue
3819
3820
3821       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
3822       d.skipData(tt)
3823
3824
3825   def __str__(self, prefix="", printElemNumber=0):
3826     res=""
3827     cnt=0
3828     for e in self.item_:
3829       elm=""
3830       if printElemNumber: elm="(%d)" % cnt
3831       res+=prefix+("Item%s {\n" % elm)
3832       res+=e.__str__(prefix + "  ", printElemNumber)
3833       res+=prefix+"}\n"
3834       cnt+=1
3835     return res
3836
3837
3838   def _BuildTagLookupTable(sparse, maxtag, default=None):
3839     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
3840
3841   kItemGroup = 1
3842   kItemvalue = 2
3843   kItemflags = 3
3844
3845   _TEXT = _BuildTagLookupTable({
3846     0: "ErrorCode",
3847     1: "Item",
3848     2: "value",
3849     3: "flags",
3850   }, 3)
3851
3852   _TYPES = _BuildTagLookupTable({
3853     0: ProtocolBuffer.Encoder.NUMERIC,
3854     1: ProtocolBuffer.Encoder.STARTGROUP,
3855     2: ProtocolBuffer.Encoder.STRING,
3856     3: ProtocolBuffer.Encoder.FLOAT,
3857   }, 3, ProtocolBuffer.Encoder.MAX_TYPE)
3858
3859
3860   _STYLE = """"""
3861   _STYLE_CONTENT_TYPE = """"""
3862   _PROTO_DESCRIPTOR_NAME = 'apphosting.MemcacheGrabTailResponse'
3863 if _extension_runtime:
3864   pass
3865
3866 __all__ = ['MemcacheServiceError','AppOverride','MemcacheGetRequest','MemcacheGetResponse','MemcacheGetResponse_Item','MemcacheSetRequest','MemcacheSetRequest_Item','MemcacheSetResponse','MemcacheDeleteRequest','MemcacheDeleteRequest_Item','MemcacheDeleteResponse','MemcacheIncrementRequest','MemcacheIncrementResponse','MemcacheBatchIncrementRequest','MemcacheBatchIncrementResponse','MemcacheFlushRequest','MemcacheFlushResponse','MemcacheStatsRequest','MergedNamespaceStats','MemcacheStatsResponse','MemcacheGrabTailRequest','MemcacheGrabTailResponse','MemcacheGrabTailResponse_Item']