thirdparty/google_appengine/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 from google.net.proto import ProtocolBuffer
  19 import array
  20 import dummy_thread as thread
  21
  22 __pychecker__ = """maxreturns=0 maxbranches=0 no-callinit
  23                    unusednames=printElemNumber,debug_strs no-special"""
  24
  25 from google.appengine.api.api_base_pb import *
  26 class MemcacheServiceError(ProtocolBuffer.ProtocolMessage):
  27
  28   OK           =    0
  29   UNSPECIFIED_ERROR =    1
  30
  31   _ErrorCode_NAMES = {
  32     0: "OK",
  33     1: "UNSPECIFIED_ERROR",
  34   }
  35
  36   def ErrorCode_Name(cls, x): return cls._ErrorCode_NAMES.get(x, "")
  37   ErrorCode_Name = classmethod(ErrorCode_Name)
  38
  39
  40   def __init__(self, contents=None):
  41     pass
  42     if contents is not None: self.MergeFromString(contents)
  43
  44
  45   def MergeFrom(self, x):
  46     assert x is not self
  47
  48   def Equals(self, x):
  49     if x is self: return 1
  50     return 1
  51
  52   def IsInitialized(self, debug_strs=None):
  53     initialized = 1
  54     return initialized
  55
  56   def ByteSize(self):
  57     n = 0
  58     return n + 0
  59
  60   def Clear(self):
  61     pass
  62
  63   def OutputUnchecked(self, out):
  64     pass
  65
  66   def TryMerge(self, d):
  67     while d.avail() > 0:
  68       tt = d.getVarInt32()
  69       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
  70       d.skipData(tt)
  71
  72
  73   def __str__(self, prefix="", printElemNumber=0):
  74     res=""
  75     return res
  76
  77
  78   _TEXT = (
  79    "ErrorCode",
  80   )
  81
  82   _TYPES = (
  83    ProtocolBuffer.Encoder.NUMERIC,
  84   )
  85
  86   _STYLE = """"""
  87   _STYLE_CONTENT_TYPE = """"""
  88 class MemcacheGetRequest(ProtocolBuffer.ProtocolMessage):
  89   has_name_space_ = 0
  90   name_space_ = ""
  91
  92   def __init__(self, contents=None):
  93     self.key_ = []
  94     if contents is not None: self.MergeFromString(contents)
  95
  96   def key_size(self): return len(self.key_)
  97   def key_list(self): return self.key_
  98
  99   def key(self, i):
 100     return self.key_[i]
 101
 102   def set_key(self, i, x):
 103     self.key_[i] = x
 104
 105   def add_key(self, x):
 106     self.key_.append(x)
 107
 108   def clear_key(self):
 109     self.key_ = []
 110
 111   def name_space(self): return self.name_space_
 112
 113   def set_name_space(self, x):
 114     self.has_name_space_ = 1
 115     self.name_space_ = x
 116
 117   def clear_name_space(self):
 118     if self.has_name_space_:
 119       self.has_name_space_ = 0
 120       self.name_space_ = ""
 121
 122   def has_name_space(self): return self.has_name_space_
 123
 124
 125   def MergeFrom(self, x):
 126     assert x is not self
 127     for i in xrange(x.key_size()): self.add_key(x.key(i))
 128     if (x.has_name_space()): self.set_name_space(x.name_space())
 129
 130   def Equals(self, x):
 131     if x is self: return 1
 132     if len(self.key_) != len(x.key_): return 0
 133     for e1, e2 in zip(self.key_, x.key_):
 134       if e1 != e2: return 0
 135     if self.has_name_space_ != x.has_name_space_: return 0
 136     if self.has_name_space_ and self.name_space_ != x.name_space_: return 0
 137     return 1
 138
 139   def IsInitialized(self, debug_strs=None):
 140     initialized = 1
 141     return initialized
 142
 143   def ByteSize(self):
 144     n = 0
 145     n += 1 * len(self.key_)
 146     for i in xrange(len(self.key_)): n += self.lengthString(len(self.key_[i]))
 147     if (self.has_name_space_): n += 1 + self.lengthString(len(self.name_space_))
 148     return n + 0
 149
 150   def Clear(self):
 151     self.clear_key()
 152     self.clear_name_space()
 153
 154   def OutputUnchecked(self, out):
 155     for i in xrange(len(self.key_)):
 156       out.putVarInt32(10)
 157       out.putPrefixedString(self.key_[i])
 158     if (self.has_name_space_):
 159       out.putVarInt32(18)
 160       out.putPrefixedString(self.name_space_)
 161
 162   def TryMerge(self, d):
 163     while d.avail() > 0:
 164       tt = d.getVarInt32()
 165       if tt == 10:
 166         self.add_key(d.getPrefixedString())
 167         continue
 168       if tt == 18:
 169         self.set_name_space(d.getPrefixedString())
 170         continue
 171       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 172       d.skipData(tt)
 173
 174
 175   def __str__(self, prefix="", printElemNumber=0):
 176     res=""
 177     cnt=0
 178     for e in self.key_:
 179       elm=""
 180       if printElemNumber: elm="(%d)" % cnt
 181       res+=prefix+("key%s: %s\n" % (elm, self.DebugFormatString(e)))
 182       cnt+=1
 183     if self.has_name_space_: res+=prefix+("name_space: %s\n" % self.DebugFormatString(self.name_space_))
 184     return res
 185
 186   kkey = 1
 187   kname_space = 2
 188
 189   _TEXT = (
 190    "ErrorCode",
 191    "key",
 192    "name_space",
 193   )
 194
 195   _TYPES = (
 196    ProtocolBuffer.Encoder.NUMERIC,
 197    ProtocolBuffer.Encoder.STRING,
 198
 199    ProtocolBuffer.Encoder.STRING,
 200
 201   )
 202
 203   _STYLE = """"""
 204   _STYLE_CONTENT_TYPE = """"""
 205 class MemcacheGetResponse_Item(ProtocolBuffer.ProtocolMessage):
 206   has_key_ = 0
 207   key_ = ""
 208   has_value_ = 0
 209   value_ = ""
 210   has_flags_ = 0
 211   flags_ = 0
 212
 213   def __init__(self, contents=None):
 214     if contents is not None: self.MergeFromString(contents)
 215
 216   def key(self): return self.key_
 217
 218   def set_key(self, x):
 219     self.has_key_ = 1
 220     self.key_ = x
 221
 222   def clear_key(self):
 223     if self.has_key_:
 224       self.has_key_ = 0
 225       self.key_ = ""
 226
 227   def has_key(self): return self.has_key_
 228
 229   def value(self): return self.value_
 230
 231   def set_value(self, x):
 232     self.has_value_ = 1
 233     self.value_ = x
 234
 235   def clear_value(self):
 236     if self.has_value_:
 237       self.has_value_ = 0
 238       self.value_ = ""
 239
 240   def has_value(self): return self.has_value_
 241
 242   def flags(self): return self.flags_
 243
 244   def set_flags(self, x):
 245     self.has_flags_ = 1
 246     self.flags_ = x
 247
 248   def clear_flags(self):
 249     if self.has_flags_:
 250       self.has_flags_ = 0
 251       self.flags_ = 0
 252
 253   def has_flags(self): return self.has_flags_
 254
 255
 256   def MergeFrom(self, x):
 257     assert x is not self
 258     if (x.has_key()): self.set_key(x.key())
 259     if (x.has_value()): self.set_value(x.value())
 260     if (x.has_flags()): self.set_flags(x.flags())
 261
 262   def Equals(self, x):
 263     if x is self: return 1
 264     if self.has_key_ != x.has_key_: return 0
 265     if self.has_key_ and self.key_ != x.key_: return 0
 266     if self.has_value_ != x.has_value_: return 0
 267     if self.has_value_ and self.value_ != x.value_: return 0
 268     if self.has_flags_ != x.has_flags_: return 0
 269     if self.has_flags_ and self.flags_ != x.flags_: return 0
 270     return 1
 271
 272   def IsInitialized(self, debug_strs=None):
 273     initialized = 1
 274     if (not self.has_key_):
 275       initialized = 0
 276       if debug_strs is not None:
 277         debug_strs.append('Required field: key not set.')
 278     if (not self.has_value_):
 279       initialized = 0
 280       if debug_strs is not None:
 281         debug_strs.append('Required field: value not set.')
 282     return initialized
 283
 284   def ByteSize(self):
 285     n = 0
 286     n += self.lengthString(len(self.key_))
 287     n += self.lengthString(len(self.value_))
 288     if (self.has_flags_): n += 5
 289     return n + 2
 290
 291   def Clear(self):
 292     self.clear_key()
 293     self.clear_value()
 294     self.clear_flags()
 295
 296   def OutputUnchecked(self, out):
 297     out.putVarInt32(18)
 298     out.putPrefixedString(self.key_)
 299     out.putVarInt32(26)
 300     out.putPrefixedString(self.value_)
 301     if (self.has_flags_):
 302       out.putVarInt32(37)
 303       out.put32(self.flags_)
 304
 305   def TryMerge(self, d):
 306     while 1:
 307       tt = d.getVarInt32()
 308       if tt == 12: break
 309       if tt == 18:
 310         self.set_key(d.getPrefixedString())
 311         continue
 312       if tt == 26:
 313         self.set_value(d.getPrefixedString())
 314         continue
 315       if tt == 37:
 316         self.set_flags(d.get32())
 317         continue
 318       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 319       d.skipData(tt)
 320
 321
 322   def __str__(self, prefix="", printElemNumber=0):
 323     res=""
 324     if self.has_key_: res+=prefix+("key: %s\n" % self.DebugFormatString(self.key_))
 325     if self.has_value_: res+=prefix+("value: %s\n" % self.DebugFormatString(self.value_))
 326     if self.has_flags_: res+=prefix+("flags: %s\n" % self.DebugFormatFixed32(self.flags_))
 327     return res
 328
 329 class MemcacheGetResponse(ProtocolBuffer.ProtocolMessage):
 330
 331   def __init__(self, contents=None):
 332     self.item_ = []
 333     if contents is not None: self.MergeFromString(contents)
 334
 335   def item_size(self): return len(self.item_)
 336   def item_list(self): return self.item_
 337
 338   def item(self, i):
 339     return self.item_[i]
 340
 341   def mutable_item(self, i):
 342     return self.item_[i]
 343
 344   def add_item(self):
 345     x = MemcacheGetResponse_Item()
 346     self.item_.append(x)
 347     return x
 348
 349   def clear_item(self):
 350     self.item_ = []
 351
 352   def MergeFrom(self, x):
 353     assert x is not self
 354     for i in xrange(x.item_size()): self.add_item().CopyFrom(x.item(i))
 355
 356   def Equals(self, x):
 357     if x is self: return 1
 358     if len(self.item_) != len(x.item_): return 0
 359     for e1, e2 in zip(self.item_, x.item_):
 360       if e1 != e2: return 0
 361     return 1
 362
 363   def IsInitialized(self, debug_strs=None):
 364     initialized = 1
 365     for p in self.item_:
 366       if not p.IsInitialized(debug_strs): initialized=0
 367     return initialized
 368
 369   def ByteSize(self):
 370     n = 0
 371     n += 2 * len(self.item_)
 372     for i in xrange(len(self.item_)): n += self.item_[i].ByteSize()
 373     return n + 0
 374
 375   def Clear(self):
 376     self.clear_item()
 377
 378   def OutputUnchecked(self, out):
 379     for i in xrange(len(self.item_)):
 380       out.putVarInt32(11)
 381       self.item_[i].OutputUnchecked(out)
 382       out.putVarInt32(12)
 383
 384   def TryMerge(self, d):
 385     while d.avail() > 0:
 386       tt = d.getVarInt32()
 387       if tt == 11:
 388         self.add_item().TryMerge(d)
 389         continue
 390       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 391       d.skipData(tt)
 392
 393
 394   def __str__(self, prefix="", printElemNumber=0):
 395     res=""
 396     cnt=0
 397     for e in self.item_:
 398       elm=""
 399       if printElemNumber: elm="(%d)" % cnt
 400       res+=prefix+("Item%s {\n" % elm)
 401       res+=e.__str__(prefix + "  ", printElemNumber)
 402       res+=prefix+"}\n"
 403       cnt+=1
 404     return res
 405
 406   kItemGroup = 1
 407   kItemkey = 2
 408   kItemvalue = 3
 409   kItemflags = 4
 410
 411   _TEXT = (
 412    "ErrorCode",
 413    "Item",
 414    "key",
 415    "value",
 416    "flags",
 417   )
 418
 419   _TYPES = (
 420    ProtocolBuffer.Encoder.NUMERIC,
 421    ProtocolBuffer.Encoder.STARTGROUP,
 422
 423    ProtocolBuffer.Encoder.STRING,
 424
 425    ProtocolBuffer.Encoder.STRING,
 426
 427    ProtocolBuffer.Encoder.FLOAT,
 428
 429   )
 430
 431   _STYLE = """"""
 432   _STYLE_CONTENT_TYPE = """"""
 433 class MemcacheSetRequest_Item(ProtocolBuffer.ProtocolMessage):
 434   has_key_ = 0
 435   key_ = ""
 436   has_value_ = 0
 437   value_ = ""
 438   has_flags_ = 0
 439   flags_ = 0
 440   has_set_policy_ = 0
 441   set_policy_ = 1
 442   has_expiration_time_ = 0
 443   expiration_time_ = 0
 444
 445   def __init__(self, contents=None):
 446     if contents is not None: self.MergeFromString(contents)
 447
 448   def key(self): return self.key_
 449
 450   def set_key(self, x):
 451     self.has_key_ = 1
 452     self.key_ = x
 453
 454   def clear_key(self):
 455     if self.has_key_:
 456       self.has_key_ = 0
 457       self.key_ = ""
 458
 459   def has_key(self): return self.has_key_
 460
 461   def value(self): return self.value_
 462
 463   def set_value(self, x):
 464     self.has_value_ = 1
 465     self.value_ = x
 466
 467   def clear_value(self):
 468     if self.has_value_:
 469       self.has_value_ = 0
 470       self.value_ = ""
 471
 472   def has_value(self): return self.has_value_
 473
 474   def flags(self): return self.flags_
 475
 476   def set_flags(self, x):
 477     self.has_flags_ = 1
 478     self.flags_ = x
 479
 480   def clear_flags(self):
 481     if self.has_flags_:
 482       self.has_flags_ = 0
 483       self.flags_ = 0
 484
 485   def has_flags(self): return self.has_flags_
 486
 487   def set_policy(self): return self.set_policy_
 488
 489   def set_set_policy(self, x):
 490     self.has_set_policy_ = 1
 491     self.set_policy_ = x
 492
 493   def clear_set_policy(self):
 494     if self.has_set_policy_:
 495       self.has_set_policy_ = 0
 496       self.set_policy_ = 1
 497
 498   def has_set_policy(self): return self.has_set_policy_
 499
 500   def expiration_time(self): return self.expiration_time_
 501
 502   def set_expiration_time(self, x):
 503     self.has_expiration_time_ = 1
 504     self.expiration_time_ = x
 505
 506   def clear_expiration_time(self):
 507     if self.has_expiration_time_:
 508       self.has_expiration_time_ = 0
 509       self.expiration_time_ = 0
 510
 511   def has_expiration_time(self): return self.has_expiration_time_
 512
 513
 514   def MergeFrom(self, x):
 515     assert x is not self
 516     if (x.has_key()): self.set_key(x.key())
 517     if (x.has_value()): self.set_value(x.value())
 518     if (x.has_flags()): self.set_flags(x.flags())
 519     if (x.has_set_policy()): self.set_set_policy(x.set_policy())
 520     if (x.has_expiration_time()): self.set_expiration_time(x.expiration_time())
 521
 522   def Equals(self, x):
 523     if x is self: return 1
 524     if self.has_key_ != x.has_key_: return 0
 525     if self.has_key_ and self.key_ != x.key_: return 0
 526     if self.has_value_ != x.has_value_: return 0
 527     if self.has_value_ and self.value_ != x.value_: return 0
 528     if self.has_flags_ != x.has_flags_: return 0
 529     if self.has_flags_ and self.flags_ != x.flags_: return 0
 530     if self.has_set_policy_ != x.has_set_policy_: return 0
 531     if self.has_set_policy_ and self.set_policy_ != x.set_policy_: return 0
 532     if self.has_expiration_time_ != x.has_expiration_time_: return 0
 533     if self.has_expiration_time_ and self.expiration_time_ != x.expiration_time_: return 0
 534     return 1
 535
 536   def IsInitialized(self, debug_strs=None):
 537     initialized = 1
 538     if (not self.has_key_):
 539       initialized = 0
 540       if debug_strs is not None:
 541         debug_strs.append('Required field: key not set.')
 542     if (not self.has_value_):
 543       initialized = 0
 544       if debug_strs is not None:
 545         debug_strs.append('Required field: value not set.')
 546     return initialized
 547
 548   def ByteSize(self):
 549     n = 0
 550     n += self.lengthString(len(self.key_))
 551     n += self.lengthString(len(self.value_))
 552     if (self.has_flags_): n += 5
 553     if (self.has_set_policy_): n += 1 + self.lengthVarInt64(self.set_policy_)
 554     if (self.has_expiration_time_): n += 5
 555     return n + 2
 556
 557   def Clear(self):
 558     self.clear_key()
 559     self.clear_value()
 560     self.clear_flags()
 561     self.clear_set_policy()
 562     self.clear_expiration_time()
 563
 564   def OutputUnchecked(self, out):
 565     out.putVarInt32(18)
 566     out.putPrefixedString(self.key_)
 567     out.putVarInt32(26)
 568     out.putPrefixedString(self.value_)
 569     if (self.has_flags_):
 570       out.putVarInt32(37)
 571       out.put32(self.flags_)
 572     if (self.has_set_policy_):
 573       out.putVarInt32(40)
 574       out.putVarInt32(self.set_policy_)
 575     if (self.has_expiration_time_):
 576       out.putVarInt32(53)
 577       out.put32(self.expiration_time_)
 578
 579   def TryMerge(self, d):
 580     while 1:
 581       tt = d.getVarInt32()
 582       if tt == 12: break
 583       if tt == 18:
 584         self.set_key(d.getPrefixedString())
 585         continue
 586       if tt == 26:
 587         self.set_value(d.getPrefixedString())
 588         continue
 589       if tt == 37:
 590         self.set_flags(d.get32())
 591         continue
 592       if tt == 40:
 593         self.set_set_policy(d.getVarInt32())
 594         continue
 595       if tt == 53:
 596         self.set_expiration_time(d.get32())
 597         continue
 598       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 599       d.skipData(tt)
 600
 601
 602   def __str__(self, prefix="", printElemNumber=0):
 603     res=""
 604     if self.has_key_: res+=prefix+("key: %s\n" % self.DebugFormatString(self.key_))
 605     if self.has_value_: res+=prefix+("value: %s\n" % self.DebugFormatString(self.value_))
 606     if self.has_flags_: res+=prefix+("flags: %s\n" % self.DebugFormatFixed32(self.flags_))
 607     if self.has_set_policy_: res+=prefix+("set_policy: %s\n" % self.DebugFormatInt32(self.set_policy_))
 608     if self.has_expiration_time_: res+=prefix+("expiration_time: %s\n" % self.DebugFormatFixed32(self.expiration_time_))
 609     return res
 610
 611 class MemcacheSetRequest(ProtocolBuffer.ProtocolMessage):
 612
 613   SET          =    1
 614   ADD          =    2
 615   REPLACE      =    3
 616
 617   _SetPolicy_NAMES = {
 618     1: "SET",
 619     2: "ADD",
 620     3: "REPLACE",
 621   }
 622
 623   def SetPolicy_Name(cls, x): return cls._SetPolicy_NAMES.get(x, "")
 624   SetPolicy_Name = classmethod(SetPolicy_Name)
 625
 626   has_name_space_ = 0
 627   name_space_ = ""
 628
 629   def __init__(self, contents=None):
 630     self.item_ = []
 631     if contents is not None: self.MergeFromString(contents)
 632
 633   def item_size(self): return len(self.item_)
 634   def item_list(self): return self.item_
 635
 636   def item(self, i):
 637     return self.item_[i]
 638
 639   def mutable_item(self, i):
 640     return self.item_[i]
 641
 642   def add_item(self):
 643     x = MemcacheSetRequest_Item()
 644     self.item_.append(x)
 645     return x
 646
 647   def clear_item(self):
 648     self.item_ = []
 649   def name_space(self): return self.name_space_
 650
 651   def set_name_space(self, x):
 652     self.has_name_space_ = 1
 653     self.name_space_ = x
 654
 655   def clear_name_space(self):
 656     if self.has_name_space_:
 657       self.has_name_space_ = 0
 658       self.name_space_ = ""
 659
 660   def has_name_space(self): return self.has_name_space_
 661
 662
 663   def MergeFrom(self, x):
 664     assert x is not self
 665     for i in xrange(x.item_size()): self.add_item().CopyFrom(x.item(i))
 666     if (x.has_name_space()): self.set_name_space(x.name_space())
 667
 668   def Equals(self, x):
 669     if x is self: return 1
 670     if len(self.item_) != len(x.item_): return 0
 671     for e1, e2 in zip(self.item_, x.item_):
 672       if e1 != e2: return 0
 673     if self.has_name_space_ != x.has_name_space_: return 0
 674     if self.has_name_space_ and self.name_space_ != x.name_space_: return 0
 675     return 1
 676
 677   def IsInitialized(self, debug_strs=None):
 678     initialized = 1
 679     for p in self.item_:
 680       if not p.IsInitialized(debug_strs): initialized=0
 681     return initialized
 682
 683   def ByteSize(self):
 684     n = 0
 685     n += 2 * len(self.item_)
 686     for i in xrange(len(self.item_)): n += self.item_[i].ByteSize()
 687     if (self.has_name_space_): n += 1 + self.lengthString(len(self.name_space_))
 688     return n + 0
 689
 690   def Clear(self):
 691     self.clear_item()
 692     self.clear_name_space()
 693
 694   def OutputUnchecked(self, out):
 695     for i in xrange(len(self.item_)):
 696       out.putVarInt32(11)
 697       self.item_[i].OutputUnchecked(out)
 698       out.putVarInt32(12)
 699     if (self.has_name_space_):
 700       out.putVarInt32(58)
 701       out.putPrefixedString(self.name_space_)
 702
 703   def TryMerge(self, d):
 704     while d.avail() > 0:
 705       tt = d.getVarInt32()
 706       if tt == 11:
 707         self.add_item().TryMerge(d)
 708         continue
 709       if tt == 58:
 710         self.set_name_space(d.getPrefixedString())
 711         continue
 712       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 713       d.skipData(tt)
 714
 715
 716   def __str__(self, prefix="", printElemNumber=0):
 717     res=""
 718     cnt=0
 719     for e in self.item_:
 720       elm=""
 721       if printElemNumber: elm="(%d)" % cnt
 722       res+=prefix+("Item%s {\n" % elm)
 723       res+=e.__str__(prefix + "  ", printElemNumber)
 724       res+=prefix+"}\n"
 725       cnt+=1
 726     if self.has_name_space_: res+=prefix+("name_space: %s\n" % self.DebugFormatString(self.name_space_))
 727     return res
 728
 729   kItemGroup = 1
 730   kItemkey = 2
 731   kItemvalue = 3
 732   kItemflags = 4
 733   kItemset_policy = 5
 734   kItemexpiration_time = 6
 735   kname_space = 7
 736
 737   _TEXT = (
 738    "ErrorCode",
 739    "Item",
 740    "key",
 741    "value",
 742    "flags",
 743    "set_policy",
 744    "expiration_time",
 745    "name_space",
 746   )
 747
 748   _TYPES = (
 749    ProtocolBuffer.Encoder.NUMERIC,
 750    ProtocolBuffer.Encoder.STARTGROUP,
 751
 752    ProtocolBuffer.Encoder.STRING,
 753
 754    ProtocolBuffer.Encoder.STRING,
 755
 756    ProtocolBuffer.Encoder.FLOAT,
 757
 758    ProtocolBuffer.Encoder.NUMERIC,
 759
 760    ProtocolBuffer.Encoder.FLOAT,
 761
 762    ProtocolBuffer.Encoder.STRING,
 763
 764   )
 765
 766   _STYLE = """"""
 767   _STYLE_CONTENT_TYPE = """"""
 768 class MemcacheSetResponse(ProtocolBuffer.ProtocolMessage):
 769
 770   STORED       =    1
 771   NOT_STORED   =    2
 772   ERROR        =    3
 773
 774   _SetStatusCode_NAMES = {
 775     1: "STORED",
 776     2: "NOT_STORED",
 777     3: "ERROR",
 778   }
 779
 780   def SetStatusCode_Name(cls, x): return cls._SetStatusCode_NAMES.get(x, "")
 781   SetStatusCode_Name = classmethod(SetStatusCode_Name)
 782
 783
 784   def __init__(self, contents=None):
 785     self.set_status_ = []
 786     if contents is not None: self.MergeFromString(contents)
 787
 788   def set_status_size(self): return len(self.set_status_)
 789   def set_status_list(self): return self.set_status_
 790
 791   def set_status(self, i):
 792     return self.set_status_[i]
 793
 794   def set_set_status(self, i, x):
 795     self.set_status_[i] = x
 796
 797   def add_set_status(self, x):
 798     self.set_status_.append(x)
 799
 800   def clear_set_status(self):
 801     self.set_status_ = []
 802
 803
 804   def MergeFrom(self, x):
 805     assert x is not self
 806     for i in xrange(x.set_status_size()): self.add_set_status(x.set_status(i))
 807
 808   def Equals(self, x):
 809     if x is self: return 1
 810     if len(self.set_status_) != len(x.set_status_): return 0
 811     for e1, e2 in zip(self.set_status_, x.set_status_):
 812       if e1 != e2: return 0
 813     return 1
 814
 815   def IsInitialized(self, debug_strs=None):
 816     initialized = 1
 817     return initialized
 818
 819   def ByteSize(self):
 820     n = 0
 821     n += 1 * len(self.set_status_)
 822     for i in xrange(len(self.set_status_)): n += self.lengthVarInt64(self.set_status_[i])
 823     return n + 0
 824
 825   def Clear(self):
 826     self.clear_set_status()
 827
 828   def OutputUnchecked(self, out):
 829     for i in xrange(len(self.set_status_)):
 830       out.putVarInt32(8)
 831       out.putVarInt32(self.set_status_[i])
 832
 833   def TryMerge(self, d):
 834     while d.avail() > 0:
 835       tt = d.getVarInt32()
 836       if tt == 8:
 837         self.add_set_status(d.getVarInt32())
 838         continue
 839       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 840       d.skipData(tt)
 841
 842
 843   def __str__(self, prefix="", printElemNumber=0):
 844     res=""
 845     cnt=0
 846     for e in self.set_status_:
 847       elm=""
 848       if printElemNumber: elm="(%d)" % cnt
 849       res+=prefix+("set_status%s: %s\n" % (elm, self.DebugFormatInt32(e)))
 850       cnt+=1
 851     return res
 852
 853   kset_status = 1
 854
 855   _TEXT = (
 856    "ErrorCode",
 857    "set_status",
 858   )
 859
 860   _TYPES = (
 861    ProtocolBuffer.Encoder.NUMERIC,
 862    ProtocolBuffer.Encoder.NUMERIC,
 863
 864   )
 865
 866   _STYLE = """"""
 867   _STYLE_CONTENT_TYPE = """"""
 868 class MemcacheDeleteRequest_Item(ProtocolBuffer.ProtocolMessage):
 869   has_key_ = 0
 870   key_ = ""
 871   has_delete_time_ = 0
 872   delete_time_ = 0
 873
 874   def __init__(self, contents=None):
 875     if contents is not None: self.MergeFromString(contents)
 876
 877   def key(self): return self.key_
 878
 879   def set_key(self, x):
 880     self.has_key_ = 1
 881     self.key_ = x
 882
 883   def clear_key(self):
 884     if self.has_key_:
 885       self.has_key_ = 0
 886       self.key_ = ""
 887
 888   def has_key(self): return self.has_key_
 889
 890   def delete_time(self): return self.delete_time_
 891
 892   def set_delete_time(self, x):
 893     self.has_delete_time_ = 1
 894     self.delete_time_ = x
 895
 896   def clear_delete_time(self):
 897     if self.has_delete_time_:
 898       self.has_delete_time_ = 0
 899       self.delete_time_ = 0
 900
 901   def has_delete_time(self): return self.has_delete_time_
 902
 903
 904   def MergeFrom(self, x):
 905     assert x is not self
 906     if (x.has_key()): self.set_key(x.key())
 907     if (x.has_delete_time()): self.set_delete_time(x.delete_time())
 908
 909   def Equals(self, x):
 910     if x is self: return 1
 911     if self.has_key_ != x.has_key_: return 0
 912     if self.has_key_ and self.key_ != x.key_: return 0
 913     if self.has_delete_time_ != x.has_delete_time_: return 0
 914     if self.has_delete_time_ and self.delete_time_ != x.delete_time_: return 0
 915     return 1
 916
 917   def IsInitialized(self, debug_strs=None):
 918     initialized = 1
 919     if (not self.has_key_):
 920       initialized = 0
 921       if debug_strs is not None:
 922         debug_strs.append('Required field: key not set.')
 923     return initialized
 924
 925   def ByteSize(self):
 926     n = 0
 927     n += self.lengthString(len(self.key_))
 928     if (self.has_delete_time_): n += 5
 929     return n + 1
 930
 931   def Clear(self):
 932     self.clear_key()
 933     self.clear_delete_time()
 934
 935   def OutputUnchecked(self, out):
 936     out.putVarInt32(18)
 937     out.putPrefixedString(self.key_)
 938     if (self.has_delete_time_):
 939       out.putVarInt32(29)
 940       out.put32(self.delete_time_)
 941
 942   def TryMerge(self, d):
 943     while 1:
 944       tt = d.getVarInt32()
 945       if tt == 12: break
 946       if tt == 18:
 947         self.set_key(d.getPrefixedString())
 948         continue
 949       if tt == 29:
 950         self.set_delete_time(d.get32())
 951         continue
 952       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 953       d.skipData(tt)
 954
 955
 956   def __str__(self, prefix="", printElemNumber=0):
 957     res=""
 958     if self.has_key_: res+=prefix+("key: %s\n" % self.DebugFormatString(self.key_))
 959     if self.has_delete_time_: res+=prefix+("delete_time: %s\n" % self.DebugFormatFixed32(self.delete_time_))
 960     return res
 961
 962 class MemcacheDeleteRequest(ProtocolBuffer.ProtocolMessage):
 963   has_name_space_ = 0
 964   name_space_ = ""
 965
 966   def __init__(self, contents=None):
 967     self.item_ = []
 968     if contents is not None: self.MergeFromString(contents)
 969
 970   def item_size(self): return len(self.item_)
 971   def item_list(self): return self.item_
 972
 973   def item(self, i):
 974     return self.item_[i]
 975
 976   def mutable_item(self, i):
 977     return self.item_[i]
 978
 979   def add_item(self):
 980     x = MemcacheDeleteRequest_Item()
 981     self.item_.append(x)
 982     return x
 983
 984   def clear_item(self):
 985     self.item_ = []
 986   def name_space(self): return self.name_space_
 987
 988   def set_name_space(self, x):
 989     self.has_name_space_ = 1
 990     self.name_space_ = x
 991
 992   def clear_name_space(self):
 993     if self.has_name_space_:
 994       self.has_name_space_ = 0
 995       self.name_space_ = ""
 996
 997   def has_name_space(self): return self.has_name_space_
 998
 999
