#!/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.net.proto.RawMessage import RawMessage

from google.appengine.datastore.datastore_pb import PutRequest

from google.appengine.datastore.datastore_pb import DeleteRequest

from google.appengine.datastore.entity_pb import Reference

class Request(ProtocolBuffer.ProtocolMessage):

  has_service_name_ = 0

  service_name_ = ""

  has_method_ = 0

  method_ = ""

  has_request_ = 0

  def __init__(self, contents=None):

    self.request_ = RawMessage()

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

  def service_name(self): return self.service_name_

  def set_service_name(self, x):

    self.has_service_name_ = 1

    self.service_name_ = x

  def clear_service_name(self):

    if self.has_service_name_:

      self.has_service_name_ = 0

      self.service_name_ = ""

  def has_service_name(self): return self.has_service_name_

  def method(self): return self.method_

  def set_method(self, x):

    self.has_method_ = 1

    self.method_ = x

  def clear_method(self):

    if self.has_method_:

      self.has_method_ = 0

      self.method_ = ""

  def has_method(self): return self.has_method_

  def request(self): return self.request_

  def mutable_request(self): self.has_request_ = 1; return self.request_

  def clear_request(self):self.has_request_ = 0; self.request_.Clear()

  def has_request(self): return self.has_request_

  def MergeFrom(self, x):

    assert x is not self

    if (x.has_service_name()): self.set_service_name(x.service_name())

    if (x.has_method()): self.set_method(x.method())

    if (x.has_request()): self.mutable_request().MergeFrom(x.request())

  def Equals(self, x):

    if x is self: return 1

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

    if self.has_service_name_ and self.service_name_ != x.service_name_: return 0

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

    if self.has_method_ and self.method_ != x.method_: return 0

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

    if self.has_request_ and self.request_ != x.request_: return 0

    return 1

  def IsInitialized(self, debug_strs=None):

    initialized = 1

    if (not self.has_service_name_):

      initialized = 0

      if debug_strs is not None:

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

    if (not self.has_method_):

      initialized = 0

      if debug_strs is not None:

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

    if (not self.has_request_):

      initialized = 0

      if debug_strs is not None:

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

    elif not self.request_.IsInitialized(debug_strs): initialized = 0

    return initialized

  def ByteSize(self):

    n = 0

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

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

    n += self.lengthString(self.request_.ByteSize())

    return n + 3

  def Clear(self):

    self.clear_service_name()

    self.clear_method()

    self.clear_request()

  def OutputUnchecked(self, out):

    out.putVarInt32(18)

    out.putPrefixedString(self.service_name_)

    out.putVarInt32(26)

    out.putPrefixedString(self.method_)

    out.putVarInt32(34)

    out.putVarInt32(self.request_.ByteSize())

    self.request_.OutputUnchecked(out)

  def TryMerge(self, d):

    while d.avail() > 0:

      tt = d.getVarInt32()

      if tt == 18:

        self.set_service_name(d.getPrefixedString())

        continue

      if tt == 26:

        self.set_method(d.getPrefixedString())

        continue

      if tt == 34:

        length = d.getVarInt32()

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

        d.skip(length)

        self.mutable_request().TryMerge(tmp)

        continue

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

      d.skipData(tt)

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

    res=""

    if self.has_service_name_: res+=prefix+("service_name: %s\n" % self.DebugFormatString(self.service_name_))

    if self.has_method_: res+=prefix+("method: %s\n" % self.DebugFormatString(self.method_))

    if self.has_request_:

      res+=prefix+"request <\n"

      res+=self.request_.__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)])

  kservice_name = 2

  kmethod = 3

  krequest = 4

  _TEXT = _BuildTagLookupTable({

    0: "ErrorCode",

    2: "service_name",

    3: "method",

    4: "request",

  }, 4)

  _TYPES = _BuildTagLookupTable({

    0: ProtocolBuffer.Encoder.NUMERIC,

    2: ProtocolBuffer.Encoder.STRING,

    3: ProtocolBuffer.Encoder.STRING,

    4: ProtocolBuffer.Encoder.STRING,

  }, 4, ProtocolBuffer.Encoder.MAX_TYPE)

  _STYLE = """"""

  _STYLE_CONTENT_TYPE = """"""

