python/google/appengine/api/search/search_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 from google.appengine.datastore.document_pb import *
  35 import google.appengine.datastore.document_pb
  36 class SearchServiceError(ProtocolBuffer.ProtocolMessage):
  37
  38
  39   OK           =    0
  40   INVALID_REQUEST =    1
  41   TRANSIENT_ERROR =    2
  42   INTERNAL_ERROR =    3
  43   PERMISSION_DENIED =    4
  44   TIMEOUT      =    5
  45   CONCURRENT_TRANSACTION =    6
  46
  47   _ErrorCode_NAMES = {
  48     0: "OK",
  49     1: "INVALID_REQUEST",
  50     2: "TRANSIENT_ERROR",
  51     3: "INTERNAL_ERROR",
  52     4: "PERMISSION_DENIED",
  53     5: "TIMEOUT",
  54     6: "CONCURRENT_TRANSACTION",
  55   }
  56
  57   def ErrorCode_Name(cls, x): return cls._ErrorCode_NAMES.get(x, "")
  58   ErrorCode_Name = classmethod(ErrorCode_Name)
  59
  60
  61   def __init__(self, contents=None):
  62     pass
  63     if contents is not None: self.MergeFromString(contents)
  64
  65
  66   def MergeFrom(self, x):
  67     assert x is not self
  68
  69   def Equals(self, x):
  70     if x is self: return 1
  71     return 1
  72
  73   def IsInitialized(self, debug_strs=None):
  74     initialized = 1
  75     return initialized
  76
  77   def ByteSize(self):
  78     n = 0
  79     return n
  80
  81   def ByteSizePartial(self):
  82     n = 0
  83     return n
  84
  85   def Clear(self):
  86     pass
  87
  88   def OutputUnchecked(self, out):
  89     pass
  90
  91   def OutputPartial(self, out):
  92     pass
  93
  94   def TryMerge(self, d):
  95     while d.avail() > 0:
  96       tt = d.getVarInt32()
  97
  98
  99       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 100       d.skipData(tt)
 101
 102
 103   def __str__(self, prefix="", printElemNumber=0):
 104     res=""
 105     return res
 106
 107
 108   def _BuildTagLookupTable(sparse, maxtag, default=None):
 109     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
 110
 111
 112   _TEXT = _BuildTagLookupTable({
 113     0: "ErrorCode",
 114   }, 0)
 115
 116   _TYPES = _BuildTagLookupTable({
 117     0: ProtocolBuffer.Encoder.NUMERIC,
 118   }, 0, ProtocolBuffer.Encoder.MAX_TYPE)
 119
 120
 121   _STYLE = """"""
 122   _STYLE_CONTENT_TYPE = """"""
 123   _PROTO_DESCRIPTOR_NAME = 'apphosting.SearchServiceError'
 124 class RequestStatus(ProtocolBuffer.ProtocolMessage):
 125   has_code_ = 0
 126   code_ = 0
 127   has_error_detail_ = 0
 128   error_detail_ = ""
 129   has_canonical_code_ = 0
 130   canonical_code_ = 0
 131
 132   def __init__(self, contents=None):
 133     if contents is not None: self.MergeFromString(contents)
 134
 135   def code(self): return self.code_
 136
 137   def set_code(self, x):
 138     self.has_code_ = 1
 139     self.code_ = x
 140
 141   def clear_code(self):
 142     if self.has_code_:
 143       self.has_code_ = 0
 144       self.code_ = 0
 145
 146   def has_code(self): return self.has_code_
 147
 148   def error_detail(self): return self.error_detail_
 149
 150   def set_error_detail(self, x):
 151     self.has_error_detail_ = 1
 152     self.error_detail_ = x
 153
 154   def clear_error_detail(self):
 155     if self.has_error_detail_:
 156       self.has_error_detail_ = 0
 157       self.error_detail_ = ""
 158
 159   def has_error_detail(self): return self.has_error_detail_
 160
 161   def canonical_code(self): return self.canonical_code_
 162
 163   def set_canonical_code(self, x):
 164     self.has_canonical_code_ = 1
 165     self.canonical_code_ = x
 166
 167   def clear_canonical_code(self):
 168     if self.has_canonical_code_:
 169       self.has_canonical_code_ = 0
 170       self.canonical_code_ = 0
 171
 172   def has_canonical_code(self): return self.has_canonical_code_
 173
 174
 175   def MergeFrom(self, x):
 176     assert x is not self
 177     if (x.has_code()): self.set_code(x.code())
 178     if (x.has_error_detail()): self.set_error_detail(x.error_detail())
 179     if (x.has_canonical_code()): self.set_canonical_code(x.canonical_code())
 180
 181   def Equals(self, x):
 182     if x is self: return 1
 183     if self.has_code_ != x.has_code_: return 0
 184     if self.has_code_ and self.code_ != x.code_: return 0
 185     if self.has_error_detail_ != x.has_error_detail_: return 0
 186     if self.has_error_detail_ and self.error_detail_ != x.error_detail_: return 0
 187     if self.has_canonical_code_ != x.has_canonical_code_: return 0
 188     if self.has_canonical_code_ and self.canonical_code_ != x.canonical_code_: return 0
 189     return 1
 190
 191   def IsInitialized(self, debug_strs=None):
 192     initialized = 1
 193     if (not self.has_code_):
 194       initialized = 0
 195       if debug_strs is not None:
 196         debug_strs.append('Required field: code not set.')
 197     return initialized
 198
 199   def ByteSize(self):
 200     n = 0
 201     n += self.lengthVarInt64(self.code_)
 202     if (self.has_error_detail_): n += 1 + self.lengthString(len(self.error_detail_))
 203     if (self.has_canonical_code_): n += 1 + self.lengthVarInt64(self.canonical_code_)
 204     return n + 1
 205
 206   def ByteSizePartial(self):
 207     n = 0
 208     if (self.has_code_):
 209       n += 1
 210       n += self.lengthVarInt64(self.code_)
 211     if (self.has_error_detail_): n += 1 + self.lengthString(len(self.error_detail_))
 212     if (self.has_canonical_code_): n += 1 + self.lengthVarInt64(self.canonical_code_)
 213     return n
 214
 215   def Clear(self):
 216     self.clear_code()
 217     self.clear_error_detail()
 218     self.clear_canonical_code()
 219
 220   def OutputUnchecked(self, out):
 221     out.putVarInt32(8)
 222     out.putVarInt32(self.code_)
 223     if (self.has_error_detail_):
 224       out.putVarInt32(18)
 225       out.putPrefixedString(self.error_detail_)
 226     if (self.has_canonical_code_):
 227       out.putVarInt32(24)
 228       out.putVarInt32(self.canonical_code_)
 229
 230   def OutputPartial(self, out):
 231     if (self.has_code_):
 232       out.putVarInt32(8)
 233       out.putVarInt32(self.code_)
 234     if (self.has_error_detail_):
 235       out.putVarInt32(18)
 236       out.putPrefixedString(self.error_detail_)
 237     if (self.has_canonical_code_):
 238       out.putVarInt32(24)
 239       out.putVarInt32(self.canonical_code_)
 240
 241   def TryMerge(self, d):
 242     while d.avail() > 0:
 243       tt = d.getVarInt32()
 244       if tt == 8:
 245         self.set_code(d.getVarInt32())
 246         continue
 247       if tt == 18:
 248         self.set_error_detail(d.getPrefixedString())
 249         continue
 250       if tt == 24:
 251         self.set_canonical_code(d.getVarInt32())
 252         continue
 253
 254
 255       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 256       d.skipData(tt)
 257
 258
 259   def __str__(self, prefix="", printElemNumber=0):
 260     res=""
 261     if self.has_code_: res+=prefix+("code: %s\n" % self.DebugFormatInt32(self.code_))
 262     if self.has_error_detail_: res+=prefix+("error_detail: %s\n" % self.DebugFormatString(self.error_detail_))
 263     if self.has_canonical_code_: res+=prefix+("canonical_code: %s\n" % self.DebugFormatInt32(self.canonical_code_))
 264     return res
 265
 266
 267   def _BuildTagLookupTable(sparse, maxtag, default=None):
 268     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
 269
 270   kcode = 1
 271   kerror_detail = 2
 272   kcanonical_code = 3
 273
 274   _TEXT = _BuildTagLookupTable({
 275     0: "ErrorCode",
 276     1: "code",
 277     2: "error_detail",
 278     3: "canonical_code",
 279   }, 3)
 280
 281   _TYPES = _BuildTagLookupTable({
 282     0: ProtocolBuffer.Encoder.NUMERIC,
 283     1: ProtocolBuffer.Encoder.NUMERIC,
 284     2: ProtocolBuffer.Encoder.STRING,
 285     3: ProtocolBuffer.Encoder.NUMERIC,
 286   }, 3, ProtocolBuffer.Encoder.MAX_TYPE)
 287
 288
 289   _STYLE = """"""
 290   _STYLE_CONTENT_TYPE = """"""
 291   _PROTO_DESCRIPTOR_NAME = 'apphosting.RequestStatus'
 292 class IndexSpec(ProtocolBuffer.ProtocolMessage):
 293
 294
 295   GLOBAL       =    0
 296   PER_DOCUMENT =    1
 297
 298   _Consistency_NAMES = {
 299     0: "GLOBAL",
 300     1: "PER_DOCUMENT",
 301   }
 302
 303   def Consistency_Name(cls, x): return cls._Consistency_NAMES.get(x, "")
 304   Consistency_Name = classmethod(Consistency_Name)
 305
 306
 307
 308   SEARCH       =    0
 309   DATASTORE    =    1
 310   CLOUD_STORAGE =    2
 311
 312   _Source_NAMES = {
 313     0: "SEARCH",
 314     1: "DATASTORE",
 315     2: "CLOUD_STORAGE",
 316   }
 317
 318   def Source_Name(cls, x): return cls._Source_NAMES.get(x, "")
 319   Source_Name = classmethod(Source_Name)
 320
 321
 322
 323   PRIORITY     =    0
 324   BACKGROUND   =    1
 325
 326   _Mode_NAMES = {
 327     0: "PRIORITY",
 328     1: "BACKGROUND",
 329   }
 330
 331   def Mode_Name(cls, x): return cls._Mode_NAMES.get(x, "")
 332   Mode_Name = classmethod(Mode_Name)
 333
 334   has_name_ = 0
 335   name_ = ""
 336   has_consistency_ = 0
 337   consistency_ = 1
 338   has_namespace_ = 0
 339   namespace_ = ""
 340   has_version_ = 0
 341   version_ = 0
 342   has_source_ = 0
 343   source_ = 0
 344   has_mode_ = 0
 345   mode_ = 0
 346
 347   def __init__(self, contents=None):
 348     if contents is not None: self.MergeFromString(contents)
 349
 350   def name(self): return self.name_
 351
 352   def set_name(self, x):
 353     self.has_name_ = 1
 354     self.name_ = x
 355
 356   def clear_name(self):
 357     if self.has_name_:
 358       self.has_name_ = 0
 359       self.name_ = ""
 360
 361   def has_name(self): return self.has_name_
 362
 363   def consistency(self): return self.consistency_
 364
 365   def set_consistency(self, x):
 366     self.has_consistency_ = 1
 367     self.consistency_ = x
 368
 369   def clear_consistency(self):
 370     if self.has_consistency_:
 371       self.has_consistency_ = 0
 372       self.consistency_ = 1
 373
 374   def has_consistency(self): return self.has_consistency_
 375
 376   def namespace(self): return self.namespace_
 377
 378   def set_namespace(self, x):
 379     self.has_namespace_ = 1
 380     self.namespace_ = x
 381
 382   def clear_namespace(self):
 383     if self.has_namespace_:
 384       self.has_namespace_ = 0
 385       self.namespace_ = ""
 386
 387   def has_namespace(self): return self.has_namespace_
 388
 389   def version(self): return self.version_
 390
 391   def set_version(self, x):
 392     self.has_version_ = 1
 393     self.version_ = x
 394
 395   def clear_version(self):
 396     if self.has_version_:
 397       self.has_version_ = 0
 398       self.version_ = 0
 399
 400   def has_version(self): return self.has_version_
 401
 402   def source(self): return self.source_
 403
 404   def set_source(self, x):
 405     self.has_source_ = 1
 406     self.source_ = x
 407
 408   def clear_source(self):
 409     if self.has_source_:
 410       self.has_source_ = 0
 411       self.source_ = 0
 412
 413   def has_source(self): return self.has_source_
 414
 415   def mode(self): return self.mode_
 416
 417   def set_mode(self, x):
 418     self.has_mode_ = 1
 419     self.mode_ = x
 420
 421   def clear_mode(self):
 422     if self.has_mode_:
 423       self.has_mode_ = 0
 424       self.mode_ = 0
 425
 426   def has_mode(self): return self.has_mode_
 427
 428
 429   def MergeFrom(self, x):
 430     assert x is not self
 431     if (x.has_name()): self.set_name(x.name())
 432     if (x.has_consistency()): self.set_consistency(x.consistency())
 433     if (x.has_namespace()): self.set_namespace(x.namespace())
 434     if (x.has_version()): self.set_version(x.version())
 435     if (x.has_source()): self.set_source(x.source())
 436     if (x.has_mode()): self.set_mode(x.mode())
 437
 438   def Equals(self, x):
 439     if x is self: return 1
 440     if self.has_name_ != x.has_name_: return 0
 441     if self.has_name_ and self.name_ != x.name_: return 0
 442     if self.has_consistency_ != x.has_consistency_: return 0
 443     if self.has_consistency_ and self.consistency_ != x.consistency_: return 0
 444     if self.has_namespace_ != x.has_namespace_: return 0
 445     if self.has_namespace_ and self.namespace_ != x.namespace_: return 0
 446     if self.has_version_ != x.has_version_: return 0
 447     if self.has_version_ and self.version_ != x.version_: return 0
 448     if self.has_source_ != x.has_source_: return 0
 449     if self.has_source_ and self.source_ != x.source_: return 0
 450     if self.has_mode_ != x.has_mode_: return 0
 451     if self.has_mode_ and self.mode_ != x.mode_: return 0
 452     return 1
 453
 454   def IsInitialized(self, debug_strs=None):
 455     initialized = 1
 456     if (not self.has_name_):
 457       initialized = 0
 458       if debug_strs is not None:
 459         debug_strs.append('Required field: name not set.')
 460     return initialized
 461
 462   def ByteSize(self):
 463     n = 0
 464     n += self.lengthString(len(self.name_))
 465     if (self.has_consistency_): n += 1 + self.lengthVarInt64(self.consistency_)
 466     if (self.has_namespace_): n += 1 + self.lengthString(len(self.namespace_))
 467     if (self.has_version_): n += 1 + self.lengthVarInt64(self.version_)
 468     if (self.has_source_): n += 1 + self.lengthVarInt64(self.source_)
 469     if (self.has_mode_): n += 1 + self.lengthVarInt64(self.mode_)
 470     return n + 1
 471
 472   def ByteSizePartial(self):
 473     n = 0
 474     if (self.has_name_):
 475       n += 1
 476       n += self.lengthString(len(self.name_))
 477     if (self.has_consistency_): n += 1 + self.lengthVarInt64(self.consistency_)
 478     if (self.has_namespace_): n += 1 + self.lengthString(len(self.namespace_))
 479     if (self.has_version_): n += 1 + self.lengthVarInt64(self.version_)
 480     if (self.has_source_): n += 1 + self.lengthVarInt64(self.source_)
 481     if (self.has_mode_): n += 1 + self.lengthVarInt64(self.mode_)
 482     return n
 483
 484   def Clear(self):
 485     self.clear_name()
 486     self.clear_consistency()
 487     self.clear_namespace()
 488     self.clear_version()
 489     self.clear_source()
 490     self.clear_mode()
 491
 492   def OutputUnchecked(self, out):
 493     out.putVarInt32(10)
 494     out.putPrefixedString(self.name_)
 495     if (self.has_consistency_):
 496       out.putVarInt32(16)
 497       out.putVarInt32(self.consistency_)
 498     if (self.has_namespace_):
 499       out.putVarInt32(26)
 500       out.putPrefixedString(self.namespace_)
 501     if (self.has_version_):
 502       out.putVarInt32(32)
 503       out.putVarInt32(self.version_)
 504     if (self.has_source_):
 505       out.putVarInt32(40)
 506       out.putVarInt32(self.source_)
 507     if (self.has_mode_):
 508       out.putVarInt32(48)
 509       out.putVarInt32(self.mode_)
 510
 511   def OutputPartial(self, out):
 512     if (self.has_name_):
 513       out.putVarInt32(10)
 514       out.putPrefixedString(self.name_)
 515     if (self.has_consistency_):
 516       out.putVarInt32(16)
 517       out.putVarInt32(self.consistency_)
 518     if (self.has_namespace_):
 519       out.putVarInt32(26)
 520       out.putPrefixedString(self.namespace_)
 521     if (self.has_version_):
 522       out.putVarInt32(32)
 523       out.putVarInt32(self.version_)
 524     if (self.has_source_):
 525       out.putVarInt32(40)
 526       out.putVarInt32(self.source_)
 527     if (self.has_mode_):
 528       out.putVarInt32(48)
 529       out.putVarInt32(self.mode_)
 530
 531   def TryMerge(self, d):
 532     while d.avail() > 0:
 533       tt = d.getVarInt32()
 534       if tt == 10:
 535         self.set_name(d.getPrefixedString())
 536         continue
 537       if tt == 16:
 538         self.set_consistency(d.getVarInt32())
 539         continue
 540       if tt == 26:
 541         self.set_namespace(d.getPrefixedString())
 542         continue
 543       if tt == 32:
 544         self.set_version(d.getVarInt32())
 545         continue
 546       if tt == 40:
 547         self.set_source(d.getVarInt32())
 548         continue
 549       if tt == 48:
 550         self.set_mode(d.getVarInt32())
 551         continue
 552
 553
 554       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 555       d.skipData(tt)
 556
 557
 558   def __str__(self, prefix="", printElemNumber=0):
 559     res=""
 560     if self.has_name_: res+=prefix+("name: %s\n" % self.DebugFormatString(self.name_))
 561     if self.has_consistency_: res+=prefix+("consistency: %s\n" % self.DebugFormatInt32(self.consistency_))
 562     if self.has_namespace_: res+=prefix+("namespace: %s\n" % self.DebugFormatString(self.namespace_))
 563     if self.has_version_: res+=prefix+("version: %s\n" % self.DebugFormatInt32(self.version_))
 564     if self.has_source_: res+=prefix+("source: %s\n" % self.DebugFormatInt32(self.source_))
 565     if self.has_mode_: res+=prefix+("mode: %s\n" % self.DebugFormatInt32(self.mode_))
 566     return res
 567
 568
 569   def _BuildTagLookupTable(sparse, maxtag, default=None):
 570     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
 571
 572   kname = 1
 573   kconsistency = 2
 574   knamespace = 3
 575   kversion = 4
 576   ksource = 5
 577   kmode = 6
 578
 579   _TEXT = _BuildTagLookupTable({
 580     0: "ErrorCode",
 581     1: "name",
 582     2: "consistency",
 583     3: "namespace",
 584     4: "version",
 585     5: "source",
 586     6: "mode",
 587   }, 6)
 588
 589   _TYPES = _BuildTagLookupTable({
 590     0: ProtocolBuffer.Encoder.NUMERIC,
 591     1: ProtocolBuffer.Encoder.STRING,
 592     2: ProtocolBuffer.Encoder.NUMERIC,
 593     3: ProtocolBuffer.Encoder.STRING,
 594     4: ProtocolBuffer.Encoder.NUMERIC,
 595     5: ProtocolBuffer.Encoder.NUMERIC,
 596     6: ProtocolBuffer.Encoder.NUMERIC,
 597   }, 6, ProtocolBuffer.Encoder.MAX_TYPE)
 598
 599
 600   _STYLE = """"""
 601   _STYLE_CONTENT_TYPE = """"""
 602   _PROTO_DESCRIPTOR_NAME = 'apphosting.IndexSpec'
 603 class IndexMetadata_Storage(ProtocolBuffer.ProtocolMessage):
 604   has_amount_used_ = 0
 605   amount_used_ = 0
 606   has_limit_ = 0
 607   limit_ = 0
 608
 609   def __init__(self, contents=None):
 610     if contents is not None: self.MergeFromString(contents)
 611
 612   def amount_used(self): return self.amount_used_
 613
 614   def set_amount_used(self, x):
 615     self.has_amount_used_ = 1
 616     self.amount_used_ = x
 617
 618   def clear_amount_used(self):
 619     if self.has_amount_used_:
 620       self.has_amount_used_ = 0
 621       self.amount_used_ = 0
 622
 623   def has_amount_used(self): return self.has_amount_used_
 624
 625   def limit(self): return self.limit_
 626
 627   def set_limit(self, x):
 628     self.has_limit_ = 1
 629     self.limit_ = x
 630
 631   def clear_limit(self):
 632     if self.has_limit_:
 633       self.has_limit_ = 0
 634       self.limit_ = 0
 635
 636   def has_limit(self): return self.has_limit_
 637
 638
 639   def MergeFrom(self, x):
 640     assert x is not self
 641     if (x.has_amount_used()): self.set_amount_used(x.amount_used())
 642     if (x.has_limit()): self.set_limit(x.limit())
 643
 644   def Equals(self, x):
 645     if x is self: return 1
 646     if self.has_amount_used_ != x.has_amount_used_: return 0
 647     if self.has_amount_used_ and self.amount_used_ != x.amount_used_: return 0
 648     if self.has_limit_ != x.has_limit_: return 0
 649     if self.has_limit_ and self.limit_ != x.limit_: return 0
 650     return 1
 651
 652   def IsInitialized(self, debug_strs=None):
 653     initialized = 1
 654     return initialized
 655
 656   def ByteSize(self):
 657     n = 0
 658     if (self.has_amount_used_): n += 1 + self.lengthVarInt64(self.amount_used_)
 659     if (self.has_limit_): n += 1 + self.lengthVarInt64(self.limit_)
 660     return n
 661
 662   def ByteSizePartial(self):
 663     n = 0
 664     if (self.has_amount_used_): n += 1 + self.lengthVarInt64(self.amount_used_)
 665     if (self.has_limit_): n += 1 + self.lengthVarInt64(self.limit_)
 666     return n
 667
 668   def Clear(self):
 669     self.clear_amount_used()
 670     self.clear_limit()
 671
 672   def OutputUnchecked(self, out):
 673     if (self.has_amount_used_):
 674       out.putVarInt32(8)
 675       out.putVarInt64(self.amount_used_)
 676     if (self.has_limit_):
 677       out.putVarInt32(16)
 678       out.putVarInt64(self.limit_)
 679
 680   def OutputPartial(self, out):
 681     if (self.has_amount_used_):
 682       out.putVarInt32(8)
 683       out.putVarInt64(self.amount_used_)
 684     if (self.has_limit_):
 685       out.putVarInt32(16)
 686       out.putVarInt64(self.limit_)
 687
 688   def TryMerge(self, d):
 689     while d.avail() > 0:
 690       tt = d.getVarInt32()
 691       if tt == 8:
 692         self.set_amount_used(d.getVarInt64())
 693         continue
 694       if tt == 16:
 695         self.set_limit(d.getVarInt64())
 696         continue
 697
 698
 699       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 700       d.skipData(tt)
 701
 702
 703   def __str__(self, prefix="", printElemNumber=0):
 704     res=""
 705     if self.has_amount_used_: res+=prefix+("amount_used: %s\n" % self.DebugFormatInt64(self.amount_used_))
 706     if self.has_limit_: res+=prefix+("limit: %s\n" % self.DebugFormatInt64(self.limit_))
 707     return res
 708
 709
 710   def _BuildTagLookupTable(sparse, maxtag, default=None):
 711     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
 712
 713   kamount_used = 1
 714   klimit = 2
 715
 716   _TEXT = _BuildTagLookupTable({
 717     0: "ErrorCode",
 718     1: "amount_used",
 719     2: "limit",
 720   }, 2)
 721
 722   _TYPES = _BuildTagLookupTable({
 723     0: ProtocolBuffer.Encoder.NUMERIC,
 724     1: ProtocolBuffer.Encoder.NUMERIC,
 725     2: ProtocolBuffer.Encoder.NUMERIC,
 726   }, 2, ProtocolBuffer.Encoder.MAX_TYPE)
 727
 728
 729   _STYLE = """"""
 730   _STYLE_CONTENT_TYPE = """"""
 731   _PROTO_DESCRIPTOR_NAME = 'apphosting.IndexMetadata_Storage'
 732 class IndexMetadata(ProtocolBuffer.ProtocolMessage):
 733   has_index_spec_ = 0
 734   has_storage_ = 0
 735   storage_ = None
 736
 737   def __init__(self, contents=None):
 738     self.index_spec_ = IndexSpec()
 739     self.field_ = []
 740     self.lazy_init_lock_ = thread.allocate_lock()
 741     if contents is not None: self.MergeFromString(contents)
 742
 743   def index_spec(self): return self.index_spec_
 744
 745   def mutable_index_spec(self): self.has_index_spec_ = 1; return self.index_spec_
 746
 747   def clear_index_spec(self):self.has_index_spec_ = 0; self.index_spec_.Clear()
 748
 749   def has_index_spec(self): return self.has_index_spec_
 750
 751   def field_size(self): return len(self.field_)
 752   def field_list(self): return self.field_
 753
 754   def field(self, i):
 755     return self.field_[i]
 756
 757   def mutable_field(self, i):
 758     return self.field_[i]
 759
 760   def add_field(self):
 761     x = FieldTypes()
 762     self.field_.append(x)
 763     return x
 764
 765   def clear_field(self):
 766     self.field_ = []
 767   def storage(self):
 768     if self.storage_ is None:
 769       self.lazy_init_lock_.acquire()
 770       try:
 771         if self.storage_ is None: self.storage_ = IndexMetadata_Storage()
 772       finally:
 773         self.lazy_init_lock_.release()
 774     return self.storage_
 775
 776   def mutable_storage(self): self.has_storage_ = 1; return self.storage()
 777
 778   def clear_storage(self):
 779
 780     if self.has_storage_:
 781       self.has_storage_ = 0;
 782       if self.storage_ is not None: self.storage_.Clear()
 783
 784   def has_storage(self): return self.has_storage_
 785
 786
 787   def MergeFrom(self, x):
 788     assert x is not self
 789     if (x.has_index_spec()): self.mutable_index_spec().MergeFrom(x.index_spec())
 790     for i in xrange(x.field_size()): self.add_field().CopyFrom(x.field(i))
 791     if (x.has_storage()): self.mutable_storage().MergeFrom(x.storage())
 792
 793   def Equals(self, x):
 794     if x is self: return 1
 795     if self.has_index_spec_ != x.has_index_spec_: return 0
 796     if self.has_index_spec_ and self.index_spec_ != x.index_spec_: return 0
 797     if len(self.field_) != len(x.field_): return 0
 798     for e1, e2 in zip(self.field_, x.field_):
 799       if e1 != e2: return 0
 800     if self.has_storage_ != x.has_storage_: return 0
 801     if self.has_storage_ and self.storage_ != x.storage_: return 0
 802     return 1
 803
 804   def IsInitialized(self, debug_strs=None):
 805     initialized = 1
 806     if (not self.has_index_spec_):
 807       initialized = 0
 808       if debug_strs is not None:
 809         debug_strs.append('Required field: index_spec not set.')
 810     elif not self.index_spec_.IsInitialized(debug_strs): initialized = 0
 811     for p in self.field_:
 812       if not p.IsInitialized(debug_strs): initialized=0
 813     if (self.has_storage_ and not self.storage_.IsInitialized(debug_strs)): initialized = 0
 814     return initialized
 815
 816   def ByteSize(self):
 817     n = 0
 818     n += self.lengthString(self.index_spec_.ByteSize())
 819     n += 1 * len(self.field_)
 820     for i in xrange(len(self.field_)): n += self.lengthString(self.field_[i].ByteSize())
 821     if (self.has_storage_): n += 1 + self.lengthString(self.storage_.ByteSize())
 822     return n + 1
 823
 824   def ByteSizePartial(self):
 825     n = 0
 826     if (self.has_index_spec_):
 827       n += 1
 828       n += self.lengthString(self.index_spec_.ByteSizePartial())
 829     n += 1 * len(self.field_)
 830     for i in xrange(len(self.field_)): n += self.lengthString(self.field_[i].ByteSizePartial())
 831     if (self.has_storage_): n += 1 + self.lengthString(self.storage_.ByteSizePartial())
 832     return n
 833
 834   def Clear(self):
 835     self.clear_index_spec()
 836     self.clear_field()
 837     self.clear_storage()
 838
 839   def OutputUnchecked(self, out):
 840     out.putVarInt32(10)
 841     out.putVarInt32(self.index_spec_.ByteSize())
 842     self.index_spec_.OutputUnchecked(out)
 843     for i in xrange(len(self.field_)):
 844       out.putVarInt32(18)
 845       out.putVarInt32(self.field_[i].ByteSize())
 846       self.field_[i].OutputUnchecked(out)
 847     if (self.has_storage_):
 848       out.putVarInt32(26)
 849       out.putVarInt32(self.storage_.ByteSize())
 850       self.storage_.OutputUnchecked(out)
 851
 852   def OutputPartial(self, out):
 853     if (self.has_index_spec_):
 854       out.putVarInt32(10)
 855       out.putVarInt32(self.index_spec_.ByteSizePartial())
 856       self.index_spec_.OutputPartial(out)
 857     for i in xrange(len(self.field_)):
 858       out.putVarInt32(18)
 859       out.putVarInt32(self.field_[i].ByteSizePartial())
 860       self.field_[i].OutputPartial(out)
 861     if (self.has_storage_):
 862       out.putVarInt32(26)
 863       out.putVarInt32(self.storage_.ByteSizePartial())
 864       self.storage_.OutputPartial(out)
 865
 866   def TryMerge(self, d):
 867     while d.avail() > 0:
 868       tt = d.getVarInt32()
 869       if tt == 10:
 870         length = d.getVarInt32()
 871         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
 872         d.skip(length)
 873         self.mutable_index_spec().TryMerge(tmp)
 874         continue
 875       if tt == 18:
 876         length = d.getVarInt32()
 877         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
 878         d.skip(length)
 879         self.add_field().TryMerge(tmp)
 880         continue
 881       if tt == 26:
 882         length = d.getVarInt32()
 883         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
 884         d.skip(length)
 885         self.mutable_storage().TryMerge(tmp)
 886         continue
 887
 888
 889       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 890       d.skipData(tt)
 891
 892
 893   def __str__(self, prefix="", printElemNumber=0):
 894     res=""
 895     if self.has_index_spec_:
 896       res+=prefix+"index_spec <\n"
 897       res+=self.index_spec_.__str__(prefix + "  ", printElemNumber)
 898       res+=prefix+">\n"
 899     cnt=0
 900     for e in self.field_:
 901       elm=""
 902       if printElemNumber: elm="(%d)" % cnt
 903       res+=prefix+("field%s <\n" % elm)
 904       res+=e.__str__(prefix + "  ", printElemNumber)
 905       res+=prefix+">\n"
 906       cnt+=1
 907     if self.has_storage_:
 908       res+=prefix+"storage <\n"
 909       res+=self.storage_.__str__(prefix + "  ", printElemNumber)
 910       res+=prefix+">\n"
 911     return res
 912
 913
 914   def _BuildTagLookupTable(sparse, maxtag, default=None):
 915     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
 916
 917   kindex_spec = 1
 918   kfield = 2
 919   kstorage = 3
 920
 921   _TEXT = _BuildTagLookupTable({
 922     0: "ErrorCode",
 923     1: "index_spec",
 924     2: "field",
 925     3: "storage",
 926   }, 3)
 927
 928   _TYPES = _BuildTagLookupTable({
 929     0: ProtocolBuffer.Encoder.NUMERIC,
 930     1: ProtocolBuffer.Encoder.STRING,
 931     2: ProtocolBuffer.Encoder.STRING,
 932     3: ProtocolBuffer.Encoder.STRING,
 933   }, 3, ProtocolBuffer.Encoder.MAX_TYPE)
 934
 935
 936   _STYLE = """"""
 937   _STYLE_CONTENT_TYPE = """"""
 938   _PROTO_DESCRIPTOR_NAME = 'apphosting.IndexMetadata'
 939 class IndexDocumentParams(ProtocolBuffer.ProtocolMessage):
 940
 941
 942   SYNCHRONOUSLY =    0
 943   WHEN_CONVENIENT =    1
 944
 945   _Freshness_NAMES = {
 946     0: "SYNCHRONOUSLY",
 947     1: "WHEN_CONVENIENT",
 948   }
 949
 950   def Freshness_Name(cls, x): return cls._Freshness_NAMES.get(x, "")
 951   Freshness_Name = classmethod(Freshness_Name)
 952
 953   has_freshness_ = 0
 954   freshness_ = 0
 955   has_index_spec_ = 0
 956
 957   def __init__(self, contents=None):
 958     self.document_ = []
 959     self.index_spec_ = IndexSpec()
 960     if contents is not None: self.MergeFromString(contents)
 961
 962   def document_size(self): return len(self.document_)
 963   def document_list(self): return self.document_
 964
 965   def document(self, i):
 966     return self.document_[i]
 967
 968   def mutable_document(self, i):
 969     return self.document_[i]
 970
 971   def add_document(self):
 972     x = Document()
 973     self.document_.append(x)
 974     return x
 975
 976   def clear_document(self):
 977     self.document_ = []
 978   def freshness(self): return self.freshness_
 979
 980   def set_freshness(self, x):
 981     self.has_freshness_ = 1
 982     self.freshness_ = x
 983
 984   def clear_freshness(self):
 985     if self.has_freshness_:
 986       self.has_freshness_ = 0
 987       self.freshness_ = 0
 988
 989   def has_freshness(self): return self.has_freshness_
 990
 991   def index_spec(self): return self.index_spec_
 992
 993   def mutable_index_spec(self): self.has_index_spec_ = 1; return self.index_spec_
 994
 995   def clear_index_spec(self):self.has_index_spec_ = 0; self.index_spec_.Clear()
 996
 997   def has_index_spec(self): return self.has_index_spec_
 998
 999