1000   def MergeFrom(self, x):
1001     assert x is not self
1002     for i in xrange(x.item_size()): self.add_item().CopyFrom(x.item(i))
1003     if (x.has_name_space()): self.set_name_space(x.name_space())
1004
1005   def Equals(self, x):
1006     if x is self: return 1
1007     if len(self.item_) != len(x.item_): return 0
1008     for e1, e2 in zip(self.item_, x.item_):
1009       if e1 != e2: return 0
1010     if self.has_name_space_ != x.has_name_space_: return 0
1011     if self.has_name_space_ and self.name_space_ != x.name_space_: return 0
1012     return 1
1013
1014   def IsInitialized(self, debug_strs=None):
1015     initialized = 1
1016     for p in self.item_:
1017       if not p.IsInitialized(debug_strs): initialized=0
1018     return initialized
1019
1020   def ByteSize(self):
1021     n = 0
1022     n += 2 * len(self.item_)
1023     for i in xrange(len(self.item_)): n += self.item_[i].ByteSize()
1024     if (self.has_name_space_): n += 1 + self.lengthString(len(self.name_space_))
1025     return n + 0
1026
1027   def Clear(self):
1028     self.clear_item()
1029     self.clear_name_space()
1030
1031   def OutputUnchecked(self, out):
1032     for i in xrange(len(self.item_)):
1033       out.putVarInt32(11)
1034       self.item_[i].OutputUnchecked(out)
1035       out.putVarInt32(12)
1036     if (self.has_name_space_):
1037       out.putVarInt32(34)
1038       out.putPrefixedString(self.name_space_)
1039
1040   def TryMerge(self, d):
1041     while d.avail() > 0:
1042       tt = d.getVarInt32()
1043       if tt == 11:
1044         self.add_item().TryMerge(d)
1045         continue
1046       if tt == 34:
1047         self.set_name_space(d.getPrefixedString())
1048         continue
1049       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1050       d.skipData(tt)
1051
1052
1053   def __str__(self, prefix="", printElemNumber=0):
1054     res=""
1055     cnt=0
1056     for e in self.item_:
1057       elm=""
1058       if printElemNumber: elm="(%d)" % cnt
1059       res+=prefix+("Item%s {\n" % elm)
1060       res+=e.__str__(prefix + "  ", printElemNumber)
1061       res+=prefix+"}\n"
1062       cnt+=1
1063     if self.has_name_space_: res+=prefix+("name_space: %s\n" % self.DebugFormatString(self.name_space_))
1064     return res
1065
1066   kItemGroup = 1
1067   kItemkey = 2
1068   kItemdelete_time = 3
1069   kname_space = 4
1070
1071   _TEXT = (
1072    "ErrorCode",
1073    "Item",
1074    "key",
1075    "delete_time",
1076    "name_space",
1077   )
1078
1079   _TYPES = (
1080    ProtocolBuffer.Encoder.NUMERIC,
1081    ProtocolBuffer.Encoder.STARTGROUP,
1082
1083    ProtocolBuffer.Encoder.STRING,
1084
1085    ProtocolBuffer.Encoder.FLOAT,
1086
1087    ProtocolBuffer.Encoder.STRING,
1088
1089   )
1090
1091   _STYLE = """"""
1092   _STYLE_CONTENT_TYPE = """"""
1093 class MemcacheDeleteResponse(ProtocolBuffer.ProtocolMessage):
1094
1095   DELETED      =    1
1096   NOT_FOUND    =    2
1097
1098   _DeleteStatusCode_NAMES = {
1099     1: "DELETED",
1100     2: "NOT_FOUND",
1101   }
1102
1103   def DeleteStatusCode_Name(cls, x): return cls._DeleteStatusCode_NAMES.get(x, "")
1104   DeleteStatusCode_Name = classmethod(DeleteStatusCode_Name)
1105
1106
1107   def __init__(self, contents=None):
1108     self.delete_status_ = []
1109     if contents is not None: self.MergeFromString(contents)
1110
1111   def delete_status_size(self): return len(self.delete_status_)
1112   def delete_status_list(self): return self.delete_status_
1113
1114   def delete_status(self, i):
1115     return self.delete_status_[i]
1116
1117   def set_delete_status(self, i, x):
1118     self.delete_status_[i] = x
1119
1120   def add_delete_status(self, x):
1121     self.delete_status_.append(x)
1122
1123   def clear_delete_status(self):
1124     self.delete_status_ = []
1125
1126
1127   def MergeFrom(self, x):
1128     assert x is not self
1129     for i in xrange(x.delete_status_size()): self.add_delete_status(x.delete_status(i))
1130
1131   def Equals(self, x):
1132     if x is self: return 1
1133     if len(self.delete_status_) != len(x.delete_status_): return 0
1134     for e1, e2 in zip(self.delete_status_, x.delete_status_):
1135       if e1 != e2: return 0
1136     return 1
1137
1138   def IsInitialized(self, debug_strs=None):
1139     initialized = 1
1140     return initialized
1141
1142   def ByteSize(self):
1143     n = 0
1144     n += 1 * len(self.delete_status_)
1145     for i in xrange(len(self.delete_status_)): n += self.lengthVarInt64(self.delete_status_[i])
1146     return n + 0
1147
1148   def Clear(self):
1149     self.clear_delete_status()
1150
1151   def OutputUnchecked(self, out):
1152     for i in xrange(len(self.delete_status_)):
1153       out.putVarInt32(8)
1154       out.putVarInt32(self.delete_status_[i])
1155
1156   def TryMerge(self, d):
1157     while d.avail() > 0:
1158       tt = d.getVarInt32()
1159       if tt == 8:
1160         self.add_delete_status(d.getVarInt32())
1161         continue
1162       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1163       d.skipData(tt)
1164
1165
1166   def __str__(self, prefix="", printElemNumber=0):
1167     res=""
1168     cnt=0
1169     for e in self.delete_status_:
1170       elm=""
1171       if printElemNumber: elm="(%d)" % cnt
1172       res+=prefix+("delete_status%s: %s\n" % (elm, self.DebugFormatInt32(e)))
1173       cnt+=1
1174     return res
1175
1176   kdelete_status = 1
1177
1178   _TEXT = (
1179    "ErrorCode",
1180    "delete_status",
1181   )
1182
1183   _TYPES = (
1184    ProtocolBuffer.Encoder.NUMERIC,
1185    ProtocolBuffer.Encoder.NUMERIC,
1186
1187   )
1188
1189   _STYLE = """"""
1190   _STYLE_CONTENT_TYPE = """"""
1191 class MemcacheIncrementRequest(ProtocolBuffer.ProtocolMessage):
1192
1193   INCREMENT    =    1
1194   DECREMENT    =    2
1195
1196   _Direction_NAMES = {
1197     1: "INCREMENT",
1198     2: "DECREMENT",
1199   }
1200
1201   def Direction_Name(cls, x): return cls._Direction_NAMES.get(x, "")
1202   Direction_Name = classmethod(Direction_Name)
1203
1204   has_key_ = 0
1205   key_ = ""
1206   has_name_space_ = 0
1207   name_space_ = ""
1208   has_delta_ = 0
1209   delta_ = 1
1210   has_direction_ = 0
1211   direction_ = 1
1212
1213   def __init__(self, contents=None):
1214     if contents is not None: self.MergeFromString(contents)
1215
1216   def key(self): return self.key_
1217
1218   def set_key(self, x):
1219     self.has_key_ = 1
1220     self.key_ = x
1221
1222   def clear_key(self):
1223     if self.has_key_:
1224       self.has_key_ = 0
1225       self.key_ = ""
1226
1227   def has_key(self): return self.has_key_
1228
1229   def name_space(self): return self.name_space_
1230
1231   def set_name_space(self, x):
1232     self.has_name_space_ = 1
1233     self.name_space_ = x
1234
1235   def clear_name_space(self):
1236     if self.has_name_space_:
1237       self.has_name_space_ = 0
1238       self.name_space_ = ""
1239
1240   def has_name_space(self): return self.has_name_space_
1241
1242   def delta(self): return self.delta_
1243
1244   def set_delta(self, x):
1245     self.has_delta_ = 1
1246     self.delta_ = x
1247
1248   def clear_delta(self):
1249     if self.has_delta_:
1250       self.has_delta_ = 0
1251       self.delta_ = 1
1252
1253   def has_delta(self): return self.has_delta_
1254
1255   def direction(self): return self.direction_
1256
1257   def set_direction(self, x):
1258     self.has_direction_ = 1
1259     self.direction_ = x
1260
1261   def clear_direction(self):
1262     if self.has_direction_:
1263       self.has_direction_ = 0
1264       self.direction_ = 1
1265
1266   def has_direction(self): return self.has_direction_
1267
1268
1269   def MergeFrom(self, x):
1270     assert x is not self
1271     if (x.has_key()): self.set_key(x.key())
1272     if (x.has_name_space()): self.set_name_space(x.name_space())
1273     if (x.has_delta()): self.set_delta(x.delta())
1274     if (x.has_direction()): self.set_direction(x.direction())
1275
1276   def Equals(self, x):
1277     if x is self: return 1
1278     if self.has_key_ != x.has_key_: return 0
1279     if self.has_key_ and self.key_ != x.key_: return 0
1280     if self.has_name_space_ != x.has_name_space_: return 0
1281     if self.has_name_space_ and self.name_space_ != x.name_space_: return 0
1282     if self.has_delta_ != x.has_delta_: return 0
1283     if self.has_delta_ and self.delta_ != x.delta_: return 0
1284     if self.has_direction_ != x.has_direction_: return 0
1285     if self.has_direction_ and self.direction_ != x.direction_: return 0
1286     return 1
1287
1288   def IsInitialized(self, debug_strs=None):
1289     initialized = 1
1290     if (not self.has_key_):
1291       initialized = 0
1292       if debug_strs is not None:
1293         debug_strs.append('Required field: key not set.')
1294     return initialized
1295
1296   def ByteSize(self):
1297     n = 0
1298     n += self.lengthString(len(self.key_))
1299     if (self.has_name_space_): n += 1 + self.lengthString(len(self.name_space_))
1300     if (self.has_delta_): n += 1 + self.lengthVarInt64(self.delta_)
1301     if (self.has_direction_): n += 1 + self.lengthVarInt64(self.direction_)
1302     return n + 1
1303
1304   def Clear(self):
1305     self.clear_key()
1306     self.clear_name_space()
1307     self.clear_delta()
1308     self.clear_direction()
1309
1310   def OutputUnchecked(self, out):
1311     out.putVarInt32(10)
1312     out.putPrefixedString(self.key_)
1313     if (self.has_delta_):
1314       out.putVarInt32(16)
1315       out.putVarUint64(self.delta_)
1316     if (self.has_direction_):
1317       out.putVarInt32(24)
1318       out.putVarInt32(self.direction_)
1319     if (self.has_name_space_):
1320       out.putVarInt32(34)
1321       out.putPrefixedString(self.name_space_)
1322
1323   def TryMerge(self, d):
1324     while d.avail() > 0:
1325       tt = d.getVarInt32()
1326       if tt == 10:
1327         self.set_key(d.getPrefixedString())
1328         continue
1329       if tt == 16:
1330         self.set_delta(d.getVarUint64())
1331         continue
1332       if tt == 24:
1333         self.set_direction(d.getVarInt32())
1334         continue
1335       if tt == 34:
1336         self.set_name_space(d.getPrefixedString())
1337         continue
1338       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1339       d.skipData(tt)
1340
1341
1342   def __str__(self, prefix="", printElemNumber=0):
1343     res=""
1344     if self.has_key_: res+=prefix+("key: %s\n" % self.DebugFormatString(self.key_))
1345     if self.has_name_space_: res+=prefix+("name_space: %s\n" % self.DebugFormatString(self.name_space_))
1346     if self.has_delta_: res+=prefix+("delta: %s\n" % self.DebugFormatInt64(self.delta_))
1347     if self.has_direction_: res+=prefix+("direction: %s\n" % self.DebugFormatInt32(self.direction_))
1348     return res
1349
1350   kkey = 1
1351   kname_space = 4
1352   kdelta = 2
1353   kdirection = 3
1354
1355   _TEXT = (
1356    "ErrorCode",
1357    "key",
1358    "delta",
1359    "direction",
1360    "name_space",
1361   )
1362
1363   _TYPES = (
1364    ProtocolBuffer.Encoder.NUMERIC,
1365    ProtocolBuffer.Encoder.STRING,
1366
1367    ProtocolBuffer.Encoder.NUMERIC,
1368
1369    ProtocolBuffer.Encoder.NUMERIC,
1370
1371    ProtocolBuffer.Encoder.STRING,
1372
1373   )
1374
1375   _STYLE = """"""
1376   _STYLE_CONTENT_TYPE = """"""
1377 class MemcacheIncrementResponse(ProtocolBuffer.ProtocolMessage):
1378   has_new_value_ = 0
1379   new_value_ = 0
1380
1381   def __init__(self, contents=None):
1382     if contents is not None: self.MergeFromString(contents)
1383
1384   def new_value(self): return self.new_value_
1385
1386   def set_new_value(self, x):
1387     self.has_new_value_ = 1
1388     self.new_value_ = x
1389
1390   def clear_new_value(self):
1391     if self.has_new_value_:
1392       self.has_new_value_ = 0
1393       self.new_value_ = 0
1394
1395   def has_new_value(self): return self.has_new_value_
1396
1397
1398   def MergeFrom(self, x):
1399     assert x is not self
1400     if (x.has_new_value()): self.set_new_value(x.new_value())
1401
1402   def Equals(self, x):
1403     if x is self: return 1
1404     if self.has_new_value_ != x.has_new_value_: return 0
1405     if self.has_new_value_ and self.new_value_ != x.new_value_: return 0
1406     return 1
1407
1408   def IsInitialized(self, debug_strs=None):
1409     initialized = 1
1410     return initialized
1411
1412   def ByteSize(self):
1413     n = 0
1414     if (self.has_new_value_): n += 1 + self.lengthVarInt64(self.new_value_)
1415     return n + 0
1416
1417   def Clear(self):
1418     self.clear_new_value()
1419
1420   def OutputUnchecked(self, out):
1421     if (self.has_new_value_):
1422       out.putVarInt32(8)
1423       out.putVarUint64(self.new_value_)
1424
1425   def TryMerge(self, d):
1426     while d.avail() > 0:
1427       tt = d.getVarInt32()
1428       if tt == 8:
1429         self.set_new_value(d.getVarUint64())
1430         continue
1431       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1432       d.skipData(tt)
1433
1434
1435   def __str__(self, prefix="", printElemNumber=0):
1436     res=""
1437     if self.has_new_value_: res+=prefix+("new_value: %s\n" % self.DebugFormatInt64(self.new_value_))
1438     return res
1439
1440   knew_value = 1
1441
1442   _TEXT = (
1443    "ErrorCode",
1444    "new_value",
1445   )
1446
1447   _TYPES = (
1448    ProtocolBuffer.Encoder.NUMERIC,
1449    ProtocolBuffer.Encoder.NUMERIC,
1450
1451   )
1452
1453   _STYLE = """"""
1454   _STYLE_CONTENT_TYPE = """"""
1455 class MemcacheFlushRequest(ProtocolBuffer.ProtocolMessage):
1456
1457   def __init__(self, contents=None):
1458     pass
1459     if contents is not None: self.MergeFromString(contents)
1460
1461
1462   def MergeFrom(self, x):
1463     assert x is not self
1464
1465   def Equals(self, x):
1466     if x is self: return 1
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     return n + 0
1476
1477   def Clear(self):
1478     pass
1479
1480   def OutputUnchecked(self, out):
1481     pass
1482
1483   def TryMerge(self, d):
1484     while d.avail() > 0:
1485       tt = d.getVarInt32()
1486       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1487       d.skipData(tt)
1488
1489
1490   def __str__(self, prefix="", printElemNumber=0):
1491     res=""
1492     return res
1493
1494
1495   _TEXT = (
1496    "ErrorCode",
1497   )
1498
1499   _TYPES = (
1500    ProtocolBuffer.Encoder.NUMERIC,
1501   )
1502
1503   _STYLE = """"""
1504   _STYLE_CONTENT_TYPE = """"""
1505 class MemcacheFlushResponse(ProtocolBuffer.ProtocolMessage):
1506
1507   def __init__(self, contents=None):
1508     pass
1509     if contents is not None: self.MergeFromString(contents)
1510
1511
1512   def MergeFrom(self, x):
1513     assert x is not self
1514
1515   def Equals(self, x):
1516     if x is self: return 1
1517     return 1
1518
1519   def IsInitialized(self, debug_strs=None):
1520     initialized = 1
1521     return initialized
1522
1523   def ByteSize(self):
1524     n = 0
1525     return n + 0
1526
1527   def Clear(self):
1528     pass
1529
1530   def OutputUnchecked(self, out):
1531     pass
1532
1533   def TryMerge(self, d):
1534     while d.avail() > 0:
1535       tt = d.getVarInt32()
1536       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1537       d.skipData(tt)
1538
1539
1540   def __str__(self, prefix="", printElemNumber=0):
1541     res=""
1542     return res
1543
1544
1545   _TEXT = (
1546    "ErrorCode",
1547   )
1548
1549   _TYPES = (
1550    ProtocolBuffer.Encoder.NUMERIC,
1551   )
1552
1553   _STYLE = """"""
1554   _STYLE_CONTENT_TYPE = """"""
1555 class MemcacheStatsRequest(ProtocolBuffer.ProtocolMessage):
1556
1557   def __init__(self, contents=None):
1558     pass
1559     if contents is not None: self.MergeFromString(contents)
1560
1561
1562   def MergeFrom(self, x):
1563     assert x is not self
1564
1565   def Equals(self, x):
1566     if x is self: return 1
1567     return 1
1568
1569   def IsInitialized(self, debug_strs=None):
1570     initialized = 1
1571     return initialized
1572
1573   def ByteSize(self):
1574     n = 0
1575     return n + 0
1576
1577   def Clear(self):
1578     pass
1579
1580   def OutputUnchecked(self, out):
1581     pass
1582
1583   def TryMerge(self, d):
1584     while d.avail() > 0:
1585       tt = d.getVarInt32()
1586       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1587       d.skipData(tt)
1588
1589
1590   def __str__(self, prefix="", printElemNumber=0):
1591     res=""
1592     return res
1593
1594
1595   _TEXT = (
1596    "ErrorCode",
1597   )
1598
1599   _TYPES = (
1600    ProtocolBuffer.Encoder.NUMERIC,
1601   )
1602
1603   _STYLE = """"""
1604   _STYLE_CONTENT_TYPE = """"""
1605 class MergedNamespaceStats(ProtocolBuffer.ProtocolMessage):
1606   has_hits_ = 0
1607   hits_ = 0
1608   has_misses_ = 0
1609   misses_ = 0
1610   has_byte_hits_ = 0
1611   byte_hits_ = 0
1612   has_items_ = 0
1613   items_ = 0
1614   has_bytes_ = 0
1615   bytes_ = 0
1616   has_oldest_item_age_ = 0
1617   oldest_item_age_ = 0
1618
1619   def __init__(self, contents=None):
1620     if contents is not None: self.MergeFromString(contents)
1621
1622   def hits(self): return self.hits_
1623
1624   def set_hits(self, x):
1625     self.has_hits_ = 1
1626     self.hits_ = x
1627
1628   def clear_hits(self):
1629     if self.has_hits_:
1630       self.has_hits_ = 0
1631       self.hits_ = 0
1632
1633   def has_hits(self): return self.has_hits_
1634
1635   def misses(self): return self.misses_
1636
1637   def set_misses(self, x):
1638     self.has_misses_ = 1
1639     self.misses_ = x
1640
1641   def clear_misses(self):
1642     if self.has_misses_:
1643       self.has_misses_ = 0
1644       self.misses_ = 0
1645
1646   def has_misses(self): return self.has_misses_
1647
1648   def byte_hits(self): return self.byte_hits_
1649
1650   def set_byte_hits(self, x):
1651     self.has_byte_hits_ = 1
1652     self.byte_hits_ = x
1653
1654   def clear_byte_hits(self):
1655     if self.has_byte_hits_:
1656       self.has_byte_hits_ = 0
1657       self.byte_hits_ = 0
1658
1659   def has_byte_hits(self): return self.has_byte_hits_
1660
1661   def items(self): return self.items_
1662
1663   def set_items(self, x):
1664     self.has_items_ = 1
1665     self.items_ = x
1666
1667   def clear_items(self):
1668     if self.has_items_:
1669       self.has_items_ = 0
1670       self.items_ = 0
1671
1672   def has_items(self): return self.has_items_
1673
1674   def bytes(self): return self.bytes_
1675
1676   def set_bytes(self, x):
1677     self.has_bytes_ = 1
1678     self.bytes_ = x
1679
1680   def clear_bytes(self):
1681     if self.has_bytes_:
1682       self.has_bytes_ = 0
1683       self.bytes_ = 0
1684
1685   def has_bytes(self): return self.has_bytes_
1686
1687   def oldest_item_age(self): return self.oldest_item_age_
1688
1689   def set_oldest_item_age(self, x):
1690     self.has_oldest_item_age_ = 1
1691     self.oldest_item_age_ = x
1692
1693   def clear_oldest_item_age(self):
1694     if self.has_oldest_item_age_:
1695       self.has_oldest_item_age_ = 0
1696       self.oldest_item_age_ = 0
1697
1698   def has_oldest_item_age(self): return self.has_oldest_item_age_
1699
1700
1701   def MergeFrom(self, x):
1702     assert x is not self
1703     if (x.has_hits()): self.set_hits(x.hits())
1704     if (x.has_misses()): self.set_misses(x.misses())
1705     if (x.has_byte_hits()): self.set_byte_hits(x.byte_hits())
1706     if (x.has_items()): self.set_items(x.items())
1707     if (x.has_bytes()): self.set_bytes(x.bytes())
1708     if (x.has_oldest_item_age()): self.set_oldest_item_age(x.oldest_item_age())
1709
1710   def Equals(self, x):
1711     if x is self: return 1
1712     if self.has_hits_ != x.has_hits_: return 0
1713     if self.has_hits_ and self.hits_ != x.hits_: return 0
1714     if self.has_misses_ != x.has_misses_: return 0
1715     if self.has_misses_ and self.misses_ != x.misses_: return 0
1716     if self.has_byte_hits_ != x.has_byte_hits_: return 0
1717     if self.has_byte_hits_ and self.byte_hits_ != x.byte_hits_: return 0
1718     if self.has_items_ != x.has_items_: return 0
1719     if self.has_items_ and self.items_ != x.items_: return 0
1720     if self.has_bytes_ != x.has_bytes_: return 0
1721     if self.has_bytes_ and self.bytes_ != x.bytes_: return 0
1722     if self.has_oldest_item_age_ != x.has_oldest_item_age_: return 0
1723     if self.has_oldest_item_age_ and self.oldest_item_age_ != x.oldest_item_age_: return 0
1724     return 1
1725
1726   def IsInitialized(self, debug_strs=None):
1727     initialized = 1
1728     if (not self.has_hits_):
1729       initialized = 0
1730       if debug_strs is not None:
1731         debug_strs.append('Required field: hits not set.')
1732     if (not self.has_misses_):
1733       initialized = 0
1734       if debug_strs is not None:
1735         debug_strs.append('Required field: misses not set.')
1736     if (not self.has_byte_hits_):
1737       initialized = 0
1738       if debug_strs is not None:
1739         debug_strs.append('Required field: byte_hits not set.')
1740     if (not self.has_items_):
1741       initialized = 0
1742       if debug_strs is not None:
1743         debug_strs.append('Required field: items not set.')
1744     if (not self.has_bytes_):
1745       initialized = 0
1746       if debug_strs is not None:
1747         debug_strs.append('Required field: bytes not set.')
1748     if (not self.has_oldest_item_age_):
1749       initialized = 0
1750       if debug_strs is not None:
1751         debug_strs.append('Required field: oldest_item_age not set.')
1752     return initialized
1753
1754   def ByteSize(self):
1755     n = 0
1756     n += self.lengthVarInt64(self.hits_)
1757     n += self.lengthVarInt64(self.misses_)
1758     n += self.lengthVarInt64(self.byte_hits_)
1759     n += self.lengthVarInt64(self.items_)
1760     n += self.lengthVarInt64(self.bytes_)
1761     return n + 10
1762
1763   def Clear(self):
1764     self.clear_hits()
1765     self.clear_misses()
1766     self.clear_byte_hits()
1767     self.clear_items()
1768     self.clear_bytes()
1769     self.clear_oldest_item_age()
1770
1771   def OutputUnchecked(self, out):
1772     out.putVarInt32(8)
1773     out.putVarUint64(self.hits_)
1774     out.putVarInt32(16)
1775     out.putVarUint64(self.misses_)
1776     out.putVarInt32(24)
1777     out.putVarUint64(self.byte_hits_)
1778     out.putVarInt32(32)
1779     out.putVarUint64(self.items_)
1780     out.putVarInt32(40)
1781     out.putVarUint64(self.bytes_)
1782     out.putVarInt32(53)
1783     out.put32(self.oldest_item_age_)
1784
1785   def TryMerge(self, d):
1786     while d.avail() > 0:
1787       tt = d.getVarInt32()
1788       if tt == 8:
1789         self.set_hits(d.getVarUint64())
1790         continue
1791       if tt == 16:
1792         self.set_misses(d.getVarUint64())
1793         continue
1794       if tt == 24:
1795         self.set_byte_hits(d.getVarUint64())
1796         continue
1797       if tt == 32:
1798         self.set_items(d.getVarUint64())
1799         continue
1800       if tt == 40:
1801         self.set_bytes(d.getVarUint64())
1802         continue
1803       if tt == 53:
1804         self.set_oldest_item_age(d.get32())
1805         continue
1806       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1807       d.skipData(tt)
1808
1809
1810   def __str__(self, prefix="", printElemNumber=0):
1811     res=""
1812     if self.has_hits_: res+=prefix+("hits: %s\n" % self.DebugFormatInt64(self.hits_))
1813     if self.has_misses_: res+=prefix+("misses: %s\n" % self.DebugFormatInt64(self.misses_))
1814     if self.has_byte_hits_: res+=prefix+("byte_hits: %s\n" % self.DebugFormatInt64(self.byte_hits_))
1815     if self.has_items_: res+=prefix+("items: %s\n" % self.DebugFormatInt64(self.items_))
1816     if self.has_bytes_: res+=prefix+("bytes: %s\n" % self.DebugFormatInt64(self.bytes_))
1817     if self.has_oldest_item_age_: res+=prefix+("oldest_item_age: %s\n" % self.DebugFormatFixed32(self.oldest_item_age_))
1818     return res
1819
1820   khits = 1
1821   kmisses = 2
1822   kbyte_hits = 3
1823   kitems = 4
1824   kbytes = 5
1825   koldest_item_age = 6
1826
1827   _TEXT = (
1828    "ErrorCode",
1829    "hits",
1830    "misses",
1831    "byte_hits",
1832    "items",
1833    "bytes",
1834    "oldest_item_age",
1835   )
1836
1837   _TYPES = (
1838    ProtocolBuffer.Encoder.NUMERIC,
1839    ProtocolBuffer.Encoder.NUMERIC,
1840
1841    ProtocolBuffer.Encoder.NUMERIC,
1842
1843    ProtocolBuffer.Encoder.NUMERIC,
1844
1845    ProtocolBuffer.Encoder.NUMERIC,
1846
1847    ProtocolBuffer.Encoder.NUMERIC,
1848
1849    ProtocolBuffer.Encoder.FLOAT,
1850
1851   )
1852
1853   _STYLE = """"""
1854   _STYLE_CONTENT_TYPE = """"""
1855 class MemcacheStatsResponse(ProtocolBuffer.ProtocolMessage):
1856   has_stats_ = 0
1857   stats_ = None
1858
1859   def __init__(self, contents=None):
1860     self.lazy_init_lock_ = thread.allocate_lock()
1861     if contents is not None: self.MergeFromString(contents)
1862
1863   def stats(self):
1864     if self.stats_ is None:
1865       self.lazy_init_lock_.acquire()
1866       try:
1867         if self.stats_ is None: self.stats_ = MergedNamespaceStats()
1868       finally:
1869         self.lazy_init_lock_.release()
1870     return self.stats_
1871
1872   def mutable_stats(self): self.has_stats_ = 1; return self.stats()
1873
1874   def clear_stats(self):
1875     if self.has_stats_:
1876       self.has_stats_ = 0;
1877       if self.stats_ is not None: self.stats_.Clear()
1878
1879   def has_stats(self): return self.has_stats_
1880
1881
1882   def MergeFrom(self, x):
1883     assert x is not self
1884     if (x.has_stats()): self.mutable_stats().MergeFrom(x.stats())
1885
1886   def Equals(self, x):
1887     if x is self: return 1
1888     if self.has_stats_ != x.has_stats_: return 0
1889     if self.has_stats_ and self.stats_ != x.stats_: return 0
1890     return 1
1891
1892   def IsInitialized(self, debug_strs=None):
1893     initialized = 1
1894     if (self.has_stats_ and not self.stats_.IsInitialized(debug_strs)): initialized = 0
1895     return initialized
1896
1897   def ByteSize(self):
1898     n = 0
1899     if (self.has_stats_): n += 1 + self.lengthString(self.stats_.ByteSize())
1900     return n + 0
1901
1902   def Clear(self):
1903     self.clear_stats()
1904
1905   def OutputUnchecked(self, out):
1906     if (self.has_stats_):
1907       out.putVarInt32(10)
1908       out.putVarInt32(self.stats_.ByteSize())
1909       self.stats_.OutputUnchecked(out)
1910
1911   def TryMerge(self, d):
1912     while d.avail() > 0:
1913       tt = d.getVarInt32()
1914       if tt == 10:
1915         length = d.getVarInt32()
1916         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
1917         d.skip(length)
1918         self.mutable_stats().TryMerge(tmp)
1919         continue
1920       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1921       d.skipData(tt)
1922
1923
1924   def __str__(self, prefix="", printElemNumber=0):
1925     res=""
1926     if self.has_stats_:
1927       res+=prefix+"stats <\n"
1928       res+=self.stats_.__str__(prefix + "  ", printElemNumber)
1929       res+=prefix+">\n"
1930     return res
1931
1932   kstats = 1
1933
1934   _TEXT = (
1935    "ErrorCode",
1936    "stats",
1937   )
1938
1939   _TYPES = (
1940    ProtocolBuffer.Encoder.NUMERIC,
1941    ProtocolBuffer.Encoder.STRING,
1942
1943   )
1944
1945   _STYLE = """"""
1946   _STYLE_CONTENT_TYPE = """"""
1947
1948 __all__ = ['MemcacheServiceError','MemcacheGetRequest','MemcacheGetResponse','MemcacheGetResponse_Item','MemcacheSetRequest','MemcacheSetRequest_Item','MemcacheSetResponse','MemcacheDeleteRequest','MemcacheDeleteRequest_Item','MemcacheDeleteResponse','MemcacheIncrementRequest','MemcacheIncrementResponse','MemcacheFlushRequest','MemcacheFlushResponse','MemcacheStatsRequest','MergedNamespaceStats','MemcacheStatsResponse']