| #!/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 * |
| 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 |
| |
| |
| _TEXT = ( |
| "ErrorCode", |
| ) |
| |
| _TYPES = ( |
| ProtocolBuffer.Encoder.NUMERIC, |
| ) |
| |
| _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 |
| |
| kkey = 1 |
| kname_space = 2 |
| |
| _TEXT = ( |
| "ErrorCode", |
| "key", |
| "name_space", |
| ) |
| |
| _TYPES = ( |
| ProtocolBuffer.Encoder.NUMERIC, |
| ProtocolBuffer.Encoder.STRING, |
| |
| ProtocolBuffer.Encoder.STRING, |
| |
| ) |
| |
| _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 |
| |
| kItemGroup = 1 |
| kItemkey = 2 |
| kItemvalue = 3 |
| kItemflags = 4 |
| |
| _TEXT = ( |
| "ErrorCode", |
| "Item", |
| "key", |
| "value", |
| "flags", |
| ) |
| |
| _TYPES = ( |
| ProtocolBuffer.Encoder.NUMERIC, |
| ProtocolBuffer.Encoder.STARTGROUP, |
| |
| ProtocolBuffer.Encoder.STRING, |
| |
| ProtocolBuffer.Encoder.STRING, |
| |
| ProtocolBuffer.Encoder.FLOAT, |
| |
| ) |
| |
| _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_ |
| |
| |
| 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()) |
| if (x.has_set_policy()): self.set_set_policy(x.set_policy()) |
| if (x.has_expiration_time()): self.set_expiration_time(x.expiration_time()) |
| |
| 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 |
| if self.has_set_policy_ != x.has_set_policy_: return 0 |
| if self.has_set_policy_ and self.set_policy_ != x.set_policy_: return 0 |
| if self.has_expiration_time_ != x.has_expiration_time_: return 0 |
| if self.has_expiration_time_ and self.expiration_time_ != x.expiration_time_: 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 |
| if (self.has_set_policy_): n += 1 + self.lengthVarInt64(self.set_policy_) |
| if (self.has_expiration_time_): n += 5 |
| return n + 2 |
| |
| def Clear(self): |
| self.clear_key() |
| self.clear_value() |
| self.clear_flags() |
| self.clear_set_policy() |
| self.clear_expiration_time() |
| |
| 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_) |
| if (self.has_set_policy_): |
| out.putVarInt32(40) |
| out.putVarInt32(self.set_policy_) |
| if (self.has_expiration_time_): |
| out.putVarInt32(53) |
| out.put32(self.expiration_time_) |
| |
| 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 == 40: |
| self.set_set_policy(d.getVarInt32()) |
| continue |
| if tt == 53: |
| self.set_expiration_time(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_)) |
| if self.has_set_policy_: res+=prefix+("set_policy: %s\n" % self.DebugFormatInt32(self.set_policy_)) |
| if self.has_expiration_time_: res+=prefix+("expiration_time: %s\n" % self.DebugFormatFixed32(self.expiration_time_)) |
| return res |
| |
| class MemcacheSetRequest(ProtocolBuffer.ProtocolMessage): |
| |
| SET = 1 |
| ADD = 2 |
| REPLACE = 3 |
| |
| _SetPolicy_NAMES = { |
| 1: "SET", |
| 2: "ADD", |
| 3: "REPLACE", |
| } |
| |
| def SetPolicy_Name(cls, x): return cls._SetPolicy_NAMES.get(x, "") |
| SetPolicy_Name = classmethod(SetPolicy_Name) |
| |
| has_name_space_ = 0 |
| name_space_ = "" |
| |
| 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 = MemcacheSetRequest_Item() |
| self.item_.append(x) |
| return x |
| |
| def clear_item(self): |
| self.item_ = [] |
| 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.item_size()): self.add_item().CopyFrom(x.item(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.item_) != len(x.item_): return 0 |
| for e1, e2 in zip(self.item_, x.item_): |
| 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 |
| 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() |
| if (self.has_name_space_): n += 1 + self.lengthString(len(self.name_space_)) |
| return n + 0 |
| |
| def Clear(self): |
| self.clear_item() |
| self.clear_name_space() |
| |
| def OutputUnchecked(self, out): |
| for i in xrange(len(self.item_)): |
| out.putVarInt32(11) |
| self.item_[i].OutputUnchecked(out) |
| out.putVarInt32(12) |
| if (self.has_name_space_): |
| out.putVarInt32(58) |
| out.putPrefixedString(self.name_space_) |
| |
| def TryMerge(self, d): |
| while d.avail() > 0: |
| tt = d.getVarInt32() |
| if tt == 11: |
| self.add_item().TryMerge(d) |
| continue |
| if tt == 58: |
| 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.item_: |
| elm="" |
| if printElemNumber: elm="(%d)" % cnt |
| res+=prefix+("Item%s {\n" % elm) |
| res+=e.__str__(prefix + " ", printElemNumber) |
| res+=prefix+"}\n" |
| cnt+=1 |
| if self.has_name_space_: res+=prefix+("name_space: %s\n" % self.DebugFormatString(self.name_space_)) |
| return res |
| |
| kItemGroup = 1 |
| kItemkey = 2 |
| kItemvalue = 3 |
| kItemflags = 4 |
| kItemset_policy = 5 |
| kItemexpiration_time = 6 |
| kname_space = 7 |
| |
| _TEXT = ( |
| "ErrorCode", |
| "Item", |
| "key", |
| "value", |
| "flags", |
| "set_policy", |
| "expiration_time", |
| "name_space", |
| ) |
| |
| _TYPES = ( |
| ProtocolBuffer.Encoder.NUMERIC, |
| ProtocolBuffer.Encoder.STARTGROUP, |
| |
| ProtocolBuffer.Encoder.STRING, |
| |
| ProtocolBuffer.Encoder.STRING, |
| |
| ProtocolBuffer.Encoder.FLOAT, |
| |
| ProtocolBuffer.Encoder.NUMERIC, |
| |
| ProtocolBuffer.Encoder.FLOAT, |
| |
| ProtocolBuffer.Encoder.STRING, |
| |
| ) |
| |
| _STYLE = """""" |
| _STYLE_CONTENT_TYPE = """""" |
| class MemcacheSetResponse(ProtocolBuffer.ProtocolMessage): |
| |
| STORED = 1 |
| NOT_STORED = 2 |
| ERROR = 3 |
| |
| _SetStatusCode_NAMES = { |
| 1: "STORED", |
| 2: "NOT_STORED", |
| 3: "ERROR", |
| } |
| |
| def SetStatusCode_Name(cls, x): return cls._SetStatusCode_NAMES.get(x, "") |
| SetStatusCode_Name = classmethod(SetStatusCode_Name) |
| |
| |
| def __init__(self, contents=None): |
| self.set_status_ = [] |
| if contents is not None: self.MergeFromString(contents) |
| |
| def set_status_size(self): return len(self.set_status_) |
| def set_status_list(self): return self.set_status_ |
| |
| def set_status(self, i): |
| return self.set_status_[i] |
| |
| def set_set_status(self, i, x): |
| self.set_status_[i] = x |
| |
| def add_set_status(self, x): |
| self.set_status_.append(x) |
| |
| def clear_set_status(self): |
| self.set_status_ = [] |
| |
| |
| def MergeFrom(self, x): |
| assert x is not self |
| for i in xrange(x.set_status_size()): self.add_set_status(x.set_status(i)) |
| |
| def Equals(self, x): |
| if x is self: return 1 |
| if len(self.set_status_) != len(x.set_status_): return 0 |
| for e1, e2 in zip(self.set_status_, x.set_status_): |
| if e1 != e2: return 0 |
| return 1 |
| |
| def IsInitialized(self, debug_strs=None): |
| initialized = 1 |
| return initialized |
| |
| def ByteSize(self): |
| n = 0 |
| n += 1 * len(self.set_status_) |
| for i in xrange(len(self.set_status_)): n += self.lengthVarInt64(self.set_status_[i]) |
| return n + 0 |
| |
| def Clear(self): |
| self.clear_set_status() |
| |
| def OutputUnchecked(self, out): |
| for i in xrange(len(self.set_status_)): |
| out.putVarInt32(8) |
| out.putVarInt32(self.set_status_[i]) |
| |
| def TryMerge(self, d): |
| while d.avail() > 0: |
| tt = d.getVarInt32() |
| if tt == 8: |
| self.add_set_status(d.getVarInt32()) |
| continue |
| if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError |
| d.skipData(tt) |
| |
| |
| def __str__(self, prefix="", printElemNumber=0): |
| res="" |
| cnt=0 |
| for e in self.set_status_: |
| elm="" |
| if printElemNumber: elm="(%d)" % cnt |
| res+=prefix+("set_status%s: %s\n" % (elm, self.DebugFormatInt32(e))) |
| cnt+=1 |
| return res |
| |
| kset_status = 1 |
| |
| _TEXT = ( |
| "ErrorCode", |
| "set_status", |
| ) |
| |
| _TYPES = ( |
| ProtocolBuffer.Encoder.NUMERIC, |
| ProtocolBuffer.Encoder.NUMERIC, |
| |
| ) |
| |
| _STYLE = """""" |
| _STYLE_CONTENT_TYPE = """""" |
| class MemcacheDeleteRequest_Item(ProtocolBuffer.ProtocolMessage): |
| has_key_ = 0 |
| key_ = "" |
| has_delete_time_ = 0 |
| delete_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 delete_time(self): return self.delete_time_ |
| |
| def set_delete_time(self, x): |
| self.has_delete_time_ = 1 |
| self.delete_time_ = x |
| |
| def clear_delete_time(self): |
| if self.has_delete_time_: |
| self.has_delete_time_ = 0 |
| self.delete_time_ = 0 |
| |
| def has_delete_time(self): return self.has_delete_time_ |
| |
| |
| def MergeFrom(self, x): |
| assert x is not self |
| if (x.has_key()): self.set_key(x.key()) |
| if (x.has_delete_time()): self.set_delete_time(x.delete_time()) |
| |
| 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_delete_time_ != x.has_delete_time_: return 0 |
| if self.has_delete_time_ and self.delete_time_ != x.delete_time_: 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.') |
| return initialized |
| |
| def ByteSize(self): |
| n = 0 |
| n += self.lengthString(len(self.key_)) |
| if (self.has_delete_time_): n += 5 |
| return n + 1 |
| |
| def Clear(self): |
| self.clear_key() |
| self.clear_delete_time() |
| |
| def OutputUnchecked(self, out): |
| out.putVarInt32(18) |
| out.putPrefixedString(self.key_) |
| if (self.has_delete_time_): |
| out.putVarInt32(29) |
| out.put32(self.delete_time_) |
| |
| def TryMerge(self, d): |
| while 1: |
| tt = d.getVarInt32() |
| if tt == 12: break |
| if tt == 18: |
| self.set_key(d.getPrefixedString()) |
| continue |
| if tt == 29: |
| self.set_delete_time(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_delete_time_: res+=prefix+("delete_time: %s\n" % self.DebugFormatFixed32(self.delete_time_)) |
| return res |
| |
| class MemcacheDeleteRequest(ProtocolBuffer.ProtocolMessage): |
| has_name_space_ = 0 |
| name_space_ = "" |
| |
| 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 = MemcacheDeleteRequest_Item() |
| self.item_.append(x) |
| return x |
| |
| def clear_item(self): |
| self.item_ = [] |
| 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.item_size()): self.add_item().CopyFrom(x.item(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.item_) != len(x.item_): return 0 |
| for e1, e2 in zip(self.item_, x.item_): |
| 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 |
| 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() |
| if (self.has_name_space_): n += 1 + self.lengthString(len(self.name_space_)) |
| return n + 0 |
| |
| def Clear(self): |
| self.clear_item() |
| self.clear_name_space() |
| |
| def OutputUnchecked(self, out): |
| for i in xrange(len(self.item_)): |
| out.putVarInt32(11) |
| self.item_[i].OutputUnchecked(out) |
| out.putVarInt32(12) |
| if (self.has_name_space_): |
| out.putVarInt32(34) |
| out.putPrefixedString(self.name_space_) |
| |
| def TryMerge(self, d): |
| while d.avail() > 0: |
| tt = d.getVarInt32() |
| if tt == 11: |
| self.add_item().TryMerge(d) |
| continue |
| if tt == 34: |
| 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.item_: |
| elm="" |
| if printElemNumber: elm="(%d)" % cnt |
| res+=prefix+("Item%s {\n" % elm) |
| res+=e.__str__(prefix + " ", printElemNumber) |
| res+=prefix+"}\n" |
| cnt+=1 |
| if self.has_name_space_: res+=prefix+("name_space: %s\n" % self.DebugFormatString(self.name_space_)) |
| return res |
| |
| kItemGroup = 1 |
| kItemkey = 2 |
| kItemdelete_time = 3 |
| kname_space = 4 |
| |
| _TEXT = ( |
| "ErrorCode", |
| "Item", |
| "key", |
| "delete_time", |
| "name_space", |
| ) |
| |
| _TYPES = ( |
| ProtocolBuffer.Encoder.NUMERIC, |
| ProtocolBuffer.Encoder.STARTGROUP, |
| |
| ProtocolBuffer.Encoder.STRING, |
| |
| ProtocolBuffer.Encoder.FLOAT, |
| |
| ProtocolBuffer.Encoder.STRING, |
| |
| ) |
| |
| _STYLE = """""" |
| _STYLE_CONTENT_TYPE = """""" |
| class MemcacheDeleteResponse(ProtocolBuffer.ProtocolMessage): |
| |
| DELETED = 1 |
| NOT_FOUND = 2 |
| |
| _DeleteStatusCode_NAMES = { |
| 1: "DELETED", |
| 2: "NOT_FOUND", |
| } |
| |
| def DeleteStatusCode_Name(cls, x): return cls._DeleteStatusCode_NAMES.get(x, "") |
| DeleteStatusCode_Name = classmethod(DeleteStatusCode_Name) |
| |
| |
| def __init__(self, contents=None): |
| self.delete_status_ = [] |
| if contents is not None: self.MergeFromString(contents) |
| |
| def delete_status_size(self): return len(self.delete_status_) |
| def delete_status_list(self): return self.delete_status_ |
| |
| def delete_status(self, i): |
| return self.delete_status_[i] |
| |
| def set_delete_status(self, i, x): |
| self.delete_status_[i] = x |
| |
| def add_delete_status(self, x): |
| self.delete_status_.append(x) |
| |
| def clear_delete_status(self): |
| self.delete_status_ = [] |
| |
| |
| def MergeFrom(self, x): |
| assert x is not self |
| for i in xrange(x.delete_status_size()): self.add_delete_status(x.delete_status(i)) |
| |
| def Equals(self, x): |
| if x is self: return 1 |
| if len(self.delete_status_) != len(x.delete_status_): return 0 |
| for e1, e2 in zip(self.delete_status_, x.delete_status_): |
| if e1 != e2: return 0 |
| return 1 |
| |
| def IsInitialized(self, debug_strs=None): |
| initialized = 1 |
| return initialized |
| |
| def ByteSize(self): |
| n = 0 |
| n += 1 * len(self.delete_status_) |
| for i in xrange(len(self.delete_status_)): n += self.lengthVarInt64(self.delete_status_[i]) |
| return n + 0 |
| |
| def Clear(self): |
| self.clear_delete_status() |
| |
| def OutputUnchecked(self, out): |
| for i in xrange(len(self.delete_status_)): |
| out.putVarInt32(8) |
| out.putVarInt32(self.delete_status_[i]) |
| |
| def TryMerge(self, d): |
| while d.avail() > 0: |
| tt = d.getVarInt32() |
| if tt == 8: |
| self.add_delete_status(d.getVarInt32()) |
| continue |
| if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError |
| d.skipData(tt) |
| |
| |
| def __str__(self, prefix="", printElemNumber=0): |
| res="" |
| cnt=0 |
| for e in self.delete_status_: |
| elm="" |
| if printElemNumber: elm="(%d)" % cnt |
| res+=prefix+("delete_status%s: %s\n" % (elm, self.DebugFormatInt32(e))) |
| cnt+=1 |
| return res |
| |
| kdelete_status = 1 |
| |
| _TEXT = ( |
| "ErrorCode", |
| "delete_status", |
| ) |
| |
| _TYPES = ( |
| ProtocolBuffer.Encoder.NUMERIC, |
| ProtocolBuffer.Encoder.NUMERIC, |
| |
| ) |
| |
| _STYLE = """""" |
| _STYLE_CONTENT_TYPE = """""" |
| class MemcacheIncrementRequest(ProtocolBuffer.ProtocolMessage): |
| |
| INCREMENT = 1 |
| DECREMENT = 2 |
| |
| _Direction_NAMES = { |
| 1: "INCREMENT", |
| 2: "DECREMENT", |
| } |
| |
| def Direction_Name(cls, x): return cls._Direction_NAMES.get(x, "") |
| Direction_Name = classmethod(Direction_Name) |
| |
| has_key_ = 0 |
| key_ = "" |
| has_name_space_ = 0 |
| name_space_ = "" |
| has_delta_ = 0 |
| delta_ = 1 |
| has_direction_ = 0 |
| direction_ = 1 |
| |
| 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 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 delta(self): return self.delta_ |
| |
| def set_delta(self, x): |
| self.has_delta_ = 1 |
| self.delta_ = x |
| |
| def clear_delta(self): |
| if self.has_delta_: |
| self.has_delta_ = 0 |
| self.delta_ = 1 |
| |
| def has_delta(self): return self.has_delta_ |
| |
| 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_key()): self.set_key(x.key()) |
| if (x.has_name_space()): self.set_name_space(x.name_space()) |
| if (x.has_delta()): self.set_delta(x.delta()) |
| if (x.has_direction()): self.set_direction(x.direction()) |
| |
| 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_name_space_ != x.has_name_space_: return 0 |
| if self.has_name_space_ and self.name_space_ != x.name_space_: return 0 |
| if self.has_delta_ != x.has_delta_: return 0 |
| if self.has_delta_ and self.delta_ != x.delta_: 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_key_): |
| initialized = 0 |
| if debug_strs is not None: |
| debug_strs.append('Required field: key not set.') |
| return initialized |
| |
| def ByteSize(self): |
| n = 0 |
| n += self.lengthString(len(self.key_)) |
| if (self.has_name_space_): n += 1 + self.lengthString(len(self.name_space_)) |
| if (self.has_delta_): n += 1 + self.lengthVarInt64(self.delta_) |
| if (self.has_direction_): n += 1 + self.lengthVarInt64(self.direction_) |
| return n + 1 |
| |
| def Clear(self): |
| self.clear_key() |
| self.clear_name_space() |
| self.clear_delta() |
| self.clear_direction() |
| |
| def OutputUnchecked(self, out): |
| out.putVarInt32(10) |
| out.putPrefixedString(self.key_) |
| if (self.has_delta_): |
| out.putVarInt32(16) |
| out.putVarUint64(self.delta_) |
| if (self.has_direction_): |
| out.putVarInt32(24) |
| out.putVarInt32(self.direction_) |
| if (self.has_name_space_): |
| out.putVarInt32(34) |
| out.putPrefixedString(self.name_space_) |
| |
| def TryMerge(self, d): |
| while d.avail() > 0: |
| tt = d.getVarInt32() |
| if tt == 10: |
| self.set_key(d.getPrefixedString()) |
| continue |
| if tt == 16: |
| self.set_delta(d.getVarUint64()) |
| continue |
| if tt == 24: |
| self.set_direction(d.getVarInt32()) |
| continue |
| if tt == 34: |
| self.set_name_space(d.getPrefixedString()) |
| 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_name_space_: res+=prefix+("name_space: %s\n" % self.DebugFormatString(self.name_space_)) |
| if self.has_delta_: res+=prefix+("delta: %s\n" % self.DebugFormatInt64(self.delta_)) |
| if self.has_direction_: res+=prefix+("direction: %s\n" % self.DebugFormatInt32(self.direction_)) |
| return res |
| |
| kkey = 1 |
| kname_space = 4 |
| kdelta = 2 |
| kdirection = 3 |
| |
| _TEXT = ( |
| "ErrorCode", |
| "key", |
| "delta", |
| "direction", |
| "name_space", |
| ) |
| |
| _TYPES = ( |
| ProtocolBuffer.Encoder.NUMERIC, |
| ProtocolBuffer.Encoder.STRING, |
| |
| ProtocolBuffer.Encoder.NUMERIC, |
| |
| ProtocolBuffer.Encoder.NUMERIC, |
| |
| ProtocolBuffer.Encoder.STRING, |
| |
| ) |
| |
| _STYLE = """""" |
| _STYLE_CONTENT_TYPE = """""" |
| class MemcacheIncrementResponse(ProtocolBuffer.ProtocolMessage): |
| has_new_value_ = 0 |
| new_value_ = 0 |
| |
| def __init__(self, contents=None): |
| if contents is not None: self.MergeFromString(contents) |
| |
| def new_value(self): return self.new_value_ |
| |
| def set_new_value(self, x): |
| self.has_new_value_ = 1 |
| self.new_value_ = x |
| |
| def clear_new_value(self): |
| if self.has_new_value_: |
| self.has_new_value_ = 0 |
| self.new_value_ = 0 |
| |
| def has_new_value(self): return self.has_new_value_ |
| |
| |
| def MergeFrom(self, x): |
| assert x is not self |
| if (x.has_new_value()): self.set_new_value(x.new_value()) |
| |
| def Equals(self, x): |
| if x is self: return 1 |
| if self.has_new_value_ != x.has_new_value_: return 0 |
| if self.has_new_value_ and self.new_value_ != x.new_value_: return 0 |
| return 1 |
| |
| def IsInitialized(self, debug_strs=None): |
| initialized = 1 |
| return initialized |
| |
| def ByteSize(self): |
| n = 0 |
| if (self.has_new_value_): n += 1 + self.lengthVarInt64(self.new_value_) |
| return n + 0 |
| |
| def Clear(self): |
| self.clear_new_value() |
| |
| def OutputUnchecked(self, out): |
| if (self.has_new_value_): |
| out.putVarInt32(8) |
| out.putVarUint64(self.new_value_) |
| |
| def TryMerge(self, d): |
| while d.avail() > 0: |
| tt = d.getVarInt32() |
| if tt == 8: |
| self.set_new_value(d.getVarUint64()) |
| continue |
| if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError |
| d.skipData(tt) |
| |
| |
| def __str__(self, prefix="", printElemNumber=0): |
| res="" |
| if self.has_new_value_: res+=prefix+("new_value: %s\n" % self.DebugFormatInt64(self.new_value_)) |
| return res |
| |
| knew_value = 1 |
| |
| _TEXT = ( |
| "ErrorCode", |
| "new_value", |
| ) |
| |
| _TYPES = ( |
| ProtocolBuffer.Encoder.NUMERIC, |
| ProtocolBuffer.Encoder.NUMERIC, |
| |
| ) |
| |
| _STYLE = """""" |
| _STYLE_CONTENT_TYPE = """""" |
| class MemcacheFlushRequest(ProtocolBuffer.ProtocolMessage): |
| |
| 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 |
| |
| |
| _TEXT = ( |
| "ErrorCode", |
| ) |
| |
| _TYPES = ( |
| ProtocolBuffer.Encoder.NUMERIC, |
| ) |
| |
| _STYLE = """""" |
| _STYLE_CONTENT_TYPE = """""" |
| class MemcacheFlushResponse(ProtocolBuffer.ProtocolMessage): |
| |
| 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 |
| |
| |
| _TEXT = ( |
| "ErrorCode", |
| ) |
| |
| _TYPES = ( |
| ProtocolBuffer.Encoder.NUMERIC, |
| ) |
| |
| _STYLE = """""" |
| _STYLE_CONTENT_TYPE = """""" |
| class MemcacheStatsRequest(ProtocolBuffer.ProtocolMessage): |
| |
| 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 |
| |
| |
| _TEXT = ( |
| "ErrorCode", |
| ) |
| |
| _TYPES = ( |
| ProtocolBuffer.Encoder.NUMERIC, |
| ) |
| |
| _STYLE = """""" |
| _STYLE_CONTENT_TYPE = """""" |
| class MergedNamespaceStats(ProtocolBuffer.ProtocolMessage): |
| has_hits_ = 0 |
| hits_ = 0 |
| has_misses_ = 0 |
| misses_ = 0 |
| has_byte_hits_ = 0 |
| byte_hits_ = 0 |
| has_items_ = 0 |
| items_ = 0 |
| has_bytes_ = 0 |
| bytes_ = 0 |
| has_oldest_item_age_ = 0 |
| oldest_item_age_ = 0 |
| |
| def __init__(self, contents=None): |
| if contents is not None: self.MergeFromString(contents) |
| |
| def hits(self): return self.hits_ |
| |
| def set_hits(self, x): |
| self.has_hits_ = 1 |
| self.hits_ = x |
| |
| def clear_hits(self): |
| if self.has_hits_: |
| self.has_hits_ = 0 |
| self.hits_ = 0 |
| |
| def has_hits(self): return self.has_hits_ |
| |
| def misses(self): return self.misses_ |
| |
| def set_misses(self, x): |
| self.has_misses_ = 1 |
| self.misses_ = x |
| |
| def clear_misses(self): |
| if self.has_misses_: |
| self.has_misses_ = 0 |
| self.misses_ = 0 |
| |
| def has_misses(self): return self.has_misses_ |
| |
| def byte_hits(self): return self.byte_hits_ |
| |
| def set_byte_hits(self, x): |
| self.has_byte_hits_ = 1 |
| self.byte_hits_ = x |
| |
| def clear_byte_hits(self): |
| if self.has_byte_hits_: |
| self.has_byte_hits_ = 0 |
| self.byte_hits_ = 0 |
| |
| def has_byte_hits(self): return self.has_byte_hits_ |
| |
| def items(self): return self.items_ |
| |
| def set_items(self, x): |
| self.has_items_ = 1 |
| self.items_ = x |
| |
| def clear_items(self): |
| if self.has_items_: |
| self.has_items_ = 0 |
| self.items_ = 0 |
| |
| def has_items(self): return self.has_items_ |
| |
| def bytes(self): return self.bytes_ |
| |
| def set_bytes(self, x): |
| self.has_bytes_ = 1 |
| self.bytes_ = x |
| |
| def clear_bytes(self): |
| if self.has_bytes_: |
| self.has_bytes_ = 0 |
| self.bytes_ = 0 |
| |
| def has_bytes(self): return self.has_bytes_ |
| |
| def oldest_item_age(self): return self.oldest_item_age_ |
| |
| def set_oldest_item_age(self, x): |
| self.has_oldest_item_age_ = 1 |
| self.oldest_item_age_ = x |
| |
| def clear_oldest_item_age(self): |
| if self.has_oldest_item_age_: |
| self.has_oldest_item_age_ = 0 |
| self.oldest_item_age_ = 0 |
| |
| def has_oldest_item_age(self): return self.has_oldest_item_age_ |
| |
| |
| def MergeFrom(self, x): |
| assert x is not self |
| if (x.has_hits()): self.set_hits(x.hits()) |
| if (x.has_misses()): self.set_misses(x.misses()) |
| if (x.has_byte_hits()): self.set_byte_hits(x.byte_hits()) |
| if (x.has_items()): self.set_items(x.items()) |
| if (x.has_bytes()): self.set_bytes(x.bytes()) |
| if (x.has_oldest_item_age()): self.set_oldest_item_age(x.oldest_item_age()) |
| |
| def Equals(self, x): |
| if x is self: return 1 |
| if self.has_hits_ != x.has_hits_: return 0 |
| if self.has_hits_ and self.hits_ != x.hits_: return 0 |
| if self.has_misses_ != x.has_misses_: return 0 |
| if self.has_misses_ and self.misses_ != x.misses_: return 0 |
| if self.has_byte_hits_ != x.has_byte_hits_: return 0 |
| if self.has_byte_hits_ and self.byte_hits_ != x.byte_hits_: return 0 |
| if self.has_items_ != x.has_items_: return 0 |
| if self.has_items_ and self.items_ != x.items_: return 0 |
| if self.has_bytes_ != x.has_bytes_: return 0 |
| if self.has_bytes_ and self.bytes_ != x.bytes_: return 0 |
| if self.has_oldest_item_age_ != x.has_oldest_item_age_: return 0 |
| if self.has_oldest_item_age_ and self.oldest_item_age_ != x.oldest_item_age_: return 0 |
| return 1 |
| |
| def IsInitialized(self, debug_strs=None): |
| initialized = 1 |
| if (not self.has_hits_): |
| initialized = 0 |
| if debug_strs is not None: |
| debug_strs.append('Required field: hits not set.') |
| if (not self.has_misses_): |
| initialized = 0 |
| if debug_strs is not None: |
| debug_strs.append('Required field: misses not set.') |
| if (not self.has_byte_hits_): |
| initialized = 0 |
| if debug_strs is not None: |
| debug_strs.append('Required field: byte_hits not set.') |
| if (not self.has_items_): |
| initialized = 0 |
| if debug_strs is not None: |
| debug_strs.append('Required field: items not set.') |
| if (not self.has_bytes_): |
| initialized = 0 |
| if debug_strs is not None: |
| debug_strs.append('Required field: bytes not set.') |
| if (not self.has_oldest_item_age_): |
| initialized = 0 |
| if debug_strs is not None: |
| debug_strs.append('Required field: oldest_item_age not set.') |
| return initialized |
| |
| def ByteSize(self): |
| n = 0 |
| n += self.lengthVarInt64(self.hits_) |
| n += self.lengthVarInt64(self.misses_) |
| n += self.lengthVarInt64(self.byte_hits_) |
| n += self.lengthVarInt64(self.items_) |
| n += self.lengthVarInt64(self.bytes_) |
| return n + 10 |
| |
| def Clear(self): |
| self.clear_hits() |
| self.clear_misses() |
| self.clear_byte_hits() |
| self.clear_items() |
| self.clear_bytes() |
| self.clear_oldest_item_age() |
| |
| def OutputUnchecked(self, out): |
| out.putVarInt32(8) |
| out.putVarUint64(self.hits_) |
| out.putVarInt32(16) |
| out.putVarUint64(self.misses_) |
| out.putVarInt32(24) |
| out.putVarUint64(self.byte_hits_) |
| out.putVarInt32(32) |
| out.putVarUint64(self.items_) |
| out.putVarInt32(40) |
| out.putVarUint64(self.bytes_) |
| out.putVarInt32(53) |
| out.put32(self.oldest_item_age_) |
| |
| def TryMerge(self, d): |
| while d.avail() > 0: |
| tt = d.getVarInt32() |
| if tt == 8: |
| self.set_hits(d.getVarUint64()) |
| continue |
| if tt == 16: |
| self.set_misses(d.getVarUint64()) |
| continue |
| if tt == 24: |
| self.set_byte_hits(d.getVarUint64()) |
| continue |
| if tt == 32: |
| self.set_items(d.getVarUint64()) |
| continue |
| if tt == 40: |
| self.set_bytes(d.getVarUint64()) |
| continue |
| if tt == 53: |
| self.set_oldest_item_age(d.get32()) |
| continue |
| if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError |
| d.skipData(tt) |
| |
| |
| def __str__(self, prefix="", printElemNumber=0): |
| res="" |
| if self.has_hits_: res+=prefix+("hits: %s\n" % self.DebugFormatInt64(self.hits_)) |
| if self.has_misses_: res+=prefix+("misses: %s\n" % self.DebugFormatInt64(self.misses_)) |
| if self.has_byte_hits_: res+=prefix+("byte_hits: %s\n" % self.DebugFormatInt64(self.byte_hits_)) |
| if self.has_items_: res+=prefix+("items: %s\n" % self.DebugFormatInt64(self.items_)) |
| if self.has_bytes_: res+=prefix+("bytes: %s\n" % self.DebugFormatInt64(self.bytes_)) |
| if self.has_oldest_item_age_: res+=prefix+("oldest_item_age: %s\n" % self.DebugFormatFixed32(self.oldest_item_age_)) |
| return res |
| |
| khits = 1 |
| kmisses = 2 |
| kbyte_hits = 3 |
| kitems = 4 |
| kbytes = 5 |
| koldest_item_age = 6 |
| |
| _TEXT = ( |
| "ErrorCode", |
| "hits", |
| "misses", |
| "byte_hits", |
| "items", |
| "bytes", |
| "oldest_item_age", |
| ) |
| |
| _TYPES = ( |
| ProtocolBuffer.Encoder.NUMERIC, |
| ProtocolBuffer.Encoder.NUMERIC, |
| |
| ProtocolBuffer.Encoder.NUMERIC, |
| |
| ProtocolBuffer.Encoder.NUMERIC, |
| |
| ProtocolBuffer.Encoder.NUMERIC, |
| |
| ProtocolBuffer.Encoder.NUMERIC, |
| |
| ProtocolBuffer.Encoder.FLOAT, |
| |
| ) |
| |
| _STYLE = """""" |
| _STYLE_CONTENT_TYPE = """""" |
| class MemcacheStatsResponse(ProtocolBuffer.ProtocolMessage): |
| has_stats_ = 0 |
| stats_ = None |
| |
| def __init__(self, contents=None): |
| self.lazy_init_lock_ = thread.allocate_lock() |
| if contents is not None: self.MergeFromString(contents) |
| |
| def stats(self): |
| if self.stats_ is None: |
| self.lazy_init_lock_.acquire() |
| try: |
| if self.stats_ is None: self.stats_ = MergedNamespaceStats() |
| finally: |
| self.lazy_init_lock_.release() |
| return self.stats_ |
| |
| def mutable_stats(self): self.has_stats_ = 1; return self.stats() |
| |
| def clear_stats(self): |
| if self.has_stats_: |
| self.has_stats_ = 0; |
| if self.stats_ is not None: self.stats_.Clear() |
| |
| def has_stats(self): return self.has_stats_ |
| |
| |
| def MergeFrom(self, x): |
| assert x is not self |
| if (x.has_stats()): self.mutable_stats().MergeFrom(x.stats()) |
| |
| def Equals(self, x): |
| if x is self: return 1 |
| if self.has_stats_ != x.has_stats_: return 0 |
| if self.has_stats_ and self.stats_ != x.stats_: return 0 |
| return 1 |
| |
| def IsInitialized(self, debug_strs=None): |
| initialized = 1 |
| if (self.has_stats_ and not self.stats_.IsInitialized(debug_strs)): initialized = 0 |
| return initialized |
| |
| def ByteSize(self): |
| n = 0 |
| if (self.has_stats_): n += 1 + self.lengthString(self.stats_.ByteSize()) |
| return n + 0 |
| |
| def Clear(self): |
| self.clear_stats() |
| |
| def OutputUnchecked(self, out): |
| if (self.has_stats_): |
| out.putVarInt32(10) |
| out.putVarInt32(self.stats_.ByteSize()) |
| self.stats_.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_stats().TryMerge(tmp) |
| continue |
| if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError |
| d.skipData(tt) |
| |
| |
| def __str__(self, prefix="", printElemNumber=0): |
| res="" |
| if self.has_stats_: |
| res+=prefix+"stats <\n" |
| res+=self.stats_.__str__(prefix + " ", printElemNumber) |
| res+=prefix+">\n" |
| return res |
| |
| kstats = 1 |
| |
| _TEXT = ( |
| "ErrorCode", |
| "stats", |
| ) |
| |
| _TYPES = ( |
| ProtocolBuffer.Encoder.NUMERIC, |
| ProtocolBuffer.Encoder.STRING, |
| |
| ) |
| |
| _STYLE = """""" |
| _STYLE_CONTENT_TYPE = """""" |
| |
| __all__ = ['MemcacheServiceError','MemcacheGetRequest','MemcacheGetResponse','MemcacheGetResponse_Item','MemcacheSetRequest','MemcacheSetRequest_Item','MemcacheSetResponse','MemcacheDeleteRequest','MemcacheDeleteRequest_Item','MemcacheDeleteResponse','MemcacheIncrementRequest','MemcacheIncrementResponse','MemcacheFlushRequest','MemcacheFlushResponse','MemcacheStatsRequest','MergedNamespaceStats','MemcacheStatsResponse'] |
