#!/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"""

from google.appengine.api.api_base_pb import Integer64Proto;

from google.appengine.api.api_base_pb import StringProto;

from google.appengine.api.api_base_pb import VoidProto;

from google.appengine.datastore.entity_pb import CompositeIndex

from google.appengine.datastore.entity_pb import EntityProto

from google.appengine.datastore.entity_pb import Index

from google.appengine.datastore.entity_pb import Property

from google.appengine.datastore.entity_pb import Reference

class Transaction(ProtocolBuffer.ProtocolMessage):

  has_handle_ = 0

  handle_ = 0

  def __init__(self, contents=None):

    if contents is not None: self.MergeFromString(contents)

  def handle(self): return self.handle_

  def set_handle(self, x):

    self.has_handle_ = 1

    self.handle_ = x

  def clear_handle(self):

    if self.has_handle_:

      self.has_handle_ = 0

      self.handle_ = 0

  def has_handle(self): return self.has_handle_

  def MergeFrom(self, x):

    assert x is not self

    if (x.has_handle()): self.set_handle(x.handle())

  def Equals(self, x):

    if x is self: return 1

    if self.has_handle_ != x.has_handle_: return 0

    if self.has_handle_ and self.handle_ != x.handle_: return 0

    return 1

  def IsInitialized(self, debug_strs=None):

    initialized = 1

    if (not self.has_handle_):

      initialized = 0

      if debug_strs is not None:

        debug_strs.append('Required field: handle not set.')

    return initialized

  def ByteSize(self):

    n = 0

    return n + 9

  def Clear(self):

    self.clear_handle()

  def OutputUnchecked(self, out):

    out.putVarInt32(9)

    out.put64(self.handle_)

  def TryMerge(self, d):

    while d.avail() > 0:

      tt = d.getVarInt32()

      if tt == 9:

        self.set_handle(d.get64())

        continue

      if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError

      d.skipData(tt)

  def __str__(self, prefix="", printElemNumber=0):

    res=""

    if self.has_handle_: res+=prefix+("handle: %s\n" % self.DebugFormatFixed64(self.handle_))

    return res

  khandle = 1

  _TEXT = (

   "ErrorCode",

   "handle",

  )

  _TYPES = (

   ProtocolBuffer.Encoder.NUMERIC,

   ProtocolBuffer.Encoder.DOUBLE,

  )

  _STYLE = """"""

  _STYLE_CONTENT_TYPE = """"""

