File: //snap/google-cloud-cli/394/lib/googlecloudsdk/appengine/release/v3/entity_pb.py
# Copyright 2016 Google LLC. All Rights Reserved.
#
# 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.
# Generated by the protocol buffer compiler. DO NOT EDIT!
# source: storage/onestore/v3/entity.proto
import abc
import array
from googlecloudsdk.appengine.proto import ProtocolBuffer
try:
from thread import allocate_lock as _Lock
except ImportError:
from threading import Lock as _Lock
if hasattr(__builtins__, "xrange"):
range = xrange
if hasattr(ProtocolBuffer, "ExtendableProtocolMessage"):
_extension_runtime = True
_ExtendableProtocolMessage = ProtocolBuffer.ExtendableProtocolMessage
else:
_extension_runtime = False
_ExtendableProtocolMessage = ProtocolBuffer.ProtocolMessage
class PropertyValue_ReferenceValuePathElement(ProtocolBuffer.ProtocolMessage):
has_type_ = 0
type_ = ""
has_id_ = 0
id_ = 0
has_name_ = 0
name_ = ""
def __init__(self, contents=None):
if contents is not None:
self.MergeFromString(contents)
def type(self):
return self.type_
def set_type(self, x):
self.has_type_ = 1
self.type_ = x
def clear_type(self):
if self.has_type_:
self.has_type_ = 0
self.type_ = ""
def has_type(self):
return self.has_type_
def id(self):
return self.id_
def set_id(self, x):
self.has_id_ = 1
self.id_ = x
def clear_id(self):
if self.has_id_:
self.has_id_ = 0
self.id_ = 0
def has_id(self):
return self.has_id_
def name(self):
return self.name_
def set_name(self, x):
self.has_name_ = 1
self.name_ = x
def clear_name(self):
if self.has_name_:
self.has_name_ = 0
self.name_ = ""
def has_name(self):
return self.has_name_
def MergeFrom(self, x):
assert x is not self
if x.has_type():
self.set_type(x.type())
if x.has_id():
self.set_id(x.id())
if x.has_name():
self.set_name(x.name())
def Equals(self, x):
if x is self:
return 1
if self.has_type_ != x.has_type_:
return 0
if self.has_type_ and self.type_ != x.type_:
return 0
if self.has_id_ != x.has_id_:
return 0
if self.has_id_ and self.id_ != x.id_:
return 0
if self.has_name_ != x.has_name_:
return 0
if self.has_name_ and self.name_ != x.name_:
return 0
return 1
def IsInitialized(self, debug_strs=None):
initialized = 1
if not self.has_type_:
initialized = 0
if debug_strs is not None:
debug_strs.append("Required field: type not set.")
return initialized
def ByteSize(self):
n = 0
n += self.lengthString(len(self.type_))
if self.has_id_:
n += 2 + self.lengthVarInt64(self.id_)
if self.has_name_:
n += 2 + self.lengthString(len(self.name_))
return n + 1
def ByteSizePartial(self):
n = 0
if self.has_type_:
n += 1
n += self.lengthString(len(self.type_))
if self.has_id_:
n += 2 + self.lengthVarInt64(self.id_)
if self.has_name_:
n += 2 + self.lengthString(len(self.name_))
return n
def Clear(self):
self.clear_type()
self.clear_id()
self.clear_name()
def OutputUnchecked(self, out):
out.putVarInt32(122)
out.putPrefixedString(self.type_)
if self.has_id_:
out.putVarInt32(128)
out.putVarInt64(self.id_)
if self.has_name_:
out.putVarInt32(138)
out.putPrefixedString(self.name_)
def OutputPartial(self, out):
if self.has_type_:
out.putVarInt32(122)
out.putPrefixedString(self.type_)
if self.has_id_:
out.putVarInt32(128)
out.putVarInt64(self.id_)
if self.has_name_:
out.putVarInt32(138)
out.putPrefixedString(self.name_)
def TryMerge(self, d):
while 1:
tt = d.getVarInt32()
if tt == 116:
break
if tt == 122:
self.set_type(d.getPrefixedString())
continue
if tt == 128:
self.set_id(d.getVarInt64())
continue
if tt == 138:
self.set_name(d.getPrefixedString())
continue
# tag 0 is special: it's used to indicate an error.
# so if we see it we raise an exception.
if tt == 0:
raise ProtocolBuffer.ProtocolBufferDecodeError()
d.skipData(tt)
def __str__(self, prefix="", printElemNumber=0):
res = ""
if self.has_type_:
res += prefix + ("type: %s\n" % self.DebugFormatString(self.type_))
if self.has_id_:
res += prefix + ("id: %s\n" % self.DebugFormatInt64(self.id_))
if self.has_name_:
res += prefix + ("name: %s\n" % self.DebugFormatString(self.name_))
return res
class PropertyValue_PointValue(ProtocolBuffer.ProtocolMessage):
has_x_ = 0
x_ = 0.0
has_y_ = 0
y_ = 0.0
def __init__(self, contents=None):
if contents is not None:
self.MergeFromString(contents)
def x(self):
return self.x_
def set_x(self, x):
self.has_x_ = 1
self.x_ = x
def clear_x(self):
if self.has_x_:
self.has_x_ = 0
self.x_ = 0.0
def has_x(self):
return self.has_x_
def y(self):
return self.y_
def set_y(self, x):
self.has_y_ = 1
self.y_ = x
def clear_y(self):
if self.has_y_:
self.has_y_ = 0
self.y_ = 0.0
def has_y(self):
return self.has_y_
def MergeFrom(self, x):
assert x is not self
if x.has_x():
self.set_x(x.x())
if x.has_y():
self.set_y(x.y())
def Equals(self, x):
if x is self:
return 1
if self.has_x_ != x.has_x_:
return 0
if self.has_x_ and self.x_ != x.x_:
return 0
if self.has_y_ != x.has_y_:
return 0
if self.has_y_ and self.y_ != x.y_:
return 0
return 1
def IsInitialized(self, debug_strs=None):
initialized = 1
if not self.has_x_:
initialized = 0
if debug_strs is not None:
debug_strs.append("Required field: x not set.")
if not self.has_y_:
initialized = 0
if debug_strs is not None:
debug_strs.append("Required field: y not set.")
return initialized
def ByteSize(self):
n = 0
return n + 18
def ByteSizePartial(self):
n = 0
if self.has_x_:
n += 9
if self.has_y_:
n += 9
return n
def Clear(self):
self.clear_x()
self.clear_y()
def OutputUnchecked(self, out):
out.putVarInt32(49)
out.putDouble(self.x_)
out.putVarInt32(57)
out.putDouble(self.y_)
def OutputPartial(self, out):
if self.has_x_:
out.putVarInt32(49)
out.putDouble(self.x_)
if self.has_y_:
out.putVarInt32(57)
out.putDouble(self.y_)
def TryMerge(self, d):
while 1:
tt = d.getVarInt32()
if tt == 44:
break
if tt == 49:
self.set_x(d.getDouble())
continue
if tt == 57:
self.set_y(d.getDouble())
continue
# tag 0 is special: it's used to indicate an error.
# so if we see it we raise an exception.
if tt == 0:
raise ProtocolBuffer.ProtocolBufferDecodeError()
d.skipData(tt)
def __str__(self, prefix="", printElemNumber=0):
res = ""
if self.has_x_:
res += prefix + ("x: %s\n" % self.DebugFormat(self.x_))
if self.has_y_:
res += prefix + ("y: %s\n" % self.DebugFormat(self.y_))
return res
class PropertyValue_UserValue(ProtocolBuffer.ProtocolMessage):
has_email_ = 0
email_ = ""
has_auth_domain_ = 0
auth_domain_ = ""
has_nickname_ = 0
nickname_ = ""
has_gaiaid_ = 0
gaiaid_ = 0
has_obfuscated_gaiaid_ = 0
obfuscated_gaiaid_ = ""
has_federated_identity_ = 0
federated_identity_ = ""
has_federated_provider_ = 0
federated_provider_ = ""
def __init__(self, contents=None):
if contents is not None:
self.MergeFromString(contents)
def email(self):
return self.email_
def set_email(self, x):
self.has_email_ = 1
self.email_ = x
def clear_email(self):
if self.has_email_:
self.has_email_ = 0
self.email_ = ""
def has_email(self):
return self.has_email_
def auth_domain(self):
return self.auth_domain_
def set_auth_domain(self, x):
self.has_auth_domain_ = 1
self.auth_domain_ = x
def clear_auth_domain(self):
if self.has_auth_domain_:
self.has_auth_domain_ = 0
self.auth_domain_ = ""
def has_auth_domain(self):
return self.has_auth_domain_
def nickname(self):
return self.nickname_
def set_nickname(self, x):
self.has_nickname_ = 1
self.nickname_ = x
def clear_nickname(self):
if self.has_nickname_:
self.has_nickname_ = 0
self.nickname_ = ""
def has_nickname(self):
return self.has_nickname_
def gaiaid(self):
return self.gaiaid_
def set_gaiaid(self, x):
self.has_gaiaid_ = 1
self.gaiaid_ = x
def clear_gaiaid(self):
if self.has_gaiaid_:
self.has_gaiaid_ = 0
self.gaiaid_ = 0
def has_gaiaid(self):
return self.has_gaiaid_
def obfuscated_gaiaid(self):
return self.obfuscated_gaiaid_
def set_obfuscated_gaiaid(self, x):
self.has_obfuscated_gaiaid_ = 1
self.obfuscated_gaiaid_ = x
def clear_obfuscated_gaiaid(self):
if self.has_obfuscated_gaiaid_:
self.has_obfuscated_gaiaid_ = 0
self.obfuscated_gaiaid_ = ""
def has_obfuscated_gaiaid(self):
return self.has_obfuscated_gaiaid_
def federated_identity(self):
return self.federated_identity_
def set_federated_identity(self, x):
self.has_federated_identity_ = 1
self.federated_identity_ = x
def clear_federated_identity(self):
if self.has_federated_identity_:
self.has_federated_identity_ = 0
self.federated_identity_ = ""
def has_federated_identity(self):
return self.has_federated_identity_
def federated_provider(self):
return self.federated_provider_
def set_federated_provider(self, x):
self.has_federated_provider_ = 1
self.federated_provider_ = x
def clear_federated_provider(self):
if self.has_federated_provider_:
self.has_federated_provider_ = 0
self.federated_provider_ = ""
def has_federated_provider(self):
return self.has_federated_provider_
def MergeFrom(self, x):
assert x is not self
if x.has_email():
self.set_email(x.email())
if x.has_auth_domain():
self.set_auth_domain(x.auth_domain())
if x.has_nickname():
self.set_nickname(x.nickname())
if x.has_gaiaid():
self.set_gaiaid(x.gaiaid())
if x.has_obfuscated_gaiaid():
self.set_obfuscated_gaiaid(x.obfuscated_gaiaid())
if x.has_federated_identity():
self.set_federated_identity(x.federated_identity())
if x.has_federated_provider():
self.set_federated_provider(x.federated_provider())
def Equals(self, x):
if x is self:
return 1
if self.has_email_ != x.has_email_:
return 0
if self.has_email_ and self.email_ != x.email_:
return 0
if self.has_auth_domain_ != x.has_auth_domain_:
return 0
if self.has_auth_domain_ and self.auth_domain_ != x.auth_domain_:
return 0
if self.has_nickname_ != x.has_nickname_:
return 0
if self.has_nickname_ and self.nickname_ != x.nickname_:
return 0
if self.has_gaiaid_ != x.has_gaiaid_:
return 0
if self.has_gaiaid_ and self.gaiaid_ != x.gaiaid_:
return 0
if self.has_obfuscated_gaiaid_ != x.has_obfuscated_gaiaid_:
return 0
if (
self.has_obfuscated_gaiaid_
and self.obfuscated_gaiaid_ != x.obfuscated_gaiaid_
):
return 0
if self.has_federated_identity_ != x.has_federated_identity_:
return 0
if (
self.has_federated_identity_
and self.federated_identity_ != x.federated_identity_
):
return 0
if self.has_federated_provider_ != x.has_federated_provider_:
return 0
if (
self.has_federated_provider_
and self.federated_provider_ != x.federated_provider_
):
return 0
return 1
def IsInitialized(self, debug_strs=None):
initialized = 1
if not self.has_email_:
initialized = 0
if debug_strs is not None:
debug_strs.append("Required field: email not set.")
if not self.has_auth_domain_:
initialized = 0
if debug_strs is not None:
debug_strs.append("Required field: auth_domain not set.")
if not self.has_gaiaid_:
initialized = 0
if debug_strs is not None:
debug_strs.append("Required field: gaiaid not set.")
return initialized
def ByteSize(self):
n = 0
n += self.lengthString(len(self.email_))
n += self.lengthString(len(self.auth_domain_))
if self.has_nickname_:
n += 1 + self.lengthString(len(self.nickname_))
n += self.lengthVarInt64(self.gaiaid_)
if self.has_obfuscated_gaiaid_:
n += 2 + self.lengthString(len(self.obfuscated_gaiaid_))
if self.has_federated_identity_:
n += 2 + self.lengthString(len(self.federated_identity_))
if self.has_federated_provider_:
n += 2 + self.lengthString(len(self.federated_provider_))
return n + 4
def ByteSizePartial(self):
n = 0
if self.has_email_:
n += 1
n += self.lengthString(len(self.email_))
if self.has_auth_domain_:
n += 1
n += self.lengthString(len(self.auth_domain_))
if self.has_nickname_:
n += 1 + self.lengthString(len(self.nickname_))
if self.has_gaiaid_:
n += 2
n += self.lengthVarInt64(self.gaiaid_)
if self.has_obfuscated_gaiaid_:
n += 2 + self.lengthString(len(self.obfuscated_gaiaid_))
if self.has_federated_identity_:
n += 2 + self.lengthString(len(self.federated_identity_))
if self.has_federated_provider_:
n += 2 + self.lengthString(len(self.federated_provider_))
return n
def Clear(self):
self.clear_email()
self.clear_auth_domain()
self.clear_nickname()
self.clear_gaiaid()
self.clear_obfuscated_gaiaid()
self.clear_federated_identity()
self.clear_federated_provider()
def OutputUnchecked(self, out):
out.putVarInt32(74)
out.putPrefixedString(self.email_)
out.putVarInt32(82)
out.putPrefixedString(self.auth_domain_)
if self.has_nickname_:
out.putVarInt32(90)
out.putPrefixedString(self.nickname_)
out.putVarInt32(144)
out.putVarInt64(self.gaiaid_)
if self.has_obfuscated_gaiaid_:
out.putVarInt32(154)
out.putPrefixedString(self.obfuscated_gaiaid_)
if self.has_federated_identity_:
out.putVarInt32(170)
out.putPrefixedString(self.federated_identity_)
if self.has_federated_provider_:
out.putVarInt32(178)
out.putPrefixedString(self.federated_provider_)
def OutputPartial(self, out):
if self.has_email_:
out.putVarInt32(74)
out.putPrefixedString(self.email_)
if self.has_auth_domain_:
out.putVarInt32(82)
out.putPrefixedString(self.auth_domain_)
if self.has_nickname_:
out.putVarInt32(90)
out.putPrefixedString(self.nickname_)
if self.has_gaiaid_:
out.putVarInt32(144)
out.putVarInt64(self.gaiaid_)
if self.has_obfuscated_gaiaid_:
out.putVarInt32(154)
out.putPrefixedString(self.obfuscated_gaiaid_)
if self.has_federated_identity_:
out.putVarInt32(170)
out.putPrefixedString(self.federated_identity_)
if self.has_federated_provider_:
out.putVarInt32(178)
out.putPrefixedString(self.federated_provider_)
def TryMerge(self, d):
while 1:
tt = d.getVarInt32()
if tt == 68:
break
if tt == 74:
self.set_email(d.getPrefixedString())
continue
if tt == 82:
self.set_auth_domain(d.getPrefixedString())
continue
if tt == 90:
self.set_nickname(d.getPrefixedString())
continue
if tt == 144:
self.set_gaiaid(d.getVarInt64())
continue
if tt == 154:
self.set_obfuscated_gaiaid(d.getPrefixedString())
continue
if tt == 170:
self.set_federated_identity(d.getPrefixedString())
continue
if tt == 178:
self.set_federated_provider(d.getPrefixedString())
continue
# tag 0 is special: it's used to indicate an error.
# so if we see it we raise an exception.
if tt == 0:
raise ProtocolBuffer.ProtocolBufferDecodeError()
d.skipData(tt)
def __str__(self, prefix="", printElemNumber=0):
res = ""
if self.has_email_:
res += prefix + ("email: %s\n" % self.DebugFormatString(self.email_))
if self.has_auth_domain_:
res += prefix + (
"auth_domain: %s\n" % self.DebugFormatString(self.auth_domain_)
)
if self.has_nickname_:
res += prefix + (
"nickname: %s\n" % self.DebugFormatString(self.nickname_)
)
if self.has_gaiaid_:
res += prefix + ("gaiaid: %s\n" % self.DebugFormatInt64(self.gaiaid_))
if self.has_obfuscated_gaiaid_:
res += prefix + (
"obfuscated_gaiaid: %s\n"
% self.DebugFormatString(self.obfuscated_gaiaid_)
)
if self.has_federated_identity_:
res += prefix + (
"federated_identity: %s\n"
% self.DebugFormatString(self.federated_identity_)
)
if self.has_federated_provider_:
res += prefix + (
"federated_provider: %s\n"
% self.DebugFormatString(self.federated_provider_)
)
return res
class PropertyValue_ReferenceValue(ProtocolBuffer.ProtocolMessage):
has_app_ = 0
app_ = ""
has_name_space_ = 0
name_space_ = ""
has_database_id_ = 0
database_id_ = ""
def __init__(self, contents=None):
self.pathelement_ = []
if contents is not None:
self.MergeFromString(contents)
def app(self):
return self.app_
def set_app(self, x):
self.has_app_ = 1
self.app_ = x
def clear_app(self):
if self.has_app_:
self.has_app_ = 0
self.app_ = ""
def has_app(self):
return self.has_app_
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 pathelement_size(self):
return len(self.pathelement_)
def pathelement_list(self):
return self.pathelement_
def pathelement(self, i):
return self.pathelement_[i]
def mutable_pathelement(self, i):
return self.pathelement_[i]
def add_pathelement(self):
x = PropertyValue_ReferenceValuePathElement()
self.pathelement_.append(x)
return x
def clear_pathelement(self):
self.pathelement_ = []
def database_id(self):
return self.database_id_
def set_database_id(self, x):
self.has_database_id_ = 1
self.database_id_ = x
def clear_database_id(self):
if self.has_database_id_:
self.has_database_id_ = 0
self.database_id_ = ""
def has_database_id(self):
return self.has_database_id_
def MergeFrom(self, x):
assert x is not self
if x.has_app():
self.set_app(x.app())
if x.has_name_space():
self.set_name_space(x.name_space())
for i in range(x.pathelement_size()):
self.add_pathelement().CopyFrom(x.pathelement(i))
if x.has_database_id():
self.set_database_id(x.database_id())
def Equals(self, x):
if x is self:
return 1
if self.has_app_ != x.has_app_:
return 0
if self.has_app_ and self.app_ != x.app_:
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 len(self.pathelement_) != len(x.pathelement_):
return 0
for e1, e2 in zip(self.pathelement_, x.pathelement_):
if e1 != e2:
return 0
if self.has_database_id_ != x.has_database_id_:
return 0
if self.has_database_id_ and self.database_id_ != x.database_id_:
return 0
return 1
def IsInitialized(self, debug_strs=None):
initialized = 1
if not self.has_app_:
initialized = 0
if debug_strs is not None:
debug_strs.append("Required field: app not set.")
for p in self.pathelement_:
if not p.IsInitialized(debug_strs):
initialized = 0
return initialized
def ByteSize(self):
n = 0
n += self.lengthString(len(self.app_))
if self.has_name_space_:
n += 2 + self.lengthString(len(self.name_space_))
n += 2 * len(self.pathelement_)
for i in range(len(self.pathelement_)):
n += self.pathelement_[i].ByteSize()
if self.has_database_id_:
n += 2 + self.lengthString(len(self.database_id_))
return n + 1
def ByteSizePartial(self):
n = 0
if self.has_app_:
n += 1
n += self.lengthString(len(self.app_))
if self.has_name_space_:
n += 2 + self.lengthString(len(self.name_space_))
n += 2 * len(self.pathelement_)
for i in range(len(self.pathelement_)):
n += self.pathelement_[i].ByteSizePartial()
if self.has_database_id_:
n += 2 + self.lengthString(len(self.database_id_))
return n
def Clear(self):
self.clear_app()
self.clear_name_space()
self.clear_pathelement()
self.clear_database_id()
def OutputUnchecked(self, out):
out.putVarInt32(106)
out.putPrefixedString(self.app_)
for i in range(len(self.pathelement_)):
out.putVarInt32(115)
self.pathelement_[i].OutputUnchecked(out)
out.putVarInt32(116)
if self.has_name_space_:
out.putVarInt32(162)
out.putPrefixedString(self.name_space_)
if self.has_database_id_:
out.putVarInt32(186)
out.putPrefixedString(self.database_id_)
def OutputPartial(self, out):
if self.has_app_:
out.putVarInt32(106)
out.putPrefixedString(self.app_)
for i in range(len(self.pathelement_)):
out.putVarInt32(115)
self.pathelement_[i].OutputPartial(out)
out.putVarInt32(116)
if self.has_name_space_:
out.putVarInt32(162)
out.putPrefixedString(self.name_space_)
if self.has_database_id_:
out.putVarInt32(186)
out.putPrefixedString(self.database_id_)
def TryMerge(self, d):
while 1:
tt = d.getVarInt32()
if tt == 100:
break
if tt == 106:
self.set_app(d.getPrefixedString())
continue
if tt == 115:
self.add_pathelement().TryMerge(d)
continue
if tt == 162:
self.set_name_space(d.getPrefixedString())
continue
if tt == 186:
self.set_database_id(d.getPrefixedString())
continue
# tag 0 is special: it's used to indicate an error.
# so if we see it we raise an exception.
if tt == 0:
raise ProtocolBuffer.ProtocolBufferDecodeError()
d.skipData(tt)
def __str__(self, prefix="", printElemNumber=0):
res = ""
if self.has_app_:
res += prefix + ("app: %s\n" % self.DebugFormatString(self.app_))
if self.has_name_space_:
res += prefix + (
"name_space: %s\n" % self.DebugFormatString(self.name_space_)
)
cnt = 0
for e in self.pathelement_:
elm = ""
if printElemNumber:
elm = "(%d)" % cnt
res += prefix + "PathElement%s {\n" % elm
res += e.__str__(prefix + " ", printElemNumber)
res += prefix + "}\n"
cnt += 1
if self.has_database_id_:
res += prefix + (
"database_id: %s\n" % self.DebugFormatString(self.database_id_)
)
return res
class PropertyValue(ProtocolBuffer.ProtocolMessage):
has_int64value_ = 0
int64value_ = 0
has_booleanvalue_ = 0
booleanvalue_ = 0
has_stringvalue_ = 0
stringvalue_ = ""
has_doublevalue_ = 0
doublevalue_ = 0.0
has_pointvalue_ = 0
pointvalue_ = None
has_uservalue_ = 0
uservalue_ = None
has_referencevalue_ = 0
referencevalue_ = None
def __init__(self, contents=None):
self.lazy_init_lock_ = _Lock()
if contents is not None:
self.MergeFromString(contents)
def int64value(self):
return self.int64value_
def set_int64value(self, x):
self.has_int64value_ = 1
self.int64value_ = x
def clear_int64value(self):
if self.has_int64value_:
self.has_int64value_ = 0
self.int64value_ = 0
def has_int64value(self):
return self.has_int64value_
def booleanvalue(self):
return self.booleanvalue_
def set_booleanvalue(self, x):
self.has_booleanvalue_ = 1
self.booleanvalue_ = x
def clear_booleanvalue(self):
if self.has_booleanvalue_:
self.has_booleanvalue_ = 0
self.booleanvalue_ = 0
def has_booleanvalue(self):
return self.has_booleanvalue_
def stringvalue(self):
return self.stringvalue_
def set_stringvalue(self, x):
self.has_stringvalue_ = 1
self.stringvalue_ = x
def clear_stringvalue(self):
if self.has_stringvalue_:
self.has_stringvalue_ = 0
self.stringvalue_ = ""
def has_stringvalue(self):
return self.has_stringvalue_
def doublevalue(self):
return self.doublevalue_
def set_doublevalue(self, x):
self.has_doublevalue_ = 1
self.doublevalue_ = x
def clear_doublevalue(self):
if self.has_doublevalue_:
self.has_doublevalue_ = 0
self.doublevalue_ = 0.0
def has_doublevalue(self):
return self.has_doublevalue_
def pointvalue(self):
if self.pointvalue_ is None:
self.lazy_init_lock_.acquire()
try:
if self.pointvalue_ is None:
self.pointvalue_ = PropertyValue_PointValue()
finally:
self.lazy_init_lock_.release()
return self.pointvalue_
def mutable_pointvalue(self):
self.has_pointvalue_ = 1
return self.pointvalue()
def clear_pointvalue(self):
# Warning: this method does not acquire the lock.
if self.has_pointvalue_:
self.has_pointvalue_ = 0
if self.pointvalue_ is not None:
self.pointvalue_.Clear()
def has_pointvalue(self):
return self.has_pointvalue_
def uservalue(self):
if self.uservalue_ is None:
self.lazy_init_lock_.acquire()
try:
if self.uservalue_ is None:
self.uservalue_ = PropertyValue_UserValue()
finally:
self.lazy_init_lock_.release()
return self.uservalue_
def mutable_uservalue(self):
self.has_uservalue_ = 1
return self.uservalue()
def clear_uservalue(self):
# Warning: this method does not acquire the lock.
if self.has_uservalue_:
self.has_uservalue_ = 0
if self.uservalue_ is not None:
self.uservalue_.Clear()
def has_uservalue(self):
return self.has_uservalue_
def referencevalue(self):
if self.referencevalue_ is None:
self.lazy_init_lock_.acquire()
try:
if self.referencevalue_ is None:
self.referencevalue_ = PropertyValue_ReferenceValue()
finally:
self.lazy_init_lock_.release()
return self.referencevalue_
def mutable_referencevalue(self):
self.has_referencevalue_ = 1
return self.referencevalue()
def clear_referencevalue(self):
# Warning: this method does not acquire the lock.
if self.has_referencevalue_:
self.has_referencevalue_ = 0
if self.referencevalue_ is not None:
self.referencevalue_.Clear()
def has_referencevalue(self):
return self.has_referencevalue_
def MergeFrom(self, x):
assert x is not self
if x.has_int64value():
self.set_int64value(x.int64value())
if x.has_booleanvalue():
self.set_booleanvalue(x.booleanvalue())
if x.has_stringvalue():
self.set_stringvalue(x.stringvalue())
if x.has_doublevalue():
self.set_doublevalue(x.doublevalue())
if x.has_pointvalue():
self.mutable_pointvalue().MergeFrom(x.pointvalue())
if x.has_uservalue():
self.mutable_uservalue().MergeFrom(x.uservalue())
if x.has_referencevalue():
self.mutable_referencevalue().MergeFrom(x.referencevalue())
def Equals(self, x):
if x is self:
return 1
if self.has_int64value_ != x.has_int64value_:
return 0
if self.has_int64value_ and self.int64value_ != x.int64value_:
return 0
if self.has_booleanvalue_ != x.has_booleanvalue_:
return 0
if self.has_booleanvalue_ and self.booleanvalue_ != x.booleanvalue_:
return 0
if self.has_stringvalue_ != x.has_stringvalue_:
return 0
if self.has_stringvalue_ and self.stringvalue_ != x.stringvalue_:
return 0
if self.has_doublevalue_ != x.has_doublevalue_:
return 0
if self.has_doublevalue_ and self.doublevalue_ != x.doublevalue_:
return 0
if self.has_pointvalue_ != x.has_pointvalue_:
return 0
if self.has_pointvalue_ and self.pointvalue_ != x.pointvalue_:
return 0
if self.has_uservalue_ != x.has_uservalue_:
return 0
if self.has_uservalue_ and self.uservalue_ != x.uservalue_:
return 0
if self.has_referencevalue_ != x.has_referencevalue_:
return 0
if self.has_referencevalue_ and self.referencevalue_ != x.referencevalue_:
return 0
return 1
def IsInitialized(self, debug_strs=None):
initialized = 1
if self.has_pointvalue_ and not self.pointvalue_.IsInitialized(debug_strs):
initialized = 0
if self.has_uservalue_ and not self.uservalue_.IsInitialized(debug_strs):
initialized = 0
if self.has_referencevalue_ and not self.referencevalue_.IsInitialized(
debug_strs
):
initialized = 0
return initialized
def ByteSize(self):
n = 0
if self.has_int64value_:
n += 1 + self.lengthVarInt64(self.int64value_)
if self.has_booleanvalue_:
n += 2
if self.has_stringvalue_:
n += 1 + self.lengthString(len(self.stringvalue_))
if self.has_doublevalue_:
n += 9
if self.has_pointvalue_:
n += 2 + self.pointvalue_.ByteSize()
if self.has_uservalue_:
n += 2 + self.uservalue_.ByteSize()
if self.has_referencevalue_:
n += 2 + self.referencevalue_.ByteSize()
return n
def ByteSizePartial(self):
n = 0
if self.has_int64value_:
n += 1 + self.lengthVarInt64(self.int64value_)
if self.has_booleanvalue_:
n += 2
if self.has_stringvalue_:
n += 1 + self.lengthString(len(self.stringvalue_))
if self.has_doublevalue_:
n += 9
if self.has_pointvalue_:
n += 2 + self.pointvalue_.ByteSizePartial()
if self.has_uservalue_:
n += 2 + self.uservalue_.ByteSizePartial()
if self.has_referencevalue_:
n += 2 + self.referencevalue_.ByteSizePartial()
return n
def Clear(self):
self.clear_int64value()
self.clear_booleanvalue()
self.clear_stringvalue()
self.clear_doublevalue()
self.clear_pointvalue()
self.clear_uservalue()
self.clear_referencevalue()
def OutputUnchecked(self, out):
if self.has_int64value_:
out.putVarInt32(8)
out.putVarInt64(self.int64value_)
if self.has_booleanvalue_:
out.putVarInt32(16)
out.putBoolean(self.booleanvalue_)
if self.has_stringvalue_:
out.putVarInt32(26)
out.putPrefixedString(self.stringvalue_)
if self.has_doublevalue_:
out.putVarInt32(33)
out.putDouble(self.doublevalue_)
if self.has_pointvalue_:
out.putVarInt32(43)
self.pointvalue_.OutputUnchecked(out)
out.putVarInt32(44)
if self.has_uservalue_:
out.putVarInt32(67)
self.uservalue_.OutputUnchecked(out)
out.putVarInt32(68)
if self.has_referencevalue_:
out.putVarInt32(99)
self.referencevalue_.OutputUnchecked(out)
out.putVarInt32(100)
def OutputPartial(self, out):
if self.has_int64value_:
out.putVarInt32(8)
out.putVarInt64(self.int64value_)
if self.has_booleanvalue_:
out.putVarInt32(16)
out.putBoolean(self.booleanvalue_)
if self.has_stringvalue_:
out.putVarInt32(26)
out.putPrefixedString(self.stringvalue_)
if self.has_doublevalue_:
out.putVarInt32(33)
out.putDouble(self.doublevalue_)
if self.has_pointvalue_:
out.putVarInt32(43)
self.pointvalue_.OutputPartial(out)
out.putVarInt32(44)
if self.has_uservalue_:
out.putVarInt32(67)
self.uservalue_.OutputPartial(out)
out.putVarInt32(68)
if self.has_referencevalue_:
out.putVarInt32(99)
self.referencevalue_.OutputPartial(out)
out.putVarInt32(100)
def TryMerge(self, d):
while d.avail() > 0:
tt = d.getVarInt32()
if tt == 8:
self.set_int64value(d.getVarInt64())
continue
if tt == 16:
self.set_booleanvalue(d.getBoolean())
continue
if tt == 26:
self.set_stringvalue(d.getPrefixedString())
continue
if tt == 33:
self.set_doublevalue(d.getDouble())
continue
if tt == 43:
self.mutable_pointvalue().TryMerge(d)
continue
if tt == 67:
self.mutable_uservalue().TryMerge(d)
continue
if tt == 99:
self.mutable_referencevalue().TryMerge(d)
continue
# tag 0 is special: it's used to indicate an error.
# so if we see it we raise an exception.
if tt == 0:
raise ProtocolBuffer.ProtocolBufferDecodeError()
d.skipData(tt)
def __str__(self, prefix="", printElemNumber=0):
res = ""
if self.has_int64value_:
res += prefix + (
"int64Value: %s\n" % self.DebugFormatInt64(self.int64value_)
)
if self.has_booleanvalue_:
res += prefix + (
"booleanValue: %s\n" % self.DebugFormatBool(self.booleanvalue_)
)
if self.has_stringvalue_:
res += prefix + (
"stringValue: %s\n" % self.DebugFormatString(self.stringvalue_)
)
if self.has_doublevalue_:
res += prefix + (
"doubleValue: %s\n" % self.DebugFormat(self.doublevalue_)
)
if self.has_pointvalue_:
res += prefix + "PointValue {\n"
res += self.pointvalue_.__str__(prefix + " ", printElemNumber)
res += prefix + "}\n"
if self.has_uservalue_:
res += prefix + "UserValue {\n"
res += self.uservalue_.__str__(prefix + " ", printElemNumber)
res += prefix + "}\n"
if self.has_referencevalue_:
res += prefix + "ReferenceValue {\n"
res += self.referencevalue_.__str__(prefix + " ", printElemNumber)
res += prefix + "}\n"
return res
def _BuildTagLookupTable(sparse, maxtag, default=None):
return tuple([sparse.get(i, default) for i in range(0, 1 + maxtag)])
kint64Value = 1
kbooleanValue = 2
kstringValue = 3
kdoubleValue = 4
kPointValueGroup = 5
kPointValuex = 6
kPointValuey = 7
kUserValueGroup = 8
kUserValueemail = 9
kUserValueauth_domain = 10
kUserValuenickname = 11
kUserValuegaiaid = 18
kUserValueobfuscated_gaiaid = 19
kUserValuefederated_identity = 21
kUserValuefederated_provider = 22
kReferenceValueGroup = 12
kReferenceValueapp = 13
kReferenceValuename_space = 20
kReferenceValuePathElementGroup = 14
kReferenceValuePathElementtype = 15
kReferenceValuePathElementid = 16
kReferenceValuePathElementname = 17
kReferenceValuedatabase_id = 23
_TEXT = _BuildTagLookupTable(
{
0: "ErrorCode",
1: "int64Value",
2: "booleanValue",
3: "stringValue",
4: "doubleValue",
5: "PointValue",
6: "x",
7: "y",
8: "UserValue",
9: "email",
10: "auth_domain",
11: "nickname",
12: "ReferenceValue",
13: "app",
14: "PathElement",
15: "type",
16: "id",
17: "name",
18: "gaiaid",
19: "obfuscated_gaiaid",
20: "name_space",
21: "federated_identity",
22: "federated_provider",
23: "database_id",
},
23,
)
_TYPES = _BuildTagLookupTable(
{
0: ProtocolBuffer.Encoder.NUMERIC,
1: ProtocolBuffer.Encoder.NUMERIC,
2: ProtocolBuffer.Encoder.NUMERIC,
3: ProtocolBuffer.Encoder.STRING,
4: ProtocolBuffer.Encoder.DOUBLE,
5: ProtocolBuffer.Encoder.STARTGROUP,
6: ProtocolBuffer.Encoder.DOUBLE,
7: ProtocolBuffer.Encoder.DOUBLE,
8: ProtocolBuffer.Encoder.STARTGROUP,
9: ProtocolBuffer.Encoder.STRING,
10: ProtocolBuffer.Encoder.STRING,
11: ProtocolBuffer.Encoder.STRING,
12: ProtocolBuffer.Encoder.STARTGROUP,
13: ProtocolBuffer.Encoder.STRING,
14: ProtocolBuffer.Encoder.STARTGROUP,
15: ProtocolBuffer.Encoder.STRING,
16: ProtocolBuffer.Encoder.NUMERIC,
17: ProtocolBuffer.Encoder.STRING,
18: ProtocolBuffer.Encoder.NUMERIC,
19: ProtocolBuffer.Encoder.STRING,
20: ProtocolBuffer.Encoder.STRING,
21: ProtocolBuffer.Encoder.STRING,
22: ProtocolBuffer.Encoder.STRING,
23: ProtocolBuffer.Encoder.STRING,
},
23,
ProtocolBuffer.Encoder.MAX_TYPE,
)
# stylesheet for XML output
_STYLE = """"""
_STYLE_CONTENT_TYPE = """"""
_PROTO_DESCRIPTOR_NAME = "storage_onestore_v3.PropertyValue"
class Property(ProtocolBuffer.ProtocolMessage):
# Meaning values
NO_MEANING = 0
BLOB = 14
TEXT = 15
BYTESTRING = 16
ATOM_CATEGORY = 1
ATOM_LINK = 2
ATOM_TITLE = 3
ATOM_CONTENT = 4
ATOM_SUMMARY = 5
ATOM_AUTHOR = 6
GD_WHEN = 7
GD_EMAIL = 8
GEORSS_POINT = 9
GD_IM = 10
GD_PHONENUMBER = 11
GD_POSTALADDRESS = 12
GD_RATING = 13
BLOBKEY = 17
ENTITY_PROTO = 19
EMPTY_LIST = 24
INDEX_VALUE = 18
_Meaning_NAMES = {
0: "NO_MEANING",
14: "BLOB",
15: "TEXT",
16: "BYTESTRING",
1: "ATOM_CATEGORY",
2: "ATOM_LINK",
3: "ATOM_TITLE",
4: "ATOM_CONTENT",
5: "ATOM_SUMMARY",
6: "ATOM_AUTHOR",
7: "GD_WHEN",
8: "GD_EMAIL",
9: "GEORSS_POINT",
10: "GD_IM",
11: "GD_PHONENUMBER",
12: "GD_POSTALADDRESS",
13: "GD_RATING",
17: "BLOBKEY",
19: "ENTITY_PROTO",
24: "EMPTY_LIST",
18: "INDEX_VALUE",
}
def Meaning_Name(cls, x):
return cls._Meaning_NAMES.get(x, "")
Meaning_Name = classmethod(Meaning_Name)
has_meaning_ = 0
meaning_ = 0
has_meaning_uri_ = 0
meaning_uri_ = ""
has_name_ = 0
name_ = ""
has_value_ = 0
has_multiple_ = 0
multiple_ = 0
has_stashed_ = 0
stashed_ = -1
has_computed_ = 0
computed_ = 0
def __init__(self, contents=None):
self.value_ = PropertyValue()
if contents is not None:
self.MergeFromString(contents)
def meaning(self):
return self.meaning_
def set_meaning(self, x):
self.has_meaning_ = 1
self.meaning_ = x
def clear_meaning(self):
if self.has_meaning_:
self.has_meaning_ = 0
self.meaning_ = 0
def has_meaning(self):
return self.has_meaning_
def meaning_uri(self):
return self.meaning_uri_
def set_meaning_uri(self, x):
self.has_meaning_uri_ = 1
self.meaning_uri_ = x
def clear_meaning_uri(self):
if self.has_meaning_uri_:
self.has_meaning_uri_ = 0
self.meaning_uri_ = ""
def has_meaning_uri(self):
return self.has_meaning_uri_
def name(self):
return self.name_
def set_name(self, x):
self.has_name_ = 1
self.name_ = x
def clear_name(self):
if self.has_name_:
self.has_name_ = 0
self.name_ = ""
def has_name(self):
return self.has_name_
def value(self):
return self.value_
def mutable_value(self):
self.has_value_ = 1
return self.value_
def clear_value(self):
self.has_value_ = 0
self.value_.Clear()
def has_value(self):
return self.has_value_
def multiple(self):
return self.multiple_
def set_multiple(self, x):
self.has_multiple_ = 1
self.multiple_ = x
def clear_multiple(self):
if self.has_multiple_:
self.has_multiple_ = 0
self.multiple_ = 0
def has_multiple(self):
return self.has_multiple_
def stashed(self):
return self.stashed_
def set_stashed(self, x):
self.has_stashed_ = 1
self.stashed_ = x
def clear_stashed(self):
if self.has_stashed_:
self.has_stashed_ = 0
self.stashed_ = -1
def has_stashed(self):
return self.has_stashed_
def computed(self):
return self.computed_
def set_computed(self, x):
self.has_computed_ = 1
self.computed_ = x
def clear_computed(self):
if self.has_computed_:
self.has_computed_ = 0
self.computed_ = 0
def has_computed(self):
return self.has_computed_
def MergeFrom(self, x):
assert x is not self
if x.has_meaning():
self.set_meaning(x.meaning())
if x.has_meaning_uri():
self.set_meaning_uri(x.meaning_uri())
if x.has_name():
self.set_name(x.name())
if x.has_value():
self.mutable_value().MergeFrom(x.value())
if x.has_multiple():
self.set_multiple(x.multiple())
if x.has_stashed():
self.set_stashed(x.stashed())
if x.has_computed():
self.set_computed(x.computed())
def Equals(self, x):
if x is self:
return 1
if self.has_meaning_ != x.has_meaning_:
return 0
if self.has_meaning_ and self.meaning_ != x.meaning_:
return 0
if self.has_meaning_uri_ != x.has_meaning_uri_:
return 0
if self.has_meaning_uri_ and self.meaning_uri_ != x.meaning_uri_:
return 0
if self.has_name_ != x.has_name_:
return 0
if self.has_name_ and self.name_ != x.name_:
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_multiple_ != x.has_multiple_:
return 0
if self.has_multiple_ and self.multiple_ != x.multiple_:
return 0
if self.has_stashed_ != x.has_stashed_:
return 0
if self.has_stashed_ and self.stashed_ != x.stashed_:
return 0
if self.has_computed_ != x.has_computed_:
return 0
if self.has_computed_ and self.computed_ != x.computed_:
return 0
return 1
def IsInitialized(self, debug_strs=None):
initialized = 1
if not self.has_name_:
initialized = 0
if debug_strs is not None:
debug_strs.append("Required field: name not set.")
if not self.has_value_:
initialized = 0
if debug_strs is not None:
debug_strs.append("Required field: value not set.")
elif not self.value_.IsInitialized(debug_strs):
initialized = 0
if not self.has_multiple_:
initialized = 0
if debug_strs is not None:
debug_strs.append("Required field: multiple not set.")
return initialized
def ByteSize(self):
n = 0
if self.has_meaning_:
n += 1 + self.lengthVarInt64(self.meaning_)
if self.has_meaning_uri_:
n += 1 + self.lengthString(len(self.meaning_uri_))
n += self.lengthString(len(self.name_))
n += self.lengthString(self.value_.ByteSize())
if self.has_stashed_:
n += 1 + self.lengthVarInt64(self.stashed_)
if self.has_computed_:
n += 2
return n + 4
def ByteSizePartial(self):
n = 0
if self.has_meaning_:
n += 1 + self.lengthVarInt64(self.meaning_)
if self.has_meaning_uri_:
n += 1 + self.lengthString(len(self.meaning_uri_))
if self.has_name_:
n += 1
n += self.lengthString(len(self.name_))
if self.has_value_:
n += 1
n += self.lengthString(self.value_.ByteSizePartial())
if self.has_multiple_:
n += 2
if self.has_stashed_:
n += 1 + self.lengthVarInt64(self.stashed_)
if self.has_computed_:
n += 2
return n
def Clear(self):
self.clear_meaning()
self.clear_meaning_uri()
self.clear_name()
self.clear_value()
self.clear_multiple()
self.clear_stashed()
self.clear_computed()
def OutputUnchecked(self, out):
if self.has_meaning_:
out.putVarInt32(8)
out.putVarInt32(self.meaning_)
if self.has_meaning_uri_:
out.putVarInt32(18)
out.putPrefixedString(self.meaning_uri_)
out.putVarInt32(26)
out.putPrefixedString(self.name_)
out.putVarInt32(32)
out.putBoolean(self.multiple_)
out.putVarInt32(42)
out.putVarInt32(self.value_.ByteSize())
self.value_.OutputUnchecked(out)
if self.has_stashed_:
out.putVarInt32(48)
out.putVarInt32(self.stashed_)
if self.has_computed_:
out.putVarInt32(56)
out.putBoolean(self.computed_)
def OutputPartial(self, out):
if self.has_meaning_:
out.putVarInt32(8)
out.putVarInt32(self.meaning_)
if self.has_meaning_uri_:
out.putVarInt32(18)
out.putPrefixedString(self.meaning_uri_)
if self.has_name_:
out.putVarInt32(26)
out.putPrefixedString(self.name_)
if self.has_multiple_:
out.putVarInt32(32)
out.putBoolean(self.multiple_)
if self.has_value_:
out.putVarInt32(42)
out.putVarInt32(self.value_.ByteSizePartial())
self.value_.OutputPartial(out)
if self.has_stashed_:
out.putVarInt32(48)
out.putVarInt32(self.stashed_)
if self.has_computed_:
out.putVarInt32(56)
out.putBoolean(self.computed_)
def TryMerge(self, d):
while d.avail() > 0:
tt = d.getVarInt32()
if tt == 8:
self.set_meaning(d.getVarInt32())
continue
if tt == 18:
self.set_meaning_uri(d.getPrefixedString())
continue
if tt == 26:
self.set_name(d.getPrefixedString())
continue
if tt == 32:
self.set_multiple(d.getBoolean())
continue
if tt == 42:
length = d.getVarInt32()
tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
d.skip(length)
self.mutable_value().TryMerge(tmp)
continue
if tt == 48:
self.set_stashed(d.getVarInt32())
continue
if tt == 56:
self.set_computed(d.getBoolean())
continue
# tag 0 is special: it's used to indicate an error.
# so if we see it we raise an exception.
if tt == 0:
raise ProtocolBuffer.ProtocolBufferDecodeError()
d.skipData(tt)
def __str__(self, prefix="", printElemNumber=0):
res = ""
if self.has_meaning_:
res += prefix + ("meaning: %s\n" % self.DebugFormatInt32(self.meaning_))
if self.has_meaning_uri_:
res += prefix + (
"meaning_uri: %s\n" % self.DebugFormatString(self.meaning_uri_)
)
if self.has_name_:
res += prefix + ("name: %s\n" % self.DebugFormatString(self.name_))
if self.has_value_:
res += prefix + "value <\n"
res += self.value_.__str__(prefix + " ", printElemNumber)
res += prefix + ">\n"
if self.has_multiple_:
res += prefix + ("multiple: %s\n" % self.DebugFormatBool(self.multiple_))
if self.has_stashed_:
res += prefix + ("stashed: %s\n" % self.DebugFormatInt32(self.stashed_))
if self.has_computed_:
res += prefix + ("computed: %s\n" % self.DebugFormatBool(self.computed_))
return res
def _BuildTagLookupTable(sparse, maxtag, default=None):
return tuple([sparse.get(i, default) for i in range(0, 1 + maxtag)])
kmeaning = 1
kmeaning_uri = 2
kname = 3
kvalue = 5
kmultiple = 4
kstashed = 6
kcomputed = 7
_TEXT = _BuildTagLookupTable(
{
0: "ErrorCode",
1: "meaning",
2: "meaning_uri",
3: "name",
4: "multiple",
5: "value",
6: "stashed",
7: "computed",
},
7,
)
_TYPES = _BuildTagLookupTable(
{
0: ProtocolBuffer.Encoder.NUMERIC,
1: ProtocolBuffer.Encoder.NUMERIC,
2: ProtocolBuffer.Encoder.STRING,
3: ProtocolBuffer.Encoder.STRING,
4: ProtocolBuffer.Encoder.NUMERIC,
5: ProtocolBuffer.Encoder.STRING,
6: ProtocolBuffer.Encoder.NUMERIC,
7: ProtocolBuffer.Encoder.NUMERIC,
},
7,
ProtocolBuffer.Encoder.MAX_TYPE,
)
# stylesheet for XML output
_STYLE = """"""
_STYLE_CONTENT_TYPE = """"""
_PROTO_DESCRIPTOR_NAME = "storage_onestore_v3.Property"
class Path_Element(ProtocolBuffer.ProtocolMessage):
has_type_ = 0
type_ = ""
has_id_ = 0
id_ = 0
has_name_ = 0
name_ = ""
def __init__(self, contents=None):
if contents is not None:
self.MergeFromString(contents)
def type(self):
return self.type_
def set_type(self, x):
self.has_type_ = 1
self.type_ = x
def clear_type(self):
if self.has_type_:
self.has_type_ = 0
self.type_ = ""
def has_type(self):
return self.has_type_
def id(self):
return self.id_
def set_id(self, x):
self.has_id_ = 1
self.id_ = x
def clear_id(self):
if self.has_id_:
self.has_id_ = 0
self.id_ = 0
def has_id(self):
return self.has_id_
def name(self):
return self.name_
def set_name(self, x):
self.has_name_ = 1
self.name_ = x
def clear_name(self):
if self.has_name_:
self.has_name_ = 0
self.name_ = ""
def has_name(self):
return self.has_name_
def MergeFrom(self, x):
assert x is not self
if x.has_type():
self.set_type(x.type())
if x.has_id():
self.set_id(x.id())
if x.has_name():
self.set_name(x.name())
def Equals(self, x):
if x is self:
return 1
if self.has_type_ != x.has_type_:
return 0
if self.has_type_ and self.type_ != x.type_:
return 0
if self.has_id_ != x.has_id_:
return 0
if self.has_id_ and self.id_ != x.id_:
return 0
if self.has_name_ != x.has_name_:
return 0
if self.has_name_ and self.name_ != x.name_:
return 0
return 1
def IsInitialized(self, debug_strs=None):
initialized = 1
if not self.has_type_:
initialized = 0
if debug_strs is not None:
debug_strs.append("Required field: type not set.")
return initialized
def ByteSize(self):
n = 0
n += self.lengthString(len(self.type_))
if self.has_id_:
n += 1 + self.lengthVarInt64(self.id_)
if self.has_name_:
n += 1 + self.lengthString(len(self.name_))
return n + 1
def ByteSizePartial(self):
n = 0
if self.has_type_:
n += 1
n += self.lengthString(len(self.type_))
if self.has_id_:
n += 1 + self.lengthVarInt64(self.id_)
if self.has_name_:
n += 1 + self.lengthString(len(self.name_))
return n
def Clear(self):
self.clear_type()
self.clear_id()
self.clear_name()
def OutputUnchecked(self, out):
out.putVarInt32(18)
out.putPrefixedString(self.type_)
if self.has_id_:
out.putVarInt32(24)
out.putVarInt64(self.id_)
if self.has_name_:
out.putVarInt32(34)
out.putPrefixedString(self.name_)
def OutputPartial(self, out):
if self.has_type_:
out.putVarInt32(18)
out.putPrefixedString(self.type_)
if self.has_id_:
out.putVarInt32(24)
out.putVarInt64(self.id_)
if self.has_name_:
out.putVarInt32(34)
out.putPrefixedString(self.name_)
def TryMerge(self, d):
while 1:
tt = d.getVarInt32()
if tt == 12:
break
if tt == 18:
self.set_type(d.getPrefixedString())
continue
if tt == 24:
self.set_id(d.getVarInt64())
continue
if tt == 34:
self.set_name(d.getPrefixedString())
continue
# tag 0 is special: it's used to indicate an error.
# so if we see it we raise an exception.
if tt == 0:
raise ProtocolBuffer.ProtocolBufferDecodeError()
d.skipData(tt)
def __str__(self, prefix="", printElemNumber=0):
res = ""
if self.has_type_:
res += prefix + ("type: %s\n" % self.DebugFormatString(self.type_))
if self.has_id_:
res += prefix + ("id: %s\n" % self.DebugFormatInt64(self.id_))
if self.has_name_:
res += prefix + ("name: %s\n" % self.DebugFormatString(self.name_))
return res
class Path(ProtocolBuffer.ProtocolMessage):
def __init__(self, contents=None):
self.element_ = []
if contents is not None:
self.MergeFromString(contents)
def element_size(self):
return len(self.element_)
def element_list(self):
return self.element_
def element(self, i):
return self.element_[i]
def mutable_element(self, i):
return self.element_[i]
def add_element(self):
x = Path_Element()
self.element_.append(x)
return x
def clear_element(self):
self.element_ = []
def MergeFrom(self, x):
assert x is not self
for i in range(x.element_size()):
self.add_element().CopyFrom(x.element(i))
def Equals(self, x):
if x is self:
return 1
if len(self.element_) != len(x.element_):
return 0
for e1, e2 in zip(self.element_, x.element_):
if e1 != e2:
return 0
return 1
def IsInitialized(self, debug_strs=None):
initialized = 1
for p in self.element_:
if not p.IsInitialized(debug_strs):
initialized = 0
return initialized
def ByteSize(self):
n = 0
n += 2 * len(self.element_)
for i in range(len(self.element_)):
n += self.element_[i].ByteSize()
return n
def ByteSizePartial(self):
n = 0
n += 2 * len(self.element_)
for i in range(len(self.element_)):
n += self.element_[i].ByteSizePartial()
return n
def Clear(self):
self.clear_element()
def OutputUnchecked(self, out):
for i in range(len(self.element_)):
out.putVarInt32(11)
self.element_[i].OutputUnchecked(out)
out.putVarInt32(12)
def OutputPartial(self, out):
for i in range(len(self.element_)):
out.putVarInt32(11)
self.element_[i].OutputPartial(out)
out.putVarInt32(12)
def TryMerge(self, d):
while d.avail() > 0:
tt = d.getVarInt32()
if tt == 11:
self.add_element().TryMerge(d)
continue
# tag 0 is special: it's used to indicate an error.
# so if we see it we raise an exception.
if tt == 0:
raise ProtocolBuffer.ProtocolBufferDecodeError()
d.skipData(tt)
def __str__(self, prefix="", printElemNumber=0):
res = ""
cnt = 0
for e in self.element_:
elm = ""
if printElemNumber:
elm = "(%d)" % cnt
res += prefix + "Element%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 range(0, 1 + maxtag)])
kElementGroup = 1
kElementtype = 2
kElementid = 3
kElementname = 4
_TEXT = _BuildTagLookupTable(
{
0: "ErrorCode",
1: "Element",
2: "type",
3: "id",
4: "name",
},
4,
)
_TYPES = _BuildTagLookupTable(
{
0: ProtocolBuffer.Encoder.NUMERIC,
1: ProtocolBuffer.Encoder.STARTGROUP,
2: ProtocolBuffer.Encoder.STRING,
3: ProtocolBuffer.Encoder.NUMERIC,
4: ProtocolBuffer.Encoder.STRING,
},
4,
ProtocolBuffer.Encoder.MAX_TYPE,
)
# stylesheet for XML output
_STYLE = """"""
_STYLE_CONTENT_TYPE = """"""
_PROTO_DESCRIPTOR_NAME = "storage_onestore_v3.Path"
class Reference(ProtocolBuffer.ProtocolMessage):
has_app_ = 0
app_ = ""
has_name_space_ = 0
name_space_ = ""
has_path_ = 0
has_database_id_ = 0
database_id_ = ""
def __init__(self, contents=None):
self.path_ = Path()
if contents is not None:
self.MergeFromString(contents)
def app(self):
return self.app_
def set_app(self, x):
self.has_app_ = 1
self.app_ = x
def clear_app(self):
if self.has_app_:
self.has_app_ = 0
self.app_ = ""
def has_app(self):
return self.has_app_
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 path(self):
return self.path_
def mutable_path(self):
self.has_path_ = 1
return self.path_
def clear_path(self):
self.has_path_ = 0
self.path_.Clear()
def has_path(self):
return self.has_path_
def database_id(self):
return self.database_id_
def set_database_id(self, x):
self.has_database_id_ = 1
self.database_id_ = x
def clear_database_id(self):
if self.has_database_id_:
self.has_database_id_ = 0
self.database_id_ = ""
def has_database_id(self):
return self.has_database_id_
def MergeFrom(self, x):
assert x is not self
if x.has_app():
self.set_app(x.app())
if x.has_name_space():
self.set_name_space(x.name_space())
if x.has_path():
self.mutable_path().MergeFrom(x.path())
if x.has_database_id():
self.set_database_id(x.database_id())
def Equals(self, x):
if x is self:
return 1
if self.has_app_ != x.has_app_:
return 0
if self.has_app_ and self.app_ != x.app_:
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_path_ != x.has_path_:
return 0
if self.has_path_ and self.path_ != x.path_:
return 0
if self.has_database_id_ != x.has_database_id_:
return 0
if self.has_database_id_ and self.database_id_ != x.database_id_:
return 0
return 1
def IsInitialized(self, debug_strs=None):
initialized = 1
if not self.has_app_:
initialized = 0
if debug_strs is not None:
debug_strs.append("Required field: app not set.")
if not self.has_path_:
initialized = 0
if debug_strs is not None:
debug_strs.append("Required field: path not set.")
elif not self.path_.IsInitialized(debug_strs):
initialized = 0
return initialized
def ByteSize(self):
n = 0
n += self.lengthString(len(self.app_))
if self.has_name_space_:
n += 2 + self.lengthString(len(self.name_space_))
n += self.lengthString(self.path_.ByteSize())
if self.has_database_id_:
n += 2 + self.lengthString(len(self.database_id_))
return n + 2
def ByteSizePartial(self):
n = 0
if self.has_app_:
n += 1
n += self.lengthString(len(self.app_))
if self.has_name_space_:
n += 2 + self.lengthString(len(self.name_space_))
if self.has_path_:
n += 1
n += self.lengthString(self.path_.ByteSizePartial())
if self.has_database_id_:
n += 2 + self.lengthString(len(self.database_id_))
return n
def Clear(self):
self.clear_app()
self.clear_name_space()
self.clear_path()
self.clear_database_id()
def OutputUnchecked(self, out):
out.putVarInt32(106)
out.putPrefixedString(self.app_)
out.putVarInt32(114)
out.putVarInt32(self.path_.ByteSize())
self.path_.OutputUnchecked(out)
if self.has_name_space_:
out.putVarInt32(162)
out.putPrefixedString(self.name_space_)
if self.has_database_id_:
out.putVarInt32(186)
out.putPrefixedString(self.database_id_)
def OutputPartial(self, out):
if self.has_app_:
out.putVarInt32(106)
out.putPrefixedString(self.app_)
if self.has_path_:
out.putVarInt32(114)
out.putVarInt32(self.path_.ByteSizePartial())
self.path_.OutputPartial(out)
if self.has_name_space_:
out.putVarInt32(162)
out.putPrefixedString(self.name_space_)
if self.has_database_id_:
out.putVarInt32(186)
out.putPrefixedString(self.database_id_)
def TryMerge(self, d):
while d.avail() > 0:
tt = d.getVarInt32()
if tt == 106:
self.set_app(d.getPrefixedString())
continue
if tt == 114:
length = d.getVarInt32()
tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
d.skip(length)
self.mutable_path().TryMerge(tmp)
continue
if tt == 162:
self.set_name_space(d.getPrefixedString())
continue
if tt == 186:
self.set_database_id(d.getPrefixedString())
continue
# tag 0 is special: it's used to indicate an error.
# so if we see it we raise an exception.
if tt == 0:
raise ProtocolBuffer.ProtocolBufferDecodeError()
d.skipData(tt)
def __str__(self, prefix="", printElemNumber=0):
res = ""
if self.has_app_:
res += prefix + ("app: %s\n" % self.DebugFormatString(self.app_))
if self.has_name_space_:
res += prefix + (
"name_space: %s\n" % self.DebugFormatString(self.name_space_)
)
if self.has_path_:
res += prefix + "path <\n"
res += self.path_.__str__(prefix + " ", printElemNumber)
res += prefix + ">\n"
if self.has_database_id_:
res += prefix + (
"database_id: %s\n" % self.DebugFormatString(self.database_id_)
)
return res
def _BuildTagLookupTable(sparse, maxtag, default=None):
return tuple([sparse.get(i, default) for i in range(0, 1 + maxtag)])
kapp = 13
kname_space = 20
kpath = 14
kdatabase_id = 23
_TEXT = _BuildTagLookupTable(
{
0: "ErrorCode",
13: "app",
14: "path",
20: "name_space",
23: "database_id",
},
23,
)
_TYPES = _BuildTagLookupTable(
{
0: ProtocolBuffer.Encoder.NUMERIC,
13: ProtocolBuffer.Encoder.STRING,
14: ProtocolBuffer.Encoder.STRING,
20: ProtocolBuffer.Encoder.STRING,
23: ProtocolBuffer.Encoder.STRING,
},
23,
ProtocolBuffer.Encoder.MAX_TYPE,
)
# stylesheet for XML output
_STYLE = """"""
_STYLE_CONTENT_TYPE = """"""
_PROTO_DESCRIPTOR_NAME = "storage_onestore_v3.Reference"
class User(ProtocolBuffer.ProtocolMessage):
has_email_ = 0
email_ = ""
has_auth_domain_ = 0
auth_domain_ = ""
has_nickname_ = 0
nickname_ = ""
has_gaiaid_ = 0
gaiaid_ = 0
has_obfuscated_gaiaid_ = 0
obfuscated_gaiaid_ = ""
has_federated_identity_ = 0
federated_identity_ = ""
has_federated_provider_ = 0
federated_provider_ = ""
def __init__(self, contents=None):
if contents is not None:
self.MergeFromString(contents)
def email(self):
return self.email_
def set_email(self, x):
self.has_email_ = 1
self.email_ = x
def clear_email(self):
if self.has_email_:
self.has_email_ = 0
self.email_ = ""
def has_email(self):
return self.has_email_
def auth_domain(self):
return self.auth_domain_
def set_auth_domain(self, x):
self.has_auth_domain_ = 1
self.auth_domain_ = x
def clear_auth_domain(self):
if self.has_auth_domain_:
self.has_auth_domain_ = 0
self.auth_domain_ = ""
def has_auth_domain(self):
return self.has_auth_domain_
def nickname(self):
return self.nickname_
def set_nickname(self, x):
self.has_nickname_ = 1
self.nickname_ = x
def clear_nickname(self):
if self.has_nickname_:
self.has_nickname_ = 0
self.nickname_ = ""
def has_nickname(self):
return self.has_nickname_
def gaiaid(self):
return self.gaiaid_
def set_gaiaid(self, x):
self.has_gaiaid_ = 1
self.gaiaid_ = x
def clear_gaiaid(self):
if self.has_gaiaid_:
self.has_gaiaid_ = 0
self.gaiaid_ = 0
def has_gaiaid(self):
return self.has_gaiaid_
def obfuscated_gaiaid(self):
return self.obfuscated_gaiaid_
def set_obfuscated_gaiaid(self, x):
self.has_obfuscated_gaiaid_ = 1
self.obfuscated_gaiaid_ = x
def clear_obfuscated_gaiaid(self):
if self.has_obfuscated_gaiaid_:
self.has_obfuscated_gaiaid_ = 0
self.obfuscated_gaiaid_ = ""
def has_obfuscated_gaiaid(self):
return self.has_obfuscated_gaiaid_
def federated_identity(self):
return self.federated_identity_
def set_federated_identity(self, x):
self.has_federated_identity_ = 1
self.federated_identity_ = x
def clear_federated_identity(self):
if self.has_federated_identity_:
self.has_federated_identity_ = 0
self.federated_identity_ = ""
def has_federated_identity(self):
return self.has_federated_identity_
def federated_provider(self):
return self.federated_provider_
def set_federated_provider(self, x):
self.has_federated_provider_ = 1
self.federated_provider_ = x
def clear_federated_provider(self):
if self.has_federated_provider_:
self.has_federated_provider_ = 0
self.federated_provider_ = ""
def has_federated_provider(self):
return self.has_federated_provider_
def MergeFrom(self, x):
assert x is not self
if x.has_email():
self.set_email(x.email())
if x.has_auth_domain():
self.set_auth_domain(x.auth_domain())
if x.has_nickname():
self.set_nickname(x.nickname())
if x.has_gaiaid():
self.set_gaiaid(x.gaiaid())
if x.has_obfuscated_gaiaid():
self.set_obfuscated_gaiaid(x.obfuscated_gaiaid())
if x.has_federated_identity():
self.set_federated_identity(x.federated_identity())
if x.has_federated_provider():
self.set_federated_provider(x.federated_provider())
def Equals(self, x):
if x is self:
return 1
if self.has_email_ != x.has_email_:
return 0
if self.has_email_ and self.email_ != x.email_:
return 0
if self.has_auth_domain_ != x.has_auth_domain_:
return 0
if self.has_auth_domain_ and self.auth_domain_ != x.auth_domain_:
return 0
if self.has_nickname_ != x.has_nickname_:
return 0
if self.has_nickname_ and self.nickname_ != x.nickname_:
return 0
if self.has_gaiaid_ != x.has_gaiaid_:
return 0
if self.has_gaiaid_ and self.gaiaid_ != x.gaiaid_:
return 0
if self.has_obfuscated_gaiaid_ != x.has_obfuscated_gaiaid_:
return 0
if (
self.has_obfuscated_gaiaid_
and self.obfuscated_gaiaid_ != x.obfuscated_gaiaid_
):
return 0
if self.has_federated_identity_ != x.has_federated_identity_:
return 0
if (
self.has_federated_identity_
and self.federated_identity_ != x.federated_identity_
):
return 0
if self.has_federated_provider_ != x.has_federated_provider_:
return 0
if (
self.has_federated_provider_
and self.federated_provider_ != x.federated_provider_
):
return 0
return 1
def IsInitialized(self, debug_strs=None):
initialized = 1
if not self.has_email_:
initialized = 0
if debug_strs is not None:
debug_strs.append("Required field: email not set.")
if not self.has_auth_domain_:
initialized = 0
if debug_strs is not None:
debug_strs.append("Required field: auth_domain not set.")
if not self.has_gaiaid_:
initialized = 0
if debug_strs is not None:
debug_strs.append("Required field: gaiaid not set.")
return initialized
def ByteSize(self):
n = 0
n += self.lengthString(len(self.email_))
n += self.lengthString(len(self.auth_domain_))
if self.has_nickname_:
n += 1 + self.lengthString(len(self.nickname_))
n += self.lengthVarInt64(self.gaiaid_)
if self.has_obfuscated_gaiaid_:
n += 1 + self.lengthString(len(self.obfuscated_gaiaid_))
if self.has_federated_identity_:
n += 1 + self.lengthString(len(self.federated_identity_))
if self.has_federated_provider_:
n += 1 + self.lengthString(len(self.federated_provider_))
return n + 3
def ByteSizePartial(self):
n = 0
if self.has_email_:
n += 1
n += self.lengthString(len(self.email_))
if self.has_auth_domain_:
n += 1
n += self.lengthString(len(self.auth_domain_))
if self.has_nickname_:
n += 1 + self.lengthString(len(self.nickname_))
if self.has_gaiaid_:
n += 1
n += self.lengthVarInt64(self.gaiaid_)
if self.has_obfuscated_gaiaid_:
n += 1 + self.lengthString(len(self.obfuscated_gaiaid_))
if self.has_federated_identity_:
n += 1 + self.lengthString(len(self.federated_identity_))
if self.has_federated_provider_:
n += 1 + self.lengthString(len(self.federated_provider_))
return n
def Clear(self):
self.clear_email()
self.clear_auth_domain()
self.clear_nickname()
self.clear_gaiaid()
self.clear_obfuscated_gaiaid()
self.clear_federated_identity()
self.clear_federated_provider()
def OutputUnchecked(self, out):
out.putVarInt32(10)
out.putPrefixedString(self.email_)
out.putVarInt32(18)
out.putPrefixedString(self.auth_domain_)
if self.has_nickname_:
out.putVarInt32(26)
out.putPrefixedString(self.nickname_)
out.putVarInt32(32)
out.putVarInt64(self.gaiaid_)
if self.has_obfuscated_gaiaid_:
out.putVarInt32(42)
out.putPrefixedString(self.obfuscated_gaiaid_)
if self.has_federated_identity_:
out.putVarInt32(50)
out.putPrefixedString(self.federated_identity_)
if self.has_federated_provider_:
out.putVarInt32(58)
out.putPrefixedString(self.federated_provider_)
def OutputPartial(self, out):
if self.has_email_:
out.putVarInt32(10)
out.putPrefixedString(self.email_)
if self.has_auth_domain_:
out.putVarInt32(18)
out.putPrefixedString(self.auth_domain_)
if self.has_nickname_:
out.putVarInt32(26)
out.putPrefixedString(self.nickname_)
if self.has_gaiaid_:
out.putVarInt32(32)
out.putVarInt64(self.gaiaid_)
if self.has_obfuscated_gaiaid_:
out.putVarInt32(42)
out.putPrefixedString(self.obfuscated_gaiaid_)
if self.has_federated_identity_:
out.putVarInt32(50)
out.putPrefixedString(self.federated_identity_)
if self.has_federated_provider_:
out.putVarInt32(58)
out.putPrefixedString(self.federated_provider_)
def TryMerge(self, d):
while d.avail() > 0:
tt = d.getVarInt32()
if tt == 10:
self.set_email(d.getPrefixedString())
continue
if tt == 18:
self.set_auth_domain(d.getPrefixedString())
continue
if tt == 26:
self.set_nickname(d.getPrefixedString())
continue
if tt == 32:
self.set_gaiaid(d.getVarInt64())
continue
if tt == 42:
self.set_obfuscated_gaiaid(d.getPrefixedString())
continue
if tt == 50:
self.set_federated_identity(d.getPrefixedString())
continue
if tt == 58:
self.set_federated_provider(d.getPrefixedString())
continue
# tag 0 is special: it's used to indicate an error.
# so if we see it we raise an exception.
if tt == 0:
raise ProtocolBuffer.ProtocolBufferDecodeError()
d.skipData(tt)
def __str__(self, prefix="", printElemNumber=0):
res = ""
if self.has_email_:
res += prefix + ("email: %s\n" % self.DebugFormatString(self.email_))
if self.has_auth_domain_:
res += prefix + (
"auth_domain: %s\n" % self.DebugFormatString(self.auth_domain_)
)
if self.has_nickname_:
res += prefix + (
"nickname: %s\n" % self.DebugFormatString(self.nickname_)
)
if self.has_gaiaid_:
res += prefix + ("gaiaid: %s\n" % self.DebugFormatInt64(self.gaiaid_))
if self.has_obfuscated_gaiaid_:
res += prefix + (
"obfuscated_gaiaid: %s\n"
% self.DebugFormatString(self.obfuscated_gaiaid_)
)
if self.has_federated_identity_:
res += prefix + (
"federated_identity: %s\n"
% self.DebugFormatString(self.federated_identity_)
)
if self.has_federated_provider_:
res += prefix + (
"federated_provider: %s\n"
% self.DebugFormatString(self.federated_provider_)
)
return res
def _BuildTagLookupTable(sparse, maxtag, default=None):
return tuple([sparse.get(i, default) for i in range(0, 1 + maxtag)])
kemail = 1
kauth_domain = 2
knickname = 3
kgaiaid = 4
kobfuscated_gaiaid = 5
kfederated_identity = 6
kfederated_provider = 7
_TEXT = _BuildTagLookupTable(
{
0: "ErrorCode",
1: "email",
2: "auth_domain",
3: "nickname",
4: "gaiaid",
5: "obfuscated_gaiaid",
6: "federated_identity",
7: "federated_provider",
},
7,
)
_TYPES = _BuildTagLookupTable(
{
0: ProtocolBuffer.Encoder.NUMERIC,
1: ProtocolBuffer.Encoder.STRING,
2: ProtocolBuffer.Encoder.STRING,
3: ProtocolBuffer.Encoder.STRING,
4: ProtocolBuffer.Encoder.NUMERIC,
5: ProtocolBuffer.Encoder.STRING,
6: ProtocolBuffer.Encoder.STRING,
7: ProtocolBuffer.Encoder.STRING,
},
7,
ProtocolBuffer.Encoder.MAX_TYPE,
)
# stylesheet for XML output
_STYLE = """"""
_STYLE_CONTENT_TYPE = """"""
_PROTO_DESCRIPTOR_NAME = "storage_onestore_v3.User"
class EntityProto(ProtocolBuffer.ProtocolMessage):
# Kind values
GD_CONTACT = 1
GD_EVENT = 2
GD_MESSAGE = 3
_Kind_NAMES = {
1: "GD_CONTACT",
2: "GD_EVENT",
3: "GD_MESSAGE",
}
def Kind_Name(cls, x):
return cls._Kind_NAMES.get(x, "")
Kind_Name = classmethod(Kind_Name)
has_key_ = 0
has_entity_group_ = 0
has_owner_ = 0
owner_ = None
has_kind_ = 0
kind_ = 0
has_kind_uri_ = 0
kind_uri_ = ""
def __init__(self, contents=None):
self.key_ = Reference()
self.entity_group_ = Path()
self.property_ = []
self.raw_property_ = []
self.lazy_init_lock_ = _Lock()
if contents is not None:
self.MergeFromString(contents)
def key(self):
return self.key_
def mutable_key(self):
self.has_key_ = 1
return self.key_
def clear_key(self):
self.has_key_ = 0
self.key_.Clear()
def has_key(self):
return self.has_key_
def entity_group(self):
return self.entity_group_
def mutable_entity_group(self):
self.has_entity_group_ = 1
return self.entity_group_
def clear_entity_group(self):
self.has_entity_group_ = 0
self.entity_group_.Clear()
def has_entity_group(self):
return self.has_entity_group_
def owner(self):
if self.owner_ is None:
self.lazy_init_lock_.acquire()
try:
if self.owner_ is None:
self.owner_ = User()
finally:
self.lazy_init_lock_.release()
return self.owner_
def mutable_owner(self):
self.has_owner_ = 1
return self.owner()
def clear_owner(self):
# Warning: this method does not acquire the lock.
if self.has_owner_:
self.has_owner_ = 0
if self.owner_ is not None:
self.owner_.Clear()
def has_owner(self):
return self.has_owner_
def kind(self):
return self.kind_
def set_kind(self, x):
self.has_kind_ = 1
self.kind_ = x
def clear_kind(self):
if self.has_kind_:
self.has_kind_ = 0
self.kind_ = 0
def has_kind(self):
return self.has_kind_
def kind_uri(self):
return self.kind_uri_
def set_kind_uri(self, x):
self.has_kind_uri_ = 1
self.kind_uri_ = x
def clear_kind_uri(self):
if self.has_kind_uri_:
self.has_kind_uri_ = 0
self.kind_uri_ = ""
def has_kind_uri(self):
return self.has_kind_uri_
def property_size(self):
return len(self.property_)
def property_list(self):
return self.property_
def property(self, i):
return self.property_[i]
def mutable_property(self, i):
return self.property_[i]
def add_property(self):
x = Property()
self.property_.append(x)
return x
def clear_property(self):
self.property_ = []
def raw_property_size(self):
return len(self.raw_property_)
def raw_property_list(self):
return self.raw_property_
def raw_property(self, i):
return self.raw_property_[i]
def mutable_raw_property(self, i):
return self.raw_property_[i]
def add_raw_property(self):
x = Property()
self.raw_property_.append(x)
return x
def clear_raw_property(self):
self.raw_property_ = []
def MergeFrom(self, x):
assert x is not self
if x.has_key():
self.mutable_key().MergeFrom(x.key())
if x.has_entity_group():
self.mutable_entity_group().MergeFrom(x.entity_group())
if x.has_owner():
self.mutable_owner().MergeFrom(x.owner())
if x.has_kind():
self.set_kind(x.kind())
if x.has_kind_uri():
self.set_kind_uri(x.kind_uri())
for i in range(x.property_size()):
self.add_property().CopyFrom(x.property(i))
for i in range(x.raw_property_size()):
self.add_raw_property().CopyFrom(x.raw_property(i))
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_entity_group_ != x.has_entity_group_:
return 0
if self.has_entity_group_ and self.entity_group_ != x.entity_group_:
return 0
if self.has_owner_ != x.has_owner_:
return 0
if self.has_owner_ and self.owner_ != x.owner_:
return 0
if self.has_kind_ != x.has_kind_:
return 0
if self.has_kind_ and self.kind_ != x.kind_:
return 0
if self.has_kind_uri_ != x.has_kind_uri_:
return 0
if self.has_kind_uri_ and self.kind_uri_ != x.kind_uri_:
return 0
if len(self.property_) != len(x.property_):
return 0
for e1, e2 in zip(self.property_, x.property_):
if e1 != e2:
return 0
if len(self.raw_property_) != len(x.raw_property_):
return 0
for e1, e2 in zip(self.raw_property_, x.raw_property_):
if e1 != e2:
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.")
elif not self.key_.IsInitialized(debug_strs):
initialized = 0
if not self.has_entity_group_:
initialized = 0
if debug_strs is not None:
debug_strs.append("Required field: entity_group not set.")
elif not self.entity_group_.IsInitialized(debug_strs):
initialized = 0
if self.has_owner_ and not self.owner_.IsInitialized(debug_strs):
initialized = 0
for p in self.property_:
if not p.IsInitialized(debug_strs):
initialized = 0
for p in self.raw_property_:
if not p.IsInitialized(debug_strs):
initialized = 0
return initialized
def ByteSize(self):
n = 0
n += self.lengthString(self.key_.ByteSize())
n += self.lengthString(self.entity_group_.ByteSize())
if self.has_owner_:
n += 2 + self.lengthString(self.owner_.ByteSize())
if self.has_kind_:
n += 1 + self.lengthVarInt64(self.kind_)
if self.has_kind_uri_:
n += 1 + self.lengthString(len(self.kind_uri_))
n += 1 * len(self.property_)
for i in range(len(self.property_)):
n += self.lengthString(self.property_[i].ByteSize())
n += 1 * len(self.raw_property_)
for i in range(len(self.raw_property_)):
n += self.lengthString(self.raw_property_[i].ByteSize())
return n + 3
def ByteSizePartial(self):
n = 0
if self.has_key_:
n += 1
n += self.lengthString(self.key_.ByteSizePartial())
if self.has_entity_group_:
n += 2
n += self.lengthString(self.entity_group_.ByteSizePartial())
if self.has_owner_:
n += 2 + self.lengthString(self.owner_.ByteSizePartial())
if self.has_kind_:
n += 1 + self.lengthVarInt64(self.kind_)
if self.has_kind_uri_:
n += 1 + self.lengthString(len(self.kind_uri_))
n += 1 * len(self.property_)
for i in range(len(self.property_)):
n += self.lengthString(self.property_[i].ByteSizePartial())
n += 1 * len(self.raw_property_)
for i in range(len(self.raw_property_)):
n += self.lengthString(self.raw_property_[i].ByteSizePartial())
return n
def Clear(self):
self.clear_key()
self.clear_entity_group()
self.clear_owner()
self.clear_kind()
self.clear_kind_uri()
self.clear_property()
self.clear_raw_property()
def OutputUnchecked(self, out):
if self.has_kind_:
out.putVarInt32(32)
out.putVarInt32(self.kind_)
if self.has_kind_uri_:
out.putVarInt32(42)
out.putPrefixedString(self.kind_uri_)
out.putVarInt32(106)
out.putVarInt32(self.key_.ByteSize())
self.key_.OutputUnchecked(out)
for i in range(len(self.property_)):
out.putVarInt32(114)
out.putVarInt32(self.property_[i].ByteSize())
self.property_[i].OutputUnchecked(out)
for i in range(len(self.raw_property_)):
out.putVarInt32(122)
out.putVarInt32(self.raw_property_[i].ByteSize())
self.raw_property_[i].OutputUnchecked(out)
out.putVarInt32(130)
out.putVarInt32(self.entity_group_.ByteSize())
self.entity_group_.OutputUnchecked(out)
if self.has_owner_:
out.putVarInt32(138)
out.putVarInt32(self.owner_.ByteSize())
self.owner_.OutputUnchecked(out)
def OutputPartial(self, out):
if self.has_kind_:
out.putVarInt32(32)
out.putVarInt32(self.kind_)
if self.has_kind_uri_:
out.putVarInt32(42)
out.putPrefixedString(self.kind_uri_)
if self.has_key_:
out.putVarInt32(106)
out.putVarInt32(self.key_.ByteSizePartial())
self.key_.OutputPartial(out)
for i in range(len(self.property_)):
out.putVarInt32(114)
out.putVarInt32(self.property_[i].ByteSizePartial())
self.property_[i].OutputPartial(out)
for i in range(len(self.raw_property_)):
out.putVarInt32(122)
out.putVarInt32(self.raw_property_[i].ByteSizePartial())
self.raw_property_[i].OutputPartial(out)
if self.has_entity_group_:
out.putVarInt32(130)
out.putVarInt32(self.entity_group_.ByteSizePartial())
self.entity_group_.OutputPartial(out)
if self.has_owner_:
out.putVarInt32(138)
out.putVarInt32(self.owner_.ByteSizePartial())
self.owner_.OutputPartial(out)
def TryMerge(self, d):
while d.avail() > 0:
tt = d.getVarInt32()
if tt == 32:
self.set_kind(d.getVarInt32())
continue
if tt == 42:
self.set_kind_uri(d.getPrefixedString())
continue
if tt == 106:
length = d.getVarInt32()
tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
d.skip(length)
self.mutable_key().TryMerge(tmp)
continue
if tt == 114:
length = d.getVarInt32()
tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
d.skip(length)
self.add_property().TryMerge(tmp)
continue
if tt == 122:
length = d.getVarInt32()
tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
d.skip(length)
self.add_raw_property().TryMerge(tmp)
continue
if tt == 130:
length = d.getVarInt32()
tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
d.skip(length)
self.mutable_entity_group().TryMerge(tmp)
continue
if tt == 138:
length = d.getVarInt32()
tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
d.skip(length)
self.mutable_owner().TryMerge(tmp)
continue
# tag 0 is special: it's used to indicate an error.
# so if we see it we raise an exception.
if tt == 0:
raise ProtocolBuffer.ProtocolBufferDecodeError()
d.skipData(tt)
def __str__(self, prefix="", printElemNumber=0):
res = ""
if self.has_key_:
res += prefix + "key <\n"
res += self.key_.__str__(prefix + " ", printElemNumber)
res += prefix + ">\n"
if self.has_entity_group_:
res += prefix + "entity_group <\n"
res += self.entity_group_.__str__(prefix + " ", printElemNumber)
res += prefix + ">\n"
if self.has_owner_:
res += prefix + "owner <\n"
res += self.owner_.__str__(prefix + " ", printElemNumber)
res += prefix + ">\n"
if self.has_kind_:
res += prefix + ("kind: %s\n" % self.DebugFormatInt32(self.kind_))
if self.has_kind_uri_:
res += prefix + (
"kind_uri: %s\n" % self.DebugFormatString(self.kind_uri_)
)
cnt = 0
for e in self.property_:
elm = ""
if printElemNumber:
elm = "(%d)" % cnt
res += prefix + "property%s <\n" % elm
res += e.__str__(prefix + " ", printElemNumber)
res += prefix + ">\n"
cnt += 1
cnt = 0
for e in self.raw_property_:
elm = ""
if printElemNumber:
elm = "(%d)" % cnt
res += prefix + "raw_property%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 range(0, 1 + maxtag)])
kkey = 13
kentity_group = 16
kowner = 17
kkind = 4
kkind_uri = 5
kproperty = 14
kraw_property = 15
_TEXT = _BuildTagLookupTable(
{
0: "ErrorCode",
4: "kind",
5: "kind_uri",
13: "key",
14: "property",
15: "raw_property",
16: "entity_group",
17: "owner",
},
17,
)
_TYPES = _BuildTagLookupTable(
{
0: ProtocolBuffer.Encoder.NUMERIC,
4: ProtocolBuffer.Encoder.NUMERIC,
5: ProtocolBuffer.Encoder.STRING,
13: ProtocolBuffer.Encoder.STRING,
14: ProtocolBuffer.Encoder.STRING,
15: ProtocolBuffer.Encoder.STRING,
16: ProtocolBuffer.Encoder.STRING,
17: ProtocolBuffer.Encoder.STRING,
},
17,
ProtocolBuffer.Encoder.MAX_TYPE,
)
# stylesheet for XML output
_STYLE = """"""
_STYLE_CONTENT_TYPE = """"""
_PROTO_DESCRIPTOR_NAME = "storage_onestore_v3.EntityProto"
class EntityMetadata(ProtocolBuffer.ProtocolMessage):
has_created_version_ = 0
created_version_ = 0
has_updated_version_ = 0
updated_version_ = 0
def __init__(self, contents=None):
if contents is not None:
self.MergeFromString(contents)
def created_version(self):
return self.created_version_
def set_created_version(self, x):
self.has_created_version_ = 1
self.created_version_ = x
def clear_created_version(self):
if self.has_created_version_:
self.has_created_version_ = 0
self.created_version_ = 0
def has_created_version(self):
return self.has_created_version_
def updated_version(self):
return self.updated_version_
def set_updated_version(self, x):
self.has_updated_version_ = 1
self.updated_version_ = x
def clear_updated_version(self):
if self.has_updated_version_:
self.has_updated_version_ = 0
self.updated_version_ = 0
def has_updated_version(self):
return self.has_updated_version_
def MergeFrom(self, x):
assert x is not self
if x.has_created_version():
self.set_created_version(x.created_version())
if x.has_updated_version():
self.set_updated_version(x.updated_version())
def Equals(self, x):
if x is self:
return 1
if self.has_created_version_ != x.has_created_version_:
return 0
if (
self.has_created_version_
and self.created_version_ != x.created_version_
):
return 0
if self.has_updated_version_ != x.has_updated_version_:
return 0
if (
self.has_updated_version_
and self.updated_version_ != x.updated_version_
):
return 0
return 1
def IsInitialized(self, debug_strs=None):
initialized = 1
return initialized
def ByteSize(self):
n = 0
if self.has_created_version_:
n += 1 + self.lengthVarInt64(self.created_version_)
if self.has_updated_version_:
n += 1 + self.lengthVarInt64(self.updated_version_)
return n
def ByteSizePartial(self):
n = 0
if self.has_created_version_:
n += 1 + self.lengthVarInt64(self.created_version_)
if self.has_updated_version_:
n += 1 + self.lengthVarInt64(self.updated_version_)
return n
def Clear(self):
self.clear_created_version()
self.clear_updated_version()
def OutputUnchecked(self, out):
if self.has_created_version_:
out.putVarInt32(8)
out.putVarInt64(self.created_version_)
if self.has_updated_version_:
out.putVarInt32(16)
out.putVarInt64(self.updated_version_)
def OutputPartial(self, out):
if self.has_created_version_:
out.putVarInt32(8)
out.putVarInt64(self.created_version_)
if self.has_updated_version_:
out.putVarInt32(16)
out.putVarInt64(self.updated_version_)
def TryMerge(self, d):
while d.avail() > 0:
tt = d.getVarInt32()
if tt == 8:
self.set_created_version(d.getVarInt64())
continue
if tt == 16:
self.set_updated_version(d.getVarInt64())
continue
# tag 0 is special: it's used to indicate an error.
# so if we see it we raise an exception.
if tt == 0:
raise ProtocolBuffer.ProtocolBufferDecodeError()
d.skipData(tt)
def __str__(self, prefix="", printElemNumber=0):
res = ""
if self.has_created_version_:
res += prefix + (
"created_version: %s\n" % self.DebugFormatInt64(self.created_version_)
)
if self.has_updated_version_:
res += prefix + (
"updated_version: %s\n" % self.DebugFormatInt64(self.updated_version_)
)
return res
def _BuildTagLookupTable(sparse, maxtag, default=None):
return tuple([sparse.get(i, default) for i in range(0, 1 + maxtag)])
kcreated_version = 1
kupdated_version = 2
_TEXT = _BuildTagLookupTable(
{
0: "ErrorCode",
1: "created_version",
2: "updated_version",
},
2,
)
_TYPES = _BuildTagLookupTable(
{
0: ProtocolBuffer.Encoder.NUMERIC,
1: ProtocolBuffer.Encoder.NUMERIC,
2: ProtocolBuffer.Encoder.NUMERIC,
},
2,
ProtocolBuffer.Encoder.MAX_TYPE,
)
# stylesheet for XML output
_STYLE = """"""
_STYLE_CONTENT_TYPE = """"""
_PROTO_DESCRIPTOR_NAME = "storage_onestore_v3.EntityMetadata"
class EntitySummary_PropertySummary(ProtocolBuffer.ProtocolMessage):
has_name_ = 0
name_ = ""
has_property_type_for_stats_ = 0
property_type_for_stats_ = ""
has_size_bytes_ = 0
size_bytes_ = 0
def __init__(self, contents=None):
if contents is not None:
self.MergeFromString(contents)
def name(self):
return self.name_
def set_name(self, x):
self.has_name_ = 1
self.name_ = x
def clear_name(self):
if self.has_name_:
self.has_name_ = 0
self.name_ = ""
def has_name(self):
return self.has_name_
def property_type_for_stats(self):
return self.property_type_for_stats_
def set_property_type_for_stats(self, x):
self.has_property_type_for_stats_ = 1
self.property_type_for_stats_ = x
def clear_property_type_for_stats(self):
if self.has_property_type_for_stats_:
self.has_property_type_for_stats_ = 0
self.property_type_for_stats_ = ""
def has_property_type_for_stats(self):
return self.has_property_type_for_stats_
def size_bytes(self):
return self.size_bytes_
def set_size_bytes(self, x):
self.has_size_bytes_ = 1
self.size_bytes_ = x
def clear_size_bytes(self):
if self.has_size_bytes_:
self.has_size_bytes_ = 0
self.size_bytes_ = 0
def has_size_bytes(self):
return self.has_size_bytes_
def MergeFrom(self, x):
assert x is not self
if x.has_name():
self.set_name(x.name())
if x.has_property_type_for_stats():
self.set_property_type_for_stats(x.property_type_for_stats())
if x.has_size_bytes():
self.set_size_bytes(x.size_bytes())
def Equals(self, x):
if x is self:
return 1
if self.has_name_ != x.has_name_:
return 0
if self.has_name_ and self.name_ != x.name_:
return 0
if self.has_property_type_for_stats_ != x.has_property_type_for_stats_:
return 0
if (
self.has_property_type_for_stats_
and self.property_type_for_stats_ != x.property_type_for_stats_
):
return 0
if self.has_size_bytes_ != x.has_size_bytes_:
return 0
if self.has_size_bytes_ and self.size_bytes_ != x.size_bytes_:
return 0
return 1
def IsInitialized(self, debug_strs=None):
initialized = 1
if not self.has_name_:
initialized = 0
if debug_strs is not None:
debug_strs.append("Required field: name not set.")
return initialized
def ByteSize(self):
n = 0
n += self.lengthString(len(self.name_))
if self.has_property_type_for_stats_:
n += 1 + self.lengthString(len(self.property_type_for_stats_))
if self.has_size_bytes_:
n += 1 + self.lengthVarInt64(self.size_bytes_)
return n + 1
def ByteSizePartial(self):
n = 0
if self.has_name_:
n += 1
n += self.lengthString(len(self.name_))
if self.has_property_type_for_stats_:
n += 1 + self.lengthString(len(self.property_type_for_stats_))
if self.has_size_bytes_:
n += 1 + self.lengthVarInt64(self.size_bytes_)
return n
def Clear(self):
self.clear_name()
self.clear_property_type_for_stats()
self.clear_size_bytes()
def OutputUnchecked(self, out):
out.putVarInt32(10)
out.putPrefixedString(self.name_)
if self.has_property_type_for_stats_:
out.putVarInt32(18)
out.putPrefixedString(self.property_type_for_stats_)
if self.has_size_bytes_:
out.putVarInt32(24)
out.putVarInt32(self.size_bytes_)
def OutputPartial(self, out):
if self.has_name_:
out.putVarInt32(10)
out.putPrefixedString(self.name_)
if self.has_property_type_for_stats_:
out.putVarInt32(18)
out.putPrefixedString(self.property_type_for_stats_)
if self.has_size_bytes_:
out.putVarInt32(24)
out.putVarInt32(self.size_bytes_)
def TryMerge(self, d):
while d.avail() > 0:
tt = d.getVarInt32()
if tt == 10:
self.set_name(d.getPrefixedString())
continue
if tt == 18:
self.set_property_type_for_stats(d.getPrefixedString())
continue
if tt == 24:
self.set_size_bytes(d.getVarInt32())
continue
# tag 0 is special: it's used to indicate an error.
# so if we see it we raise an exception.
if tt == 0:
raise ProtocolBuffer.ProtocolBufferDecodeError()
d.skipData(tt)
def __str__(self, prefix="", printElemNumber=0):
res = ""
if self.has_name_:
res += prefix + ("name: %s\n" % self.DebugFormatString(self.name_))
if self.has_property_type_for_stats_:
res += prefix + (
"property_type_for_stats: %s\n"
% self.DebugFormatString(self.property_type_for_stats_)
)
if self.has_size_bytes_:
res += prefix + (
"size_bytes: %s\n" % self.DebugFormatInt32(self.size_bytes_)
)
return res
def _BuildTagLookupTable(sparse, maxtag, default=None):
return tuple([sparse.get(i, default) for i in range(0, 1 + maxtag)])
kname = 1
kproperty_type_for_stats = 2
ksize_bytes = 3
_TEXT = _BuildTagLookupTable(
{
0: "ErrorCode",
1: "name",
2: "property_type_for_stats",
3: "size_bytes",
},
3,
)
_TYPES = _BuildTagLookupTable(
{
0: ProtocolBuffer.Encoder.NUMERIC,
1: ProtocolBuffer.Encoder.STRING,
2: ProtocolBuffer.Encoder.STRING,
3: ProtocolBuffer.Encoder.NUMERIC,
},
3,
ProtocolBuffer.Encoder.MAX_TYPE,
)
# stylesheet for XML output
_STYLE = """"""
_STYLE_CONTENT_TYPE = """"""
_PROTO_DESCRIPTOR_NAME = "storage_onestore_v3.EntitySummary_PropertySummary"
class EntitySummary(ProtocolBuffer.ProtocolMessage):
def __init__(self, contents=None):
self.large_raw_property_ = []
if contents is not None:
self.MergeFromString(contents)
def large_raw_property_size(self):
return len(self.large_raw_property_)
def large_raw_property_list(self):
return self.large_raw_property_
def large_raw_property(self, i):
return self.large_raw_property_[i]
def mutable_large_raw_property(self, i):
return self.large_raw_property_[i]
def add_large_raw_property(self):
x = EntitySummary_PropertySummary()
self.large_raw_property_.append(x)
return x
def clear_large_raw_property(self):
self.large_raw_property_ = []
def MergeFrom(self, x):
assert x is not self
for i in range(x.large_raw_property_size()):
self.add_large_raw_property().CopyFrom(x.large_raw_property(i))
def Equals(self, x):
if x is self:
return 1
if len(self.large_raw_property_) != len(x.large_raw_property_):
return 0
for e1, e2 in zip(self.large_raw_property_, x.large_raw_property_):
if e1 != e2:
return 0
return 1
def IsInitialized(self, debug_strs=None):
initialized = 1
for p in self.large_raw_property_:
if not p.IsInitialized(debug_strs):
initialized = 0
return initialized
def ByteSize(self):
n = 0
n += 1 * len(self.large_raw_property_)
for i in range(len(self.large_raw_property_)):
n += self.lengthString(self.large_raw_property_[i].ByteSize())
return n
def ByteSizePartial(self):
n = 0
n += 1 * len(self.large_raw_property_)
for i in range(len(self.large_raw_property_)):
n += self.lengthString(self.large_raw_property_[i].ByteSizePartial())
return n
def Clear(self):
self.clear_large_raw_property()
def OutputUnchecked(self, out):
for i in range(len(self.large_raw_property_)):
out.putVarInt32(10)
out.putVarInt32(self.large_raw_property_[i].ByteSize())
self.large_raw_property_[i].OutputUnchecked(out)
def OutputPartial(self, out):
for i in range(len(self.large_raw_property_)):
out.putVarInt32(10)
out.putVarInt32(self.large_raw_property_[i].ByteSizePartial())
self.large_raw_property_[i].OutputPartial(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.add_large_raw_property().TryMerge(tmp)
continue
# tag 0 is special: it's used to indicate an error.
# so if we see it we raise an exception.
if tt == 0:
raise ProtocolBuffer.ProtocolBufferDecodeError()
d.skipData(tt)
def __str__(self, prefix="", printElemNumber=0):
res = ""
cnt = 0
for e in self.large_raw_property_:
elm = ""
if printElemNumber:
elm = "(%d)" % cnt
res += prefix + "large_raw_property%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 range(0, 1 + maxtag)])
klarge_raw_property = 1
_TEXT = _BuildTagLookupTable(
{
0: "ErrorCode",
1: "large_raw_property",
},
1,
)
_TYPES = _BuildTagLookupTable(
{
0: ProtocolBuffer.Encoder.NUMERIC,
1: ProtocolBuffer.Encoder.STRING,
},
1,
ProtocolBuffer.Encoder.MAX_TYPE,
)
# stylesheet for XML output
_STYLE = """"""
_STYLE_CONTENT_TYPE = """"""
_PROTO_DESCRIPTOR_NAME = "storage_onestore_v3.EntitySummary"
class CompositeProperty(ProtocolBuffer.ProtocolMessage):
has_index_id_ = 0
index_id_ = 0
def __init__(self, contents=None):
self.value_ = []
if contents is not None:
self.MergeFromString(contents)
def index_id(self):
return self.index_id_
def set_index_id(self, x):
self.has_index_id_ = 1
self.index_id_ = x
def clear_index_id(self):
if self.has_index_id_:
self.has_index_id_ = 0
self.index_id_ = 0
def has_index_id(self):
return self.has_index_id_
def value_size(self):
return len(self.value_)
def value_list(self):
return self.value_
def value(self, i):
return self.value_[i]
def set_value(self, i, x):
self.value_[i] = x
def add_value(self, x):
self.value_.append(x)
def clear_value(self):
self.value_ = []
def MergeFrom(self, x):
assert x is not self
if x.has_index_id():
self.set_index_id(x.index_id())
for i in range(x.value_size()):
self.add_value(x.value(i))
def Equals(self, x):
if x is self:
return 1
if self.has_index_id_ != x.has_index_id_:
return 0
if self.has_index_id_ and self.index_id_ != x.index_id_:
return 0
if len(self.value_) != len(x.value_):
return 0
for e1, e2 in zip(self.value_, x.value_):
if e1 != e2:
return 0
return 1
def IsInitialized(self, debug_strs=None):
initialized = 1
if not self.has_index_id_:
initialized = 0
if debug_strs is not None:
debug_strs.append("Required field: index_id not set.")
return initialized
def ByteSize(self):
n = 0
n += self.lengthVarInt64(self.index_id_)
n += 1 * len(self.value_)
for i in range(len(self.value_)):
n += self.lengthString(len(self.value_[i]))
return n + 1
def ByteSizePartial(self):
n = 0
if self.has_index_id_:
n += 1
n += self.lengthVarInt64(self.index_id_)
n += 1 * len(self.value_)
for i in range(len(self.value_)):
n += self.lengthString(len(self.value_[i]))
return n
def Clear(self):
self.clear_index_id()
self.clear_value()
def OutputUnchecked(self, out):
out.putVarInt32(8)
out.putVarInt64(self.index_id_)
for i in range(len(self.value_)):
out.putVarInt32(18)
out.putPrefixedString(self.value_[i])
def OutputPartial(self, out):
if self.has_index_id_:
out.putVarInt32(8)
out.putVarInt64(self.index_id_)
for i in range(len(self.value_)):
out.putVarInt32(18)
out.putPrefixedString(self.value_[i])
def TryMerge(self, d):
while d.avail() > 0:
tt = d.getVarInt32()
if tt == 8:
self.set_index_id(d.getVarInt64())
continue
if tt == 18:
self.add_value(d.getPrefixedString())
continue
# tag 0 is special: it's used to indicate an error.
# so if we see it we raise an exception.
if tt == 0:
raise ProtocolBuffer.ProtocolBufferDecodeError()
d.skipData(tt)
def __str__(self, prefix="", printElemNumber=0):
res = ""
if self.has_index_id_:
res += prefix + ("index_id: %s\n" % self.DebugFormatInt64(self.index_id_))
cnt = 0
for e in self.value_:
elm = ""
if printElemNumber:
elm = "(%d)" % cnt
res += prefix + "value%s: %s\n" % (elm, self.DebugFormatString(e))
cnt += 1
return res
def _BuildTagLookupTable(sparse, maxtag, default=None):
return tuple([sparse.get(i, default) for i in range(0, 1 + maxtag)])
kindex_id = 1
kvalue = 2
_TEXT = _BuildTagLookupTable(
{
0: "ErrorCode",
1: "index_id",
2: "value",
},
2,
)
_TYPES = _BuildTagLookupTable(
{
0: ProtocolBuffer.Encoder.NUMERIC,
1: ProtocolBuffer.Encoder.NUMERIC,
2: ProtocolBuffer.Encoder.STRING,
},
2,
ProtocolBuffer.Encoder.MAX_TYPE,
)
# stylesheet for XML output
_STYLE = """"""
_STYLE_CONTENT_TYPE = """"""
_PROTO_DESCRIPTOR_NAME = "storage_onestore_v3.CompositeProperty"
class Index_Property(ProtocolBuffer.ProtocolMessage):
# Direction values
DIRECTION_UNSPECIFIED = 0
ASCENDING = 1
DESCENDING = 2
_Direction_NAMES = {
0: "DIRECTION_UNSPECIFIED",
1: "ASCENDING",
2: "DESCENDING",
}
def Direction_Name(cls, x):
return cls._Direction_NAMES.get(x, "")
Direction_Name = classmethod(Direction_Name)
# Mode values
MODE_UNSPECIFIED = 0
GEOSPATIAL = 3
ARRAY_CONTAINS = 4
_Mode_NAMES = {
0: "MODE_UNSPECIFIED",
3: "GEOSPATIAL",
4: "ARRAY_CONTAINS",
}
def Mode_Name(cls, x):
return cls._Mode_NAMES.get(x, "")
Mode_Name = classmethod(Mode_Name)
has_name_ = 0
name_ = ""
has_direction_ = 0
direction_ = 0
has_mode_ = 0
mode_ = 0
def __init__(self, contents=None):
if contents is not None:
self.MergeFromString(contents)
def name(self):
return self.name_
def set_name(self, x):
self.has_name_ = 1
self.name_ = x
def clear_name(self):
if self.has_name_:
self.has_name_ = 0
self.name_ = ""
def has_name(self):
return self.has_name_
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_ = 0
def has_direction(self):
return self.has_direction_
def mode(self):
return self.mode_
def set_mode(self, x):
self.has_mode_ = 1
self.mode_ = x
def clear_mode(self):
if self.has_mode_:
self.has_mode_ = 0
self.mode_ = 0
def has_mode(self):
return self.has_mode_
def MergeFrom(self, x):
assert x is not self
if x.has_name():
self.set_name(x.name())
if x.has_direction():
self.set_direction(x.direction())
if x.has_mode():
self.set_mode(x.mode())
def Equals(self, x):
if x is self:
return 1
if self.has_name_ != x.has_name_:
return 0
if self.has_name_ and self.name_ != x.name_:
return 0
if self.has_direction_ != x.has_direction_:
return 0
if self.has_direction_ and self.direction_ != x.direction_:
return 0
if self.has_mode_ != x.has_mode_:
return 0
if self.has_mode_ and self.mode_ != x.mode_:
return 0
return 1
def IsInitialized(self, debug_strs=None):
initialized = 1
if not self.has_name_:
initialized = 0
if debug_strs is not None:
debug_strs.append("Required field: name not set.")
return initialized
def ByteSize(self):
n = 0
n += self.lengthString(len(self.name_))
if self.has_direction_:
n += 1 + self.lengthVarInt64(self.direction_)
if self.has_mode_:
n += 1 + self.lengthVarInt64(self.mode_)
return n + 1
def ByteSizePartial(self):
n = 0
if self.has_name_:
n += 1
n += self.lengthString(len(self.name_))
if self.has_direction_:
n += 1 + self.lengthVarInt64(self.direction_)
if self.has_mode_:
n += 1 + self.lengthVarInt64(self.mode_)
return n
def Clear(self):
self.clear_name()
self.clear_direction()
self.clear_mode()
def OutputUnchecked(self, out):
out.putVarInt32(26)
out.putPrefixedString(self.name_)
if self.has_direction_:
out.putVarInt32(32)
out.putVarInt32(self.direction_)
if self.has_mode_:
out.putVarInt32(48)
out.putVarInt32(self.mode_)
def OutputPartial(self, out):
if self.has_name_:
out.putVarInt32(26)
out.putPrefixedString(self.name_)
if self.has_direction_:
out.putVarInt32(32)
out.putVarInt32(self.direction_)
if self.has_mode_:
out.putVarInt32(48)
out.putVarInt32(self.mode_)
def TryMerge(self, d):
while 1:
tt = d.getVarInt32()
if tt == 20:
break
if tt == 26:
self.set_name(d.getPrefixedString())
continue
if tt == 32:
self.set_direction(d.getVarInt32())
continue
if tt == 48:
self.set_mode(d.getVarInt32())
continue
# tag 0 is special: it's used to indicate an error.
# so if we see it we raise an exception.
if tt == 0:
raise ProtocolBuffer.ProtocolBufferDecodeError()
d.skipData(tt)
def __str__(self, prefix="", printElemNumber=0):
res = ""
if self.has_name_:
res += prefix + ("name: %s\n" % self.DebugFormatString(self.name_))
if self.has_direction_:
res += prefix + (
"direction: %s\n" % self.DebugFormatInt32(self.direction_)
)
if self.has_mode_:
res += prefix + ("mode: %s\n" % self.DebugFormatInt32(self.mode_))
return res
class Index(ProtocolBuffer.ProtocolMessage):
# Version values
VERSION_UNSPECIFIED = 0
V1 = 1
V2 = 2
V3 = 3
_Version_NAMES = {
0: "VERSION_UNSPECIFIED",
1: "V1",
2: "V2",
3: "V3",
}
def Version_Name(cls, x):
return cls._Version_NAMES.get(x, "")
Version_Name = classmethod(Version_Name)
has_entity_type_ = 0
entity_type_ = ""
has_ancestor_ = 0
ancestor_ = 0
has_parent_ = 0
parent_ = 0
has_version_ = 0
version_ = 0
def __init__(self, contents=None):
self.property_ = []
if contents is not None:
self.MergeFromString(contents)
def entity_type(self):
return self.entity_type_
def set_entity_type(self, x):
self.has_entity_type_ = 1
self.entity_type_ = x
def clear_entity_type(self):
if self.has_entity_type_:
self.has_entity_type_ = 0
self.entity_type_ = ""
def has_entity_type(self):
return self.has_entity_type_
def ancestor(self):
return self.ancestor_
def set_ancestor(self, x):
self.has_ancestor_ = 1
self.ancestor_ = x
def clear_ancestor(self):
if self.has_ancestor_:
self.has_ancestor_ = 0
self.ancestor_ = 0
def has_ancestor(self):
return self.has_ancestor_
def parent(self):
return self.parent_
def set_parent(self, x):
self.has_parent_ = 1
self.parent_ = x
def clear_parent(self):
if self.has_parent_:
self.has_parent_ = 0
self.parent_ = 0
def has_parent(self):
return self.has_parent_
def version(self):
return self.version_
def set_version(self, x):
self.has_version_ = 1
self.version_ = x
def clear_version(self):
if self.has_version_:
self.has_version_ = 0
self.version_ = 0
def has_version(self):
return self.has_version_
def property_size(self):
return len(self.property_)
def property_list(self):
return self.property_
def property(self, i):
return self.property_[i]
def mutable_property(self, i):
return self.property_[i]
def add_property(self):
x = Index_Property()
self.property_.append(x)
return x
def clear_property(self):
self.property_ = []
def MergeFrom(self, x):
assert x is not self
if x.has_entity_type():
self.set_entity_type(x.entity_type())
if x.has_ancestor():
self.set_ancestor(x.ancestor())
if x.has_parent():
self.set_parent(x.parent())
if x.has_version():
self.set_version(x.version())
for i in range(x.property_size()):
self.add_property().CopyFrom(x.property(i))
def Equals(self, x):
if x is self:
return 1
if self.has_entity_type_ != x.has_entity_type_:
return 0
if self.has_entity_type_ and self.entity_type_ != x.entity_type_:
return 0
if self.has_ancestor_ != x.has_ancestor_:
return 0
if self.has_ancestor_ and self.ancestor_ != x.ancestor_:
return 0
if self.has_parent_ != x.has_parent_:
return 0
if self.has_parent_ and self.parent_ != x.parent_:
return 0
if self.has_version_ != x.has_version_:
return 0
if self.has_version_ and self.version_ != x.version_:
return 0
if len(self.property_) != len(x.property_):
return 0
for e1, e2 in zip(self.property_, x.property_):
if e1 != e2:
return 0
return 1
def IsInitialized(self, debug_strs=None):
initialized = 1
if not self.has_entity_type_:
initialized = 0
if debug_strs is not None:
debug_strs.append("Required field: entity_type not set.")
if not self.has_ancestor_:
initialized = 0
if debug_strs is not None:
debug_strs.append("Required field: ancestor not set.")
for p in self.property_:
if not p.IsInitialized(debug_strs):
initialized = 0
return initialized
def ByteSize(self):
n = 0
n += self.lengthString(len(self.entity_type_))
if self.has_parent_:
n += 2
if self.has_version_:
n += 1 + self.lengthVarInt64(self.version_)
n += 2 * len(self.property_)
for i in range(len(self.property_)):
n += self.property_[i].ByteSize()
return n + 3
def ByteSizePartial(self):
n = 0
if self.has_entity_type_:
n += 1
n += self.lengthString(len(self.entity_type_))
if self.has_ancestor_:
n += 2
if self.has_parent_:
n += 2
if self.has_version_:
n += 1 + self.lengthVarInt64(self.version_)
n += 2 * len(self.property_)
for i in range(len(self.property_)):
n += self.property_[i].ByteSizePartial()
return n
def Clear(self):
self.clear_entity_type()
self.clear_ancestor()
self.clear_parent()
self.clear_version()
self.clear_property()
def OutputUnchecked(self, out):
out.putVarInt32(10)
out.putPrefixedString(self.entity_type_)
for i in range(len(self.property_)):
out.putVarInt32(19)
self.property_[i].OutputUnchecked(out)
out.putVarInt32(20)
out.putVarInt32(40)
out.putBoolean(self.ancestor_)
if self.has_parent_:
out.putVarInt32(56)
out.putBoolean(self.parent_)
if self.has_version_:
out.putVarInt32(64)
out.putVarInt32(self.version_)
def OutputPartial(self, out):
if self.has_entity_type_:
out.putVarInt32(10)
out.putPrefixedString(self.entity_type_)
for i in range(len(self.property_)):
out.putVarInt32(19)
self.property_[i].OutputPartial(out)
out.putVarInt32(20)
if self.has_ancestor_:
out.putVarInt32(40)
out.putBoolean(self.ancestor_)
if self.has_parent_:
out.putVarInt32(56)
out.putBoolean(self.parent_)
if self.has_version_:
out.putVarInt32(64)
out.putVarInt32(self.version_)
def TryMerge(self, d):
while d.avail() > 0:
tt = d.getVarInt32()
if tt == 10:
self.set_entity_type(d.getPrefixedString())
continue
if tt == 19:
self.add_property().TryMerge(d)
continue
if tt == 40:
self.set_ancestor(d.getBoolean())
continue
if tt == 56:
self.set_parent(d.getBoolean())
continue
if tt == 64:
self.set_version(d.getVarInt32())
continue
# tag 0 is special: it's used to indicate an error.
# so if we see it we raise an exception.
if tt == 0:
raise ProtocolBuffer.ProtocolBufferDecodeError()
d.skipData(tt)
def __str__(self, prefix="", printElemNumber=0):
res = ""
if self.has_entity_type_:
res += prefix + (
"entity_type: %s\n" % self.DebugFormatString(self.entity_type_)
)
if self.has_ancestor_:
res += prefix + ("ancestor: %s\n" % self.DebugFormatBool(self.ancestor_))
if self.has_parent_:
res += prefix + ("parent: %s\n" % self.DebugFormatBool(self.parent_))
if self.has_version_:
res += prefix + ("version: %s\n" % self.DebugFormatInt32(self.version_))
cnt = 0
for e in self.property_:
elm = ""
if printElemNumber:
elm = "(%d)" % cnt
res += prefix + "Property%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 range(0, 1 + maxtag)])
kentity_type = 1
kancestor = 5
kparent = 7
kversion = 8
kPropertyGroup = 2
kPropertyname = 3
kPropertydirection = 4
kPropertymode = 6
_TEXT = _BuildTagLookupTable(
{
0: "ErrorCode",
1: "entity_type",
2: "Property",
3: "name",
4: "direction",
5: "ancestor",
6: "mode",
7: "parent",
8: "version",
},
8,
)
_TYPES = _BuildTagLookupTable(
{
0: ProtocolBuffer.Encoder.NUMERIC,
1: ProtocolBuffer.Encoder.STRING,
2: ProtocolBuffer.Encoder.STARTGROUP,
3: ProtocolBuffer.Encoder.STRING,
4: ProtocolBuffer.Encoder.NUMERIC,
5: ProtocolBuffer.Encoder.NUMERIC,
6: ProtocolBuffer.Encoder.NUMERIC,
7: ProtocolBuffer.Encoder.NUMERIC,
8: ProtocolBuffer.Encoder.NUMERIC,
},
8,
ProtocolBuffer.Encoder.MAX_TYPE,
)
# stylesheet for XML output
_STYLE = """"""
_STYLE_CONTENT_TYPE = """"""
_PROTO_DESCRIPTOR_NAME = "storage_onestore_v3.Index"
class CompositeIndex(ProtocolBuffer.ProtocolMessage):
# State values
WRITE_ONLY = 1
READ_WRITE = 2
DELETED = 3
ERROR = 4
_State_NAMES = {
1: "WRITE_ONLY",
2: "READ_WRITE",
3: "DELETED",
4: "ERROR",
}
def State_Name(cls, x):
return cls._State_NAMES.get(x, "")
State_Name = classmethod(State_Name)
# WorkflowState values
PENDING = 1
ACTIVE = 2
COMPLETED = 3
_WorkflowState_NAMES = {
1: "PENDING",
2: "ACTIVE",
3: "COMPLETED",
}
def WorkflowState_Name(cls, x):
return cls._WorkflowState_NAMES.get(x, "")
WorkflowState_Name = classmethod(WorkflowState_Name)
has_app_id_ = 0
app_id_ = ""
has_database_id_ = 0
database_id_ = ""
has_id_ = 0
id_ = 0
has_definition_ = 0
has_state_ = 0
state_ = 0
has_workflow_state_ = 0
workflow_state_ = 0
has_error_message_ = 0
error_message_ = ""
has_only_use_if_required_ = 0
only_use_if_required_ = 0
has_disabled_index_ = 0
disabled_index_ = 0
has_deprecated_write_division_family_ = 0
deprecated_write_division_family_ = ""
def __init__(self, contents=None):
self.definition_ = Index()
self.deprecated_read_division_family_ = []
if contents is not None:
self.MergeFromString(contents)
def app_id(self):
return self.app_id_
def set_app_id(self, x):
self.has_app_id_ = 1
self.app_id_ = x
def clear_app_id(self):
if self.has_app_id_:
self.has_app_id_ = 0
self.app_id_ = ""
def has_app_id(self):
return self.has_app_id_
def database_id(self):
return self.database_id_
def set_database_id(self, x):
self.has_database_id_ = 1
self.database_id_ = x
def clear_database_id(self):
if self.has_database_id_:
self.has_database_id_ = 0
self.database_id_ = ""
def has_database_id(self):
return self.has_database_id_
def id(self):
return self.id_
def set_id(self, x):
self.has_id_ = 1
self.id_ = x
def clear_id(self):
if self.has_id_:
self.has_id_ = 0
self.id_ = 0
def has_id(self):
return self.has_id_
def definition(self):
return self.definition_
def mutable_definition(self):
self.has_definition_ = 1
return self.definition_
def clear_definition(self):
self.has_definition_ = 0
self.definition_.Clear()
def has_definition(self):
return self.has_definition_
def state(self):
return self.state_
def set_state(self, x):
self.has_state_ = 1
self.state_ = x
def clear_state(self):
if self.has_state_:
self.has_state_ = 0
self.state_ = 0
def has_state(self):
return self.has_state_
def workflow_state(self):
return self.workflow_state_
def set_workflow_state(self, x):
self.has_workflow_state_ = 1
self.workflow_state_ = x
def clear_workflow_state(self):
if self.has_workflow_state_:
self.has_workflow_state_ = 0
self.workflow_state_ = 0
def has_workflow_state(self):
return self.has_workflow_state_
def error_message(self):
return self.error_message_
def set_error_message(self, x):
self.has_error_message_ = 1
self.error_message_ = x
def clear_error_message(self):
if self.has_error_message_:
self.has_error_message_ = 0
self.error_message_ = ""
def has_error_message(self):
return self.has_error_message_
def only_use_if_required(self):
return self.only_use_if_required_
def set_only_use_if_required(self, x):
self.has_only_use_if_required_ = 1
self.only_use_if_required_ = x
def clear_only_use_if_required(self):
if self.has_only_use_if_required_:
self.has_only_use_if_required_ = 0
self.only_use_if_required_ = 0
def has_only_use_if_required(self):
return self.has_only_use_if_required_
def disabled_index(self):
return self.disabled_index_
def set_disabled_index(self, x):
self.has_disabled_index_ = 1
self.disabled_index_ = x
def clear_disabled_index(self):
if self.has_disabled_index_:
self.has_disabled_index_ = 0
self.disabled_index_ = 0
def has_disabled_index(self):
return self.has_disabled_index_
def deprecated_read_division_family_size(self):
return len(self.deprecated_read_division_family_)
def deprecated_read_division_family_list(self):
return self.deprecated_read_division_family_
def deprecated_read_division_family(self, i):
return self.deprecated_read_division_family_[i]
def set_deprecated_read_division_family(self, i, x):
self.deprecated_read_division_family_[i] = x
def add_deprecated_read_division_family(self, x):
self.deprecated_read_division_family_.append(x)
def clear_deprecated_read_division_family(self):
self.deprecated_read_division_family_ = []
def deprecated_write_division_family(self):
return self.deprecated_write_division_family_
def set_deprecated_write_division_family(self, x):
self.has_deprecated_write_division_family_ = 1
self.deprecated_write_division_family_ = x
def clear_deprecated_write_division_family(self):
if self.has_deprecated_write_division_family_:
self.has_deprecated_write_division_family_ = 0
self.deprecated_write_division_family_ = ""
def has_deprecated_write_division_family(self):
return self.has_deprecated_write_division_family_
def MergeFrom(self, x):
assert x is not self
if x.has_app_id():
self.set_app_id(x.app_id())
if x.has_database_id():
self.set_database_id(x.database_id())
if x.has_id():
self.set_id(x.id())
if x.has_definition():
self.mutable_definition().MergeFrom(x.definition())
if x.has_state():
self.set_state(x.state())
if x.has_workflow_state():
self.set_workflow_state(x.workflow_state())
if x.has_error_message():
self.set_error_message(x.error_message())
if x.has_only_use_if_required():
self.set_only_use_if_required(x.only_use_if_required())
if x.has_disabled_index():
self.set_disabled_index(x.disabled_index())
for i in range(x.deprecated_read_division_family_size()):
self.add_deprecated_read_division_family(
x.deprecated_read_division_family(i)
)
if x.has_deprecated_write_division_family():
self.set_deprecated_write_division_family(
x.deprecated_write_division_family()
)
def Equals(self, x):
if x is self:
return 1
if self.has_app_id_ != x.has_app_id_:
return 0
if self.has_app_id_ and self.app_id_ != x.app_id_:
return 0
if self.has_database_id_ != x.has_database_id_:
return 0
if self.has_database_id_ and self.database_id_ != x.database_id_:
return 0
if self.has_id_ != x.has_id_:
return 0
if self.has_id_ and self.id_ != x.id_:
return 0
if self.has_definition_ != x.has_definition_:
return 0
if self.has_definition_ and self.definition_ != x.definition_:
return 0
if self.has_state_ != x.has_state_:
return 0
if self.has_state_ and self.state_ != x.state_:
return 0
if self.has_workflow_state_ != x.has_workflow_state_:
return 0
if self.has_workflow_state_ and self.workflow_state_ != x.workflow_state_:
return 0
if self.has_error_message_ != x.has_error_message_:
return 0
if self.has_error_message_ and self.error_message_ != x.error_message_:
return 0
if self.has_only_use_if_required_ != x.has_only_use_if_required_:
return 0
if (
self.has_only_use_if_required_
and self.only_use_if_required_ != x.only_use_if_required_
):
return 0
if self.has_disabled_index_ != x.has_disabled_index_:
return 0
if self.has_disabled_index_ and self.disabled_index_ != x.disabled_index_:
return 0
if len(self.deprecated_read_division_family_) != len(
x.deprecated_read_division_family_
):
return 0
for e1, e2 in zip(
self.deprecated_read_division_family_,
x.deprecated_read_division_family_,
):
if e1 != e2:
return 0
if (
self.has_deprecated_write_division_family_
!= x.has_deprecated_write_division_family_
):
return 0
if (
self.has_deprecated_write_division_family_
and self.deprecated_write_division_family_
!= x.deprecated_write_division_family_
):
return 0
return 1
def IsInitialized(self, debug_strs=None):
initialized = 1
if not self.has_app_id_:
initialized = 0
if debug_strs is not None:
debug_strs.append("Required field: app_id not set.")
if not self.has_id_:
initialized = 0
if debug_strs is not None:
debug_strs.append("Required field: id not set.")
if not self.has_definition_:
initialized = 0
if debug_strs is not None:
debug_strs.append("Required field: definition not set.")
elif not self.definition_.IsInitialized(debug_strs):
initialized = 0
if not self.has_state_:
initialized = 0
if debug_strs is not None:
debug_strs.append("Required field: state not set.")
return initialized
def ByteSize(self):
n = 0
n += self.lengthString(len(self.app_id_))
if self.has_database_id_:
n += 1 + self.lengthString(len(self.database_id_))
n += self.lengthVarInt64(self.id_)
n += self.lengthString(self.definition_.ByteSize())
n += self.lengthVarInt64(self.state_)
if self.has_workflow_state_:
n += 1 + self.lengthVarInt64(self.workflow_state_)
if self.has_error_message_:
n += 1 + self.lengthString(len(self.error_message_))
if self.has_only_use_if_required_:
n += 2
if self.has_disabled_index_:
n += 2
n += 1 * len(self.deprecated_read_division_family_)
for i in range(len(self.deprecated_read_division_family_)):
n += self.lengthString(len(self.deprecated_read_division_family_[i]))
if self.has_deprecated_write_division_family_:
n += 1 + self.lengthString(len(self.deprecated_write_division_family_))
return n + 4
def ByteSizePartial(self):
n = 0
if self.has_app_id_:
n += 1
n += self.lengthString(len(self.app_id_))
if self.has_database_id_:
n += 1 + self.lengthString(len(self.database_id_))
if self.has_id_:
n += 1
n += self.lengthVarInt64(self.id_)
if self.has_definition_:
n += 1
n += self.lengthString(self.definition_.ByteSizePartial())
if self.has_state_:
n += 1
n += self.lengthVarInt64(self.state_)
if self.has_workflow_state_:
n += 1 + self.lengthVarInt64(self.workflow_state_)
if self.has_error_message_:
n += 1 + self.lengthString(len(self.error_message_))
if self.has_only_use_if_required_:
n += 2
if self.has_disabled_index_:
n += 2
n += 1 * len(self.deprecated_read_division_family_)
for i in range(len(self.deprecated_read_division_family_)):
n += self.lengthString(len(self.deprecated_read_division_family_[i]))
if self.has_deprecated_write_division_family_:
n += 1 + self.lengthString(len(self.deprecated_write_division_family_))
return n
def Clear(self):
self.clear_app_id()
self.clear_database_id()
self.clear_id()
self.clear_definition()
self.clear_state()
self.clear_workflow_state()
self.clear_error_message()
self.clear_only_use_if_required()
self.clear_disabled_index()
self.clear_deprecated_read_division_family()
self.clear_deprecated_write_division_family()
def OutputUnchecked(self, out):
out.putVarInt32(10)
out.putPrefixedString(self.app_id_)
out.putVarInt32(16)
out.putVarInt64(self.id_)
out.putVarInt32(26)
out.putVarInt32(self.definition_.ByteSize())
self.definition_.OutputUnchecked(out)
out.putVarInt32(32)
out.putVarInt32(self.state_)
if self.has_only_use_if_required_:
out.putVarInt32(48)
out.putBoolean(self.only_use_if_required_)
for i in range(len(self.deprecated_read_division_family_)):
out.putVarInt32(58)
out.putPrefixedString(self.deprecated_read_division_family_[i])
if self.has_deprecated_write_division_family_:
out.putVarInt32(66)
out.putPrefixedString(self.deprecated_write_division_family_)
if self.has_disabled_index_:
out.putVarInt32(72)
out.putBoolean(self.disabled_index_)
if self.has_workflow_state_:
out.putVarInt32(80)
out.putVarInt32(self.workflow_state_)
if self.has_error_message_:
out.putVarInt32(90)
out.putPrefixedString(self.error_message_)
if self.has_database_id_:
out.putVarInt32(98)
out.putPrefixedString(self.database_id_)
def OutputPartial(self, out):
if self.has_app_id_:
out.putVarInt32(10)
out.putPrefixedString(self.app_id_)
if self.has_id_:
out.putVarInt32(16)
out.putVarInt64(self.id_)
if self.has_definition_:
out.putVarInt32(26)
out.putVarInt32(self.definition_.ByteSizePartial())
self.definition_.OutputPartial(out)
if self.has_state_:
out.putVarInt32(32)
out.putVarInt32(self.state_)
if self.has_only_use_if_required_:
out.putVarInt32(48)
out.putBoolean(self.only_use_if_required_)
for i in range(len(self.deprecated_read_division_family_)):
out.putVarInt32(58)
out.putPrefixedString(self.deprecated_read_division_family_[i])
if self.has_deprecated_write_division_family_:
out.putVarInt32(66)
out.putPrefixedString(self.deprecated_write_division_family_)
if self.has_disabled_index_:
out.putVarInt32(72)
out.putBoolean(self.disabled_index_)
if self.has_workflow_state_:
out.putVarInt32(80)
out.putVarInt32(self.workflow_state_)
if self.has_error_message_:
out.putVarInt32(90)
out.putPrefixedString(self.error_message_)
if self.has_database_id_:
out.putVarInt32(98)
out.putPrefixedString(self.database_id_)
def TryMerge(self, d):
while d.avail() > 0:
tt = d.getVarInt32()
if tt == 10:
self.set_app_id(d.getPrefixedString())
continue
if tt == 16:
self.set_id(d.getVarInt64())
continue
if tt == 26:
length = d.getVarInt32()
tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
d.skip(length)
self.mutable_definition().TryMerge(tmp)
continue
if tt == 32:
self.set_state(d.getVarInt32())
continue
if tt == 48:
self.set_only_use_if_required(d.getBoolean())
continue
if tt == 58:
self.add_deprecated_read_division_family(d.getPrefixedString())
continue
if tt == 66:
self.set_deprecated_write_division_family(d.getPrefixedString())
continue
if tt == 72:
self.set_disabled_index(d.getBoolean())
continue
if tt == 80:
self.set_workflow_state(d.getVarInt32())
continue
if tt == 90:
self.set_error_message(d.getPrefixedString())
continue
if tt == 98:
self.set_database_id(d.getPrefixedString())
continue
# tag 0 is special: it's used to indicate an error.
# so if we see it we raise an exception.
if tt == 0:
raise ProtocolBuffer.ProtocolBufferDecodeError()
d.skipData(tt)
def __str__(self, prefix="", printElemNumber=0):
res = ""
if self.has_app_id_:
res += prefix + ("app_id: %s\n" % self.DebugFormatString(self.app_id_))
if self.has_database_id_:
res += prefix + (
"database_id: %s\n" % self.DebugFormatString(self.database_id_)
)
if self.has_id_:
res += prefix + ("id: %s\n" % self.DebugFormatInt64(self.id_))
if self.has_definition_:
res += prefix + "definition <\n"
res += self.definition_.__str__(prefix + " ", printElemNumber)
res += prefix + ">\n"
if self.has_state_:
res += prefix + ("state: %s\n" % self.DebugFormatInt32(self.state_))
if self.has_workflow_state_:
res += prefix + (
"workflow_state: %s\n" % self.DebugFormatInt32(self.workflow_state_)
)
if self.has_error_message_:
res += prefix + (
"error_message: %s\n" % self.DebugFormatString(self.error_message_)
)
if self.has_only_use_if_required_:
res += prefix + (
"only_use_if_required: %s\n"
% self.DebugFormatBool(self.only_use_if_required_)
)
if self.has_disabled_index_:
res += prefix + (
"disabled_index: %s\n" % self.DebugFormatBool(self.disabled_index_)
)
cnt = 0
for e in self.deprecated_read_division_family_:
elm = ""
if printElemNumber:
elm = "(%d)" % cnt
res += prefix + (
"deprecated_read_division_family%s: %s\n"
% (elm, self.DebugFormatString(e))
)
cnt += 1
if self.has_deprecated_write_division_family_:
res += prefix + (
"deprecated_write_division_family: %s\n"
% self.DebugFormatString(self.deprecated_write_division_family_)
)
return res
def _BuildTagLookupTable(sparse, maxtag, default=None):
return tuple([sparse.get(i, default) for i in range(0, 1 + maxtag)])
kapp_id = 1
kdatabase_id = 12
kid = 2
kdefinition = 3
kstate = 4
kworkflow_state = 10
kerror_message = 11
konly_use_if_required = 6
kdisabled_index = 9
kdeprecated_read_division_family = 7
kdeprecated_write_division_family = 8
_TEXT = _BuildTagLookupTable(
{
0: "ErrorCode",
1: "app_id",
2: "id",
3: "definition",
4: "state",
6: "only_use_if_required",
7: "deprecated_read_division_family",
8: "deprecated_write_division_family",
9: "disabled_index",
10: "workflow_state",
11: "error_message",
12: "database_id",
},
12,
)
_TYPES = _BuildTagLookupTable(
{
0: ProtocolBuffer.Encoder.NUMERIC,
1: ProtocolBuffer.Encoder.STRING,
2: ProtocolBuffer.Encoder.NUMERIC,
3: ProtocolBuffer.Encoder.STRING,
4: ProtocolBuffer.Encoder.NUMERIC,
6: ProtocolBuffer.Encoder.NUMERIC,
7: ProtocolBuffer.Encoder.STRING,
8: ProtocolBuffer.Encoder.STRING,
9: ProtocolBuffer.Encoder.NUMERIC,
10: ProtocolBuffer.Encoder.NUMERIC,
11: ProtocolBuffer.Encoder.STRING,
12: ProtocolBuffer.Encoder.STRING,
},
12,
ProtocolBuffer.Encoder.MAX_TYPE,
)
# stylesheet for XML output
_STYLE = """"""
_STYLE_CONTENT_TYPE = """"""
_PROTO_DESCRIPTOR_NAME = "storage_onestore_v3.CompositeIndex"
class SearchIndexEntry(ProtocolBuffer.ProtocolMessage):
has_index_id_ = 0
index_id_ = 0
has_write_division_family_ = 0
write_division_family_ = ""
has_fingerprint_1999_ = 0
fingerprint_1999_ = 0
has_fingerprint_2011_ = 0
fingerprint_2011_ = 0
def __init__(self, contents=None):
if contents is not None:
self.MergeFromString(contents)
def index_id(self):
return self.index_id_
def set_index_id(self, x):
self.has_index_id_ = 1
self.index_id_ = x
def clear_index_id(self):
if self.has_index_id_:
self.has_index_id_ = 0
self.index_id_ = 0
def has_index_id(self):
return self.has_index_id_
def write_division_family(self):
return self.write_division_family_
def set_write_division_family(self, x):
self.has_write_division_family_ = 1
self.write_division_family_ = x
def clear_write_division_family(self):
if self.has_write_division_family_:
self.has_write_division_family_ = 0
self.write_division_family_ = ""
def has_write_division_family(self):
return self.has_write_division_family_
def fingerprint_1999(self):
return self.fingerprint_1999_
def set_fingerprint_1999(self, x):
self.has_fingerprint_1999_ = 1
self.fingerprint_1999_ = x
def clear_fingerprint_1999(self):
if self.has_fingerprint_1999_:
self.has_fingerprint_1999_ = 0
self.fingerprint_1999_ = 0
def has_fingerprint_1999(self):
return self.has_fingerprint_1999_
def fingerprint_2011(self):
return self.fingerprint_2011_
def set_fingerprint_2011(self, x):
self.has_fingerprint_2011_ = 1
self.fingerprint_2011_ = x
def clear_fingerprint_2011(self):
if self.has_fingerprint_2011_:
self.has_fingerprint_2011_ = 0
self.fingerprint_2011_ = 0
def has_fingerprint_2011(self):
return self.has_fingerprint_2011_
def MergeFrom(self, x):
assert x is not self
if x.has_index_id():
self.set_index_id(x.index_id())
if x.has_write_division_family():
self.set_write_division_family(x.write_division_family())
if x.has_fingerprint_1999():
self.set_fingerprint_1999(x.fingerprint_1999())
if x.has_fingerprint_2011():
self.set_fingerprint_2011(x.fingerprint_2011())
def Equals(self, x):
if x is self:
return 1
if self.has_index_id_ != x.has_index_id_:
return 0
if self.has_index_id_ and self.index_id_ != x.index_id_:
return 0
if self.has_write_division_family_ != x.has_write_division_family_:
return 0
if (
self.has_write_division_family_
and self.write_division_family_ != x.write_division_family_
):
return 0
if self.has_fingerprint_1999_ != x.has_fingerprint_1999_:
return 0
if (
self.has_fingerprint_1999_
and self.fingerprint_1999_ != x.fingerprint_1999_
):
return 0
if self.has_fingerprint_2011_ != x.has_fingerprint_2011_:
return 0
if (
self.has_fingerprint_2011_
and self.fingerprint_2011_ != x.fingerprint_2011_
):
return 0
return 1
def IsInitialized(self, debug_strs=None):
initialized = 1
if not self.has_index_id_:
initialized = 0
if debug_strs is not None:
debug_strs.append("Required field: index_id not set.")
if not self.has_write_division_family_:
initialized = 0
if debug_strs is not None:
debug_strs.append("Required field: write_division_family not set.")
return initialized
def ByteSize(self):
n = 0
n += self.lengthVarInt64(self.index_id_)
n += self.lengthString(len(self.write_division_family_))
if self.has_fingerprint_1999_:
n += 9
if self.has_fingerprint_2011_:
n += 9
return n + 2
def ByteSizePartial(self):
n = 0
if self.has_index_id_:
n += 1
n += self.lengthVarInt64(self.index_id_)
if self.has_write_division_family_:
n += 1
n += self.lengthString(len(self.write_division_family_))
if self.has_fingerprint_1999_:
n += 9
if self.has_fingerprint_2011_:
n += 9
return n
def Clear(self):
self.clear_index_id()
self.clear_write_division_family()
self.clear_fingerprint_1999()
self.clear_fingerprint_2011()
def OutputUnchecked(self, out):
out.putVarInt32(8)
out.putVarInt64(self.index_id_)
out.putVarInt32(18)
out.putPrefixedString(self.write_division_family_)
if self.has_fingerprint_1999_:
out.putVarInt32(25)
out.put64(self.fingerprint_1999_)
if self.has_fingerprint_2011_:
out.putVarInt32(33)
out.put64(self.fingerprint_2011_)
def OutputPartial(self, out):
if self.has_index_id_:
out.putVarInt32(8)
out.putVarInt64(self.index_id_)
if self.has_write_division_family_:
out.putVarInt32(18)
out.putPrefixedString(self.write_division_family_)
if self.has_fingerprint_1999_:
out.putVarInt32(25)
out.put64(self.fingerprint_1999_)
if self.has_fingerprint_2011_:
out.putVarInt32(33)
out.put64(self.fingerprint_2011_)
def TryMerge(self, d):
while d.avail() > 0:
tt = d.getVarInt32()
if tt == 8:
self.set_index_id(d.getVarInt64())
continue
if tt == 18:
self.set_write_division_family(d.getPrefixedString())
continue
if tt == 25:
self.set_fingerprint_1999(d.get64())
continue
if tt == 33:
self.set_fingerprint_2011(d.get64())
continue
# tag 0 is special: it's used to indicate an error.
# so if we see it we raise an exception.
if tt == 0:
raise ProtocolBuffer.ProtocolBufferDecodeError()
d.skipData(tt)
def __str__(self, prefix="", printElemNumber=0):
res = ""
if self.has_index_id_:
res += prefix + ("index_id: %s\n" % self.DebugFormatInt64(self.index_id_))
if self.has_write_division_family_:
res += prefix + (
"write_division_family: %s\n"
% self.DebugFormatString(self.write_division_family_)
)
if self.has_fingerprint_1999_:
res += prefix + (
"fingerprint_1999: %s\n"
% self.DebugFormatFixed64(self.fingerprint_1999_)
)
if self.has_fingerprint_2011_:
res += prefix + (
"fingerprint_2011: %s\n"
% self.DebugFormatFixed64(self.fingerprint_2011_)
)
return res
def _BuildTagLookupTable(sparse, maxtag, default=None):
return tuple([sparse.get(i, default) for i in range(0, 1 + maxtag)])
kindex_id = 1
kwrite_division_family = 2
kfingerprint_1999 = 3
kfingerprint_2011 = 4
_TEXT = _BuildTagLookupTable(
{
0: "ErrorCode",
1: "index_id",
2: "write_division_family",
3: "fingerprint_1999",
4: "fingerprint_2011",
},
4,
)
_TYPES = _BuildTagLookupTable(
{
0: ProtocolBuffer.Encoder.NUMERIC,
1: ProtocolBuffer.Encoder.NUMERIC,
2: ProtocolBuffer.Encoder.STRING,
3: ProtocolBuffer.Encoder.DOUBLE,
4: ProtocolBuffer.Encoder.DOUBLE,
},
4,
ProtocolBuffer.Encoder.MAX_TYPE,
)
# stylesheet for XML output
_STYLE = """"""
_STYLE_CONTENT_TYPE = """"""
_PROTO_DESCRIPTOR_NAME = "storage_onestore_v3.SearchIndexEntry"
class IndexPostfix_IndexValue(ProtocolBuffer.ProtocolMessage):
has_property_name_ = 0
property_name_ = ""
has_value_ = 0
def __init__(self, contents=None):
self.value_ = PropertyValue()
if contents is not None:
self.MergeFromString(contents)
def property_name(self):
return self.property_name_
def set_property_name(self, x):
self.has_property_name_ = 1
self.property_name_ = x
def clear_property_name(self):
if self.has_property_name_:
self.has_property_name_ = 0
self.property_name_ = ""
def has_property_name(self):
return self.has_property_name_
def value(self):
return self.value_
def mutable_value(self):
self.has_value_ = 1
return self.value_
def clear_value(self):
self.has_value_ = 0
self.value_.Clear()
def has_value(self):
return self.has_value_
def MergeFrom(self, x):
assert x is not self
if x.has_property_name():
self.set_property_name(x.property_name())
if x.has_value():
self.mutable_value().MergeFrom(x.value())
def Equals(self, x):
if x is self:
return 1
if self.has_property_name_ != x.has_property_name_:
return 0
if self.has_property_name_ and self.property_name_ != x.property_name_:
return 0
if self.has_value_ != x.has_value_:
return 0
if self.has_value_ and self.value_ != x.value_:
return 0
return 1
def IsInitialized(self, debug_strs=None):
initialized = 1
if not self.has_property_name_:
initialized = 0
if debug_strs is not None:
debug_strs.append("Required field: property_name not set.")
if not self.has_value_:
initialized = 0
if debug_strs is not None:
debug_strs.append("Required field: value not set.")
elif not self.value_.IsInitialized(debug_strs):
initialized = 0
return initialized
def ByteSize(self):
n = 0
n += self.lengthString(len(self.property_name_))
n += self.lengthString(self.value_.ByteSize())
return n + 2
def ByteSizePartial(self):
n = 0
if self.has_property_name_:
n += 1
n += self.lengthString(len(self.property_name_))
if self.has_value_:
n += 1
n += self.lengthString(self.value_.ByteSizePartial())
return n
def Clear(self):
self.clear_property_name()
self.clear_value()
def OutputUnchecked(self, out):
out.putVarInt32(10)
out.putPrefixedString(self.property_name_)
out.putVarInt32(18)
out.putVarInt32(self.value_.ByteSize())
self.value_.OutputUnchecked(out)
def OutputPartial(self, out):
if self.has_property_name_:
out.putVarInt32(10)
out.putPrefixedString(self.property_name_)
if self.has_value_:
out.putVarInt32(18)
out.putVarInt32(self.value_.ByteSizePartial())
self.value_.OutputPartial(out)
def TryMerge(self, d):
while d.avail() > 0:
tt = d.getVarInt32()
if tt == 10:
self.set_property_name(d.getPrefixedString())
continue
if tt == 18:
length = d.getVarInt32()
tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
d.skip(length)
self.mutable_value().TryMerge(tmp)
continue
# tag 0 is special: it's used to indicate an error.
# so if we see it we raise an exception.
if tt == 0:
raise ProtocolBuffer.ProtocolBufferDecodeError()
d.skipData(tt)
def __str__(self, prefix="", printElemNumber=0):
res = ""
if self.has_property_name_:
res += prefix + (
"property_name: %s\n" % self.DebugFormatString(self.property_name_)
)
if self.has_value_:
res += prefix + "value <\n"
res += self.value_.__str__(prefix + " ", printElemNumber)
res += prefix + ">\n"
return res
def _BuildTagLookupTable(sparse, maxtag, default=None):
return tuple([sparse.get(i, default) for i in range(0, 1 + maxtag)])
kproperty_name = 1
kvalue = 2
_TEXT = _BuildTagLookupTable(
{
0: "ErrorCode",
1: "property_name",
2: "value",
},
2,
)
_TYPES = _BuildTagLookupTable(
{
0: ProtocolBuffer.Encoder.NUMERIC,
1: ProtocolBuffer.Encoder.STRING,
2: ProtocolBuffer.Encoder.STRING,
},
2,
ProtocolBuffer.Encoder.MAX_TYPE,
)
# stylesheet for XML output
_STYLE = """"""
_STYLE_CONTENT_TYPE = """"""
_PROTO_DESCRIPTOR_NAME = "storage_onestore_v3.IndexPostfix_IndexValue"
class IndexPostfix(ProtocolBuffer.ProtocolMessage):
has_key_ = 0
key_ = None
has_before_ = 0
before_ = 1
has_before_ascending_ = 0
before_ascending_ = 0
def __init__(self, contents=None):
self.index_value_ = []
self.lazy_init_lock_ = _Lock()
if contents is not None:
self.MergeFromString(contents)
def index_value_size(self):
return len(self.index_value_)
def index_value_list(self):
return self.index_value_
def index_value(self, i):
return self.index_value_[i]
def mutable_index_value(self, i):
return self.index_value_[i]
def add_index_value(self):
x = IndexPostfix_IndexValue()
self.index_value_.append(x)
return x
def clear_index_value(self):
self.index_value_ = []
def key(self):
if self.key_ is None:
self.lazy_init_lock_.acquire()
try:
if self.key_ is None:
self.key_ = Reference()
finally:
self.lazy_init_lock_.release()
return self.key_
def mutable_key(self):
self.has_key_ = 1
return self.key()
def clear_key(self):
# Warning: this method does not acquire the lock.
if self.has_key_:
self.has_key_ = 0
if self.key_ is not None:
self.key_.Clear()
def has_key(self):
return self.has_key_
def before(self):
return self.before_
def set_before(self, x):
self.has_before_ = 1
self.before_ = x
def clear_before(self):
if self.has_before_:
self.has_before_ = 0
self.before_ = 1
def has_before(self):
return self.has_before_
def before_ascending(self):
return self.before_ascending_
def set_before_ascending(self, x):
self.has_before_ascending_ = 1
self.before_ascending_ = x
def clear_before_ascending(self):
if self.has_before_ascending_:
self.has_before_ascending_ = 0
self.before_ascending_ = 0
def has_before_ascending(self):
return self.has_before_ascending_
def MergeFrom(self, x):
assert x is not self
for i in range(x.index_value_size()):
self.add_index_value().CopyFrom(x.index_value(i))
if x.has_key():
self.mutable_key().MergeFrom(x.key())
if x.has_before():
self.set_before(x.before())
if x.has_before_ascending():
self.set_before_ascending(x.before_ascending())
def Equals(self, x):
if x is self:
return 1
if len(self.index_value_) != len(x.index_value_):
return 0
for e1, e2 in zip(self.index_value_, x.index_value_):
if e1 != e2:
return 0
if self.has_key_ != x.has_key_:
return 0
if self.has_key_ and self.key_ != x.key_:
return 0
if self.has_before_ != x.has_before_:
return 0
if self.has_before_ and self.before_ != x.before_:
return 0
if self.has_before_ascending_ != x.has_before_ascending_:
return 0
if (
self.has_before_ascending_
and self.before_ascending_ != x.before_ascending_
):
return 0
return 1
def IsInitialized(self, debug_strs=None):
initialized = 1
for p in self.index_value_:
if not p.IsInitialized(debug_strs):
initialized = 0
if self.has_key_ and not self.key_.IsInitialized(debug_strs):
initialized = 0
return initialized
def ByteSize(self):
n = 0
n += 1 * len(self.index_value_)
for i in range(len(self.index_value_)):
n += self.lengthString(self.index_value_[i].ByteSize())
if self.has_key_:
n += 1 + self.lengthString(self.key_.ByteSize())
if self.has_before_:
n += 2
if self.has_before_ascending_:
n += 2
return n
def ByteSizePartial(self):
n = 0
n += 1 * len(self.index_value_)
for i in range(len(self.index_value_)):
n += self.lengthString(self.index_value_[i].ByteSizePartial())
if self.has_key_:
n += 1 + self.lengthString(self.key_.ByteSizePartial())
if self.has_before_:
n += 2
if self.has_before_ascending_:
n += 2
return n
def Clear(self):
self.clear_index_value()
self.clear_key()
self.clear_before()
self.clear_before_ascending()
def OutputUnchecked(self, out):
for i in range(len(self.index_value_)):
out.putVarInt32(10)
out.putVarInt32(self.index_value_[i].ByteSize())
self.index_value_[i].OutputUnchecked(out)
if self.has_key_:
out.putVarInt32(18)
out.putVarInt32(self.key_.ByteSize())
self.key_.OutputUnchecked(out)
if self.has_before_:
out.putVarInt32(24)
out.putBoolean(self.before_)
if self.has_before_ascending_:
out.putVarInt32(32)
out.putBoolean(self.before_ascending_)
def OutputPartial(self, out):
for i in range(len(self.index_value_)):
out.putVarInt32(10)
out.putVarInt32(self.index_value_[i].ByteSizePartial())
self.index_value_[i].OutputPartial(out)
if self.has_key_:
out.putVarInt32(18)
out.putVarInt32(self.key_.ByteSizePartial())
self.key_.OutputPartial(out)
if self.has_before_:
out.putVarInt32(24)
out.putBoolean(self.before_)
if self.has_before_ascending_:
out.putVarInt32(32)
out.putBoolean(self.before_ascending_)
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.add_index_value().TryMerge(tmp)
continue
if tt == 18:
length = d.getVarInt32()
tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
d.skip(length)
self.mutable_key().TryMerge(tmp)
continue
if tt == 24:
self.set_before(d.getBoolean())
continue
if tt == 32:
self.set_before_ascending(d.getBoolean())
continue
# tag 0 is special: it's used to indicate an error.
# so if we see it we raise an exception.
if tt == 0:
raise ProtocolBuffer.ProtocolBufferDecodeError()
d.skipData(tt)
def __str__(self, prefix="", printElemNumber=0):
res = ""
cnt = 0
for e in self.index_value_:
elm = ""
if printElemNumber:
elm = "(%d)" % cnt
res += prefix + "index_value%s <\n" % elm
res += e.__str__(prefix + " ", printElemNumber)
res += prefix + ">\n"
cnt += 1
if self.has_key_:
res += prefix + "key <\n"
res += self.key_.__str__(prefix + " ", printElemNumber)
res += prefix + ">\n"
if self.has_before_:
res += prefix + ("before: %s\n" % self.DebugFormatBool(self.before_))
if self.has_before_ascending_:
res += prefix + (
"before_ascending: %s\n"
% self.DebugFormatBool(self.before_ascending_)
)
return res
def _BuildTagLookupTable(sparse, maxtag, default=None):
return tuple([sparse.get(i, default) for i in range(0, 1 + maxtag)])
kindex_value = 1
kkey = 2
kbefore = 3
kbefore_ascending = 4
_TEXT = _BuildTagLookupTable(
{
0: "ErrorCode",
1: "index_value",
2: "key",
3: "before",
4: "before_ascending",
},
4,
)
_TYPES = _BuildTagLookupTable(
{
0: ProtocolBuffer.Encoder.NUMERIC,
1: ProtocolBuffer.Encoder.STRING,
2: ProtocolBuffer.Encoder.STRING,
3: ProtocolBuffer.Encoder.NUMERIC,
4: ProtocolBuffer.Encoder.NUMERIC,
},
4,
ProtocolBuffer.Encoder.MAX_TYPE,
)
# stylesheet for XML output
_STYLE = """"""
_STYLE_CONTENT_TYPE = """"""
_PROTO_DESCRIPTOR_NAME = "storage_onestore_v3.IndexPostfix"
class IndexPosition(ProtocolBuffer.ProtocolMessage):
has_key_ = 0
key_ = ""
has_before_ = 0
before_ = 1
has_before_ascending_ = 0
before_ascending_ = 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 before(self):
return self.before_
def set_before(self, x):
self.has_before_ = 1
self.before_ = x
def clear_before(self):
if self.has_before_:
self.has_before_ = 0
self.before_ = 1
def has_before(self):
return self.has_before_
def before_ascending(self):
return self.before_ascending_
def set_before_ascending(self, x):
self.has_before_ascending_ = 1
self.before_ascending_ = x
def clear_before_ascending(self):
if self.has_before_ascending_:
self.has_before_ascending_ = 0
self.before_ascending_ = 0
def has_before_ascending(self):
return self.has_before_ascending_
def MergeFrom(self, x):
assert x is not self
if x.has_key():
self.set_key(x.key())
if x.has_before():
self.set_before(x.before())
if x.has_before_ascending():
self.set_before_ascending(x.before_ascending())
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_before_ != x.has_before_:
return 0
if self.has_before_ and self.before_ != x.before_:
return 0
if self.has_before_ascending_ != x.has_before_ascending_:
return 0
if (
self.has_before_ascending_
and self.before_ascending_ != x.before_ascending_
):
return 0
return 1
def IsInitialized(self, debug_strs=None):
initialized = 1
return initialized
def ByteSize(self):
n = 0
if self.has_key_:
n += 1 + self.lengthString(len(self.key_))
if self.has_before_:
n += 2
if self.has_before_ascending_:
n += 2
return n
def ByteSizePartial(self):
n = 0
if self.has_key_:
n += 1 + self.lengthString(len(self.key_))
if self.has_before_:
n += 2
if self.has_before_ascending_:
n += 2
return n
def Clear(self):
self.clear_key()
self.clear_before()
self.clear_before_ascending()
def OutputUnchecked(self, out):
if self.has_key_:
out.putVarInt32(10)
out.putPrefixedString(self.key_)
if self.has_before_:
out.putVarInt32(16)
out.putBoolean(self.before_)
if self.has_before_ascending_:
out.putVarInt32(24)
out.putBoolean(self.before_ascending_)
def OutputPartial(self, out):
if self.has_key_:
out.putVarInt32(10)
out.putPrefixedString(self.key_)
if self.has_before_:
out.putVarInt32(16)
out.putBoolean(self.before_)
if self.has_before_ascending_:
out.putVarInt32(24)
out.putBoolean(self.before_ascending_)
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_before(d.getBoolean())
continue
if tt == 24:
self.set_before_ascending(d.getBoolean())
continue
# tag 0 is special: it's used to indicate an error.
# so if we see it we raise an exception.
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_before_:
res += prefix + ("before: %s\n" % self.DebugFormatBool(self.before_))
if self.has_before_ascending_:
res += prefix + (
"before_ascending: %s\n"
% self.DebugFormatBool(self.before_ascending_)
)
return res
def _BuildTagLookupTable(sparse, maxtag, default=None):
return tuple([sparse.get(i, default) for i in range(0, 1 + maxtag)])
kkey = 1
kbefore = 2
kbefore_ascending = 3
_TEXT = _BuildTagLookupTable(
{
0: "ErrorCode",
1: "key",
2: "before",
3: "before_ascending",
},
3,
)
_TYPES = _BuildTagLookupTable(
{
0: ProtocolBuffer.Encoder.NUMERIC,
1: ProtocolBuffer.Encoder.STRING,
2: ProtocolBuffer.Encoder.NUMERIC,
3: ProtocolBuffer.Encoder.NUMERIC,
},
3,
ProtocolBuffer.Encoder.MAX_TYPE,
)
# stylesheet for XML output
_STYLE = """"""
_STYLE_CONTENT_TYPE = """"""
_PROTO_DESCRIPTOR_NAME = "storage_onestore_v3.IndexPosition"
if _extension_runtime:
pass
__all__ = [
"PropertyValue",
"PropertyValue_ReferenceValuePathElement",
"PropertyValue_PointValue",
"PropertyValue_UserValue",
"PropertyValue_ReferenceValue",
"Property",
"Path",
"Path_Element",
"Reference",
"User",
"EntityProto",
"EntityMetadata",
"EntitySummary_PropertySummary",
"EntitySummary",
"CompositeProperty",
"Index",
"Index_Property",
"CompositeIndex",
"SearchIndexEntry",
"IndexPostfix_IndexValue",
"IndexPostfix",
"IndexPosition",
]