1000   def MergeFrom(self, x):
1001     assert x is not self
1002     for i in xrange(x.document_size()): self.add_document().CopyFrom(x.document(i))
1003     if (x.has_freshness()): self.set_freshness(x.freshness())
1004     if (x.has_index_spec()): self.mutable_index_spec().MergeFrom(x.index_spec())
1005
1006   def Equals(self, x):
1007     if x is self: return 1
1008     if len(self.document_) != len(x.document_): return 0
1009     for e1, e2 in zip(self.document_, x.document_):
1010       if e1 != e2: return 0
1011     if self.has_freshness_ != x.has_freshness_: return 0
1012     if self.has_freshness_ and self.freshness_ != x.freshness_: return 0
1013     if self.has_index_spec_ != x.has_index_spec_: return 0
1014     if self.has_index_spec_ and self.index_spec_ != x.index_spec_: return 0
1015     return 1
1016
1017   def IsInitialized(self, debug_strs=None):
1018     initialized = 1
1019     for p in self.document_:
1020       if not p.IsInitialized(debug_strs): initialized=0
1021     if (not self.has_index_spec_):
1022       initialized = 0
1023       if debug_strs is not None:
1024         debug_strs.append('Required field: index_spec not set.')
1025     elif not self.index_spec_.IsInitialized(debug_strs): initialized = 0
1026     return initialized
1027
1028   def ByteSize(self):
1029     n = 0
1030     n += 1 * len(self.document_)
1031     for i in xrange(len(self.document_)): n += self.lengthString(self.document_[i].ByteSize())
1032     if (self.has_freshness_): n += 1 + self.lengthVarInt64(self.freshness_)
1033     n += self.lengthString(self.index_spec_.ByteSize())
1034     return n + 1
1035
1036   def ByteSizePartial(self):
1037     n = 0
1038     n += 1 * len(self.document_)
1039     for i in xrange(len(self.document_)): n += self.lengthString(self.document_[i].ByteSizePartial())
1040     if (self.has_freshness_): n += 1 + self.lengthVarInt64(self.freshness_)
1041     if (self.has_index_spec_):
1042       n += 1
1043       n += self.lengthString(self.index_spec_.ByteSizePartial())
1044     return n
1045
1046   def Clear(self):
1047     self.clear_document()
1048     self.clear_freshness()
1049     self.clear_index_spec()
1050
1051   def OutputUnchecked(self, out):
1052     for i in xrange(len(self.document_)):
1053       out.putVarInt32(10)
1054       out.putVarInt32(self.document_[i].ByteSize())
1055       self.document_[i].OutputUnchecked(out)
1056     if (self.has_freshness_):
1057       out.putVarInt32(16)
1058       out.putVarInt32(self.freshness_)
1059     out.putVarInt32(26)
1060     out.putVarInt32(self.index_spec_.ByteSize())
1061     self.index_spec_.OutputUnchecked(out)
1062
1063   def OutputPartial(self, out):
1064     for i in xrange(len(self.document_)):
1065       out.putVarInt32(10)
1066       out.putVarInt32(self.document_[i].ByteSizePartial())
1067       self.document_[i].OutputPartial(out)
1068     if (self.has_freshness_):
1069       out.putVarInt32(16)
1070       out.putVarInt32(self.freshness_)
1071     if (self.has_index_spec_):
1072       out.putVarInt32(26)
1073       out.putVarInt32(self.index_spec_.ByteSizePartial())
1074       self.index_spec_.OutputPartial(out)
1075
1076   def TryMerge(self, d):
1077     while d.avail() > 0:
1078       tt = d.getVarInt32()
1079       if tt == 10:
1080         length = d.getVarInt32()
1081         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
1082         d.skip(length)
1083         self.add_document().TryMerge(tmp)
1084         continue
1085       if tt == 16:
1086         self.set_freshness(d.getVarInt32())
1087         continue
1088       if tt == 26:
1089         length = d.getVarInt32()
1090         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
1091         d.skip(length)
1092         self.mutable_index_spec().TryMerge(tmp)
1093         continue
1094
1095
1096       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1097       d.skipData(tt)
1098
1099
1100   def __str__(self, prefix="", printElemNumber=0):
1101     res=""
1102     cnt=0
1103     for e in self.document_:
1104       elm=""
1105       if printElemNumber: elm="(%d)" % cnt
1106       res+=prefix+("document%s <\n" % elm)
1107       res+=e.__str__(prefix + "  ", printElemNumber)
1108       res+=prefix+">\n"
1109       cnt+=1
1110     if self.has_freshness_: res+=prefix+("freshness: %s\n" % self.DebugFormatInt32(self.freshness_))
1111     if self.has_index_spec_:
1112       res+=prefix+"index_spec <\n"
1113       res+=self.index_spec_.__str__(prefix + "  ", printElemNumber)
1114       res+=prefix+">\n"
1115     return res
1116
1117
1118   def _BuildTagLookupTable(sparse, maxtag, default=None):
1119     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
1120
1121   kdocument = 1
1122   kfreshness = 2
1123   kindex_spec = 3
1124
1125   _TEXT = _BuildTagLookupTable({
1126     0: "ErrorCode",
1127     1: "document",
1128     2: "freshness",
1129     3: "index_spec",
1130   }, 3)
1131
1132   _TYPES = _BuildTagLookupTable({
1133     0: ProtocolBuffer.Encoder.NUMERIC,
1134     1: ProtocolBuffer.Encoder.STRING,
1135     2: ProtocolBuffer.Encoder.NUMERIC,
1136     3: ProtocolBuffer.Encoder.STRING,
1137   }, 3, ProtocolBuffer.Encoder.MAX_TYPE)
1138
1139
1140   _STYLE = """"""
1141   _STYLE_CONTENT_TYPE = """"""
1142   _PROTO_DESCRIPTOR_NAME = 'apphosting.IndexDocumentParams'
1143 class IndexDocumentRequest(ProtocolBuffer.ProtocolMessage):
1144   has_params_ = 0
1145   has_app_id_ = 0
1146   app_id_ = ""
1147
1148   def __init__(self, contents=None):
1149     self.params_ = IndexDocumentParams()
1150     if contents is not None: self.MergeFromString(contents)
1151
1152   def params(self): return self.params_
1153
1154   def mutable_params(self): self.has_params_ = 1; return self.params_
1155
1156   def clear_params(self):self.has_params_ = 0; self.params_.Clear()
1157
1158   def has_params(self): return self.has_params_
1159
1160   def app_id(self): return self.app_id_
1161
1162   def set_app_id(self, x):
1163     self.has_app_id_ = 1
1164     self.app_id_ = x
1165
1166   def clear_app_id(self):
1167     if self.has_app_id_:
1168       self.has_app_id_ = 0
1169       self.app_id_ = ""
1170
1171   def has_app_id(self): return self.has_app_id_
1172
1173
1174   def MergeFrom(self, x):
1175     assert x is not self
1176     if (x.has_params()): self.mutable_params().MergeFrom(x.params())
1177     if (x.has_app_id()): self.set_app_id(x.app_id())
1178
1179   def Equals(self, x):
1180     if x is self: return 1
1181     if self.has_params_ != x.has_params_: return 0
1182     if self.has_params_ and self.params_ != x.params_: return 0
1183     if self.has_app_id_ != x.has_app_id_: return 0
1184     if self.has_app_id_ and self.app_id_ != x.app_id_: return 0
1185     return 1
1186
1187   def IsInitialized(self, debug_strs=None):
1188     initialized = 1
1189     if (not self.has_params_):
1190       initialized = 0
1191       if debug_strs is not None:
1192         debug_strs.append('Required field: params not set.')
1193     elif not self.params_.IsInitialized(debug_strs): initialized = 0
1194     return initialized
1195
1196   def ByteSize(self):
1197     n = 0
1198     n += self.lengthString(self.params_.ByteSize())
1199     if (self.has_app_id_): n += 1 + self.lengthString(len(self.app_id_))
1200     return n + 1
1201
1202   def ByteSizePartial(self):
1203     n = 0
1204     if (self.has_params_):
1205       n += 1
1206       n += self.lengthString(self.params_.ByteSizePartial())
1207     if (self.has_app_id_): n += 1 + self.lengthString(len(self.app_id_))
1208     return n
1209
1210   def Clear(self):
1211     self.clear_params()
1212     self.clear_app_id()
1213
1214   def OutputUnchecked(self, out):
1215     out.putVarInt32(10)
1216     out.putVarInt32(self.params_.ByteSize())
1217     self.params_.OutputUnchecked(out)
1218     if (self.has_app_id_):
1219       out.putVarInt32(26)
1220       out.putPrefixedString(self.app_id_)
1221
1222   def OutputPartial(self, out):
1223     if (self.has_params_):
1224       out.putVarInt32(10)
1225       out.putVarInt32(self.params_.ByteSizePartial())
1226       self.params_.OutputPartial(out)
1227     if (self.has_app_id_):
1228       out.putVarInt32(26)
1229       out.putPrefixedString(self.app_id_)
1230
1231   def TryMerge(self, d):
1232     while d.avail() > 0:
1233       tt = d.getVarInt32()
1234       if tt == 10:
1235         length = d.getVarInt32()
1236         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
1237         d.skip(length)
1238         self.mutable_params().TryMerge(tmp)
1239         continue
1240       if tt == 26:
1241         self.set_app_id(d.getPrefixedString())
1242         continue
1243
1244
1245       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1246       d.skipData(tt)
1247
1248
1249   def __str__(self, prefix="", printElemNumber=0):
1250     res=""
1251     if self.has_params_:
1252       res+=prefix+"params <\n"
1253       res+=self.params_.__str__(prefix + "  ", printElemNumber)
1254       res+=prefix+">\n"
1255     if self.has_app_id_: res+=prefix+("app_id: %s\n" % self.DebugFormatString(self.app_id_))
1256     return res
1257
1258
1259   def _BuildTagLookupTable(sparse, maxtag, default=None):
1260     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
1261
1262   kparams = 1
1263   kapp_id = 3
1264
1265   _TEXT = _BuildTagLookupTable({
1266     0: "ErrorCode",
1267     1: "params",
1268     3: "app_id",
1269   }, 3)
1270
1271   _TYPES = _BuildTagLookupTable({
1272     0: ProtocolBuffer.Encoder.NUMERIC,
1273     1: ProtocolBuffer.Encoder.STRING,
1274     3: ProtocolBuffer.Encoder.STRING,
1275   }, 3, ProtocolBuffer.Encoder.MAX_TYPE)
1276
1277
1278   _STYLE = """"""
1279   _STYLE_CONTENT_TYPE = """"""
1280   _PROTO_DESCRIPTOR_NAME = 'apphosting.IndexDocumentRequest'
1281 class IndexDocumentResponse(ProtocolBuffer.ProtocolMessage):
1282
1283   def __init__(self, contents=None):
1284     self.status_ = []
1285     self.doc_id_ = []
1286     if contents is not None: self.MergeFromString(contents)
1287
1288   def status_size(self): return len(self.status_)
1289   def status_list(self): return self.status_
1290
1291   def status(self, i):
1292     return self.status_[i]
1293
1294   def mutable_status(self, i):
1295     return self.status_[i]
1296
1297   def add_status(self):
1298     x = RequestStatus()
1299     self.status_.append(x)
1300     return x
1301
1302   def clear_status(self):
1303     self.status_ = []
1304   def doc_id_size(self): return len(self.doc_id_)
1305   def doc_id_list(self): return self.doc_id_
1306
1307   def doc_id(self, i):
1308     return self.doc_id_[i]
1309
1310   def set_doc_id(self, i, x):
1311     self.doc_id_[i] = x
1312
1313   def add_doc_id(self, x):
1314     self.doc_id_.append(x)
1315
1316   def clear_doc_id(self):
1317     self.doc_id_ = []
1318
1319
1320   def MergeFrom(self, x):
1321     assert x is not self
1322     for i in xrange(x.status_size()): self.add_status().CopyFrom(x.status(i))
1323     for i in xrange(x.doc_id_size()): self.add_doc_id(x.doc_id(i))
1324
1325   def Equals(self, x):
1326     if x is self: return 1
1327     if len(self.status_) != len(x.status_): return 0
1328     for e1, e2 in zip(self.status_, x.status_):
1329       if e1 != e2: return 0
1330     if len(self.doc_id_) != len(x.doc_id_): return 0
1331     for e1, e2 in zip(self.doc_id_, x.doc_id_):
1332       if e1 != e2: return 0
1333     return 1
1334
1335   def IsInitialized(self, debug_strs=None):
1336     initialized = 1
1337     for p in self.status_:
1338       if not p.IsInitialized(debug_strs): initialized=0
1339     return initialized
1340
1341   def ByteSize(self):
1342     n = 0
1343     n += 1 * len(self.status_)
1344     for i in xrange(len(self.status_)): n += self.lengthString(self.status_[i].ByteSize())
1345     n += 1 * len(self.doc_id_)
1346     for i in xrange(len(self.doc_id_)): n += self.lengthString(len(self.doc_id_[i]))
1347     return n
1348
1349   def ByteSizePartial(self):
1350     n = 0
1351     n += 1 * len(self.status_)
1352     for i in xrange(len(self.status_)): n += self.lengthString(self.status_[i].ByteSizePartial())
1353     n += 1 * len(self.doc_id_)
1354     for i in xrange(len(self.doc_id_)): n += self.lengthString(len(self.doc_id_[i]))
1355     return n
1356
1357   def Clear(self):
1358     self.clear_status()
1359     self.clear_doc_id()
1360
1361   def OutputUnchecked(self, out):
1362     for i in xrange(len(self.status_)):
1363       out.putVarInt32(10)
1364       out.putVarInt32(self.status_[i].ByteSize())
1365       self.status_[i].OutputUnchecked(out)
1366     for i in xrange(len(self.doc_id_)):
1367       out.putVarInt32(18)
1368       out.putPrefixedString(self.doc_id_[i])
1369
1370   def OutputPartial(self, out):
1371     for i in xrange(len(self.status_)):
1372       out.putVarInt32(10)
1373       out.putVarInt32(self.status_[i].ByteSizePartial())
1374       self.status_[i].OutputPartial(out)
1375     for i in xrange(len(self.doc_id_)):
1376       out.putVarInt32(18)
1377       out.putPrefixedString(self.doc_id_[i])
1378
1379   def TryMerge(self, d):
1380     while d.avail() > 0:
1381       tt = d.getVarInt32()
1382       if tt == 10:
1383         length = d.getVarInt32()
1384         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
1385         d.skip(length)
1386         self.add_status().TryMerge(tmp)
1387         continue
1388       if tt == 18:
1389         self.add_doc_id(d.getPrefixedString())
1390         continue
1391
1392
1393       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1394       d.skipData(tt)
1395
1396
1397   def __str__(self, prefix="", printElemNumber=0):
1398     res=""
1399     cnt=0
1400     for e in self.status_:
1401       elm=""
1402       if printElemNumber: elm="(%d)" % cnt
1403       res+=prefix+("status%s <\n" % elm)
1404       res+=e.__str__(prefix + "  ", printElemNumber)
1405       res+=prefix+">\n"
1406       cnt+=1
1407     cnt=0
1408     for e in self.doc_id_:
1409       elm=""
1410       if printElemNumber: elm="(%d)" % cnt
1411       res+=prefix+("doc_id%s: %s\n" % (elm, self.DebugFormatString(e)))
1412       cnt+=1
1413     return res
1414
1415
1416   def _BuildTagLookupTable(sparse, maxtag, default=None):
1417     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
1418
1419   kstatus = 1
1420   kdoc_id = 2
1421
1422   _TEXT = _BuildTagLookupTable({
1423     0: "ErrorCode",
1424     1: "status",
1425     2: "doc_id",
1426   }, 2)
1427
1428   _TYPES = _BuildTagLookupTable({
1429     0: ProtocolBuffer.Encoder.NUMERIC,
1430     1: ProtocolBuffer.Encoder.STRING,
1431     2: ProtocolBuffer.Encoder.STRING,
1432   }, 2, ProtocolBuffer.Encoder.MAX_TYPE)
1433
1434
1435   _STYLE = """"""
1436   _STYLE_CONTENT_TYPE = """"""
1437   _PROTO_DESCRIPTOR_NAME = 'apphosting.IndexDocumentResponse'
1438 class DeleteDocumentParams(ProtocolBuffer.ProtocolMessage):
1439   has_index_spec_ = 0
1440
1441   def __init__(self, contents=None):
1442     self.doc_id_ = []
1443     self.index_spec_ = IndexSpec()
1444     if contents is not None: self.MergeFromString(contents)
1445
1446   def doc_id_size(self): return len(self.doc_id_)
1447   def doc_id_list(self): return self.doc_id_
1448
1449   def doc_id(self, i):
1450     return self.doc_id_[i]
1451
1452   def set_doc_id(self, i, x):
1453     self.doc_id_[i] = x
1454
1455   def add_doc_id(self, x):
1456     self.doc_id_.append(x)
1457
1458   def clear_doc_id(self):
1459     self.doc_id_ = []
1460
1461   def index_spec(self): return self.index_spec_
1462
1463   def mutable_index_spec(self): self.has_index_spec_ = 1; return self.index_spec_
1464
1465   def clear_index_spec(self):self.has_index_spec_ = 0; self.index_spec_.Clear()
1466
1467   def has_index_spec(self): return self.has_index_spec_
1468
1469
1470   def MergeFrom(self, x):
1471     assert x is not self
1472     for i in xrange(x.doc_id_size()): self.add_doc_id(x.doc_id(i))
1473     if (x.has_index_spec()): self.mutable_index_spec().MergeFrom(x.index_spec())
1474
1475   def Equals(self, x):
1476     if x is self: return 1
1477     if len(self.doc_id_) != len(x.doc_id_): return 0
1478     for e1, e2 in zip(self.doc_id_, x.doc_id_):
1479       if e1 != e2: return 0
1480     if self.has_index_spec_ != x.has_index_spec_: return 0
1481     if self.has_index_spec_ and self.index_spec_ != x.index_spec_: return 0
1482     return 1
1483
1484   def IsInitialized(self, debug_strs=None):
1485     initialized = 1
1486     if (not self.has_index_spec_):
1487       initialized = 0
1488       if debug_strs is not None:
1489         debug_strs.append('Required field: index_spec not set.')
1490     elif not self.index_spec_.IsInitialized(debug_strs): initialized = 0
1491     return initialized
1492
1493   def ByteSize(self):
1494     n = 0
1495     n += 1 * len(self.doc_id_)
1496     for i in xrange(len(self.doc_id_)): n += self.lengthString(len(self.doc_id_[i]))
1497     n += self.lengthString(self.index_spec_.ByteSize())
1498     return n + 1
1499
1500   def ByteSizePartial(self):
1501     n = 0
1502     n += 1 * len(self.doc_id_)
1503     for i in xrange(len(self.doc_id_)): n += self.lengthString(len(self.doc_id_[i]))
1504     if (self.has_index_spec_):
1505       n += 1
1506       n += self.lengthString(self.index_spec_.ByteSizePartial())
1507     return n
1508
1509   def Clear(self):
1510     self.clear_doc_id()
1511     self.clear_index_spec()
1512
1513   def OutputUnchecked(self, out):
1514     for i in xrange(len(self.doc_id_)):
1515       out.putVarInt32(10)
1516       out.putPrefixedString(self.doc_id_[i])
1517     out.putVarInt32(18)
1518     out.putVarInt32(self.index_spec_.ByteSize())
1519     self.index_spec_.OutputUnchecked(out)
1520
1521   def OutputPartial(self, out):
1522     for i in xrange(len(self.doc_id_)):
1523       out.putVarInt32(10)
1524       out.putPrefixedString(self.doc_id_[i])
1525     if (self.has_index_spec_):
1526       out.putVarInt32(18)
1527       out.putVarInt32(self.index_spec_.ByteSizePartial())
1528       self.index_spec_.OutputPartial(out)
1529
1530   def TryMerge(self, d):
1531     while d.avail() > 0:
1532       tt = d.getVarInt32()
1533       if tt == 10:
1534         self.add_doc_id(d.getPrefixedString())
1535         continue
1536       if tt == 18:
1537         length = d.getVarInt32()
1538         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
1539         d.skip(length)
1540         self.mutable_index_spec().TryMerge(tmp)
1541         continue
1542
1543
1544       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1545       d.skipData(tt)
1546
1547
1548   def __str__(self, prefix="", printElemNumber=0):
1549     res=""
1550     cnt=0
1551     for e in self.doc_id_:
1552       elm=""
1553       if printElemNumber: elm="(%d)" % cnt
1554       res+=prefix+("doc_id%s: %s\n" % (elm, self.DebugFormatString(e)))
1555       cnt+=1
1556     if self.has_index_spec_:
1557       res+=prefix+"index_spec <\n"
1558       res+=self.index_spec_.__str__(prefix + "  ", printElemNumber)
1559       res+=prefix+">\n"
1560     return res
1561
1562
1563   def _BuildTagLookupTable(sparse, maxtag, default=None):
1564     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
1565
1566   kdoc_id = 1
1567   kindex_spec = 2
1568
1569   _TEXT = _BuildTagLookupTable({
1570     0: "ErrorCode",
1571     1: "doc_id",
1572     2: "index_spec",
1573   }, 2)
1574
1575   _TYPES = _BuildTagLookupTable({
1576     0: ProtocolBuffer.Encoder.NUMERIC,
1577     1: ProtocolBuffer.Encoder.STRING,
1578     2: ProtocolBuffer.Encoder.STRING,
1579   }, 2, ProtocolBuffer.Encoder.MAX_TYPE)
1580
1581
1582   _STYLE = """"""
1583   _STYLE_CONTENT_TYPE = """"""
1584   _PROTO_DESCRIPTOR_NAME = 'apphosting.DeleteDocumentParams'
1585 class DeleteDocumentRequest(ProtocolBuffer.ProtocolMessage):
1586   has_params_ = 0
1587   has_app_id_ = 0
1588   app_id_ = ""
1589
1590   def __init__(self, contents=None):
1591     self.params_ = DeleteDocumentParams()
1592     if contents is not None: self.MergeFromString(contents)
1593
1594   def params(self): return self.params_
1595
1596   def mutable_params(self): self.has_params_ = 1; return self.params_
1597
1598   def clear_params(self):self.has_params_ = 0; self.params_.Clear()
1599
1600   def has_params(self): return self.has_params_
1601
1602   def app_id(self): return self.app_id_
1603
1604   def set_app_id(self, x):
1605     self.has_app_id_ = 1
1606     self.app_id_ = x
1607
1608   def clear_app_id(self):
1609     if self.has_app_id_:
1610       self.has_app_id_ = 0
1611       self.app_id_ = ""
1612
1613   def has_app_id(self): return self.has_app_id_
1614
1615
1616   def MergeFrom(self, x):
1617     assert x is not self
1618     if (x.has_params()): self.mutable_params().MergeFrom(x.params())
1619     if (x.has_app_id()): self.set_app_id(x.app_id())
1620
1621   def Equals(self, x):
1622     if x is self: return 1
1623     if self.has_params_ != x.has_params_: return 0
1624     if self.has_params_ and self.params_ != x.params_: return 0
1625     if self.has_app_id_ != x.has_app_id_: return 0
1626     if self.has_app_id_ and self.app_id_ != x.app_id_: return 0
1627     return 1
1628
1629   def IsInitialized(self, debug_strs=None):
1630     initialized = 1
1631     if (not self.has_params_):
1632       initialized = 0
1633       if debug_strs is not None:
1634         debug_strs.append('Required field: params not set.')
1635     elif not self.params_.IsInitialized(debug_strs): initialized = 0
1636     return initialized
1637
1638   def ByteSize(self):
1639     n = 0
1640     n += self.lengthString(self.params_.ByteSize())
1641     if (self.has_app_id_): n += 1 + self.lengthString(len(self.app_id_))
1642     return n + 1
1643
1644   def ByteSizePartial(self):
1645     n = 0
1646     if (self.has_params_):
1647       n += 1
1648       n += self.lengthString(self.params_.ByteSizePartial())
1649     if (self.has_app_id_): n += 1 + self.lengthString(len(self.app_id_))
1650     return n
1651
1652   def Clear(self):
1653     self.clear_params()
1654     self.clear_app_id()
1655
1656   def OutputUnchecked(self, out):
1657     out.putVarInt32(10)
1658     out.putVarInt32(self.params_.ByteSize())
1659     self.params_.OutputUnchecked(out)
1660     if (self.has_app_id_):
1661       out.putVarInt32(26)
1662       out.putPrefixedString(self.app_id_)
1663
1664   def OutputPartial(self, out):
1665     if (self.has_params_):
1666       out.putVarInt32(10)
1667       out.putVarInt32(self.params_.ByteSizePartial())
1668       self.params_.OutputPartial(out)
1669     if (self.has_app_id_):
1670       out.putVarInt32(26)
1671       out.putPrefixedString(self.app_id_)
1672
1673   def TryMerge(self, d):
1674     while d.avail() > 0:
1675       tt = d.getVarInt32()
1676       if tt == 10:
1677         length = d.getVarInt32()
1678         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
1679         d.skip(length)
1680         self.mutable_params().TryMerge(tmp)
1681         continue
1682       if tt == 26:
1683         self.set_app_id(d.getPrefixedString())
1684         continue
1685
1686
1687       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1688       d.skipData(tt)
1689
1690
1691   def __str__(self, prefix="", printElemNumber=0):
1692     res=""
1693     if self.has_params_:
1694       res+=prefix+"params <\n"
1695       res+=self.params_.__str__(prefix + "  ", printElemNumber)
1696       res+=prefix+">\n"
1697     if self.has_app_id_: res+=prefix+("app_id: %s\n" % self.DebugFormatString(self.app_id_))
1698     return res
1699
1700
1701   def _BuildTagLookupTable(sparse, maxtag, default=None):
1702     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
1703
1704   kparams = 1
1705   kapp_id = 3
1706
1707   _TEXT = _BuildTagLookupTable({
1708     0: "ErrorCode",
1709     1: "params",
1710     3: "app_id",
1711   }, 3)
1712
1713   _TYPES = _BuildTagLookupTable({
1714     0: ProtocolBuffer.Encoder.NUMERIC,
1715     1: ProtocolBuffer.Encoder.STRING,
1716     3: ProtocolBuffer.Encoder.STRING,
1717   }, 3, ProtocolBuffer.Encoder.MAX_TYPE)
1718
1719
1720   _STYLE = """"""
1721   _STYLE_CONTENT_TYPE = """"""
1722   _PROTO_DESCRIPTOR_NAME = 'apphosting.DeleteDocumentRequest'
1723 class DeleteDocumentResponse(ProtocolBuffer.ProtocolMessage):
1724
1725   def __init__(self, contents=None):
1726     self.status_ = []
1727     if contents is not None: self.MergeFromString(contents)
1728
1729   def status_size(self): return len(self.status_)
1730   def status_list(self): return self.status_
1731
1732   def status(self, i):
1733     return self.status_[i]
1734
1735   def mutable_status(self, i):
1736     return self.status_[i]
1737
1738   def add_status(self):
1739     x = RequestStatus()
1740     self.status_.append(x)
1741     return x
1742
1743   def clear_status(self):
1744     self.status_ = []
1745
1746   def MergeFrom(self, x):
1747     assert x is not self
1748     for i in xrange(x.status_size()): self.add_status().CopyFrom(x.status(i))
1749
1750   def Equals(self, x):
1751     if x is self: return 1
1752     if len(self.status_) != len(x.status_): return 0
1753     for e1, e2 in zip(self.status_, x.status_):
1754       if e1 != e2: return 0
1755     return 1
1756
1757   def IsInitialized(self, debug_strs=None):
1758     initialized = 1
1759     for p in self.status_:
1760       if not p.IsInitialized(debug_strs): initialized=0
1761     return initialized
1762
1763   def ByteSize(self):
1764     n = 0
1765     n += 1 * len(self.status_)
1766     for i in xrange(len(self.status_)): n += self.lengthString(self.status_[i].ByteSize())
1767     return n
1768
1769   def ByteSizePartial(self):
1770     n = 0
1771     n += 1 * len(self.status_)
1772     for i in xrange(len(self.status_)): n += self.lengthString(self.status_[i].ByteSizePartial())
1773     return n
1774
1775   def Clear(self):
1776     self.clear_status()
1777
1778   def OutputUnchecked(self, out):
1779     for i in xrange(len(self.status_)):
1780       out.putVarInt32(10)
1781       out.putVarInt32(self.status_[i].ByteSize())
1782       self.status_[i].OutputUnchecked(out)
1783
1784   def OutputPartial(self, out):
1785     for i in xrange(len(self.status_)):
1786       out.putVarInt32(10)
1787       out.putVarInt32(self.status_[i].ByteSizePartial())
1788       self.status_[i].OutputPartial(out)
1789
1790   def TryMerge(self, d):
1791     while d.avail() > 0:
1792       tt = d.getVarInt32()
1793       if tt == 10:
1794         length = d.getVarInt32()
1795         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
1796         d.skip(length)
1797         self.add_status().TryMerge(tmp)
1798         continue
1799
1800
1801       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1802       d.skipData(tt)
1803
1804
1805   def __str__(self, prefix="", printElemNumber=0):
1806     res=""
1807     cnt=0
1808     for e in self.status_:
1809       elm=""
1810       if printElemNumber: elm="(%d)" % cnt
1811       res+=prefix+("status%s <\n" % elm)
1812       res+=e.__str__(prefix + "  ", printElemNumber)
1813       res+=prefix+">\n"
1814       cnt+=1
1815     return res
1816
1817
1818   def _BuildTagLookupTable(sparse, maxtag, default=None):
1819     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
1820
1821   kstatus = 1
1822
1823   _TEXT = _BuildTagLookupTable({
1824     0: "ErrorCode",
1825     1: "status",
1826   }, 1)
1827
1828   _TYPES = _BuildTagLookupTable({
1829     0: ProtocolBuffer.Encoder.NUMERIC,
1830     1: ProtocolBuffer.Encoder.STRING,
1831   }, 1, ProtocolBuffer.Encoder.MAX_TYPE)
1832
1833
1834   _STYLE = """"""
1835   _STYLE_CONTENT_TYPE = """"""
1836   _PROTO_DESCRIPTOR_NAME = 'apphosting.DeleteDocumentResponse'
1837 class ListDocumentsParams(ProtocolBuffer.ProtocolMessage):
1838   has_index_spec_ = 0
1839   has_start_doc_id_ = 0
1840   start_doc_id_ = ""
1841   has_include_start_doc_ = 0
1842   include_start_doc_ = 1
1843   has_limit_ = 0
1844   limit_ = 100
1845   has_keys_only_ = 0
1846   keys_only_ = 0
1847
1848   def __init__(self, contents=None):
1849     self.index_spec_ = IndexSpec()
1850     if contents is not None: self.MergeFromString(contents)
1851
1852   def index_spec(self): return self.index_spec_
1853
1854   def mutable_index_spec(self): self.has_index_spec_ = 1; return self.index_spec_
1855
1856   def clear_index_spec(self):self.has_index_spec_ = 0; self.index_spec_.Clear()
1857
1858   def has_index_spec(self): return self.has_index_spec_
1859
1860   def start_doc_id(self): return self.start_doc_id_
1861
1862   def set_start_doc_id(self, x):
1863     self.has_start_doc_id_ = 1
1864     self.start_doc_id_ = x
1865
1866   def clear_start_doc_id(self):
1867     if self.has_start_doc_id_:
1868       self.has_start_doc_id_ = 0
1869       self.start_doc_id_ = ""
1870
1871   def has_start_doc_id(self): return self.has_start_doc_id_
1872
1873   def include_start_doc(self): return self.include_start_doc_
1874
1875   def set_include_start_doc(self, x):
1876     self.has_include_start_doc_ = 1
1877     self.include_start_doc_ = x
1878
1879   def clear_include_start_doc(self):
1880     if self.has_include_start_doc_:
1881       self.has_include_start_doc_ = 0
1882       self.include_start_doc_ = 1
1883
1884   def has_include_start_doc(self): return self.has_include_start_doc_
1885
1886   def limit(self): return self.limit_
1887
1888   def set_limit(self, x):
1889     self.has_limit_ = 1
1890     self.limit_ = x
1891
1892   def clear_limit(self):
1893     if self.has_limit_:
1894       self.has_limit_ = 0
1895       self.limit_ = 100
1896
1897   def has_limit(self): return self.has_limit_
1898
1899   def keys_only(self): return self.keys_only_
1900
1901   def set_keys_only(self, x):
1902     self.has_keys_only_ = 1
1903     self.keys_only_ = x
1904
1905   def clear_keys_only(self):
1906     if self.has_keys_only_:
1907       self.has_keys_only_ = 0
1908       self.keys_only_ = 0
1909
1910   def has_keys_only(self): return self.has_keys_only_
1911
1912
1913   def MergeFrom(self, x):
1914     assert x is not self
1915     if (x.has_index_spec()): self.mutable_index_spec().MergeFrom(x.index_spec())
1916     if (x.has_start_doc_id()): self.set_start_doc_id(x.start_doc_id())
1917     if (x.has_include_start_doc()): self.set_include_start_doc(x.include_start_doc())
1918     if (x.has_limit()): self.set_limit(x.limit())
1919     if (x.has_keys_only()): self.set_keys_only(x.keys_only())
1920
1921   def Equals(self, x):
1922     if x is self: return 1
1923     if self.has_index_spec_ != x.has_index_spec_: return 0
1924     if self.has_index_spec_ and self.index_spec_ != x.index_spec_: return 0
1925     if self.has_start_doc_id_ != x.has_start_doc_id_: return 0
1926     if self.has_start_doc_id_ and self.start_doc_id_ != x.start_doc_id_: return 0
1927     if self.has_include_start_doc_ != x.has_include_start_doc_: return 0
1928     if self.has_include_start_doc_ and self.include_start_doc_ != x.include_start_doc_: return 0
1929     if self.has_limit_ != x.has_limit_: return 0
1930     if self.has_limit_ and self.limit_ != x.limit_: return 0
1931     if self.has_keys_only_ != x.has_keys_only_: return 0
1932     if self.has_keys_only_ and self.keys_only_ != x.keys_only_: return 0
1933     return 1
1934
1935   def IsInitialized(self, debug_strs=None):
1936     initialized = 1
1937     if (not self.has_index_spec_):
1938       initialized = 0
1939       if debug_strs is not None:
1940         debug_strs.append('Required field: index_spec not set.')
1941     elif not self.index_spec_.IsInitialized(debug_strs): initialized = 0
1942     return initialized
1943
1944   def ByteSize(self):
1945     n = 0
1946     n += self.lengthString(self.index_spec_.ByteSize())
1947     if (self.has_start_doc_id_): n += 1 + self.lengthString(len(self.start_doc_id_))
1948     if (self.has_include_start_doc_): n += 2
1949     if (self.has_limit_): n += 1 + self.lengthVarInt64(self.limit_)
1950     if (self.has_keys_only_): n += 2
1951     return n + 1
1952
1953   def ByteSizePartial(self):
1954     n = 0
1955     if (self.has_index_spec_):
1956       n += 1
1957       n += self.lengthString(self.index_spec_.ByteSizePartial())
1958     if (self.has_start_doc_id_): n += 1 + self.lengthString(len(self.start_doc_id_))
1959     if (self.has_include_start_doc_): n += 2
1960     if (self.has_limit_): n += 1 + self.lengthVarInt64(self.limit_)
1961     if (self.has_keys_only_): n += 2
1962     return n
1963
1964   def Clear(self):
1965     self.clear_index_spec()
1966     self.clear_start_doc_id()
1967     self.clear_include_start_doc()
1968     self.clear_limit()
1969     self.clear_keys_only()
1970
1971   def OutputUnchecked(self, out):
1972     out.putVarInt32(10)
1973     out.putVarInt32(self.index_spec_.ByteSize())
1974     self.index_spec_.OutputUnchecked(out)
1975     if (self.has_start_doc_id_):
1976       out.putVarInt32(18)
1977       out.putPrefixedString(self.start_doc_id_)
1978     if (self.has_include_start_doc_):
1979       out.putVarInt32(24)
1980       out.putBoolean(self.include_start_doc_)
1981     if (self.has_limit_):
1982       out.putVarInt32(32)
1983       out.putVarInt32(self.limit_)
1984     if (self.has_keys_only_):
1985       out.putVarInt32(40)
1986       out.putBoolean(self.keys_only_)
1987
1988   def OutputPartial(self, out):
1989     if (self.has_index_spec_):
1990       out.putVarInt32(10)
1991       out.putVarInt32(self.index_spec_.ByteSizePartial())
1992       self.index_spec_.OutputPartial(out)
1993     if (self.has_start_doc_id_):
1994       out.putVarInt32(18)
1995       out.putPrefixedString(self.start_doc_id_)
1996     if (self.has_include_start_doc_):
1997       out.putVarInt32(24)
1998       out.putBoolean(self.include_start_doc_)
1999     if (self.has_limit_):
2000       out.putVarInt32(32)
2001       out.putVarInt32(self.limit_)
2002     if (self.has_keys_only_):
2003       out.putVarInt32(40)
2004       out.putBoolean(self.keys_only_)
2005
2006   def TryMerge(self, d):
2007     while d.avail() > 0:
2008       tt = d.getVarInt32()
2009       if tt == 10:
2010         length = d.getVarInt32()
2011         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
2012         d.skip(length)
2013         self.mutable_index_spec().TryMerge(tmp)
2014         continue
2015       if tt == 18:
2016         self.set_start_doc_id(d.getPrefixedString())
2017         continue
2018       if tt == 24:
2019         self.set_include_start_doc(d.getBoolean())
2020         continue
2021       if tt == 32:
2022         self.set_limit(d.getVarInt32())
2023         continue
2024       if tt == 40:
2025         self.set_keys_only(d.getBoolean())
2026         continue
2027
2028
2029       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
2030       d.skipData(tt)
2031
2032
2033   def __str__(self, prefix="", printElemNumber=0):
2034     res=""
2035     if self.has_index_spec_:
2036       res+=prefix+"index_spec <\n"
2037       res+=self.index_spec_.__str__(prefix + "  ", printElemNumber)
2038       res+=prefix+">\n"
2039     if self.has_start_doc_id_: res+=prefix+("start_doc_id: %s\n" % self.DebugFormatString(self.start_doc_id_))
2040     if self.has_include_start_doc_: res+=prefix+("include_start_doc: %s\n" % self.DebugFormatBool(self.include_start_doc_))
2041     if self.has_limit_: res+=prefix+("limit: %s\n" % self.DebugFormatInt32(self.limit_))
2042     if self.has_keys_only_: res+=prefix+("keys_only: %s\n" % self.DebugFormatBool(self.keys_only_))
2043     return res
2044
2045
2046   def _BuildTagLookupTable(sparse, maxtag, default=None):
2047     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
2048
2049   kindex_spec = 1
2050   kstart_doc_id = 2
2051   kinclude_start_doc = 3
2052   klimit = 4
2053   kkeys_only = 5
2054
2055   _TEXT = _BuildTagLookupTable({
2056     0: "ErrorCode",
2057     1: "index_spec",
2058     2: "start_doc_id",
2059     3: "include_start_doc",
2060     4: "limit",
2061     5: "keys_only",
2062   }, 5)
2063
2064   _TYPES = _BuildTagLookupTable({
2065     0: ProtocolBuffer.Encoder.NUMERIC,
2066     1: ProtocolBuffer.Encoder.STRING,
2067     2: ProtocolBuffer.Encoder.STRING,
2068     3: ProtocolBuffer.Encoder.NUMERIC,
2069     4: ProtocolBuffer.Encoder.NUMERIC,
2070     5: ProtocolBuffer.Encoder.NUMERIC,
2071   }, 5, ProtocolBuffer.Encoder.MAX_TYPE)
2072
2073
2074   _STYLE = """"""
2075   _STYLE_CONTENT_TYPE = """"""
2076   _PROTO_DESCRIPTOR_NAME = 'apphosting.ListDocumentsParams'
2077 class ListDocumentsRequest(ProtocolBuffer.ProtocolMessage):
2078   has_params_ = 0
2079   has_app_id_ = 0
2080   app_id_ = ""
2081
2082   def __init__(self, contents=None):
2083     self.params_ = ListDocumentsParams()
2084     if contents is not None: self.MergeFromString(contents)
2085
2086   def params(self): return self.params_
2087
2088   def mutable_params(self): self.has_params_ = 1; return self.params_
2089
2090   def clear_params(self):self.has_params_ = 0; self.params_.Clear()
2091
2092   def has_params(self): return self.has_params_
2093
2094   def app_id(self): return self.app_id_
2095
2096   def set_app_id(self, x):
2097     self.has_app_id_ = 1
2098     self.app_id_ = x
2099
2100   def clear_app_id(self):
2101     if self.has_app_id_:
2102       self.has_app_id_ = 0
2103       self.app_id_ = ""
2104
2105   def has_app_id(self): return self.has_app_id_
2106
2107
2108   def MergeFrom(self, x):
2109     assert x is not self
2110     if (x.has_params()): self.mutable_params().MergeFrom(x.params())
2111     if (x.has_app_id()): self.set_app_id(x.app_id())
2112
2113   def Equals(self, x):
2114     if x is self: return 1
2115     if self.has_params_ != x.has_params_: return 0
2116     if self.has_params_ and self.params_ != x.params_: return 0
2117     if self.has_app_id_ != x.has_app_id_: return 0
2118     if self.has_app_id_ and self.app_id_ != x.app_id_: return 0
2119     return 1
2120
2121   def IsInitialized(self, debug_strs=None):
2122     initialized = 1
2123     if (not self.has_params_):
2124       initialized = 0
2125       if debug_strs is not None:
2126         debug_strs.append('Required field: params not set.')
2127     elif not self.params_.IsInitialized(debug_strs): initialized = 0
2128     return initialized
2129
2130   def ByteSize(self):
2131     n = 0
2132     n += self.lengthString(self.params_.ByteSize())
2133     if (self.has_app_id_): n += 1 + self.lengthString(len(self.app_id_))
2134     return n + 1
2135
2136   def ByteSizePartial(self):
2137     n = 0
2138     if (self.has_params_):
2139       n += 1
2140       n += self.lengthString(self.params_.ByteSizePartial())
2141     if (self.has_app_id_): n += 1 + self.lengthString(len(self.app_id_))
2142     return n
2143
2144   def Clear(self):
2145     self.clear_params()
2146     self.clear_app_id()
2147
2148   def OutputUnchecked(self, out):
2149     out.putVarInt32(10)
2150     out.putVarInt32(self.params_.ByteSize())
2151     self.params_.OutputUnchecked(out)
2152     if (self.has_app_id_):
2153       out.putVarInt32(18)
2154       out.putPrefixedString(self.app_id_)
2155
2156   def OutputPartial(self, out):
2157     if (self.has_params_):
2158       out.putVarInt32(10)
2159       out.putVarInt32(self.params_.ByteSizePartial())
2160       self.params_.OutputPartial(out)
2161     if (self.has_app_id_):
2162       out.putVarInt32(18)
2163       out.putPrefixedString(self.app_id_)
2164
2165   def TryMerge(self, d):
2166     while d.avail() > 0:
2167       tt = d.getVarInt32()
2168       if tt == 10:
2169         length = d.getVarInt32()
2170         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
2171         d.skip(length)
2172         self.mutable_params().TryMerge(tmp)
2173         continue
2174       if tt == 18:
2175         self.set_app_id(d.getPrefixedString())
2176         continue
2177
2178
2179       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
2180       d.skipData(tt)
2181
2182
2183   def __str__(self, prefix="", printElemNumber=0):
2184     res=""
2185     if self.has_params_:
2186       res+=prefix+"params <\n"
2187       res+=self.params_.__str__(prefix + "  ", printElemNumber)
2188       res+=prefix+">\n"
2189     if self.has_app_id_: res+=prefix+("app_id: %s\n" % self.DebugFormatString(self.app_id_))
2190     return res
2191
2192
2193   def _BuildTagLookupTable(sparse, maxtag, default=None):
2194     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
2195
2196   kparams = 1
2197   kapp_id = 2
2198
2199   _TEXT = _BuildTagLookupTable({
2200     0: "ErrorCode",
2201     1: "params",
2202     2: "app_id",
2203   }, 2)
2204
2205   _TYPES = _BuildTagLookupTable({
2206     0: ProtocolBuffer.Encoder.NUMERIC,
2207     1: ProtocolBuffer.Encoder.STRING,
2208     2: ProtocolBuffer.Encoder.STRING,
2209   }, 2, ProtocolBuffer.Encoder.MAX_TYPE)
2210
2211
2212   _STYLE = """"""
2213   _STYLE_CONTENT_TYPE = """"""
2214   _PROTO_DESCRIPTOR_NAME = 'apphosting.ListDocumentsRequest'
2215 class ListDocumentsResponse(ProtocolBuffer.ProtocolMessage):
2216   has_status_ = 0
2217
2218   def __init__(self, contents=None):
2219     self.status_ = RequestStatus()
2220     self.document_ = []
2221     if contents is not None: self.MergeFromString(contents)
2222
2223   def status(self): return self.status_
2224
2225   def mutable_status(self): self.has_status_ = 1; return self.status_
2226
2227   def clear_status(self):self.has_status_ = 0; self.status_.Clear()
2228
2229   def has_status(self): return self.has_status_
2230
2231   def document_size(self): return len(self.document_)
2232   def document_list(self): return self.document_
2233
2234   def document(self, i):
2235     return self.document_[i]
2236
2237   def mutable_document(self, i):
2238     return self.document_[i]
2239
2240   def add_document(self):
2241     x = Document()
2242     self.document_.append(x)
2243     return x
2244
2245   def clear_document(self):
2246     self.document_ = []
2247
2248   def MergeFrom(self, x):
2249     assert x is not self
2250     if (x.has_status()): self.mutable_status().MergeFrom(x.status())
2251     for i in xrange(x.document_size()): self.add_document().CopyFrom(x.document(i))
2252
2253   def Equals(self, x):
2254     if x is self: return 1
2255     if self.has_status_ != x.has_status_: return 0
2256     if self.has_status_ and self.status_ != x.status_: return 0
2257     if len(self.document_) != len(x.document_): return 0
2258     for e1, e2 in zip(self.document_, x.document_):
2259       if e1 != e2: return 0
2260     return 1
2261
2262   def IsInitialized(self, debug_strs=None):
2263     initialized = 1
2264     if (not self.has_status_):
2265       initialized = 0
2266       if debug_strs is not None:
2267         debug_strs.append('Required field: status not set.')
2268     elif not self.status_.IsInitialized(debug_strs): initialized = 0
2269     for p in self.document_:
2270       if not p.IsInitialized(debug_strs): initialized=0
2271     return initialized
2272
2273   def ByteSize(self):
2274     n = 0
2275     n += self.lengthString(self.status_.ByteSize())
2276     n += 1 * len(self.document_)
2277     for i in xrange(len(self.document_)): n += self.lengthString(self.document_[i].ByteSize())
2278     return n + 1
2279
2280   def ByteSizePartial(self):
2281     n = 0
2282     if (self.has_status_):
2283       n += 1
2284       n += self.lengthString(self.status_.ByteSizePartial())
2285     n += 1 * len(self.document_)
2286     for i in xrange(len(self.document_)): n += self.lengthString(self.document_[i].ByteSizePartial())
2287     return n
2288
2289   def Clear(self):
2290     self.clear_status()
2291     self.clear_document()
2292
2293   def OutputUnchecked(self, out):
2294     out.putVarInt32(10)
2295     out.putVarInt32(self.status_.ByteSize())
2296     self.status_.OutputUnchecked(out)
2297     for i in xrange(len(self.document_)):
2298       out.putVarInt32(18)
2299       out.putVarInt32(self.document_[i].ByteSize())
2300       self.document_[i].OutputUnchecked(out)
2301
2302   def OutputPartial(self, out):
2303     if (self.has_status_):
2304       out.putVarInt32(10)
2305       out.putVarInt32(self.status_.ByteSizePartial())
2306       self.status_.OutputPartial(out)
2307     for i in xrange(len(self.document_)):
2308       out.putVarInt32(18)
2309       out.putVarInt32(self.document_[i].ByteSizePartial())
2310       self.document_[i].OutputPartial(out)
2311
2312   def TryMerge(self, d):
2313     while d.avail() > 0:
2314       tt = d.getVarInt32()
2315       if tt == 10:
2316         length = d.getVarInt32()
2317         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
2318         d.skip(length)
2319         self.mutable_status().TryMerge(tmp)
2320         continue
2321       if tt == 18:
2322         length = d.getVarInt32()
2323         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
2324         d.skip(length)
2325         self.add_document().TryMerge(tmp)
2326         continue
2327
2328
2329       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
2330       d.skipData(tt)
2331
2332
2333   def __str__(self, prefix="", printElemNumber=0):
2334     res=""
2335     if self.has_status_:
2336       res+=prefix+"status <\n"
2337       res+=self.status_.__str__(prefix + "  ", printElemNumber)
2338       res+=prefix+">\n"
2339     cnt=0
2340     for e in self.document_:
2341       elm=""
2342       if printElemNumber: elm="(%d)" % cnt
2343       res+=prefix+("document%s <\n" % elm)
2344       res+=e.__str__(prefix + "  ", printElemNumber)
2345       res+=prefix+">\n"
2346       cnt+=1
2347     return res
2348
2349
2350   def _BuildTagLookupTable(sparse, maxtag, default=None):
2351     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
2352
2353   kstatus = 1
2354   kdocument = 2
2355
2356   _TEXT = _BuildTagLookupTable({
2357     0: "ErrorCode",
2358     1: "status",
2359     2: "document",
2360   }, 2)
2361
2362   _TYPES = _BuildTagLookupTable({
2363     0: ProtocolBuffer.Encoder.NUMERIC,
2364     1: ProtocolBuffer.Encoder.STRING,
2365     2: ProtocolBuffer.Encoder.STRING,
2366   }, 2, ProtocolBuffer.Encoder.MAX_TYPE)
2367
2368
2369   _STYLE = """"""
2370   _STYLE_CONTENT_TYPE = """"""
2371   _PROTO_DESCRIPTOR_NAME = 'apphosting.ListDocumentsResponse'
2372 class ListIndexesParams(ProtocolBuffer.ProtocolMessage):
2373   has_fetch_schema_ = 0
2374   fetch_schema_ = 0
2375   has_limit_ = 0
2376   limit_ = 20
2377   has_namespace_ = 0
2378   namespace_ = ""
2379   has_start_index_name_ = 0
2380   start_index_name_ = ""
2381   has_include_start_index_ = 0
2382   include_start_index_ = 1
2383   has_index_name_prefix_ = 0
2384   index_name_prefix_ = ""
2385   has_offset_ = 0
2386   offset_ = 0
2387   has_source_ = 0
2388   source_ = 0
2389
2390   def __init__(self, contents=None):
2391     if contents is not None: self.MergeFromString(contents)
2392
2393   def fetch_schema(self): return self.fetch_schema_
2394
2395   def set_fetch_schema(self, x):
2396     self.has_fetch_schema_ = 1
2397     self.fetch_schema_ = x
2398
2399   def clear_fetch_schema(self):
2400     if self.has_fetch_schema_:
2401       self.has_fetch_schema_ = 0
2402       self.fetch_schema_ = 0
2403
2404   def has_fetch_schema(self): return self.has_fetch_schema_
2405
2406   def limit(self): return self.limit_
2407
2408   def set_limit(self, x):
2409     self.has_limit_ = 1
2410     self.limit_ = x
2411
2412   def clear_limit(self):
2413     if self.has_limit_:
2414       self.has_limit_ = 0
2415       self.limit_ = 20
2416
2417   def has_limit(self): return self.has_limit_
2418
2419   def namespace(self): return self.namespace_
2420
2421   def set_namespace(self, x):
2422     self.has_namespace_ = 1
2423     self.namespace_ = x
2424
2425   def clear_namespace(self):
2426     if self.has_namespace_:
2427       self.has_namespace_ = 0
2428       self.namespace_ = ""
2429
2430   def has_namespace(self): return self.has_namespace_
2431
2432   def start_index_name(self): return self.start_index_name_
2433
2434   def set_start_index_name(self, x):
2435     self.has_start_index_name_ = 1
2436     self.start_index_name_ = x
2437
2438   def clear_start_index_name(self):
2439     if self.has_start_index_name_:
2440       self.has_start_index_name_ = 0
2441       self.start_index_name_ = ""
2442
2443   def has_start_index_name(self): return self.has_start_index_name_
2444
2445   def include_start_index(self): return self.include_start_index_
2446
2447   def set_include_start_index(self, x):
2448     self.has_include_start_index_ = 1
2449     self.include_start_index_ = x
2450
2451   def clear_include_start_index(self):
2452     if self.has_include_start_index_:
2453       self.has_include_start_index_ = 0
2454       self.include_start_index_ = 1
2455
2456   def has_include_start_index(self): return self.has_include_start_index_
2457
2458   def index_name_prefix(self): return self.index_name_prefix_
2459
2460   def set_index_name_prefix(self, x):
2461     self.has_index_name_prefix_ = 1
2462     self.index_name_prefix_ = x
2463
2464   def clear_index_name_prefix(self):
2465     if self.has_index_name_prefix_:
2466       self.has_index_name_prefix_ = 0
2467       self.index_name_prefix_ = ""
2468
2469   def has_index_name_prefix(self): return self.has_index_name_prefix_
2470
2471   def offset(self): return self.offset_
2472
2473   def set_offset(self, x):
2474     self.has_offset_ = 1
2475     self.offset_ = x
2476
2477   def clear_offset(self):
2478     if self.has_offset_:
2479       self.has_offset_ = 0
2480       self.offset_ = 0
2481
2482   def has_offset(self): return self.has_offset_
2483
2484   def source(self): return self.source_
2485
2486   def set_source(self, x):
2487     self.has_source_ = 1
2488     self.source_ = x
2489
2490   def clear_source(self):
2491     if self.has_source_:
2492       self.has_source_ = 0
2493       self.source_ = 0
2494
2495   def has_source(self): return self.has_source_
2496
2497
2498   def MergeFrom(self, x):
2499     assert x is not self
2500     if (x.has_fetch_schema()): self.set_fetch_schema(x.fetch_schema())
2501     if (x.has_limit()): self.set_limit(x.limit())
2502     if (x.has_namespace()): self.set_namespace(x.namespace())
2503     if (x.has_start_index_name()): self.set_start_index_name(x.start_index_name())
2504     if (x.has_include_start_index()): self.set_include_start_index(x.include_start_index())
2505     if (x.has_index_name_prefix()): self.set_index_name_prefix(x.index_name_prefix())
2506     if (x.has_offset()): self.set_offset(x.offset())
2507     if (x.has_source()): self.set_source(x.source())
2508
2509   def Equals(self, x):
2510     if x is self: return 1
2511     if self.has_fetch_schema_ != x.has_fetch_schema_: return 0
2512     if self.has_fetch_schema_ and self.fetch_schema_ != x.fetch_schema_: return 0
2513     if self.has_limit_ != x.has_limit_: return 0
2514     if self.has_limit_ and self.limit_ != x.limit_: return 0
2515     if self.has_namespace_ != x.has_namespace_: return 0
2516     if self.has_namespace_ and self.namespace_ != x.namespace_: return 0
2517     if self.has_start_index_name_ != x.has_start_index_name_: return 0
2518     if self.has_start_index_name_ and self.start_index_name_ != x.start_index_name_: return 0
2519     if self.has_include_start_index_ != x.has_include_start_index_: return 0
2520     if self.has_include_start_index_ and self.include_start_index_ != x.include_start_index_: return 0
2521     if self.has_index_name_prefix_ != x.has_index_name_prefix_: return 0
2522     if self.has_index_name_prefix_ and self.index_name_prefix_ != x.index_name_prefix_: return 0
2523     if self.has_offset_ != x.has_offset_: return 0
2524     if self.has_offset_ and self.offset_ != x.offset_: return 0
2525     if self.has_source_ != x.has_source_: return 0
2526     if self.has_source_ and self.source_ != x.source_: return 0
2527     return 1
2528
2529   def IsInitialized(self, debug_strs=None):
2530     initialized = 1
2531     return initialized
2532
2533   def ByteSize(self):
2534     n = 0
2535     if (self.has_fetch_schema_): n += 2
2536     if (self.has_limit_): n += 1 + self.lengthVarInt64(self.limit_)
2537     if (self.has_namespace_): n += 1 + self.lengthString(len(self.namespace_))
2538     if (self.has_start_index_name_): n += 1 + self.lengthString(len(self.start_index_name_))
2539     if (self.has_include_start_index_): n += 2
2540     if (self.has_index_name_prefix_): n += 1 + self.lengthString(len(self.index_name_prefix_))
2541     if (self.has_offset_): n += 1 + self.lengthVarInt64(self.offset_)
2542     if (self.has_source_): n += 1 + self.lengthVarInt64(self.source_)
2543     return n
2544
2545   def ByteSizePartial(self):
2546     n = 0
2547     if (self.has_fetch_schema_): n += 2
2548     if (self.has_limit_): n += 1 + self.lengthVarInt64(self.limit_)
2549     if (self.has_namespace_): n += 1 + self.lengthString(len(self.namespace_))
2550     if (self.has_start_index_name_): n += 1 + self.lengthString(len(self.start_index_name_))
2551     if (self.has_include_start_index_): n += 2
2552     if (self.has_index_name_prefix_): n += 1 + self.lengthString(len(self.index_name_prefix_))
2553     if (self.has_offset_): n += 1 + self.lengthVarInt64(self.offset_)
2554     if (self.has_source_): n += 1 + self.lengthVarInt64(self.source_)
2555     return n
2556
2557   def Clear(self):
2558     self.clear_fetch_schema()
2559     self.clear_limit()
2560     self.clear_namespace()
2561     self.clear_start_index_name()
2562     self.clear_include_start_index()
2563     self.clear_index_name_prefix()
2564     self.clear_offset()
2565     self.clear_source()
2566
2567   def OutputUnchecked(self, out):
2568     if (self.has_fetch_schema_):
2569       out.putVarInt32(8)
2570       out.putBoolean(self.fetch_schema_)
2571     if (self.has_limit_):
2572       out.putVarInt32(16)
2573       out.putVarInt32(self.limit_)
2574     if (self.has_namespace_):
2575       out.putVarInt32(26)
2576       out.putPrefixedString(self.namespace_)
2577     if (self.has_start_index_name_):
2578       out.putVarInt32(34)
2579       out.putPrefixedString(self.start_index_name_)
2580     if (self.has_include_start_index_):
2581       out.putVarInt32(40)
2582       out.putBoolean(self.include_start_index_)
2583     if (self.has_index_name_prefix_):
2584       out.putVarInt32(50)
2585       out.putPrefixedString(self.index_name_prefix_)
2586     if (self.has_offset_):
2587       out.putVarInt32(56)
2588       out.putVarInt32(self.offset_)
2589     if (self.has_source_):
2590       out.putVarInt32(64)
2591       out.putVarInt32(self.source_)
2592
2593   def OutputPartial(self, out):
2594     if (self.has_fetch_schema_):
2595       out.putVarInt32(8)
2596       out.putBoolean(self.fetch_schema_)
2597     if (self.has_limit_):
2598       out.putVarInt32(16)
2599       out.putVarInt32(self.limit_)
2600     if (self.has_namespace_):
2601       out.putVarInt32(26)
2602       out.putPrefixedString(self.namespace_)
2603     if (self.has_start_index_name_):
2604       out.putVarInt32(34)
2605       out.putPrefixedString(self.start_index_name_)
2606     if (self.has_include_start_index_):
2607       out.putVarInt32(40)
2608       out.putBoolean(self.include_start_index_)
2609     if (self.has_index_name_prefix_):
2610       out.putVarInt32(50)
2611       out.putPrefixedString(self.index_name_prefix_)
2612     if (self.has_offset_):
2613       out.putVarInt32(56)
2614       out.putVarInt32(self.offset_)
2615     if (self.has_source_):
2616       out.putVarInt32(64)
2617       out.putVarInt32(self.source_)
2618
2619   def TryMerge(self, d):
2620     while d.avail() > 0:
2621       tt = d.getVarInt32()
2622       if tt == 8:
2623         self.set_fetch_schema(d.getBoolean())
2624         continue
2625       if tt == 16:
2626         self.set_limit(d.getVarInt32())
2627         continue
2628       if tt == 26:
2629         self.set_namespace(d.getPrefixedString())
2630         continue
2631       if tt == 34:
2632         self.set_start_index_name(d.getPrefixedString())
2633         continue
2634       if tt == 40:
2635         self.set_include_start_index(d.getBoolean())
2636         continue
2637       if tt == 50:
2638         self.set_index_name_prefix(d.getPrefixedString())
2639         continue
2640       if tt == 56:
2641         self.set_offset(d.getVarInt32())
2642         continue
2643       if tt == 64:
2644         self.set_source(d.getVarInt32())
2645         continue
2646
2647
2648       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
2649       d.skipData(tt)
2650
2651
2652   def __str__(self, prefix="", printElemNumber=0):
2653     res=""
2654     if self.has_fetch_schema_: res+=prefix+("fetch_schema: %s\n" % self.DebugFormatBool(self.fetch_schema_))
2655     if self.has_limit_: res+=prefix+("limit: %s\n" % self.DebugFormatInt32(self.limit_))
2656     if self.has_namespace_: res+=prefix+("namespace: %s\n" % self.DebugFormatString(self.namespace_))
2657     if self.has_start_index_name_: res+=prefix+("start_index_name: %s\n" % self.DebugFormatString(self.start_index_name_))
2658     if self.has_include_start_index_: res+=prefix+("include_start_index: %s\n" % self.DebugFormatBool(self.include_start_index_))
2659     if self.has_index_name_prefix_: res+=prefix+("index_name_prefix: %s\n" % self.DebugFormatString(self.index_name_prefix_))
2660     if self.has_offset_: res+=prefix+("offset: %s\n" % self.DebugFormatInt32(self.offset_))
2661     if self.has_source_: res+=prefix+("source: %s\n" % self.DebugFormatInt32(self.source_))
2662     return res
2663
2664
2665   def _BuildTagLookupTable(sparse, maxtag, default=None):
2666     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
2667
2668   kfetch_schema = 1
2669   klimit = 2
2670   knamespace = 3
2671   kstart_index_name = 4
2672   kinclude_start_index = 5
2673   kindex_name_prefix = 6
2674   koffset = 7
2675   ksource = 8
2676
2677   _TEXT = _BuildTagLookupTable({
2678     0: "ErrorCode",
2679     1: "fetch_schema",
2680     2: "limit",
2681     3: "namespace",
2682     4: "start_index_name",
2683     5: "include_start_index",
2684     6: "index_name_prefix",
2685     7: "offset",
2686     8: "source",
2687   }, 8)
2688
2689   _TYPES = _BuildTagLookupTable({
2690     0: ProtocolBuffer.Encoder.NUMERIC,
2691     1: ProtocolBuffer.Encoder.NUMERIC,
2692     2: ProtocolBuffer.Encoder.NUMERIC,
2693     3: ProtocolBuffer.Encoder.STRING,
2694     4: ProtocolBuffer.Encoder.STRING,
2695     5: ProtocolBuffer.Encoder.NUMERIC,
2696     6: ProtocolBuffer.Encoder.STRING,
2697     7: ProtocolBuffer.Encoder.NUMERIC,
2698     8: ProtocolBuffer.Encoder.NUMERIC,
2699   }, 8, ProtocolBuffer.Encoder.MAX_TYPE)
2700
2701
2702   _STYLE = """"""
2703   _STYLE_CONTENT_TYPE = """"""
2704   _PROTO_DESCRIPTOR_NAME = 'apphosting.ListIndexesParams'
2705 class ListIndexesRequest(ProtocolBuffer.ProtocolMessage):
2706   has_params_ = 0
2707   has_app_id_ = 0
2708   app_id_ = ""
2709
2710   def __init__(self, contents=None):
2711     self.params_ = ListIndexesParams()
2712     if contents is not None: self.MergeFromString(contents)
2713
2714   def params(self): return self.params_
2715
2716   def mutable_params(self): self.has_params_ = 1; return self.params_
2717
2718   def clear_params(self):self.has_params_ = 0; self.params_.Clear()
2719
2720   def has_params(self): return self.has_params_
2721
2722   def app_id(self): return self.app_id_
2723
2724   def set_app_id(self, x):
2725     self.has_app_id_ = 1
2726     self.app_id_ = x
2727
2728   def clear_app_id(self):
2729     if self.has_app_id_:
2730       self.has_app_id_ = 0
2731       self.app_id_ = ""
2732
2733   def has_app_id(self): return self.has_app_id_
2734
2735
2736   def MergeFrom(self, x):
2737     assert x is not self
2738     if (x.has_params()): self.mutable_params().MergeFrom(x.params())
2739     if (x.has_app_id()): self.set_app_id(x.app_id())
2740
2741   def Equals(self, x):
2742     if x is self: return 1
2743     if self.has_params_ != x.has_params_: return 0
2744     if self.has_params_ and self.params_ != x.params_: return 0
2745     if self.has_app_id_ != x.has_app_id_: return 0
2746     if self.has_app_id_ and self.app_id_ != x.app_id_: return 0
2747     return 1
2748
2749   def IsInitialized(self, debug_strs=None):
2750     initialized = 1
2751     if (not self.has_params_):
2752       initialized = 0
2753       if debug_strs is not None:
2754         debug_strs.append('Required field: params not set.')
2755     elif not self.params_.IsInitialized(debug_strs): initialized = 0
2756     return initialized
2757
2758   def ByteSize(self):
2759     n = 0
2760     n += self.lengthString(self.params_.ByteSize())
2761     if (self.has_app_id_): n += 1 + self.lengthString(len(self.app_id_))
2762     return n + 1
2763
2764   def ByteSizePartial(self):
2765     n = 0
2766     if (self.has_params_):
2767       n += 1
2768       n += self.lengthString(self.params_.ByteSizePartial())
2769     if (self.has_app_id_): n += 1 + self.lengthString(len(self.app_id_))
2770     return n
2771
2772   def Clear(self):
2773     self.clear_params()
2774     self.clear_app_id()
2775
2776   def OutputUnchecked(self, out):
2777     out.putVarInt32(10)
2778     out.putVarInt32(self.params_.ByteSize())
2779     self.params_.OutputUnchecked(out)
2780     if (self.has_app_id_):
2781       out.putVarInt32(26)
2782       out.putPrefixedString(self.app_id_)
2783
2784   def OutputPartial(self, out):
2785     if (self.has_params_):
2786       out.putVarInt32(10)
2787       out.putVarInt32(self.params_.ByteSizePartial())
2788       self.params_.OutputPartial(out)
2789     if (self.has_app_id_):
2790       out.putVarInt32(26)
2791       out.putPrefixedString(self.app_id_)
2792
2793   def TryMerge(self, d):
2794     while d.avail() > 0:
2795       tt = d.getVarInt32()
2796       if tt == 10:
2797         length = d.getVarInt32()
2798         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
2799         d.skip(length)
2800         self.mutable_params().TryMerge(tmp)
2801         continue
2802       if tt == 26:
2803         self.set_app_id(d.getPrefixedString())
2804         continue
2805
2806
2807       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
2808       d.skipData(tt)
2809
2810
2811   def __str__(self, prefix="", printElemNumber=0):
2812     res=""
2813     if self.has_params_:
2814       res+=prefix+"params <\n"
2815       res+=self.params_.__str__(prefix + "  ", printElemNumber)
2816       res+=prefix+">\n"
2817     if self.has_app_id_: res+=prefix+("app_id: %s\n" % self.DebugFormatString(self.app_id_))
2818     return res
2819
2820
2821   def _BuildTagLookupTable(sparse, maxtag, default=None):
2822     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
2823
2824   kparams = 1
2825   kapp_id = 3
2826
2827   _TEXT = _BuildTagLookupTable({
2828     0: "ErrorCode",
2829     1: "params",
2830     3: "app_id",
2831   }, 3)
2832
2833   _TYPES = _BuildTagLookupTable({
2834     0: ProtocolBuffer.Encoder.NUMERIC,
2835     1: ProtocolBuffer.Encoder.STRING,
2836     3: ProtocolBuffer.Encoder.STRING,
2837   }, 3, ProtocolBuffer.Encoder.MAX_TYPE)
2838
2839
2840   _STYLE = """"""
2841   _STYLE_CONTENT_TYPE = """"""
2842   _PROTO_DESCRIPTOR_NAME = 'apphosting.ListIndexesRequest'
2843 class ListIndexesResponse(ProtocolBuffer.ProtocolMessage):
2844   has_status_ = 0
2845
2846   def __init__(self, contents=None):
2847     self.status_ = RequestStatus()
2848     self.index_metadata_ = []
2849     if contents is not None: self.MergeFromString(contents)
2850
2851   def status(self): return self.status_
2852
2853   def mutable_status(self): self.has_status_ = 1; return self.status_
2854
2855   def clear_status(self):self.has_status_ = 0; self.status_.Clear()
2856
2857   def has_status(self): return self.has_status_
2858
2859   def index_metadata_size(self): return len(self.index_metadata_)
2860   def index_metadata_list(self): return self.index_metadata_
2861
2862   def index_metadata(self, i):
2863     return self.index_metadata_[i]
2864
2865   def mutable_index_metadata(self, i):
2866     return self.index_metadata_[i]
2867
2868   def add_index_metadata(self):
2869     x = IndexMetadata()
2870     self.index_metadata_.append(x)
2871     return x
2872
2873   def clear_index_metadata(self):
2874     self.index_metadata_ = []
2875
2876   def MergeFrom(self, x):
2877     assert x is not self
2878     if (x.has_status()): self.mutable_status().MergeFrom(x.status())
2879     for i in xrange(x.index_metadata_size()): self.add_index_metadata().CopyFrom(x.index_metadata(i))
2880
2881   def Equals(self, x):
2882     if x is self: return 1
2883     if self.has_status_ != x.has_status_: return 0
2884     if self.has_status_ and self.status_ != x.status_: return 0
2885     if len(self.index_metadata_) != len(x.index_metadata_): return 0
2886     for e1, e2 in zip(self.index_metadata_, x.index_metadata_):
2887       if e1 != e2: return 0
2888     return 1
2889
2890   def IsInitialized(self, debug_strs=None):
2891     initialized = 1
2892     if (not self.has_status_):
2893       initialized = 0
2894       if debug_strs is not None:
2895         debug_strs.append('Required field: status not set.')
2896     elif not self.status_.IsInitialized(debug_strs): initialized = 0
2897     for p in self.index_metadata_:
2898       if not p.IsInitialized(debug_strs): initialized=0
2899     return initialized
2900
2901   def ByteSize(self):
2902     n = 0
2903     n += self.lengthString(self.status_.ByteSize())
2904     n += 1 * len(self.index_metadata_)
2905     for i in xrange(len(self.index_metadata_)): n += self.lengthString(self.index_metadata_[i].ByteSize())
2906     return n + 1
2907
2908   def ByteSizePartial(self):
2909     n = 0
2910     if (self.has_status_):
2911       n += 1
2912       n += self.lengthString(self.status_.ByteSizePartial())
2913     n += 1 * len(self.index_metadata_)
2914     for i in xrange(len(self.index_metadata_)): n += self.lengthString(self.index_metadata_[i].ByteSizePartial())
2915     return n
2916
2917   def Clear(self):
2918     self.clear_status()
2919     self.clear_index_metadata()
2920
2921   def OutputUnchecked(self, out):
2922     out.putVarInt32(10)
2923     out.putVarInt32(self.status_.ByteSize())
2924     self.status_.OutputUnchecked(out)
2925     for i in xrange(len(self.index_metadata_)):
2926       out.putVarInt32(18)
2927       out.putVarInt32(self.index_metadata_[i].ByteSize())
2928       self.index_metadata_[i].OutputUnchecked(out)
2929
2930   def OutputPartial(self, out):
2931     if (self.has_status_):
2932       out.putVarInt32(10)
2933       out.putVarInt32(self.status_.ByteSizePartial())
2934       self.status_.OutputPartial(out)
2935     for i in xrange(len(self.index_metadata_)):
2936       out.putVarInt32(18)
2937       out.putVarInt32(self.index_metadata_[i].ByteSizePartial())
2938       self.index_metadata_[i].OutputPartial(out)
2939
2940   def TryMerge(self, d):
2941     while d.avail() > 0:
2942       tt = d.getVarInt32()
2943       if tt == 10:
2944         length = d.getVarInt32()
2945         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
2946         d.skip(length)
2947         self.mutable_status().TryMerge(tmp)
2948         continue
2949       if tt == 18:
2950         length = d.getVarInt32()
2951         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
2952         d.skip(length)
2953         self.add_index_metadata().TryMerge(tmp)
2954         continue
2955
2956
2957       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
2958       d.skipData(tt)
2959
2960
2961   def __str__(self, prefix="", printElemNumber=0):
2962     res=""
2963     if self.has_status_:
2964       res+=prefix+"status <\n"
2965       res+=self.status_.__str__(prefix + "  ", printElemNumber)
2966       res+=prefix+">\n"
2967     cnt=0
2968     for e in self.index_metadata_:
2969       elm=""
2970       if printElemNumber: elm="(%d)" % cnt
2971       res+=prefix+("index_metadata%s <\n" % elm)
2972       res+=e.__str__(prefix + "  ", printElemNumber)
2973       res+=prefix+">\n"
2974       cnt+=1
2975     return res
2976
2977
2978   def _BuildTagLookupTable(sparse, maxtag, default=None):
2979     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
2980
2981   kstatus = 1
2982   kindex_metadata = 2
2983
2984   _TEXT = _BuildTagLookupTable({
2985     0: "ErrorCode",
2986     1: "status",
2987     2: "index_metadata",
2988   }, 2)
2989
2990   _TYPES = _BuildTagLookupTable({
2991     0: ProtocolBuffer.Encoder.NUMERIC,
2992     1: ProtocolBuffer.Encoder.STRING,
2993     2: ProtocolBuffer.Encoder.STRING,
2994   }, 2, ProtocolBuffer.Encoder.MAX_TYPE)
2995
2996
2997   _STYLE = """"""
2998   _STYLE_CONTENT_TYPE = """"""
2999   _PROTO_DESCRIPTOR_NAME = 'apphosting.ListIndexesResponse'
3000 class DeleteSchemaParams(ProtocolBuffer.ProtocolMessage):
3001   has_source_ = 0
3002   source_ = 0
3003
3004   def __init__(self, contents=None):
3005     self.index_spec_ = []
3006     if contents is not None: self.MergeFromString(contents)
3007
3008   def source(self): return self.source_
3009
3010   def set_source(self, x):
3011     self.has_source_ = 1
3012     self.source_ = x
3013
3014   def clear_source(self):
3015     if self.has_source_:
3016       self.has_source_ = 0
3017       self.source_ = 0
3018
3019   def has_source(self): return self.has_source_
3020
3021   def index_spec_size(self): return len(self.index_spec_)
3022   def index_spec_list(self): return self.index_spec_
3023
3024   def index_spec(self, i):
3025     return self.index_spec_[i]
3026
3027   def mutable_index_spec(self, i):
3028     return self.index_spec_[i]
3029
3030   def add_index_spec(self):
3031     x = IndexSpec()
3032     self.index_spec_.append(x)
3033     return x
3034
3035   def clear_index_spec(self):
3036     self.index_spec_ = []
3037
3038   def MergeFrom(self, x):
3039     assert x is not self
3040     if (x.has_source()): self.set_source(x.source())
3041     for i in xrange(x.index_spec_size()): self.add_index_spec().CopyFrom(x.index_spec(i))
3042
3043   def Equals(self, x):
3044     if x is self: return 1
3045     if self.has_source_ != x.has_source_: return 0
3046     if self.has_source_ and self.source_ != x.source_: return 0
3047     if len(self.index_spec_) != len(x.index_spec_): return 0
3048     for e1, e2 in zip(self.index_spec_, x.index_spec_):
3049       if e1 != e2: return 0
3050     return 1
3051
3052   def IsInitialized(self, debug_strs=None):
3053     initialized = 1
3054     for p in self.index_spec_:
3055       if not p.IsInitialized(debug_strs): initialized=0
3056     return initialized
3057
3058   def ByteSize(self):
3059     n = 0
3060     if (self.has_source_): n += 1 + self.lengthVarInt64(self.source_)
3061     n += 1 * len(self.index_spec_)
3062     for i in xrange(len(self.index_spec_)): n += self.lengthString(self.index_spec_[i].ByteSize())
3063     return n
3064
3065   def ByteSizePartial(self):
3066     n = 0
3067     if (self.has_source_): n += 1 + self.lengthVarInt64(self.source_)
3068     n += 1 * len(self.index_spec_)
3069     for i in xrange(len(self.index_spec_)): n += self.lengthString(self.index_spec_[i].ByteSizePartial())
3070     return n
3071
3072   def Clear(self):
3073     self.clear_source()
3074     self.clear_index_spec()
3075
3076   def OutputUnchecked(self, out):
3077     if (self.has_source_):
3078       out.putVarInt32(8)
3079       out.putVarInt32(self.source_)
3080     for i in xrange(len(self.index_spec_)):
3081       out.putVarInt32(18)
3082       out.putVarInt32(self.index_spec_[i].ByteSize())
3083       self.index_spec_[i].OutputUnchecked(out)
3084
3085   def OutputPartial(self, out):
3086     if (self.has_source_):
3087       out.putVarInt32(8)
3088       out.putVarInt32(self.source_)
3089     for i in xrange(len(self.index_spec_)):
3090       out.putVarInt32(18)
3091       out.putVarInt32(self.index_spec_[i].ByteSizePartial())
3092       self.index_spec_[i].OutputPartial(out)
3093
3094   def TryMerge(self, d):
3095     while d.avail() > 0:
3096       tt = d.getVarInt32()
3097       if tt == 8:
3098         self.set_source(d.getVarInt32())
3099         continue
3100       if tt == 18:
3101         length = d.getVarInt32()
3102         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
3103         d.skip(length)
3104         self.add_index_spec().TryMerge(tmp)
3105         continue
3106
3107
3108       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
3109       d.skipData(tt)
3110
3111
3112   def __str__(self, prefix="", printElemNumber=0):
3113     res=""
3114     if self.has_source_: res+=prefix+("source: %s\n" % self.DebugFormatInt32(self.source_))
3115     cnt=0
3116     for e in self.index_spec_:
3117       elm=""
3118       if printElemNumber: elm="(%d)" % cnt
3119       res+=prefix+("index_spec%s <\n" % elm)
3120       res+=e.__str__(prefix + "  ", printElemNumber)
3121       res+=prefix+">\n"
3122       cnt+=1
3123     return res
3124
3125
3126   def _BuildTagLookupTable(sparse, maxtag, default=None):
3127     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
3128
3129   ksource = 1
3130   kindex_spec = 2
3131
3132   _TEXT = _BuildTagLookupTable({
3133     0: "ErrorCode",
3134     1: "source",
3135     2: "index_spec",
3136   }, 2)
3137
3138   _TYPES = _BuildTagLookupTable({
3139     0: ProtocolBuffer.Encoder.NUMERIC,
3140     1: ProtocolBuffer.Encoder.NUMERIC,
3141     2: ProtocolBuffer.Encoder.STRING,
3142   }, 2, ProtocolBuffer.Encoder.MAX_TYPE)
3143
3144
3145   _STYLE = """"""
3146   _STYLE_CONTENT_TYPE = """"""
3147   _PROTO_DESCRIPTOR_NAME = 'apphosting.DeleteSchemaParams'
3148 class DeleteSchemaRequest(ProtocolBuffer.ProtocolMessage):
3149   has_params_ = 0
3150   has_app_id_ = 0
3151   app_id_ = ""
3152
3153   def __init__(self, contents=None):
3154     self.params_ = DeleteSchemaParams()
3155     if contents is not None: self.MergeFromString(contents)
3156
3157   def params(self): return self.params_
3158
3159   def mutable_params(self): self.has_params_ = 1; return self.params_
3160
3161   def clear_params(self):self.has_params_ = 0; self.params_.Clear()
3162
3163   def has_params(self): return self.has_params_
3164
3165   def app_id(self): return self.app_id_
3166
3167   def set_app_id(self, x):
3168     self.has_app_id_ = 1
3169     self.app_id_ = x
3170
3171   def clear_app_id(self):
3172     if self.has_app_id_:
3173       self.has_app_id_ = 0
3174       self.app_id_ = ""
3175
3176   def has_app_id(self): return self.has_app_id_
3177
3178
3179   def MergeFrom(self, x):
3180     assert x is not self
3181     if (x.has_params()): self.mutable_params().MergeFrom(x.params())
3182     if (x.has_app_id()): self.set_app_id(x.app_id())
3183
3184   def Equals(self, x):
3185     if x is self: return 1
3186     if self.has_params_ != x.has_params_: return 0
3187     if self.has_params_ and self.params_ != x.params_: return 0
3188     if self.has_app_id_ != x.has_app_id_: return 0
3189     if self.has_app_id_ and self.app_id_ != x.app_id_: return 0
3190     return 1
3191
3192   def IsInitialized(self, debug_strs=None):
3193     initialized = 1
3194     if (not self.has_params_):
3195       initialized = 0
3196       if debug_strs is not None:
3197         debug_strs.append('Required field: params not set.')
3198     elif not self.params_.IsInitialized(debug_strs): initialized = 0
3199     return initialized
3200
3201   def ByteSize(self):
3202     n = 0
3203     n += self.lengthString(self.params_.ByteSize())
3204     if (self.has_app_id_): n += 1 + self.lengthString(len(self.app_id_))
3205     return n + 1
3206
3207   def ByteSizePartial(self):
3208     n = 0
3209     if (self.has_params_):
3210       n += 1
3211       n += self.lengthString(self.params_.ByteSizePartial())
3212     if (self.has_app_id_): n += 1 + self.lengthString(len(self.app_id_))
3213     return n
3214
3215   def Clear(self):
3216     self.clear_params()
3217     self.clear_app_id()
3218
3219   def OutputUnchecked(self, out):
3220     out.putVarInt32(10)
3221     out.putVarInt32(self.params_.ByteSize())
3222     self.params_.OutputUnchecked(out)
3223     if (self.has_app_id_):
3224       out.putVarInt32(26)
3225       out.putPrefixedString(self.app_id_)
3226
3227   def OutputPartial(self, out):
3228     if (self.has_params_):
3229       out.putVarInt32(10)
3230       out.putVarInt32(self.params_.ByteSizePartial())
3231       self.params_.OutputPartial(out)
3232     if (self.has_app_id_):
3233       out.putVarInt32(26)
3234       out.putPrefixedString(self.app_id_)
3235
3236   def TryMerge(self, d):
3237     while d.avail() > 0:
3238       tt = d.getVarInt32()
3239       if tt == 10:
3240         length = d.getVarInt32()
3241         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
3242         d.skip(length)
3243         self.mutable_params().TryMerge(tmp)
3244         continue
3245       if tt == 26:
3246         self.set_app_id(d.getPrefixedString())
3247         continue
3248
3249
3250       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
3251       d.skipData(tt)
3252
3253
3254   def __str__(self, prefix="", printElemNumber=0):
3255     res=""
3256     if self.has_params_:
3257       res+=prefix+"params <\n"
3258       res+=self.params_.__str__(prefix + "  ", printElemNumber)
3259       res+=prefix+">\n"
3260     if self.has_app_id_: res+=prefix+("app_id: %s\n" % self.DebugFormatString(self.app_id_))
3261     return res
3262
3263
3264   def _BuildTagLookupTable(sparse, maxtag, default=None):
3265     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
3266
3267   kparams = 1
3268   kapp_id = 3
3269
3270   _TEXT = _BuildTagLookupTable({
3271     0: "ErrorCode",
3272     1: "params",
3273     3: "app_id",
3274   }, 3)
3275
3276   _TYPES = _BuildTagLookupTable({
3277     0: ProtocolBuffer.Encoder.NUMERIC,
3278     1: ProtocolBuffer.Encoder.STRING,
3279     3: ProtocolBuffer.Encoder.STRING,
3280   }, 3, ProtocolBuffer.Encoder.MAX_TYPE)
3281
3282
3283   _STYLE = """"""
3284   _STYLE_CONTENT_TYPE = """"""
3285   _PROTO_DESCRIPTOR_NAME = 'apphosting.DeleteSchemaRequest'
3286 class DeleteSchemaResponse(ProtocolBuffer.ProtocolMessage):
3287
3288   def __init__(self, contents=None):
3289     self.status_ = []
3290     if contents is not None: self.MergeFromString(contents)
3291
3292   def status_size(self): return len(self.status_)
3293   def status_list(self): return self.status_
3294
3295   def status(self, i):
3296     return self.status_[i]
3297
3298   def mutable_status(self, i):
3299     return self.status_[i]
3300
3301   def add_status(self):
3302     x = RequestStatus()
3303     self.status_.append(x)
3304     return x
3305
3306   def clear_status(self):
3307     self.status_ = []
3308
3309   def MergeFrom(self, x):
3310     assert x is not self
3311     for i in xrange(x.status_size()): self.add_status().CopyFrom(x.status(i))
3312
3313   def Equals(self, x):
3314     if x is self: return 1
3315     if len(self.status_) != len(x.status_): return 0
3316     for e1, e2 in zip(self.status_, x.status_):
3317       if e1 != e2: return 0
3318     return 1
3319
3320   def IsInitialized(self, debug_strs=None):
3321     initialized = 1
3322     for p in self.status_:
3323       if not p.IsInitialized(debug_strs): initialized=0
3324     return initialized
3325
3326   def ByteSize(self):
3327     n = 0
3328     n += 1 * len(self.status_)
3329     for i in xrange(len(self.status_)): n += self.lengthString(self.status_[i].ByteSize())
3330     return n
3331
3332   def ByteSizePartial(self):
3333     n = 0
3334     n += 1 * len(self.status_)
3335     for i in xrange(len(self.status_)): n += self.lengthString(self.status_[i].ByteSizePartial())
3336     return n
3337
3338   def Clear(self):
3339     self.clear_status()
3340
3341   def OutputUnchecked(self, out):
3342     for i in xrange(len(self.status_)):
3343       out.putVarInt32(10)
3344       out.putVarInt32(self.status_[i].ByteSize())
3345       self.status_[i].OutputUnchecked(out)
3346
3347   def OutputPartial(self, out):
3348     for i in xrange(len(self.status_)):
3349       out.putVarInt32(10)
3350       out.putVarInt32(self.status_[i].ByteSizePartial())
3351       self.status_[i].OutputPartial(out)
3352
3353   def TryMerge(self, d):
3354     while d.avail() > 0:
3355       tt = d.getVarInt32()
3356       if tt == 10:
3357         length = d.getVarInt32()
3358         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
3359         d.skip(length)
3360         self.add_status().TryMerge(tmp)
3361         continue
3362
3363
3364       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
3365       d.skipData(tt)
3366
3367
3368   def __str__(self, prefix="", printElemNumber=0):
3369     res=""
3370     cnt=0
3371     for e in self.status_:
3372       elm=""
3373       if printElemNumber: elm="(%d)" % cnt
3374       res+=prefix+("status%s <\n" % elm)
3375       res+=e.__str__(prefix + "  ", printElemNumber)
3376       res+=prefix+">\n"
3377       cnt+=1
3378     return res
3379
3380
3381   def _BuildTagLookupTable(sparse, maxtag, default=None):
3382     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
3383
3384   kstatus = 1
3385
3386   _TEXT = _BuildTagLookupTable({
3387     0: "ErrorCode",
3388     1: "status",
3389   }, 1)
3390
3391   _TYPES = _BuildTagLookupTable({
3392     0: ProtocolBuffer.Encoder.NUMERIC,
3393     1: ProtocolBuffer.Encoder.STRING,
3394   }, 1, ProtocolBuffer.Encoder.MAX_TYPE)
3395
3396
3397   _STYLE = """"""
3398   _STYLE_CONTENT_TYPE = """"""
3399   _PROTO_DESCRIPTOR_NAME = 'apphosting.DeleteSchemaResponse'
3400 class SortSpec(ProtocolBuffer.ProtocolMessage):
3401   has_sort_expression_ = 0
3402   sort_expression_ = ""
3403   has_sort_descending_ = 0
3404   sort_descending_ = 1
3405   has_default_value_text_ = 0
3406   default_value_text_ = ""
3407   has_default_value_numeric_ = 0
3408   default_value_numeric_ = 0.0
3409
3410   def __init__(self, contents=None):
3411     if contents is not None: self.MergeFromString(contents)
3412
3413   def sort_expression(self): return self.sort_expression_
3414
3415   def set_sort_expression(self, x):
3416     self.has_sort_expression_ = 1
3417     self.sort_expression_ = x
3418
3419   def clear_sort_expression(self):
3420     if self.has_sort_expression_:
3421       self.has_sort_expression_ = 0
3422       self.sort_expression_ = ""
3423
3424   def has_sort_expression(self): return self.has_sort_expression_
3425
3426   def sort_descending(self): return self.sort_descending_
3427
3428   def set_sort_descending(self, x):
3429     self.has_sort_descending_ = 1
3430     self.sort_descending_ = x
3431
3432   def clear_sort_descending(self):
3433     if self.has_sort_descending_:
3434       self.has_sort_descending_ = 0
3435       self.sort_descending_ = 1
3436
3437   def has_sort_descending(self): return self.has_sort_descending_
3438
3439   def default_value_text(self): return self.default_value_text_
3440
3441   def set_default_value_text(self, x):
3442     self.has_default_value_text_ = 1
3443     self.default_value_text_ = x
3444
3445   def clear_default_value_text(self):
3446     if self.has_default_value_text_:
3447       self.has_default_value_text_ = 0
3448       self.default_value_text_ = ""
3449
3450   def has_default_value_text(self): return self.has_default_value_text_
3451
3452   def default_value_numeric(self): return self.default_value_numeric_
3453
3454   def set_default_value_numeric(self, x):
3455     self.has_default_value_numeric_ = 1
3456     self.default_value_numeric_ = x
3457
3458   def clear_default_value_numeric(self):
3459     if self.has_default_value_numeric_:
3460       self.has_default_value_numeric_ = 0
3461       self.default_value_numeric_ = 0.0
3462
3463   def has_default_value_numeric(self): return self.has_default_value_numeric_
3464
3465
3466   def MergeFrom(self, x):
3467     assert x is not self
3468     if (x.has_sort_expression()): self.set_sort_expression(x.sort_expression())
3469     if (x.has_sort_descending()): self.set_sort_descending(x.sort_descending())
3470     if (x.has_default_value_text()): self.set_default_value_text(x.default_value_text())
3471     if (x.has_default_value_numeric()): self.set_default_value_numeric(x.default_value_numeric())
3472
3473   def Equals(self, x):
3474     if x is self: return 1
3475     if self.has_sort_expression_ != x.has_sort_expression_: return 0
3476     if self.has_sort_expression_ and self.sort_expression_ != x.sort_expression_: return 0
3477     if self.has_sort_descending_ != x.has_sort_descending_: return 0
3478     if self.has_sort_descending_ and self.sort_descending_ != x.sort_descending_: return 0
3479     if self.has_default_value_text_ != x.has_default_value_text_: return 0
3480     if self.has_default_value_text_ and self.default_value_text_ != x.default_value_text_: return 0
3481     if self.has_default_value_numeric_ != x.has_default_value_numeric_: return 0
3482     if self.has_default_value_numeric_ and self.default_value_numeric_ != x.default_value_numeric_: return 0
3483     return 1
3484
3485   def IsInitialized(self, debug_strs=None):
3486     initialized = 1
3487     if (not self.has_sort_expression_):
3488       initialized = 0
3489       if debug_strs is not None:
3490         debug_strs.append('Required field: sort_expression not set.')
3491     return initialized
3492
3493   def ByteSize(self):
3494     n = 0
3495     n += self.lengthString(len(self.sort_expression_))
3496     if (self.has_sort_descending_): n += 2
3497     if (self.has_default_value_text_): n += 1 + self.lengthString(len(self.default_value_text_))
3498     if (self.has_default_value_numeric_): n += 9
3499     return n + 1
3500
3501   def ByteSizePartial(self):
3502     n = 0
3503     if (self.has_sort_expression_):
3504       n += 1
3505       n += self.lengthString(len(self.sort_expression_))
3506     if (self.has_sort_descending_): n += 2
3507     if (self.has_default_value_text_): n += 1 + self.lengthString(len(self.default_value_text_))
3508     if (self.has_default_value_numeric_): n += 9
3509     return n
3510
3511   def Clear(self):
3512     self.clear_sort_expression()
3513     self.clear_sort_descending()
3514     self.clear_default_value_text()
3515     self.clear_default_value_numeric()
3516
3517   def OutputUnchecked(self, out):
3518     out.putVarInt32(10)
3519     out.putPrefixedString(self.sort_expression_)
3520     if (self.has_sort_descending_):
3521       out.putVarInt32(16)
3522       out.putBoolean(self.sort_descending_)
3523     if (self.has_default_value_text_):
3524       out.putVarInt32(34)
3525       out.putPrefixedString(self.default_value_text_)
3526     if (self.has_default_value_numeric_):
3527       out.putVarInt32(41)
3528       out.putDouble(self.default_value_numeric_)
3529
3530   def OutputPartial(self, out):
3531     if (self.has_sort_expression_):
3532       out.putVarInt32(10)
3533       out.putPrefixedString(self.sort_expression_)
3534     if (self.has_sort_descending_):
3535       out.putVarInt32(16)
3536       out.putBoolean(self.sort_descending_)
3537     if (self.has_default_value_text_):
3538       out.putVarInt32(34)
3539       out.putPrefixedString(self.default_value_text_)
3540     if (self.has_default_value_numeric_):
3541       out.putVarInt32(41)
3542       out.putDouble(self.default_value_numeric_)
3543
3544   def TryMerge(self, d):
3545     while d.avail() > 0:
3546       tt = d.getVarInt32()
3547       if tt == 10:
3548         self.set_sort_expression(d.getPrefixedString())
3549         continue
3550       if tt == 16:
3551         self.set_sort_descending(d.getBoolean())
3552         continue
3553       if tt == 34:
3554         self.set_default_value_text(d.getPrefixedString())
3555         continue
3556       if tt == 41:
3557         self.set_default_value_numeric(d.getDouble())
3558         continue
3559
3560
3561       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
3562       d.skipData(tt)
3563
3564
3565   def __str__(self, prefix="", printElemNumber=0):
3566     res=""
3567     if self.has_sort_expression_: res+=prefix+("sort_expression: %s\n" % self.DebugFormatString(self.sort_expression_))
3568     if self.has_sort_descending_: res+=prefix+("sort_descending: %s\n" % self.DebugFormatBool(self.sort_descending_))
3569     if self.has_default_value_text_: res+=prefix+("default_value_text: %s\n" % self.DebugFormatString(self.default_value_text_))
3570     if self.has_default_value_numeric_: res+=prefix+("default_value_numeric: %s\n" % self.DebugFormat(self.default_value_numeric_))
3571     return res
3572
3573
3574   def _BuildTagLookupTable(sparse, maxtag, default=None):
3575     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
3576
3577   ksort_expression = 1
3578   ksort_descending = 2
3579   kdefault_value_text = 4
3580   kdefault_value_numeric = 5
3581
3582   _TEXT = _BuildTagLookupTable({
3583     0: "ErrorCode",
3584     1: "sort_expression",
3585     2: "sort_descending",
3586     4: "default_value_text",
3587     5: "default_value_numeric",
3588   }, 5)
3589
3590   _TYPES = _BuildTagLookupTable({
3591     0: ProtocolBuffer.Encoder.NUMERIC,
3592     1: ProtocolBuffer.Encoder.STRING,
3593     2: ProtocolBuffer.Encoder.NUMERIC,
3594     4: ProtocolBuffer.Encoder.STRING,
3595     5: ProtocolBuffer.Encoder.DOUBLE,
3596   }, 5, ProtocolBuffer.Encoder.MAX_TYPE)
3597
3598
3599   _STYLE = """"""
3600   _STYLE_CONTENT_TYPE = """"""
3601   _PROTO_DESCRIPTOR_NAME = 'apphosting.SortSpec'
3602 class ScorerSpec(ProtocolBuffer.ProtocolMessage):
3603
3604
3605   RESCORING_MATCH_SCORER =    0
3606   MATCH_SCORER =    2
3607
3608   _Scorer_NAMES = {
3609     0: "RESCORING_MATCH_SCORER",
3610     2: "MATCH_SCORER",
3611   }
3612
3613   def Scorer_Name(cls, x): return cls._Scorer_NAMES.get(x, "")
3614   Scorer_Name = classmethod(Scorer_Name)
3615
3616   has_scorer_ = 0
3617   scorer_ = 2
3618   has_limit_ = 0
3619   limit_ = 1000
3620   has_match_scorer_parameters_ = 0
3621   match_scorer_parameters_ = ""
3622
3623   def __init__(self, contents=None):
3624     if contents is not None: self.MergeFromString(contents)
3625
3626   def scorer(self): return self.scorer_
3627
3628   def set_scorer(self, x):
3629     self.has_scorer_ = 1
3630     self.scorer_ = x
3631
3632   def clear_scorer(self):
3633     if self.has_scorer_:
3634       self.has_scorer_ = 0
3635       self.scorer_ = 2
3636
3637   def has_scorer(self): return self.has_scorer_
3638
3639   def limit(self): return self.limit_
3640
3641   def set_limit(self, x):
3642     self.has_limit_ = 1
3643     self.limit_ = x
3644
3645   def clear_limit(self):
3646     if self.has_limit_:
3647       self.has_limit_ = 0
3648       self.limit_ = 1000
3649
3650   def has_limit(self): return self.has_limit_
3651
3652   def match_scorer_parameters(self): return self.match_scorer_parameters_
3653
3654   def set_match_scorer_parameters(self, x):
3655     self.has_match_scorer_parameters_ = 1
3656     self.match_scorer_parameters_ = x
3657
3658   def clear_match_scorer_parameters(self):
3659     if self.has_match_scorer_parameters_:
3660       self.has_match_scorer_parameters_ = 0
3661       self.match_scorer_parameters_ = ""
3662
3663   def has_match_scorer_parameters(self): return self.has_match_scorer_parameters_
3664
3665
3666   def MergeFrom(self, x):
3667     assert x is not self
3668     if (x.has_scorer()): self.set_scorer(x.scorer())
3669     if (x.has_limit()): self.set_limit(x.limit())
3670     if (x.has_match_scorer_parameters()): self.set_match_scorer_parameters(x.match_scorer_parameters())
3671
3672   def Equals(self, x):
3673     if x is self: return 1
3674     if self.has_scorer_ != x.has_scorer_: return 0
3675     if self.has_scorer_ and self.scorer_ != x.scorer_: return 0
3676     if self.has_limit_ != x.has_limit_: return 0
3677     if self.has_limit_ and self.limit_ != x.limit_: return 0
3678     if self.has_match_scorer_parameters_ != x.has_match_scorer_parameters_: return 0
3679     if self.has_match_scorer_parameters_ and self.match_scorer_parameters_ != x.match_scorer_parameters_: return 0
3680     return 1
3681
3682   def IsInitialized(self, debug_strs=None):
3683     initialized = 1
3684     return initialized
3685
3686   def ByteSize(self):
3687     n = 0
3688     if (self.has_scorer_): n += 1 + self.lengthVarInt64(self.scorer_)
3689     if (self.has_limit_): n += 1 + self.lengthVarInt64(self.limit_)
3690     if (self.has_match_scorer_parameters_): n += 1 + self.lengthString(len(self.match_scorer_parameters_))
3691     return n
3692
3693   def ByteSizePartial(self):
3694     n = 0
3695     if (self.has_scorer_): n += 1 + self.lengthVarInt64(self.scorer_)
3696     if (self.has_limit_): n += 1 + self.lengthVarInt64(self.limit_)
3697     if (self.has_match_scorer_parameters_): n += 1 + self.lengthString(len(self.match_scorer_parameters_))
3698     return n
3699
3700   def Clear(self):
3701     self.clear_scorer()
3702     self.clear_limit()
3703     self.clear_match_scorer_parameters()
3704
3705   def OutputUnchecked(self, out):
3706     if (self.has_scorer_):
3707       out.putVarInt32(8)
3708       out.putVarInt32(self.scorer_)
3709     if (self.has_limit_):
3710       out.putVarInt32(16)
3711       out.putVarInt32(self.limit_)
3712     if (self.has_match_scorer_parameters_):
3713       out.putVarInt32(74)
3714       out.putPrefixedString(self.match_scorer_parameters_)
3715
3716   def OutputPartial(self, out):
3717     if (self.has_scorer_):
3718       out.putVarInt32(8)
3719       out.putVarInt32(self.scorer_)
3720     if (self.has_limit_):
3721       out.putVarInt32(16)
3722       out.putVarInt32(self.limit_)
3723     if (self.has_match_scorer_parameters_):
3724       out.putVarInt32(74)
3725       out.putPrefixedString(self.match_scorer_parameters_)
3726
3727   def TryMerge(self, d):
3728     while d.avail() > 0:
3729       tt = d.getVarInt32()
3730       if tt == 8:
3731         self.set_scorer(d.getVarInt32())
3732         continue
3733       if tt == 16:
3734         self.set_limit(d.getVarInt32())
3735         continue
3736       if tt == 74:
3737         self.set_match_scorer_parameters(d.getPrefixedString())
3738         continue
3739
3740
3741       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
3742       d.skipData(tt)
3743
3744
3745   def __str__(self, prefix="", printElemNumber=0):
3746     res=""
3747     if self.has_scorer_: res+=prefix+("scorer: %s\n" % self.DebugFormatInt32(self.scorer_))
3748     if self.has_limit_: res+=prefix+("limit: %s\n" % self.DebugFormatInt32(self.limit_))
3749     if self.has_match_scorer_parameters_: res+=prefix+("match_scorer_parameters: %s\n" % self.DebugFormatString(self.match_scorer_parameters_))
3750     return res
3751
3752
3753   def _BuildTagLookupTable(sparse, maxtag, default=None):
3754     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
3755
3756   kscorer = 1
3757   klimit = 2
3758   kmatch_scorer_parameters = 9
3759
3760   _TEXT = _BuildTagLookupTable({
3761     0: "ErrorCode",
3762     1: "scorer",
3763     2: "limit",
3764     9: "match_scorer_parameters",
3765   }, 9)
3766
3767   _TYPES = _BuildTagLookupTable({
3768     0: ProtocolBuffer.Encoder.NUMERIC,
3769     1: ProtocolBuffer.Encoder.NUMERIC,
3770     2: ProtocolBuffer.Encoder.NUMERIC,
3771     9: ProtocolBuffer.Encoder.STRING,
3772   }, 9, ProtocolBuffer.Encoder.MAX_TYPE)
3773
3774
3775   _STYLE = """"""
3776   _STYLE_CONTENT_TYPE = """"""
3777   _PROTO_DESCRIPTOR_NAME = 'apphosting.ScorerSpec'
3778 class FieldSpec_Expression(ProtocolBuffer.ProtocolMessage):
3779   has_name_ = 0
3780   name_ = ""
3781   has_expression_ = 0
3782   expression_ = ""
3783
3784   def __init__(self, contents=None):
3785     if contents is not None: self.MergeFromString(contents)
3786
3787   def name(self): return self.name_
3788
3789   def set_name(self, x):
3790     self.has_name_ = 1
3791     self.name_ = x
3792
3793   def clear_name(self):
3794     if self.has_name_:
3795       self.has_name_ = 0
3796       self.name_ = ""
3797
3798   def has_name(self): return self.has_name_
3799
3800   def expression(self): return self.expression_
3801
3802   def set_expression(self, x):
3803     self.has_expression_ = 1
3804     self.expression_ = x
3805
3806   def clear_expression(self):
3807     if self.has_expression_:
3808       self.has_expression_ = 0
3809       self.expression_ = ""
3810
3811   def has_expression(self): return self.has_expression_
3812
3813
3814   def MergeFrom(self, x):
3815     assert x is not self
3816     if (x.has_name()): self.set_name(x.name())
3817     if (x.has_expression()): self.set_expression(x.expression())
3818
3819   def Equals(self, x):
3820     if x is self: return 1
3821     if self.has_name_ != x.has_name_: return 0
3822     if self.has_name_ and self.name_ != x.name_: return 0
3823     if self.has_expression_ != x.has_expression_: return 0
3824     if self.has_expression_ and self.expression_ != x.expression_: return 0
3825     return 1
3826
3827   def IsInitialized(self, debug_strs=None):
3828     initialized = 1
3829     if (not self.has_name_):
3830       initialized = 0
3831       if debug_strs is not None:
3832         debug_strs.append('Required field: name not set.')
3833     if (not self.has_expression_):
3834       initialized = 0
3835       if debug_strs is not None:
3836         debug_strs.append('Required field: expression not set.')
3837     return initialized
3838
3839   def ByteSize(self):
3840     n = 0
3841     n += self.lengthString(len(self.name_))
3842     n += self.lengthString(len(self.expression_))
3843     return n + 2
3844
3845   def ByteSizePartial(self):
3846     n = 0
3847     if (self.has_name_):
3848       n += 1
3849       n += self.lengthString(len(self.name_))
3850     if (self.has_expression_):
3851       n += 1
3852       n += self.lengthString(len(self.expression_))
3853     return n
3854
3855   def Clear(self):
3856     self.clear_name()
3857     self.clear_expression()
3858
3859   def OutputUnchecked(self, out):
3860     out.putVarInt32(26)
3861     out.putPrefixedString(self.name_)
3862     out.putVarInt32(34)
3863     out.putPrefixedString(self.expression_)
3864
3865   def OutputPartial(self, out):
3866     if (self.has_name_):
3867       out.putVarInt32(26)
3868       out.putPrefixedString(self.name_)
3869     if (self.has_expression_):
3870       out.putVarInt32(34)
3871       out.putPrefixedString(self.expression_)
3872
3873   def TryMerge(self, d):
3874     while 1:
3875       tt = d.getVarInt32()
3876       if tt == 20: break
3877       if tt == 26:
3878         self.set_name(d.getPrefixedString())
3879         continue
3880       if tt == 34:
3881         self.set_expression(d.getPrefixedString())
3882         continue
3883
3884
3885       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
3886       d.skipData(tt)
3887
3888
3889   def __str__(self, prefix="", printElemNumber=0):
3890     res=""
3891     if self.has_name_: res+=prefix+("name: %s\n" % self.DebugFormatString(self.name_))
3892     if self.has_expression_: res+=prefix+("expression: %s\n" % self.DebugFormatString(self.expression_))
3893     return res
3894
3895 class FieldSpec(ProtocolBuffer.ProtocolMessage):
3896
3897   def __init__(self, contents=None):
3898     self.name_ = []
3899     self.expression_ = []
3900     if contents is not None: self.MergeFromString(contents)
3901
3902   def name_size(self): return len(self.name_)
3903   def name_list(self): return self.name_
3904
3905   def name(self, i):
3906     return self.name_[i]
3907
3908   def set_name(self, i, x):
3909     self.name_[i] = x
3910
3911   def add_name(self, x):
3912     self.name_.append(x)
3913
3914   def clear_name(self):
3915     self.name_ = []
3916
3917   def expression_size(self): return len(self.expression_)
3918   def expression_list(self): return self.expression_
3919
3920   def expression(self, i):
3921     return self.expression_[i]
3922
3923   def mutable_expression(self, i):
3924     return self.expression_[i]
3925
3926   def add_expression(self):
3927     x = FieldSpec_Expression()
3928     self.expression_.append(x)
3929     return x
3930
3931   def clear_expression(self):
3932     self.expression_ = []
3933
3934   def MergeFrom(self, x):
3935     assert x is not self
3936     for i in xrange(x.name_size()): self.add_name(x.name(i))
3937     for i in xrange(x.expression_size()): self.add_expression().CopyFrom(x.expression(i))
3938
3939   def Equals(self, x):
3940     if x is self: return 1
3941     if len(self.name_) != len(x.name_): return 0
3942     for e1, e2 in zip(self.name_, x.name_):
3943       if e1 != e2: return 0
3944     if len(self.expression_) != len(x.expression_): return 0
3945     for e1, e2 in zip(self.expression_, x.expression_):
3946       if e1 != e2: return 0
3947     return 1
3948
3949   def IsInitialized(self, debug_strs=None):
3950     initialized = 1
3951     for p in self.expression_:
3952       if not p.IsInitialized(debug_strs): initialized=0
3953     return initialized
3954
3955   def ByteSize(self):
3956     n = 0
3957     n += 1 * len(self.name_)
3958     for i in xrange(len(self.name_)): n += self.lengthString(len(self.name_[i]))
3959     n += 2 * len(self.expression_)
3960     for i in xrange(len(self.expression_)): n += self.expression_[i].ByteSize()
3961     return n
3962
3963   def ByteSizePartial(self):
3964     n = 0
3965     n += 1 * len(self.name_)
3966     for i in xrange(len(self.name_)): n += self.lengthString(len(self.name_[i]))
3967     n += 2 * len(self.expression_)
3968     for i in xrange(len(self.expression_)): n += self.expression_[i].ByteSizePartial()
3969     return n
3970
3971   def Clear(self):
3972     self.clear_name()
3973     self.clear_expression()
3974
3975   def OutputUnchecked(self, out):
3976     for i in xrange(len(self.name_)):
3977       out.putVarInt32(10)
3978       out.putPrefixedString(self.name_[i])
3979     for i in xrange(len(self.expression_)):
3980       out.putVarInt32(19)
3981       self.expression_[i].OutputUnchecked(out)
3982       out.putVarInt32(20)
3983
3984   def OutputPartial(self, out):
3985     for i in xrange(len(self.name_)):
3986       out.putVarInt32(10)
3987       out.putPrefixedString(self.name_[i])
3988     for i in xrange(len(self.expression_)):
3989       out.putVarInt32(19)
3990       self.expression_[i].OutputPartial(out)
3991       out.putVarInt32(20)
3992
3993   def TryMerge(self, d):
3994     while d.avail() > 0:
3995       tt = d.getVarInt32()
3996       if tt == 10:
3997         self.add_name(d.getPrefixedString())
3998         continue
3999       if tt == 19:
4000         self.add_expression().TryMerge(d)
4001         continue
4002
4003
4004       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
4005       d.skipData(tt)
4006
4007
4008   def __str__(self, prefix="", printElemNumber=0):
4009     res=""
4010     cnt=0
4011     for e in self.name_:
4012       elm=""
4013       if printElemNumber: elm="(%d)" % cnt
4014       res+=prefix+("name%s: %s\n" % (elm, self.DebugFormatString(e)))
4015       cnt+=1
4016     cnt=0
4017     for e in self.expression_:
4018       elm=""
4019       if printElemNumber: elm="(%d)" % cnt
4020       res+=prefix+("Expression%s {\n" % elm)
4021       res+=e.__str__(prefix + "  ", printElemNumber)
4022       res+=prefix+"}\n"
4023       cnt+=1
4024     return res
4025
4026
4027   def _BuildTagLookupTable(sparse, maxtag, default=None):
4028     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
4029
4030   kname = 1
4031   kExpressionGroup = 2
4032   kExpressionname = 3
4033   kExpressionexpression = 4
4034
4035   _TEXT = _BuildTagLookupTable({
4036     0: "ErrorCode",
4037     1: "name",
4038     2: "Expression",
4039     3: "name",
4040     4: "expression",
4041   }, 4)
4042
4043   _TYPES = _BuildTagLookupTable({
4044     0: ProtocolBuffer.Encoder.NUMERIC,
4045     1: ProtocolBuffer.Encoder.STRING,
4046     2: ProtocolBuffer.Encoder.STARTGROUP,
4047     3: ProtocolBuffer.Encoder.STRING,
4048     4: ProtocolBuffer.Encoder.STRING,
4049   }, 4, ProtocolBuffer.Encoder.MAX_TYPE)
4050
4051
4052   _STYLE = """"""
4053   _STYLE_CONTENT_TYPE = """"""
4054   _PROTO_DESCRIPTOR_NAME = 'apphosting.FieldSpec'
4055 class FacetRange(ProtocolBuffer.ProtocolMessage):
4056   has_name_ = 0
4057   name_ = ""
4058   has_start_ = 0
4059   start_ = ""
4060   has_end_ = 0
4061   end_ = ""
4062
4063   def __init__(self, contents=None):
4064     if contents is not None: self.MergeFromString(contents)
4065
4066   def name(self): return self.name_
4067
4068   def set_name(self, x):
4069     self.has_name_ = 1
4070     self.name_ = x
4071
4072   def clear_name(self):
4073     if self.has_name_:
4074       self.has_name_ = 0
4075       self.name_ = ""
4076
4077   def has_name(self): return self.has_name_
4078
4079   def start(self): return self.start_
4080
4081   def set_start(self, x):
4082     self.has_start_ = 1
4083     self.start_ = x
4084
4085   def clear_start(self):
4086     if self.has_start_:
4087       self.has_start_ = 0
4088       self.start_ = ""
4089
4090   def has_start(self): return self.has_start_
4091
4092   def end(self): return self.end_
4093
4094   def set_end(self, x):
4095     self.has_end_ = 1
4096     self.end_ = x
4097
4098   def clear_end(self):
4099     if self.has_end_:
4100       self.has_end_ = 0
4101       self.end_ = ""
4102
4103   def has_end(self): return self.has_end_
4104
4105
4106   def MergeFrom(self, x):
4107     assert x is not self
4108     if (x.has_name()): self.set_name(x.name())
4109     if (x.has_start()): self.set_start(x.start())
4110     if (x.has_end()): self.set_end(x.end())
4111
4112   def Equals(self, x):
4113     if x is self: return 1
4114     if self.has_name_ != x.has_name_: return 0
4115     if self.has_name_ and self.name_ != x.name_: return 0
4116     if self.has_start_ != x.has_start_: return 0
4117     if self.has_start_ and self.start_ != x.start_: return 0
4118     if self.has_end_ != x.has_end_: return 0
4119     if self.has_end_ and self.end_ != x.end_: return 0
4120     return 1
4121
4122   def IsInitialized(self, debug_strs=None):
4123     initialized = 1
4124     return initialized
4125
4126   def ByteSize(self):
4127     n = 0
4128     if (self.has_name_): n += 1 + self.lengthString(len(self.name_))
4129     if (self.has_start_): n += 1 + self.lengthString(len(self.start_))
4130     if (self.has_end_): n += 1 + self.lengthString(len(self.end_))
4131     return n
4132
4133   def ByteSizePartial(self):
4134     n = 0
4135     if (self.has_name_): n += 1 + self.lengthString(len(self.name_))
4136     if (self.has_start_): n += 1 + self.lengthString(len(self.start_))
4137     if (self.has_end_): n += 1 + self.lengthString(len(self.end_))
4138     return n
4139
4140   def Clear(self):
4141     self.clear_name()
4142     self.clear_start()
4143     self.clear_end()
4144
4145   def OutputUnchecked(self, out):
4146     if (self.has_name_):
4147       out.putVarInt32(10)
4148       out.putPrefixedString(self.name_)
4149     if (self.has_start_):
4150       out.putVarInt32(18)
4151       out.putPrefixedString(self.start_)
4152     if (self.has_end_):
4153       out.putVarInt32(26)
4154       out.putPrefixedString(self.end_)
4155
4156   def OutputPartial(self, out):
4157     if (self.has_name_):
4158       out.putVarInt32(10)
4159       out.putPrefixedString(self.name_)
4160     if (self.has_start_):
4161       out.putVarInt32(18)
4162       out.putPrefixedString(self.start_)
4163     if (self.has_end_):
4164       out.putVarInt32(26)
4165       out.putPrefixedString(self.end_)
4166
4167   def TryMerge(self, d):
4168     while d.avail() > 0:
4169       tt = d.getVarInt32()
4170       if tt == 10:
4171         self.set_name(d.getPrefixedString())
4172         continue
4173       if tt == 18:
4174         self.set_start(d.getPrefixedString())
4175         continue
4176       if tt == 26:
4177         self.set_end(d.getPrefixedString())
4178         continue
4179
4180
4181       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
4182       d.skipData(tt)
4183
4184
4185   def __str__(self, prefix="", printElemNumber=0):
4186     res=""
4187     if self.has_name_: res+=prefix+("name: %s\n" % self.DebugFormatString(self.name_))
4188     if self.has_start_: res+=prefix+("start: %s\n" % self.DebugFormatString(self.start_))
4189     if self.has_end_: res+=prefix+("end: %s\n" % self.DebugFormatString(self.end_))
4190     return res
4191
4192
4193   def _BuildTagLookupTable(sparse, maxtag, default=None):
4194     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
4195
4196   kname = 1
4197   kstart = 2
4198   kend = 3
4199
4200   _TEXT = _BuildTagLookupTable({
4201     0: "ErrorCode",
4202     1: "name",
4203     2: "start",
4204     3: "end",
4205   }, 3)
4206
4207   _TYPES = _BuildTagLookupTable({
4208     0: ProtocolBuffer.Encoder.NUMERIC,
4209     1: ProtocolBuffer.Encoder.STRING,
4210     2: ProtocolBuffer.Encoder.STRING,
4211     3: ProtocolBuffer.Encoder.STRING,
4212   }, 3, ProtocolBuffer.Encoder.MAX_TYPE)
4213
4214
4215   _STYLE = """"""
4216   _STYLE_CONTENT_TYPE = """"""
4217   _PROTO_DESCRIPTOR_NAME = 'apphosting.FacetRange'
4218 class FacetRequestParam(ProtocolBuffer.ProtocolMessage):
4219   has_value_limit_ = 0
4220   value_limit_ = 0
4221
4222   def __init__(self, contents=None):
4223     self.range_ = []
4224     self.value_constraint_ = []
4225     if contents is not None: self.MergeFromString(contents)
4226
4227   def value_limit(self): return self.value_limit_
4228
4229   def set_value_limit(self, x):
4230     self.has_value_limit_ = 1
4231     self.value_limit_ = x
4232
4233   def clear_value_limit(self):
4234     if self.has_value_limit_:
4235       self.has_value_limit_ = 0
4236       self.value_limit_ = 0
4237
4238   def has_value_limit(self): return self.has_value_limit_
4239
4240   def range_size(self): return len(self.range_)
4241   def range_list(self): return self.range_
4242
4243   def range(self, i):
4244     return self.range_[i]
4245
4246   def mutable_range(self, i):
4247     return self.range_[i]
4248
4249   def add_range(self):
4250     x = FacetRange()
4251     self.range_.append(x)
4252     return x
4253
4254   def clear_range(self):
4255     self.range_ = []
4256   def value_constraint_size(self): return len(self.value_constraint_)
4257   def value_constraint_list(self): return self.value_constraint_
4258
4259   def value_constraint(self, i):
4260     return self.value_constraint_[i]
4261
4262   def set_value_constraint(self, i, x):
4263     self.value_constraint_[i] = x
4264
4265   def add_value_constraint(self, x):
4266     self.value_constraint_.append(x)
4267
4268   def clear_value_constraint(self):
4269     self.value_constraint_ = []
4270
4271
4272   def MergeFrom(self, x):
4273     assert x is not self
4274     if (x.has_value_limit()): self.set_value_limit(x.value_limit())
4275     for i in xrange(x.range_size()): self.add_range().CopyFrom(x.range(i))
4276     for i in xrange(x.value_constraint_size()): self.add_value_constraint(x.value_constraint(i))
4277
4278   def Equals(self, x):
4279     if x is self: return 1
4280     if self.has_value_limit_ != x.has_value_limit_: return 0
4281     if self.has_value_limit_ and self.value_limit_ != x.value_limit_: return 0
4282     if len(self.range_) != len(x.range_): return 0
4283     for e1, e2 in zip(self.range_, x.range_):
4284       if e1 != e2: return 0
4285     if len(self.value_constraint_) != len(x.value_constraint_): return 0
4286     for e1, e2 in zip(self.value_constraint_, x.value_constraint_):
4287       if e1 != e2: return 0
4288     return 1
4289
4290   def IsInitialized(self, debug_strs=None):
4291     initialized = 1
4292     for p in self.range_:
4293       if not p.IsInitialized(debug_strs): initialized=0
4294     return initialized
4295
4296   def ByteSize(self):
4297     n = 0
4298     if (self.has_value_limit_): n += 1 + self.lengthVarInt64(self.value_limit_)
4299     n += 1 * len(self.range_)
4300     for i in xrange(len(self.range_)): n += self.lengthString(self.range_[i].ByteSize())
4301     n += 1 * len(self.value_constraint_)
4302     for i in xrange(len(self.value_constraint_)): n += self.lengthString(len(self.value_constraint_[i]))
4303     return n
4304
4305   def ByteSizePartial(self):
4306     n = 0
4307     if (self.has_value_limit_): n += 1 + self.lengthVarInt64(self.value_limit_)
4308     n += 1 * len(self.range_)
4309     for i in xrange(len(self.range_)): n += self.lengthString(self.range_[i].ByteSizePartial())
4310     n += 1 * len(self.value_constraint_)
4311     for i in xrange(len(self.value_constraint_)): n += self.lengthString(len(self.value_constraint_[i]))
4312     return n
4313
4314   def Clear(self):
4315     self.clear_value_limit()
4316     self.clear_range()
4317     self.clear_value_constraint()
4318
4319   def OutputUnchecked(self, out):
4320     if (self.has_value_limit_):
4321       out.putVarInt32(8)
4322       out.putVarInt32(self.value_limit_)
4323     for i in xrange(len(self.range_)):
4324       out.putVarInt32(18)
4325       out.putVarInt32(self.range_[i].ByteSize())
4326       self.range_[i].OutputUnchecked(out)
4327     for i in xrange(len(self.value_constraint_)):
4328       out.putVarInt32(26)
4329       out.putPrefixedString(self.value_constraint_[i])
4330
4331   def OutputPartial(self, out):
4332     if (self.has_value_limit_):
4333       out.putVarInt32(8)
4334       out.putVarInt32(self.value_limit_)
4335     for i in xrange(len(self.range_)):
4336       out.putVarInt32(18)
4337       out.putVarInt32(self.range_[i].ByteSizePartial())
4338       self.range_[i].OutputPartial(out)
4339     for i in xrange(len(self.value_constraint_)):
4340       out.putVarInt32(26)
4341       out.putPrefixedString(self.value_constraint_[i])
4342
4343   def TryMerge(self, d):
4344     while d.avail() > 0:
4345       tt = d.getVarInt32()
4346       if tt == 8:
4347         self.set_value_limit(d.getVarInt32())
4348         continue
4349       if tt == 18:
4350         length = d.getVarInt32()
4351         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
4352         d.skip(length)
4353         self.add_range().TryMerge(tmp)
4354         continue
4355       if tt == 26:
4356         self.add_value_constraint(d.getPrefixedString())
4357         continue
4358
4359
4360       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
4361       d.skipData(tt)
4362
4363
4364   def __str__(self, prefix="", printElemNumber=0):
4365     res=""
4366     if self.has_value_limit_: res+=prefix+("value_limit: %s\n" % self.DebugFormatInt32(self.value_limit_))
4367     cnt=0
4368     for e in self.range_:
4369       elm=""
4370       if printElemNumber: elm="(%d)" % cnt
4371       res+=prefix+("range%s <\n" % elm)
4372       res+=e.__str__(prefix + "  ", printElemNumber)
4373       res+=prefix+">\n"
4374       cnt+=1
4375     cnt=0
4376     for e in self.value_constraint_:
4377       elm=""
4378       if printElemNumber: elm="(%d)" % cnt
4379       res+=prefix+("value_constraint%s: %s\n" % (elm, self.DebugFormatString(e)))
4380       cnt+=1
4381     return res
4382
4383
4384   def _BuildTagLookupTable(sparse, maxtag, default=None):
4385     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
4386
4387   kvalue_limit = 1
4388   krange = 2
4389   kvalue_constraint = 3
4390
4391   _TEXT = _BuildTagLookupTable({
4392     0: "ErrorCode",
4393     1: "value_limit",
4394     2: "range",
4395     3: "value_constraint",
4396   }, 3)
4397
4398   _TYPES = _BuildTagLookupTable({
4399     0: ProtocolBuffer.Encoder.NUMERIC,
4400     1: ProtocolBuffer.Encoder.NUMERIC,
4401     2: ProtocolBuffer.Encoder.STRING,
4402     3: ProtocolBuffer.Encoder.STRING,
4403   }, 3, ProtocolBuffer.Encoder.MAX_TYPE)
4404
4405
4406   _STYLE = """"""
4407   _STYLE_CONTENT_TYPE = """"""
4408   _PROTO_DESCRIPTOR_NAME = 'apphosting.FacetRequestParam'
4409 class FacetAutoDetectParam(ProtocolBuffer.ProtocolMessage):
4410   has_value_limit_ = 0
4411   value_limit_ = 10
4412
4413   def __init__(self, contents=None):
4414     if contents is not None: self.MergeFromString(contents)
4415
4416   def value_limit(self): return self.value_limit_
4417
4418   def set_value_limit(self, x):
4419     self.has_value_limit_ = 1
4420     self.value_limit_ = x
4421
4422   def clear_value_limit(self):
4423     if self.has_value_limit_:
4424       self.has_value_limit_ = 0
4425       self.value_limit_ = 10
4426
4427   def has_value_limit(self): return self.has_value_limit_
4428
4429
4430   def MergeFrom(self, x):
4431     assert x is not self
4432     if (x.has_value_limit()): self.set_value_limit(x.value_limit())
4433
4434   def Equals(self, x):
4435     if x is self: return 1
4436     if self.has_value_limit_ != x.has_value_limit_: return 0
4437     if self.has_value_limit_ and self.value_limit_ != x.value_limit_: return 0
4438     return 1
4439
4440   def IsInitialized(self, debug_strs=None):
4441     initialized = 1
4442     return initialized
4443
4444   def ByteSize(self):
4445     n = 0
4446     if (self.has_value_limit_): n += 1 + self.lengthVarInt64(self.value_limit_)
4447     return n
4448
4449   def ByteSizePartial(self):
4450     n = 0
4451     if (self.has_value_limit_): n += 1 + self.lengthVarInt64(self.value_limit_)
4452     return n
4453
4454   def Clear(self):
4455     self.clear_value_limit()
4456
4457   def OutputUnchecked(self, out):
4458     if (self.has_value_limit_):
4459       out.putVarInt32(8)
4460       out.putVarInt32(self.value_limit_)
4461
4462   def OutputPartial(self, out):
4463     if (self.has_value_limit_):
4464       out.putVarInt32(8)
4465       out.putVarInt32(self.value_limit_)
4466
4467   def TryMerge(self, d):
4468     while d.avail() > 0:
4469       tt = d.getVarInt32()
4470       if tt == 8:
4471         self.set_value_limit(d.getVarInt32())
4472         continue
4473
4474
4475       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
4476       d.skipData(tt)
4477
4478
4479   def __str__(self, prefix="", printElemNumber=0):
4480     res=""
4481     if self.has_value_limit_: res+=prefix+("value_limit: %s\n" % self.DebugFormatInt32(self.value_limit_))
4482     return res
4483
4484
4485   def _BuildTagLookupTable(sparse, maxtag, default=None):
4486     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
4487
4488   kvalue_limit = 1
4489
4490   _TEXT = _BuildTagLookupTable({
4491     0: "ErrorCode",
4492     1: "value_limit",
4493   }, 1)
4494
4495   _TYPES = _BuildTagLookupTable({
4496     0: ProtocolBuffer.Encoder.NUMERIC,
4497     1: ProtocolBuffer.Encoder.NUMERIC,
4498   }, 1, ProtocolBuffer.Encoder.MAX_TYPE)
4499
4500
4501   _STYLE = """"""
4502   _STYLE_CONTENT_TYPE = """"""
4503   _PROTO_DESCRIPTOR_NAME = 'apphosting.FacetAutoDetectParam'
4504 class FacetRequest(ProtocolBuffer.ProtocolMessage):
4505   has_name_ = 0
4506   name_ = ""
4507   has_params_ = 0
4508   params_ = None
4509
4510   def __init__(self, contents=None):
4511     self.lazy_init_lock_ = thread.allocate_lock()
4512     if contents is not None: self.MergeFromString(contents)
4513
4514   def name(self): return self.name_
4515
4516   def set_name(self, x):
4517     self.has_name_ = 1
4518     self.name_ = x
4519
4520   def clear_name(self):
4521     if self.has_name_:
4522       self.has_name_ = 0
4523       self.name_ = ""
4524
4525   def has_name(self): return self.has_name_
4526
4527   def params(self):
4528     if self.params_ is None:
4529       self.lazy_init_lock_.acquire()
4530       try:
4531         if self.params_ is None: self.params_ = FacetRequestParam()
4532       finally:
4533         self.lazy_init_lock_.release()
4534     return self.params_
4535
4536   def mutable_params(self): self.has_params_ = 1; return self.params()
4537
4538   def clear_params(self):
4539
4540     if self.has_params_:
4541       self.has_params_ = 0;
4542       if self.params_ is not None: self.params_.Clear()
4543
4544   def has_params(self): return self.has_params_
4545
4546
4547   def MergeFrom(self, x):
4548     assert x is not self
4549     if (x.has_name()): self.set_name(x.name())
4550     if (x.has_params()): self.mutable_params().MergeFrom(x.params())
4551
4552   def Equals(self, x):
4553     if x is self: return 1
4554     if self.has_name_ != x.has_name_: return 0
4555     if self.has_name_ and self.name_ != x.name_: return 0
4556     if self.has_params_ != x.has_params_: return 0
4557     if self.has_params_ and self.params_ != x.params_: return 0
4558     return 1
4559
4560   def IsInitialized(self, debug_strs=None):
4561     initialized = 1
4562     if (not self.has_name_):
4563       initialized = 0
4564       if debug_strs is not None:
4565         debug_strs.append('Required field: name not set.')
4566     if (self.has_params_ and not self.params_.IsInitialized(debug_strs)): initialized = 0
4567     return initialized
4568
4569   def ByteSize(self):
4570     n = 0
4571     n += self.lengthString(len(self.name_))
4572     if (self.has_params_): n += 1 + self.lengthString(self.params_.ByteSize())
4573     return n + 1
4574
4575   def ByteSizePartial(self):
4576     n = 0
4577     if (self.has_name_):
4578       n += 1
4579       n += self.lengthString(len(self.name_))
4580     if (self.has_params_): n += 1 + self.lengthString(self.params_.ByteSizePartial())
4581     return n
4582
4583   def Clear(self):
4584     self.clear_name()
4585     self.clear_params()
4586
4587   def OutputUnchecked(self, out):
4588     out.putVarInt32(10)
4589     out.putPrefixedString(self.name_)
4590     if (self.has_params_):
4591       out.putVarInt32(18)
4592       out.putVarInt32(self.params_.ByteSize())
4593       self.params_.OutputUnchecked(out)
4594
4595   def OutputPartial(self, out):
4596     if (self.has_name_):
4597       out.putVarInt32(10)
4598       out.putPrefixedString(self.name_)
4599     if (self.has_params_):
4600       out.putVarInt32(18)
4601       out.putVarInt32(self.params_.ByteSizePartial())
4602       self.params_.OutputPartial(out)
4603
4604   def TryMerge(self, d):
4605     while d.avail() > 0:
4606       tt = d.getVarInt32()
4607       if tt == 10:
4608         self.set_name(d.getPrefixedString())
4609         continue
4610       if tt == 18:
4611         length = d.getVarInt32()
4612         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
4613         d.skip(length)
4614         self.mutable_params().TryMerge(tmp)
4615         continue
4616
4617
4618       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
4619       d.skipData(tt)
4620
4621
4622   def __str__(self, prefix="", printElemNumber=0):
4623     res=""
4624     if self.has_name_: res+=prefix+("name: %s\n" % self.DebugFormatString(self.name_))
4625     if self.has_params_:
4626       res+=prefix+"params <\n"
4627       res+=self.params_.__str__(prefix + "  ", printElemNumber)
4628       res+=prefix+">\n"
4629     return res
4630
4631
4632   def _BuildTagLookupTable(sparse, maxtag, default=None):
4633     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
4634
4635   kname = 1
4636   kparams = 2
4637
4638   _TEXT = _BuildTagLookupTable({
4639     0: "ErrorCode",
4640     1: "name",
4641     2: "params",
4642   }, 2)
4643
4644   _TYPES = _BuildTagLookupTable({
4645     0: ProtocolBuffer.Encoder.NUMERIC,
4646     1: ProtocolBuffer.Encoder.STRING,
4647     2: ProtocolBuffer.Encoder.STRING,
4648   }, 2, ProtocolBuffer.Encoder.MAX_TYPE)
4649
4650
4651   _STYLE = """"""
4652   _STYLE_CONTENT_TYPE = """"""
4653   _PROTO_DESCRIPTOR_NAME = 'apphosting.FacetRequest'
4654 class FacetRefinement_Range(ProtocolBuffer.ProtocolMessage):
4655   has_start_ = 0
4656   start_ = ""
4657   has_end_ = 0
4658   end_ = ""
4659
4660   def __init__(self, contents=None):
4661     if contents is not None: self.MergeFromString(contents)
4662
4663   def start(self): return self.start_
4664
4665   def set_start(self, x):
4666     self.has_start_ = 1
4667     self.start_ = x
4668
4669   def clear_start(self):
4670     if self.has_start_:
4671       self.has_start_ = 0
4672       self.start_ = ""
4673
4674   def has_start(self): return self.has_start_
4675
4676   def end(self): return self.end_
4677
4678   def set_end(self, x):
4679     self.has_end_ = 1
4680     self.end_ = x
4681
4682   def clear_end(self):
4683     if self.has_end_:
4684       self.has_end_ = 0
4685       self.end_ = ""
4686
4687   def has_end(self): return self.has_end_
4688
4689
4690   def MergeFrom(self, x):
4691     assert x is not self
4692     if (x.has_start()): self.set_start(x.start())
4693     if (x.has_end()): self.set_end(x.end())
4694
4695   def Equals(self, x):
4696     if x is self: return 1
4697     if self.has_start_ != x.has_start_: return 0
4698     if self.has_start_ and self.start_ != x.start_: return 0
4699     if self.has_end_ != x.has_end_: return 0
4700     if self.has_end_ and self.end_ != x.end_: return 0
4701     return 1
4702
4703   def IsInitialized(self, debug_strs=None):
4704     initialized = 1
4705     return initialized
4706
4707   def ByteSize(self):
4708     n = 0
4709     if (self.has_start_): n += 1 + self.lengthString(len(self.start_))
4710     if (self.has_end_): n += 1 + self.lengthString(len(self.end_))
4711     return n
4712
4713   def ByteSizePartial(self):
4714     n = 0
4715     if (self.has_start_): n += 1 + self.lengthString(len(self.start_))
4716     if (self.has_end_): n += 1 + self.lengthString(len(self.end_))
4717     return n
4718
4719   def Clear(self):
4720     self.clear_start()
4721     self.clear_end()
4722
4723   def OutputUnchecked(self, out):
4724     if (self.has_start_):
4725       out.putVarInt32(10)
4726       out.putPrefixedString(self.start_)
4727     if (self.has_end_):
4728       out.putVarInt32(18)
4729       out.putPrefixedString(self.end_)
4730
4731   def OutputPartial(self, out):
4732     if (self.has_start_):
4733       out.putVarInt32(10)
4734       out.putPrefixedString(self.start_)
4735     if (self.has_end_):
4736       out.putVarInt32(18)
4737       out.putPrefixedString(self.end_)
4738
4739   def TryMerge(self, d):
4740     while d.avail() > 0:
4741       tt = d.getVarInt32()
4742       if tt == 10:
4743         self.set_start(d.getPrefixedString())
4744         continue
4745       if tt == 18:
4746         self.set_end(d.getPrefixedString())
4747         continue
4748
4749
4750       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
4751       d.skipData(tt)
4752
4753
4754   def __str__(self, prefix="", printElemNumber=0):
4755     res=""
4756     if self.has_start_: res+=prefix+("start: %s\n" % self.DebugFormatString(self.start_))
4757     if self.has_end_: res+=prefix+("end: %s\n" % self.DebugFormatString(self.end_))
4758     return res
4759
4760
4761   def _BuildTagLookupTable(sparse, maxtag, default=None):
4762     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
4763
4764   kstart = 1
4765   kend = 2
4766
4767   _TEXT = _BuildTagLookupTable({
4768     0: "ErrorCode",
4769     1: "start",
4770     2: "end",
4771   }, 2)
4772
4773   _TYPES = _BuildTagLookupTable({
4774     0: ProtocolBuffer.Encoder.NUMERIC,
4775     1: ProtocolBuffer.Encoder.STRING,
4776     2: ProtocolBuffer.Encoder.STRING,
4777   }, 2, ProtocolBuffer.Encoder.MAX_TYPE)
4778
4779
4780   _STYLE = """"""
4781   _STYLE_CONTENT_TYPE = """"""
4782   _PROTO_DESCRIPTOR_NAME = 'apphosting.FacetRefinement_Range'
4783 class FacetRefinement(ProtocolBuffer.ProtocolMessage):
4784   has_name_ = 0
4785   name_ = ""
4786   has_value_ = 0
4787   value_ = ""
4788   has_range_ = 0
4789   range_ = None
4790
4791   def __init__(self, contents=None):
4792     self.lazy_init_lock_ = thread.allocate_lock()
4793     if contents is not None: self.MergeFromString(contents)
4794
4795   def name(self): return self.name_
4796
4797   def set_name(self, x):
4798     self.has_name_ = 1
4799     self.name_ = x
4800
4801   def clear_name(self):
4802     if self.has_name_:
4803       self.has_name_ = 0
4804       self.name_ = ""
4805
4806   def has_name(self): return self.has_name_
4807
4808   def value(self): return self.value_
4809
4810   def set_value(self, x):
4811     self.has_value_ = 1
4812     self.value_ = x
4813
4814   def clear_value(self):
4815     if self.has_value_:
4816       self.has_value_ = 0
4817       self.value_ = ""
4818
4819   def has_value(self): return self.has_value_
4820
4821   def range(self):
4822     if self.range_ is None:
4823       self.lazy_init_lock_.acquire()
4824       try:
4825         if self.range_ is None: self.range_ = FacetRefinement_Range()
4826       finally:
4827         self.lazy_init_lock_.release()
4828     return self.range_
4829
4830   def mutable_range(self): self.has_range_ = 1; return self.range()
4831
4832   def clear_range(self):
4833
4834     if self.has_range_:
4835       self.has_range_ = 0;
4836       if self.range_ is not None: self.range_.Clear()
4837
4838   def has_range(self): return self.has_range_
4839
4840
4841   def MergeFrom(self, x):
4842     assert x is not self
4843     if (x.has_name()): self.set_name(x.name())
4844     if (x.has_value()): self.set_value(x.value())
4845     if (x.has_range()): self.mutable_range().MergeFrom(x.range())
4846
4847   def Equals(self, x):
4848     if x is self: return 1
4849     if self.has_name_ != x.has_name_: return 0
4850     if self.has_name_ and self.name_ != x.name_: return 0
4851     if self.has_value_ != x.has_value_: return 0
4852     if self.has_value_ and self.value_ != x.value_: return 0
4853     if self.has_range_ != x.has_range_: return 0
4854     if self.has_range_ and self.range_ != x.range_: return 0
4855     return 1
4856
4857   def IsInitialized(self, debug_strs=None):
4858     initialized = 1
4859     if (not self.has_name_):
4860       initialized = 0
4861       if debug_strs is not None:
4862         debug_strs.append('Required field: name not set.')
4863     if (self.has_range_ and not self.range_.IsInitialized(debug_strs)): initialized = 0
4864     return initialized
4865
4866   def ByteSize(self):
4867     n = 0
4868     n += self.lengthString(len(self.name_))
4869     if (self.has_value_): n += 1 + self.lengthString(len(self.value_))
4870     if (self.has_range_): n += 1 + self.lengthString(self.range_.ByteSize())
4871     return n + 1
4872
4873   def ByteSizePartial(self):
4874     n = 0
4875     if (self.has_name_):
4876       n += 1
4877       n += self.lengthString(len(self.name_))
4878     if (self.has_value_): n += 1 + self.lengthString(len(self.value_))
4879     if (self.has_range_): n += 1 + self.lengthString(self.range_.ByteSizePartial())
4880     return n
4881
4882   def Clear(self):
4883     self.clear_name()
4884     self.clear_value()
4885     self.clear_range()
4886
4887   def OutputUnchecked(self, out):
4888     out.putVarInt32(10)
4889     out.putPrefixedString(self.name_)
4890     if (self.has_value_):
4891       out.putVarInt32(18)
4892       out.putPrefixedString(self.value_)
4893     if (self.has_range_):
4894       out.putVarInt32(26)
4895       out.putVarInt32(self.range_.ByteSize())
4896       self.range_.OutputUnchecked(out)
4897
4898   def OutputPartial(self, out):
4899     if (self.has_name_):
4900       out.putVarInt32(10)
4901       out.putPrefixedString(self.name_)
4902     if (self.has_value_):
4903       out.putVarInt32(18)
4904       out.putPrefixedString(self.value_)
4905     if (self.has_range_):
4906       out.putVarInt32(26)
4907       out.putVarInt32(self.range_.ByteSizePartial())
4908       self.range_.OutputPartial(out)
4909
4910   def TryMerge(self, d):
4911     while d.avail() > 0:
4912       tt = d.getVarInt32()
4913       if tt == 10:
4914         self.set_name(d.getPrefixedString())
4915         continue
4916       if tt == 18:
4917         self.set_value(d.getPrefixedString())
4918         continue
4919       if tt == 26:
4920         length = d.getVarInt32()
4921         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
4922         d.skip(length)
4923         self.mutable_range().TryMerge(tmp)
4924         continue
4925
4926
4927       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
4928       d.skipData(tt)
4929
4930
4931   def __str__(self, prefix="", printElemNumber=0):
4932     res=""
4933     if self.has_name_: res+=prefix+("name: %s\n" % self.DebugFormatString(self.name_))
4934     if self.has_value_: res+=prefix+("value: %s\n" % self.DebugFormatString(self.value_))
4935     if self.has_range_:
4936       res+=prefix+"range <\n"
4937       res+=self.range_.__str__(prefix + "  ", printElemNumber)
4938       res+=prefix+">\n"
4939     return res
4940
4941
4942   def _BuildTagLookupTable(sparse, maxtag, default=None):
4943     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
4944
4945   kname = 1
4946   kvalue = 2
4947   krange = 3
4948
4949   _TEXT = _BuildTagLookupTable({
4950     0: "ErrorCode",
4951     1: "name",
4952     2: "value",
4953     3: "range",
4954   }, 3)
4955
4956   _TYPES = _BuildTagLookupTable({
4957     0: ProtocolBuffer.Encoder.NUMERIC,
4958     1: ProtocolBuffer.Encoder.STRING,
4959     2: ProtocolBuffer.Encoder.STRING,
4960     3: ProtocolBuffer.Encoder.STRING,
4961   }, 3, ProtocolBuffer.Encoder.MAX_TYPE)
4962
4963
4964   _STYLE = """"""
4965   _STYLE_CONTENT_TYPE = """"""
4966   _PROTO_DESCRIPTOR_NAME = 'apphosting.FacetRefinement'
4967 class SearchParams(ProtocolBuffer.ProtocolMessage):
4968
4969
4970   NONE         =    0
4971   SINGLE       =    1
4972   PER_RESULT   =    2
4973
4974   _CursorType_NAMES = {
4975     0: "NONE",
4976     1: "SINGLE",
4977     2: "PER_RESULT",
4978   }
4979
4980   def CursorType_Name(cls, x): return cls._CursorType_NAMES.get(x, "")
4981   CursorType_Name = classmethod(CursorType_Name)
4982
4983
4984
4985   STRICT       =    0
4986   RELAXED      =    1
4987
4988   _ParsingMode_NAMES = {
4989     0: "STRICT",
4990     1: "RELAXED",
4991   }
4992
4993   def ParsingMode_Name(cls, x): return cls._ParsingMode_NAMES.get(x, "")
4994   ParsingMode_Name = classmethod(ParsingMode_Name)
4995
4996   has_index_spec_ = 0
4997   has_query_ = 0
4998   query_ = ""
4999   has_cursor_ = 0
5000   cursor_ = ""
5001   has_offset_ = 0
5002   offset_ = 0
5003   has_cursor_type_ = 0
5004   cursor_type_ = 0
5005   has_limit_ = 0
5006   limit_ = 20
5007   has_matched_count_accuracy_ = 0
5008   matched_count_accuracy_ = 0
5009   has_scorer_spec_ = 0
5010   scorer_spec_ = None
5011   has_field_spec_ = 0
5012   field_spec_ = None
5013   has_keys_only_ = 0
5014   keys_only_ = 0
5015   has_parsing_mode_ = 0
5016   parsing_mode_ = 0
5017   has_auto_discover_facet_count_ = 0
5018   auto_discover_facet_count_ = 0
5019   has_facet_auto_detect_param_ = 0
5020   facet_auto_detect_param_ = None
5021   has_facet_depth_ = 0
5022   facet_depth_ = 1000
5023
5024   def __init__(self, contents=None):
5025     self.index_spec_ = IndexSpec()
5026     self.sort_spec_ = []
5027     self.include_facet_ = []
5028     self.facet_refinement_ = []
5029     self.lazy_init_lock_ = thread.allocate_lock()
5030     if contents is not None: self.MergeFromString(contents)
5031
5032   def index_spec(self): return self.index_spec_
5033
5034   def mutable_index_spec(self): self.has_index_spec_ = 1; return self.index_spec_
5035
5036   def clear_index_spec(self):self.has_index_spec_ = 0; self.index_spec_.Clear()
5037
5038   def has_index_spec(self): return self.has_index_spec_
5039
5040   def query(self): return self.query_
5041
5042   def set_query(self, x):
5043     self.has_query_ = 1
5044     self.query_ = x
5045
5046   def clear_query(self):
5047     if self.has_query_:
5048       self.has_query_ = 0
5049       self.query_ = ""
5050
5051   def has_query(self): return self.has_query_
5052
5053   def cursor(self): return self.cursor_
5054
5055   def set_cursor(self, x):
5056     self.has_cursor_ = 1
5057     self.cursor_ = x
5058
5059   def clear_cursor(self):
5060     if self.has_cursor_:
5061       self.has_cursor_ = 0
5062       self.cursor_ = ""
5063
5064   def has_cursor(self): return self.has_cursor_
5065
5066   def offset(self): return self.offset_
5067
5068   def set_offset(self, x):
5069     self.has_offset_ = 1
5070     self.offset_ = x
5071
5072   def clear_offset(self):
5073     if self.has_offset_:
5074       self.has_offset_ = 0
5075       self.offset_ = 0
5076
5077   def has_offset(self): return self.has_offset_
5078
5079   def cursor_type(self): return self.cursor_type_
5080
5081   def set_cursor_type(self, x):
5082     self.has_cursor_type_ = 1
5083     self.cursor_type_ = x
5084
5085   def clear_cursor_type(self):
5086     if self.has_cursor_type_:
5087       self.has_cursor_type_ = 0
5088       self.cursor_type_ = 0
5089
5090   def has_cursor_type(self): return self.has_cursor_type_
5091
5092   def limit(self): return self.limit_
5093
5094   def set_limit(self, x):
5095     self.has_limit_ = 1
5096     self.limit_ = x
5097
5098   def clear_limit(self):
5099     if self.has_limit_:
5100       self.has_limit_ = 0
5101       self.limit_ = 20
5102
5103   def has_limit(self): return self.has_limit_
5104
5105   def matched_count_accuracy(self): return self.matched_count_accuracy_
5106
5107   def set_matched_count_accuracy(self, x):
5108     self.has_matched_count_accuracy_ = 1
5109     self.matched_count_accuracy_ = x
5110
5111   def clear_matched_count_accuracy(self):
5112     if self.has_matched_count_accuracy_:
5113       self.has_matched_count_accuracy_ = 0
5114       self.matched_count_accuracy_ = 0
5115
5116   def has_matched_count_accuracy(self): return self.has_matched_count_accuracy_
5117
5118   def sort_spec_size(self): return len(self.sort_spec_)
5119   def sort_spec_list(self): return self.sort_spec_
5120
5121   def sort_spec(self, i):
5122     return self.sort_spec_[i]
5123
5124   def mutable_sort_spec(self, i):
5125     return self.sort_spec_[i]
5126
5127   def add_sort_spec(self):
5128     x = SortSpec()
5129     self.sort_spec_.append(x)
5130     return x
5131
5132   def clear_sort_spec(self):
5133     self.sort_spec_ = []
5134   def scorer_spec(self):
5135     if self.scorer_spec_ is None:
5136       self.lazy_init_lock_.acquire()
5137       try:
5138         if self.scorer_spec_ is None: self.scorer_spec_ = ScorerSpec()
5139       finally:
5140         self.lazy_init_lock_.release()
5141     return self.scorer_spec_
5142
5143   def mutable_scorer_spec(self): self.has_scorer_spec_ = 1; return self.scorer_spec()
5144
5145   def clear_scorer_spec(self):
5146
5147     if self.has_scorer_spec_:
5148       self.has_scorer_spec_ = 0;
5149       if self.scorer_spec_ is not None: self.scorer_spec_.Clear()
5150
5151   def has_scorer_spec(self): return self.has_scorer_spec_
5152
5153   def field_spec(self):
5154     if self.field_spec_ is None:
5155       self.lazy_init_lock_.acquire()
5156       try:
5157         if self.field_spec_ is None: self.field_spec_ = FieldSpec()
5158       finally:
5159         self.lazy_init_lock_.release()
5160     return self.field_spec_
5161
5162   def mutable_field_spec(self): self.has_field_spec_ = 1; return self.field_spec()
5163
5164   def clear_field_spec(self):
5165
5166     if self.has_field_spec_:
5167       self.has_field_spec_ = 0;
5168       if self.field_spec_ is not None: self.field_spec_.Clear()
5169
5170   def has_field_spec(self): return self.has_field_spec_
5171
5172   def keys_only(self): return self.keys_only_
5173
5174   def set_keys_only(self, x):
5175     self.has_keys_only_ = 1
5176     self.keys_only_ = x
5177
5178   def clear_keys_only(self):
5179     if self.has_keys_only_:
5180       self.has_keys_only_ = 0
5181       self.keys_only_ = 0
5182
5183   def has_keys_only(self): return self.has_keys_only_
5184
5185   def parsing_mode(self): return self.parsing_mode_
5186
5187   def set_parsing_mode(self, x):
5188     self.has_parsing_mode_ = 1
5189     self.parsing_mode_ = x
5190
5191   def clear_parsing_mode(self):
5192     if self.has_parsing_mode_:
5193       self.has_parsing_mode_ = 0
5194       self.parsing_mode_ = 0
5195
5196   def has_parsing_mode(self): return self.has_parsing_mode_
5197
5198   def auto_discover_facet_count(self): return self.auto_discover_facet_count_
5199
5200   def set_auto_discover_facet_count(self, x):
5201     self.has_auto_discover_facet_count_ = 1
5202     self.auto_discover_facet_count_ = x
5203
5204   def clear_auto_discover_facet_count(self):
5205     if self.has_auto_discover_facet_count_:
5206       self.has_auto_discover_facet_count_ = 0
5207       self.auto_discover_facet_count_ = 0
5208
5209   def has_auto_discover_facet_count(self): return self.has_auto_discover_facet_count_
5210
5211   def include_facet_size(self): return len(self.include_facet_)
5212   def include_facet_list(self): return self.include_facet_
5213
5214   def include_facet(self, i):
5215     return self.include_facet_[i]
5216
5217   def mutable_include_facet(self, i):
5218     return self.include_facet_[i]
5219
5220   def add_include_facet(self):
5221     x = FacetRequest()
5222     self.include_facet_.append(x)
5223     return x
5224
5225   def clear_include_facet(self):
5226     self.include_facet_ = []
5227   def facet_refinement_size(self): return len(self.facet_refinement_)
5228   def facet_refinement_list(self): return self.facet_refinement_
5229
5230   def facet_refinement(self, i):
5231     return self.facet_refinement_[i]
5232
5233   def mutable_facet_refinement(self, i):
5234     return self.facet_refinement_[i]
5235
5236   def add_facet_refinement(self):
5237     x = FacetRefinement()
5238     self.facet_refinement_.append(x)
5239     return x
5240
5241   def clear_facet_refinement(self):
5242     self.facet_refinement_ = []
5243   def facet_auto_detect_param(self):
5244     if self.facet_auto_detect_param_ is None:
5245       self.lazy_init_lock_.acquire()
5246       try:
5247         if self.facet_auto_detect_param_ is None: self.facet_auto_detect_param_ = FacetAutoDetectParam()
5248       finally:
5249         self.lazy_init_lock_.release()
5250     return self.facet_auto_detect_param_
5251
5252   def mutable_facet_auto_detect_param(self): self.has_facet_auto_detect_param_ = 1; return self.facet_auto_detect_param()
5253
5254   def clear_facet_auto_detect_param(self):
5255
5256     if self.has_facet_auto_detect_param_:
5257       self.has_facet_auto_detect_param_ = 0;
5258       if self.facet_auto_detect_param_ is not None: self.facet_auto_detect_param_.Clear()
5259
5260   def has_facet_auto_detect_param(self): return self.has_facet_auto_detect_param_
5261
5262   def facet_depth(self): return self.facet_depth_
5263
5264   def set_facet_depth(self, x):
5265     self.has_facet_depth_ = 1
5266     self.facet_depth_ = x
5267
5268   def clear_facet_depth(self):
5269     if self.has_facet_depth_:
5270       self.has_facet_depth_ = 0
5271       self.facet_depth_ = 1000
5272
5273   def has_facet_depth(self): return self.has_facet_depth_
5274
5275
5276   def MergeFrom(self, x):
5277     assert x is not self
5278     if (x.has_index_spec()): self.mutable_index_spec().MergeFrom(x.index_spec())
5279     if (x.has_query()): self.set_query(x.query())
5280     if (x.has_cursor()): self.set_cursor(x.cursor())
5281     if (x.has_offset()): self.set_offset(x.offset())
5282     if (x.has_cursor_type()): self.set_cursor_type(x.cursor_type())
5283     if (x.has_limit()): self.set_limit(x.limit())
5284     if (x.has_matched_count_accuracy()): self.set_matched_count_accuracy(x.matched_count_accuracy())
5285     for i in xrange(x.sort_spec_size()): self.add_sort_spec().CopyFrom(x.sort_spec(i))
5286     if (x.has_scorer_spec()): self.mutable_scorer_spec().MergeFrom(x.scorer_spec())
5287     if (x.has_field_spec()): self.mutable_field_spec().MergeFrom(x.field_spec())
5288     if (x.has_keys_only()): self.set_keys_only(x.keys_only())
5289     if (x.has_parsing_mode()): self.set_parsing_mode(x.parsing_mode())
5290     if (x.has_auto_discover_facet_count()): self.set_auto_discover_facet_count(x.auto_discover_facet_count())
5291     for i in xrange(x.include_facet_size()): self.add_include_facet().CopyFrom(x.include_facet(i))
5292     for i in xrange(x.facet_refinement_size()): self.add_facet_refinement().CopyFrom(x.facet_refinement(i))
5293     if (x.has_facet_auto_detect_param()): self.mutable_facet_auto_detect_param().MergeFrom(x.facet_auto_detect_param())
5294     if (x.has_facet_depth()): self.set_facet_depth(x.facet_depth())
5295
5296   def Equals(self, x):
5297     if x is self: return 1
5298     if self.has_index_spec_ != x.has_index_spec_: return 0
5299     if self.has_index_spec_ and self.index_spec_ != x.index_spec_: return 0
5300     if self.has_query_ != x.has_query_: return 0
5301     if self.has_query_ and self.query_ != x.query_: return 0
5302     if self.has_cursor_ != x.has_cursor_: return 0
5303     if self.has_cursor_ and self.cursor_ != x.cursor_: return 0
5304     if self.has_offset_ != x.has_offset_: return 0
5305     if self.has_offset_ and self.offset_ != x.offset_: return 0
5306     if self.has_cursor_type_ != x.has_cursor_type_: return 0
5307     if self.has_cursor_type_ and self.cursor_type_ != x.cursor_type_: return 0
5308     if self.has_limit_ != x.has_limit_: return 0
5309     if self.has_limit_ and self.limit_ != x.limit_: return 0
5310     if self.has_matched_count_accuracy_ != x.has_matched_count_accuracy_: return 0
5311     if self.has_matched_count_accuracy_ and self.matched_count_accuracy_ != x.matched_count_accuracy_: return 0
5312     if len(self.sort_spec_) != len(x.sort_spec_): return 0
5313     for e1, e2 in zip(self.sort_spec_, x.sort_spec_):
5314       if e1 != e2: return 0
5315     if self.has_scorer_spec_ != x.has_scorer_spec_: return 0
5316     if self.has_scorer_spec_ and self.scorer_spec_ != x.scorer_spec_: return 0
5317     if self.has_field_spec_ != x.has_field_spec_: return 0
5318     if self.has_field_spec_ and self.field_spec_ != x.field_spec_: return 0
5319     if self.has_keys_only_ != x.has_keys_only_: return 0
5320     if self.has_keys_only_ and self.keys_only_ != x.keys_only_: return 0
5321     if self.has_parsing_mode_ != x.has_parsing_mode_: return 0
5322     if self.has_parsing_mode_ and self.parsing_mode_ != x.parsing_mode_: return 0
5323     if self.has_auto_discover_facet_count_ != x.has_auto_discover_facet_count_: return 0
5324     if self.has_auto_discover_facet_count_ and self.auto_discover_facet_count_ != x.auto_discover_facet_count_: return 0
5325     if len(self.include_facet_) != len(x.include_facet_): return 0
5326     for e1, e2 in zip(self.include_facet_, x.include_facet_):
5327       if e1 != e2: return 0
5328     if len(self.facet_refinement_) != len(x.facet_refinement_): return 0
5329     for e1, e2 in zip(self.facet_refinement_, x.facet_refinement_):
5330       if e1 != e2: return 0
5331     if self.has_facet_auto_detect_param_ != x.has_facet_auto_detect_param_: return 0
5332     if self.has_facet_auto_detect_param_ and self.facet_auto_detect_param_ != x.facet_auto_detect_param_: return 0
5333     if self.has_facet_depth_ != x.has_facet_depth_: return 0
5334     if self.has_facet_depth_ and self.facet_depth_ != x.facet_depth_: return 0
5335     return 1
5336
5337   def IsInitialized(self, debug_strs=None):
5338     initialized = 1
5339     if (not self.has_index_spec_):
5340       initialized = 0
5341       if debug_strs is not None:
5342         debug_strs.append('Required field: index_spec not set.')
5343     elif not self.index_spec_.IsInitialized(debug_strs): initialized = 0
5344     if (not self.has_query_):
5345       initialized = 0
5346       if debug_strs is not None:
5347         debug_strs.append('Required field: query not set.')
5348     for p in self.sort_spec_:
5349       if not p.IsInitialized(debug_strs): initialized=0
5350     if (self.has_scorer_spec_ and not self.scorer_spec_.IsInitialized(debug_strs)): initialized = 0
5351     if (self.has_field_spec_ and not self.field_spec_.IsInitialized(debug_strs)): initialized = 0
5352     for p in self.include_facet_:
5353       if not p.IsInitialized(debug_strs): initialized=0
5354     for p in self.facet_refinement_:
5355       if not p.IsInitialized(debug_strs): initialized=0
5356     if (self.has_facet_auto_detect_param_ and not self.facet_auto_detect_param_.IsInitialized(debug_strs)): initialized = 0
5357     return initialized
5358
5359   def ByteSize(self):
5360     n = 0
5361     n += self.lengthString(self.index_spec_.ByteSize())
5362     n += self.lengthString(len(self.query_))
5363     if (self.has_cursor_): n += 1 + self.lengthString(len(self.cursor_))
5364     if (self.has_offset_): n += 1 + self.lengthVarInt64(self.offset_)
5365     if (self.has_cursor_type_): n += 1 + self.lengthVarInt64(self.cursor_type_)
5366     if (self.has_limit_): n += 1 + self.lengthVarInt64(self.limit_)
5367     if (self.has_matched_count_accuracy_): n += 1 + self.lengthVarInt64(self.matched_count_accuracy_)
5368     n += 1 * len(self.sort_spec_)
5369     for i in xrange(len(self.sort_spec_)): n += self.lengthString(self.sort_spec_[i].ByteSize())
5370     if (self.has_scorer_spec_): n += 1 + self.lengthString(self.scorer_spec_.ByteSize())
5371     if (self.has_field_spec_): n += 1 + self.lengthString(self.field_spec_.ByteSize())
5372     if (self.has_keys_only_): n += 2
5373     if (self.has_parsing_mode_): n += 1 + self.lengthVarInt64(self.parsing_mode_)
5374     if (self.has_auto_discover_facet_count_): n += 1 + self.lengthVarInt64(self.auto_discover_facet_count_)
5375     n += 2 * len(self.include_facet_)
5376     for i in xrange(len(self.include_facet_)): n += self.lengthString(self.include_facet_[i].ByteSize())
5377     n += 2 * len(self.facet_refinement_)
5378     for i in xrange(len(self.facet_refinement_)): n += self.lengthString(self.facet_refinement_[i].ByteSize())
5379     if (self.has_facet_auto_detect_param_): n += 2 + self.lengthString(self.facet_auto_detect_param_.ByteSize())
5380     if (self.has_facet_depth_): n += 2 + self.lengthVarInt64(self.facet_depth_)
5381     return n + 2
5382
5383   def ByteSizePartial(self):
5384     n = 0
5385     if (self.has_index_spec_):
5386       n += 1
5387       n += self.lengthString(self.index_spec_.ByteSizePartial())
5388     if (self.has_query_):
5389       n += 1
5390       n += self.lengthString(len(self.query_))
5391     if (self.has_cursor_): n += 1 + self.lengthString(len(self.cursor_))
5392     if (self.has_offset_): n += 1 + self.lengthVarInt64(self.offset_)
5393     if (self.has_cursor_type_): n += 1 + self.lengthVarInt64(self.cursor_type_)
5394     if (self.has_limit_): n += 1 + self.lengthVarInt64(self.limit_)
5395     if (self.has_matched_count_accuracy_): n += 1 + self.lengthVarInt64(self.matched_count_accuracy_)
5396     n += 1 * len(self.sort_spec_)
5397     for i in xrange(len(self.sort_spec_)): n += self.lengthString(self.sort_spec_[i].ByteSizePartial())
5398     if (self.has_scorer_spec_): n += 1 + self.lengthString(self.scorer_spec_.ByteSizePartial())
5399     if (self.has_field_spec_): n += 1 + self.lengthString(self.field_spec_.ByteSizePartial())
5400     if (self.has_keys_only_): n += 2
5401     if (self.has_parsing_mode_): n += 1 + self.lengthVarInt64(self.parsing_mode_)
5402     if (self.has_auto_discover_facet_count_): n += 1 + self.lengthVarInt64(self.auto_discover_facet_count_)
5403     n += 2 * len(self.include_facet_)
5404     for i in xrange(len(self.include_facet_)): n += self.lengthString(self.include_facet_[i].ByteSizePartial())
5405     n += 2 * len(self.facet_refinement_)
5406     for i in xrange(len(self.facet_refinement_)): n += self.lengthString(self.facet_refinement_[i].ByteSizePartial())
5407     if (self.has_facet_auto_detect_param_): n += 2 + self.lengthString(self.facet_auto_detect_param_.ByteSizePartial())
5408     if (self.has_facet_depth_): n += 2 + self.lengthVarInt64(self.facet_depth_)
5409     return n
5410
5411   def Clear(self):
5412     self.clear_index_spec()
5413     self.clear_query()
5414     self.clear_cursor()
5415     self.clear_offset()
5416     self.clear_cursor_type()
5417     self.clear_limit()
5418     self.clear_matched_count_accuracy()
5419     self.clear_sort_spec()
5420     self.clear_scorer_spec()
5421     self.clear_field_spec()
5422     self.clear_keys_only()
5423     self.clear_parsing_mode()
5424     self.clear_auto_discover_facet_count()
5425     self.clear_include_facet()
5426     self.clear_facet_refinement()
5427     self.clear_facet_auto_detect_param()
5428     self.clear_facet_depth()
5429
5430   def OutputUnchecked(self, out):
5431     out.putVarInt32(10)
5432     out.putVarInt32(self.index_spec_.ByteSize())
5433     self.index_spec_.OutputUnchecked(out)
5434     out.putVarInt32(18)
5435     out.putPrefixedString(self.query_)
5436     if (self.has_cursor_):
5437       out.putVarInt32(34)
5438       out.putPrefixedString(self.cursor_)
5439     if (self.has_cursor_type_):
5440       out.putVarInt32(40)
5441       out.putVarInt32(self.cursor_type_)
5442     if (self.has_limit_):
5443       out.putVarInt32(48)
5444       out.putVarInt32(self.limit_)
5445     if (self.has_matched_count_accuracy_):
5446       out.putVarInt32(56)
5447       out.putVarInt32(self.matched_count_accuracy_)
5448     for i in xrange(len(self.sort_spec_)):
5449       out.putVarInt32(66)
5450       out.putVarInt32(self.sort_spec_[i].ByteSize())
5451       self.sort_spec_[i].OutputUnchecked(out)
5452     if (self.has_scorer_spec_):
5453       out.putVarInt32(74)
5454       out.putVarInt32(self.scorer_spec_.ByteSize())
5455       self.scorer_spec_.OutputUnchecked(out)
5456     if (self.has_field_spec_):
5457       out.putVarInt32(82)
5458       out.putVarInt32(self.field_spec_.ByteSize())
5459       self.field_spec_.OutputUnchecked(out)
5460     if (self.has_offset_):
5461       out.putVarInt32(88)
5462       out.putVarInt32(self.offset_)
5463     if (self.has_keys_only_):
5464       out.putVarInt32(96)
5465       out.putBoolean(self.keys_only_)
5466     if (self.has_parsing_mode_):
5467       out.putVarInt32(104)
5468       out.putVarInt32(self.parsing_mode_)
5469     if (self.has_auto_discover_facet_count_):
5470       out.putVarInt32(120)
5471       out.putVarInt32(self.auto_discover_facet_count_)
5472     for i in xrange(len(self.include_facet_)):
5473       out.putVarInt32(130)
5474       out.putVarInt32(self.include_facet_[i].ByteSize())
5475       self.include_facet_[i].OutputUnchecked(out)
5476     for i in xrange(len(self.facet_refinement_)):
5477       out.putVarInt32(138)
5478       out.putVarInt32(self.facet_refinement_[i].ByteSize())
5479       self.facet_refinement_[i].OutputUnchecked(out)
5480     if (self.has_facet_auto_detect_param_):
5481       out.putVarInt32(146)
5482       out.putVarInt32(self.facet_auto_detect_param_.ByteSize())
5483       self.facet_auto_detect_param_.OutputUnchecked(out)
5484     if (self.has_facet_depth_):
5485       out.putVarInt32(152)
5486       out.putVarInt32(self.facet_depth_)
5487
5488   def OutputPartial(self, out):
5489     if (self.has_index_spec_):
5490       out.putVarInt32(10)
5491       out.putVarInt32(self.index_spec_.ByteSizePartial())
5492       self.index_spec_.OutputPartial(out)
5493     if (self.has_query_):
5494       out.putVarInt32(18)
5495       out.putPrefixedString(self.query_)
5496     if (self.has_cursor_):
5497       out.putVarInt32(34)
5498       out.putPrefixedString(self.cursor_)
5499     if (self.has_cursor_type_):
5500       out.putVarInt32(40)
5501       out.putVarInt32(self.cursor_type_)
5502     if (self.has_limit_):
5503       out.putVarInt32(48)
5504       out.putVarInt32(self.limit_)
5505     if (self.has_matched_count_accuracy_):
5506       out.putVarInt32(56)
5507       out.putVarInt32(self.matched_count_accuracy_)
5508     for i in xrange(len(self.sort_spec_)):
5509       out.putVarInt32(66)
5510       out.putVarInt32(self.sort_spec_[i].ByteSizePartial())
5511       self.sort_spec_[i].OutputPartial(out)
5512     if (self.has_scorer_spec_):
5513       out.putVarInt32(74)
5514       out.putVarInt32(self.scorer_spec_.ByteSizePartial())
5515       self.scorer_spec_.OutputPartial(out)
5516     if (self.has_field_spec_):
5517       out.putVarInt32(82)
5518       out.putVarInt32(self.field_spec_.ByteSizePartial())
5519       self.field_spec_.OutputPartial(out)
5520     if (self.has_offset_):
5521       out.putVarInt32(88)
5522       out.putVarInt32(self.offset_)
5523     if (self.has_keys_only_):
5524       out.putVarInt32(96)
5525       out.putBoolean(self.keys_only_)
5526     if (self.has_parsing_mode_):
5527       out.putVarInt32(104)
5528       out.putVarInt32(self.parsing_mode_)
5529     if (self.has_auto_discover_facet_count_):
5530       out.putVarInt32(120)
5531       out.putVarInt32(self.auto_discover_facet_count_)
5532     for i in xrange(len(self.include_facet_)):
5533       out.putVarInt32(130)
5534       out.putVarInt32(self.include_facet_[i].ByteSizePartial())
5535       self.include_facet_[i].OutputPartial(out)
5536     for i in xrange(len(self.facet_refinement_)):
5537       out.putVarInt32(138)
5538       out.putVarInt32(self.facet_refinement_[i].ByteSizePartial())
5539       self.facet_refinement_[i].OutputPartial(out)
5540     if (self.has_facet_auto_detect_param_):
5541       out.putVarInt32(146)
5542       out.putVarInt32(self.facet_auto_detect_param_.ByteSizePartial())
5543       self.facet_auto_detect_param_.OutputPartial(out)
5544     if (self.has_facet_depth_):
5545       out.putVarInt32(152)
5546       out.putVarInt32(self.facet_depth_)
5547
5548   def TryMerge(self, d):
5549     while d.avail() > 0:
5550       tt = d.getVarInt32()
5551       if tt == 10:
5552         length = d.getVarInt32()
5553         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
5554         d.skip(length)
5555         self.mutable_index_spec().TryMerge(tmp)
5556         continue
5557       if tt == 18:
5558         self.set_query(d.getPrefixedString())
5559         continue
5560       if tt == 34:
5561         self.set_cursor(d.getPrefixedString())
5562         continue
5563       if tt == 40:
5564         self.set_cursor_type(d.getVarInt32())
5565         continue
5566       if tt == 48:
5567         self.set_limit(d.getVarInt32())
5568         continue
5569       if tt == 56:
5570         self.set_matched_count_accuracy(d.getVarInt32())
5571         continue
5572       if tt == 66:
5573         length = d.getVarInt32()
5574         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
5575         d.skip(length)
5576         self.add_sort_spec().TryMerge(tmp)
5577         continue
5578       if tt == 74:
5579         length = d.getVarInt32()
5580         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
5581         d.skip(length)
5582         self.mutable_scorer_spec().TryMerge(tmp)
5583         continue
5584       if tt == 82:
5585         length = d.getVarInt32()
5586         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
5587         d.skip(length)
5588         self.mutable_field_spec().TryMerge(tmp)
5589         continue
5590       if tt == 88:
5591         self.set_offset(d.getVarInt32())
5592         continue
5593       if tt == 96:
5594         self.set_keys_only(d.getBoolean())
5595         continue
5596       if tt == 104:
5597         self.set_parsing_mode(d.getVarInt32())
5598         continue
5599       if tt == 120:
5600         self.set_auto_discover_facet_count(d.getVarInt32())
5601         continue
5602       if tt == 130:
5603         length = d.getVarInt32()
5604         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
5605         d.skip(length)
5606         self.add_include_facet().TryMerge(tmp)
5607         continue
5608       if tt == 138:
5609         length = d.getVarInt32()
5610         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
5611         d.skip(length)
5612         self.add_facet_refinement().TryMerge(tmp)
5613         continue
5614       if tt == 146:
5615         length = d.getVarInt32()
5616         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
5617         d.skip(length)
5618         self.mutable_facet_auto_detect_param().TryMerge(tmp)
5619         continue
5620       if tt == 152:
5621         self.set_facet_depth(d.getVarInt32())
5622         continue
5623
5624
5625       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
5626       d.skipData(tt)
5627
5628
5629   def __str__(self, prefix="", printElemNumber=0):
5630     res=""
5631     if self.has_index_spec_:
5632       res+=prefix+"index_spec <\n"
5633       res+=self.index_spec_.__str__(prefix + "  ", printElemNumber)
5634       res+=prefix+">\n"
5635     if self.has_query_: res+=prefix+("query: %s\n" % self.DebugFormatString(self.query_))
5636     if self.has_cursor_: res+=prefix+("cursor: %s\n" % self.DebugFormatString(self.cursor_))
5637     if self.has_offset_: res+=prefix+("offset: %s\n" % self.DebugFormatInt32(self.offset_))
5638     if self.has_cursor_type_: res+=prefix+("cursor_type: %s\n" % self.DebugFormatInt32(self.cursor_type_))
5639     if self.has_limit_: res+=prefix+("limit: %s\n" % self.DebugFormatInt32(self.limit_))
5640     if self.has_matched_count_accuracy_: res+=prefix+("matched_count_accuracy: %s\n" % self.DebugFormatInt32(self.matched_count_accuracy_))
5641     cnt=0
5642     for e in self.sort_spec_:
5643       elm=""
5644       if printElemNumber: elm="(%d)" % cnt
5645       res+=prefix+("sort_spec%s <\n" % elm)
5646       res+=e.__str__(prefix + "  ", printElemNumber)
5647       res+=prefix+">\n"
5648       cnt+=1
5649     if self.has_scorer_spec_:
5650       res+=prefix+"scorer_spec <\n"
5651       res+=self.scorer_spec_.__str__(prefix + "  ", printElemNumber)
5652       res+=prefix+">\n"
5653     if self.has_field_spec_:
5654       res+=prefix+"field_spec <\n"
5655       res+=self.field_spec_.__str__(prefix + "  ", printElemNumber)
5656       res+=prefix+">\n"
5657     if self.has_keys_only_: res+=prefix+("keys_only: %s\n" % self.DebugFormatBool(self.keys_only_))
5658     if self.has_parsing_mode_: res+=prefix+("parsing_mode: %s\n" % self.DebugFormatInt32(self.parsing_mode_))
5659     if self.has_auto_discover_facet_count_: res+=prefix+("auto_discover_facet_count: %s\n" % self.DebugFormatInt32(self.auto_discover_facet_count_))
5660     cnt=0
5661     for e in self.include_facet_:
5662       elm=""
5663       if printElemNumber: elm="(%d)" % cnt
5664       res+=prefix+("include_facet%s <\n" % elm)
5665       res+=e.__str__(prefix + "  ", printElemNumber)
5666       res+=prefix+">\n"
5667       cnt+=1
5668     cnt=0
5669     for e in self.facet_refinement_:
5670       elm=""
5671       if printElemNumber: elm="(%d)" % cnt
5672       res+=prefix+("facet_refinement%s <\n" % elm)
5673       res+=e.__str__(prefix + "  ", printElemNumber)
5674       res+=prefix+">\n"
5675       cnt+=1
5676     if self.has_facet_auto_detect_param_:
5677       res+=prefix+"facet_auto_detect_param <\n"
5678       res+=self.facet_auto_detect_param_.__str__(prefix + "  ", printElemNumber)
5679       res+=prefix+">\n"
5680     if self.has_facet_depth_: res+=prefix+("facet_depth: %s\n" % self.DebugFormatInt32(self.facet_depth_))
5681     return res
5682
5683
5684   def _BuildTagLookupTable(sparse, maxtag, default=None):
5685     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
5686
5687   kindex_spec = 1
5688   kquery = 2
5689   kcursor = 4
5690   koffset = 11
5691   kcursor_type = 5
5692   klimit = 6
5693   kmatched_count_accuracy = 7
5694   ksort_spec = 8
5695   kscorer_spec = 9
5696   kfield_spec = 10
5697   kkeys_only = 12
5698   kparsing_mode = 13
5699   kauto_discover_facet_count = 15
5700   kinclude_facet = 16
5701   kfacet_refinement = 17
5702   kfacet_auto_detect_param = 18
5703   kfacet_depth = 19
5704
5705   _TEXT = _BuildTagLookupTable({
5706     0: "ErrorCode",
5707     1: "index_spec",
5708     2: "query",
5709     4: "cursor",
5710     5: "cursor_type",
5711     6: "limit",
5712     7: "matched_count_accuracy",
5713     8: "sort_spec",
5714     9: "scorer_spec",
5715     10: "field_spec",
5716     11: "offset",
5717     12: "keys_only",
5718     13: "parsing_mode",
5719     15: "auto_discover_facet_count",
5720     16: "include_facet",
5721     17: "facet_refinement",
5722     18: "facet_auto_detect_param",
5723     19: "facet_depth",
5724   }, 19)
5725
5726   _TYPES = _BuildTagLookupTable({
5727     0: ProtocolBuffer.Encoder.NUMERIC,
5728     1: ProtocolBuffer.Encoder.STRING,
5729     2: ProtocolBuffer.Encoder.STRING,
5730     4: ProtocolBuffer.Encoder.STRING,
5731     5: ProtocolBuffer.Encoder.NUMERIC,
5732     6: ProtocolBuffer.Encoder.NUMERIC,
5733     7: ProtocolBuffer.Encoder.NUMERIC,
5734     8: ProtocolBuffer.Encoder.STRING,
5735     9: ProtocolBuffer.Encoder.STRING,
5736     10: ProtocolBuffer.Encoder.STRING,
5737     11: ProtocolBuffer.Encoder.NUMERIC,
5738     12: ProtocolBuffer.Encoder.NUMERIC,
5739     13: ProtocolBuffer.Encoder.NUMERIC,
5740     15: ProtocolBuffer.Encoder.NUMERIC,
5741     16: ProtocolBuffer.Encoder.STRING,
5742     17: ProtocolBuffer.Encoder.STRING,
5743     18: ProtocolBuffer.Encoder.STRING,
5744     19: ProtocolBuffer.Encoder.NUMERIC,
5745   }, 19, ProtocolBuffer.Encoder.MAX_TYPE)
5746
5747
5748   _STYLE = """"""
5749   _STYLE_CONTENT_TYPE = """"""
5750   _PROTO_DESCRIPTOR_NAME = 'apphosting.SearchParams'
5751 class SearchRequest(ProtocolBuffer.ProtocolMessage):
5752   has_params_ = 0
5753   has_app_id_ = 0
5754   app_id_ = ""
5755
5756   def __init__(self, contents=None):
5757     self.params_ = SearchParams()
5758     if contents is not None: self.MergeFromString(contents)
5759
5760   def params(self): return self.params_
5761
5762   def mutable_params(self): self.has_params_ = 1; return self.params_
5763
5764   def clear_params(self):self.has_params_ = 0; self.params_.Clear()
5765
5766   def has_params(self): return self.has_params_
5767
5768   def app_id(self): return self.app_id_
5769
5770   def set_app_id(self, x):
5771     self.has_app_id_ = 1
5772     self.app_id_ = x
5773
5774   def clear_app_id(self):
5775     if self.has_app_id_:
5776       self.has_app_id_ = 0
5777       self.app_id_ = ""
5778
5779   def has_app_id(self): return self.has_app_id_
5780
5781
5782   def MergeFrom(self, x):
5783     assert x is not self
5784     if (x.has_params()): self.mutable_params().MergeFrom(x.params())
5785     if (x.has_app_id()): self.set_app_id(x.app_id())
5786
5787   def Equals(self, x):
5788     if x is self: return 1
5789     if self.has_params_ != x.has_params_: return 0
5790     if self.has_params_ and self.params_ != x.params_: return 0
5791     if self.has_app_id_ != x.has_app_id_: return 0
5792     if self.has_app_id_ and self.app_id_ != x.app_id_: return 0
5793     return 1
5794
5795   def IsInitialized(self, debug_strs=None):
5796     initialized = 1
5797     if (not self.has_params_):
5798       initialized = 0
5799       if debug_strs is not None:
5800         debug_strs.append('Required field: params not set.')
5801     elif not self.params_.IsInitialized(debug_strs): initialized = 0
5802     return initialized
5803
5804   def ByteSize(self):
5805     n = 0
5806     n += self.lengthString(self.params_.ByteSize())
5807     if (self.has_app_id_): n += 1 + self.lengthString(len(self.app_id_))
5808     return n + 1
5809
5810   def ByteSizePartial(self):
5811     n = 0
5812     if (self.has_params_):
5813       n += 1
5814       n += self.lengthString(self.params_.ByteSizePartial())
5815     if (self.has_app_id_): n += 1 + self.lengthString(len(self.app_id_))
5816     return n
5817
5818   def Clear(self):
5819     self.clear_params()
5820     self.clear_app_id()
5821
5822   def OutputUnchecked(self, out):
5823     out.putVarInt32(10)
5824     out.putVarInt32(self.params_.ByteSize())
5825     self.params_.OutputUnchecked(out)
5826     if (self.has_app_id_):
5827       out.putVarInt32(26)
5828       out.putPrefixedString(self.app_id_)
5829
5830   def OutputPartial(self, out):
5831     if (self.has_params_):
5832       out.putVarInt32(10)
5833       out.putVarInt32(self.params_.ByteSizePartial())
5834       self.params_.OutputPartial(out)
5835     if (self.has_app_id_):
5836       out.putVarInt32(26)
5837       out.putPrefixedString(self.app_id_)
5838
5839   def TryMerge(self, d):
5840     while d.avail() > 0:
5841       tt = d.getVarInt32()
5842       if tt == 10:
5843         length = d.getVarInt32()
5844         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
5845         d.skip(length)
5846         self.mutable_params().TryMerge(tmp)
5847         continue
5848       if tt == 26:
5849         self.set_app_id(d.getPrefixedString())
5850         continue
5851
5852
5853       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
5854       d.skipData(tt)
5855
5856
5857   def __str__(self, prefix="", printElemNumber=0):
5858     res=""
5859     if self.has_params_:
5860       res+=prefix+"params <\n"
5861       res+=self.params_.__str__(prefix + "  ", printElemNumber)
5862       res+=prefix+">\n"
5863     if self.has_app_id_: res+=prefix+("app_id: %s\n" % self.DebugFormatString(self.app_id_))
5864     return res
5865
5866
5867   def _BuildTagLookupTable(sparse, maxtag, default=None):
5868     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
5869
5870   kparams = 1
5871   kapp_id = 3
5872
5873   _TEXT = _BuildTagLookupTable({
5874     0: "ErrorCode",
5875     1: "params",
5876     3: "app_id",
5877   }, 3)
5878
5879   _TYPES = _BuildTagLookupTable({
5880     0: ProtocolBuffer.Encoder.NUMERIC,
5881     1: ProtocolBuffer.Encoder.STRING,
5882     3: ProtocolBuffer.Encoder.STRING,
5883   }, 3, ProtocolBuffer.Encoder.MAX_TYPE)
5884
5885
5886   _STYLE = """"""
5887   _STYLE_CONTENT_TYPE = """"""
5888   _PROTO_DESCRIPTOR_NAME = 'apphosting.SearchRequest'
5889 class FacetResultValue(ProtocolBuffer.ProtocolMessage):
5890   has_name_ = 0
5891   name_ = ""
5892   has_count_ = 0
5893   count_ = 0
5894   has_refinement_ = 0
5895
5896   def __init__(self, contents=None):
5897     self.refinement_ = FacetRefinement()
5898     if contents is not None: self.MergeFromString(contents)
5899
5900   def name(self): return self.name_
5901
5902   def set_name(self, x):
5903     self.has_name_ = 1
5904     self.name_ = x
5905
5906   def clear_name(self):
5907     if self.has_name_:
5908       self.has_name_ = 0
5909       self.name_ = ""
5910
5911   def has_name(self): return self.has_name_
5912
5913   def count(self): return self.count_
5914
5915   def set_count(self, x):
5916     self.has_count_ = 1
5917     self.count_ = x
5918
5919   def clear_count(self):
5920     if self.has_count_:
5921       self.has_count_ = 0
5922       self.count_ = 0
5923
5924   def has_count(self): return self.has_count_
5925
5926   def refinement(self): return self.refinement_
5927
5928   def mutable_refinement(self): self.has_refinement_ = 1; return self.refinement_
5929
5930   def clear_refinement(self):self.has_refinement_ = 0; self.refinement_.Clear()
5931
5932   def has_refinement(self): return self.has_refinement_
5933
5934
5935   def MergeFrom(self, x):
5936     assert x is not self
5937     if (x.has_name()): self.set_name(x.name())
5938     if (x.has_count()): self.set_count(x.count())
5939     if (x.has_refinement()): self.mutable_refinement().MergeFrom(x.refinement())
5940
5941   def Equals(self, x):
5942     if x is self: return 1
5943     if self.has_name_ != x.has_name_: return 0
5944     if self.has_name_ and self.name_ != x.name_: return 0
5945     if self.has_count_ != x.has_count_: return 0
5946     if self.has_count_ and self.count_ != x.count_: return 0
5947     if self.has_refinement_ != x.has_refinement_: return 0
5948     if self.has_refinement_ and self.refinement_ != x.refinement_: return 0
5949     return 1
5950
5951   def IsInitialized(self, debug_strs=None):
5952     initialized = 1
5953     if (not self.has_name_):
5954       initialized = 0
5955       if debug_strs is not None:
5956         debug_strs.append('Required field: name not set.')
5957     if (not self.has_count_):
5958       initialized = 0
5959       if debug_strs is not None:
5960         debug_strs.append('Required field: count not set.')
5961     if (not self.has_refinement_):
5962       initialized = 0
5963       if debug_strs is not None:
5964         debug_strs.append('Required field: refinement not set.')
5965     elif not self.refinement_.IsInitialized(debug_strs): initialized = 0
5966     return initialized
5967
5968   def ByteSize(self):
5969     n = 0
5970     n += self.lengthString(len(self.name_))
5971     n += self.lengthVarInt64(self.count_)
5972     n += self.lengthString(self.refinement_.ByteSize())
5973     return n + 3
5974
5975   def ByteSizePartial(self):
5976     n = 0
5977     if (self.has_name_):
5978       n += 1
5979       n += self.lengthString(len(self.name_))
5980     if (self.has_count_):
5981       n += 1
5982       n += self.lengthVarInt64(self.count_)
5983     if (self.has_refinement_):
5984       n += 1
5985       n += self.lengthString(self.refinement_.ByteSizePartial())
5986     return n
5987
5988   def Clear(self):
5989     self.clear_name()
5990     self.clear_count()
5991     self.clear_refinement()
5992
5993   def OutputUnchecked(self, out):
5994     out.putVarInt32(10)
5995     out.putPrefixedString(self.name_)
5996     out.putVarInt32(16)
5997     out.putVarInt32(self.count_)
5998     out.putVarInt32(26)
5999     out.putVarInt32(self.refinement_.ByteSize())
6000     self.refinement_.OutputUnchecked(out)
6001
6002   def OutputPartial(self, out):
6003     if (self.has_name_):
6004       out.putVarInt32(10)
6005       out.putPrefixedString(self.name_)
6006     if (self.has_count_):
6007       out.putVarInt32(16)
6008       out.putVarInt32(self.count_)
6009     if (self.has_refinement_):
6010       out.putVarInt32(26)
6011       out.putVarInt32(self.refinement_.ByteSizePartial())
6012       self.refinement_.OutputPartial(out)
6013
6014   def TryMerge(self, d):
6015     while d.avail() > 0:
6016       tt = d.getVarInt32()
6017       if tt == 10:
6018         self.set_name(d.getPrefixedString())
6019         continue
6020       if tt == 16:
6021         self.set_count(d.getVarInt32())
6022         continue
6023       if tt == 26:
6024         length = d.getVarInt32()
6025         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
6026         d.skip(length)
6027         self.mutable_refinement().TryMerge(tmp)
6028         continue
6029
6030
6031       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
6032       d.skipData(tt)
6033
6034
6035   def __str__(self, prefix="", printElemNumber=0):
6036     res=""
6037     if self.has_name_: res+=prefix+("name: %s\n" % self.DebugFormatString(self.name_))
6038     if self.has_count_: res+=prefix+("count: %s\n" % self.DebugFormatInt32(self.count_))
6039     if self.has_refinement_:
6040       res+=prefix+"refinement <\n"
6041       res+=self.refinement_.__str__(prefix + "  ", printElemNumber)
6042       res+=prefix+">\n"
6043     return res
6044
6045
6046   def _BuildTagLookupTable(sparse, maxtag, default=None):
6047     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
6048
6049   kname = 1
6050   kcount = 2
6051   krefinement = 3
6052
6053   _TEXT = _BuildTagLookupTable({
6054     0: "ErrorCode",
6055     1: "name",
6056     2: "count",
6057     3: "refinement",
6058   }, 3)
6059
6060   _TYPES = _BuildTagLookupTable({
6061     0: ProtocolBuffer.Encoder.NUMERIC,
6062     1: ProtocolBuffer.Encoder.STRING,
6063     2: ProtocolBuffer.Encoder.NUMERIC,
6064     3: ProtocolBuffer.Encoder.STRING,
6065   }, 3, ProtocolBuffer.Encoder.MAX_TYPE)
6066
6067
6068   _STYLE = """"""
6069   _STYLE_CONTENT_TYPE = """"""
6070   _PROTO_DESCRIPTOR_NAME = 'apphosting.FacetResultValue'
6071 class FacetResult(ProtocolBuffer.ProtocolMessage):
6072   has_name_ = 0
6073   name_ = ""
6074
6075   def __init__(self, contents=None):
6076     self.value_ = []
6077     if contents is not None: self.MergeFromString(contents)
6078
6079   def name(self): return self.name_
6080
6081   def set_name(self, x):
6082     self.has_name_ = 1
6083     self.name_ = x
6084
6085   def clear_name(self):
6086     if self.has_name_:
6087       self.has_name_ = 0
6088       self.name_ = ""
6089
6090   def has_name(self): return self.has_name_
6091
6092   def value_size(self): return len(self.value_)
6093   def value_list(self): return self.value_
6094
6095   def value(self, i):
6096     return self.value_[i]
6097
6098   def mutable_value(self, i):
6099     return self.value_[i]
6100
6101   def add_value(self):
6102     x = FacetResultValue()
6103     self.value_.append(x)
6104     return x
6105
6106   def clear_value(self):
6107     self.value_ = []
6108
6109   def MergeFrom(self, x):
6110     assert x is not self
6111     if (x.has_name()): self.set_name(x.name())
6112     for i in xrange(x.value_size()): self.add_value().CopyFrom(x.value(i))
6113
6114   def Equals(self, x):
6115     if x is self: return 1
6116     if self.has_name_ != x.has_name_: return 0
6117     if self.has_name_ and self.name_ != x.name_: return 0
6118     if len(self.value_) != len(x.value_): return 0
6119     for e1, e2 in zip(self.value_, x.value_):
6120       if e1 != e2: return 0
6121     return 1
6122
6123   def IsInitialized(self, debug_strs=None):
6124     initialized = 1
6125     if (not self.has_name_):
6126       initialized = 0
6127       if debug_strs is not None:
6128         debug_strs.append('Required field: name not set.')
6129     for p in self.value_:
6130       if not p.IsInitialized(debug_strs): initialized=0
6131     return initialized
6132
6133   def ByteSize(self):
6134     n = 0
6135     n += self.lengthString(len(self.name_))
6136     n += 1 * len(self.value_)
6137     for i in xrange(len(self.value_)): n += self.lengthString(self.value_[i].ByteSize())
6138     return n + 1
6139
6140   def ByteSizePartial(self):
6141     n = 0
6142     if (self.has_name_):
6143       n += 1
6144       n += self.lengthString(len(self.name_))
6145     n += 1 * len(self.value_)
6146     for i in xrange(len(self.value_)): n += self.lengthString(self.value_[i].ByteSizePartial())
6147     return n
6148
6149   def Clear(self):
6150     self.clear_name()
6151     self.clear_value()
6152
6153   def OutputUnchecked(self, out):
6154     out.putVarInt32(10)
6155     out.putPrefixedString(self.name_)
6156     for i in xrange(len(self.value_)):
6157       out.putVarInt32(18)
6158       out.putVarInt32(self.value_[i].ByteSize())
6159       self.value_[i].OutputUnchecked(out)
6160
6161   def OutputPartial(self, out):
6162     if (self.has_name_):
6163       out.putVarInt32(10)
6164       out.putPrefixedString(self.name_)
6165     for i in xrange(len(self.value_)):
6166       out.putVarInt32(18)
6167       out.putVarInt32(self.value_[i].ByteSizePartial())
6168       self.value_[i].OutputPartial(out)
6169
6170   def TryMerge(self, d):
6171     while d.avail() > 0:
6172       tt = d.getVarInt32()
6173       if tt == 10:
6174         self.set_name(d.getPrefixedString())
6175         continue
6176       if tt == 18:
6177         length = d.getVarInt32()
6178         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
6179         d.skip(length)
6180         self.add_value().TryMerge(tmp)
6181         continue
6182
6183
6184       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
6185       d.skipData(tt)
6186
6187
6188   def __str__(self, prefix="", printElemNumber=0):
6189     res=""
6190     if self.has_name_: res+=prefix+("name: %s\n" % self.DebugFormatString(self.name_))
6191     cnt=0
6192     for e in self.value_:
6193       elm=""
6194       if printElemNumber: elm="(%d)" % cnt
6195       res+=prefix+("value%s <\n" % elm)
6196       res+=e.__str__(prefix + "  ", printElemNumber)
6197       res+=prefix+">\n"
6198       cnt+=1
6199     return res
6200
6201
6202   def _BuildTagLookupTable(sparse, maxtag, default=None):
6203     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
6204
6205   kname = 1
6206   kvalue = 2
6207
6208   _TEXT = _BuildTagLookupTable({
6209     0: "ErrorCode",
6210     1: "name",
6211     2: "value",
6212   }, 2)
6213
6214   _TYPES = _BuildTagLookupTable({
6215     0: ProtocolBuffer.Encoder.NUMERIC,
6216     1: ProtocolBuffer.Encoder.STRING,
6217     2: ProtocolBuffer.Encoder.STRING,
6218   }, 2, ProtocolBuffer.Encoder.MAX_TYPE)
6219
6220
6221   _STYLE = """"""
6222   _STYLE_CONTENT_TYPE = """"""
6223   _PROTO_DESCRIPTOR_NAME = 'apphosting.FacetResult'
6224 class SearchResult(ProtocolBuffer.ProtocolMessage):
6225   has_document_ = 0
6226   has_cursor_ = 0
6227   cursor_ = ""
6228
6229   def __init__(self, contents=None):
6230     self.document_ = Document()
6231     self.expression_ = []
6232     self.score_ = []
6233     if contents is not None: self.MergeFromString(contents)
6234
6235   def document(self): return self.document_
6236
6237   def mutable_document(self): self.has_document_ = 1; return self.document_
6238
6239   def clear_document(self):self.has_document_ = 0; self.document_.Clear()
6240
6241   def has_document(self): return self.has_document_
6242
6243   def expression_size(self): return len(self.expression_)
6244   def expression_list(self): return self.expression_
6245
6246   def expression(self, i):
6247     return self.expression_[i]
6248
6249   def mutable_expression(self, i):
6250     return self.expression_[i]
6251
6252   def add_expression(self):
6253     x = Field()
6254     self.expression_.append(x)
6255     return x
6256
6257   def clear_expression(self):
6258     self.expression_ = []
6259   def score_size(self): return len(self.score_)
6260   def score_list(self): return self.score_
6261
6262   def score(self, i):
6263     return self.score_[i]
6264
6265   def set_score(self, i, x):
6266     self.score_[i] = x
6267
6268   def add_score(self, x):
6269     self.score_.append(x)
6270
6271   def clear_score(self):
6272     self.score_ = []
6273
6274   def cursor(self): return self.cursor_
6275
6276   def set_cursor(self, x):
6277     self.has_cursor_ = 1
6278     self.cursor_ = x
6279
6280   def clear_cursor(self):
6281     if self.has_cursor_:
6282       self.has_cursor_ = 0
6283       self.cursor_ = ""
6284
6285   def has_cursor(self): return self.has_cursor_
6286
6287
6288   def MergeFrom(self, x):
6289     assert x is not self
6290     if (x.has_document()): self.mutable_document().MergeFrom(x.document())
6291     for i in xrange(x.expression_size()): self.add_expression().CopyFrom(x.expression(i))
6292     for i in xrange(x.score_size()): self.add_score(x.score(i))
6293     if (x.has_cursor()): self.set_cursor(x.cursor())
6294
6295   def Equals(self, x):
6296     if x is self: return 1
6297     if self.has_document_ != x.has_document_: return 0
6298     if self.has_document_ and self.document_ != x.document_: return 0
6299     if len(self.expression_) != len(x.expression_): return 0
6300     for e1, e2 in zip(self.expression_, x.expression_):
6301       if e1 != e2: return 0
6302     if len(self.score_) != len(x.score_): return 0
6303     for e1, e2 in zip(self.score_, x.score_):
6304       if e1 != e2: return 0
6305     if self.has_cursor_ != x.has_cursor_: return 0
6306     if self.has_cursor_ and self.cursor_ != x.cursor_: return 0
6307     return 1
6308
6309   def IsInitialized(self, debug_strs=None):
6310     initialized = 1
6311     if (not self.has_document_):
6312       initialized = 0
6313       if debug_strs is not None:
6314         debug_strs.append('Required field: document not set.')
6315     elif not self.document_.IsInitialized(debug_strs): initialized = 0
6316     for p in self.expression_:
6317       if not p.IsInitialized(debug_strs): initialized=0
6318     return initialized
6319
6320   def ByteSize(self):
6321     n = 0
6322     n += self.lengthString(self.document_.ByteSize())
6323     n += 1 * len(self.expression_)
6324     for i in xrange(len(self.expression_)): n += self.lengthString(self.expression_[i].ByteSize())
6325     n += 9 * len(self.score_)
6326     if (self.has_cursor_): n += 1 + self.lengthString(len(self.cursor_))
6327     return n + 1
6328
6329   def ByteSizePartial(self):
6330     n = 0
6331     if (self.has_document_):
6332       n += 1
6333       n += self.lengthString(self.document_.ByteSizePartial())
6334     n += 1 * len(self.expression_)
6335     for i in xrange(len(self.expression_)): n += self.lengthString(self.expression_[i].ByteSizePartial())
6336     n += 9 * len(self.score_)
6337     if (self.has_cursor_): n += 1 + self.lengthString(len(self.cursor_))
6338     return n
6339
6340   def Clear(self):
6341     self.clear_document()
6342     self.clear_expression()
6343     self.clear_score()
6344     self.clear_cursor()
6345
6346   def OutputUnchecked(self, out):
6347     out.putVarInt32(10)
6348     out.putVarInt32(self.document_.ByteSize())
6349     self.document_.OutputUnchecked(out)
6350     for i in xrange(len(self.score_)):
6351       out.putVarInt32(17)
6352       out.putDouble(self.score_[i])
6353     if (self.has_cursor_):
6354       out.putVarInt32(26)
6355       out.putPrefixedString(self.cursor_)
6356     for i in xrange(len(self.expression_)):
6357       out.putVarInt32(34)
6358       out.putVarInt32(self.expression_[i].ByteSize())
6359       self.expression_[i].OutputUnchecked(out)
6360
6361   def OutputPartial(self, out):
6362     if (self.has_document_):
6363       out.putVarInt32(10)
6364       out.putVarInt32(self.document_.ByteSizePartial())
6365       self.document_.OutputPartial(out)
6366     for i in xrange(len(self.score_)):
6367       out.putVarInt32(17)
6368       out.putDouble(self.score_[i])
6369     if (self.has_cursor_):
6370       out.putVarInt32(26)
6371       out.putPrefixedString(self.cursor_)
6372     for i in xrange(len(self.expression_)):
6373       out.putVarInt32(34)
6374       out.putVarInt32(self.expression_[i].ByteSizePartial())
6375       self.expression_[i].OutputPartial(out)
6376
6377   def TryMerge(self, d):
6378     while d.avail() > 0:
6379       tt = d.getVarInt32()
6380       if tt == 10:
6381         length = d.getVarInt32()
6382         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
6383         d.skip(length)
6384         self.mutable_document().TryMerge(tmp)
6385         continue
6386       if tt == 17:
6387         self.add_score(d.getDouble())
6388         continue
6389       if tt == 26:
6390         self.set_cursor(d.getPrefixedString())
6391         continue
6392       if tt == 34:
6393         length = d.getVarInt32()
6394         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
6395         d.skip(length)
6396         self.add_expression().TryMerge(tmp)
6397         continue
6398
6399
6400       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
6401       d.skipData(tt)
6402
6403
6404   def __str__(self, prefix="", printElemNumber=0):
6405     res=""
6406     if self.has_document_:
6407       res+=prefix+"document <\n"
6408       res+=self.document_.__str__(prefix + "  ", printElemNumber)
6409       res+=prefix+">\n"
6410     cnt=0
6411     for e in self.expression_:
6412       elm=""
6413       if printElemNumber: elm="(%d)" % cnt
6414       res+=prefix+("expression%s <\n" % elm)
6415       res+=e.__str__(prefix + "  ", printElemNumber)
6416       res+=prefix+">\n"
6417       cnt+=1
6418     cnt=0
6419     for e in self.score_:
6420       elm=""
6421       if printElemNumber: elm="(%d)" % cnt
6422       res+=prefix+("score%s: %s\n" % (elm, self.DebugFormat(e)))
6423       cnt+=1
6424     if self.has_cursor_: res+=prefix+("cursor: %s\n" % self.DebugFormatString(self.cursor_))
6425     return res
6426
6427
6428   def _BuildTagLookupTable(sparse, maxtag, default=None):
6429     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
6430
6431   kdocument = 1
6432   kexpression = 4
6433   kscore = 2
6434   kcursor = 3
6435
6436   _TEXT = _BuildTagLookupTable({
6437     0: "ErrorCode",
6438     1: "document",
6439     2: "score",
6440     3: "cursor",
6441     4: "expression",
6442   }, 4)
6443
6444   _TYPES = _BuildTagLookupTable({
6445     0: ProtocolBuffer.Encoder.NUMERIC,
6446     1: ProtocolBuffer.Encoder.STRING,
6447     2: ProtocolBuffer.Encoder.DOUBLE,
6448     3: ProtocolBuffer.Encoder.STRING,
6449     4: ProtocolBuffer.Encoder.STRING,
6450   }, 4, ProtocolBuffer.Encoder.MAX_TYPE)
6451
6452
6453   _STYLE = """"""
6454   _STYLE_CONTENT_TYPE = """"""
6455   _PROTO_DESCRIPTOR_NAME = 'apphosting.SearchResult'
6456 class SearchResponse(_ExtendableProtocolMessage):
6457   has_matched_count_ = 0
6458   matched_count_ = 0
6459   has_status_ = 0
6460   has_cursor_ = 0
6461   cursor_ = ""
6462
6463   def __init__(self, contents=None):
6464     if _extension_runtime:
6465       self._extension_fields = {}
6466     self.result_ = []
6467     self.status_ = RequestStatus()
6468     self.facet_result_ = []
6469     if contents is not None: self.MergeFromString(contents)
6470
6471   def result_size(self): return len(self.result_)
6472   def result_list(self): return self.result_
6473
6474   def result(self, i):
6475     return self.result_[i]
6476
6477   def mutable_result(self, i):
6478     return self.result_[i]
6479
6480   def add_result(self):
6481     x = SearchResult()
6482     self.result_.append(x)
6483     return x
6484
6485   def clear_result(self):
6486     self.result_ = []
6487   def matched_count(self): return self.matched_count_
6488
6489   def set_matched_count(self, x):
6490     self.has_matched_count_ = 1
6491     self.matched_count_ = x
6492
6493   def clear_matched_count(self):
6494     if self.has_matched_count_:
6495       self.has_matched_count_ = 0
6496       self.matched_count_ = 0
6497
6498   def has_matched_count(self): return self.has_matched_count_
6499
6500   def status(self): return self.status_
6501
6502   def mutable_status(self): self.has_status_ = 1; return self.status_
6503
6504   def clear_status(self):self.has_status_ = 0; self.status_.Clear()
6505
6506   def has_status(self): return self.has_status_
6507
6508   def cursor(self): return self.cursor_
6509
6510   def set_cursor(self, x):
6511     self.has_cursor_ = 1
6512     self.cursor_ = x
6513
6514   def clear_cursor(self):
6515     if self.has_cursor_:
6516       self.has_cursor_ = 0
6517       self.cursor_ = ""
6518
6519   def has_cursor(self): return self.has_cursor_
6520
6521   def facet_result_size(self): return len(self.facet_result_)
6522   def facet_result_list(self): return self.facet_result_
6523
6524   def facet_result(self, i):
6525     return self.facet_result_[i]
6526
6527   def mutable_facet_result(self, i):
6528     return self.facet_result_[i]
6529
6530   def add_facet_result(self):
6531     x = FacetResult()
6532     self.facet_result_.append(x)
6533     return x
6534
6535   def clear_facet_result(self):
6536     self.facet_result_ = []
6537
6538   def MergeFrom(self, x):
6539     assert x is not self
6540     for i in xrange(x.result_size()): self.add_result().CopyFrom(x.result(i))
6541     if (x.has_matched_count()): self.set_matched_count(x.matched_count())
6542     if (x.has_status()): self.mutable_status().MergeFrom(x.status())
6543     if (x.has_cursor()): self.set_cursor(x.cursor())
6544     for i in xrange(x.facet_result_size()): self.add_facet_result().CopyFrom(x.facet_result(i))
6545     if _extension_runtime: self._MergeExtensionFields(x)
6546
6547   def Equals(self, x):
6548     if x is self: return 1
6549     if len(self.result_) != len(x.result_): return 0
6550     for e1, e2 in zip(self.result_, x.result_):
6551       if e1 != e2: return 0
6552     if self.has_matched_count_ != x.has_matched_count_: return 0
6553     if self.has_matched_count_ and self.matched_count_ != x.matched_count_: return 0
6554     if self.has_status_ != x.has_status_: return 0
6555     if self.has_status_ and self.status_ != x.status_: return 0
6556     if self.has_cursor_ != x.has_cursor_: return 0
6557     if self.has_cursor_ and self.cursor_ != x.cursor_: return 0
6558     if len(self.facet_result_) != len(x.facet_result_): return 0
6559     for e1, e2 in zip(self.facet_result_, x.facet_result_):
6560       if e1 != e2: return 0
6561     if _extension_runtime and not self._ExtensionEquals(x): return 0
6562     return 1
6563
6564   def IsInitialized(self, debug_strs=None):
6565     initialized = 1
6566     for p in self.result_:
6567       if not p.IsInitialized(debug_strs): initialized=0
6568     if (not self.has_matched_count_):
6569       initialized = 0
6570       if debug_strs is not None:
6571         debug_strs.append('Required field: matched_count not set.')
6572     if (not self.has_status_):
6573       initialized = 0
6574       if debug_strs is not None:
6575         debug_strs.append('Required field: status not set.')
6576     elif not self.status_.IsInitialized(debug_strs): initialized = 0
6577     for p in self.facet_result_:
6578       if not p.IsInitialized(debug_strs): initialized=0
6579     return initialized
6580
6581   def ByteSize(self):
6582     n = 0
6583     n += 1 * len(self.result_)
6584     for i in xrange(len(self.result_)): n += self.lengthString(self.result_[i].ByteSize())
6585     n += self.lengthVarInt64(self.matched_count_)
6586     n += self.lengthString(self.status_.ByteSize())
6587     if (self.has_cursor_): n += 1 + self.lengthString(len(self.cursor_))
6588     n += 1 * len(self.facet_result_)
6589     for i in xrange(len(self.facet_result_)): n += self.lengthString(self.facet_result_[i].ByteSize())
6590     if _extension_runtime:
6591       n += self._ExtensionByteSize(False)
6592     return n + 2
6593
6594   def ByteSizePartial(self):
6595     n = 0
6596     n += 1 * len(self.result_)
6597     for i in xrange(len(self.result_)): n += self.lengthString(self.result_[i].ByteSizePartial())
6598     if (self.has_matched_count_):
6599       n += 1
6600       n += self.lengthVarInt64(self.matched_count_)
6601     if (self.has_status_):
6602       n += 1
6603       n += self.lengthString(self.status_.ByteSizePartial())
6604     if (self.has_cursor_): n += 1 + self.lengthString(len(self.cursor_))
6605     n += 1 * len(self.facet_result_)
6606     for i in xrange(len(self.facet_result_)): n += self.lengthString(self.facet_result_[i].ByteSizePartial())
6607     if _extension_runtime:
6608       n += self._ExtensionByteSize(True)
6609     return n
6610
6611   def Clear(self):
6612     self.clear_result()
6613     self.clear_matched_count()
6614     self.clear_status()
6615     self.clear_cursor()
6616     self.clear_facet_result()
6617     if _extension_runtime: self._extension_fields.clear()
6618
6619   def OutputUnchecked(self, out):
6620     if _extension_runtime:
6621       extensions = self._ListExtensions()
6622       extension_index = 0
6623     for i in xrange(len(self.result_)):
6624       out.putVarInt32(10)
6625       out.putVarInt32(self.result_[i].ByteSize())
6626       self.result_[i].OutputUnchecked(out)
6627     out.putVarInt32(16)
6628     out.putVarInt64(self.matched_count_)
6629     out.putVarInt32(26)
6630     out.putVarInt32(self.status_.ByteSize())
6631     self.status_.OutputUnchecked(out)
6632     if (self.has_cursor_):
6633       out.putVarInt32(34)
6634       out.putPrefixedString(self.cursor_)
6635     for i in xrange(len(self.facet_result_)):
6636       out.putVarInt32(42)
6637       out.putVarInt32(self.facet_result_[i].ByteSize())
6638       self.facet_result_[i].OutputUnchecked(out)
6639     if _extension_runtime:
6640       extension_index = self._OutputExtensionFields(out, False, extensions, extension_index, 10000)
6641
6642   def OutputPartial(self, out):
6643     if _extension_runtime:
6644       extensions = self._ListExtensions()
6645       extension_index = 0
6646     for i in xrange(len(self.result_)):
6647       out.putVarInt32(10)
6648       out.putVarInt32(self.result_[i].ByteSizePartial())
6649       self.result_[i].OutputPartial(out)
6650     if (self.has_matched_count_):
6651       out.putVarInt32(16)
6652       out.putVarInt64(self.matched_count_)
6653     if (self.has_status_):
6654       out.putVarInt32(26)
6655       out.putVarInt32(self.status_.ByteSizePartial())
6656       self.status_.OutputPartial(out)
6657     if (self.has_cursor_):
6658       out.putVarInt32(34)
6659       out.putPrefixedString(self.cursor_)
6660     for i in xrange(len(self.facet_result_)):
6661       out.putVarInt32(42)
6662       out.putVarInt32(self.facet_result_[i].ByteSizePartial())
6663       self.facet_result_[i].OutputPartial(out)
6664     if _extension_runtime:
6665       extension_index = self._OutputExtensionFields(out, True, extensions, extension_index, 10000)
6666
6667   def TryMerge(self, d):
6668     while d.avail() > 0:
6669       tt = d.getVarInt32()
6670       if tt == 10:
6671         length = d.getVarInt32()
6672         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
6673         d.skip(length)
6674         self.add_result().TryMerge(tmp)
6675         continue
6676       if tt == 16:
6677         self.set_matched_count(d.getVarInt64())
6678         continue
6679       if tt == 26:
6680         length = d.getVarInt32()
6681         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
6682         d.skip(length)
6683         self.mutable_status().TryMerge(tmp)
6684         continue
6685       if tt == 34:
6686         self.set_cursor(d.getPrefixedString())
6687         continue
6688       if tt == 42:
6689         length = d.getVarInt32()
6690         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
6691         d.skip(length)
6692         self.add_facet_result().TryMerge(tmp)
6693         continue
6694       if _extension_runtime:
6695         if (1000 <= tt and tt < 10000):
6696           self._ParseOneExtensionField(tt, d)
6697           continue
6698
6699
6700       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
6701       d.skipData(tt)
6702
6703
6704   def __str__(self, prefix="", printElemNumber=0):
6705     res=""
6706     cnt=0
6707     for e in self.result_:
6708       elm=""
6709       if printElemNumber: elm="(%d)" % cnt
6710       res+=prefix+("result%s <\n" % elm)
6711       res+=e.__str__(prefix + "  ", printElemNumber)
6712       res+=prefix+">\n"
6713       cnt+=1
6714     if self.has_matched_count_: res+=prefix+("matched_count: %s\n" % self.DebugFormatInt64(self.matched_count_))
6715     if self.has_status_:
6716       res+=prefix+"status <\n"
6717       res+=self.status_.__str__(prefix + "  ", printElemNumber)
6718       res+=prefix+">\n"
6719     if self.has_cursor_: res+=prefix+("cursor: %s\n" % self.DebugFormatString(self.cursor_))
6720     cnt=0
6721     for e in self.facet_result_:
6722       elm=""
6723       if printElemNumber: elm="(%d)" % cnt
6724       res+=prefix+("facet_result%s <\n" % elm)
6725       res+=e.__str__(prefix + "  ", printElemNumber)
6726       res+=prefix+">\n"
6727       cnt+=1
6728     if _extension_runtime:
6729       res+=self._ExtensionDebugString(prefix, printElemNumber)
6730     return res
6731
6732   if _extension_runtime:
6733     _extensions_by_field_number = {}
6734
6735   def _BuildTagLookupTable(sparse, maxtag, default=None):
6736     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
6737
6738   kresult = 1
6739   kmatched_count = 2
6740   kstatus = 3
6741   kcursor = 4
6742   kfacet_result = 5
6743
6744   _TEXT = _BuildTagLookupTable({
6745     0: "ErrorCode",
6746     1: "result",
6747     2: "matched_count",
6748     3: "status",
6749     4: "cursor",
6750     5: "facet_result",
6751   }, 5)
6752
6753   _TYPES = _BuildTagLookupTable({
6754     0: ProtocolBuffer.Encoder.NUMERIC,
6755     1: ProtocolBuffer.Encoder.STRING,
6756     2: ProtocolBuffer.Encoder.NUMERIC,
6757     3: ProtocolBuffer.Encoder.STRING,
6758     4: ProtocolBuffer.Encoder.STRING,
6759     5: ProtocolBuffer.Encoder.STRING,
6760   }, 5, ProtocolBuffer.Encoder.MAX_TYPE)
6761
6762
6763   _STYLE = """"""
6764   _STYLE_CONTENT_TYPE = """"""
6765   _PROTO_DESCRIPTOR_NAME = 'apphosting.SearchResponse'
6766 if _extension_runtime:
6767   pass
6768
6769 __all__ = ['SearchServiceError','RequestStatus','IndexSpec','IndexMetadata_Storage','IndexMetadata','IndexDocumentParams','IndexDocumentRequest','IndexDocumentResponse','DeleteDocumentParams','DeleteDocumentRequest','DeleteDocumentResponse','ListDocumentsParams','ListDocumentsRequest','ListDocumentsResponse','ListIndexesParams','ListIndexesRequest','ListIndexesResponse','DeleteSchemaParams','DeleteSchemaRequest','DeleteSchemaResponse','SortSpec','ScorerSpec','FieldSpec','FieldSpec_Expression','FacetRange','FacetRequestParam','FacetAutoDetectParam','FacetRequest','FacetRefinement_Range','FacetRefinement','SearchParams','SearchRequest','FacetResultValue','FacetResult','SearchResult','SearchResponse']