class Query_Filter(ProtocolBuffer.ProtocolMessage):

  LESS_THAN    =    1

  LESS_THAN_OR_EQUAL =    2

  GREATER_THAN =    3

  GREATER_THAN_OR_EQUAL =    4

  EQUAL        =    5

  IN           =    6

  EXISTS       =    7

  _Operator_NAMES = {

    1: "LESS_THAN",

    2: "LESS_THAN_OR_EQUAL",

    3: "GREATER_THAN",

    4: "GREATER_THAN_OR_EQUAL",

    5: "EQUAL",

    6: "IN",

    7: "EXISTS",

  }

  def Operator_Name(cls, x): return cls._Operator_NAMES.get(x, "")

  Operator_Name = classmethod(Operator_Name)

  has_op_ = 0

  op_ = 0

  def __init__(self, contents=None):

    self.property_ = []

    if contents is not None: self.MergeFromString(contents)

  def op(self): return self.op_

  def set_op(self, x):

    self.has_op_ = 1

    self.op_ = x

  def clear_op(self):

    if self.has_op_:

      self.has_op_ = 0

      self.op_ = 0

  def has_op(self): return self.has_op_

  def property_size(self): return len(self.property_)

  def property_list(self): return self.property_

  def property(self, i):

    return self.property_[i]

  def mutable_property(self, i):

    return self.property_[i]

  def add_property(self):

    x = Property()

    self.property_.append(x)

    return x

  def clear_property(self):

    self.property_ = []

  def MergeFrom(self, x):

    assert x is not self

    if (x.has_op()): self.set_op(x.op())

    for i in xrange(x.property_size()): self.add_property().CopyFrom(x.property(i))

  def Equals(self, x):

    if x is self: return 1

    if self.has_op_ != x.has_op_: return 0

    if self.has_op_ and self.op_ != x.op_: return 0

    if len(self.property_) != len(x.property_): return 0

    for e1, e2 in zip(self.property_, x.property_):

      if e1 != e2: return 0

    return 1

  def IsInitialized(self, debug_strs=None):

    initialized = 1

    if (not self.has_op_):

      initialized = 0

      if debug_strs is not None:

        debug_strs.append('Required field: op not set.')

    for p in self.property_:

      if not p.IsInitialized(debug_strs): initialized=0

    return initialized

  def ByteSize(self):

    n = 0

    n += self.lengthVarInt64(self.op_)

    n += 1 * len(self.property_)

    for i in xrange(len(self.property_)): n += self.lengthString(self.property_[i].ByteSize())

    return n + 1

  def Clear(self):

    self.clear_op()

    self.clear_property()

  def OutputUnchecked(self, out):

    out.putVarInt32(48)

    out.putVarInt32(self.op_)

    for i in xrange(len(self.property_)):

      out.putVarInt32(114)

      out.putVarInt32(self.property_[i].ByteSize())

      self.property_[i].OutputUnchecked(out)

  def TryMerge(self, d):

    while 1:

      tt = d.getVarInt32()

      if tt == 36: break

      if tt == 48:

        self.set_op(d.getVarInt32())

        continue

      if tt == 114:

        length = d.getVarInt32()

        tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)

        d.skip(length)

        self.add_property().TryMerge(tmp)

        continue

      if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError

      d.skipData(tt)

  def __str__(self, prefix="", printElemNumber=0):

    res=""

    if self.has_op_: res+=prefix+("op: %s\n" % self.DebugFormatInt32(self.op_))

    cnt=0

    for e in self.property_:

      elm=""

      if printElemNumber: elm="(%d)" % cnt

      res+=prefix+("property%s <\n" % elm)

      res+=e.__str__(prefix + "  ", printElemNumber)

      res+=prefix+">\n"

      cnt+=1

    return res

class Query_Order(ProtocolBuffer.ProtocolMessage):

  ASCENDING    =    1

  DESCENDING   =    2

  _Direction_NAMES = {

    1: "ASCENDING",

    2: "DESCENDING",

  }

  def Direction_Name(cls, x): return cls._Direction_NAMES.get(x, "")

  Direction_Name = classmethod(Direction_Name)

  has_property_ = 0

  property_ = ""

  has_direction_ = 0

  direction_ = 1

  def __init__(self, contents=None):

    if contents is not None: self.MergeFromString(contents)

  def property(self): return self.property_

  def set_property(self, x):

    self.has_property_ = 1

    self.property_ = x

  def clear_property(self):

    if self.has_property_:

      self.has_property_ = 0

      self.property_ = ""

  def has_property(self): return self.has_property_

  def direction(self): return self.direction_

  def set_direction(self, x):

    self.has_direction_ = 1

    self.direction_ = x

  def clear_direction(self):

    if self.has_direction_:

      self.has_direction_ = 0

      self.direction_ = 1

  def has_direction(self): return self.has_direction_

  def MergeFrom(self, x):

    assert x is not self

    if (x.has_property()): self.set_property(x.property())

    if (x.has_direction()): self.set_direction(x.direction())

  def Equals(self, x):

    if x is self: return 1

    if self.has_property_ != x.has_property_: return 0

    if self.has_property_ and self.property_ != x.property_: return 0

    if self.has_direction_ != x.has_direction_: return 0

    if self.has_direction_ and self.direction_ != x.direction_: return 0

    return 1

  def IsInitialized(self, debug_strs=None):

    initialized = 1

    if (not self.has_property_):

      initialized = 0

      if debug_strs is not None:

        debug_strs.append('Required field: property not set.')

    return initialized

  def ByteSize(self):

    n = 0

    n += self.lengthString(len(self.property_))

    if (self.has_direction_): n += 1 + self.lengthVarInt64(self.direction_)

    return n + 1

  def Clear(self):

    self.clear_property()

    self.clear_direction()

  def OutputUnchecked(self, out):

    out.putVarInt32(82)

    out.putPrefixedString(self.property_)

    if (self.has_direction_):

      out.putVarInt32(88)

      out.putVarInt32(self.direction_)

  def TryMerge(self, d):

    while 1:

      tt = d.getVarInt32()

      if tt == 76: break

      if tt == 82:

        self.set_property(d.getPrefixedString())

        continue

      if tt == 88:

        self.set_direction(d.getVarInt32())

        continue

      if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError

      d.skipData(tt)

  def __str__(self, prefix="", printElemNumber=0):

    res=""

    if self.has_property_: res+=prefix+("property: %s\n" % self.DebugFormatString(self.property_))

    if self.has_direction_: res+=prefix+("direction: %s\n" % self.DebugFormatInt32(self.direction_))

    return res

