thirdparty/google_appengine/google/appengine/api/capabilities/capability_service_pb.py
Add an home_for reference property
This field will be set to whatever presence is using the document as
home document.
Patch by: Sverre Rabbelier
#!/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.base.capabilities_pb import CapabilityConfig
class IsEnabledRequest(ProtocolBuffer.ProtocolMessage):
has_package_ = 0
package_ = ""
def __init__(self, contents=None):
self.capability_ = []
self.call_ = []
if contents is not None: self.MergeFromString(contents)
def package(self): return self.package_
def set_package(self, x):
self.has_package_ = 1
self.package_ = x
def clear_package(self):
if self.has_package_:
self.has_package_ = 0
self.package_ = ""
def has_package(self): return self.has_package_
def capability_size(self): return len(self.capability_)
def capability_list(self): return self.capability_
def capability(self, i):
return self.capability_[i]
def set_capability(self, i, x):
self.capability_[i] = x
def add_capability(self, x):
self.capability_.append(x)
def clear_capability(self):
self.capability_ = []
def call_size(self): return len(self.call_)
def call_list(self): return self.call_
def call(self, i):
return self.call_[i]
def set_call(self, i, x):
self.call_[i] = x
def add_call(self, x):
self.call_.append(x)
def clear_call(self):
self.call_ = []
def MergeFrom(self, x):
assert x is not self
if (x.has_package()): self.set_package(x.package())
for i in xrange(x.capability_size()): self.add_capability(x.capability(i))
for i in xrange(x.call_size()): self.add_call(x.call(i))
def Equals(self, x):
if x is self: return 1
if self.has_package_ != x.has_package_: return 0
if self.has_package_ and self.package_ != x.package_: return 0
if len(self.capability_) != len(x.capability_): return 0
for e1, e2 in zip(self.capability_, x.capability_):
if e1 != e2: return 0
if len(self.call_) != len(x.call_): return 0
for e1, e2 in zip(self.call_, x.call_):
if e1 != e2: return 0
return 1
def IsInitialized(self, debug_strs=None):
initialized = 1
if (not self.has_package_):
initialized = 0
if debug_strs is not None:
debug_strs.append('Required field: package not set.')
return initialized
def ByteSize(self):
n = 0
n += self.lengthString(len(self.package_))
n += 1 * len(self.capability_)
for i in xrange(len(self.capability_)): n += self.lengthString(len(self.capability_[i]))
n += 1 * len(self.call_)
for i in xrange(len(self.call_)): n += self.lengthString(len(self.call_[i]))
return n + 1
def Clear(self):
self.clear_package()
self.clear_capability()
self.clear_call()
def OutputUnchecked(self, out):
out.putVarInt32(10)
out.putPrefixedString(self.package_)
for i in xrange(len(self.capability_)):
out.putVarInt32(18)
out.putPrefixedString(self.capability_[i])
for i in xrange(len(self.call_)):
out.putVarInt32(26)
out.putPrefixedString(self.call_[i])
def TryMerge(self, d):
while d.avail() > 0:
tt = d.getVarInt32()
if tt == 10:
self.set_package(d.getPrefixedString())
continue
if tt == 18:
self.add_capability(d.getPrefixedString())
continue
if tt == 26:
self.add_call(d.getPrefixedString())
continue
if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
d.skipData(tt)
def __str__(self, prefix="", printElemNumber=0):
res=""
if self.has_package_: res+=prefix+("package: %s\n" % self.DebugFormatString(self.package_))
cnt=0
for e in self.capability_:
elm=""
if printElemNumber: elm="(%d)" % cnt
res+=prefix+("capability%s: %s\n" % (elm, self.DebugFormatString(e)))
cnt+=1
cnt=0
for e in self.call_:
elm=""
if printElemNumber: elm="(%d)" % cnt
res+=prefix+("call%s: %s\n" % (elm, self.DebugFormatString(e)))
cnt+=1
return res
kpackage = 1
kcapability = 2
kcall = 3
_TEXT = (
"ErrorCode",
"package",
"capability",
"call",
)
_TYPES = (
ProtocolBuffer.Encoder.NUMERIC,
ProtocolBuffer.Encoder.STRING,
ProtocolBuffer.Encoder.STRING,
ProtocolBuffer.Encoder.STRING,
)
_STYLE = """"""
_STYLE_CONTENT_TYPE = """"""
class IsEnabledResponse(ProtocolBuffer.ProtocolMessage):
ENABLED = 1
SCHEDULED_FUTURE = 2
SCHEDULED_NOW = 3
DISABLED = 4
UNKNOWN = 5
_SummaryStatus_NAMES = {
1: "ENABLED",
2: "SCHEDULED_FUTURE",
3: "SCHEDULED_NOW",
4: "DISABLED",
5: "UNKNOWN",
}
def SummaryStatus_Name(cls, x): return cls._SummaryStatus_NAMES.get(x, "")
SummaryStatus_Name = classmethod(SummaryStatus_Name)
has_summary_status_ = 0
summary_status_ = 0
has_time_until_scheduled_ = 0
time_until_scheduled_ = 0
def __init__(self, contents=None):
self.config_ = []
if contents is not None: self.MergeFromString(contents)
def summary_status(self): return self.summary_status_
def set_summary_status(self, x):
self.has_summary_status_ = 1
self.summary_status_ = x
def clear_summary_status(self):
if self.has_summary_status_:
self.has_summary_status_ = 0
self.summary_status_ = 0
def has_summary_status(self): return self.has_summary_status_
def time_until_scheduled(self): return self.time_until_scheduled_
def set_time_until_scheduled(self, x):
self.has_time_until_scheduled_ = 1
self.time_until_scheduled_ = x
def clear_time_until_scheduled(self):
if self.has_time_until_scheduled_:
self.has_time_until_scheduled_ = 0
self.time_until_scheduled_ = 0
def has_time_until_scheduled(self): return self.has_time_until_scheduled_
def config_size(self): return len(self.config_)
def config_list(self): return self.config_
def config(self, i):
return self.config_[i]
def mutable_config(self, i):
return self.config_[i]
def add_config(self):
x = CapabilityConfig()
self.config_.append(x)
return x
def clear_config(self):
self.config_ = []
def MergeFrom(self, x):
assert x is not self
if (x.has_summary_status()): self.set_summary_status(x.summary_status())
if (x.has_time_until_scheduled()): self.set_time_until_scheduled(x.time_until_scheduled())
for i in xrange(x.config_size()): self.add_config().CopyFrom(x.config(i))
def Equals(self, x):
if x is self: return 1
if self.has_summary_status_ != x.has_summary_status_: return 0
if self.has_summary_status_ and self.summary_status_ != x.summary_status_: return 0
if self.has_time_until_scheduled_ != x.has_time_until_scheduled_: return 0
if self.has_time_until_scheduled_ and self.time_until_scheduled_ != x.time_until_scheduled_: return 0
if len(self.config_) != len(x.config_): return 0
for e1, e2 in zip(self.config_, x.config_):
if e1 != e2: return 0
return 1
def IsInitialized(self, debug_strs=None):
initialized = 1
if (not self.has_summary_status_):
initialized = 0
if debug_strs is not None:
debug_strs.append('Required field: summary_status not set.')
for p in self.config_:
if not p.IsInitialized(debug_strs): initialized=0
return initialized
def ByteSize(self):
n = 0
n += self.lengthVarInt64(self.summary_status_)
if (self.has_time_until_scheduled_): n += 1 + self.lengthVarInt64(self.time_until_scheduled_)
n += 1 * len(self.config_)
for i in xrange(len(self.config_)): n += self.lengthString(self.config_[i].ByteSize())
return n + 1
def Clear(self):
self.clear_summary_status()
self.clear_time_until_scheduled()
self.clear_config()
def OutputUnchecked(self, out):
out.putVarInt32(8)
out.putVarInt32(self.summary_status_)
if (self.has_time_until_scheduled_):
out.putVarInt32(16)
out.putVarInt64(self.time_until_scheduled_)
for i in xrange(len(self.config_)):
out.putVarInt32(26)
out.putVarInt32(self.config_[i].ByteSize())
self.config_[i].OutputUnchecked(out)
def TryMerge(self, d):
while d.avail() > 0:
tt = d.getVarInt32()
if tt == 8:
self.set_summary_status(d.getVarInt32())
continue
if tt == 16:
self.set_time_until_scheduled(d.getVarInt64())
continue
if tt == 26:
length = d.getVarInt32()
tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
d.skip(length)
self.add_config().TryMerge(tmp)
continue
if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
d.skipData(tt)
def __str__(self, prefix="", printElemNumber=0):
res=""
if self.has_summary_status_: res+=prefix+("summary_status: %s\n" % self.DebugFormatInt32(self.summary_status_))
if self.has_time_until_scheduled_: res+=prefix+("time_until_scheduled: %s\n" % self.DebugFormatInt64(self.time_until_scheduled_))
cnt=0
for e in self.config_:
elm=""
if printElemNumber: elm="(%d)" % cnt
res+=prefix+("config%s <\n" % elm)
res+=e.__str__(prefix + " ", printElemNumber)
res+=prefix+">\n"
cnt+=1
return res
ksummary_status = 1
ktime_until_scheduled = 2
kconfig = 3
_TEXT = (
"ErrorCode",
"summary_status",
"time_until_scheduled",
"config",
)
_TYPES = (
ProtocolBuffer.Encoder.NUMERIC,
ProtocolBuffer.Encoder.NUMERIC,
ProtocolBuffer.Encoder.NUMERIC,
ProtocolBuffer.Encoder.STRING,
)
_STYLE = """"""
_STYLE_CONTENT_TYPE = """"""
__all__ = ['IsEnabledRequest','IsEnabledResponse']