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

  kservice_name = 2

  kmethod = 3

  krequest = 4

  _STYLE = """"""

  _STYLE_CONTENT_TYPE = """"""

class Response(ProtocolBuffer.ProtocolMessage):

  has_response_ = 0

  response_ = None

  has_exception_ = 0

  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 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())

  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

    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

    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())

    return n + 0

  def Clear(self):

    self.clear_response()

    self.clear_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)

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

    return res

  kresponse = 1

  kexception = 2