class ApplicationError(ProtocolBuffer.ProtocolMessage):

  has_code_ = 0

  code_ = 0

  has_detail_ = 0

  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 detail(self): return self.detail_

  def set_detail(self, x):

    self.has_detail_ = 1

    self.detail_ = x

  def clear_detail(self):

    if self.has_detail_:

      self.has_detail_ = 0

      self.detail_ = ""

  def has_detail(self): return self.has_detail_

  def MergeFrom(self, x):

    assert x is not self

    if (x.has_code()): self.set_code(x.code())

    if (x.has_detail()): self.set_detail(x.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_detail_ != x.has_detail_: return 0

    if self.has_detail_ and self.detail_ != x.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.')

    if (not self.has_detail_):

      initialized = 0

      if debug_strs is not None:

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

    return initialized

  def ByteSize(self):

    n = 0

    n += self.lengthVarInt64(self.code_)

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

    return n + 2

  def Clear(self):

    self.clear_code()

    self.clear_detail()

  def OutputUnchecked(self, out):

    out.putVarInt32(8)

    out.putVarInt32(self.code_)

    out.putVarInt32(18)

    out.putPrefixedString(self.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_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_detail_: res+=prefix+("detail: %s\n" % self.DebugFormatString(self.detail_))

    return res

  def _BuildTagLookupTable(sparse, maxtag, default=None):

    return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])

  kcode = 1

  kdetail = 2

  _TEXT = _BuildTagLookupTable({

    0: "ErrorCode",

    1: "code",

    2: "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 = """"""

class Response(ProtocolBuffer.ProtocolMessage):

  has_response_ = 0

  response_ = None

  has_exception_ = 0

  exception_ = None

  has_application_error_ = 0

  application_error_ = None

  has_java_exception_ = 0

  java_exception_ = None

  def __init__(self, contents=None):

    self.lazy_init_lock_ = thread.allocate_lock()

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

  def response(self):

    if self.response_ is None:

      self.lazy_init_lock_.acquire()

      try:

        if self.response_ is None: self.response_ = RawMessage()

      finally:

        self.lazy_init_lock_.release()

    return self.response_

  def mutable_response(self): self.has_response_ = 1; return self.response()

  def clear_response(self):

    if self.has_response_:

      self.has_response_ = 0;

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

  def has_response(self): return self.has_response_

  def exception(self):

    if self.exception_ is None:

      self.lazy_init_lock_.acquire()

      try:

        if self.exception_ is None: self.exception_ = RawMessage()

      finally:

        self.lazy_init_lock_.release()

    return self.exception_

  def mutable_exception(self): self.has_exception_ = 1; return self.exception()

  def clear_exception(self):

    if self.has_exception_:

      self.has_exception_ = 0;

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

  def has_exception(self): return self.has_exception_

  def application_error(self):

    if self.application_error_ is None:

      self.lazy_init_lock_.acquire()

      try:

        if self.application_error_ is None: self.application_error_ = ApplicationError()

      finally:

        self.lazy_init_lock_.release()

    return self.application_error_

  def mutable_application_error(self): self.has_application_error_ = 1; return self.application_error()

  def clear_application_error(self):

    if self.has_application_error_:

      self.has_application_error_ = 0;

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

  def has_application_error(self): return self.has_application_error_

  def java_exception(self):

    if self.java_exception_ is None:

      self.lazy_init_lock_.acquire()

      try:

        if self.java_exception_ is None: self.java_exception_ = RawMessage()

      finally:

        self.lazy_init_lock_.release()

    return self.java_exception_

  def mutable_java_exception(self): self.has_java_exception_ = 1; return self.java_exception()

  def clear_java_exception(self):

    if self.has_java_exception_:

      self.has_java_exception_ = 0;

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

  def has_java_exception(self): return self.has_java_exception_

  def MergeFrom(self, x):

    assert x is not self

    if (x.has_response()): self.mutable_response().MergeFrom(x.response())

    if (x.has_exception()): self.mutable_exception().MergeFrom(x.exception())

    if (x.has_application_error()): self.mutable_application_error().MergeFrom(x.application_error())

    if (x.has_java_exception()): self.mutable_java_exception().MergeFrom(x.java_exception())

  def Equals(self, x):

    if x is self: return 1

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

    if self.has_response_ and self.response_ != x.response_: return 0

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

    if self.has_exception_ and self.exception_ != x.exception_: return 0

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

    if self.has_application_error_ and self.application_error_ != x.application_error_: return 0

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

    if self.has_java_exception_ and self.java_exception_ != x.java_exception_: return 0

    return 1

  def IsInitialized(self, debug_strs=None):

    initialized = 1

    if (self.has_response_ and not self.response_.IsInitialized(debug_strs)): initialized = 0

    if (self.has_exception_ and not self.exception_.IsInitialized(debug_strs)): initialized = 0

    if (self.has_application_error_ and not self.application_error_.IsInitialized(debug_strs)): initialized = 0

    if (self.has_java_exception_ and not self.java_exception_.IsInitialized(debug_strs)): initialized = 0

    return initialized

  def ByteSize(self):

    n = 0

    if (self.has_response_): n += 1 + self.lengthString(self.response_.ByteSize())

    if (self.has_exception_): n += 1 + self.lengthString(self.exception_.ByteSize())

    if (self.has_application_error_): n += 1 + self.lengthString(self.application_error_.ByteSize())

    if (self.has_java_exception_): n += 1 + self.lengthString(self.java_exception_.ByteSize())

    return n + 0

  def Clear(self):

    self.clear_response()

    self.clear_exception()

    self.clear_application_error()

    self.clear_java_exception()

  def OutputUnchecked(self, out):

    if (self.has_response_):

      out.putVarInt32(10)

      out.putVarInt32(self.response_.ByteSize())

      self.response_.OutputUnchecked(out)

    if (self.has_exception_):

      out.putVarInt32(18)

      out.putVarInt32(self.exception_.ByteSize())

      self.exception_.OutputUnchecked(out)

    if (self.has_application_error_):

      out.putVarInt32(26)

      out.putVarInt32(self.application_error_.ByteSize())

      self.application_error_.OutputUnchecked(out)

    if (self.has_java_exception_):

      out.putVarInt32(34)

      out.putVarInt32(self.java_exception_.ByteSize())

      self.java_exception_.OutputUnchecked(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_response().TryMerge(tmp)

        continue

      if tt == 18:

        length = d.getVarInt32()

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

        d.skip(length)

        self.mutable_exception().TryMerge(tmp)

        continue

      if tt == 26:

        length = d.getVarInt32()

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

        d.skip(length)

        self.mutable_application_error().TryMerge(tmp)

        continue

      if tt == 34:

        length = d.getVarInt32()

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

        d.skip(length)

        self.mutable_java_exception().TryMerge(tmp)

        continue

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

      d.skipData(tt)

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

    res=""

    if self.has_response_:

      res+=prefix+"response <\n"

      res+=self.response_.__str__(prefix + "  ", printElemNumber)

      res+=prefix+">\n"

    if self.has_exception_:

      res+=prefix+"exception <\n"

      res+=self.exception_.__str__(prefix + "  ", printElemNumber)

      res+=prefix+">\n"

    if self.has_application_error_:

      res+=prefix+"application_error <\n"

      res+=self.application_error_.__str__(prefix + "  ", printElemNumber)

      res+=prefix+">\n"

    if self.has_java_exception_:

      res+=prefix+"java_exception <\n"

      res+=self.java_exception_.__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)])

  kresponse = 1

  kexception = 2

  kapplication_error = 3

  kjava_exception = 4

  _TEXT = _BuildTagLookupTable({

    0: "ErrorCode",

    1: "response",

    2: "exception",

    3: "application_error",

    4: "java_exception",