text: #!/usr/bin/env python
  #
  # Copyright 2007 Google Inc.
  #
  # Licensed under the Apache License, Version 2.0 (the "License");
  # you may not use this file except in compliance with the License.
  # You may obtain a copy of the License at
  #
  #     http://www.apache.org/licenses/LICENSE-2.0
  #
  # Unless required by applicable law or agreed to in writing, software
  # distributed under the License is distributed on an "AS IS" BASIS,
  # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  # See the License for the specific language governing permissions and
  # limitations under the License.
  #
  
  
  
  from google.net.proto import ProtocolBuffer
  import array
  import dummy_thread as thread
  
  __pychecker__ = """maxreturns=0 maxbranches=0 no-callinit
                     unusednames=printElemNumber,debug_strs no-special"""
  
  if hasattr(ProtocolBuffer, 'ExtendableProtocolMessage'):
    _extension_runtime = True
    _ExtendableProtocolMessage = ProtocolBuffer.ExtendableProtocolMessage
  else:
    _extension_runtime = False
    _ExtendableProtocolMessage = ProtocolBuffer.ProtocolMessage
  
  from google.appengine.datastore.document_pb import *
  import google.appengine.datastore.document_pb
  class SearchServiceError(ProtocolBuffer.ProtocolMessage):
  
  
    OK           =    0
    INVALID_REQUEST =    1
    TRANSIENT_ERROR =    2
    INTERNAL_ERROR =    3
    PERMISSION_DENIED =    4
  
    _ErrorCode_NAMES = {
      0: "OK",
      1: "INVALID_REQUEST",
      2: "TRANSIENT_ERROR",
      3: "INTERNAL_ERROR",
      4: "PERMISSION_DENIED",
    }
  
    def ErrorCode_Name(cls, x): return cls._ErrorCode_NAMES.get(x, "")
    ErrorCode_Name = classmethod(ErrorCode_Name)
  
  
    def __init__(self, contents=None):
      pass
      if contents is not None: self.MergeFromString(contents)
  
  
    def MergeFrom(self, x):
      assert x is not self
  
    def Equals(self, x):
      if x is self: return 1
      return 1
  
    def IsInitialized(self, debug_strs=None):
      initialized = 1
      return initialized
  
    def ByteSize(self):
      n = 0
      return n
  
    def ByteSizePartial(self):
      n = 0
      return n
  
    def Clear(self):
      pass
  
    def OutputUnchecked(self, out):
      pass
  
    def OutputPartial(self, out):
      pass
  
    def TryMerge(self, d):
      while d.avail() > 0:
        tt = d.getVarInt32()
  
  
        if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
        d.skipData(tt)
  
  
    def __str__(self, prefix="", printElemNumber=0):
      res=""
      return res
  
  
    def _BuildTagLookupTable(sparse, maxtag, default=None):
      return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
  
  
    _TEXT = _BuildTagLookupTable({
      0: "ErrorCode",
    }, 0)
  
    _TYPES = _BuildTagLookupTable({
      0: ProtocolBuffer.Encoder.NUMERIC,
    }, 0, ProtocolBuffer.Encoder.MAX_TYPE)
  
  
    _STYLE = """"""
    _STYLE_CONTENT_TYPE = """"""
    _PROTO_DESCRIPTOR_NAME = 'apphosting.SearchServiceError'
  class RequestStatus(ProtocolBuffer.ProtocolMessage):
    has_code_ = 0
    code_ = 0
    has_error_detail_ = 0
    error_detail_ = ""
  
    def __init__(self, contents=None):
      if contents is not None: self.MergeFromString(contents)
  
    def code(self): return self.code_
  
    def set_code(self, x):
      self.has_code_ = 1
      self.code_ = x
  
    def clear_code(self):
      if self.has_code_:
        self.has_code_ = 0
        self.code_ = 0
  
    def has_code(self): return self.has_code_
  
    def error_detail(self): return self.error_detail_
  
    def set_error_detail(self, x):
      self.has_error_detail_ = 1
      self.error_detail_ = x
  
    def clear_error_detail(self):
      if self.has_error_detail_:
        self.has_error_detail_ = 0
        self.error_detail_ = ""
  
    def has_error_detail(self): return self.has_error_detail_
  
  
    def MergeFrom(self, x):
      assert x is not self
      if (x.has_code()): self.set_code(x.code())
      if (x.has_error_detail()): self.set_error_detail(x.error_detail())
  
    def Equals(self, x):
      if x is self: return 1
      if self.has_code_ != x.has_code_: return 0
      if self.has_code_ and self.code_ != x.code_: return 0
      if self.has_error_detail_ != x.has_error_detail_: return 0
      if self.has_error_detail_ and self.error_detail_ != x.error_detail_: return 0
      return 1
  
    def IsInitialized(self, debug_strs=None):
      initialized = 1
      if (not self.has_code_):
        initialized = 0
        if debug_strs is not None:
          debug_strs.append('Required field: code not set.')
      return initialized
  
    def ByteSize(self):
      n = 0
      n += self.lengthVarInt64(self.code_)
      if (self.has_error_detail_): n += 1 + self.lengthString(len(self.error_detail_))
      return n + 1
  
    def ByteSizePartial(self):
      n = 0
      if (self.has_code_):
        n += 1
        n += self.lengthVarInt64(self.code_)
      if (self.has_error_detail_): n += 1 + self.lengthString(len(self.error_detail_))
      return n
  
    def Clear(self):
      self.clear_code()
      self.clear_error_detail()
  
    def OutputUnchecked(self, out):
      out.putVarInt32(8)
      out.putVarInt32(self.code_)
      if (self.has_error_detail_):
        out.putVarInt32(18)
        out.putPrefixedString(self.error_detail_)
  
    def OutputPartial(self, out):
      if (self.has_code_):
        out.putVarInt32(8)
        out.putVarInt32(self.code_)
      if (self.has_error_detail_):
        out.putVarInt32(18)
        out.putPrefixedString(self.error_detail_)
  
    def TryMerge(self, d):
      while d.avail() > 0:
        tt = d.getVarInt32()
        if tt == 8:
          self.set_code(d.getVarInt32())
          continue
        if tt == 18:
          self.set_error_detail(d.getPrefixedString())
          continue
  
  
        if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
        d.skipData(tt)
  
  
    def __str__(self, prefix="", printElemNumber=0):
      res=""
      if self.has_code_: res+=prefix+("code: %s\n" % self.DebugFormatInt32(self.code_))
      if self.has_error_detail_: res+=prefix+("error_detail: %s\n" % self.DebugFormatString(self.error_detail_))
      return res
  
  
    def _BuildTagLookupTable(sparse, maxtag, default=None):
      return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
  
    kcode = 1
    kerror_detail = 2
  
    _TEXT = _BuildTagLookupTable({
      0: "ErrorCode",
      1: "code",
      2: "error_detail",
    }, 2)
  
    _TYPES = _BuildTagLookupTable({
      0: ProtocolBuffer.Encoder.NUMERIC,
      1: ProtocolBuffer.Encoder.NUMERIC,
      2: ProtocolBuffer.Encoder.STRING,
    }, 2, ProtocolBuffer.Encoder.MAX_TYPE)
  
  
    _STYLE = """"""
    _STYLE_CONTENT_TYPE = """"""
    _PROTO_DESCRIPTOR_NAME = 'apphosting.RequestStatus'
  class IndexSpec(ProtocolBuffer.ProtocolMessage):
  
  
    GLOBAL       =    0
    PER_DOCUMENT =    1
  
    _Consistency_NAMES = {
      0: "GLOBAL",
      1: "PER_DOCUMENT",
    }
  
    def Consistency_Name(cls, x): return cls._Consistency_NAMES.get(x, "")
    Consistency_Name = classmethod(Consistency_Name)
  
  
  
    SEARCH       =    0
    DATASTORE    =    1
    CLOUD_STORAGE =    2
  
    _Source_NAMES = {
      0: "SEARCH",
      1: "DATASTORE",
      2: "CLOUD_STORAGE",
    }
  
    def Source_Name(cls, x): return cls._Source_NAMES.get(x, "")
    Source_Name = classmethod(Source_Name)
  
  
  
    PRIORITY     =    0
    BACKGROUND   =    1
  
    _Mode_NAMES = {
      0: "PRIORITY",
      1: "BACKGROUND",
    }
  
    def Mode_Name(cls, x): return cls._Mode_NAMES.get(x, "")
    Mode_Name = classmethod(Mode_Name)
  
    has_name_ = 0
    name_ = ""
    has_consistency_ = 0
    consistency_ = 1
    has_namespace_ = 0
    namespace_ = ""
    has_version_ = 0
    version_ = 0
    has_source_ = 0
    source_ = 0
    has_mode_ = 0
    mode_ = 0
  
    def __init__(self, contents=None):
      if contents is not None: self.MergeFromString(contents)
  
    def name(self): return self.name_
  
    def set_name(self, x):
      self.has_name_ = 1
      self.name_ = x
  
    def clear_name(self):
      if self.has_name_:
        self.has_name_ = 0
        self.name_ = ""
  
    def has_name(self): return self.has_name_
  
    def consistency(self): return self.consistency_
  
    def set_consistency(self, x):
      self.has_consistency_ = 1
      self.consistency_ = x
  
    def clear_consistency(self):
      if self.has_consistency_:
        self.has_consistency_ = 0
        self.consistency_ = 1
  
    def has_consistency(self): return self.has_consistency_
  
    def namespace(self): return self.namespace_
  
    def set_namespace(self, x):
      self.has_namespace_ = 1
      self.namespace_ = x
  
    def clear_namespace(self):
      if self.has_namespace_:
        self.has_namespace_ = 0
        self.namespace_ = ""
  
    def has_namespace(self): return self.has_namespace_
  
    def version(self): return self.version_
  
    def set_version(self, x):
      self.has_version_ = 1
      self.version_ = x
  
    def clear_version(self):
      if self.has_version_:
        self.has_version_ = 0
        self.version_ = 0
  
    def has_version(self): return self.has_version_
  
    def source(self): return self.source_
  
    def set_source(self, x):
      self.has_source_ = 1
      self.source_ = x
  
    def clear_source(self):
      if self.has_source_:
        self.has_source_ = 0
        self.source_ = 0
  
    def has_source(self): return self.has_source_
  
    def mode(self): return self.mode_
  
    def set_mode(self, x):
      self.has_mode_ = 1
      self.mode_ = x
  
    def clear_mode(self):
      if self.has_mode_:
        self.has_mode_ = 0
        self.mode_ = 0
  
    def has_mode(self): return self.has_mode_
  
  
    def MergeFrom(self, x):
      assert x is not self
      if (x.has_name()): self.set_name(x.name())
      if (x.has_consistency()): self.set_consistency(x.consistency())
      if (x.has_namespace()): self.set_namespace(x.namespace())
      if (x.has_version()): self.set_version(x.version())
      if (x.has_source()): self.set_source(x.source())
      if (x.has_mode()): self.set_mode(x.mode())
  
    def Equals(self, x):
      if x is self: return 1
      if self.has_name_ != x.has_name_: return 0
      if self.has_name_ and self.name_ != x.name_: return 0
      if self.has_consistency_ != x.has_consistency_: return 0
      if self.has_consistency_ and self.consistency_ != x.consistency_: return 0
      if self.has_namespace_ != x.has_namespace_: return 0
      if self.has_namespace_ and self.namespace_ != x.namespace_: return 0
      if self.has_version_ != x.has_version_: return 0
      if self.has_version_ and self.version_ != x.version_: return 0
      if self.has_source_ != x.has_source_: return 0
      if self.has_source_ and self.source_ != x.source_: return 0
      if self.has_mode_ != x.has_mode_: return 0
      if self.has_mode_ and self.mode_ != x.mode_: return 0
      return 1
  
    def IsInitialized(self, debug_strs=None):
      initialized = 1
      if (not self.has_name_):
        initialized = 0
        if debug_strs is not None:
          debug_strs.append('Required field: name not set.')
      return initialized
  
    def ByteSize(self):
      n = 0
      n += self.lengthString(len(self.name_))
      if (self.has_consistency_): n += 1 + self.lengthVarInt64(self.consistency_)
      if (self.has_namespace_): n += 1 + self.lengthString(len(self.namespace_))
      if (self.has_version_): n += 1 + self.lengthVarInt64(self.version_)
      if (self.has_source_): n += 1 + self.lengthVarInt64(self.source_)
      if (self.has_mode_): n += 1 + self.lengthVarInt64(self.mode_)
      return n + 1
  
    def ByteSizePartial(self):
      n = 0
      if (self.has_name_):
        n += 1
        n += self.lengthString(len(self.name_))
      if (self.has_consistency_): n += 1 + self.lengthVarInt64(self.consistency_)
      if (self.has_namespace_): n += 1 + self.lengthString(len(self.namespace_))
      if (self.has_version_): n += 1 + self.lengthVarInt64(self.version_)
      if (self.has_source_): n += 1 + self.lengthVarInt64(self.source_)
      if (self.has_mode_): n += 1 + self.lengthVarInt64(self.mode_)
      return n
  
    def Clear(self):
      self.clear_name()
      self.clear_consistency()
      self.clear_namespace()
      self.clear_version()
      self.clear_source()
      self.clear_mode()
  
    def OutputUnchecked(self, out):
      out.putVarInt32(10)
      out.putPrefixedString(self.name_)
      if (self.has_consistency_):
        out.putVarInt32(16)
        out.putVarInt32(self.consistency_)
      if (self.has_namespace_):
        out.putVarInt32(26)
        out.putPrefixedString(self.namespace_)
      if (self.has_version_):
        out.putVarInt32(32)
        out.putVarInt32(self.version_)
      if (self.has_source_):
        out.putVarInt32(40)
        out.putVarInt32(self.source_)
      if (self.has_mode_):
        out.putVarInt32(48)
        out.putVarInt32(self.mode_)
  
    def OutputPartial(self, out):
      if (self.has_name_):
        out.putVarInt32(10)
        out.putPrefixedString(self.name_)
      if (self.has_consistency_):
        out.putVarInt32(16)
        out.putVarInt32(self.consistency_)
      if (self.has_namespace_):
        out.putVarInt32(26)
        out.putPrefixedString(self.namespace_)
      if (self.has_version_):
        out.putVarInt32(32)
        out.putVarInt32(self.version_)
      if (self.has_source_):
        out.putVarInt32(40)
        out.putVarInt32(self.source_)
      if (self.has_mode_):
        out.putVarInt32(48)
        out.putVarInt32(self.mode_)
  
    def TryMerge(self, d):
      while d.avail() > 0:
        tt = d.getVarInt32()
        if tt == 10:
          self.set_name(d.getPrefixedString())
          continue
        if tt == 16:
          self.set_consistency(d.getVarInt32())
          continue
        if tt == 26:
          self.set_namespace(d.getPrefixedString())
          continue
        if tt == 32:
          self.set_version(d.getVarInt32())
          continue
        if tt == 40:
          self.set_source(d.getVarInt32())
          continue
        if tt == 48:
          self.set_mode(d.getVarInt32())
          continue
  
  
        if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
        d.skipData(tt)
  
  
    def __str__(self, prefix="", printElemNumber=0):
      res=""
      if self.has_name_: res+=prefix+("name: %s\n" % self.DebugFormatString(self.name_))
      if self.has_consistency_: res+=prefix+("consistency: %s\n" % self.DebugFormatInt32(self.consistency_))
      if self.has_namespace_: res+=prefix+("namespace: %s\n" % self.DebugFormatString(self.namespace_))
      if self.has_version_: res+=prefix+("version: %s\n" % self.DebugFormatInt32(self.version_))
      if self.has_source_: res+=prefix+("source: %s\n" % self.DebugFormatInt32(self.source_))
      if self.has_mode_: res+=prefix+("mode: %s\n" % self.DebugFormatInt32(self.mode_))
      return res
  
  
    def _BuildTagLookupTable(sparse, maxtag, default=None):
      return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
  
    kname = 1
    kconsistency = 2
    knamespace = 3
    kversion = 4
    ksource = 5
    kmode = 6
  
    _TEXT = _BuildTagLookupTable({
      0: "ErrorCode",
      1: "name",
      2: "consistency",
      3: "namespace",
      4: "version",
      5: "source",
      6: "mode",
    }, 6)
  
    _TYPES = _BuildTagLookupTable({
      0: ProtocolBuffer.Encoder.NUMERIC,
      1: ProtocolBuffer.Encoder.STRING,
      2: ProtocolBuffer.Encoder.NUMERIC,
      3: ProtocolBuffer.Encoder.STRING,
      4: ProtocolBuffer.Encoder.NUMERIC,
      5: ProtocolBuffer.Encoder.NUMERIC,
      6: ProtocolBuffer.Encoder.NUMERIC,
    }, 6, ProtocolBuffer.Encoder.MAX_TYPE)
  
  
    _STYLE = """"""
    _STYLE_CONTENT_TYPE = """"""
    _PROTO_DESCRIPTOR_NAME = 'apphosting.IndexSpec'
  class IndexMetadata(ProtocolBuffer.ProtocolMessage):
    has_index_spec_ = 0
  
    def __init__(self, contents=None):
      self.index_spec_ = IndexSpec()
      self.field_ = []
      if contents is not None: self.MergeFromString(contents)
  
    def index_spec(self): return self.index_spec_
  
    def mutable_index_spec(self): self.has_index_spec_ = 1; return self.index_spec_
  
    def clear_index_spec(self):self.has_index_spec_ = 0; self.index_spec_.Clear()
  
    def has_index_spec(self): return self.has_index_spec_
  
    def field_size(self): return len(self.field_)
    def field_list(self): return self.field_
  
    def field(self, i):
      return self.field_[i]
  
    def mutable_field(self, i):
      return self.field_[i]
  
    def add_field(self):
      x = FieldTypes()
      self.field_.append(x)
      return x
  
    def clear_field(self):
      self.field_ = []
  
    def MergeFrom(self, x):
      assert x is not self
      if (x.has_index_spec()): self.mutable_index_spec().MergeFrom(x.index_spec())
      for i in xrange(x.field_size()): self.add_field().CopyFrom(x.field(i))
  
    def Equals(self, x):
      if x is self: return 1
      if self.has_index_spec_ != x.has_index_spec_: return 0
      if self.has_index_spec_ and self.index_spec_ != x.index_spec_: return 0
      if len(self.field_) != len(x.field_): return 0
      for e1, e2 in zip(self.field_, x.field_):
        if e1 != e2: return 0
      return 1
  
    def IsInitialized(self, debug_strs=None):
      initialized = 1
      if (not self.has_index_spec_):
        initialized = 0
        if debug_strs is not None:
          debug_strs.append('Required field: index_spec not set.')
      elif not self.index_spec_.IsInitialized(debug_strs): initialized = 0
      for p in self.field_:
        if not p.IsInitialized(debug_strs): initialized=0
      return initialized
  
    def ByteSize(self):
      n = 0
      n += self.lengthString(self.index_spec_.ByteSize())
      n += 1 * len(self.field_)
      for i in xrange(len(self.field_)): n += self.lengthString(self.field_[i].ByteSize())
      return n + 1
  
    def ByteSizePartial(self):
      n = 0
      if (self.has_index_spec_):
        n += 1
        n += self.lengthString(self.index_spec_.ByteSizePartial())
      n += 1 * len(self.field_)
      for i in xrange(len(self.field_)): n += self.lengthString(self.field_[i].ByteSizePartial())
      return n
  
    def Clear(self):
      self.clear_index_spec()
      self.clear_field()
  
    def OutputUnchecked(self, out):
      out.putVarInt32(10)
      out.putVarInt32(self.index_spec_.ByteSize())
      self.index_spec_.OutputUnchecked(out)
      for i in xrange(len(self.field_)):
        out.putVarInt32(18)
        out.putVarInt32(self.field_[i].ByteSize())
        self.field_[i].OutputUnchecked(out)
  
    def OutputPartial(self, out):
      if (self.has_index_spec_):
        out.putVarInt32(10)
        out.putVarInt32(self.index_spec_.ByteSizePartial())
        self.index_spec_.OutputPartial(out)
      for i in xrange(len(self.field_)):
        out.putVarInt32(18)
        out.putVarInt32(self.field_[i].ByteSizePartial())
        self.field_[i].OutputPartial(out)
  
    def TryMerge(self, d):
      while d.avail() > 0:
        tt = d.getVarInt32()
        if tt == 10:
          length = d.getVarInt32()
          tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
          d.skip(length)
          self.mutable_index_spec().TryMerge(tmp)
          continue
        if tt == 18:
          length = d.getVarInt32()
          tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
          d.skip(length)
          self.add_field().TryMerge(tmp)
          continue
  
  
        if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
        d.skipData(tt)
  
  
    def __str__(self, prefix="", printElemNumber=0):
      res=""
      if self.has_index_spec_:
        res+=prefix+"index_spec <\n"
        res+=self.index_spec_.__str__(prefix + "  ", printElemNumber)
        res+=prefix+">\n"
      cnt=0
      for e in self.field_:
        elm=""
        if printElemNumber: elm="(%d)" % cnt
        res+=prefix+("field%s <\n" % elm)
        res+=e.__str__(prefix + "  ", printElemNumber)
        res+=prefix+">\n"
        cnt+=1
      return res
  
  
    def _BuildTagLookupTable(sparse, maxtag, default=None):
      return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
  
    kindex_spec = 1
    kfield = 2
  
    _TEXT = _BuildTagLookupTable({
      0: "ErrorCode",
      1: "index_spec",
      2: "field",
    }, 2)
  
    _TYPES = _BuildTagLookupTable({
      0: ProtocolBuffer.Encoder.NUMERIC,
      1: ProtocolBuffer.Encoder.STRING,
      2: ProtocolBuffer.Encoder.STRING,
    }, 2, ProtocolBuffer.Encoder.MAX_TYPE)
  
  
    _STYLE = """"""
    _STYLE_CONTENT_TYPE = """"""
    _PROTO_DESCRIPTOR_NAME = 'apphosting.IndexMetadata'
  class IndexDocumentParams(ProtocolBuffer.ProtocolMessage):
  
  
    SYNCHRONOUSLY =    0
    WHEN_CONVENIENT =    1
  
    _Freshness_NAMES = {
      0: "SYNCHRONOUSLY",
      1: "WHEN_CONVENIENT",
    }
  
    def Freshness_Name(cls, x): return cls._Freshness_NAMES.get(x, "")
    Freshness_Name = classmethod(Freshness_Name)
  
    has_freshness_ = 0
    freshness_ = 0
    has_index_spec_ = 0
  
    def __init__(self, contents=None):
      self.document_ = []
      self.index_spec_ = IndexSpec()
      if contents is not None: self.MergeFromString(contents)
  
    def document_size(self): return len(self.document_)
    def document_list(self): return self.document_
  
    def document(self, i):
      return self.document_[i]
  
    def mutable_document(self, i):
      return self.document_[i]
  
    def add_document(self):
      x = Document()
      self.document_.append(x)
      return x
  
    def clear_document(self):
      self.document_ = []
    def freshness(self): return self.freshness_
  
    def set_freshness(self, x):
      self.has_freshness_ = 1
      self.freshness_ = x
  
    def clear_freshness(self):
      if self.has_freshness_:
        self.has_freshness_ = 0
        self.freshness_ = 0
  
    def has_freshness(self): return self.has_freshness_
  
    def index_spec(self): return self.index_spec_
  
    def mutable_index_spec(self): self.has_index_spec_ = 1; return self.index_spec_
  
    def clear_index_spec(self):self.has_index_spec_ = 0; self.index_spec_.Clear()
  
    def has_index_spec(self): return self.has_index_spec_
  
  
    def MergeFrom(self, x):
      assert x is not self
      for i in xrange(x.document_size()): self.add_document().CopyFrom(x.document(i))
      if (x.has_freshness()): self.set_freshness(x.freshness())
      if (x.has_index_spec()): self.mutable_index_spec().MergeFrom(x.index_spec())
  
    def Equals(self, x):
      if x is self: return 1
      if len(self.document_) != len(x.document_): return 0
      for e1, e2 in zip(self.document_, x.document_):
        if e1 != e2: return 0
      if self.has_freshness_ != x.has_freshness_: return 0
      if self.has_freshness_ and self.freshness_ != x.freshness_: return 0
      if self.has_index_spec_ != x.has_index_spec_: return 0
      if self.has_index_spec_ and self.index_spec_ != x.index_spec_: return 0
      return 1
  
    def IsInitialized(self, debug_strs=None):
      initialized = 1
      for p in self.document_:
        if not p.IsInitialized(debug_strs): initialized=0
      if (not self.has_index_spec_):
        initialized = 0
        if debug_strs is not None:
          debug_strs.append('Required field: index_spec not set.')
      elif not self.index_spec_.IsInitialized(debug_strs): initialized = 0
      return initialized
  
    def ByteSize(self):
      n = 0
      n += 1 * len(self.document_)
      for i in xrange(len(self.document_)): n += self.lengthString(self.document_[i].ByteSize())
      if (self.has_freshness_): n += 1 + self.lengthVarInt64(self.freshness_)
      n += self.lengthString(self.index_spec_.ByteSize())
      return n + 1
  
    def ByteSizePartial(self):
      n = 0
      n += 1 * len(self.document_)
      for i in xrange(len(self.document_)): n += self.lengthString(self.document_[i].ByteSizePartial())
      if (self.has_freshness_): n += 1 + self.lengthVarInt64(self.freshness_)
      if (self.has_index_spec_):
        n += 1
        n += self.lengthString(self.index_spec_.ByteSizePartial())
      return n
  
    def Clear(self):
      self.clear_document()
      self.clear_freshness()
      self.clear_index_spec()
  
    def OutputUnchecked(self, out):
      for i in xrange(len(self.document_)):
        out.putVarInt32(10)
        out.putVarInt32(self.document_[i].ByteSize())
        self.document_[i].OutputUnchecked(out)
      if (self.has_freshness_):
        out.putVarInt32(16)
        out.putVarInt32(self.freshness_)
      out.putVarInt32(26)
      out.putVarInt32(self.index_spec_.ByteSize())
      self.index_spec_.OutputUnchecked(out)
  
    def OutputPartial(self, out):
      for i in xrange(len(self.document_)):
        out.putVarInt32(10)
        out.putVarInt32(self.document_[i].ByteSizePartial())
        self.document_[i].OutputPartial(out)
      if (self.has_freshness_):
        out.putVarInt32(16)
        out.putVarInt32(self.freshness_)
      if (self.has_index_spec_):
        out.putVarInt32(26)
        out.putVarInt32(self.index_spec_.ByteSizePartial())
        self.index_spec_.OutputPartial(out)
  
    def TryMerge(self, d):
      while d.avail() > 0:
        tt = d.getVarInt32()
        if tt == 10:
          length = d.getVarInt32()
          tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
          d.skip(length)
          self.add_document().TryMerge(tmp)
          continue
        if tt == 16:
          self.set_freshness(d.getVarInt32())
          continue
        if tt == 26:
          length = d.getVarInt32()
          tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
          d.skip(length)
          self.mutable_index_spec().TryMerge(tmp)
          continue
  
  
        if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
        d.skipData(tt)
  
  
    def __str__(self, prefix="", printElemNumber=0):
      res=""
      cnt=0
      for e in self.document_:
        elm=""
        if printElemNumber: elm="(%d)" % cnt
        res+=prefix+("document%s <\n" % elm)
        res+=e.__str__(prefix + "  ", printElemNumber)
        res+=prefix+">\n"
        cnt+=1
      if self.has_freshness_: res+=prefix+("freshness: %s\n" % self.DebugFormatInt32(self.freshness_))
      if self.has_index_spec_:
        res+=prefix+"index_spec <\n"
        res+=self.index_spec_.__str__(prefix + "  ", printElemNumber)
        res+=prefix+">\n"
      return res
  
  
    def _BuildTagLookupTable(sparse, maxtag, default=None):
      return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
  
    kdocument = 1
    kfreshness = 2
    kindex_spec = 3
  
    _TEXT = _BuildTagLookupTable({
      0: "ErrorCode",
      1: "document",
      2: "freshness",
      3: "index_spec",
    }, 3)
  
    _TYPES = _BuildTagLookupTable({
      0: ProtocolBuffer.Encoder.NUMERIC,
      1: ProtocolBuffer.Encoder.STRING,
      2: ProtocolBuffer.Encoder.NUMERIC,
      3: ProtocolBuffer.Encoder.STRING,
    }, 3, ProtocolBuffer.Encoder.MAX_TYPE)
  
  
    _STYLE = """"""
    _STYLE_CONTENT_TYPE = """"""
    _PROTO_DESCRIPTOR_NAME = 'apphosting.IndexDocumentParams'
  class IndexDocumentRequest(ProtocolBuffer.ProtocolMessage):
    has_params_ = 0
    has_app_id_ = 0
    app_id_ = ""
  
    def __init__(self, contents=None):
      self.params_ = IndexDocumentParams()
      if contents is not None: self.MergeFromString(contents)
  
    def params(self): return self.params_
  
    def mutable_params(self): self.has_params_ = 1; return self.params_
  
    def clear_params(self):self.has_params_ = 0; self.params_.Clear()
  
    def has_params(self): return self.has_params_
  
    def app_id(self): return self.app_id_
  
    def set_app_id(self, x):
      self.has_app_id_ = 1
      self.app_id_ = x
  
    def clear_app_id(self):
      if self.has_app_id_:
        self.has_app_id_ = 0
        self.app_id_ = ""
  
    def has_app_id(self): return self.has_app_id_
  
  
    def MergeFrom(self, x):
      assert x is not self
      if (x.has_params()): self.mutable_params().MergeFrom(x.params())
      if (x.has_app_id()): self.set_app_id(x.app_id())
  
    def Equals(self, x):
      if x is self: return 1
      if self.has_params_ != x.has_params_: return 0
      if self.has_params_ and self.params_ != x.params_: return 0
      if self.has_app_id_ != x.has_app_id_: return 0
      if self.has_app_id_ and self.app_id_ != x.app_id_: return 0
      return 1
  
    def IsInitialized(self, debug_strs=None):
      initialized = 1
      if (not self.has_params_):
        initialized = 0
        if debug_strs is not None:
          debug_strs.append('Required field: params not set.')
      elif not self.params_.IsInitialized(debug_strs): initialized = 0
      return initialized
  
    def ByteSize(self):
      n = 0
      n += self.lengthString(self.params_.ByteSize())
      if (self.has_app_id_): n += 1 + self.lengthString(len(self.app_id_))
      return n + 1
  
    def ByteSizePartial(self):
      n = 0
      if (self.has_params_):
        n += 1
        n += self.lengthString(self.params_.ByteSizePartial())
      if (self.has_app_id_): n += 1 + self.lengthString(len(self.app_id_))
      return n
  
    def Clear(self):
      self.clear_params()
      self.clear_app_id()
  
    def OutputUnchecked(self, out):
      out.putVarInt32(10)
      out.putVarInt32(self.params_.ByteSize())
      self.params_.OutputUnchecked(out)
      if (self.has_app_id_):
        out.putVarInt32(26)
        out.putPrefixedString(self.app_id_)
  
    def OutputPartial(self, out):
      if (self.has_params_):
        out.putVarInt32(10)
        out.putVarInt32(self.params_.ByteSizePartial())
        self.params_.OutputPartial(out)
      if (self.has_app_id_):
        out.putVarInt32(26)
        out.putPrefixedString(self.app_id_)
  
    def TryMerge(self, d):
      while d.avail() > 0:
        tt = d.getVarInt32()
        if tt == 10:
          length = d.getVarInt32()
          tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
          d.skip(length)
          self.mutable_params().TryMerge(tmp)
          continue
        if tt == 26:
          self.set_app_id(d.getPrefixedString())
          continue
  
  
        if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
        d.skipData(tt)
  
  
    def __str__(self, prefix="", printElemNumber=0):
      res=""
      if self.has_params_:
        res+=prefix+"params <\n"
        res+=self.params_.__str__(prefix + "  ", printElemNumber)
        res+=prefix+">\n"
      if self.has_app_id_: res+=prefix+("app_id: %s\n" % self.DebugFormatString(self.app_id_))
      return res
  
  
    def _BuildTagLookupTable(sparse, maxtag, default=None):
      return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
  
    kparams = 1
    kapp_id = 3
  
    _TEXT = _BuildTagLookupTable({
      0: "ErrorCode",
      1: "params",
      3: "app_id",
    }, 3)
  
    _TYPES = _BuildTagLookupTable({
      0: ProtocolBuffer.Encoder.NUMERIC,
      1: ProtocolBuffer.Encoder.STRING,
      3: ProtocolBuffer.Encoder.STRING,
    }, 3, ProtocolBuffer.Encoder.MAX_TYPE)
  
  
    _STYLE = """"""
    _STYLE_CONTENT_TYPE = """"""
    _PROTO_DESCRIPTOR_NAME = 'apphosting.IndexDocumentRequest'
  class IndexDocumentResponse(ProtocolBuffer.ProtocolMessage):
  
    def __init__(self, contents=None):
      self.status_ = []
      self.doc_id_ = []
      if contents is not None: self.MergeFromString(contents)
  
    def status_size(self): return len(self.status_)
    def status_list(self): return self.status_
  
    def status(self, i):
      return self.status_[i]
  
    def mutable_status(self, i):
      return self.status_[i]
  
    def add_status(self):
      x = RequestStatus()
      self.status_.append(x)
      return x
  
    def clear_status(self):
      self.status_ = []
    def doc_id_size(self): return len(self.doc_id_)
    def doc_id_list(self): return self.doc_id_
  
    def doc_id(self, i):
      return self.doc_id_[i]
  
    def set_doc_id(self, i, x):
      self.doc_id_[i] = x
  
    def add_doc_id(self, x):
      self.doc_id_.append(x)
  
    def clear_doc_id(self):
      self.doc_id_ = []
  
  
    def MergeFrom(self, x):
      assert x is not self
      for i in xrange(x.status_size()): self.add_status().CopyFrom(x.status(i))
      for i in xrange(x.doc_id_size()): self.add_doc_id(x.doc_id(i))
  
    def Equals(self, x):
      if x is self: return 1
      if len(self.status_) != len(x.status_): return 0
      for e1, e2 in zip(self.status_, x.status_):
        if e1 != e2: return 0
      if len(self.doc_id_) != len(x.doc_id_): return 0
      for e1, e2 in zip(self.doc_id_, x.doc_id_):
        if e1 != e2: return 0
      return 1
  
    def IsInitialized(self, debug_strs=None):
      initialized = 1
      for p in self.status_:
        if not p.IsInitialized(debug_strs): initialized=0
      return initialized
  
    def ByteSize(self):
      n = 0
      n += 1 * len(self.status_)
      for i in xrange(len(self.status_)): n += self.lengthString(self.status_[i].ByteSize())
      n += 1 * len(self.doc_id_)
      for i in xrange(len(self.doc_id_)): n += self.lengthString(len(self.doc_id_[i]))
      return n
  
    def ByteSizePartial(self):
      n = 0
      n += 1 * len(self.status_)
      for i in xrange(len(self.status_)): n += self.lengthString(self.status_[i].ByteSizePartial())
      n += 1 * len(self.doc_id_)
      for i in xrange(len(self.doc_id_)): n += self.lengthString(len(self.doc_id_[i]))
      return n
  
    def Clear(self):
      self.clear_status()
      self.clear_doc_id()
  
    def OutputUnchecked(self, out):
      for i in xrange(len(self.status_)):
        out.putVarInt32(10)
        out.putVarInt32(self.status_[i].ByteSize())
        self.status_[i].OutputUnchecked(out)
      for i in xrange(len(self.doc_id_)):
        out.putVarInt32(18)
        out.putPrefixedString(self.doc_id_[i])
  
    def OutputPartial(self, out):
      for i in xrange(len(self.status_)):
        out.putVarInt32(10)
        out.putVarInt32(self.status_[i].ByteSizePartial())
        self.status_[i].OutputPartial(out)
      for i in xrange(len(self.doc_id_)):
        out.putVarInt32(18)
        out.putPrefixedString(self.doc_id_[i])
  
    def TryMerge(self, d):
      while d.avail() > 0:
        tt = d.getVarInt32()
        if tt == 10:
          length = d.getVarInt32()
          tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
          d.skip(length)
          self.add_status().TryMerge(tmp)
          continue
        if tt == 18:
          self.add_doc_id(d.getPrefixedString())
          continue
  
  
        if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
        d.skipData(tt)
  
  
    def __str__(self, prefix="", printElemNumber=0):
      res=""
      cnt=0
      for e in self.status_:
        elm=""
        if printElemNumber: elm="(%d)" % cnt
        res+=prefix+("status%s <\n" % elm)
        res+=e.__str__(prefix + "  ", printElemNumber)
        res+=prefix+">\n"
        cnt+=1
      cnt=0
      for e in self.doc_id_:
        elm=""
        if printElemNumber: elm="(%d)" % cnt
        res+=prefix+("doc_id%s: %s\n" % (elm, self.DebugFormatString(e)))
        cnt+=1
      return res
  
  
    def _BuildTagLookupTable(sparse, maxtag, default=None):
      return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
  
    kstatus = 1
    kdoc_id = 2
  
    _TEXT = _BuildTagLookupTable({
      0: "ErrorCode",
      1: "status",
      2: "doc_id",
    }, 2)
  
    _TYPES = _BuildTagLookupTable({
      0: ProtocolBuffer.Encoder.NUMERIC,
      1: ProtocolBuffer.Encoder.STRING,
      2: ProtocolBuffer.Encoder.STRING,
    }, 2, ProtocolBuffer.Encoder.MAX_TYPE)
  
  
    _STYLE = """"""
    _STYLE_CONTENT_TYPE = """"""
    _PROTO_DESCRIPTOR_NAME = 'apphosting.IndexDocumentResponse'
  class DeleteDocumentParams(ProtocolBuffer.ProtocolMessage):
    has_index_spec_ = 0
  
    def __init__(self, contents=None):
      self.doc_id_ = []
      self.index_spec_ = IndexSpec()
      if contents is not None: self.MergeFromString(contents)
  
    def doc_id_size(self): return len(self.doc_id_)
    def doc_id_list(self): return self.doc_id_
  
    def doc_id(self, i):
      return self.doc_id_[i]
  
    def set_doc_id(self, i, x):
      self.doc_id_[i] = x
  
    def add_doc_id(self, x):
      self.doc_id_.append(x)
  
    def clear_doc_id(self):
      self.doc_id_ = []
  
    def index_spec(self): return self.index_spec_
  
    def mutable_index_spec(self): self.has_index_spec_ = 1; return self.index_spec_
  
    def clear_index_spec(self):self.has_index_spec_ = 0; self.index_spec_.Clear()
  
    def has_index_spec(self): return self.has_index_spec_
  
  
    def MergeFrom(self, x):
      assert x is not self
      for i in xrange(x.doc_id_size()): self.add_doc_id(x.doc_id(i))
      if (x.has_index_spec()): self.mutable_index_spec().MergeFrom(x.index_spec())
  
    def Equals(self, x):
      if x is self: return 1
      if len(self.doc_id_) != len(x.doc_id_): return 0
      for e1, e2 in zip(self.doc_id_, x.doc_id_):
        if e1 != e2: return 0
      if self.has_index_spec_ != x.has_index_spec_: return 0
      if self.has_index_spec_ and self.index_spec_ != x.index_spec_: return 0
      return 1
  
    def IsInitialized(self, debug_strs=None):
      initialized = 1
      if (not self.has_index_spec_):
        initialized = 0
        if debug_strs is not None:
          debug_strs.append('Required field: index_spec not set.')
      elif not self.index_spec_.IsInitialized(debug_strs): initialized = 0
      return initialized
  
    def ByteSize(self):
      n = 0
      n += 1 * len(self.doc_id_)
      for i in xrange(len(self.doc_id_)): n += self.lengthString(len(self.doc_id_[i]))
      n += self.lengthString(self.index_spec_.ByteSize())
      return n + 1
  
    def ByteSizePartial(self):
      n = 0
      n += 1 * len(self.doc_id_)
      for i in xrange(len(self.doc_id_)): n += self.lengthString(len(self.doc_id_[i]))
      if (self.has_index_spec_):
        n += 1
        n += self.lengthString(self.index_spec_.ByteSizePartial())
      return n
  
    def Clear(self):
      self.clear_doc_id()
      self.clear_index_spec()
  
    def OutputUnchecked(self, out):
      for i in xrange(len(self.doc_id_)):
        out.putVarInt32(10)
        out.putPrefixedString(self.doc_id_[i])
      out.putVarInt32(18)
      out.putVarInt32(self.index_spec_.ByteSize())
      self.index_spec_.OutputUnchecked(out)
  
    def OutputPartial(self, out):
      for i in xrange(len(self.doc_id_)):
        out.putVarInt32(10)
        out.putPrefixedString(self.doc_id_[i])
      if (self.has_index_spec_):
        out.putVarInt32(18)
        out.putVarInt32(self.index_spec_.ByteSizePartial())
        self.index_spec_.OutputPartial(out)
  
    def TryMerge(self, d):
      while d.avail() > 0:
        tt = d.getVarInt32()
        if tt == 10:
          self.add_doc_id(d.getPrefixedString())
          continue
        if tt == 18:
          length = d.getVarInt32()
          tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
          d.skip(length)
          self.mutable_index_spec().TryMerge(tmp)
          continue
  
  
        if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
        d.skipData(tt)
  
  
    def __str__(self, prefix="", printElemNumber=0):
      res=""
      cnt=0
      for e in self.doc_id_:
        elm=""
        if printElemNumber: elm="(%d)" % cnt
        res+=prefix+("doc_id%s: %s\n" % (elm, self.DebugFormatString(e)))
        cnt+=1
      if self.has_index_spec_:
        res+=prefix+"index_spec <\n"
        res+=self.index_spec_.__str__(prefix + "  ", printElemNumber)
        res+=prefix+">\n"
      return res
  
  
    def _BuildTagLookupTable(sparse, maxtag, default=None):
      return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
  
    kdoc_id = 1
    kindex_spec = 2
  
    _TEXT = _BuildTagLookupTable({
      0: "ErrorCode",
      1: "doc_id",
      2: "index_spec",
    }, 2)
  
    _TYPES = _BuildTagLookupTable({
      0: ProtocolBuffer.Encoder.NUMERIC,
      1: ProtocolBuffer.Encoder.STRING,
      2: ProtocolBuffer.Encoder.STRING,
    }, 2, ProtocolBuffer.Encoder.MAX_TYPE)
  
  
    _STYLE = """"""
    _STYLE_CONTENT_TYPE = """"""
    _PROTO_DESCRIPTOR_NAME = 'apphosting.DeleteDocumentParams'
  class DeleteDocumentRequest(ProtocolBuffer.ProtocolMessage):
    has_params_ = 0
    has_app_id_ = 0
    app_id_ = ""
  
    def __init__(self, contents=None):
      self.params_ = DeleteDocumentParams()
      if contents is not None: self.MergeFromString(contents)
  
    def params(self): return self.params_
  
    def mutable_params(self): self.has_params_ = 1; return self.params_
  
    def clear_params(self):self.has_params_ = 0; self.params_.Clear()
  
    def has_params(self): return self.has_params_
  
    def app_id(self): return self.app_id_
  
    def set_app_id(self, x):
      self.has_app_id_ = 1
      self.app_id_ = x
  
    def clear_app_id(self):
      if self.has_app_id_:
        self.has_app_id_ = 0
        self.app_id_ = ""
  
    def has_app_id(self): return self.has_app_id_
  
  
    def MergeFrom(self, x):
      assert x is not self
      if (x.has_params()): self.mutable_params().MergeFrom(x.params())
      if (x.has_app_id()): self.set_app_id(x.app_id())
  
    def Equals(self, x):
      if x is self: return 1
      if self.has_params_ != x.has_params_: return 0
      if self.has_params_ and self.params_ != x.params_: return 0
      if self.has_app_id_ != x.has_app_id_: return 0
      if self.has_app_id_ and self.app_id_ != x.app_id_: return 0
      return 1
  
    def IsInitialized(self, debug_strs=None):
      initialized = 1
      if (not self.has_params_):
        initialized = 0
        if debug_strs is not None:
          debug_strs.append('Required field: params not set.')
      elif not self.params_.IsInitialized(debug_strs): initialized = 0
      return initialized
  
    def ByteSize(self):
      n = 0
      n += self.lengthString(self.params_.ByteSize())
      if (self.has_app_id_): n += 1 + self.lengthString(len(self.app_id_))
      return n + 1
  
    def ByteSizePartial(self):
      n = 0
      if (self.has_params_):
        n += 1
        n += self.lengthString(self.params_.ByteSizePartial())
      if (self.has_app_id_): n += 1 + self.lengthString(len(self.app_id_))
      return n
  
    def Clear(self):
      self.clear_params()
      self.clear_app_id()
  
    def OutputUnchecked(self, out):
      out.putVarInt32(10)
      out.putVarInt32(self.params_.ByteSize())
      self.params_.OutputUnchecked(out)
      if (self.has_app_id_):
        out.putVarInt32(26)
        out.putPrefixedString(self.app_id_)
  
    def OutputPartial(self, out):
      if (self.has_params_):
        out.putVarInt32(10)
        out.putVarInt32(self.params_.ByteSizePartial())
        self.params_.OutputPartial(out)
      if (self.has_app_id_):
        out.putVarInt32(26)
        out.putPrefixedString(self.app_id_)
  
    def TryMerge(self, d):
      while d.avail() > 0:
        tt = d.getVarInt32()
        if tt == 10:
          length = d.getVarInt32()
          tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
          d.skip(length)
          self.mutable_params().TryMerge(tmp)
          continue
        if tt == 26:
          self.set_app_id(d.getPrefixedString())
          continue
  
  
        if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
        d.skipData(tt)
  
  
    def __str__(self, prefix="", printElemNumber=0):
      res=""
      if self.has_params_:
        res+=prefix+"params <\n"
        res+=self.params_.__str__(prefix + "  ", printElemNumber)
        res+=prefix+">\n"
      if self.has_app_id_: res+=prefix+("app_id: %s\n" % self.DebugFormatString(self.app_id_))
      return res
  
  
    def _BuildTagLookupTable(sparse, maxtag, default=None):
      return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
  
    kparams = 1
    kapp_id = 3
  
    _TEXT = _BuildTagLookupTable({
      0: "ErrorCode",
      1: "params",
      3: "app_id",
    }, 3)
  
    _TYPES = _BuildTagLookupTable({
      0: ProtocolBuffer.Encoder.NUMERIC,
      1: ProtocolBuffer.Encoder.STRING,
      3: ProtocolBuffer.Encoder.STRING,
    }, 3, ProtocolBuffer.Encoder.MAX_TYPE)
  
  
    _STYLE = """"""
    _STYLE_CONTENT_TYPE = """"""
    _PROTO_DESCRIPTOR_NAME = 'apphosting.DeleteDocumentRequest'
  class DeleteDocumentResponse(ProtocolBuffer.ProtocolMessage):
  
    def __init__(self, contents=None):
      self.status_ = []
      if contents is not None: self.MergeFromString(contents)
  
    def status_size(self): return len(self.status_)
    def status_list(self): return self.status_
  
    def status(self, i):
      return self.status_[i]
  
    def mutable_status(self, i):
      return self.status_[i]
  
    def add_status(self):
      x = RequestStatus()
      self.status_.append(x)
      return x
  
    def clear_status(self):
      self.status_ = []
  
    def MergeFrom(self, x):
      assert x is not self
      for i in xrange(x.status_size()): self.add_status().CopyFrom(x.status(i))
  
    def Equals(self, x):
      if x is self: return 1
      if len(self.status_) != len(x.status_): return 0
      for e1, e2 in zip(self.status_, x.status_):
        if e1 != e2: return 0
      return 1
  
    def IsInitialized(self, debug_strs=None):
      initialized = 1
      for p in self.status_:
        if not p.IsInitialized(debug_strs): initialized=0
      return initialized
  
    def ByteSize(self):
      n = 0
      n += 1 * len(self.status_)
      for i in xrange(len(self.status_)): n += self.lengthString(self.status_[i].ByteSize())
      return n
  
    def ByteSizePartial(self):
      n = 0
      n += 1 * len(self.status_)
      for i in xrange(len(self.status_)): n += self.lengthString(self.status_[i].ByteSizePartial())
      return n
  
    def Clear(self):
      self.clear_status()
  
    def OutputUnchecked(self, out):
      for i in xrange(len(self.status_)):
        out.putVarInt32(10)
        out.putVarInt32(self.status_[i].ByteSize())
        self.status_[i].OutputUnchecked(out)
  
    def OutputPartial(self, out):
      for i in xrange(len(self.status_)):
        out.putVarInt32(10)
        out.putVarInt32(self.status_[i].ByteSizePartial())
        self.status_[i].OutputPartial(out)
  
    def TryMerge(self, d):
      while d.avail() > 0:
        tt = d.getVarInt32()
        if tt == 10:
          length = d.getVarInt32()
          tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
          d.skip(length)
          self.add_status().TryMerge(tmp)
          continue
  
  
        if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
        d.skipData(tt)
  
  
    def __str__(self, prefix="", printElemNumber=0):
      res=""
      cnt=0
      for e in self.status_:
        elm=""
        if printElemNumber: elm="(%d)" % cnt
        res+=prefix+("status%s <\n" % elm)
        res+=e.__str__(prefix + "  ", printElemNumber)
        res+=prefix+">\n"
        cnt+=1
      return res
  
  
    def _BuildTagLookupTable(sparse, maxtag, default=None):
      return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
  
    kstatus = 1
  
    _TEXT = _BuildTagLookupTable({
      0: "ErrorCode",
      1: "status",
    }, 1)
  
    _TYPES = _BuildTagLookupTable({
      0: ProtocolBuffer.Encoder.NUMERIC,
      1: ProtocolBuffer.Encoder.STRING,
    }, 1, ProtocolBuffer.Encoder.MAX_TYPE)
  
  
    _STYLE = """"""
    _STYLE_CONTENT_TYPE = """"""
    _PROTO_DESCRIPTOR_NAME = 'apphosting.DeleteDocumentResponse'
  class ListDocumentsParams(ProtocolBuffer.ProtocolMessage):
    has_index_spec_ = 0
    has_start_doc_id_ = 0
    start_doc_id_ = ""
    has_include_start_doc_ = 0
    include_start_doc_ = 1
    has_limit_ = 0
    limit_ = 100
    has_keys_only_ = 0
    keys_only_ = 0
  
    def __init__(self, contents=None):
      self.index_spec_ = IndexSpec()
      if contents is not None: self.MergeFromString(contents)
  
    def index_spec(self): return self.index_spec_
  
    def mutable_index_spec(self): self.has_index_spec_ = 1; return self.index_spec_
  
    def clear_index_spec(self):self.has_index_spec_ = 0; self.index_spec_.Clear()
  
    def has_index_spec(self): return self.has_index_spec_
  
    def start_doc_id(self): return self.start_doc_id_
  
    def set_start_doc_id(self, x):
      self.has_start_doc_id_ = 1
      self.start_doc_id_ = x
  
    def clear_start_doc_id(self):
      if self.has_start_doc_id_:
        self.has_start_doc_id_ = 0
        self.start_doc_id_ = ""
  
    def has_start_doc_id(self): return self.has_start_doc_id_
  
    def include_start_doc(self): return self.include_start_doc_
  
    def set_include_start_doc(self, x):
      self.has_include_start_doc_ = 1
      self.include_start_doc_ = x
  
    def clear_include_start_doc(self):
      if self.has_include_start_doc_:
        self.has_include_start_doc_ = 0
        self.include_start_doc_ = 1
  
    def has_include_start_doc(self): return self.has_include_start_doc_
  
    def limit(self): return self.limit_
  
    def set_limit(self, x):
      self.has_limit_ = 1
      self.limit_ = x
  
    def clear_limit(self):
      if self.has_limit_:
        self.has_limit_ = 0
        self.limit_ = 100
  
    def has_limit(self): return self.has_limit_
  
    def keys_only(self): return self.keys_only_
  
    def set_keys_only(self, x):
      self.has_keys_only_ = 1
      self.keys_only_ = x
  
    def clear_keys_only(self):
      if self.has_keys_only_:
        self.has_keys_only_ = 0
        self.keys_only_ = 0
  
    def has_keys_only(self): return self.has_keys_only_
  
  
    def MergeFrom(self, x):
      assert x is not self
      if (x.has_index_spec()): self.mutable_index_spec().MergeFrom(x.index_spec())
      if (x.has_start_doc_id()): self.set_start_doc_id(x.start_doc_id())
      if (x.has_include_start_doc()): self.set_include_start_doc(x.include_start_doc())
      if (x.has_limit()): self.set_limit(x.limit())
      if (x.has_keys_only()): self.set_keys_only(x.keys_only())
  
    def Equals(self, x):
      if x is self: return 1
      if self.has_index_spec_ != x.has_index_spec_: return 0
      if self.has_index_spec_ and self.index_spec_ != x.index_spec_: return 0
      if self.has_start_doc_id_ != x.has_start_doc_id_: return 0
      if self.has_start_doc_id_ and self.start_doc_id_ != x.start_doc_id_: return 0
      if self.has_include_start_doc_ != x.has_include_start_doc_: return 0
      if self.has_include_start_doc_ and self.include_start_doc_ != x.include_start_doc_: return 0
      if self.has_limit_ != x.has_limit_: return 0
      if self.has_limit_ and self.limit_ != x.limit_: return 0
      if self.has_keys_only_ != x.has_keys_only_: return 0
      if self.has_keys_only_ and self.keys_only_ != x.keys_only_: return 0
      return 1
  
    def IsInitialized(self, debug_strs=None):
      initialized = 1
      if (not self.has_index_spec_):
        initialized = 0
        if debug_strs is not None:
          debug_strs.append('Required field: index_spec not set.')
      elif not self.index_spec_.IsInitialized(debug_strs): initialized = 0
      return initialized
  
    def ByteSize(self):
      n = 0
      n += self.lengthString(self.index_spec_.ByteSize())
      if (self.has_start_doc_id_): n += 1 + self.lengthString(len(self.start_doc_id_))
      if (self.has_include_start_doc_): n += 2
      if (self.has_limit_): n += 1 + self.lengthVarInt64(self.limit_)
      if (self.has_keys_only_): n += 2
      return n + 1
  
    def ByteSizePartial(self):
      n = 0
      if (self.has_index_spec_):
        n += 1
        n += self.lengthString(self.index_spec_.ByteSizePartial())
      if (self.has_start_doc_id_): n += 1 + self.lengthString(len(self.start_doc_id_))
      if (self.has_include_start_doc_): n += 2
      if (self.has_limit_): n += 1 + self.lengthVarInt64(self.limit_)
      if (self.has_keys_only_): n += 2
      return n
  
    def Clear(self):
      self.clear_index_spec()
      self.clear_start_doc_id()
      self.clear_include_start_doc()
      self.clear_limit()
      self.clear_keys_only()
  
    def OutputUnchecked(self, out):
      out.putVarInt32(10)
      out.putVarInt32(self.index_spec_.ByteSize())
      self.index_spec_.OutputUnchecked(out)
      if (self.has_start_doc_id_):
        out.putVarInt32(18)
        out.putPrefixedString(self.start_doc_id_)
      if (self.has_include_start_doc_):
        out.putVarInt32(24)
        out.putBoolean(self.include_start_doc_)
      if (self.has_limit_):
        out.putVarInt32(32)
        out.putVarInt32(self.limit_)
      if (self.has_keys_only_):
        out.putVarInt32(40)
        out.putBoolean(self.keys_only_)
  
    def OutputPartial(self, out):
      if (self.has_index_spec_):
        out.putVarInt32(10)
        out.putVarInt32(self.index_spec_.ByteSizePartial())
        self.index_spec_.OutputPartial(out)
      if (self.has_start_doc_id_):
        out.putVarInt32(18)
        out.putPrefixedString(self.start_doc_id_)
      if (self.has_include_start_doc_):
        out.putVarInt32(24)
        out.putBoolean(self.include_start_doc_)
      if (self.has_limit_):
        out.putVarInt32(32)
        out.putVarInt32(self.limit_)
      if (self.has_keys_only_):
        out.putVarInt32(40)
        out.putBoolean(self.keys_only_)
  
    def TryMerge(self, d):
      while d.avail() > 0:
        tt = d.getVarInt32()
        if tt == 10:
          length = d.getVarInt32()
          tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
          d.skip(length)
          self.mutable_index_spec().TryMerge(tmp)
          continue
        if tt == 18:
          self.set_start_doc_id(d.getPrefixedString())
          continue
        if tt == 24:
          self.set_include_start_doc(d.getBoolean())
          continue
        if tt == 32:
          self.set_limit(d.getVarInt32())
          continue
        if tt == 40:
          self.set_keys_only(d.getBoolean())
          continue
  
  
        if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
        d.skipData(tt)
  
  
    def __str__(self, prefix="", printElemNumber=0):
      res=""
      if self.has_index_spec_:
        res+=prefix+"index_spec <\n"
        res+=self.index_spec_.__str__(prefix + "  ", printElemNumber)
        res+=prefix+">\n"
      if self.has_start_doc_id_: res+=prefix+("start_doc_id: %s\n" % self.DebugFormatString(self.start_doc_id_))
      if self.has_include_start_doc_: res+=prefix+("include_start_doc: %s\n" % self.DebugFormatBool(self.include_start_doc_))
      if self.has_limit_: res+=prefix+("limit: %s\n" % self.DebugFormatInt32(self.limit_))
      if self.has_keys_only_: res+=prefix+("keys_only: %s\n" % self.DebugFormatBool(self.keys_only_))
      return res
  
  
    def _BuildTagLookupTable(sparse, maxtag, default=None):
      return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
  
    kindex_spec = 1
    kstart_doc_id = 2
    kinclude_start_doc = 3
    klimit = 4
    kkeys_only = 5
  
    _TEXT = _BuildTagLookupTable({
      0: "ErrorCode",
      1: "index_spec",
      2: "start_doc_id",
      3: "include_start_doc",
      4: "limit",
      5: "keys_only",
    }, 5)
  
    _TYPES = _BuildTagLookupTable({
      0: ProtocolBuffer.Encoder.NUMERIC,
      1: ProtocolBuffer.Encoder.STRING,
      2: ProtocolBuffer.Encoder.STRING,
      3: ProtocolBuffer.Encoder.NUMERIC,
      4: ProtocolBuffer.Encoder.NUMERIC,
      5: ProtocolBuffer.Encoder.NUMERIC,
    }, 5, ProtocolBuffer.Encoder.MAX_TYPE)
  
  
    _STYLE = """"""
    _STYLE_CONTENT_TYPE = """"""
    _PROTO_DESCRIPTOR_NAME = 'apphosting.ListDocumentsParams'
  class ListDocumentsRequest(ProtocolBuffer.ProtocolMessage):
    has_params_ = 0
    has_app_id_ = 0
    app_id_ = ""
  
    def __init__(self, contents=None):
      self.params_ = ListDocumentsParams()
      if contents is not None: self.MergeFromString(contents)
  
    def params(self): return self.params_
  
    def mutable_params(self): self.has_params_ = 1; return self.params_
  
    def clear_params(self):self.has_params_ = 0; self.params_.Clear()
  
    def has_params(self): return self.has_params_
  
    def app_id(self): return self.app_id_
  
    def set_app_id(self, x):
      self.has_app_id_ = 1
      self.app_id_ = x
  
    def clear_app_id(self):
      if self.has_app_id_:
        self.has_app_id_ = 0
        self.app_id_ = ""
  
    def has_app_id(self): return self.has_app_id_
  
  
    def MergeFrom(self, x):
      assert x is not self
      if (x.has_params()): self.mutable_params().MergeFrom(x.params())
      if (x.has_app_id()): self.set_app_id(x.app_id())
  
    def Equals(self, x):
      if x is self: return 1
      if self.has_params_ != x.has_params_: return 0
      if self.has_params_ and self.params_ != x.params_: return 0
      if self.has_app_id_ != x.has_app_id_: return 0
      if self.has_app_id_ and self.app_id_ != x.app_id_: return 0
      return 1
  
    def IsInitialized(self, debug_strs=None):
      initialized = 1
      if (not self.has_params_):
        initialized = 0
        if debug_strs is not None:
          debug_strs.append('Required field: params not set.')
      elif not self.params_.IsInitialized(debug_strs): initialized = 0
      return initialized
  
    def ByteSize(self):
      n = 0
      n += self.lengthString(self.params_.ByteSize())
      if (self.has_app_id_): n += 1 + self.lengthString(len(self.app_id_))
      return n + 1
  
    def ByteSizePartial(self):
      n = 0
      if (self.has_params_):
        n += 1
        n += self.lengthString(self.params_.ByteSizePartial())
      if (self.has_app_id_): n += 1 + self.lengthString(len(self.app_id_))
      return n
  
    def Clear(self):
      self.clear_params()
      self.clear_app_id()
  
    def OutputUnchecked(self, out):
      out.putVarInt32(10)
      out.putVarInt32(self.params_.ByteSize())
      self.params_.OutputUnchecked(out)
      if (self.has_app_id_):
        out.putVarInt32(18)
        out.putPrefixedString(self.app_id_)
  
    def OutputPartial(self, out):
      if (self.has_params_):
        out.putVarInt32(10)
        out.putVarInt32(self.params_.ByteSizePartial())
        self.params_.OutputPartial(out)
      if (self.has_app_id_):
        out.putVarInt32(18)
        out.putPrefixedString(self.app_id_)
  
    def TryMerge(self, d):
      while d.avail() > 0:
        tt = d.getVarInt32()
        if tt == 10:
          length = d.getVarInt32()
          tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
          d.skip(length)
          self.mutable_params().TryMerge(tmp)
          continue
        if tt == 18:
          self.set_app_id(d.getPrefixedString())
          continue
  
  
        if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
        d.skipData(tt)
  
  
    def __str__(self, prefix="", printElemNumber=0):
      res=""
      if self.has_params_:
        res+=prefix+"params <\n"
        res+=self.params_.__str__(prefix + "  ", printElemNumber)
        res+=prefix+">\n"
      if self.has_app_id_: res+=prefix+("app_id: %s\n" % self.DebugFormatString(self.app_id_))
      return res
  
  
    def _BuildTagLookupTable(sparse, maxtag, default=None):
      return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
  
    kparams = 1
    kapp_id = 2
  
    _TEXT = _BuildTagLookupTable({
      0: "ErrorCode",
      1: "params",
      2: "app_id",
    }, 2)
  
    _TYPES = _BuildTagLookupTable({
      0: ProtocolBuffer.Encoder.NUMERIC,
      1: ProtocolBuffer.Encoder.STRING,
      2: ProtocolBuffer.Encoder.STRING,
    }, 2, ProtocolBuffer.Encoder.MAX_TYPE)
  
  
    _STYLE = """"""
    _STYLE_CONTENT_TYPE = """"""
    _PROTO_DESCRIPTOR_NAME = 'apphosting.ListDocumentsRequest'
  class ListDocumentsResponse(ProtocolBuffer.ProtocolMessage):
    has_status_ = 0
  
    def __init__(self, contents=None):
      self.status_ = RequestStatus()
      self.document_ = []
      if contents is not None: self.MergeFromString(contents)
  
    def status(self): return self.status_
  
    def mutable_status(self): self.has_status_ = 1; return self.status_
  
    def clear_status(self):self.has_status_ = 0; self.status_.Clear()
  
    def has_status(self): return self.has_status_
  
    def document_size(self): return len(self.document_)
    def document_list(self): return self.document_
  
    def document(self, i):
      return self.document_[i]
  
    def mutable_document(self, i):
      return self.document_[i]
  
    def add_document(self):
      x = Document()
      self.document_.append(x)
      return x
  
    def clear_document(self):
      self.document_ = []
  
    def MergeFrom(self, x):
      assert x is not self
      if (x.has_status()): self.mutable_status().MergeFrom(x.status())
      for i in xrange(x.document_size()): self.add_document().CopyFrom(x.document(i))
  
    def Equals(self, x):
      if x is self: return 1
      if self.has_status_ != x.has_status_: return 0
      if self.has_status_ and self.status_ != x.status_: return 0
      if len(self.document_) != len(x.document_): return 0
      for e1, e2 in zip(self.document_, x.document_):
        if e1 != e2: return 0
      return 1
  
    def IsInitialized(self, debug_strs=None):
      initialized = 1
      if (not self.has_status_):
        initialized = 0
        if debug_strs is not None:
          debug_strs.append('Required field: status not set.')
      elif not self.status_.IsInitialized(debug_strs): initialized = 0
      for p in self.document_:
        if not p.IsInitialized(debug_strs): initialized=0
      return initialized
  
    def ByteSize(self):
      n = 0
      n += self.lengthString(self.status_.ByteSize())
      n += 1 * len(self.document_)
      for i in xrange(len(self.document_)): n += self.lengthString(self.document_[i].ByteSize())
      return n + 1
  
    def ByteSizePartial(self):
      n = 0
      if (self.has_status_):
        n += 1
        n += self.lengthString(self.status_.ByteSizePartial())
      n += 1 * len(self.document_)
      for i in xrange(len(self.document_)): n += self.lengthString(self.document_[i].ByteSizePartial())
      return n
  
    def Clear(self):
      self.clear_status()
      self.clear_document()
  
    def OutputUnchecked(self, out):
      out.putVarInt32(10)
      out.putVarInt32(self.status_.ByteSize())
      self.status_.OutputUnchecked(out)
      for i in xrange(len(self.document_)):
        out.putVarInt32(18)
        out.putVarInt32(self.document_[i].ByteSize())
        self.document_[i].OutputUnchecked(out)
  
    def OutputPartial(self, out):
      if (self.has_status_):
        out.putVarInt32(10)
        out.putVarInt32(self.status_.ByteSizePartial())
        self.status_.OutputPartial(out)
      for i in xrange(len(self.document_)):
        out.putVarInt32(18)
        out.putVarInt32(self.document_[i].ByteSizePartial())
        self.document_[i].OutputPartial(out)
  
    def TryMerge(self, d):
      while d.avail() > 0:
        tt = d.getVarInt32()
        if tt == 10:
          length = d.getVarInt32()
          tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
          d.skip(length)
          self.mutable_status().TryMerge(tmp)
          continue
        if tt == 18:
          length = d.getVarInt32()
          tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
          d.skip(length)
          self.add_document().TryMerge(tmp)
          continue
  
  
        if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
        d.skipData(tt)
  
  
    def __str__(self, prefix="", printElemNumber=0):
      res=""
      if self.has_status_:
        res+=prefix+"status <\n"
        res+=self.status_.__str__(prefix + "  ", printElemNumber)
        res+=prefix+">\n"
      cnt=0
      for e in self.document_:
        elm=""
        if printElemNumber: elm="(%d)" % cnt
        res+=prefix+("document%s <\n" % elm)
        res+=e.__str__(prefix + "  ", printElemNumber)
        res+=prefix+">\n"
        cnt+=1
      return res
  
  
    def _BuildTagLookupTable(sparse, maxtag, default=None):
      return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
  
    kstatus = 1
    kdocument = 2
  
    _TEXT = _BuildTagLookupTable({
      0: "ErrorCode",
      1: "status",
      2: "document",
    }, 2)
  
    _TYPES = _BuildTagLookupTable({
      0: ProtocolBuffer.Encoder.NUMERIC,
      1: ProtocolBuffer.Encoder.STRING,
      2: ProtocolBuffer.Encoder.STRING,
    }, 2, ProtocolBuffer.Encoder.MAX_TYPE)
  
  
    _STYLE = """"""
    _STYLE_CONTENT_TYPE = """"""
    _PROTO_DESCRIPTOR_NAME = 'apphosting.ListDocumentsResponse'
  class ListIndexesParams(ProtocolBuffer.ProtocolMessage):
    has_fetch_schema_ = 0
    fetch_schema_ = 0
    has_limit_ = 0
    limit_ = 20
    has_namespace_ = 0
    namespace_ = ""
    has_start_index_name_ = 0
    start_index_name_ = ""
    has_include_start_index_ = 0
    include_start_index_ = 1
    has_index_name_prefix_ = 0
    index_name_prefix_ = ""
    has_offset_ = 0
    offset_ = 0
    has_source_ = 0
    source_ = 0
  
    def __init__(self, contents=None):
      if contents is not None: self.MergeFromString(contents)
  
    def fetch_schema(self): return self.fetch_schema_
  
    def set_fetch_schema(self, x):
      self.has_fetch_schema_ = 1
      self.fetch_schema_ = x
  
    def clear_fetch_schema(self):
      if self.has_fetch_schema_:
        self.has_fetch_schema_ = 0
        self.fetch_schema_ = 0
  
    def has_fetch_schema(self): return self.has_fetch_schema_
  
    def limit(self): return self.limit_
  
    def set_limit(self, x):
      self.has_limit_ = 1
      self.limit_ = x
  
    def clear_limit(self):
      if self.has_limit_:
        self.has_limit_ = 0
        self.limit_ = 20
  
    def has_limit(self): return self.has_limit_
  
    def namespace(self): return self.namespace_
  
    def set_namespace(self, x):
      self.has_namespace_ = 1
      self.namespace_ = x
  
    def clear_namespace(self):
      if self.has_namespace_:
        self.has_namespace_ = 0
        self.namespace_ = ""
  
    def has_namespace(self): return self.has_namespace_
  
    def start_index_name(self): return self.start_index_name_
  
    def set_start_index_name(self, x):
      self.has_start_index_name_ = 1
      self.start_index_name_ = x
  
    def clear_start_index_name(self):
      if self.has_start_index_name_:
        self.has_start_index_name_ = 0
        self.start_index_name_ = ""
  
    def has_start_index_name(self): return self.has_start_index_name_
  
    def include_start_index(self): return self.include_start_index_
  
    def set_include_start_index(self, x):
      self.has_include_start_index_ = 1
      self.include_start_index_ = x
  
    def clear_include_start_index(self):
      if self.has_include_start_index_:
        self.has_include_start_index_ = 0
        self.include_start_index_ = 1
  
    def has_include_start_index(self): return self.has_include_start_index_
  
    def index_name_prefix(self): return self.index_name_prefix_
  
    def set_index_name_prefix(self, x):
      self.has_index_name_prefix_ = 1
      self.index_name_prefix_ = x
  
    def clear_index_name_prefix(self):
      if self.has_index_name_prefix_:
        self.has_index_name_prefix_ = 0
        self.index_name_prefix_ = ""
  
    def has_index_name_prefix(self): return self.has_index_name_prefix_
  
    def offset(self): return self.offset_
  
    def set_offset(self, x):
      self.has_offset_ = 1
      self.offset_ = x
  
    def clear_offset(self):
      if self.has_offset_:
        self.has_offset_ = 0
        self.offset_ = 0
  
    def has_offset(self): return self.has_offset_
  
    def source(self): return self.source_
  
    def set_source(self, x):
      self.has_source_ = 1
      self.source_ = x
  
    def clear_source(self):
      if self.has_source_:
        self.has_source_ = 0
        self.source_ = 0
  
    def has_source(self): return self.has_source_
  
  
    def MergeFrom(self, x):
      assert x is not self
      if (x.has_fetch_schema()): self.set_fetch_schema(x.fetch_schema())
      if (x.has_limit()): self.set_limit(x.limit())
      if (x.has_namespace()): self.set_namespace(x.namespace())
      if (x.has_start_index_name()): self.set_start_index_name(x.start_index_name())
      if (x.has_include_start_index()): self.set_include_start_index(x.include_start_index())
      if (x.has_index_name_prefix()): self.set_index_name_prefix(x.index_name_prefix())
      if (x.has_offset()): self.set_offset(x.offset())
      if (x.has_source()): self.set_source(x.source())
  
    def Equals(self, x):
      if x is self: return 1
      if self.has_fetch_schema_ != x.has_fetch_schema_: return 0
      if self.has_fetch_schema_ and self.fetch_schema_ != x.fetch_schema_: return 0
      if self.has_limit_ != x.has_limit_: return 0
      if self.has_limit_ and self.limit_ != x.limit_: return 0
      if self.has_namespace_ != x.has_namespace_: return 0
      if self.has_namespace_ and self.namespace_ != x.namespace_: return 0
      if self.has_start_index_name_ != x.has_start_index_name_: return 0
      if self.has_start_index_name_ and self.start_index_name_ != x.start_index_name_: return 0
      if self.has_include_start_index_ != x.has_include_start_index_: return 0
      if self.has_include_start_index_ and self.include_start_index_ != x.include_start_index_: return 0
      if self.has_index_name_prefix_ != x.has_index_name_prefix_: return 0
      if self.has_index_name_prefix_ and self.index_name_prefix_ != x.index_name_prefix_: return 0
      if self.has_offset_ != x.has_offset_: return 0
      if self.has_offset_ and self.offset_ != x.offset_: return 0
      if self.has_source_ != x.has_source_: return 0
      if self.has_source_ and self.source_ != x.source_: return 0
      return 1
  
    def IsInitialized(self, debug_strs=None):
      initialized = 1
      return initialized
  
    def ByteSize(self):
      n = 0
      if (self.has_fetch_schema_): n += 2
      if (self.has_limit_): n += 1 + self.lengthVarInt64(self.limit_)
      if (self.has_namespace_): n += 1 + self.lengthString(len(self.namespace_))
      if (self.has_start_index_name_): n += 1 + self.lengthString(len(self.start_index_name_))
      if (self.has_include_start_index_): n += 2
      if (self.has_index_name_prefix_): n += 1 + self.lengthString(len(self.index_name_prefix_))
      if (self.has_offset_): n += 1 + self.lengthVarInt64(self.offset_)
      if (self.has_source_): n += 1 + self.lengthVarInt64(self.source_)
      return n
  
    def ByteSizePartial(self):
      n = 0
      if (self.has_fetch_schema_): n += 2
      if (self.has_limit_): n += 1 + self.lengthVarInt64(self.limit_)
      if (self.has_namespace_): n += 1 + self.lengthString(len(self.namespace_))
      if (self.has_start_index_name_): n += 1 + self.lengthString(len(self.start_index_name_))
      if (self.has_include_start_index_): n += 2
      if (self.has_index_name_prefix_): n += 1 + self.lengthString(len(self.index_name_prefix_))
      if (self.has_offset_): n += 1 + self.lengthVarInt64(self.offset_)
      if (self.has_source_): n += 1 + self.lengthVarInt64(self.source_)
      return n
  
    def Clear(self):
      self.clear_fetch_schema()
      self.clear_limit()
      self.clear_namespace()
      self.clear_start_index_name()
      self.clear_include_start_index()
      self.clear_index_name_prefix()
      self.clear_offset()
      self.clear_source()
  
    def OutputUnchecked(self, out):
      if (self.has_fetch_schema_):
        out.putVarInt32(8)
        out.putBoolean(self.fetch_schema_)
      if (self.has_limit_):
        out.putVarInt32(16)
        out.putVarInt32(self.limit_)
      if (self.has_namespace_):
        out.putVarInt32(26)
        out.putPrefixedString(self.namespace_)
      if (self.has_start_index_name_):
        out.putVarInt32(34)
        out.putPrefixedString(self.start_index_name_)
      if (self.has_include_start_index_):
        out.putVarInt32(40)
        out.putBoolean(self.include_start_index_)
      if (self.has_index_name_prefix_):
        out.putVarInt32(50)
        out.putPrefixedString(self.index_name_prefix_)
      if (self.has_offset_):
        out.putVarInt32(56)
        out.putVarInt32(self.offset_)
      if (self.has_source_):
        out.putVarInt32(64)
        out.putVarInt32(self.source_)
  
    def OutputPartial(self, out):
      if (self.has_fetch_schema_):
        out.putVarInt32(8)
        out.putBoolean(self.fetch_schema_)
      if (self.has_limit_):
        out.putVarInt32(16)
        out.putVarInt32(self.limit_)
      if (self.has_namespace_):
        out.putVarInt32(26)
        out.putPrefixedString(self.namespace_)
      if (self.has_start_index_name_):
        out.putVarInt32(34)
        out.putPrefixedString(self.start_index_name_)
      if (self.has_include_start_index_):
        out.putVarInt32(40)
        out.putBoolean(self.include_start_index_)
      if (self.has_index_name_prefix_):
        out.putVarInt32(50)
        out.putPrefixedString(self.index_name_prefix_)
      if (self.has_offset_):
        out.putVarInt32(56)
        out.putVarInt32(self.offset_)
      if (self.has_source_):
        out.putVarInt32(64)
        out.putVarInt32(self.source_)
  
    def TryMerge(self, d):
      while d.avail() > 0:
        tt = d.getVarInt32()
        if tt == 8:
          self.set_fetch_schema(d.getBoolean())
          continue
        if tt == 16:
          self.set_limit(d.getVarInt32())
          continue
        if tt == 26:
          self.set_namespace(d.getPrefixedString())
          continue
        if tt == 34:
          self.set_start_index_name(d.getPrefixedString())
          continue
        if tt == 40:
          self.set_include_start_index(d.getBoolean())
          continue
        if tt == 50:
          self.set_index_name_prefix(d.getPrefixedString())
          continue
        if tt == 56:
          self.set_offset(d.getVarInt32())
          continue
        if tt == 64:
          self.set_source(d.getVarInt32())
          continue
  
  
        if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
        d.skipData(tt)
  
  
    def __str__(self, prefix="", printElemNumber=0):
      res=""
      if self.has_fetch_schema_: res+=prefix+("fetch_schema: %s\n" % self.DebugFormatBool(self.fetch_schema_))
      if self.has_limit_: res+=prefix+("limit: %s\n" % self.DebugFormatInt32(self.limit_))
      if self.has_namespace_: res+=prefix+("namespace: %s\n" % self.DebugFormatString(self.namespace_))
      if self.has_start_index_name_: res+=prefix+("start_index_name: %s\n" % self.DebugFormatString(self.start_index_name_))
      if self.has_include_start_index_: res+=prefix+("include_start_index: %s\n" % self.DebugFormatBool(self.include_start_index_))
      if self.has_index_name_prefix_: res+=prefix+("index_name_prefix: %s\n" % self.DebugFormatString(self.index_name_prefix_))
      if self.has_offset_: res+=prefix+("offset: %s\n" % self.DebugFormatInt32(self.offset_))
      if self.has_source_: res+=prefix+("source: %s\n" % self.DebugFormatInt32(self.source_))
      return res
  
  
    def _BuildTagLookupTable(sparse, maxtag, default=None):
      return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
  
    kfetch_schema = 1
    klimit = 2
    knamespace = 3
    kstart_index_name = 4
    kinclude_start_index = 5
    kindex_name_prefix = 6
    koffset = 7
    ksource = 8
  
    _TEXT = _BuildTagLookupTable({
      0: "ErrorCode",
      1: "fetch_schema",
      2: "limit",
      3: "namespace",
      4: "start_index_name",
      5: "include_start_index",
      6: "index_name_prefix",
      7: "offset",
      8: "source",
    }, 8)
  
    _TYPES = _BuildTagLookupTable({
      0: ProtocolBuffer.Encoder.NUMERIC,
      1: ProtocolBuffer.Encoder.NUMERIC,
      2: ProtocolBuffer.Encoder.NUMERIC,
      3: ProtocolBuffer.Encoder.STRING,
      4: ProtocolBuffer.Encoder.STRING,
      5: ProtocolBuffer.Encoder.NUMERIC,
      6: ProtocolBuffer.Encoder.STRING,
      7: ProtocolBuffer.Encoder.NUMERIC,
      8: ProtocolBuffer.Encoder.NUMERIC,
    }, 8, ProtocolBuffer.Encoder.MAX_TYPE)
  
  
    _STYLE = """"""
    _STYLE_CONTENT_TYPE = """"""
    _PROTO_DESCRIPTOR_NAME = 'apphosting.ListIndexesParams'
  class ListIndexesRequest(ProtocolBuffer.ProtocolMessage):
    has_params_ = 0
    has_app_id_ = 0
    app_id_ = ""
  
    def __init__(self, contents=None):
      self.params_ = ListIndexesParams()
      if contents is not None: self.MergeFromString(contents)
  
    def params(self): return self.params_
  
    def mutable_params(self): self.has_params_ = 1; return self.params_
  
    def clear_params(self):self.has_params_ = 0; self.params_.Clear()
  
    def has_params(self): return self.has_params_
  
    def app_id(self): return self.app_id_
  
    def set_app_id(self, x):
      self.has_app_id_ = 1
      self.app_id_ = x
  
    def clear_app_id(self):
      if self.has_app_id_:
        self.has_app_id_ = 0
        self.app_id_ = ""
  
    def has_app_id(self): return self.has_app_id_
  
  
    def MergeFrom(self, x):
      assert x is not self
      if (x.has_params()): self.mutable_params().MergeFrom(x.params())
      if (x.has_app_id()): self.set_app_id(x.app_id())
  
    def Equals(self, x):
      if x is self: return 1
      if self.has_params_ != x.has_params_: return 0
      if self.has_params_ and self.params_ != x.params_: return 0
      if self.has_app_id_ != x.has_app_id_: return 0
      if self.has_app_id_ and self.app_id_ != x.app_id_: return 0
      return 1
  
    def IsInitialized(self, debug_strs=None):
      initialized = 1
      if (not self.has_params_):
        initialized = 0
        if debug_strs is not None:
          debug_strs.append('Required field: params not set.')
      elif not self.params_.IsInitialized(debug_strs): initialized = 0
      return initialized
  
    def ByteSize(self):
      n = 0
      n += self.lengthString(self.params_.ByteSize())
      if (self.has_app_id_): n += 1 + self.lengthString(len(self.app_id_))
      return n + 1
  
    def ByteSizePartial(self):
      n = 0
      if (self.has_params_):
        n += 1
        n += self.lengthString(self.params_.ByteSizePartial())
      if (self.has_app_id_): n += 1 + self.lengthString(len(self.app_id_))
      return n
  
    def Clear(self):
      self.clear_params()
      self.clear_app_id()
  
    def OutputUnchecked(self, out):
      out.putVarInt32(10)
      out.putVarInt32(self.params_.ByteSize())
      self.params_.OutputUnchecked(out)
      if (self.has_app_id_):
        out.putVarInt32(26)
        out.putPrefixedString(self.app_id_)
  
    def OutputPartial(self, out):
      if (self.has_params_):
        out.putVarInt32(10)
        out.putVarInt32(self.params_.ByteSizePartial())
        self.params_.OutputPartial(out)
      if (self.has_app_id_):
        out.putVarInt32(26)
        out.putPrefixedString(self.app_id_)
  
    def TryMerge(self, d):
      while d.avail() > 0:
        tt = d.getVarInt32()
        if tt == 10:
          length = d.getVarInt32()
          tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
          d.skip(length)
          self.mutable_params().TryMerge(tmp)
          continue
        if tt == 26:
          self.set_app_id(d.getPrefixedString())
          continue
  
  
        if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
        d.skipData(tt)
  
  
    def __str__(self, prefix="", printElemNumber=0):
      res=""
      if self.has_params_:
        res+=prefix+"params <\n"
        res+=self.params_.__str__(prefix + "  ", printElemNumber)
        res+=prefix+">\n"
      if self.has_app_id_: res+=prefix+("app_id: %s\n" % self.DebugFormatString(self.app_id_))
      return res
  
  
    def _BuildTagLookupTable(sparse, maxtag, default=None):
      return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
  
    kparams = 1
    kapp_id = 3
  
    _TEXT = _BuildTagLookupTable({
      0: "ErrorCode",
      1: "params",
      3: "app_id",
    }, 3)
  
    _TYPES = _BuildTagLookupTable({
      0: ProtocolBuffer.Encoder.NUMERIC,
      1: ProtocolBuffer.Encoder.STRING,
      3: ProtocolBuffer.Encoder.STRING,
    }, 3, ProtocolBuffer.Encoder.MAX_TYPE)
  
  
    _STYLE = """"""
    _STYLE_CONTENT_TYPE = """"""
    _PROTO_DESCRIPTOR_NAME = 'apphosting.ListIndexesRequest'
  class ListIndexesResponse(ProtocolBuffer.ProtocolMessage):
    has_status_ = 0
  
    def __init__(self, contents=None):
      self.status_ = RequestStatus()
      self.index_metadata_ = []
      if contents is not None: self.MergeFromString(contents)
  
    def status(self): return self.status_
  
    def mutable_status(self): self.has_status_ = 1; return self.status_
  
    def clear_status(self):self.has_status_ = 0; self.status_.Clear()
  
    def has_status(self): return self.has_status_
  
    def index_metadata_size(self): return len(self.index_metadata_)
    def index_metadata_list(self): return self.index_metadata_
  
    def index_metadata(self, i):
      return self.index_metadata_[i]
  
    def mutable_index_metadata(self, i):
      return self.index_metadata_[i]
  
    def add_index_metadata(self):
      x = IndexMetadata()
      self.index_metadata_.append(x)
      return x
  
    def clear_index_metadata(self):
      self.index_metadata_ = []
  
    def MergeFrom(self, x):
      assert x is not self
      if (x.has_status()): self.mutable_status().MergeFrom(x.status())
      for i in xrange(x.index_metadata_size()): self.add_index_metadata().CopyFrom(x.index_metadata(i))
  
    def Equals(self, x):
      if x is self: return 1
      if self.has_status_ != x.has_status_: return 0
      if self.has_status_ and self.status_ != x.status_: return 0
      if len(self.index_metadata_) != len(x.index_metadata_): return 0
      for e1, e2 in zip(self.index_metadata_, x.index_metadata_):
        if e1 != e2: return 0
      return 1
  
    def IsInitialized(self, debug_strs=None):
      initialized = 1
      if (not self.has_status_):
        initialized = 0
        if debug_strs is not None:
          debug_strs.append('Required field: status not set.')
      elif not self.status_.IsInitialized(debug_strs): initialized = 0
      for p in self.index_metadata_:
        if not p.IsInitialized(debug_strs): initialized=0
      return initialized
  
    def ByteSize(self):
      n = 0
      n += self.lengthString(self.status_.ByteSize())
      n += 1 * len(self.index_metadata_)
      for i in xrange(len(self.index_metadata_)): n += self.lengthString(self.index_metadata_[i].ByteSize())
      return n + 1
  
    def ByteSizePartial(self):
      n = 0
      if (self.has_status_):
        n += 1
        n += self.lengthString(self.status_.ByteSizePartial())
      n += 1 * len(self.index_metadata_)
      for i in xrange(len(self.index_metadata_)): n += self.lengthString(self.index_metadata_[i].ByteSizePartial())
      return n
  
    def Clear(self):
      self.clear_status()
      self.clear_index_metadata()
  
    def OutputUnchecked(self, out):
      out.putVarInt32(10)
      out.putVarInt32(self.status_.ByteSize())
      self.status_.OutputUnchecked(out)
      for i in xrange(len(self.index_metadata_)):
        out.putVarInt32(18)
        out.putVarInt32(self.index_metadata_[i].ByteSize())
        self.index_metadata_[i].OutputUnchecked(out)
  
    def OutputPartial(self, out):
      if (self.has_status_):
        out.putVarInt32(10)
        out.putVarInt32(self.status_.ByteSizePartial())
        self.status_.OutputPartial(out)
      for i in xrange(len(self.index_metadata_)):
        out.putVarInt32(18)
        out.putVarInt32(self.index_metadata_[i].ByteSizePartial())
        self.index_metadata_[i].OutputPartial(out)
  
    def TryMerge(self, d):
      while d.avail() > 0:
        tt = d.getVarInt32()
        if tt == 10:
          length = d.getVarInt32()
          tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
          d.skip(length)
          self.mutable_status().TryMerge(tmp)
          continue
        if tt == 18:
          length = d.getVarInt32()
          tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
          d.skip(length)
          self.add_index_metadata().TryMerge(tmp)
          continue
  
  
        if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
        d.skipData(tt)
  
  
    def __str__(self, prefix="", printElemNumber=0):
      res=""
      if self.has_status_:
        res+=prefix+"status <\n"
        res+=self.status_.__str__(prefix + "  ", printElemNumber)
        res+=prefix+">\n"
      cnt=0
      for e in self.index_metadata_:
        elm=""
        if printElemNumber: elm="(%d)" % cnt
        res+=prefix+("index_metadata%s <\n" % elm)
        res+=e.__str__(prefix + "  ", printElemNumber)
        res+=prefix+">\n"
        cnt+=1
      return res
  
  
    def _BuildTagLookupTable(sparse, maxtag, default=None):
      return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
  
    kstatus = 1
    kindex_metadata = 2
  
    _TEXT = _BuildTagLookupTable({
      0: "ErrorCode",
      1: "status",
      2: "index_metadata",
    }, 2)
  
    _TYPES = _BuildTagLookupTable({
      0: ProtocolBuffer.Encoder.NUMERIC,
      1: ProtocolBuffer.Encoder.STRING,
      2: ProtocolBuffer.Encoder.STRING,
    }, 2, ProtocolBuffer.Encoder.MAX_TYPE)
  
  
    _STYLE = """"""
    _STYLE_CONTENT_TYPE = """"""
    _PROTO_DESCRIPTOR_NAME = 'apphosting.ListIndexesResponse'
  class DeleteSchemaParams(ProtocolBuffer.ProtocolMessage):
    has_source_ = 0
    source_ = 0
  
    def __init__(self, contents=None):
      self.index_spec_ = []
      if contents is not None: self.MergeFromString(contents)
  
    def source(self): return self.source_
  
    def set_source(self, x):
      self.has_source_ = 1
      self.source_ = x
  
    def clear_source(self):
      if self.has_source_:
        self.has_source_ = 0
        self.source_ = 0
  
    def has_source(self): return self.has_source_
  
    def index_spec_size(self): return len(self.index_spec_)
    def index_spec_list(self): return self.index_spec_
  
    def index_spec(self, i):
      return self.index_spec_[i]
  
    def mutable_index_spec(self, i):
      return self.index_spec_[i]
  
    def add_index_spec(self):
      x = IndexSpec()
      self.index_spec_.append(x)
      return x
  
    def clear_index_spec(self):
      self.index_spec_ = []
  
    def MergeFrom(self, x):
      assert x is not self
      if (x.has_source()): self.set_source(x.source())
      for i in xrange(x.index_spec_size()): self.add_index_spec().CopyFrom(x.index_spec(i))
  
    def Equals(self, x):
      if x is self: return 1
      if self.has_source_ != x.has_source_: return 0
      if self.has_source_ and self.source_ != x.source_: return 0
      if len(self.index_spec_) != len(x.index_spec_): return 0
      for e1, e2 in zip(self.index_spec_, x.index_spec_):
        if e1 != e2: return 0
      return 1
  
    def IsInitialized(self, debug_strs=None):
      initialized = 1
      for p in self.index_spec_:
        if not p.IsInitialized(debug_strs): initialized=0
      return initialized
  
    def ByteSize(self):
      n = 0
      if (self.has_source_): n += 1 + self.lengthVarInt64(self.source_)
      n += 1 * len(self.index_spec_)
      for i in xrange(len(self.index_spec_)): n += self.lengthString(self.index_spec_[i].ByteSize())
      return n
  
    def ByteSizePartial(self):
      n = 0
      if (self.has_source_): n += 1 + self.lengthVarInt64(self.source_)
      n += 1 * len(self.index_spec_)
      for i in xrange(len(self.index_spec_)): n += self.lengthString(self.index_spec_[i].ByteSizePartial())
      return n
  
    def Clear(self):
      self.clear_source()
      self.clear_index_spec()
  
    def OutputUnchecked(self, out):
      if (self.has_source_):
        out.putVarInt32(8)
        out.putVarInt32(self.source_)
      for i in xrange(len(self.index_spec_)):
        out.putVarInt32(18)
        out.putVarInt32(self.index_spec_[i].ByteSize())
        self.index_spec_[i].OutputUnchecked(out)
  
    def OutputPartial(self, out):
      if (self.has_source_):
        out.putVarInt32(8)
        out.putVarInt32(self.source_)
      for i in xrange(len(self.index_spec_)):
        out.putVarInt32(18)
        out.putVarInt32(self.index_spec_[i].ByteSizePartial())
        self.index_spec_[i].OutputPartial(out)
  
    def TryMerge(self, d):
      while d.avail() > 0:
        tt = d.getVarInt32()
        if tt == 8:
          self.set_source(d.getVarInt32())
          continue
        if tt == 18:
          length = d.getVarInt32()
          tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
          d.skip(length)
          self.add_index_spec().TryMerge(tmp)
          continue
  
  
        if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
        d.skipData(tt)
  
  
    def __str__(self, prefix="", printElemNumber=0):
      res=""
      if self.has_source_: res+=prefix+("source: %s\n" % self.DebugFormatInt32(self.source_))
      cnt=0
      for e in self.index_spec_:
        elm=""
        if printElemNumber: elm="(%d)" % cnt
        res+=prefix+("index_spec%s <\n" % elm)
        res+=e.__str__(prefix + "  ", printElemNumber)
        res+=prefix+">\n"
        cnt+=1
      return res
  
  
    def _BuildTagLookupTable(sparse, maxtag, default=None):
      return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
  
    ksource = 1
    kindex_spec = 2
  
    _TEXT = _BuildTagLookupTable({
      0: "ErrorCode",
      1: "source",
      2: "index_spec",
    }, 2)
  
    _TYPES = _BuildTagLookupTable({
      0: ProtocolBuffer.Encoder.NUMERIC,
      1: ProtocolBuffer.Encoder.NUMERIC,
      2: ProtocolBuffer.Encoder.STRING,
    }, 2, ProtocolBuffer.Encoder.MAX_TYPE)
  
  
    _STYLE = """"""
    _STYLE_CONTENT_TYPE = """"""
    _PROTO_DESCRIPTOR_NAME = 'apphosting.DeleteSchemaParams'
  class DeleteSchemaRequest(ProtocolBuffer.ProtocolMessage):
    has_params_ = 0
    has_app_id_ = 0
    app_id_ = ""
  
    def __init__(self, contents=None):
      self.params_ = DeleteSchemaParams()
      if contents is not None: self.MergeFromString(contents)
  
    def params(self): return self.params_
  
    def mutable_params(self): self.has_params_ = 1; return self.params_
  
    def clear_params(self):self.has_params_ = 0; self.params_.Clear()
  
    def has_params(self): return self.has_params_
  
    def app_id(self): return self.app_id_
  
    def set_app_id(self, x):
      self.has_app_id_ = 1
      self.app_id_ = x
  
    def clear_app_id(self):
      if self.has_app_id_:
        self.has_app_id_ = 0
        self.app_id_ = ""
  
    def has_app_id(self): return self.has_app_id_
  
  
    def MergeFrom(self, x):
      assert x is not self
      if (x.has_params()): self.mutable_params().MergeFrom(x.params())
      if (x.has_app_id()): self.set_app_id(x.app_id())
  
    def Equals(self, x):
      if x is self: return 1
      if self.has_params_ != x.has_params_: return 0
      if self.has_params_ and self.params_ != x.params_: return 0
      if self.has_app_id_ != x.has_app_id_: return 0
      if self.has_app_id_ and self.app_id_ != x.app_id_: return 0
      return 1
  
    def IsInitialized(self, debug_strs=None):
      initialized = 1
      if (not self.has_params_):
        initialized = 0
        if debug_strs is not None:
          debug_strs.append('Required field: params not set.')
      elif not self.params_.IsInitialized(debug_strs): initialized = 0
      return initialized
  
    def ByteSize(self):
      n = 0
      n += self.lengthString(self.params_.ByteSize())
      if (self.has_app_id_): n += 1 + self.lengthString(len(self.app_id_))
      return n + 1
  
    def ByteSizePartial(self):
      n = 0
      if (self.has_params_):
        n += 1
        n += self.lengthString(self.params_.ByteSizePartial())
      if (self.has_app_id_): n += 1 + self.lengthString(len(self.app_id_))
      return n
  
    def Clear(self):
      self.clear_params()
      self.clear_app_id()
  
    def OutputUnchecked(self, out):
      out.putVarInt32(10)
      out.putVarInt32(self.params_.ByteSize())
      self.params_.OutputUnchecked(out)
      if (self.has_app_id_):
        out.putVarInt32(26)
        out.putPrefixedString(self.app_id_)
  
    def OutputPartial(self, out):
      if (self.has_params_):
        out.putVarInt32(10)
        out.putVarInt32(self.params_.ByteSizePartial())
        self.params_.OutputPartial(out)
      if (self.has_app_id_):
        out.putVarInt32(26)
        out.putPrefixedString(self.app_id_)
  
    def TryMerge(self, d):
      while d.avail() > 0:
        tt = d.getVarInt32()
        if tt == 10:
          length = d.getVarInt32()
          tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
          d.skip(length)
          self.mutable_params().TryMerge(tmp)
          continue
        if tt == 26:
          self.set_app_id(d.getPrefixedString())
          continue
  
  
        if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
        d.skipData(tt)
  
  
    def __str__(self, prefix="", printElemNumber=0):
      res=""
      if self.has_params_:
        res+=prefix+"params <\n"
        res+=self.params_.__str__(prefix + "  ", printElemNumber)
        res+=prefix+">\n"
      if self.has_app_id_: res+=prefix+("app_id: %s\n" % self.DebugFormatString(self.app_id_))
      return res
  
  
    def _BuildTagLookupTable(sparse, maxtag, default=None):
      return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
  
    kparams = 1
    kapp_id = 3
  
    _TEXT = _BuildTagLookupTable({
      0: "ErrorCode",
      1: "params",
      3: "app_id",
    }, 3)
  
    _TYPES = _BuildTagLookupTable({
      0: ProtocolBuffer.Encoder.NUMERIC,
      1: ProtocolBuffer.Encoder.STRING,
      3: ProtocolBuffer.Encoder.STRING,
    }, 3, ProtocolBuffer.Encoder.MAX_TYPE)
  
  
    _STYLE = """"""
    _STYLE_CONTENT_TYPE = """"""
    _PROTO_DESCRIPTOR_NAME = 'apphosting.DeleteSchemaRequest'
  class DeleteSchemaResponse(ProtocolBuffer.ProtocolMessage):
  
    def __init__(self, contents=None):
      self.status_ = []
      if contents is not None: self.MergeFromString(contents)
  
    def status_size(self): return len(self.status_)
    def status_list(self): return self.status_
  
    def status(self, i):
      return self.status_[i]
  
    def mutable_status(self, i):
      return self.status_[i]
  
    def add_status(self):
      x = RequestStatus()
      self.status_.append(x)
      return x
  
    def clear_status(self):
      self.status_ = []
  
    def MergeFrom(self, x):
      assert x is not self
      for i in xrange(x.status_size()): self.add_status().CopyFrom(x.status(i))
  
    def Equals(self, x):
      if x is self: return 1
      if len(self.status_) != len(x.status_): return 0
      for e1, e2 in zip(self.status_, x.status_):
        if e1 != e2: return 0
      return 1
  
    def IsInitialized(self, debug_strs=None):
      initialized = 1
      for p in self.status_:
        if not p.IsInitialized(debug_strs): initialized=0
      return initialized
  
    def ByteSize(self):
      n = 0
      n += 1 * len(self.status_)
      for i in xrange(len(self.status_)): n += self.lengthString(self.status_[i].ByteSize())
      return n
  
    def ByteSizePartial(self):
      n = 0
      n += 1 * len(self.status_)
      for i in xrange(len(self.status_)): n += self.lengthString(self.status_[i].ByteSizePartial())
      return n
  
    def Clear(self):
      self.clear_status()
  
    def OutputUnchecked(self, out):
      for i in xrange(len(self.status_)):
        out.putVarInt32(10)
        out.putVarInt32(self.status_[i].ByteSize())
        self.status_[i].OutputUnchecked(out)
  
    def OutputPartial(self, out):
      for i in xrange(len(self.status_)):
        out.putVarInt32(10)
        out.putVarInt32(self.status_[i].ByteSizePartial())
        self.status_[i].OutputPartial(out)
  
    def TryMerge(self, d):
      while d.avail() > 0:
        tt = d.getVarInt32()
        if tt == 10:
          length = d.getVarInt32()
          tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
          d.skip(length)
          self.add_status().TryMerge(tmp)
          continue
  
  
        if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
        d.skipData(tt)
  
  
    def __str__(self, prefix="", printElemNumber=0):
      res=""
      cnt=0
      for e in self.status_:
        elm=""
        if printElemNumber: elm="(%d)" % cnt
        res+=prefix+("status%s <\n" % elm)
        res+=e.__str__(prefix + "  ", printElemNumber)
        res+=prefix+">\n"
        cnt+=1
      return res
  
  
    def _BuildTagLookupTable(sparse, maxtag, default=None):
      return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
  
    kstatus = 1
  
    _TEXT = _BuildTagLookupTable({
      0: "ErrorCode",
      1: "status",
    }, 1)
  
    _TYPES = _BuildTagLookupTable({
      0: ProtocolBuffer.Encoder.NUMERIC,
      1: ProtocolBuffer.Encoder.STRING,
    }, 1, ProtocolBuffer.Encoder.MAX_TYPE)
  
  
    _STYLE = """"""
    _STYLE_CONTENT_TYPE = """"""
    _PROTO_DESCRIPTOR_NAME = 'apphosting.DeleteSchemaResponse'
  class SortSpec(ProtocolBuffer.ProtocolMessage):
    has_sort_expression_ = 0
    sort_expression_ = ""
    has_sort_descending_ = 0
    sort_descending_ = 1
    has_default_value_text_ = 0
    default_value_text_ = ""
    has_default_value_numeric_ = 0
    default_value_numeric_ = 0.0
  
    def __init__(self, contents=None):
      if contents is not None: self.MergeFromString(contents)
  
    def sort_expression(self): return self.sort_expression_
  
    def set_sort_expression(self, x):
      self.has_sort_expression_ = 1
      self.sort_expression_ = x
  
    def clear_sort_expression(self):
      if self.has_sort_expression_:
        self.has_sort_expression_ = 0
        self.sort_expression_ = ""
  
    def has_sort_expression(self): return self.has_sort_expression_
  
    def sort_descending(self): return self.sort_descending_
  
    def set_sort_descending(self, x):
      self.has_sort_descending_ = 1
      self.sort_descending_ = x
  
    def clear_sort_descending(self):
      if self.has_sort_descending_:
        self.has_sort_descending_ = 0
        self.sort_descending_ = 1
  
    def has_sort_descending(self): return self.has_sort_descending_
  
    def default_value_text(self): return self.default_value_text_
  
    def set_default_value_text(self, x):
      self.has_default_value_text_ = 1
      self.default_value_text_ = x
  
    def clear_default_value_text(self):
      if self.has_default_value_text_:
        self.has_default_value_text_ = 0
        self.default_value_text_ = ""
  
    def has_default_value_text(self): return self.has_default_value_text_
  
    def default_value_numeric(self): return self.default_value_numeric_
  
    def set_default_value_numeric(self, x):
      self.has_default_value_numeric_ = 1
      self.default_value_numeric_ = x
  
    def clear_default_value_numeric(self):
      if self.has_default_value_numeric_:
        self.has_default_value_numeric_ = 0
        self.default_value_numeric_ = 0.0
  
    def has_default_value_numeric(self): return self.has_default_value_numeric_
  
  
    def MergeFrom(self, x):
      assert x is not self
      if (x.has_sort_expression()): self.set_sort_expression(x.sort_expression())
      if (x.has_sort_descending()): self.set_sort_descending(x.sort_descending())
      if (x.has_default_value_text()): self.set_default_value_text(x.default_value_text())
      if (x.has_default_value_numeric()): self.set_default_value_numeric(x.default_value_numeric())
  
    def Equals(self, x):
      if x is self: return 1
      if self.has_sort_expression_ != x.has_sort_expression_: return 0
      if self.has_sort_expression_ and self.sort_expression_ != x.sort_expression_: return 0
      if self.has_sort_descending_ != x.has_sort_descending_: return 0
      if self.has_sort_descending_ and self.sort_descending_ != x.sort_descending_: return 0
      if self.has_default_value_text_ != x.has_default_value_text_: return 0
      if self.has_default_value_text_ and self.default_value_text_ != x.default_value_text_: return 0
      if self.has_default_value_numeric_ != x.has_default_value_numeric_: return 0
      if self.has_default_value_numeric_ and self.default_value_numeric_ != x.default_value_numeric_: return 0
      return 1
  
    def IsInitialized(self, debug_strs=None):
      initialized = 1
      if (not self.has_sort_expression_):
        initialized = 0
        if debug_strs is not None:
          debug_strs.append('Required field: sort_expression not set.')
      return initialized
  
    def ByteSize(self):
      n = 0
      n += self.lengthString(len(self.sort_expression_))
      if (self.has_sort_descending_): n += 2
      if (self.has_default_value_text_): n += 1 + self.lengthString(len(self.default_value_text_))
      if (self.has_default_value_numeric_): n += 9
      return n + 1
  
    def ByteSizePartial(self):
      n = 0
      if (self.has_sort_expression_):
        n += 1
        n += self.lengthString(len(self.sort_expression_))
      if (self.has_sort_descending_): n += 2
      if (self.has_default_value_text_): n += 1 + self.lengthString(len(self.default_value_text_))
      if (self.has_default_value_numeric_): n += 9
      return n
  
    def Clear(self):
      self.clear_sort_expression()
      self.clear_sort_descending()
      self.clear_default_value_text()
      self.clear_default_value_numeric()
  
    def OutputUnchecked(self, out):
      out.putVarInt32(10)
      out.putPrefixedString(self.sort_expression_)
      if (self.has_sort_descending_):
        out.putVarInt32(16)
        out.putBoolean(self.sort_descending_)
      if (self.has_default_value_text_):
        out.putVarInt32(34)
        out.putPrefixedString(self.default_value_text_)
      if (self.has_default_value_numeric_):
        out.putVarInt32(41)
        out.putDouble(self.default_value_numeric_)
  
    def OutputPartial(self, out):
      if (self.has_sort_expression_):
        out.putVarInt32(10)
        out.putPrefixedString(self.sort_expression_)
      if (self.has_sort_descending_):
        out.putVarInt32(16)
        out.putBoolean(self.sort_descending_)
      if (self.has_default_value_text_):
        out.putVarInt32(34)
        out.putPrefixedString(self.default_value_text_)
      if (self.has_default_value_numeric_):
        out.putVarInt32(41)
        out.putDouble(self.default_value_numeric_)
  
    def TryMerge(self, d):
      while d.avail() > 0:
        tt = d.getVarInt32()
        if tt == 10:
          self.set_sort_expression(d.getPrefixedString())
          continue
        if tt == 16:
          self.set_sort_descending(d.getBoolean())
          continue
        if tt == 34:
          self.set_default_value_text(d.getPrefixedString())
          continue
        if tt == 41:
          self.set_default_value_numeric(d.getDouble())
          continue
  
  
        if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
        d.skipData(tt)
  
  
    def __str__(self, prefix="", printElemNumber=0):
      res=""
      if self.has_sort_expression_: res+=prefix+("sort_expression: %s\n" % self.DebugFormatString(self.sort_expression_))
      if self.has_sort_descending_: res+=prefix+("sort_descending: %s\n" % self.DebugFormatBool(self.sort_descending_))
      if self.has_default_value_text_: res+=prefix+("default_value_text: %s\n" % self.DebugFormatString(self.default_value_text_))
      if self.has_default_value_numeric_: res+=prefix+("default_value_numeric: %s\n" % self.DebugFormat(self.default_value_numeric_))
      return res
  
  
    def _BuildTagLookupTable(sparse, maxtag, default=None):
      return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
  
    ksort_expression = 1
    ksort_descending = 2
    kdefault_value_text = 4
    kdefault_value_numeric = 5
  
    _TEXT = _BuildTagLookupTable({
      0: "ErrorCode",
      1: "sort_expression",
      2: "sort_descending",
      4: "default_value_text",
      5: "default_value_numeric",
    }, 5)
  
    _TYPES = _BuildTagLookupTable({
      0: ProtocolBuffer.Encoder.NUMERIC,
      1: ProtocolBuffer.Encoder.STRING,
      2: ProtocolBuffer.Encoder.NUMERIC,
      4: ProtocolBuffer.Encoder.STRING,
      5: ProtocolBuffer.Encoder.DOUBLE,
    }, 5, ProtocolBuffer.Encoder.MAX_TYPE)
  
  
    _STYLE = """"""
    _STYLE_CONTENT_TYPE = """"""
    _PROTO_DESCRIPTOR_NAME = 'apphosting.SortSpec'
  class ScorerSpec(ProtocolBuffer.ProtocolMessage):
  
  
    RESCORING_MATCH_SCORER =    0
    MATCH_SCORER =    2
  
    _Scorer_NAMES = {
      0: "RESCORING_MATCH_SCORER",
      2: "MATCH_SCORER",
    }
  
    def Scorer_Name(cls, x): return cls._Scorer_NAMES.get(x, "")
    Scorer_Name = classmethod(Scorer_Name)
  
    has_scorer_ = 0
    scorer_ = 2
    has_limit_ = 0
    limit_ = 1000
    has_match_scorer_parameters_ = 0
    match_scorer_parameters_ = ""
  
    def __init__(self, contents=None):
      if contents is not None: self.MergeFromString(contents)
  
    def scorer(self): return self.scorer_
  
    def set_scorer(self, x):
      self.has_scorer_ = 1
      self.scorer_ = x
  
    def clear_scorer(self):
      if self.has_scorer_:
        self.has_scorer_ = 0
        self.scorer_ = 2
  
    def has_scorer(self): return self.has_scorer_
  
    def limit(self): return self.limit_
  
    def set_limit(self, x):
      self.has_limit_ = 1
      self.limit_ = x
  
    def clear_limit(self):
      if self.has_limit_:
        self.has_limit_ = 0
        self.limit_ = 1000
  
    def has_limit(self): return self.has_limit_
  
    def match_scorer_parameters(self): return self.match_scorer_parameters_
  
    def set_match_scorer_parameters(self, x):
      self.has_match_scorer_parameters_ = 1
      self.match_scorer_parameters_ = x
  
    def clear_match_scorer_parameters(self):
      if self.has_match_scorer_parameters_:
        self.has_match_scorer_parameters_ = 0
        self.match_scorer_parameters_ = ""
  
    def has_match_scorer_parameters(self): return self.has_match_scorer_parameters_
  
  
    def MergeFrom(self, x):
      assert x is not self
      if (x.has_scorer()): self.set_scorer(x.scorer())
      if (x.has_limit()): self.set_limit(x.limit())
      if (x.has_match_scorer_parameters()): self.set_match_scorer_parameters(x.match_scorer_parameters())
  
    def Equals(self, x):
      if x is self: return 1
      if self.has_scorer_ != x.has_scorer_: return 0
      if self.has_scorer_ and self.scorer_ != x.scorer_: return 0
      if self.has_limit_ != x.has_limit_: return 0
      if self.has_limit_ and self.limit_ != x.limit_: return 0
      if self.has_match_scorer_parameters_ != x.has_match_scorer_parameters_: return 0
      if self.has_match_scorer_parameters_ and self.match_scorer_parameters_ != x.match_scorer_parameters_: return 0
      return 1
  
    def IsInitialized(self, debug_strs=None):
      initialized = 1
      return initialized
  
    def ByteSize(self):
      n = 0
      if (self.has_scorer_): n += 1 + self.lengthVarInt64(self.scorer_)
      if (self.has_limit_): n += 1 + self.lengthVarInt64(self.limit_)
      if (self.has_match_scorer_parameters_): n += 1 + self.lengthString(len(self.match_scorer_parameters_))
      return n
  
    def ByteSizePartial(self):
      n = 0
      if (self.has_scorer_): n += 1 + self.lengthVarInt64(self.scorer_)
      if (self.has_limit_): n += 1 + self.lengthVarInt64(self.limit_)
      if (self.has_match_scorer_parameters_): n += 1 + self.lengthString(len(self.match_scorer_parameters_))
      return n
  
    def Clear(self):
      self.clear_scorer()
      self.clear_limit()
      self.clear_match_scorer_parameters()
  
    def OutputUnchecked(self, out):
      if (self.has_scorer_):
        out.putVarInt32(8)
        out.putVarInt32(self.scorer_)
      if (self.has_limit_):
        out.putVarInt32(16)
        out.putVarInt32(self.limit_)
      if (self.has_match_scorer_parameters_):
        out.putVarInt32(74)
        out.putPrefixedString(self.match_scorer_parameters_)
  
    def OutputPartial(self, out):
      if (self.has_scorer_):
        out.putVarInt32(8)
        out.putVarInt32(self.scorer_)
      if (self.has_limit_):
        out.putVarInt32(16)
        out.putVarInt32(self.limit_)
      if (self.has_match_scorer_parameters_):
        out.putVarInt32(74)
        out.putPrefixedString(self.match_scorer_parameters_)
  
    def TryMerge(self, d):
      while d.avail() > 0:
        tt = d.getVarInt32()
        if tt == 8:
          self.set_scorer(d.getVarInt32())
          continue
        if tt == 16:
          self.set_limit(d.getVarInt32())
          continue
        if tt == 74:
          self.set_match_scorer_parameters(d.getPrefixedString())
          continue
  
  
        if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
        d.skipData(tt)
  
  
    def __str__(self, prefix="", printElemNumber=0):
      res=""
      if self.has_scorer_: res+=prefix+("scorer: %s\n" % self.DebugFormatInt32(self.scorer_))
      if self.has_limit_: res+=prefix+("limit: %s\n" % self.DebugFormatInt32(self.limit_))
      if self.has_match_scorer_parameters_: res+=prefix+("match_scorer_parameters: %s\n" % self.DebugFormatString(self.match_scorer_parameters_))
      return res
  
  
    def _BuildTagLookupTable(sparse, maxtag, default=None):
      return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
  
    kscorer = 1
    klimit = 2
    kmatch_scorer_parameters = 9
  
    _TEXT = _BuildTagLookupTable({
      0: "ErrorCode",
      1: "scorer",
      2: "limit",
      9: "match_scorer_parameters",
    }, 9)
  
    _TYPES = _BuildTagLookupTable({
      0: ProtocolBuffer.Encoder.NUMERIC,
      1: ProtocolBuffer.Encoder.NUMERIC,
      2: ProtocolBuffer.Encoder.NUMERIC,
      9: ProtocolBuffer.Encoder.STRING,
    }, 9, ProtocolBuffer.Encoder.MAX_TYPE)
  
  
    _STYLE = """"""
    _STYLE_CONTENT_TYPE = """"""
    _PROTO_DESCRIPTOR_NAME = 'apphosting.ScorerSpec'
  class FieldSpec_Expression(ProtocolBuffer.ProtocolMessage):
    has_name_ = 0
    name_ = ""
    has_expression_ = 0
    expression_ = ""
  
    def __init__(self, contents=None):
      if contents is not None: self.MergeFromString(contents)
  
    def name(self): return self.name_
  
    def set_name(self, x):
      self.has_name_ = 1
      self.name_ = x
  
    def clear_name(self):
      if self.has_name_:
        self.has_name_ = 0
        self.name_ = ""
  
    def has_name(self): return self.has_name_
  
    def expression(self): return self.expression_
  
    def set_expression(self, x):
      self.has_expression_ = 1
      self.expression_ = x
  
    def clear_expression(self):
      if self.has_expression_:
        self.has_expression_ = 0
        self.expression_ = ""
  
    def has_expression(self): return self.has_expression_
  
  
    def MergeFrom(self, x):
      assert x is not self
      if (x.has_name()): self.set_name(x.name())
      if (x.has_expression()): self.set_expression(x.expression())
  
    def Equals(self, x):
      if x is self: return 1
      if self.has_name_ != x.has_name_: return 0
      if self.has_name_ and self.name_ != x.name_: return 0
      if self.has_expression_ != x.has_expression_: return 0
      if self.has_expression_ and self.expression_ != x.expression_: return 0
      return 1
  
    def IsInitialized(self, debug_strs=None):
      initialized = 1
      if (not self.has_name_):
        initialized = 0
        if debug_strs is not None:
          debug_strs.append('Required field: name not set.')
      if (not self.has_expression_):
        initialized = 0
        if debug_strs is not None:
          debug_strs.append('Required field: expression not set.')
      return initialized
  
    def ByteSize(self):
      n = 0
      n += self.lengthString(len(self.name_))
      n += self.lengthString(len(self.expression_))
      return n + 2
  
    def ByteSizePartial(self):
      n = 0
      if (self.has_name_):
        n += 1
        n += self.lengthString(len(self.name_))
      if (self.has_expression_):
        n += 1
        n += self.lengthString(len(self.expression_))
      return n
  
    def Clear(self):
      self.clear_name()
      self.clear_expression()
  
    def OutputUnchecked(self, out):
      out.putVarInt32(26)
      out.putPrefixedString(self.name_)
      out.putVarInt32(34)
      out.putPrefixedString(self.expression_)
  
    def OutputPartial(self, out):
      if (self.has_name_):
        out.putVarInt32(26)
        out.putPrefixedString(self.name_)
      if (self.has_expression_):
        out.putVarInt32(34)
        out.putPrefixedString(self.expression_)
  
    def TryMerge(self, d):
      while 1:
        tt = d.getVarInt32()
        if tt == 20: break
        if tt == 26:
          self.set_name(d.getPrefixedString())
          continue
        if tt == 34:
          self.set_expression(d.getPrefixedString())
          continue
  
  
        if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
        d.skipData(tt)
  
  
    def __str__(self, prefix="", printElemNumber=0):
      res=""
      if self.has_name_: res+=prefix+("name: %s\n" % self.DebugFormatString(self.name_))
      if self.has_expression_: res+=prefix+("expression: %s\n" % self.DebugFormatString(self.expression_))
      return res
  
  class FieldSpec(ProtocolBuffer.ProtocolMessage):
  
    def __init__(self, contents=None):
      self.name_ = []
      self.expression_ = []
      if contents is not None: self.MergeFromString(contents)
  
    def name_size(self): return len(self.name_)
    def name_list(self): return self.name_
  
    def name(self, i):
      return self.name_[i]
  
    def set_name(self, i, x):
      self.name_[i] = x
  
    def add_name(self, x):
      self.name_.append(x)
  
    def clear_name(self):
      self.name_ = []
  
    def expression_size(self): return len(self.expression_)
    def expression_list(self): return self.expression_
  
    def expression(self, i):
      return self.expression_[i]
  
    def mutable_expression(self, i):
      return self.expression_[i]
  
    def add_expression(self):
      x = FieldSpec_Expression()
      self.expression_.append(x)
      return x
  
    def clear_expression(self):
      self.expression_ = []
  
    def MergeFrom(self, x):
      assert x is not self
      for i in xrange(x.name_size()): self.add_name(x.name(i))
      for i in xrange(x.expression_size()): self.add_expression().CopyFrom(x.expression(i))
  
    def Equals(self, x):
      if x is self: return 1
      if len(self.name_) != len(x.name_): return 0
      for e1, e2 in zip(self.name_, x.name_):
        if e1 != e2: return 0
      if len(self.expression_) != len(x.expression_): return 0
      for e1, e2 in zip(self.expression_, x.expression_):
        if e1 != e2: return 0
      return 1
  
    def IsInitialized(self, debug_strs=None):
      initialized = 1
      for p in self.expression_:
        if not p.IsInitialized(debug_strs): initialized=0
      return initialized
  
    def ByteSize(self):
      n = 0
      n += 1 * len(self.name_)
      for i in xrange(len(self.name_)): n += self.lengthString(len(self.name_[i]))
      n += 2 * len(self.expression_)
      for i in xrange(len(self.expression_)): n += self.expression_[i].ByteSize()
      return n
  
    def ByteSizePartial(self):
      n = 0
      n += 1 * len(self.name_)
      for i in xrange(len(self.name_)): n += self.lengthString(len(self.name_[i]))
      n += 2 * len(self.expression_)
      for i in xrange(len(self.expression_)): n += self.expression_[i].ByteSizePartial()
      return n
  
    def Clear(self):
      self.clear_name()
      self.clear_expression()
  
    def OutputUnchecked(self, out):
      for i in xrange(len(self.name_)):
        out.putVarInt32(10)
        out.putPrefixedString(self.name_[i])
      for i in xrange(len(self.expression_)):
        out.putVarInt32(19)
        self.expression_[i].OutputUnchecked(out)
        out.putVarInt32(20)
  
    def OutputPartial(self, out):
      for i in xrange(len(self.name_)):
        out.putVarInt32(10)
        out.putPrefixedString(self.name_[i])
      for i in xrange(len(self.expression_)):
        out.putVarInt32(19)
        self.expression_[i].OutputPartial(out)
        out.putVarInt32(20)
  
    def TryMerge(self, d):
      while d.avail() > 0:
        tt = d.getVarInt32()
        if tt == 10:
          self.add_name(d.getPrefixedString())
          continue
        if tt == 19:
          self.add_expression().TryMerge(d)
          continue
  
  
        if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
        d.skipData(tt)
  
  
    def __str__(self, prefix="", printElemNumber=0):
      res=""
      cnt=0
      for e in self.name_:
        elm=""
        if printElemNumber: elm="(%d)" % cnt
        res+=prefix+("name%s: %s\n" % (elm, self.DebugFormatString(e)))
        cnt+=1
      cnt=0
      for e in self.expression_:
        elm=""
        if printElemNumber: elm="(%d)" % cnt
        res+=prefix+("Expression%s {\n" % elm)
        res+=e.__str__(prefix + "  ", printElemNumber)
        res+=prefix+"}\n"
        cnt+=1
      return res
  
  
    def _BuildTagLookupTable(sparse, maxtag, default=None):
      return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
  
    kname = 1
    kExpressionGroup = 2
    kExpressionname = 3
    kExpressionexpression = 4
  
    _TEXT = _BuildTagLookupTable({
      0: "ErrorCode",
      1: "name",
      2: "Expression",
      3: "name",
      4: "expression",
    }, 4)
  
    _TYPES = _BuildTagLookupTable({
      0: ProtocolBuffer.Encoder.NUMERIC,
      1: ProtocolBuffer.Encoder.STRING,
      2: ProtocolBuffer.Encoder.STARTGROUP,
      3: ProtocolBuffer.Encoder.STRING,
      4: ProtocolBuffer.Encoder.STRING,
    }, 4, ProtocolBuffer.Encoder.MAX_TYPE)
  
  
    _STYLE = """"""
    _STYLE_CONTENT_TYPE = """"""
    _PROTO_DESCRIPTOR_NAME = 'apphosting.FieldSpec'
  class SearchParams(ProtocolBuffer.ProtocolMessage):
  
  
    NONE         =    0
    SINGLE       =    1
    PER_RESULT   =    2
  
    _CursorType_NAMES = {
      0: "NONE",
      1: "SINGLE",
      2: "PER_RESULT",
    }
  
    def CursorType_Name(cls, x): return cls._CursorType_NAMES.get(x, "")
    CursorType_Name = classmethod(CursorType_Name)
  
  
  
    STRICT       =    0
    RELAXED      =    1
  
    _ParsingMode_NAMES = {
      0: "STRICT",
      1: "RELAXED",
    }
  
    def ParsingMode_Name(cls, x): return cls._ParsingMode_NAMES.get(x, "")
    ParsingMode_Name = classmethod(ParsingMode_Name)
  
    has_index_spec_ = 0
    has_query_ = 0
    query_ = ""
    has_cursor_ = 0
    cursor_ = ""
    has_offset_ = 0
    offset_ = 0
    has_cursor_type_ = 0
    cursor_type_ = 0
    has_limit_ = 0
    limit_ = 20
    has_matched_count_accuracy_ = 0
    matched_count_accuracy_ = 0
    has_scorer_spec_ = 0
    scorer_spec_ = None
    has_field_spec_ = 0
    field_spec_ = None
    has_keys_only_ = 0
    keys_only_ = 0
    has_parsing_mode_ = 0
    parsing_mode_ = 0
  
    def __init__(self, contents=None):
      self.index_spec_ = IndexSpec()
      self.sort_spec_ = []
      self.lazy_init_lock_ = thread.allocate_lock()
      if contents is not None: self.MergeFromString(contents)
  
    def index_spec(self): return self.index_spec_
  
    def mutable_index_spec(self): self.has_index_spec_ = 1; return self.index_spec_
  
    def clear_index_spec(self):self.has_index_spec_ = 0; self.index_spec_.Clear()
  
    def has_index_spec(self): return self.has_index_spec_
  
    def query(self): return self.query_
  
    def set_query(self, x):
      self.has_query_ = 1
      self.query_ = x
  
    def clear_query(self):
      if self.has_query_:
        self.has_query_ = 0
        self.query_ = ""
  
    def has_query(self): return self.has_query_
  
    def cursor(self): return self.cursor_
  
    def set_cursor(self, x):
      self.has_cursor_ = 1
      self.cursor_ = x
  
    def clear_cursor(self):
      if self.has_cursor_:
        self.has_cursor_ = 0
        self.cursor_ = ""
  
    def has_cursor(self): return self.has_cursor_
  
    def offset(self): return self.offset_
  
    def set_offset(self, x):
      self.has_offset_ = 1
      self.offset_ = x
  
    def clear_offset(self):
      if self.has_offset_:
        self.has_offset_ = 0
        self.offset_ = 0
  
    def has_offset(self): return self.has_offset_
  
    def cursor_type(self): return self.cursor_type_
  
    def set_cursor_type(self, x):
      self.has_cursor_type_ = 1
      self.cursor_type_ = x
  
    def clear_cursor_type(self):
      if self.has_cursor_type_:
        self.has_cursor_type_ = 0
        self.cursor_type_ = 0
  
    def has_cursor_type(self): return self.has_cursor_type_
  
    def limit(self): return self.limit_
  
    def set_limit(self, x):
      self.has_limit_ = 1
      self.limit_ = x
  
    def clear_limit(self):
      if self.has_limit_:
        self.has_limit_ = 0
        self.limit_ = 20
  
    def has_limit(self): return self.has_limit_
  
    def matched_count_accuracy(self): return self.matched_count_accuracy_
  
    def set_matched_count_accuracy(self, x):
      self.has_matched_count_accuracy_ = 1
      self.matched_count_accuracy_ = x
  
    def clear_matched_count_accuracy(self):
      if self.has_matched_count_accuracy_:
        self.has_matched_count_accuracy_ = 0
        self.matched_count_accuracy_ = 0
  
    def has_matched_count_accuracy(self): return self.has_matched_count_accuracy_
  
    def sort_spec_size(self): return len(self.sort_spec_)
    def sort_spec_list(self): return self.sort_spec_
  
    def sort_spec(self, i):
      return self.sort_spec_[i]
  
    def mutable_sort_spec(self, i):
      return self.sort_spec_[i]
  
    def add_sort_spec(self):
      x = SortSpec()
      self.sort_spec_.append(x)
      return x
  
    def clear_sort_spec(self):
      self.sort_spec_ = []
    def scorer_spec(self):
      if self.scorer_spec_ is None:
        self.lazy_init_lock_.acquire()
        try:
          if self.scorer_spec_ is None: self.scorer_spec_ = ScorerSpec()
        finally:
          self.lazy_init_lock_.release()
      return self.scorer_spec_
  
    def mutable_scorer_spec(self): self.has_scorer_spec_ = 1; return self.scorer_spec()
  
    def clear_scorer_spec(self):
  
      if self.has_scorer_spec_:
        self.has_scorer_spec_ = 0;
        if self.scorer_spec_ is not None: self.scorer_spec_.Clear()
  
    def has_scorer_spec(self): return self.has_scorer_spec_
  
    def field_spec(self):
      if self.field_spec_ is None:
        self.lazy_init_lock_.acquire()
        try:
          if self.field_spec_ is None: self.field_spec_ = FieldSpec()
        finally:
          self.lazy_init_lock_.release()
      return self.field_spec_
  
    def mutable_field_spec(self): self.has_field_spec_ = 1; return self.field_spec()
  
    def clear_field_spec(self):
  
      if self.has_field_spec_:
        self.has_field_spec_ = 0;
        if self.field_spec_ is not None: self.field_spec_.Clear()
  
    def has_field_spec(self): return self.has_field_spec_
  
    def keys_only(self): return self.keys_only_
  
    def set_keys_only(self, x):
      self.has_keys_only_ = 1
      self.keys_only_ = x
  
    def clear_keys_only(self):
      if self.has_keys_only_:
        self.has_keys_only_ = 0
        self.keys_only_ = 0
  
    def has_keys_only(self): return self.has_keys_only_
  
    def parsing_mode(self): return self.parsing_mode_
  
    def set_parsing_mode(self, x):
      self.has_parsing_mode_ = 1
      self.parsing_mode_ = x
  
    def clear_parsing_mode(self):
      if self.has_parsing_mode_:
        self.has_parsing_mode_ = 0
        self.parsing_mode_ = 0
  
    def has_parsing_mode(self): return self.has_parsing_mode_
  
  
    def MergeFrom(self, x):
      assert x is not self
      if (x.has_index_spec()): self.mutable_index_spec().MergeFrom(x.index_spec())
      if (x.has_query()): self.set_query(x.query())
      if (x.has_cursor()): self.set_cursor(x.cursor())
      if (x.has_offset()): self.set_offset(x.offset())
      if (x.has_cursor_type()): self.set_cursor_type(x.cursor_type())
      if (x.has_limit()): self.set_limit(x.limit())
      if (x.has_matched_count_accuracy()): self.set_matched_count_accuracy(x.matched_count_accuracy())
      for i in xrange(x.sort_spec_size()): self.add_sort_spec().CopyFrom(x.sort_spec(i))
      if (x.has_scorer_spec()): self.mutable_scorer_spec().MergeFrom(x.scorer_spec())
      if (x.has_field_spec()): self.mutable_field_spec().MergeFrom(x.field_spec())
      if (x.has_keys_only()): self.set_keys_only(x.keys_only())
      if (x.has_parsing_mode()): self.set_parsing_mode(x.parsing_mode())
  
    def Equals(self, x):
      if x is self: return 1
      if self.has_index_spec_ != x.has_index_spec_: return 0
      if self.has_index_spec_ and self.index_spec_ != x.index_spec_: return 0
      if self.has_query_ != x.has_query_: return 0
      if self.has_query_ and self.query_ != x.query_: return 0
      if self.has_cursor_ != x.has_cursor_: return 0
      if self.has_cursor_ and self.cursor_ != x.cursor_: return 0
      if self.has_offset_ != x.has_offset_: return 0
      if self.has_offset_ and self.offset_ != x.offset_: return 0
      if self.has_cursor_type_ != x.has_cursor_type_: return 0
      if self.has_cursor_type_ and self.cursor_type_ != x.cursor_type_: return 0
      if self.has_limit_ != x.has_limit_: return 0
      if self.has_limit_ and self.limit_ != x.limit_: return 0
      if self.has_matched_count_accuracy_ != x.has_matched_count_accuracy_: return 0
      if self.has_matched_count_accuracy_ and self.matched_count_accuracy_ != x.matched_count_accuracy_: return 0
      if len(self.sort_spec_) != len(x.sort_spec_): return 0
      for e1, e2 in zip(self.sort_spec_, x.sort_spec_):
        if e1 != e2: return 0
      if self.has_scorer_spec_ != x.has_scorer_spec_: return 0
      if self.has_scorer_spec_ and self.scorer_spec_ != x.scorer_spec_: return 0
      if self.has_field_spec_ != x.has_field_spec_: return 0
      if self.has_field_spec_ and self.field_spec_ != x.field_spec_: return 0
      if self.has_keys_only_ != x.has_keys_only_: return 0
      if self.has_keys_only_ and self.keys_only_ != x.keys_only_: return 0
      if self.has_parsing_mode_ != x.has_parsing_mode_: return 0
      if self.has_parsing_mode_ and self.parsing_mode_ != x.parsing_mode_: return 0
      return 1
  
    def IsInitialized(self, debug_strs=None):
      initialized = 1
      if (not self.has_index_spec_):
        initialized = 0
        if debug_strs is not None:
          debug_strs.append('Required field: index_spec not set.')
      elif not self.index_spec_.IsInitialized(debug_strs): initialized = 0
      if (not self.has_query_):
        initialized = 0
        if debug_strs is not None:
          debug_strs.append('Required field: query not set.')
      for p in self.sort_spec_:
        if not p.IsInitialized(debug_strs): initialized=0
      if (self.has_scorer_spec_ and not self.scorer_spec_.IsInitialized(debug_strs)): initialized = 0
      if (self.has_field_spec_ and not self.field_spec_.IsInitialized(debug_strs)): initialized = 0
      return initialized
  
    def ByteSize(self):
      n = 0
      n += self.lengthString(self.index_spec_.ByteSize())
      n += self.lengthString(len(self.query_))
      if (self.has_cursor_): n += 1 + self.lengthString(len(self.cursor_))
      if (self.has_offset_): n += 1 + self.lengthVarInt64(self.offset_)
      if (self.has_cursor_type_): n += 1 + self.lengthVarInt64(self.cursor_type_)
      if (self.has_limit_): n += 1 + self.lengthVarInt64(self.limit_)
      if (self.has_matched_count_accuracy_): n += 1 + self.lengthVarInt64(self.matched_count_accuracy_)
      n += 1 * len(self.sort_spec_)
      for i in xrange(len(self.sort_spec_)): n += self.lengthString(self.sort_spec_[i].ByteSize())
      if (self.has_scorer_spec_): n += 1 + self.lengthString(self.scorer_spec_.ByteSize())
      if (self.has_field_spec_): n += 1 + self.lengthString(self.field_spec_.ByteSize())
      if (self.has_keys_only_): n += 2
      if (self.has_parsing_mode_): n += 1 + self.lengthVarInt64(self.parsing_mode_)
      return n + 2
  
    def ByteSizePartial(self):
      n = 0
      if (self.has_index_spec_):
        n += 1
        n += self.lengthString(self.index_spec_.ByteSizePartial())
      if (self.has_query_):
        n += 1
        n += self.lengthString(len(self.query_))
      if (self.has_cursor_): n += 1 + self.lengthString(len(self.cursor_))
      if (self.has_offset_): n += 1 + self.lengthVarInt64(self.offset_)
      if (self.has_cursor_type_): n += 1 + self.lengthVarInt64(self.cursor_type_)
      if (self.has_limit_): n += 1 + self.lengthVarInt64(self.limit_)
      if (self.has_matched_count_accuracy_): n += 1 + self.lengthVarInt64(self.matched_count_accuracy_)
      n += 1 * len(self.sort_spec_)
      for i in xrange(len(self.sort_spec_)): n += self.lengthString(self.sort_spec_[i].ByteSizePartial())
      if (self.has_scorer_spec_): n += 1 + self.lengthString(self.scorer_spec_.ByteSizePartial())
      if (self.has_field_spec_): n += 1 + self.lengthString(self.field_spec_.ByteSizePartial())
      if (self.has_keys_only_): n += 2
      if (self.has_parsing_mode_): n += 1 + self.lengthVarInt64(self.parsing_mode_)
      return n
  
    def Clear(self):
      self.clear_index_spec()
      self.clear_query()
      self.clear_cursor()
      self.clear_offset()
      self.clear_cursor_type()
      self.clear_limit()
      self.clear_matched_count_accuracy()
      self.clear_sort_spec()
      self.clear_scorer_spec()
      self.clear_field_spec()
      self.clear_keys_only()
      self.clear_parsing_mode()
  
    def OutputUnchecked(self, out):
      out.putVarInt32(10)
      out.putVarInt32(self.index_spec_.ByteSize())
      self.index_spec_.OutputUnchecked(out)
      out.putVarInt32(18)
      out.putPrefixedString(self.query_)
      if (self.has_cursor_):
        out.putVarInt32(34)
        out.putPrefixedString(self.cursor_)
      if (self.has_cursor_type_):
        out.putVarInt32(40)
        out.putVarInt32(self.cursor_type_)
      if (self.has_limit_):
        out.putVarInt32(48)
        out.putVarInt32(self.limit_)
      if (self.has_matched_count_accuracy_):
        out.putVarInt32(56)
        out.putVarInt32(self.matched_count_accuracy_)
      for i in xrange(len(self.sort_spec_)):
        out.putVarInt32(66)
        out.putVarInt32(self.sort_spec_[i].ByteSize())
        self.sort_spec_[i].OutputUnchecked(out)
      if (self.has_scorer_spec_):
        out.putVarInt32(74)
        out.putVarInt32(self.scorer_spec_.ByteSize())
        self.scorer_spec_.OutputUnchecked(out)
      if (self.has_field_spec_):
        out.putVarInt32(82)
        out.putVarInt32(self.field_spec_.ByteSize())
        self.field_spec_.OutputUnchecked(out)
      if (self.has_offset_):
        out.putVarInt32(88)
        out.putVarInt32(self.offset_)
      if (self.has_keys_only_):
        out.putVarInt32(96)
        out.putBoolean(self.keys_only_)
      if (self.has_parsing_mode_):
        out.putVarInt32(104)
        out.putVarInt32(self.parsing_mode_)
  
    def OutputPartial(self, out):
      if (self.has_index_spec_):
        out.putVarInt32(10)
        out.putVarInt32(self.index_spec_.ByteSizePartial())
        self.index_spec_.OutputPartial(out)
      if (self.has_query_):
        out.putVarInt32(18)
        out.putPrefixedString(self.query_)
      if (self.has_cursor_):
        out.putVarInt32(34)
        out.putPrefixedString(self.cursor_)
      if (self.has_cursor_type_):
        out.putVarInt32(40)
        out.putVarInt32(self.cursor_type_)
      if (self.has_limit_):
        out.putVarInt32(48)
        out.putVarInt32(self.limit_)
      if (self.has_matched_count_accuracy_):
        out.putVarInt32(56)
        out.putVarInt32(self.matched_count_accuracy_)
      for i in xrange(len(self.sort_spec_)):
        out.putVarInt32(66)
        out.putVarInt32(self.sort_spec_[i].ByteSizePartial())
        self.sort_spec_[i].OutputPartial(out)
      if (self.has_scorer_spec_):
        out.putVarInt32(74)
        out.putVarInt32(self.scorer_spec_.ByteSizePartial())
        self.scorer_spec_.OutputPartial(out)
      if (self.has_field_spec_):
        out.putVarInt32(82)
        out.putVarInt32(self.field_spec_.ByteSizePartial())
        self.field_spec_.OutputPartial(out)
      if (self.has_offset_):
        out.putVarInt32(88)
        out.putVarInt32(self.offset_)
      if (self.has_keys_only_):
        out.putVarInt32(96)
        out.putBoolean(self.keys_only_)
      if (self.has_parsing_mode_):
        out.putVarInt32(104)
        out.putVarInt32(self.parsing_mode_)
  
    def TryMerge(self, d):
      while d.avail() > 0:
        tt = d.getVarInt32()
        if tt == 10:
          length = d.getVarInt32()
          tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
          d.skip(length)
          self.mutable_index_spec().TryMerge(tmp)
          continue
        if tt == 18:
          self.set_query(d.getPrefixedString())
          continue
        if tt == 34:
          self.set_cursor(d.getPrefixedString())
          continue
        if tt == 40:
          self.set_cursor_type(d.getVarInt32())
          continue
        if tt == 48:
          self.set_limit(d.getVarInt32())
          continue
        if tt == 56:
          self.set_matched_count_accuracy(d.getVarInt32())
          continue
        if tt == 66:
          length = d.getVarInt32()
          tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
          d.skip(length)
          self.add_sort_spec().TryMerge(tmp)
          continue
        if tt == 74:
          length = d.getVarInt32()
          tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
          d.skip(length)
          self.mutable_scorer_spec().TryMerge(tmp)
          continue
        if tt == 82:
          length = d.getVarInt32()
          tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
          d.skip(length)
          self.mutable_field_spec().TryMerge(tmp)
          continue
        if tt == 88:
          self.set_offset(d.getVarInt32())
          continue
        if tt == 96:
          self.set_keys_only(d.getBoolean())
          continue
        if tt == 104:
          self.set_parsing_mode(d.getVarInt32())
          continue
  
  
        if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
        d.skipData(tt)
  
  
    def __str__(self, prefix="", printElemNumber=0):
      res=""
      if self.has_index_spec_:
        res+=prefix+"index_spec <\n"
        res+=self.index_spec_.__str__(prefix + "  ", printElemNumber)
        res+=prefix+">\n"
      if self.has_query_: res+=prefix+("query: %s\n" % self.DebugFormatString(self.query_))
      if self.has_cursor_: res+=prefix+("cursor: %s\n" % self.DebugFormatString(self.cursor_))
      if self.has_offset_: res+=prefix+("offset: %s\n" % self.DebugFormatInt32(self.offset_))
      if self.has_cursor_type_: res+=prefix+("cursor_type: %s\n" % self.DebugFormatInt32(self.cursor_type_))
      if self.has_limit_: res+=prefix+("limit: %s\n" % self.DebugFormatInt32(self.limit_))
      if self.has_matched_count_accuracy_: res+=prefix+("matched_count_accuracy: %s\n" % self.DebugFormatInt32(self.matched_count_accuracy_))
      cnt=0
      for e in self.sort_spec_:
        elm=""
        if printElemNumber: elm="(%d)" % cnt
        res+=prefix+("sort_spec%s <\n" % elm)
        res+=e.__str__(prefix + "  ", printElemNumber)
        res+=prefix+">\n"
        cnt+=1
      if self.has_scorer_spec_:
        res+=prefix+"scorer_spec <\n"
        res+=self.scorer_spec_.__str__(prefix + "  ", printElemNumber)
        res+=prefix+">\n"
      if self.has_field_spec_:
        res+=prefix+"field_spec <\n"
        res+=self.field_spec_.__str__(prefix + "  ", printElemNumber)
        res+=prefix+">\n"
      if self.has_keys_only_: res+=prefix+("keys_only: %s\n" % self.DebugFormatBool(self.keys_only_))
      if self.has_parsing_mode_: res+=prefix+("parsing_mode: %s\n" % self.DebugFormatInt32(self.parsing_mode_))
      return res
  
  
    def _BuildTagLookupTable(sparse, maxtag, default=None):
      return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
  
    kindex_spec = 1
    kquery = 2
    kcursor = 4
    koffset = 11
    kcursor_type = 5
    klimit = 6
    kmatched_count_accuracy = 7
    ksort_spec = 8
    kscorer_spec = 9
    kfield_spec = 10
    kkeys_only = 12
    kparsing_mode = 13
  
    _TEXT = _BuildTagLookupTable({
      0: "ErrorCode",
      1: "index_spec",
      2: "query",
      4: "cursor",
      5: "cursor_type",
      6: "limit",
      7: "matched_count_accuracy",
      8: "sort_spec",
      9: "scorer_spec",
      10: "field_spec",
      11: "offset",
      12: "keys_only",
      13: "parsing_mode",
    }, 13)
  
    _TYPES = _BuildTagLookupTable({
      0: ProtocolBuffer.Encoder.NUMERIC,
      1: ProtocolBuffer.Encoder.STRING,
      2: ProtocolBuffer.Encoder.STRING,
      4: ProtocolBuffer.Encoder.STRING,
      5: ProtocolBuffer.Encoder.NUMERIC,
      6: ProtocolBuffer.Encoder.NUMERIC,
      7: ProtocolBuffer.Encoder.NUMERIC,
      8: ProtocolBuffer.Encoder.STRING,
      9: ProtocolBuffer.Encoder.STRING,
      10: ProtocolBuffer.Encoder.STRING,
      11: ProtocolBuffer.Encoder.NUMERIC,
      12: ProtocolBuffer.Encoder.NUMERIC,
      13: ProtocolBuffer.Encoder.NUMERIC,
    }, 13, ProtocolBuffer.Encoder.MAX_TYPE)
  
  
    _STYLE = """"""
    _STYLE_CONTENT_TYPE = """"""
    _PROTO_DESCRIPTOR_NAME = 'apphosting.SearchParams'
  class SearchRequest(ProtocolBuffer.ProtocolMessage):
    has_params_ = 0
    has_app_id_ = 0
    app_id_ = ""
  
    def __init__(self, contents=None):
      self.params_ = SearchParams()
      if contents is not None: self.MergeFromString(contents)
  
    def params(self): return self.params_
  
    def mutable_params(self): self.has_params_ = 1; return self.params_
  
    def clear_params(self):self.has_params_ = 0; self.params_.Clear()
  
    def has_params(self): return self.has_params_
  
    def app_id(self): return self.app_id_
  
    def set_app_id(self, x):
      self.has_app_id_ = 1
      self.app_id_ = x
  
    def clear_app_id(self):
      if self.has_app_id_:
        self.has_app_id_ = 0
        self.app_id_ = ""
  
    def has_app_id(self): return self.has_app_id_
  
  
    def MergeFrom(self, x):
      assert x is not self
      if (x.has_params()): self.mutable_params().MergeFrom(x.params())
      if (x.has_app_id()): self.set_app_id(x.app_id())
  
    def Equals(self, x):
      if x is self: return 1
      if self.has_params_ != x.has_params_: return 0
      if self.has_params_ and self.params_ != x.params_: return 0
      if self.has_app_id_ != x.has_app_id_: return 0
      if self.has_app_id_ and self.app_id_ != x.app_id_: return 0
      return 1
  
    def IsInitialized(self, debug_strs=None):
      initialized = 1
      if (not self.has_params_):
        initialized = 0
        if debug_strs is not None:
          debug_strs.append('Required field: params not set.')
      elif not self.params_.IsInitialized(debug_strs): initialized = 0
      return initialized
  
    def ByteSize(self):
      n = 0
      n += self.lengthString(self.params_.ByteSize())
      if (self.has_app_id_): n += 1 + self.lengthString(len(self.app_id_))
      return n + 1
  
    def ByteSizePartial(self):
      n = 0
      if (self.has_params_):
        n += 1
        n += self.lengthString(self.params_.ByteSizePartial())
      if (self.has_app_id_): n += 1 + self.lengthString(len(self.app_id_))
      return n
  
    def Clear(self):
      self.clear_params()
      self.clear_app_id()
  
    def OutputUnchecked(self, out):
      out.putVarInt32(10)
      out.putVarInt32(self.params_.ByteSize())
      self.params_.OutputUnchecked(out)
      if (self.has_app_id_):
        out.putVarInt32(26)
        out.putPrefixedString(self.app_id_)
  
    def OutputPartial(self, out):
      if (self.has_params_):
        out.putVarInt32(10)
        out.putVarInt32(self.params_.ByteSizePartial())
        self.params_.OutputPartial(out)
      if (self.has_app_id_):
        out.putVarInt32(26)
        out.putPrefixedString(self.app_id_)
  
    def TryMerge(self, d):
      while d.avail() > 0:
        tt = d.getVarInt32()
        if tt == 10:
          length = d.getVarInt32()
          tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
          d.skip(length)
          self.mutable_params().TryMerge(tmp)
          continue
        if tt == 26:
          self.set_app_id(d.getPrefixedString())
          continue
  
  
        if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
        d.skipData(tt)
  
  
    def __str__(self, prefix="", printElemNumber=0):
      res=""
      if self.has_params_:
        res+=prefix+"params <\n"
        res+=self.params_.__str__(prefix + "  ", printElemNumber)
        res+=prefix+">\n"
      if self.has_app_id_: res+=prefix+("app_id: %s\n" % self.DebugFormatString(self.app_id_))
      return res
  
  
    def _BuildTagLookupTable(sparse, maxtag, default=None):
      return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
  
    kparams = 1
    kapp_id = 3
  
    _TEXT = _BuildTagLookupTable({
      0: "ErrorCode",
      1: "params",
      3: "app_id",
    }, 3)
  
    _TYPES = _BuildTagLookupTable({
      0: ProtocolBuffer.Encoder.NUMERIC,
      1: ProtocolBuffer.Encoder.STRING,
      3: ProtocolBuffer.Encoder.STRING,
    }, 3, ProtocolBuffer.Encoder.MAX_TYPE)
  
  
    _STYLE = """"""
    _STYLE_CONTENT_TYPE = """"""
    _PROTO_DESCRIPTOR_NAME = 'apphosting.SearchRequest'
  class SearchResult(ProtocolBuffer.ProtocolMessage):
    has_document_ = 0
    has_cursor_ = 0
    cursor_ = ""
  
    def __init__(self, contents=None):
      self.document_ = Document()
      self.expression_ = []
      self.score_ = []
      if contents is not None: self.MergeFromString(contents)
  
    def document(self): return self.document_
  
    def mutable_document(self): self.has_document_ = 1; return self.document_
  
    def clear_document(self):self.has_document_ = 0; self.document_.Clear()
  
    def has_document(self): return self.has_document_
  
    def expression_size(self): return len(self.expression_)
    def expression_list(self): return self.expression_
  
    def expression(self, i):
      return self.expression_[i]
  
    def mutable_expression(self, i):
      return self.expression_[i]
  
    def add_expression(self):
      x = Field()
      self.expression_.append(x)
      return x
  
    def clear_expression(self):
      self.expression_ = []
    def score_size(self): return len(self.score_)
    def score_list(self): return self.score_
  
    def score(self, i):
      return self.score_[i]
  
    def set_score(self, i, x):
      self.score_[i] = x
  
    def add_score(self, x):
      self.score_.append(x)
  
    def clear_score(self):
      self.score_ = []
  
    def cursor(self): return self.cursor_
  
    def set_cursor(self, x):
      self.has_cursor_ = 1
      self.cursor_ = x
  
    def clear_cursor(self):
      if self.has_cursor_:
        self.has_cursor_ = 0
        self.cursor_ = ""
  
    def has_cursor(self): return self.has_cursor_
  
  
    def MergeFrom(self, x):
      assert x is not self
      if (x.has_document()): self.mutable_document().MergeFrom(x.document())
      for i in xrange(x.expression_size()): self.add_expression().CopyFrom(x.expression(i))
      for i in xrange(x.score_size()): self.add_score(x.score(i))
      if (x.has_cursor()): self.set_cursor(x.cursor())
  
    def Equals(self, x):
      if x is self: return 1
      if self.has_document_ != x.has_document_: return 0
      if self.has_document_ and self.document_ != x.document_: return 0
      if len(self.expression_) != len(x.expression_): return 0
      for e1, e2 in zip(self.expression_, x.expression_):
        if e1 != e2: return 0
      if len(self.score_) != len(x.score_): return 0
      for e1, e2 in zip(self.score_, x.score_):
        if e1 != e2: return 0
      if self.has_cursor_ != x.has_cursor_: return 0
      if self.has_cursor_ and self.cursor_ != x.cursor_: return 0
      return 1
  
    def IsInitialized(self, debug_strs=None):
      initialized = 1
      if (not self.has_document_):
        initialized = 0
        if debug_strs is not None:
          debug_strs.append('Required field: document not set.')
      elif not self.document_.IsInitialized(debug_strs): initialized = 0
      for p in self.expression_:
        if not p.IsInitialized(debug_strs): initialized=0
      return initialized
  
    def ByteSize(self):
      n = 0
      n += self.lengthString(self.document_.ByteSize())
      n += 1 * len(self.expression_)
      for i in xrange(len(self.expression_)): n += self.lengthString(self.expression_[i].ByteSize())
      n += 9 * len(self.score_)
      if (self.has_cursor_): n += 1 + self.lengthString(len(self.cursor_))
      return n + 1
  
    def ByteSizePartial(self):
      n = 0
      if (self.has_document_):
        n += 1
        n += self.lengthString(self.document_.ByteSizePartial())
      n += 1 * len(self.expression_)
      for i in xrange(len(self.expression_)): n += self.lengthString(self.expression_[i].ByteSizePartial())
      n += 9 * len(self.score_)
      if (self.has_cursor_): n += 1 + self.lengthString(len(self.cursor_))
      return n
  
    def Clear(self):
      self.clear_document()
      self.clear_expression()
      self.clear_score()
      self.clear_cursor()
  
    def OutputUnchecked(self, out):
      out.putVarInt32(10)
      out.putVarInt32(self.document_.ByteSize())
      self.document_.OutputUnchecked(out)
      for i in xrange(len(self.score_)):
        out.putVarInt32(17)
        out.putDouble(self.score_[i])
      if (self.has_cursor_):
        out.putVarInt32(26)
        out.putPrefixedString(self.cursor_)
      for i in xrange(len(self.expression_)):
        out.putVarInt32(34)
        out.putVarInt32(self.expression_[i].ByteSize())
        self.expression_[i].OutputUnchecked(out)
  
    def OutputPartial(self, out):
      if (self.has_document_):
        out.putVarInt32(10)
        out.putVarInt32(self.document_.ByteSizePartial())
        self.document_.OutputPartial(out)
      for i in xrange(len(self.score_)):
        out.putVarInt32(17)
        out.putDouble(self.score_[i])
      if (self.has_cursor_):
        out.putVarInt32(26)
        out.putPrefixedString(self.cursor_)
      for i in xrange(len(self.expression_)):
        out.putVarInt32(34)
        out.putVarInt32(self.expression_[i].ByteSizePartial())
        self.expression_[i].OutputPartial(out)
  
    def TryMerge(self, d):
      while d.avail() > 0:
        tt = d.getVarInt32()
        if tt == 10:
          length = d.getVarInt32()
          tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
          d.skip(length)
          self.mutable_document().TryMerge(tmp)
          continue
        if tt == 17:
          self.add_score(d.getDouble())
          continue
        if tt == 26:
          self.set_cursor(d.getPrefixedString())
          continue
        if tt == 34:
          length = d.getVarInt32()
          tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
          d.skip(length)
          self.add_expression().TryMerge(tmp)
          continue
  
  
        if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
        d.skipData(tt)
  
  
    def __str__(self, prefix="", printElemNumber=0):
      res=""
      if self.has_document_:
        res+=prefix+"document <\n"
        res+=self.document_.__str__(prefix + "  ", printElemNumber)
        res+=prefix+">\n"
      cnt=0
      for e in self.expression_:
        elm=""
        if printElemNumber: elm="(%d)" % cnt
        res+=prefix+("expression%s <\n" % elm)
        res+=e.__str__(prefix + "  ", printElemNumber)
        res+=prefix+">\n"
        cnt+=1
      cnt=0
      for e in self.score_:
        elm=""
        if printElemNumber: elm="(%d)" % cnt
        res+=prefix+("score%s: %s\n" % (elm, self.DebugFormat(e)))
        cnt+=1
      if self.has_cursor_: res+=prefix+("cursor: %s\n" % self.DebugFormatString(self.cursor_))
      return res
  
  
    def _BuildTagLookupTable(sparse, maxtag, default=None):
      return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
  
    kdocument = 1
    kexpression = 4
    kscore = 2
    kcursor = 3
  
    _TEXT = _BuildTagLookupTable({
      0: "ErrorCode",
      1: "document",
      2: "score",
      3: "cursor",
      4: "expression",
    }, 4)
  
    _TYPES = _BuildTagLookupTable({
      0: ProtocolBuffer.Encoder.NUMERIC,
      1: ProtocolBuffer.Encoder.STRING,
      2: ProtocolBuffer.Encoder.DOUBLE,
      3: ProtocolBuffer.Encoder.STRING,
      4: ProtocolBuffer.Encoder.STRING,
    }, 4, ProtocolBuffer.Encoder.MAX_TYPE)
  
  
    _STYLE = """"""
    _STYLE_CONTENT_TYPE = """"""
    _PROTO_DESCRIPTOR_NAME = 'apphosting.SearchResult'
  class SearchResponse(ProtocolBuffer.ProtocolMessage):
    has_matched_count_ = 0
    matched_count_ = 0
    has_status_ = 0
    has_cursor_ = 0
    cursor_ = ""
  
    def __init__(self, contents=None):
      self.result_ = []
      self.status_ = RequestStatus()
      if contents is not None: self.MergeFromString(contents)
  
    def result_size(self): return len(self.result_)
    def result_list(self): return self.result_
  
    def result(self, i):
      return self.result_[i]
  
    def mutable_result(self, i):
      return self.result_[i]
  
    def add_result(self):
      x = SearchResult()
      self.result_.append(x)
      return x
  
    def clear_result(self):
      self.result_ = []
    def matched_count(self): return self.matched_count_
  
    def set_matched_count(self, x):
      self.has_matched_count_ = 1
      self.matched_count_ = x
  
    def clear_matched_count(self):
      if self.has_matched_count_:
        self.has_matched_count_ = 0
        self.matched_count_ = 0
  
    def has_matched_count(self): return self.has_matched_count_
  
    def status(self): return self.status_
  
    def mutable_status(self): self.has_status_ = 1; return self.status_
  
    def clear_status(self):self.has_status_ = 0; self.status_.Clear()
  
    def has_status(self): return self.has_status_
  
    def cursor(self): return self.cursor_
  
    def set_cursor(self, x):
      self.has_cursor_ = 1
      self.cursor_ = x
  
    def clear_cursor(self):
      if self.has_cursor_:
        self.has_cursor_ = 0
        self.cursor_ = ""
  
    def has_cursor(self): return self.has_cursor_
  
  
    def MergeFrom(self, x):
      assert x is not self
      for i in xrange(x.result_size()): self.add_result().CopyFrom(x.result(i))
      if (x.has_matched_count()): self.set_matched_count(x.matched_count())
      if (x.has_status()): self.mutable_status().MergeFrom(x.status())
      if (x.has_cursor()): self.set_cursor(x.cursor())
  
    def Equals(self, x):
      if x is self: return 1
      if len(self.result_) != len(x.result_): return 0
      for e1, e2 in zip(self.result_, x.result_):
        if e1 != e2: return 0
      if self.has_matched_count_ != x.has_matched_count_: return 0
      if self.has_matched_count_ and self.matched_count_ != x.matched_count_: return 0
      if self.has_status_ != x.has_status_: return 0
      if self.has_status_ and self.status_ != x.status_: return 0
      if self.has_cursor_ != x.has_cursor_: return 0
      if self.has_cursor_ and self.cursor_ != x.cursor_: return 0
      return 1
  
    def IsInitialized(self, debug_strs=None):
      initialized = 1
      for p in self.result_:
        if not p.IsInitialized(debug_strs): initialized=0
      if (not self.has_matched_count_):
        initialized = 0
        if debug_strs is not None:
          debug_strs.append('Required field: matched_count not set.')
      if (not self.has_status_):
        initialized = 0
        if debug_strs is not None:
          debug_strs.append('Required field: status not set.')
      elif not self.status_.IsInitialized(debug_strs): initialized = 0
      return initialized
  
    def ByteSize(self):
      n = 0
      n += 1 * len(self.result_)
      for i in xrange(len(self.result_)): n += self.lengthString(self.result_[i].ByteSize())
      n += self.lengthVarInt64(self.matched_count_)
      n += self.lengthString(self.status_.ByteSize())
      if (self.has_cursor_): n += 1 + self.lengthString(len(self.cursor_))
      return n + 2
  
    def ByteSizePartial(self):
      n = 0
      n += 1 * len(self.result_)
      for i in xrange(len(self.result_)): n += self.lengthString(self.result_[i].ByteSizePartial())
      if (self.has_matched_count_):
        n += 1
        n += self.lengthVarInt64(self.matched_count_)
      if (self.has_status_):
        n += 1
        n += self.lengthString(self.status_.ByteSizePartial())
      if (self.has_cursor_): n += 1 + self.lengthString(len(self.cursor_))
      return n
  
    def Clear(self):
      self.clear_result()
      self.clear_matched_count()
      self.clear_status()
      self.clear_cursor()
  
    def OutputUnchecked(self, out):
      for i in xrange(len(self.result_)):
        out.putVarInt32(10)
        out.putVarInt32(self.result_[i].ByteSize())
        self.result_[i].OutputUnchecked(out)
      out.putVarInt32(16)
      out.putVarInt64(self.matched_count_)
      out.putVarInt32(26)
      out.putVarInt32(self.status_.ByteSize())
      self.status_.OutputUnchecked(out)
      if (self.has_cursor_):
        out.putVarInt32(34)
        out.putPrefixedString(self.cursor_)
  
    def OutputPartial(self, out):
      for i in xrange(len(self.result_)):
        out.putVarInt32(10)
        out.putVarInt32(self.result_[i].ByteSizePartial())
        self.result_[i].OutputPartial(out)
      if (self.has_matched_count_):
        out.putVarInt32(16)
        out.putVarInt64(self.matched_count_)
      if (self.has_status_):
        out.putVarInt32(26)
        out.putVarInt32(self.status_.ByteSizePartial())
        self.status_.OutputPartial(out)
      if (self.has_cursor_):
        out.putVarInt32(34)
        out.putPrefixedString(self.cursor_)
  
    def TryMerge(self, d):
      while d.avail() > 0:
        tt = d.getVarInt32()
        if tt == 10:
          length = d.getVarInt32()
          tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
          d.skip(length)
          self.add_result().TryMerge(tmp)
          continue
        if tt == 16:
          self.set_matched_count(d.getVarInt64())
          continue
        if tt == 26:
          length = d.getVarInt32()
          tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
          d.skip(length)
          self.mutable_status().TryMerge(tmp)
          continue
        if tt == 34:
          self.set_cursor(d.getPrefixedString())
          continue
  
  
        if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
        d.skipData(tt)
  
  
    def __str__(self, prefix="", printElemNumber=0):
      res=""
      cnt=0
      for e in self.result_:
        elm=""
        if printElemNumber: elm="(%d)" % cnt
        res+=prefix+("result%s <\n" % elm)
        res+=e.__str__(prefix + "  ", printElemNumber)
        res+=prefix+">\n"
        cnt+=1
      if self.has_matched_count_: res+=prefix+("matched_count: %s\n" % self.DebugFormatInt64(self.matched_count_))
      if self.has_status_:
        res+=prefix+"status <\n"
        res+=self.status_.__str__(prefix + "  ", printElemNumber)
        res+=prefix+">\n"
      if self.has_cursor_: res+=prefix+("cursor: %s\n" % self.DebugFormatString(self.cursor_))
      return res
  
  
    def _BuildTagLookupTable(sparse, maxtag, default=None):
      return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
  
    kresult = 1
    kmatched_count = 2
    kstatus = 3
    kcursor = 4
  
    _TEXT = _BuildTagLookupTable({
      0: "ErrorCode",
      1: "result",
      2: "matched_count",
      3: "status",
      4: "cursor",
    }, 4)
  
    _TYPES = _BuildTagLookupTable({
      0: ProtocolBuffer.Encoder.NUMERIC,
      1: ProtocolBuffer.Encoder.STRING,
      2: ProtocolBuffer.Encoder.NUMERIC,
      3: ProtocolBuffer.Encoder.STRING,
      4: ProtocolBuffer.Encoder.STRING,
    }, 4, ProtocolBuffer.Encoder.MAX_TYPE)
  
  
    _STYLE = """"""
    _STYLE_CONTENT_TYPE = """"""
    _PROTO_DESCRIPTOR_NAME = 'apphosting.SearchResponse'
  if _extension_runtime:
    pass
  
  __all__ = ['SearchServiceError','RequestStatus','IndexSpec','IndexMetadata','IndexDocumentParams','IndexDocumentRequest','IndexDocumentResponse','DeleteDocumentParams','DeleteDocumentRequest','DeleteDocumentResponse','ListDocumentsParams','ListDocumentsRequest','ListDocumentsResponse','ListIndexesParams','ListIndexesRequest','ListIndexesResponse','DeleteSchemaParams','DeleteSchemaRequest','DeleteSchemaResponse','SortSpec','ScorerSpec','FieldSpec','FieldSpec_Expression','SearchParams','SearchRequest','SearchResult','SearchResponse']
  