class Query(ProtocolBuffer.ProtocolMessage):

  ORDER_FIRST  =    1

  ANCESTOR_FIRST =    2

  FILTER_FIRST =    3

  _Hint_NAMES = {

    1: "ORDER_FIRST",

    2: "ANCESTOR_FIRST",

    3: "FILTER_FIRST",

  }

  def Hint_Name(cls, x): return cls._Hint_NAMES.get(x, "")

  Hint_Name = classmethod(Hint_Name)

  has_app_ = 0

  app_ = ""

  has_kind_ = 0

  kind_ = ""

  has_ancestor_ = 0

  ancestor_ = None

  has_search_query_ = 0

  search_query_ = ""

  has_hint_ = 0

  hint_ = 0

  has_offset_ = 0

  offset_ = 0

  has_limit_ = 0

  limit_ = 0

  has_require_perfect_plan_ = 0

  require_perfect_plan_ = 0

  def __init__(self, contents=None):

    self.filter_ = []

    self.order_ = []

    self.composite_index_ = []

    self.lazy_init_lock_ = thread.allocate_lock()

    if contents is not None: self.MergeFromString(contents)

  def app(self): return self.app_

  def set_app(self, x):

    self.has_app_ = 1

    self.app_ = x

  def clear_app(self):

    if self.has_app_:

      self.has_app_ = 0

      self.app_ = ""

  def has_app(self): return self.has_app_

  def kind(self): return self.kind_

  def set_kind(self, x):

    self.has_kind_ = 1

    self.kind_ = x

  def clear_kind(self):

    if self.has_kind_:

      self.has_kind_ = 0

      self.kind_ = ""

  def has_kind(self): return self.has_kind_

  def ancestor(self):

    if self.ancestor_ is None:

      self.lazy_init_lock_.acquire()

      try:

        if self.ancestor_ is None: self.ancestor_ = Reference()

      finally:

        self.lazy_init_lock_.release()

    return self.ancestor_

  def mutable_ancestor(self): self.has_ancestor_ = 1; return self.ancestor()

  def clear_ancestor(self):

    if self.has_ancestor_:

      self.has_ancestor_ = 0;

      if self.ancestor_ is not None: self.ancestor_.Clear()

  def has_ancestor(self): return self.has_ancestor_

  def filter_size(self): return len(self.filter_)

  def filter_list(self): return self.filter_

  def filter(self, i):

    return self.filter_[i]

  def mutable_filter(self, i):

    return self.filter_[i]

  def add_filter(self):

    x = Query_Filter()

    self.filter_.append(x)

    return x

  def clear_filter(self):

    self.filter_ = []

  def search_query(self): return self.search_query_

  def set_search_query(self, x):

    self.has_search_query_ = 1

    self.search_query_ = x

  def clear_search_query(self):

    if self.has_search_query_:

      self.has_search_query_ = 0

      self.search_query_ = ""

  def has_search_query(self): return self.has_search_query_

  def order_size(self): return len(self.order_)

  def order_list(self): return self.order_

  def order(self, i):

    return self.order_[i]

  def mutable_order(self, i):

    return self.order_[i]

  def add_order(self):

    x = Query_Order()

    self.order_.append(x)

    return x

  def clear_order(self):

    self.order_ = []

  def hint(self): return self.hint_

  def set_hint(self, x):

    self.has_hint_ = 1

    self.hint_ = x

  def clear_hint(self):

    if self.has_hint_:

      self.has_hint_ = 0

      self.hint_ = 0

  def has_hint(self): return self.has_hint_

  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 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_ = 0

  def has_limit(self): return self.has_limit_

  def composite_index_size(self): return len(self.composite_index_)