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

class MemcacheServiceError(ProtocolBuffer.ProtocolMessage):

  OK           =    0

  UNSPECIFIED_ERROR =    1

  _ErrorCode_NAMES = {

    0: "OK",

    1: "UNSPECIFIED_ERROR",

  }

  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 + 0

  def Clear(self):

    pass

  def OutputUnchecked(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 = """"""

class MemcacheGetRequest(ProtocolBuffer.ProtocolMessage):

  has_name_space_ = 0

  name_space_ = ""

  def __init__(self, contents=None):

    self.key_ = []

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

  def key_size(self): return len(self.key_)

  def key_list(self): return self.key_

  def key(self, i):

    return self.key_[i]

  def set_key(self, i, x):

    self.key_[i] = x

  def add_key(self, x):

    self.key_.append(x)

  def clear_key(self):

    self.key_ = []

  def name_space(self): return self.name_space_

  def set_name_space(self, x):

    self.has_name_space_ = 1

    self.name_space_ = x

  def clear_name_space(self):

    if self.has_name_space_:

      self.has_name_space_ = 0

      self.name_space_ = ""

  def has_name_space(self): return self.has_name_space_

  def MergeFrom(self, x):

    assert x is not self

    for i in xrange(x.key_size()): self.add_key(x.key(i))

    if (x.has_name_space()): self.set_name_space(x.name_space())

  def Equals(self, x):

    if x is self: return 1

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

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

      if e1 != e2: return 0

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

    if self.has_name_space_ and self.name_space_ != x.name_space_: return 0

    return 1

  def IsInitialized(self, debug_strs=None):

    initialized = 1

    return initialized

  def ByteSize(self):

    n = 0

    n += 1 * len(self.key_)

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

    if (self.has_name_space_): n += 1 + self.lengthString(len(self.name_space_))

    return n + 0

  def Clear(self):

    self.clear_key()

    self.clear_name_space()

  def OutputUnchecked(self, out):

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

      out.putVarInt32(10)

      out.putPrefixedString(self.key_[i])

    if (self.has_name_space_):

      out.putVarInt32(18)

      out.putPrefixedString(self.name_space_)

  def TryMerge(self, d):

    while d.avail() > 0:

      tt = d.getVarInt32()

      if tt == 10:

        self.add_key(d.getPrefixedString())

        continue

      if tt == 18:

        self.set_name_space(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.key_:

      elm=""

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

      res+=prefix+("key%s: %s\n" % (elm, self.DebugFormatString(e)))

      cnt+=1

    if self.has_name_space_: res+=prefix+("name_space: %s\n" % self.DebugFormatString(self.name_space_))

    return res

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

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

  kkey = 1

  kname_space = 2

  _TEXT = _BuildTagLookupTable({

    0: "ErrorCode",

    1: "key",

    2: "name_space",

  }, 2)

  _TYPES = _BuildTagLookupTable({

    0: ProtocolBuffer.Encoder.NUMERIC,

    1: ProtocolBuffer.Encoder.STRING,

    2: ProtocolBuffer.Encoder.STRING,

  }, 2, ProtocolBuffer.Encoder.MAX_TYPE)

  _STYLE = """"""

  _STYLE_CONTENT_TYPE = """"""

class MemcacheGetResponse_Item(ProtocolBuffer.ProtocolMessage):

  has_key_ = 0

  key_ = ""

  has_value_ = 0

  value_ = ""

  has_flags_ = 0

  flags_ = 0

  def __init__(self, contents=None):

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

  def key(self): return self.key_

  def set_key(self, x):

    self.has_key_ = 1

    self.key_ = x

  def clear_key(self):

    if self.has_key_:

      self.has_key_ = 0

      self.key_ = ""

  def has_key(self): return self.has_key_

  def value(self): return self.value_

  def set_value(self, x):

    self.has_value_ = 1

    self.value_ = x

  def clear_value(self):

    if self.has_value_:

      self.has_value_ = 0

      self.value_ = ""

  def has_value(self): return self.has_value_

  def flags(self): return self.flags_

  def set_flags(self, x):

    self.has_flags_ = 1

    self.flags_ = x

  def clear_flags(self):

    if self.has_flags_:

      self.has_flags_ = 0

      self.flags_ = 0

  def has_flags(self): return self.has_flags_

  def MergeFrom(self, x):

    assert x is not self

    if (x.has_key()): self.set_key(x.key())

    if (x.has_value()): self.set_value(x.value())

    if (x.has_flags()): self.set_flags(x.flags())

  def Equals(self, x):

    if x is self: return 1

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

    if self.has_key_ and self.key_ != x.key_: return 0

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

    if self.has_value_ and self.value_ != x.value_: return 0

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

    if self.has_flags_ and self.flags_ != x.flags_: return 0

    return 1

  def IsInitialized(self, debug_strs=None):

    initialized = 1

    if (not self.has_key_):

      initialized = 0

      if debug_strs is not None:

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

    if (not self.has_value_):

      initialized = 0

      if debug_strs is not None:

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

    return initialized

  def ByteSize(self):

    n = 0

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

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

    if (self.has_flags_): n += 5

    return n + 2

  def Clear(self):

    self.clear_key()

    self.clear_value()

    self.clear_flags()

  def OutputUnchecked(self, out):

    out.putVarInt32(18)

    out.putPrefixedString(self.key_)

    out.putVarInt32(26)

    out.putPrefixedString(self.value_)

    if (self.has_flags_):

      out.putVarInt32(37)

      out.put32(self.flags_)

  def TryMerge(self, d):

    while 1:

      tt = d.getVarInt32()

      if tt == 12: break

      if tt == 18:

        self.set_key(d.getPrefixedString())

        continue

      if tt == 26:

        self.set_value(d.getPrefixedString())

        continue

      if tt == 37:

        self.set_flags(d.get32())

        continue

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

      d.skipData(tt)

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

    res=""

    if self.has_key_: res+=prefix+("key: %s\n" % self.DebugFormatString(self.key_))

    if self.has_value_: res+=prefix+("value: %s\n" % self.DebugFormatString(self.value_))

    if self.has_flags_: res+=prefix+("flags: %s\n" % self.DebugFormatFixed32(self.flags_))

    return res

class MemcacheGetResponse(ProtocolBuffer.ProtocolMessage):

  def __init__(self, contents=None):

    self.item_ = []

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

  def item_size(self): return len(self.item_)

  def item_list(self): return self.item_

  def item(self, i):

    return self.item_[i]

  def mutable_item(self, i):

    return self.item_[i]

  def add_item(self):

    x = MemcacheGetResponse_Item()

    self.item_.append(x)

    return x

  def clear_item(self):

    self.item_ = []

  def MergeFrom(self, x):

    assert x is not self

    for i in xrange(x.item_size()): self.add_item().CopyFrom(x.item(i))

  def Equals(self, x):

    if x is self: return 1

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

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

      if e1 != e2: return 0

    return 1

  def IsInitialized(self, debug_strs=None):

    initialized = 1

    for p in self.item_:

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

    return initialized

  def ByteSize(self):

    n = 0

    n += 2 * len(self.item_)

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

    return n + 0

  def Clear(self):

    self.clear_item()

  def OutputUnchecked(self, out):

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

      out.putVarInt32(11)

      self.item_[i].OutputUnchecked(out)

      out.putVarInt32(12)

  def TryMerge(self, d):

    while d.avail() > 0:

      tt = d.getVarInt32()

      if tt == 11:

        self.add_item().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.item_:

      elm=""

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

      res+=prefix+("Item%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)])

  kItemGroup = 1

  kItemkey = 2

  kItemvalue = 3

  kItemflags = 4

  _TEXT = _BuildTagLookupTable({

    0: "ErrorCode",

    1: "Item",

    2: "key",

    3: "value",

    4: "flags",

  }, 4)

  _TYPES = _BuildTagLookupTable({

    0: ProtocolBuffer.Encoder.NUMERIC,

    1: ProtocolBuffer.Encoder.STARTGROUP,

    2: ProtocolBuffer.Encoder.STRING,

    3: ProtocolBuffer.Encoder.STRING,

    4: ProtocolBuffer.Encoder.FLOAT,

  }, 4, ProtocolBuffer.Encoder.MAX_TYPE)

  _STYLE = """"""

  _STYLE_CONTENT_TYPE = """"""

class MemcacheSetRequest_Item(ProtocolBuffer.ProtocolMessage):

  has_key_ = 0

  key_ = ""

  has_value_ = 0

  value_ = ""

  has_flags_ = 0

  flags_ = 0

  has_set_policy_ = 0

  set_policy_ = 1

  has_expiration_time_ = 0

  expiration_time_ = 0

  def __init__(self, contents=None):

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

  def key(self): return self.key_

  def set_key(self, x):

    self.has_key_ = 1

    self.key_ = x

  def clear_key(self):

    if self.has_key_:

      self.has_key_ = 0

      self.key_ = ""

  def has_key(self): return self.has_key_

  def value(self): return self.value_

  def set_value(self, x):

    self.has_value_ = 1

    self.value_ = x

  def clear_value(self):

    if self.has_value_:

      self.has_value_ = 0

      self.value_ = ""

  def has_value(self): return self.has_value_

  def flags(self): return self.flags_

  def set_flags(self, x):

    self.has_flags_ = 1

    self.flags_ = x

  def clear_flags(self):

    if self.has_flags_:

      self.has_flags_ = 0

      self.flags_ = 0

  def has_flags(self): return self.has_flags_

  def set_policy(self): return self.set_policy_

  def set_set_policy(self, x):

    self.has_set_policy_ = 1

    self.set_policy_ = x

  def clear_set_policy(self):

    if self.has_set_policy_:

      self.has_set_policy_ = 0

      self.set_policy_ = 1

  def has_set_policy(self): return self.has_set_policy_

  def expiration_time(self): return self.expiration_time_

  def set_expiration_time(self, x):

    self.has_expiration_time_ = 1

    self.expiration_time_ = x

  def clear_expiration_time(self):

    if self.has_expiration_time_:

      self.has_expiration_time_ = 0

      self.expiration_time_ = 0

  def has_expiration_time(self): return self.has_expiration_time_