python/google/appengine/datastore/entity_pb.py

   1 #!/usr/bin/env python
   2 #
   3 # Copyright 2007 Google Inc.
   4 #
   5 # Licensed under the Apache License, Version 2.0 (the "License");
   6 # you may not use this file except in compliance with the License.
   7 # You may obtain a copy of the License at
   8 #
   9 #     http://www.apache.org/licenses/LICENSE-2.0
  10 #
  11 # Unless required by applicable law or agreed to in writing, software
  12 # distributed under the License is distributed on an "AS IS" BASIS,
  13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 # See the License for the specific language governing permissions and
  15 # limitations under the License.
  16 #
  17
  18
  19
  20 from google.net.proto import ProtocolBuffer
  21 import array
  22 import dummy_thread as thread
  23
  24 __pychecker__ = """maxreturns=0 maxbranches=0 no-callinit
  25                    unusednames=printElemNumber,debug_strs no-special"""
  26
  27 if hasattr(ProtocolBuffer, 'ExtendableProtocolMessage'):
  28   _extension_runtime = True
  29   _ExtendableProtocolMessage = ProtocolBuffer.ExtendableProtocolMessage
  30 else:
  31   _extension_runtime = False
  32   _ExtendableProtocolMessage = ProtocolBuffer.ProtocolMessage
  33
  34 class PropertyValue_ReferenceValuePathElement(ProtocolBuffer.ProtocolMessage):
  35   has_type_ = 0
  36   type_ = ""
  37   has_id_ = 0
  38   id_ = 0
  39   has_name_ = 0
  40   name_ = ""
  41
  42   def __init__(self, contents=None):
  43     if contents is not None: self.MergeFromString(contents)
  44
  45   def type(self): return self.type_
  46
  47   def set_type(self, x):
  48     self.has_type_ = 1
  49     self.type_ = x
  50
  51   def clear_type(self):
  52     if self.has_type_:
  53       self.has_type_ = 0
  54       self.type_ = ""
  55
  56   def has_type(self): return self.has_type_
  57
  58   def id(self): return self.id_
  59
  60   def set_id(self, x):
  61     self.has_id_ = 1
  62     self.id_ = x
  63
  64   def clear_id(self):
  65     if self.has_id_:
  66       self.has_id_ = 0
  67       self.id_ = 0
  68
  69   def has_id(self): return self.has_id_
  70
  71   def name(self): return self.name_
  72
  73   def set_name(self, x):
  74     self.has_name_ = 1
  75     self.name_ = x
  76
  77   def clear_name(self):
  78     if self.has_name_:
  79       self.has_name_ = 0
  80       self.name_ = ""
  81
  82   def has_name(self): return self.has_name_
  83
  84
  85   def MergeFrom(self, x):
  86     assert x is not self
  87     if (x.has_type()): self.set_type(x.type())
  88     if (x.has_id()): self.set_id(x.id())
  89     if (x.has_name()): self.set_name(x.name())
  90
  91   def Equals(self, x):
  92     if x is self: return 1
  93     if self.has_type_ != x.has_type_: return 0
  94     if self.has_type_ and self.type_ != x.type_: return 0
  95     if self.has_id_ != x.has_id_: return 0
  96     if self.has_id_ and self.id_ != x.id_: return 0
  97     if self.has_name_ != x.has_name_: return 0
  98     if self.has_name_ and self.name_ != x.name_: return 0
  99     return 1
 100
 101   def IsInitialized(self, debug_strs=None):
 102     initialized = 1
 103     if (not self.has_type_):
 104       initialized = 0
 105       if debug_strs is not None:
 106         debug_strs.append('Required field: type not set.')
 107     return initialized
 108
 109   def ByteSize(self):
 110     n = 0
 111     n += self.lengthString(len(self.type_))
 112     if (self.has_id_): n += 2 + self.lengthVarInt64(self.id_)
 113     if (self.has_name_): n += 2 + self.lengthString(len(self.name_))
 114     return n + 1
 115
 116   def ByteSizePartial(self):
 117     n = 0
 118     if (self.has_type_):
 119       n += 1
 120       n += self.lengthString(len(self.type_))
 121     if (self.has_id_): n += 2 + self.lengthVarInt64(self.id_)
 122     if (self.has_name_): n += 2 + self.lengthString(len(self.name_))
 123     return n
 124
 125   def Clear(self):
 126     self.clear_type()
 127     self.clear_id()
 128     self.clear_name()
 129
 130   def OutputUnchecked(self, out):
 131     out.putVarInt32(122)
 132     out.putPrefixedString(self.type_)
 133     if (self.has_id_):
 134       out.putVarInt32(128)
 135       out.putVarInt64(self.id_)
 136     if (self.has_name_):
 137       out.putVarInt32(138)
 138       out.putPrefixedString(self.name_)
 139
 140   def OutputPartial(self, out):
 141     if (self.has_type_):
 142       out.putVarInt32(122)
 143       out.putPrefixedString(self.type_)
 144     if (self.has_id_):
 145       out.putVarInt32(128)
 146       out.putVarInt64(self.id_)
 147     if (self.has_name_):
 148       out.putVarInt32(138)
 149       out.putPrefixedString(self.name_)
 150
 151   def TryMerge(self, d):
 152     while 1:
 153       tt = d.getVarInt32()
 154       if tt == 116: break
 155       if tt == 122:
 156         self.set_type(d.getPrefixedString())
 157         continue
 158       if tt == 128:
 159         self.set_id(d.getVarInt64())
 160         continue
 161       if tt == 138:
 162         self.set_name(d.getPrefixedString())
 163         continue
 164
 165
 166       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 167       d.skipData(tt)
 168
 169
 170   def __str__(self, prefix="", printElemNumber=0):
 171     res=""
 172     if self.has_type_: res+=prefix+("type: %s\n" % self.DebugFormatString(self.type_))
 173     if self.has_id_: res+=prefix+("id: %s\n" % self.DebugFormatInt64(self.id_))
 174     if self.has_name_: res+=prefix+("name: %s\n" % self.DebugFormatString(self.name_))
 175     return res
 176
 177 class PropertyValue_PointValue(ProtocolBuffer.ProtocolMessage):
 178   has_x_ = 0
 179   x_ = 0.0
 180   has_y_ = 0
 181   y_ = 0.0
 182
 183   def __init__(self, contents=None):
 184     if contents is not None: self.MergeFromString(contents)
 185
 186   def x(self): return self.x_
 187
 188   def set_x(self, x):
 189     self.has_x_ = 1
 190     self.x_ = x
 191
 192   def clear_x(self):
 193     if self.has_x_:
 194       self.has_x_ = 0
 195       self.x_ = 0.0
 196
 197   def has_x(self): return self.has_x_
 198
 199   def y(self): return self.y_
 200
 201   def set_y(self, x):
 202     self.has_y_ = 1
 203     self.y_ = x
 204
 205   def clear_y(self):
 206     if self.has_y_:
 207       self.has_y_ = 0
 208       self.y_ = 0.0
 209
 210   def has_y(self): return self.has_y_
 211
 212
 213   def MergeFrom(self, x):
 214     assert x is not self
 215     if (x.has_x()): self.set_x(x.x())
 216     if (x.has_y()): self.set_y(x.y())
 217
 218   def Equals(self, x):
 219     if x is self: return 1
 220     if self.has_x_ != x.has_x_: return 0
 221     if self.has_x_ and self.x_ != x.x_: return 0
 222     if self.has_y_ != x.has_y_: return 0
 223     if self.has_y_ and self.y_ != x.y_: return 0
 224     return 1
 225
 226   def IsInitialized(self, debug_strs=None):
 227     initialized = 1
 228     if (not self.has_x_):
 229       initialized = 0
 230       if debug_strs is not None:
 231         debug_strs.append('Required field: x not set.')
 232     if (not self.has_y_):
 233       initialized = 0
 234       if debug_strs is not None:
 235         debug_strs.append('Required field: y not set.')
 236     return initialized
 237
 238   def ByteSize(self):
 239     n = 0
 240     return n + 18
 241
 242   def ByteSizePartial(self):
 243     n = 0
 244     if (self.has_x_):
 245       n += 9
 246     if (self.has_y_):
 247       n += 9
 248     return n
 249
 250   def Clear(self):
 251     self.clear_x()
 252     self.clear_y()
 253
 254   def OutputUnchecked(self, out):
 255     out.putVarInt32(49)
 256     out.putDouble(self.x_)
 257     out.putVarInt32(57)
 258     out.putDouble(self.y_)
 259
 260   def OutputPartial(self, out):
 261     if (self.has_x_):
 262       out.putVarInt32(49)
 263       out.putDouble(self.x_)
 264     if (self.has_y_):
 265       out.putVarInt32(57)
 266       out.putDouble(self.y_)
 267
 268   def TryMerge(self, d):
 269     while 1:
 270       tt = d.getVarInt32()
 271       if tt == 44: break
 272       if tt == 49:
 273         self.set_x(d.getDouble())
 274         continue
 275       if tt == 57:
 276         self.set_y(d.getDouble())
 277         continue
 278
 279
 280       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 281       d.skipData(tt)
 282
 283
 284   def __str__(self, prefix="", printElemNumber=0):
 285     res=""
 286     if self.has_x_: res+=prefix+("x: %s\n" % self.DebugFormat(self.x_))
 287     if self.has_y_: res+=prefix+("y: %s\n" % self.DebugFormat(self.y_))
 288     return res
 289
 290 class PropertyValue_UserValue(ProtocolBuffer.ProtocolMessage):
 291   has_email_ = 0
 292   email_ = ""
 293   has_auth_domain_ = 0
 294   auth_domain_ = ""
 295   has_nickname_ = 0
 296   nickname_ = ""
 297   has_gaiaid_ = 0
 298   gaiaid_ = 0
 299   has_obfuscated_gaiaid_ = 0
 300   obfuscated_gaiaid_ = ""
 301   has_federated_identity_ = 0
 302   federated_identity_ = ""
 303   has_federated_provider_ = 0
 304   federated_provider_ = ""
 305
 306   def __init__(self, contents=None):
 307     if contents is not None: self.MergeFromString(contents)
 308
 309   def email(self): return self.email_
 310
 311   def set_email(self, x):
 312     self.has_email_ = 1
 313     self.email_ = x
 314
 315   def clear_email(self):
 316     if self.has_email_:
 317       self.has_email_ = 0
 318       self.email_ = ""
 319
 320   def has_email(self): return self.has_email_
 321
 322   def auth_domain(self): return self.auth_domain_
 323
 324   def set_auth_domain(self, x):
 325     self.has_auth_domain_ = 1
 326     self.auth_domain_ = x
 327
 328   def clear_auth_domain(self):
 329     if self.has_auth_domain_:
 330       self.has_auth_domain_ = 0
 331       self.auth_domain_ = ""
 332
 333   def has_auth_domain(self): return self.has_auth_domain_
 334
 335   def nickname(self): return self.nickname_
 336
 337   def set_nickname(self, x):
 338     self.has_nickname_ = 1
 339     self.nickname_ = x
 340
 341   def clear_nickname(self):
 342     if self.has_nickname_:
 343       self.has_nickname_ = 0
 344       self.nickname_ = ""
 345
 346   def has_nickname(self): return self.has_nickname_
 347
 348   def gaiaid(self): return self.gaiaid_
 349
 350   def set_gaiaid(self, x):
 351     self.has_gaiaid_ = 1
 352     self.gaiaid_ = x
 353
 354   def clear_gaiaid(self):
 355     if self.has_gaiaid_:
 356       self.has_gaiaid_ = 0
 357       self.gaiaid_ = 0
 358
 359   def has_gaiaid(self): return self.has_gaiaid_
 360
 361   def obfuscated_gaiaid(self): return self.obfuscated_gaiaid_
 362
 363   def set_obfuscated_gaiaid(self, x):
 364     self.has_obfuscated_gaiaid_ = 1
 365     self.obfuscated_gaiaid_ = x
 366
 367   def clear_obfuscated_gaiaid(self):
 368     if self.has_obfuscated_gaiaid_:
 369       self.has_obfuscated_gaiaid_ = 0
 370       self.obfuscated_gaiaid_ = ""
 371
 372   def has_obfuscated_gaiaid(self): return self.has_obfuscated_gaiaid_
 373
 374   def federated_identity(self): return self.federated_identity_
 375
 376   def set_federated_identity(self, x):
 377     self.has_federated_identity_ = 1
 378     self.federated_identity_ = x
 379
 380   def clear_federated_identity(self):
 381     if self.has_federated_identity_:
 382       self.has_federated_identity_ = 0
 383       self.federated_identity_ = ""
 384
 385   def has_federated_identity(self): return self.has_federated_identity_
 386
 387   def federated_provider(self): return self.federated_provider_
 388
 389   def set_federated_provider(self, x):
 390     self.has_federated_provider_ = 1
 391     self.federated_provider_ = x
 392
 393   def clear_federated_provider(self):
 394     if self.has_federated_provider_:
 395       self.has_federated_provider_ = 0
 396       self.federated_provider_ = ""
 397
 398   def has_federated_provider(self): return self.has_federated_provider_
 399
 400
 401   def MergeFrom(self, x):
 402     assert x is not self
 403     if (x.has_email()): self.set_email(x.email())
 404     if (x.has_auth_domain()): self.set_auth_domain(x.auth_domain())
 405     if (x.has_nickname()): self.set_nickname(x.nickname())
 406     if (x.has_gaiaid()): self.set_gaiaid(x.gaiaid())
 407     if (x.has_obfuscated_gaiaid()): self.set_obfuscated_gaiaid(x.obfuscated_gaiaid())
 408     if (x.has_federated_identity()): self.set_federated_identity(x.federated_identity())
 409     if (x.has_federated_provider()): self.set_federated_provider(x.federated_provider())
 410
 411   def Equals(self, x):
 412     if x is self: return 1
 413     if self.has_email_ != x.has_email_: return 0
 414     if self.has_email_ and self.email_ != x.email_: return 0
 415     if self.has_auth_domain_ != x.has_auth_domain_: return 0
 416     if self.has_auth_domain_ and self.auth_domain_ != x.auth_domain_: return 0
 417     if self.has_nickname_ != x.has_nickname_: return 0
 418     if self.has_nickname_ and self.nickname_ != x.nickname_: return 0
 419     if self.has_gaiaid_ != x.has_gaiaid_: return 0
 420     if self.has_gaiaid_ and self.gaiaid_ != x.gaiaid_: return 0
 421     if self.has_obfuscated_gaiaid_ != x.has_obfuscated_gaiaid_: return 0
 422     if self.has_obfuscated_gaiaid_ and self.obfuscated_gaiaid_ != x.obfuscated_gaiaid_: return 0
 423     if self.has_federated_identity_ != x.has_federated_identity_: return 0
 424     if self.has_federated_identity_ and self.federated_identity_ != x.federated_identity_: return 0
 425     if self.has_federated_provider_ != x.has_federated_provider_: return 0
 426     if self.has_federated_provider_ and self.federated_provider_ != x.federated_provider_: return 0
 427     return 1
 428
 429   def IsInitialized(self, debug_strs=None):
 430     initialized = 1
 431     if (not self.has_email_):
 432       initialized = 0
 433       if debug_strs is not None:
 434         debug_strs.append('Required field: email not set.')
 435     if (not self.has_auth_domain_):
 436       initialized = 0
 437       if debug_strs is not None:
 438         debug_strs.append('Required field: auth_domain not set.')
 439     if (not self.has_gaiaid_):
 440       initialized = 0
 441       if debug_strs is not None:
 442         debug_strs.append('Required field: gaiaid not set.')
 443     return initialized
 444
 445   def ByteSize(self):
 446     n = 0
 447     n += self.lengthString(len(self.email_))
 448     n += self.lengthString(len(self.auth_domain_))
 449     if (self.has_nickname_): n += 1 + self.lengthString(len(self.nickname_))
 450     n += self.lengthVarInt64(self.gaiaid_)
 451     if (self.has_obfuscated_gaiaid_): n += 2 + self.lengthString(len(self.obfuscated_gaiaid_))
 452     if (self.has_federated_identity_): n += 2 + self.lengthString(len(self.federated_identity_))
 453     if (self.has_federated_provider_): n += 2 + self.lengthString(len(self.federated_provider_))
 454     return n + 4
 455
 456   def ByteSizePartial(self):
 457     n = 0
 458     if (self.has_email_):
 459       n += 1
 460       n += self.lengthString(len(self.email_))
 461     if (self.has_auth_domain_):
 462       n += 1
 463       n += self.lengthString(len(self.auth_domain_))
 464     if (self.has_nickname_): n += 1 + self.lengthString(len(self.nickname_))
 465     if (self.has_gaiaid_):
 466       n += 2
 467       n += self.lengthVarInt64(self.gaiaid_)
 468     if (self.has_obfuscated_gaiaid_): n += 2 + self.lengthString(len(self.obfuscated_gaiaid_))
 469     if (self.has_federated_identity_): n += 2 + self.lengthString(len(self.federated_identity_))
 470     if (self.has_federated_provider_): n += 2 + self.lengthString(len(self.federated_provider_))
 471     return n
 472
 473   def Clear(self):
 474     self.clear_email()
 475     self.clear_auth_domain()
 476     self.clear_nickname()
 477     self.clear_gaiaid()
 478     self.clear_obfuscated_gaiaid()
 479     self.clear_federated_identity()
 480     self.clear_federated_provider()
 481
 482   def OutputUnchecked(self, out):
 483     out.putVarInt32(74)
 484     out.putPrefixedString(self.email_)
 485     out.putVarInt32(82)
 486     out.putPrefixedString(self.auth_domain_)
 487     if (self.has_nickname_):
 488       out.putVarInt32(90)
 489       out.putPrefixedString(self.nickname_)
 490     out.putVarInt32(144)
 491     out.putVarInt64(self.gaiaid_)
 492     if (self.has_obfuscated_gaiaid_):
 493       out.putVarInt32(154)
 494       out.putPrefixedString(self.obfuscated_gaiaid_)
 495     if (self.has_federated_identity_):
 496       out.putVarInt32(170)
 497       out.putPrefixedString(self.federated_identity_)
 498     if (self.has_federated_provider_):
 499       out.putVarInt32(178)
 500       out.putPrefixedString(self.federated_provider_)
 501
 502   def OutputPartial(self, out):
 503     if (self.has_email_):
 504       out.putVarInt32(74)
 505       out.putPrefixedString(self.email_)
 506     if (self.has_auth_domain_):
 507       out.putVarInt32(82)
 508       out.putPrefixedString(self.auth_domain_)
 509     if (self.has_nickname_):
 510       out.putVarInt32(90)
 511       out.putPrefixedString(self.nickname_)
 512     if (self.has_gaiaid_):
 513       out.putVarInt32(144)
 514       out.putVarInt64(self.gaiaid_)
 515     if (self.has_obfuscated_gaiaid_):
 516       out.putVarInt32(154)
 517       out.putPrefixedString(self.obfuscated_gaiaid_)
 518     if (self.has_federated_identity_):
 519       out.putVarInt32(170)
 520       out.putPrefixedString(self.federated_identity_)
 521     if (self.has_federated_provider_):
 522       out.putVarInt32(178)
 523       out.putPrefixedString(self.federated_provider_)
 524
 525   def TryMerge(self, d):
 526     while 1:
 527       tt = d.getVarInt32()
 528       if tt == 68: break
 529       if tt == 74:
 530         self.set_email(d.getPrefixedString())
 531         continue
 532       if tt == 82:
 533         self.set_auth_domain(d.getPrefixedString())
 534         continue
 535       if tt == 90:
 536         self.set_nickname(d.getPrefixedString())
 537         continue
 538       if tt == 144:
 539         self.set_gaiaid(d.getVarInt64())
 540         continue
 541       if tt == 154:
 542         self.set_obfuscated_gaiaid(d.getPrefixedString())
 543         continue
 544       if tt == 170:
 545         self.set_federated_identity(d.getPrefixedString())
 546         continue
 547       if tt == 178:
 548         self.set_federated_provider(d.getPrefixedString())
 549         continue
 550
 551
 552       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 553       d.skipData(tt)
 554
 555
 556   def __str__(self, prefix="", printElemNumber=0):
 557     res=""
 558     if self.has_email_: res+=prefix+("email: %s\n" % self.DebugFormatString(self.email_))
 559     if self.has_auth_domain_: res+=prefix+("auth_domain: %s\n" % self.DebugFormatString(self.auth_domain_))
 560     if self.has_nickname_: res+=prefix+("nickname: %s\n" % self.DebugFormatString(self.nickname_))
 561     if self.has_gaiaid_: res+=prefix+("gaiaid: %s\n" % self.DebugFormatInt64(self.gaiaid_))
 562     if self.has_obfuscated_gaiaid_: res+=prefix+("obfuscated_gaiaid: %s\n" % self.DebugFormatString(self.obfuscated_gaiaid_))
 563     if self.has_federated_identity_: res+=prefix+("federated_identity: %s\n" % self.DebugFormatString(self.federated_identity_))
 564     if self.has_federated_provider_: res+=prefix+("federated_provider: %s\n" % self.DebugFormatString(self.federated_provider_))
 565     return res
 566
 567 class PropertyValue_ReferenceValue(ProtocolBuffer.ProtocolMessage):
 568   has_app_ = 0
 569   app_ = ""
 570   has_name_space_ = 0
 571   name_space_ = ""
 572
 573   def __init__(self, contents=None):
 574     self.pathelement_ = []
 575     if contents is not None: self.MergeFromString(contents)
 576
 577   def app(self): return self.app_
 578
 579   def set_app(self, x):
 580     self.has_app_ = 1
 581     self.app_ = x
 582
 583   def clear_app(self):
 584     if self.has_app_:
 585       self.has_app_ = 0
 586       self.app_ = ""
 587
 588   def has_app(self): return self.has_app_
 589
 590   def name_space(self): return self.name_space_
 591
 592   def set_name_space(self, x):
 593     self.has_name_space_ = 1
 594     self.name_space_ = x
 595
 596   def clear_name_space(self):
 597     if self.has_name_space_:
 598       self.has_name_space_ = 0
 599       self.name_space_ = ""
 600
 601   def has_name_space(self): return self.has_name_space_
 602
 603   def pathelement_size(self): return len(self.pathelement_)
 604   def pathelement_list(self): return self.pathelement_
 605
 606   def pathelement(self, i):
 607     return self.pathelement_[i]
 608
 609   def mutable_pathelement(self, i):
 610     return self.pathelement_[i]
 611
 612   def add_pathelement(self):
 613     x = PropertyValue_ReferenceValuePathElement()
 614     self.pathelement_.append(x)
 615     return x
 616
 617   def clear_pathelement(self):
 618     self.pathelement_ = []
 619
 620   def MergeFrom(self, x):
 621     assert x is not self
 622     if (x.has_app()): self.set_app(x.app())
 623     if (x.has_name_space()): self.set_name_space(x.name_space())
 624     for i in xrange(x.pathelement_size()): self.add_pathelement().CopyFrom(x.pathelement(i))
 625
 626   def Equals(self, x):
 627     if x is self: return 1
 628     if self.has_app_ != x.has_app_: return 0
 629     if self.has_app_ and self.app_ != x.app_: return 0
 630     if self.has_name_space_ != x.has_name_space_: return 0
 631     if self.has_name_space_ and self.name_space_ != x.name_space_: return 0
 632     if len(self.pathelement_) != len(x.pathelement_): return 0
 633     for e1, e2 in zip(self.pathelement_, x.pathelement_):
 634       if e1 != e2: return 0
 635     return 1
 636
 637   def IsInitialized(self, debug_strs=None):
 638     initialized = 1
 639     if (not self.has_app_):
 640       initialized = 0
 641       if debug_strs is not None:
 642         debug_strs.append('Required field: app not set.')
 643     for p in self.pathelement_:
 644       if not p.IsInitialized(debug_strs): initialized=0
 645     return initialized
 646
 647   def ByteSize(self):
 648     n = 0
 649     n += self.lengthString(len(self.app_))
 650     if (self.has_name_space_): n += 2 + self.lengthString(len(self.name_space_))
 651     n += 2 * len(self.pathelement_)
 652     for i in xrange(len(self.pathelement_)): n += self.pathelement_[i].ByteSize()
 653     return n + 1
 654
 655   def ByteSizePartial(self):
 656     n = 0
 657     if (self.has_app_):
 658       n += 1
 659       n += self.lengthString(len(self.app_))
 660     if (self.has_name_space_): n += 2 + self.lengthString(len(self.name_space_))
 661     n += 2 * len(self.pathelement_)
 662     for i in xrange(len(self.pathelement_)): n += self.pathelement_[i].ByteSizePartial()
 663     return n
 664
 665   def Clear(self):
 666     self.clear_app()
 667     self.clear_name_space()
 668     self.clear_pathelement()
 669
 670   def OutputUnchecked(self, out):
 671     out.putVarInt32(106)
 672     out.putPrefixedString(self.app_)
 673     for i in xrange(len(self.pathelement_)):
 674       out.putVarInt32(115)
 675       self.pathelement_[i].OutputUnchecked(out)
 676       out.putVarInt32(116)
 677     if (self.has_name_space_):
 678       out.putVarInt32(162)
 679       out.putPrefixedString(self.name_space_)
 680
 681   def OutputPartial(self, out):
 682     if (self.has_app_):
 683       out.putVarInt32(106)
 684       out.putPrefixedString(self.app_)
 685     for i in xrange(len(self.pathelement_)):
 686       out.putVarInt32(115)
 687       self.pathelement_[i].OutputPartial(out)
 688       out.putVarInt32(116)
 689     if (self.has_name_space_):
 690       out.putVarInt32(162)
 691       out.putPrefixedString(self.name_space_)
 692
 693   def TryMerge(self, d):
 694     while 1:
 695       tt = d.getVarInt32()
 696       if tt == 100: break
 697       if tt == 106:
 698         self.set_app(d.getPrefixedString())
 699         continue
 700       if tt == 115:
 701         self.add_pathelement().TryMerge(d)
 702         continue
 703       if tt == 162:
 704         self.set_name_space(d.getPrefixedString())
 705         continue
 706
 707
 708       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 709       d.skipData(tt)
 710
 711
 712   def __str__(self, prefix="", printElemNumber=0):
 713     res=""
 714     if self.has_app_: res+=prefix+("app: %s\n" % self.DebugFormatString(self.app_))
 715     if self.has_name_space_: res+=prefix+("name_space: %s\n" % self.DebugFormatString(self.name_space_))
 716     cnt=0
 717     for e in self.pathelement_:
 718       elm=""
 719       if printElemNumber: elm="(%d)" % cnt
 720       res+=prefix+("PathElement%s {\n" % elm)
 721       res+=e.__str__(prefix + "  ", printElemNumber)
 722       res+=prefix+"}\n"
 723       cnt+=1
 724     return res
 725
 726 class PropertyValue(ProtocolBuffer.ProtocolMessage):
 727   has_int64value_ = 0
 728   int64value_ = 0
 729   has_booleanvalue_ = 0
 730   booleanvalue_ = 0
 731   has_stringvalue_ = 0
 732   stringvalue_ = ""
 733   has_doublevalue_ = 0
 734   doublevalue_ = 0.0
 735   has_pointvalue_ = 0
 736   pointvalue_ = None
 737   has_uservalue_ = 0
 738   uservalue_ = None
 739   has_referencevalue_ = 0
 740   referencevalue_ = None
 741
 742   def __init__(self, contents=None):
 743     self.lazy_init_lock_ = thread.allocate_lock()
 744     if contents is not None: self.MergeFromString(contents)
 745
 746   def int64value(self): return self.int64value_
 747
 748   def set_int64value(self, x):
 749     self.has_int64value_ = 1
 750     self.int64value_ = x
 751
 752   def clear_int64value(self):
 753     if self.has_int64value_:
 754       self.has_int64value_ = 0
 755       self.int64value_ = 0
 756
 757   def has_int64value(self): return self.has_int64value_
 758
 759   def booleanvalue(self): return self.booleanvalue_
 760
 761   def set_booleanvalue(self, x):
 762     self.has_booleanvalue_ = 1
 763     self.booleanvalue_ = x
 764
 765   def clear_booleanvalue(self):
 766     if self.has_booleanvalue_:
 767       self.has_booleanvalue_ = 0
 768       self.booleanvalue_ = 0
 769
 770   def has_booleanvalue(self): return self.has_booleanvalue_
 771
 772   def stringvalue(self): return self.stringvalue_
 773
 774   def set_stringvalue(self, x):
 775     self.has_stringvalue_ = 1
 776     self.stringvalue_ = x
 777
 778   def clear_stringvalue(self):
 779     if self.has_stringvalue_:
 780       self.has_stringvalue_ = 0
 781       self.stringvalue_ = ""
 782
 783   def has_stringvalue(self): return self.has_stringvalue_
 784
 785   def doublevalue(self): return self.doublevalue_
 786
 787   def set_doublevalue(self, x):
 788     self.has_doublevalue_ = 1
 789     self.doublevalue_ = x
 790
 791   def clear_doublevalue(self):
 792     if self.has_doublevalue_:
 793       self.has_doublevalue_ = 0
 794       self.doublevalue_ = 0.0
 795
 796   def has_doublevalue(self): return self.has_doublevalue_
 797
 798   def pointvalue(self):
 799     if self.pointvalue_ is None:
 800       self.lazy_init_lock_.acquire()
 801       try:
 802         if self.pointvalue_ is None: self.pointvalue_ = PropertyValue_PointValue()
 803       finally:
 804         self.lazy_init_lock_.release()
 805     return self.pointvalue_
 806
 807   def mutable_pointvalue(self): self.has_pointvalue_ = 1; return self.pointvalue()
 808
 809   def clear_pointvalue(self):
 810
 811     if self.has_pointvalue_:
 812       self.has_pointvalue_ = 0;
 813       if self.pointvalue_ is not None: self.pointvalue_.Clear()
 814
 815   def has_pointvalue(self): return self.has_pointvalue_
 816
 817   def uservalue(self):
 818     if self.uservalue_ is None:
 819       self.lazy_init_lock_.acquire()
 820       try:
 821         if self.uservalue_ is None: self.uservalue_ = PropertyValue_UserValue()
 822       finally:
 823         self.lazy_init_lock_.release()
 824     return self.uservalue_
 825
 826   def mutable_uservalue(self): self.has_uservalue_ = 1; return self.uservalue()
 827
 828   def clear_uservalue(self):
 829
 830     if self.has_uservalue_:
 831       self.has_uservalue_ = 0;
 832       if self.uservalue_ is not None: self.uservalue_.Clear()
 833
 834   def has_uservalue(self): return self.has_uservalue_
 835
 836   def referencevalue(self):
 837     if self.referencevalue_ is None:
 838       self.lazy_init_lock_.acquire()
 839       try:
 840         if self.referencevalue_ is None: self.referencevalue_ = PropertyValue_ReferenceValue()
 841       finally:
 842         self.lazy_init_lock_.release()
 843     return self.referencevalue_
 844
 845   def mutable_referencevalue(self): self.has_referencevalue_ = 1; return self.referencevalue()
 846
 847   def clear_referencevalue(self):
 848
 849     if self.has_referencevalue_:
 850       self.has_referencevalue_ = 0;
 851       if self.referencevalue_ is not None: self.referencevalue_.Clear()
 852
 853   def has_referencevalue(self): return self.has_referencevalue_
 854
 855
 856   def MergeFrom(self, x):
 857     assert x is not self
 858     if (x.has_int64value()): self.set_int64value(x.int64value())
 859     if (x.has_booleanvalue()): self.set_booleanvalue(x.booleanvalue())
 860     if (x.has_stringvalue()): self.set_stringvalue(x.stringvalue())
 861     if (x.has_doublevalue()): self.set_doublevalue(x.doublevalue())
 862     if (x.has_pointvalue()): self.mutable_pointvalue().MergeFrom(x.pointvalue())
 863     if (x.has_uservalue()): self.mutable_uservalue().MergeFrom(x.uservalue())
 864     if (x.has_referencevalue()): self.mutable_referencevalue().MergeFrom(x.referencevalue())
 865
 866   def Equals(self, x):
 867     if x is self: return 1
 868     if self.has_int64value_ != x.has_int64value_: return 0
 869     if self.has_int64value_ and self.int64value_ != x.int64value_: return 0
 870     if self.has_booleanvalue_ != x.has_booleanvalue_: return 0
 871     if self.has_booleanvalue_ and self.booleanvalue_ != x.booleanvalue_: return 0
 872     if self.has_stringvalue_ != x.has_stringvalue_: return 0
 873     if self.has_stringvalue_ and self.stringvalue_ != x.stringvalue_: return 0
 874     if self.has_doublevalue_ != x.has_doublevalue_: return 0
 875     if self.has_doublevalue_ and self.doublevalue_ != x.doublevalue_: return 0
 876     if self.has_pointvalue_ != x.has_pointvalue_: return 0
 877     if self.has_pointvalue_ and self.pointvalue_ != x.pointvalue_: return 0
 878     if self.has_uservalue_ != x.has_uservalue_: return 0
 879     if self.has_uservalue_ and self.uservalue_ != x.uservalue_: return 0
 880     if self.has_referencevalue_ != x.has_referencevalue_: return 0
 881     if self.has_referencevalue_ and self.referencevalue_ != x.referencevalue_: return 0
 882     return 1
 883
 884   def IsInitialized(self, debug_strs=None):
 885     initialized = 1
 886     if (self.has_pointvalue_ and not self.pointvalue_.IsInitialized(debug_strs)): initialized = 0
 887     if (self.has_uservalue_ and not self.uservalue_.IsInitialized(debug_strs)): initialized = 0
 888     if (self.has_referencevalue_ and not self.referencevalue_.IsInitialized(debug_strs)): initialized = 0
 889     return initialized
 890
 891   def ByteSize(self):
 892     n = 0
 893     if (self.has_int64value_): n += 1 + self.lengthVarInt64(self.int64value_)
 894     if (self.has_booleanvalue_): n += 2
 895     if (self.has_stringvalue_): n += 1 + self.lengthString(len(self.stringvalue_))
 896     if (self.has_doublevalue_): n += 9
 897     if (self.has_pointvalue_): n += 2 + self.pointvalue_.ByteSize()
 898     if (self.has_uservalue_): n += 2 + self.uservalue_.ByteSize()
 899     if (self.has_referencevalue_): n += 2 + self.referencevalue_.ByteSize()
 900     return n
 901
 902   def ByteSizePartial(self):
 903     n = 0
 904     if (self.has_int64value_): n += 1 + self.lengthVarInt64(self.int64value_)
 905     if (self.has_booleanvalue_): n += 2
 906     if (self.has_stringvalue_): n += 1 + self.lengthString(len(self.stringvalue_))
 907     if (self.has_doublevalue_): n += 9
 908     if (self.has_pointvalue_): n += 2 + self.pointvalue_.ByteSizePartial()
 909     if (self.has_uservalue_): n += 2 + self.uservalue_.ByteSizePartial()
 910     if (self.has_referencevalue_): n += 2 + self.referencevalue_.ByteSizePartial()
 911     return n
 912
 913   def Clear(self):
 914     self.clear_int64value()
 915     self.clear_booleanvalue()
 916     self.clear_stringvalue()
 917     self.clear_doublevalue()
 918     self.clear_pointvalue()
 919     self.clear_uservalue()
 920     self.clear_referencevalue()
 921
 922   def OutputUnchecked(self, out):
 923     if (self.has_int64value_):
 924       out.putVarInt32(8)
 925       out.putVarInt64(self.int64value_)
 926     if (self.has_booleanvalue_):
 927       out.putVarInt32(16)
 928       out.putBoolean(self.booleanvalue_)
 929     if (self.has_stringvalue_):
 930       out.putVarInt32(26)
 931       out.putPrefixedString(self.stringvalue_)
 932     if (self.has_doublevalue_):
 933       out.putVarInt32(33)
 934       out.putDouble(self.doublevalue_)
 935     if (self.has_pointvalue_):
 936       out.putVarInt32(43)
 937       self.pointvalue_.OutputUnchecked(out)
 938       out.putVarInt32(44)
 939     if (self.has_uservalue_):
 940       out.putVarInt32(67)
 941       self.uservalue_.OutputUnchecked(out)
 942       out.putVarInt32(68)
 943     if (self.has_referencevalue_):
 944       out.putVarInt32(99)
 945       self.referencevalue_.OutputUnchecked(out)
 946       out.putVarInt32(100)
 947
 948   def OutputPartial(self, out):
 949     if (self.has_int64value_):
 950       out.putVarInt32(8)
 951       out.putVarInt64(self.int64value_)
 952     if (self.has_booleanvalue_):
 953       out.putVarInt32(16)
 954       out.putBoolean(self.booleanvalue_)
 955     if (self.has_stringvalue_):
 956       out.putVarInt32(26)
 957       out.putPrefixedString(self.stringvalue_)
 958     if (self.has_doublevalue_):
 959       out.putVarInt32(33)
 960       out.putDouble(self.doublevalue_)
 961     if (self.has_pointvalue_):
 962       out.putVarInt32(43)
 963       self.pointvalue_.OutputPartial(out)
 964       out.putVarInt32(44)
 965     if (self.has_uservalue_):
 966       out.putVarInt32(67)
 967       self.uservalue_.OutputPartial(out)
 968       out.putVarInt32(68)
 969     if (self.has_referencevalue_):
 970       out.putVarInt32(99)
 971       self.referencevalue_.OutputPartial(out)
 972       out.putVarInt32(100)
 973
 974   def TryMerge(self, d):
 975     while d.avail() > 0:
 976       tt = d.getVarInt32()
 977       if tt == 8:
 978         self.set_int64value(d.getVarInt64())
 979         continue
 980       if tt == 16:
 981         self.set_booleanvalue(d.getBoolean())
 982         continue
 983       if tt == 26:
 984         self.set_stringvalue(d.getPrefixedString())
 985         continue
 986       if tt == 33:
 987         self.set_doublevalue(d.getDouble())
 988         continue
 989       if tt == 43:
 990         self.mutable_pointvalue().TryMerge(d)
 991         continue
 992       if tt == 67:
 993         self.mutable_uservalue().TryMerge(d)
 994         continue
 995       if tt == 99:
 996         self.mutable_referencevalue().TryMerge(d)
 997         continue
 998
 999
1000       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1001       d.skipData(tt)
1002
1003
1004   def __str__(self, prefix="", printElemNumber=0):
1005     res=""
1006     if self.has_int64value_: res+=prefix+("int64Value: %s\n" % self.DebugFormatInt64(self.int64value_))
1007     if self.has_booleanvalue_: res+=prefix+("booleanValue: %s\n" % self.DebugFormatBool(self.booleanvalue_))
1008     if self.has_stringvalue_: res+=prefix+("stringValue: %s\n" % self.DebugFormatString(self.stringvalue_))
1009     if self.has_doublevalue_: res+=prefix+("doubleValue: %s\n" % self.DebugFormat(self.doublevalue_))
1010     if self.has_pointvalue_:
1011       res+=prefix+"PointValue {\n"
1012       res+=self.pointvalue_.__str__(prefix + "  ", printElemNumber)
1013       res+=prefix+"}\n"
1014     if self.has_uservalue_:
1015       res+=prefix+"UserValue {\n"
1016       res+=self.uservalue_.__str__(prefix + "  ", printElemNumber)
1017       res+=prefix+"}\n"
1018     if self.has_referencevalue_:
1019       res+=prefix+"ReferenceValue {\n"
1020       res+=self.referencevalue_.__str__(prefix + "  ", printElemNumber)
1021       res+=prefix+"}\n"
1022     return res
1023
1024
1025   def _BuildTagLookupTable(sparse, maxtag, default=None):
1026     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
1027
1028   kint64Value = 1
1029   kbooleanValue = 2
1030   kstringValue = 3
1031   kdoubleValue = 4
1032   kPointValueGroup = 5
1033   kPointValuex = 6
1034   kPointValuey = 7
1035   kUserValueGroup = 8
1036   kUserValueemail = 9
1037   kUserValueauth_domain = 10
1038   kUserValuenickname = 11
1039   kUserValuegaiaid = 18
1040   kUserValueobfuscated_gaiaid = 19
1041   kUserValuefederated_identity = 21
1042   kUserValuefederated_provider = 22
1043   kReferenceValueGroup = 12
1044   kReferenceValueapp = 13
1045   kReferenceValuename_space = 20
1046   kReferenceValuePathElementGroup = 14
1047   kReferenceValuePathElementtype = 15
1048   kReferenceValuePathElementid = 16
1049   kReferenceValuePathElementname = 17
1050
1051   _TEXT = _BuildTagLookupTable({
1052     0: "ErrorCode",
1053     1: "int64Value",
1054     2: "booleanValue",
1055     3: "stringValue",
1056     4: "doubleValue",
1057     5: "PointValue",
1058     6: "x",
1059     7: "y",
1060     8: "UserValue",
1061     9: "email",
1062     10: "auth_domain",
1063     11: "nickname",
1064     12: "ReferenceValue",
1065     13: "app",
1066     14: "PathElement",
1067     15: "type",
1068     16: "id",
1069     17: "name",
1070     18: "gaiaid",
1071     19: "obfuscated_gaiaid",
1072     20: "name_space",
1073     21: "federated_identity",
1074     22: "federated_provider",
1075   }, 22)
1076
1077   _TYPES = _BuildTagLookupTable({
1078     0: ProtocolBuffer.Encoder.NUMERIC,
1079     1: ProtocolBuffer.Encoder.NUMERIC,
1080     2: ProtocolBuffer.Encoder.NUMERIC,
1081     3: ProtocolBuffer.Encoder.STRING,
1082     4: ProtocolBuffer.Encoder.DOUBLE,
1083     5: ProtocolBuffer.Encoder.STARTGROUP,
1084     6: ProtocolBuffer.Encoder.DOUBLE,
1085     7: ProtocolBuffer.Encoder.DOUBLE,
1086     8: ProtocolBuffer.Encoder.STARTGROUP,
1087     9: ProtocolBuffer.Encoder.STRING,
1088     10: ProtocolBuffer.Encoder.STRING,
1089     11: ProtocolBuffer.Encoder.STRING,
1090     12: ProtocolBuffer.Encoder.STARTGROUP,
1091     13: ProtocolBuffer.Encoder.STRING,
1092     14: ProtocolBuffer.Encoder.STARTGROUP,
1093     15: ProtocolBuffer.Encoder.STRING,
1094     16: ProtocolBuffer.Encoder.NUMERIC,
1095     17: ProtocolBuffer.Encoder.STRING,
1096     18: ProtocolBuffer.Encoder.NUMERIC,
1097     19: ProtocolBuffer.Encoder.STRING,
1098     20: ProtocolBuffer.Encoder.STRING,
1099     21: ProtocolBuffer.Encoder.STRING,
1100     22: ProtocolBuffer.Encoder.STRING,
1101   }, 22, ProtocolBuffer.Encoder.MAX_TYPE)
1102
1103
1104   _STYLE = """"""
1105   _STYLE_CONTENT_TYPE = """"""
1106   _PROTO_DESCRIPTOR_NAME = 'storage_onestore_v3.PropertyValue'
1107 class Property(ProtocolBuffer.ProtocolMessage):
1108
1109
1110   NO_MEANING   =    0
1111   BLOB         =   14
1112   TEXT         =   15
1113   BYTESTRING   =   16
1114   ATOM_CATEGORY =    1
1115   ATOM_LINK    =    2
1116   ATOM_TITLE   =    3
1117   ATOM_CONTENT =    4
1118   ATOM_SUMMARY =    5
1119   ATOM_AUTHOR  =    6
1120   GD_WHEN      =    7
1121   GD_EMAIL     =    8
1122   GEORSS_POINT =    9
1123   GD_IM        =   10
1124   GD_PHONENUMBER =   11
1125   GD_POSTALADDRESS =   12
1126   GD_RATING    =   13
1127   BLOBKEY      =   17
1128   ENTITY_PROTO =   19
1129   INDEX_VALUE  =   18
1130
1131   _Meaning_NAMES = {
1132     0: "NO_MEANING",
1133     14: "BLOB",
1134     15: "TEXT",
1135     16: "BYTESTRING",
1136     1: "ATOM_CATEGORY",
1137     2: "ATOM_LINK",
1138     3: "ATOM_TITLE",
1139     4: "ATOM_CONTENT",
1140     5: "ATOM_SUMMARY",
1141     6: "ATOM_AUTHOR",
1142     7: "GD_WHEN",
1143     8: "GD_EMAIL",
1144     9: "GEORSS_POINT",
1145     10: "GD_IM",
1146     11: "GD_PHONENUMBER",
1147     12: "GD_POSTALADDRESS",
1148     13: "GD_RATING",
1149     17: "BLOBKEY",
1150     19: "ENTITY_PROTO",
1151     18: "INDEX_VALUE",
1152   }
1153
1154   def Meaning_Name(cls, x): return cls._Meaning_NAMES.get(x, "")
1155   Meaning_Name = classmethod(Meaning_Name)
1156
1157   has_meaning_ = 0
1158   meaning_ = 0
1159   has_meaning_uri_ = 0
1160   meaning_uri_ = ""
1161   has_name_ = 0
1162   name_ = ""
1163   has_value_ = 0
1164   has_multiple_ = 0
1165   multiple_ = 0
1166   has_embedded_ = 0
1167   embedded_ = 0
1168
1169   def __init__(self, contents=None):
1170     self.value_ = PropertyValue()
1171     if contents is not None: self.MergeFromString(contents)
1172
1173   def meaning(self): return self.meaning_
1174
1175   def set_meaning(self, x):
1176     self.has_meaning_ = 1
1177     self.meaning_ = x
1178
1179   def clear_meaning(self):
1180     if self.has_meaning_:
1181       self.has_meaning_ = 0
1182       self.meaning_ = 0
1183
1184   def has_meaning(self): return self.has_meaning_
1185
1186   def meaning_uri(self): return self.meaning_uri_
1187
1188   def set_meaning_uri(self, x):
1189     self.has_meaning_uri_ = 1
1190     self.meaning_uri_ = x
1191
1192   def clear_meaning_uri(self):
1193     if self.has_meaning_uri_:
1194       self.has_meaning_uri_ = 0
1195       self.meaning_uri_ = ""
1196
1197   def has_meaning_uri(self): return self.has_meaning_uri_
1198
1199   def name(self): return self.name_
1200
1201   def set_name(self, x):
1202     self.has_name_ = 1
1203     self.name_ = x
1204
1205   def clear_name(self):
1206     if self.has_name_:
1207       self.has_name_ = 0
1208       self.name_ = ""
1209
1210   def has_name(self): return self.has_name_
1211
1212   def value(self): return self.value_
1213
1214   def mutable_value(self): self.has_value_ = 1; return self.value_
1215
1216   def clear_value(self):self.has_value_ = 0; self.value_.Clear()
1217
1218   def has_value(self): return self.has_value_
1219
1220   def multiple(self): return self.multiple_
1221
1222   def set_multiple(self, x):
1223     self.has_multiple_ = 1
1224     self.multiple_ = x
1225
1226   def clear_multiple(self):
1227     if self.has_multiple_:
1228       self.has_multiple_ = 0
1229       self.multiple_ = 0
1230
1231   def has_multiple(self): return self.has_multiple_
1232
1233   def embedded(self): return self.embedded_
1234
1235   def set_embedded(self, x):
1236     self.has_embedded_ = 1
1237     self.embedded_ = x
1238
1239   def clear_embedded(self):
1240     if self.has_embedded_:
1241       self.has_embedded_ = 0
1242       self.embedded_ = 0
1243
1244   def has_embedded(self): return self.has_embedded_
1245
1246
1247   def MergeFrom(self, x):
1248     assert x is not self
1249     if (x.has_meaning()): self.set_meaning(x.meaning())
1250     if (x.has_meaning_uri()): self.set_meaning_uri(x.meaning_uri())
1251     if (x.has_name()): self.set_name(x.name())
1252     if (x.has_value()): self.mutable_value().MergeFrom(x.value())
1253     if (x.has_multiple()): self.set_multiple(x.multiple())
1254     if (x.has_embedded()): self.set_embedded(x.embedded())
1255
1256   def Equals(self, x):
1257     if x is self: return 1
1258     if self.has_meaning_ != x.has_meaning_: return 0
1259     if self.has_meaning_ and self.meaning_ != x.meaning_: return 0
1260     if self.has_meaning_uri_ != x.has_meaning_uri_: return 0
1261     if self.has_meaning_uri_ and self.meaning_uri_ != x.meaning_uri_: return 0
1262     if self.has_name_ != x.has_name_: return 0
1263     if self.has_name_ and self.name_ != x.name_: return 0
1264     if self.has_value_ != x.has_value_: return 0
1265     if self.has_value_ and self.value_ != x.value_: return 0
1266     if self.has_multiple_ != x.has_multiple_: return 0
1267     if self.has_multiple_ and self.multiple_ != x.multiple_: return 0
1268     if self.has_embedded_ != x.has_embedded_: return 0
1269     if self.has_embedded_ and self.embedded_ != x.embedded_: return 0
1270     return 1
1271
1272   def IsInitialized(self, debug_strs=None):
1273     initialized = 1
1274     if (not self.has_name_):
1275       initialized = 0
1276       if debug_strs is not None:
1277         debug_strs.append('Required field: name not set.')
1278     if (not self.has_value_):
1279       initialized = 0
1280       if debug_strs is not None:
1281         debug_strs.append('Required field: value not set.')
1282     elif not self.value_.IsInitialized(debug_strs): initialized = 0
1283     if (not self.has_multiple_):
1284       initialized = 0
1285       if debug_strs is not None:
1286         debug_strs.append('Required field: multiple not set.')
1287     return initialized
1288
1289   def ByteSize(self):
1290     n = 0
1291     if (self.has_meaning_): n += 1 + self.lengthVarInt64(self.meaning_)
1292     if (self.has_meaning_uri_): n += 1 + self.lengthString(len(self.meaning_uri_))
1293     n += self.lengthString(len(self.name_))
1294     n += self.lengthString(self.value_.ByteSize())
1295     if (self.has_embedded_): n += 2
1296     return n + 4
1297
1298   def ByteSizePartial(self):
1299     n = 0
1300     if (self.has_meaning_): n += 1 + self.lengthVarInt64(self.meaning_)
1301     if (self.has_meaning_uri_): n += 1 + self.lengthString(len(self.meaning_uri_))
1302     if (self.has_name_):
1303       n += 1
1304       n += self.lengthString(len(self.name_))
1305     if (self.has_value_):
1306       n += 1
1307       n += self.lengthString(self.value_.ByteSizePartial())
1308     if (self.has_multiple_):
1309       n += 2
1310     if (self.has_embedded_): n += 2
1311     return n
1312
1313   def Clear(self):
1314     self.clear_meaning()
1315     self.clear_meaning_uri()
1316     self.clear_name()
1317     self.clear_value()
1318     self.clear_multiple()
1319     self.clear_embedded()
1320
1321   def OutputUnchecked(self, out):
1322     if (self.has_meaning_):
1323       out.putVarInt32(8)
1324       out.putVarInt32(self.meaning_)
1325     if (self.has_meaning_uri_):
1326       out.putVarInt32(18)
1327       out.putPrefixedString(self.meaning_uri_)
1328     out.putVarInt32(26)
1329     out.putPrefixedString(self.name_)
1330     out.putVarInt32(32)
1331     out.putBoolean(self.multiple_)
1332     out.putVarInt32(42)
1333     out.putVarInt32(self.value_.ByteSize())
1334     self.value_.OutputUnchecked(out)
1335     if (self.has_embedded_):
1336       out.putVarInt32(48)
1337       out.putBoolean(self.embedded_)
1338
1339   def OutputPartial(self, out):
1340     if (self.has_meaning_):
1341       out.putVarInt32(8)
1342       out.putVarInt32(self.meaning_)
1343     if (self.has_meaning_uri_):
1344       out.putVarInt32(18)
1345       out.putPrefixedString(self.meaning_uri_)
1346     if (self.has_name_):
1347       out.putVarInt32(26)
1348       out.putPrefixedString(self.name_)
1349     if (self.has_multiple_):
1350       out.putVarInt32(32)
1351       out.putBoolean(self.multiple_)
1352     if (self.has_value_):
1353       out.putVarInt32(42)
1354       out.putVarInt32(self.value_.ByteSizePartial())
1355       self.value_.OutputPartial(out)
1356     if (self.has_embedded_):
1357       out.putVarInt32(48)
1358       out.putBoolean(self.embedded_)
1359
1360   def TryMerge(self, d):
1361     while d.avail() > 0:
1362       tt = d.getVarInt32()
1363       if tt == 8:
1364         self.set_meaning(d.getVarInt32())
1365         continue
1366       if tt == 18:
1367         self.set_meaning_uri(d.getPrefixedString())
1368         continue
1369       if tt == 26:
1370         self.set_name(d.getPrefixedString())
1371         continue
1372       if tt == 32:
1373         self.set_multiple(d.getBoolean())
1374         continue
1375       if tt == 42:
1376         length = d.getVarInt32()
1377         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
1378         d.skip(length)
1379         self.mutable_value().TryMerge(tmp)
1380         continue
1381       if tt == 48:
1382         self.set_embedded(d.getBoolean())
1383         continue
1384
1385
1386       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1387       d.skipData(tt)
1388
1389
1390   def __str__(self, prefix="", printElemNumber=0):
1391     res=""
1392     if self.has_meaning_: res+=prefix+("meaning: %s\n" % self.DebugFormatInt32(self.meaning_))
1393     if self.has_meaning_uri_: res+=prefix+("meaning_uri: %s\n" % self.DebugFormatString(self.meaning_uri_))
1394     if self.has_name_: res+=prefix+("name: %s\n" % self.DebugFormatString(self.name_))
1395     if self.has_value_:
1396       res+=prefix+"value <\n"
1397       res+=self.value_.__str__(prefix + "  ", printElemNumber)
1398       res+=prefix+">\n"
1399     if self.has_multiple_: res+=prefix+("multiple: %s\n" % self.DebugFormatBool(self.multiple_))
1400     if self.has_embedded_: res+=prefix+("embedded: %s\n" % self.DebugFormatBool(self.embedded_))
1401     return res
1402
1403
1404   def _BuildTagLookupTable(sparse, maxtag, default=None):
1405     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
1406
1407   kmeaning = 1
1408   kmeaning_uri = 2
1409   kname = 3
1410   kvalue = 5
1411   kmultiple = 4
1412   kembedded = 6
1413
1414   _TEXT = _BuildTagLookupTable({
1415     0: "ErrorCode",
1416     1: "meaning",
1417     2: "meaning_uri",
1418     3: "name",
1419     4: "multiple",
1420     5: "value",
1421     6: "embedded",
1422   }, 6)
1423
1424   _TYPES = _BuildTagLookupTable({
1425     0: ProtocolBuffer.Encoder.NUMERIC,
1426     1: ProtocolBuffer.Encoder.NUMERIC,
1427     2: ProtocolBuffer.Encoder.STRING,
1428     3: ProtocolBuffer.Encoder.STRING,
1429     4: ProtocolBuffer.Encoder.NUMERIC,
1430     5: ProtocolBuffer.Encoder.STRING,
1431     6: ProtocolBuffer.Encoder.NUMERIC,
1432   }, 6, ProtocolBuffer.Encoder.MAX_TYPE)
1433
1434
1435   _STYLE = """"""
1436   _STYLE_CONTENT_TYPE = """"""
1437   _PROTO_DESCRIPTOR_NAME = 'storage_onestore_v3.Property'
1438 class Path_Element(ProtocolBuffer.ProtocolMessage):
1439   has_type_ = 0
1440   type_ = ""
1441   has_id_ = 0
1442   id_ = 0
1443   has_name_ = 0
1444   name_ = ""
1445
1446   def __init__(self, contents=None):
1447     if contents is not None: self.MergeFromString(contents)
1448
1449   def type(self): return self.type_
1450
1451   def set_type(self, x):
1452     self.has_type_ = 1
1453     self.type_ = x
1454
1455   def clear_type(self):
1456     if self.has_type_:
1457       self.has_type_ = 0
1458       self.type_ = ""
1459
1460   def has_type(self): return self.has_type_
1461
1462   def id(self): return self.id_
1463
1464   def set_id(self, x):
1465     self.has_id_ = 1
1466     self.id_ = x
1467
1468   def clear_id(self):
1469     if self.has_id_:
1470       self.has_id_ = 0
1471       self.id_ = 0
1472
1473   def has_id(self): return self.has_id_
1474
1475   def name(self): return self.name_
1476
1477   def set_name(self, x):
1478     self.has_name_ = 1
1479     self.name_ = x
1480
1481   def clear_name(self):
1482     if self.has_name_:
1483       self.has_name_ = 0
1484       self.name_ = ""
1485
1486   def has_name(self): return self.has_name_
1487
1488
1489   def MergeFrom(self, x):
1490     assert x is not self
1491     if (x.has_type()): self.set_type(x.type())
1492     if (x.has_id()): self.set_id(x.id())
1493     if (x.has_name()): self.set_name(x.name())
1494
1495   def Equals(self, x):
1496     if x is self: return 1
1497     if self.has_type_ != x.has_type_: return 0
1498     if self.has_type_ and self.type_ != x.type_: return 0
1499     if self.has_id_ != x.has_id_: return 0
1500     if self.has_id_ and self.id_ != x.id_: return 0
1501     if self.has_name_ != x.has_name_: return 0
1502     if self.has_name_ and self.name_ != x.name_: return 0
1503     return 1
1504
1505   def IsInitialized(self, debug_strs=None):
1506     initialized = 1
1507     if (not self.has_type_):
1508       initialized = 0
1509       if debug_strs is not None:
1510         debug_strs.append('Required field: type not set.')
1511     return initialized
1512
1513   def ByteSize(self):
1514     n = 0
1515     n += self.lengthString(len(self.type_))
1516     if (self.has_id_): n += 1 + self.lengthVarInt64(self.id_)
1517     if (self.has_name_): n += 1 + self.lengthString(len(self.name_))
1518     return n + 1
1519
1520   def ByteSizePartial(self):
1521     n = 0
1522     if (self.has_type_):
1523       n += 1
1524       n += self.lengthString(len(self.type_))
1525     if (self.has_id_): n += 1 + self.lengthVarInt64(self.id_)
1526     if (self.has_name_): n += 1 + self.lengthString(len(self.name_))
1527     return n
1528
1529   def Clear(self):
1530     self.clear_type()
1531     self.clear_id()
1532     self.clear_name()
1533
1534   def OutputUnchecked(self, out):
1535     out.putVarInt32(18)
1536     out.putPrefixedString(self.type_)
1537     if (self.has_id_):
1538       out.putVarInt32(24)
1539       out.putVarInt64(self.id_)
1540     if (self.has_name_):
1541       out.putVarInt32(34)
1542       out.putPrefixedString(self.name_)
1543
1544   def OutputPartial(self, out):
1545     if (self.has_type_):
1546       out.putVarInt32(18)
1547       out.putPrefixedString(self.type_)
1548     if (self.has_id_):
1549       out.putVarInt32(24)
1550       out.putVarInt64(self.id_)
1551     if (self.has_name_):
1552       out.putVarInt32(34)
1553       out.putPrefixedString(self.name_)
1554
1555   def TryMerge(self, d):
1556     while 1:
1557       tt = d.getVarInt32()
1558       if tt == 12: break
1559       if tt == 18:
1560         self.set_type(d.getPrefixedString())
1561         continue
1562       if tt == 24:
1563         self.set_id(d.getVarInt64())
1564         continue
1565       if tt == 34:
1566         self.set_name(d.getPrefixedString())
1567         continue
1568
1569
1570       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1571       d.skipData(tt)
1572
1573
1574   def __str__(self, prefix="", printElemNumber=0):
1575     res=""
1576     if self.has_type_: res+=prefix+("type: %s\n" % self.DebugFormatString(self.type_))
1577     if self.has_id_: res+=prefix+("id: %s\n" % self.DebugFormatInt64(self.id_))
1578     if self.has_name_: res+=prefix+("name: %s\n" % self.DebugFormatString(self.name_))
1579     return res
1580
1581 class Path(ProtocolBuffer.ProtocolMessage):
1582
1583   def __init__(self, contents=None):
1584     self.element_ = []
1585     if contents is not None: self.MergeFromString(contents)
1586
1587   def element_size(self): return len(self.element_)
1588   def element_list(self): return self.element_
1589
1590   def element(self, i):
1591     return self.element_[i]
1592
1593   def mutable_element(self, i):
1594     return self.element_[i]
1595
1596   def add_element(self):
1597     x = Path_Element()
1598     self.element_.append(x)
1599     return x
1600
1601   def clear_element(self):
1602     self.element_ = []
1603
1604   def MergeFrom(self, x):
1605     assert x is not self
1606     for i in xrange(x.element_size()): self.add_element().CopyFrom(x.element(i))
1607
1608   def Equals(self, x):
1609     if x is self: return 1
1610     if len(self.element_) != len(x.element_): return 0
1611     for e1, e2 in zip(self.element_, x.element_):
1612       if e1 != e2: return 0
1613     return 1
1614
1615   def IsInitialized(self, debug_strs=None):
1616     initialized = 1
1617     for p in self.element_:
1618       if not p.IsInitialized(debug_strs): initialized=0
1619     return initialized
1620
1621   def ByteSize(self):
1622     n = 0
1623     n += 2 * len(self.element_)
1624     for i in xrange(len(self.element_)): n += self.element_[i].ByteSize()
1625     return n
1626
1627   def ByteSizePartial(self):
1628     n = 0
1629     n += 2 * len(self.element_)
1630     for i in xrange(len(self.element_)): n += self.element_[i].ByteSizePartial()
1631     return n
1632
1633   def Clear(self):
1634     self.clear_element()
1635
1636   def OutputUnchecked(self, out):
1637     for i in xrange(len(self.element_)):
1638       out.putVarInt32(11)
1639       self.element_[i].OutputUnchecked(out)
1640       out.putVarInt32(12)
1641
1642   def OutputPartial(self, out):
1643     for i in xrange(len(self.element_)):
1644       out.putVarInt32(11)
1645       self.element_[i].OutputPartial(out)
1646       out.putVarInt32(12)
1647
1648   def TryMerge(self, d):
1649     while d.avail() > 0:
1650       tt = d.getVarInt32()
1651       if tt == 11:
1652         self.add_element().TryMerge(d)
1653         continue
1654
1655
1656       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1657       d.skipData(tt)
1658
1659
1660   def __str__(self, prefix="", printElemNumber=0):
1661     res=""
1662     cnt=0
1663     for e in self.element_:
1664       elm=""
1665       if printElemNumber: elm="(%d)" % cnt
1666       res+=prefix+("Element%s {\n" % elm)
1667       res+=e.__str__(prefix + "  ", printElemNumber)
1668       res+=prefix+"}\n"
1669       cnt+=1
1670     return res
1671
1672
1673   def _BuildTagLookupTable(sparse, maxtag, default=None):
1674     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
1675
1676   kElementGroup = 1
1677   kElementtype = 2
1678   kElementid = 3
1679   kElementname = 4
1680
1681   _TEXT = _BuildTagLookupTable({
1682     0: "ErrorCode",
1683     1: "Element",
1684     2: "type",
1685     3: "id",
1686     4: "name",
1687   }, 4)
1688
1689   _TYPES = _BuildTagLookupTable({
1690     0: ProtocolBuffer.Encoder.NUMERIC,
1691     1: ProtocolBuffer.Encoder.STARTGROUP,
1692     2: ProtocolBuffer.Encoder.STRING,
1693     3: ProtocolBuffer.Encoder.NUMERIC,
1694     4: ProtocolBuffer.Encoder.STRING,
1695   }, 4, ProtocolBuffer.Encoder.MAX_TYPE)
1696
1697
1698   _STYLE = """"""
1699   _STYLE_CONTENT_TYPE = """"""
1700   _PROTO_DESCRIPTOR_NAME = 'storage_onestore_v3.Path'
1701 class Reference(ProtocolBuffer.ProtocolMessage):
1702   has_app_ = 0
1703   app_ = ""
1704   has_name_space_ = 0
1705   name_space_ = ""
1706   has_path_ = 0
1707
1708   def __init__(self, contents=None):
1709     self.path_ = Path()
1710     if contents is not None: self.MergeFromString(contents)
1711
1712   def app(self): return self.app_
1713
1714   def set_app(self, x):
1715     self.has_app_ = 1
1716     self.app_ = x
1717
1718   def clear_app(self):
1719     if self.has_app_:
1720       self.has_app_ = 0
1721       self.app_ = ""
1722
1723   def has_app(self): return self.has_app_
1724
1725   def name_space(self): return self.name_space_
1726
1727   def set_name_space(self, x):
1728     self.has_name_space_ = 1
1729     self.name_space_ = x
1730
1731   def clear_name_space(self):
1732     if self.has_name_space_:
1733       self.has_name_space_ = 0
1734       self.name_space_ = ""
1735
1736   def has_name_space(self): return self.has_name_space_
1737
1738   def path(self): return self.path_
1739
1740   def mutable_path(self): self.has_path_ = 1; return self.path_
1741
1742   def clear_path(self):self.has_path_ = 0; self.path_.Clear()
1743
1744   def has_path(self): return self.has_path_
1745
1746
1747   def MergeFrom(self, x):
1748     assert x is not self
1749     if (x.has_app()): self.set_app(x.app())
1750     if (x.has_name_space()): self.set_name_space(x.name_space())
1751     if (x.has_path()): self.mutable_path().MergeFrom(x.path())
1752
1753   def Equals(self, x):
1754     if x is self: return 1
1755     if self.has_app_ != x.has_app_: return 0
1756     if self.has_app_ and self.app_ != x.app_: return 0
1757     if self.has_name_space_ != x.has_name_space_: return 0
1758     if self.has_name_space_ and self.name_space_ != x.name_space_: return 0
1759     if self.has_path_ != x.has_path_: return 0
1760     if self.has_path_ and self.path_ != x.path_: return 0
1761     return 1
1762
1763   def IsInitialized(self, debug_strs=None):
1764     initialized = 1
1765     if (not self.has_app_):
1766       initialized = 0
1767       if debug_strs is not None:
1768         debug_strs.append('Required field: app not set.')
1769     if (not self.has_path_):
1770       initialized = 0
1771       if debug_strs is not None:
1772         debug_strs.append('Required field: path not set.')
1773     elif not self.path_.IsInitialized(debug_strs): initialized = 0
1774     return initialized
1775
1776   def ByteSize(self):
1777     n = 0
1778     n += self.lengthString(len(self.app_))
1779     if (self.has_name_space_): n += 2 + self.lengthString(len(self.name_space_))
1780     n += self.lengthString(self.path_.ByteSize())
1781     return n + 2
1782
1783   def ByteSizePartial(self):
1784     n = 0
1785     if (self.has_app_):
1786       n += 1
1787       n += self.lengthString(len(self.app_))
1788     if (self.has_name_space_): n += 2 + self.lengthString(len(self.name_space_))
1789     if (self.has_path_):
1790       n += 1
1791       n += self.lengthString(self.path_.ByteSizePartial())
1792     return n
1793
1794   def Clear(self):
1795     self.clear_app()
1796     self.clear_name_space()
1797     self.clear_path()
1798
1799   def OutputUnchecked(self, out):
1800     out.putVarInt32(106)
1801     out.putPrefixedString(self.app_)
1802     out.putVarInt32(114)
1803     out.putVarInt32(self.path_.ByteSize())
1804     self.path_.OutputUnchecked(out)
1805     if (self.has_name_space_):
1806       out.putVarInt32(162)
1807       out.putPrefixedString(self.name_space_)
1808
1809   def OutputPartial(self, out):
1810     if (self.has_app_):
1811       out.putVarInt32(106)
1812       out.putPrefixedString(self.app_)
1813     if (self.has_path_):
1814       out.putVarInt32(114)
1815       out.putVarInt32(self.path_.ByteSizePartial())
1816       self.path_.OutputPartial(out)
1817     if (self.has_name_space_):
1818       out.putVarInt32(162)
1819       out.putPrefixedString(self.name_space_)
1820
1821   def TryMerge(self, d):
1822     while d.avail() > 0:
1823       tt = d.getVarInt32()
1824       if tt == 106:
1825         self.set_app(d.getPrefixedString())
1826         continue
1827       if tt == 114:
1828         length = d.getVarInt32()
1829         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
1830         d.skip(length)
1831         self.mutable_path().TryMerge(tmp)
1832         continue
1833       if tt == 162:
1834         self.set_name_space(d.getPrefixedString())
1835         continue
1836
1837
1838       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1839       d.skipData(tt)
1840
1841
1842   def __str__(self, prefix="", printElemNumber=0):
1843     res=""
1844     if self.has_app_: res+=prefix+("app: %s\n" % self.DebugFormatString(self.app_))
1845     if self.has_name_space_: res+=prefix+("name_space: %s\n" % self.DebugFormatString(self.name_space_))
1846     if self.has_path_:
1847       res+=prefix+"path <\n"
1848       res+=self.path_.__str__(prefix + "  ", printElemNumber)
1849       res+=prefix+">\n"
1850     return res
1851
1852
1853   def _BuildTagLookupTable(sparse, maxtag, default=None):
1854     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
1855
1856   kapp = 13
1857   kname_space = 20
1858   kpath = 14
1859
1860   _TEXT = _BuildTagLookupTable({
1861     0: "ErrorCode",
1862     13: "app",
1863     14: "path",
1864     20: "name_space",
1865   }, 20)
1866
1867   _TYPES = _BuildTagLookupTable({
1868     0: ProtocolBuffer.Encoder.NUMERIC,
1869     13: ProtocolBuffer.Encoder.STRING,
1870     14: ProtocolBuffer.Encoder.STRING,
1871     20: ProtocolBuffer.Encoder.STRING,
1872   }, 20, ProtocolBuffer.Encoder.MAX_TYPE)
1873
1874
1875   _STYLE = """"""
1876   _STYLE_CONTENT_TYPE = """"""
1877   _PROTO_DESCRIPTOR_NAME = 'storage_onestore_v3.Reference'
1878 class User(ProtocolBuffer.ProtocolMessage):
1879   has_email_ = 0
1880   email_ = ""
1881   has_auth_domain_ = 0
1882   auth_domain_ = ""
1883   has_nickname_ = 0
1884   nickname_ = ""
1885   has_gaiaid_ = 0
1886   gaiaid_ = 0
1887   has_obfuscated_gaiaid_ = 0
1888   obfuscated_gaiaid_ = ""
1889   has_federated_identity_ = 0
1890   federated_identity_ = ""
1891   has_federated_provider_ = 0
1892   federated_provider_ = ""
1893
1894   def __init__(self, contents=None):
1895     if contents is not None: self.MergeFromString(contents)
1896
1897   def email(self): return self.email_
1898
1899   def set_email(self, x):
1900     self.has_email_ = 1
1901     self.email_ = x
1902
1903   def clear_email(self):
1904     if self.has_email_:
1905       self.has_email_ = 0
1906       self.email_ = ""
1907
1908   def has_email(self): return self.has_email_
1909
1910   def auth_domain(self): return self.auth_domain_
1911
1912   def set_auth_domain(self, x):
1913     self.has_auth_domain_ = 1
1914     self.auth_domain_ = x
1915
1916   def clear_auth_domain(self):
1917     if self.has_auth_domain_:
1918       self.has_auth_domain_ = 0
1919       self.auth_domain_ = ""
1920
1921   def has_auth_domain(self): return self.has_auth_domain_
1922
1923   def nickname(self): return self.nickname_
1924
1925   def set_nickname(self, x):
1926     self.has_nickname_ = 1
1927     self.nickname_ = x
1928
1929   def clear_nickname(self):
1930     if self.has_nickname_:
1931       self.has_nickname_ = 0
1932       self.nickname_ = ""
1933
1934   def has_nickname(self): return self.has_nickname_
1935
1936   def gaiaid(self): return self.gaiaid_
1937
1938   def set_gaiaid(self, x):
1939     self.has_gaiaid_ = 1
1940     self.gaiaid_ = x
1941
1942   def clear_gaiaid(self):
1943     if self.has_gaiaid_:
1944       self.has_gaiaid_ = 0
1945       self.gaiaid_ = 0
1946
1947   def has_gaiaid(self): return self.has_gaiaid_
1948
1949   def obfuscated_gaiaid(self): return self.obfuscated_gaiaid_
1950
1951   def set_obfuscated_gaiaid(self, x):
1952     self.has_obfuscated_gaiaid_ = 1
1953     self.obfuscated_gaiaid_ = x
1954
1955   def clear_obfuscated_gaiaid(self):
1956     if self.has_obfuscated_gaiaid_:
1957       self.has_obfuscated_gaiaid_ = 0
1958       self.obfuscated_gaiaid_ = ""
1959
1960   def has_obfuscated_gaiaid(self): return self.has_obfuscated_gaiaid_
1961
1962   def federated_identity(self): return self.federated_identity_
1963
1964   def set_federated_identity(self, x):
1965     self.has_federated_identity_ = 1
1966     self.federated_identity_ = x
1967
1968   def clear_federated_identity(self):
1969     if self.has_federated_identity_:
1970       self.has_federated_identity_ = 0
1971       self.federated_identity_ = ""
1972
1973   def has_federated_identity(self): return self.has_federated_identity_
1974
1975   def federated_provider(self): return self.federated_provider_
1976
1977   def set_federated_provider(self, x):
1978     self.has_federated_provider_ = 1
1979     self.federated_provider_ = x
1980
1981   def clear_federated_provider(self):
1982     if self.has_federated_provider_:
1983       self.has_federated_provider_ = 0
1984       self.federated_provider_ = ""
1985
1986   def has_federated_provider(self): return self.has_federated_provider_
1987
1988
1989   def MergeFrom(self, x):
1990     assert x is not self
1991     if (x.has_email()): self.set_email(x.email())
1992     if (x.has_auth_domain()): self.set_auth_domain(x.auth_domain())
1993     if (x.has_nickname()): self.set_nickname(x.nickname())
1994     if (x.has_gaiaid()): self.set_gaiaid(x.gaiaid())
1995     if (x.has_obfuscated_gaiaid()): self.set_obfuscated_gaiaid(x.obfuscated_gaiaid())
1996     if (x.has_federated_identity()): self.set_federated_identity(x.federated_identity())
1997     if (x.has_federated_provider()): self.set_federated_provider(x.federated_provider())
1998
1999   def Equals(self, x):
2000     if x is self: return 1
2001     if self.has_email_ != x.has_email_: return 0
2002     if self.has_email_ and self.email_ != x.email_: return 0
2003     if self.has_auth_domain_ != x.has_auth_domain_: return 0
2004     if self.has_auth_domain_ and self.auth_domain_ != x.auth_domain_: return 0
2005     if self.has_nickname_ != x.has_nickname_: return 0
2006     if self.has_nickname_ and self.nickname_ != x.nickname_: return 0
2007     if self.has_gaiaid_ != x.has_gaiaid_: return 0
2008     if self.has_gaiaid_ and self.gaiaid_ != x.gaiaid_: return 0
2009     if self.has_obfuscated_gaiaid_ != x.has_obfuscated_gaiaid_: return 0
2010     if self.has_obfuscated_gaiaid_ and self.obfuscated_gaiaid_ != x.obfuscated_gaiaid_: return 0
2011     if self.has_federated_identity_ != x.has_federated_identity_: return 0
2012     if self.has_federated_identity_ and self.federated_identity_ != x.federated_identity_: return 0
2013     if self.has_federated_provider_ != x.has_federated_provider_: return 0
2014     if self.has_federated_provider_ and self.federated_provider_ != x.federated_provider_: return 0
2015     return 1
2016
2017   def IsInitialized(self, debug_strs=None):
2018     initialized = 1
2019     if (not self.has_email_):
2020       initialized = 0
2021       if debug_strs is not None:
2022         debug_strs.append('Required field: email not set.')
2023     if (not self.has_auth_domain_):
2024       initialized = 0
2025       if debug_strs is not None:
2026         debug_strs.append('Required field: auth_domain not set.')
2027     if (not self.has_gaiaid_):
2028       initialized = 0
2029       if debug_strs is not None:
2030         debug_strs.append('Required field: gaiaid not set.')
2031     return initialized
2032
2033   def ByteSize(self):
2034     n = 0
2035     n += self.lengthString(len(self.email_))
2036     n += self.lengthString(len(self.auth_domain_))
2037     if (self.has_nickname_): n += 1 + self.lengthString(len(self.nickname_))
2038     n += self.lengthVarInt64(self.gaiaid_)
2039     if (self.has_obfuscated_gaiaid_): n += 1 + self.lengthString(len(self.obfuscated_gaiaid_))
2040     if (self.has_federated_identity_): n += 1 + self.lengthString(len(self.federated_identity_))
2041     if (self.has_federated_provider_): n += 1 + self.lengthString(len(self.federated_provider_))
2042     return n + 3
2043
2044   def ByteSizePartial(self):
2045     n = 0
2046     if (self.has_email_):
2047       n += 1
2048       n += self.lengthString(len(self.email_))
2049     if (self.has_auth_domain_):
2050       n += 1
2051       n += self.lengthString(len(self.auth_domain_))
2052     if (self.has_nickname_): n += 1 + self.lengthString(len(self.nickname_))
2053     if (self.has_gaiaid_):
2054       n += 1
2055       n += self.lengthVarInt64(self.gaiaid_)
2056     if (self.has_obfuscated_gaiaid_): n += 1 + self.lengthString(len(self.obfuscated_gaiaid_))
2057     if (self.has_federated_identity_): n += 1 + self.lengthString(len(self.federated_identity_))
2058     if (self.has_federated_provider_): n += 1 + self.lengthString(len(self.federated_provider_))
2059     return n
2060
2061   def Clear(self):
2062     self.clear_email()
2063     self.clear_auth_domain()
2064     self.clear_nickname()
2065     self.clear_gaiaid()
2066     self.clear_obfuscated_gaiaid()
2067     self.clear_federated_identity()
2068     self.clear_federated_provider()
2069
2070   def OutputUnchecked(self, out):
2071     out.putVarInt32(10)
2072     out.putPrefixedString(self.email_)
2073     out.putVarInt32(18)
2074     out.putPrefixedString(self.auth_domain_)
2075     if (self.has_nickname_):
2076       out.putVarInt32(26)
2077       out.putPrefixedString(self.nickname_)
2078     out.putVarInt32(32)
2079     out.putVarInt64(self.gaiaid_)
2080     if (self.has_obfuscated_gaiaid_):
2081       out.putVarInt32(42)
2082       out.putPrefixedString(self.obfuscated_gaiaid_)
2083     if (self.has_federated_identity_):
2084       out.putVarInt32(50)
2085       out.putPrefixedString(self.federated_identity_)
2086     if (self.has_federated_provider_):
2087       out.putVarInt32(58)
2088       out.putPrefixedString(self.federated_provider_)
2089
2090   def OutputPartial(self, out):
2091     if (self.has_email_):
2092       out.putVarInt32(10)
2093       out.putPrefixedString(self.email_)
2094     if (self.has_auth_domain_):
2095       out.putVarInt32(18)
2096       out.putPrefixedString(self.auth_domain_)
2097     if (self.has_nickname_):
2098       out.putVarInt32(26)
2099       out.putPrefixedString(self.nickname_)
2100     if (self.has_gaiaid_):
2101       out.putVarInt32(32)
2102       out.putVarInt64(self.gaiaid_)
2103     if (self.has_obfuscated_gaiaid_):
2104       out.putVarInt32(42)
2105       out.putPrefixedString(self.obfuscated_gaiaid_)
2106     if (self.has_federated_identity_):
2107       out.putVarInt32(50)
2108       out.putPrefixedString(self.federated_identity_)
2109     if (self.has_federated_provider_):
2110       out.putVarInt32(58)
2111       out.putPrefixedString(self.federated_provider_)
2112
2113   def TryMerge(self, d):
2114     while d.avail() > 0:
2115       tt = d.getVarInt32()
2116       if tt == 10:
2117         self.set_email(d.getPrefixedString())
2118         continue
2119       if tt == 18:
2120         self.set_auth_domain(d.getPrefixedString())
2121         continue
2122       if tt == 26:
2123         self.set_nickname(d.getPrefixedString())
2124         continue
2125       if tt == 32:
2126         self.set_gaiaid(d.getVarInt64())
2127         continue
2128       if tt == 42:
2129         self.set_obfuscated_gaiaid(d.getPrefixedString())
2130         continue
2131       if tt == 50:
2132         self.set_federated_identity(d.getPrefixedString())
2133         continue
2134       if tt == 58:
2135         self.set_federated_provider(d.getPrefixedString())
2136         continue
2137
2138
2139       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
2140       d.skipData(tt)
2141
2142
2143   def __str__(self, prefix="", printElemNumber=0):
2144     res=""
2145     if self.has_email_: res+=prefix+("email: %s\n" % self.DebugFormatString(self.email_))
2146     if self.has_auth_domain_: res+=prefix+("auth_domain: %s\n" % self.DebugFormatString(self.auth_domain_))
2147     if self.has_nickname_: res+=prefix+("nickname: %s\n" % self.DebugFormatString(self.nickname_))
2148     if self.has_gaiaid_: res+=prefix+("gaiaid: %s\n" % self.DebugFormatInt64(self.gaiaid_))
2149     if self.has_obfuscated_gaiaid_: res+=prefix+("obfuscated_gaiaid: %s\n" % self.DebugFormatString(self.obfuscated_gaiaid_))
2150     if self.has_federated_identity_: res+=prefix+("federated_identity: %s\n" % self.DebugFormatString(self.federated_identity_))
2151     if self.has_federated_provider_: res+=prefix+("federated_provider: %s\n" % self.DebugFormatString(self.federated_provider_))
2152     return res
2153
2154
2155   def _BuildTagLookupTable(sparse, maxtag, default=None):
2156     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
2157
2158   kemail = 1
2159   kauth_domain = 2
2160   knickname = 3
2161   kgaiaid = 4
2162   kobfuscated_gaiaid = 5
2163   kfederated_identity = 6
2164   kfederated_provider = 7
2165
2166   _TEXT = _BuildTagLookupTable({
2167     0: "ErrorCode",
2168     1: "email",
2169     2: "auth_domain",
2170     3: "nickname",
2171     4: "gaiaid",
2172     5: "obfuscated_gaiaid",
2173     6: "federated_identity",
2174     7: "federated_provider",
2175   }, 7)
2176
2177   _TYPES = _BuildTagLookupTable({
2178     0: ProtocolBuffer.Encoder.NUMERIC,
2179     1: ProtocolBuffer.Encoder.STRING,
2180     2: ProtocolBuffer.Encoder.STRING,
2181     3: ProtocolBuffer.Encoder.STRING,
2182     4: ProtocolBuffer.Encoder.NUMERIC,
2183     5: ProtocolBuffer.Encoder.STRING,
2184     6: ProtocolBuffer.Encoder.STRING,
2185     7: ProtocolBuffer.Encoder.STRING,
2186   }, 7, ProtocolBuffer.Encoder.MAX_TYPE)
2187
2188
2189   _STYLE = """"""
2190   _STYLE_CONTENT_TYPE = """"""
2191   _PROTO_DESCRIPTOR_NAME = 'storage_onestore_v3.User'
2192 class EntityProto(ProtocolBuffer.ProtocolMessage):
2193
2194
2195   GD_CONTACT   =    1
2196   GD_EVENT     =    2
2197   GD_MESSAGE   =    3
2198
2199   _Kind_NAMES = {
2200     1: "GD_CONTACT",
2201     2: "GD_EVENT",
2202     3: "GD_MESSAGE",
2203   }
2204
2205   def Kind_Name(cls, x): return cls._Kind_NAMES.get(x, "")
2206   Kind_Name = classmethod(Kind_Name)
2207
2208   has_key_ = 0
2209   has_entity_group_ = 0
2210   has_owner_ = 0
2211   owner_ = None
2212   has_kind_ = 0
2213   kind_ = 0
2214   has_kind_uri_ = 0
2215   kind_uri_ = ""
2216
2217   def __init__(self, contents=None):
2218     self.key_ = Reference()
2219     self.entity_group_ = Path()
2220     self.property_ = []
2221     self.raw_property_ = []
2222     self.lazy_init_lock_ = thread.allocate_lock()
2223     if contents is not None: self.MergeFromString(contents)
2224
2225   def key(self): return self.key_
2226
2227   def mutable_key(self): self.has_key_ = 1; return self.key_
2228
2229   def clear_key(self):self.has_key_ = 0; self.key_.Clear()
2230
2231   def has_key(self): return self.has_key_
2232
2233   def entity_group(self): return self.entity_group_
2234
2235   def mutable_entity_group(self): self.has_entity_group_ = 1; return self.entity_group_
2236
2237   def clear_entity_group(self):self.has_entity_group_ = 0; self.entity_group_.Clear()
2238
2239   def has_entity_group(self): return self.has_entity_group_
2240
2241   def owner(self):
2242     if self.owner_ is None:
2243       self.lazy_init_lock_.acquire()
2244       try:
2245         if self.owner_ is None: self.owner_ = User()
2246       finally:
2247         self.lazy_init_lock_.release()
2248     return self.owner_
2249
2250   def mutable_owner(self): self.has_owner_ = 1; return self.owner()
2251
2252   def clear_owner(self):
2253
2254     if self.has_owner_:
2255       self.has_owner_ = 0;
2256       if self.owner_ is not None: self.owner_.Clear()
2257
2258   def has_owner(self): return self.has_owner_
2259
2260   def kind(self): return self.kind_
2261
2262   def set_kind(self, x):
2263     self.has_kind_ = 1
2264     self.kind_ = x
2265
2266   def clear_kind(self):
2267     if self.has_kind_:
2268       self.has_kind_ = 0
2269       self.kind_ = 0
2270
2271   def has_kind(self): return self.has_kind_
2272
2273   def kind_uri(self): return self.kind_uri_
2274
2275   def set_kind_uri(self, x):
2276     self.has_kind_uri_ = 1
2277     self.kind_uri_ = x
2278
2279   def clear_kind_uri(self):
2280     if self.has_kind_uri_:
2281       self.has_kind_uri_ = 0
2282       self.kind_uri_ = ""
2283
2284   def has_kind_uri(self): return self.has_kind_uri_
2285
2286   def property_size(self): return len(self.property_)
2287   def property_list(self): return self.property_
2288
2289   def property(self, i):
2290     return self.property_[i]
2291
2292   def mutable_property(self, i):
2293     return self.property_[i]
2294
2295   def add_property(self):
2296     x = Property()
2297     self.property_.append(x)
2298     return x
2299
2300   def clear_property(self):
2301     self.property_ = []
2302   def raw_property_size(self): return len(self.raw_property_)
2303   def raw_property_list(self): return self.raw_property_
2304
2305   def raw_property(self, i):
2306     return self.raw_property_[i]
2307
2308   def mutable_raw_property(self, i):
2309     return self.raw_property_[i]
2310
2311   def add_raw_property(self):
2312     x = Property()
2313     self.raw_property_.append(x)
2314     return x
2315
2316   def clear_raw_property(self):
2317     self.raw_property_ = []
2318
2319   def MergeFrom(self, x):
2320     assert x is not self
2321     if (x.has_key()): self.mutable_key().MergeFrom(x.key())
2322     if (x.has_entity_group()): self.mutable_entity_group().MergeFrom(x.entity_group())
2323     if (x.has_owner()): self.mutable_owner().MergeFrom(x.owner())
2324     if (x.has_kind()): self.set_kind(x.kind())
2325     if (x.has_kind_uri()): self.set_kind_uri(x.kind_uri())
2326     for i in xrange(x.property_size()): self.add_property().CopyFrom(x.property(i))
2327     for i in xrange(x.raw_property_size()): self.add_raw_property().CopyFrom(x.raw_property(i))
2328
2329   def Equals(self, x):
2330     if x is self: return 1
2331     if self.has_key_ != x.has_key_: return 0
2332     if self.has_key_ and self.key_ != x.key_: return 0
2333     if self.has_entity_group_ != x.has_entity_group_: return 0
2334     if self.has_entity_group_ and self.entity_group_ != x.entity_group_: return 0
2335     if self.has_owner_ != x.has_owner_: return 0
2336     if self.has_owner_ and self.owner_ != x.owner_: return 0
2337     if self.has_kind_ != x.has_kind_: return 0
2338     if self.has_kind_ and self.kind_ != x.kind_: return 0
2339     if self.has_kind_uri_ != x.has_kind_uri_: return 0
2340     if self.has_kind_uri_ and self.kind_uri_ != x.kind_uri_: return 0
2341     if len(self.property_) != len(x.property_): return 0
2342     for e1, e2 in zip(self.property_, x.property_):
2343       if e1 != e2: return 0
2344     if len(self.raw_property_) != len(x.raw_property_): return 0
2345     for e1, e2 in zip(self.raw_property_, x.raw_property_):
2346       if e1 != e2: return 0
2347     return 1
2348
2349   def IsInitialized(self, debug_strs=None):
2350     initialized = 1
2351     if (not self.has_key_):
2352       initialized = 0
2353       if debug_strs is not None:
2354         debug_strs.append('Required field: key not set.')
2355     elif not self.key_.IsInitialized(debug_strs): initialized = 0
2356     if (not self.has_entity_group_):
2357       initialized = 0
2358       if debug_strs is not None:
2359         debug_strs.append('Required field: entity_group not set.')
2360     elif not self.entity_group_.IsInitialized(debug_strs): initialized = 0
2361     if (self.has_owner_ and not self.owner_.IsInitialized(debug_strs)): initialized = 0
2362     for p in self.property_:
2363       if not p.IsInitialized(debug_strs): initialized=0
2364     for p in self.raw_property_:
2365       if not p.IsInitialized(debug_strs): initialized=0
2366     return initialized
2367
2368   def ByteSize(self):
2369     n = 0
2370     n += self.lengthString(self.key_.ByteSize())
2371     n += self.lengthString(self.entity_group_.ByteSize())
2372     if (self.has_owner_): n += 2 + self.lengthString(self.owner_.ByteSize())
2373     if (self.has_kind_): n += 1 + self.lengthVarInt64(self.kind_)
2374     if (self.has_kind_uri_): n += 1 + self.lengthString(len(self.kind_uri_))
2375     n += 1 * len(self.property_)
2376     for i in xrange(len(self.property_)): n += self.lengthString(self.property_[i].ByteSize())
2377     n += 1 * len(self.raw_property_)
2378     for i in xrange(len(self.raw_property_)): n += self.lengthString(self.raw_property_[i].ByteSize())
2379     return n + 3
2380
2381   def ByteSizePartial(self):
2382     n = 0
2383     if (self.has_key_):
2384       n += 1
2385       n += self.lengthString(self.key_.ByteSizePartial())
2386     if (self.has_entity_group_):
2387       n += 2
2388       n += self.lengthString(self.entity_group_.ByteSizePartial())
2389     if (self.has_owner_): n += 2 + self.lengthString(self.owner_.ByteSizePartial())
2390     if (self.has_kind_): n += 1 + self.lengthVarInt64(self.kind_)
2391     if (self.has_kind_uri_): n += 1 + self.lengthString(len(self.kind_uri_))
2392     n += 1 * len(self.property_)
2393     for i in xrange(len(self.property_)): n += self.lengthString(self.property_[i].ByteSizePartial())
2394     n += 1 * len(self.raw_property_)
2395     for i in xrange(len(self.raw_property_)): n += self.lengthString(self.raw_property_[i].ByteSizePartial())
2396     return n
2397
2398   def Clear(self):
2399     self.clear_key()
2400     self.clear_entity_group()
2401     self.clear_owner()
2402     self.clear_kind()
2403     self.clear_kind_uri()
2404     self.clear_property()
2405     self.clear_raw_property()
2406
2407   def OutputUnchecked(self, out):
2408     if (self.has_kind_):
2409       out.putVarInt32(32)
2410       out.putVarInt32(self.kind_)
2411     if (self.has_kind_uri_):
2412       out.putVarInt32(42)
2413       out.putPrefixedString(self.kind_uri_)
2414     out.putVarInt32(106)
2415     out.putVarInt32(self.key_.ByteSize())
2416     self.key_.OutputUnchecked(out)
2417     for i in xrange(len(self.property_)):
2418       out.putVarInt32(114)
2419       out.putVarInt32(self.property_[i].ByteSize())
2420       self.property_[i].OutputUnchecked(out)
2421     for i in xrange(len(self.raw_property_)):
2422       out.putVarInt32(122)
2423       out.putVarInt32(self.raw_property_[i].ByteSize())
2424       self.raw_property_[i].OutputUnchecked(out)
2425     out.putVarInt32(130)
2426     out.putVarInt32(self.entity_group_.ByteSize())
2427     self.entity_group_.OutputUnchecked(out)
2428     if (self.has_owner_):
2429       out.putVarInt32(138)
2430       out.putVarInt32(self.owner_.ByteSize())
2431       self.owner_.OutputUnchecked(out)
2432
2433   def OutputPartial(self, out):
2434     if (self.has_kind_):
2435       out.putVarInt32(32)
2436       out.putVarInt32(self.kind_)
2437     if (self.has_kind_uri_):
2438       out.putVarInt32(42)
2439       out.putPrefixedString(self.kind_uri_)
2440     if (self.has_key_):
2441       out.putVarInt32(106)
2442       out.putVarInt32(self.key_.ByteSizePartial())
2443       self.key_.OutputPartial(out)
2444     for i in xrange(len(self.property_)):
2445       out.putVarInt32(114)
2446       out.putVarInt32(self.property_[i].ByteSizePartial())
2447       self.property_[i].OutputPartial(out)
2448     for i in xrange(len(self.raw_property_)):
2449       out.putVarInt32(122)
2450       out.putVarInt32(self.raw_property_[i].ByteSizePartial())
2451       self.raw_property_[i].OutputPartial(out)
2452     if (self.has_entity_group_):
2453       out.putVarInt32(130)
2454       out.putVarInt32(self.entity_group_.ByteSizePartial())
2455       self.entity_group_.OutputPartial(out)
2456     if (self.has_owner_):
2457       out.putVarInt32(138)
2458       out.putVarInt32(self.owner_.ByteSizePartial())
2459       self.owner_.OutputPartial(out)
2460
2461   def TryMerge(self, d):
2462     while d.avail() > 0:
2463       tt = d.getVarInt32()
2464       if tt == 32:
2465         self.set_kind(d.getVarInt32())
2466         continue
2467       if tt == 42:
2468         self.set_kind_uri(d.getPrefixedString())
2469         continue
2470       if tt == 106:
2471         length = d.getVarInt32()
2472         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
2473         d.skip(length)
2474         self.mutable_key().TryMerge(tmp)
2475         continue
2476       if tt == 114:
2477         length = d.getVarInt32()
2478         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
2479         d.skip(length)
2480         self.add_property().TryMerge(tmp)
2481         continue
2482       if tt == 122:
2483         length = d.getVarInt32()
2484         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
2485         d.skip(length)
2486         self.add_raw_property().TryMerge(tmp)
2487         continue
2488       if tt == 130:
2489         length = d.getVarInt32()
2490         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
2491         d.skip(length)
2492         self.mutable_entity_group().TryMerge(tmp)
2493         continue
2494       if tt == 138:
2495         length = d.getVarInt32()
2496         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
2497         d.skip(length)
2498         self.mutable_owner().TryMerge(tmp)
2499         continue
2500
2501
2502       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
2503       d.skipData(tt)
2504
2505
2506   def __str__(self, prefix="", printElemNumber=0):
2507     res=""
2508     if self.has_key_:
2509       res+=prefix+"key <\n"
2510       res+=self.key_.__str__(prefix + "  ", printElemNumber)
2511       res+=prefix+">\n"
2512     if self.has_entity_group_:
2513       res+=prefix+"entity_group <\n"
2514       res+=self.entity_group_.__str__(prefix + "  ", printElemNumber)
2515       res+=prefix+">\n"
2516     if self.has_owner_:
2517       res+=prefix+"owner <\n"
2518       res+=self.owner_.__str__(prefix + "  ", printElemNumber)
2519       res+=prefix+">\n"
2520     if self.has_kind_: res+=prefix+("kind: %s\n" % self.DebugFormatInt32(self.kind_))
2521     if self.has_kind_uri_: res+=prefix+("kind_uri: %s\n" % self.DebugFormatString(self.kind_uri_))
2522     cnt=0
2523     for e in self.property_:
2524       elm=""
2525       if printElemNumber: elm="(%d)" % cnt
2526       res+=prefix+("property%s <\n" % elm)
2527       res+=e.__str__(prefix + "  ", printElemNumber)
2528       res+=prefix+">\n"
2529       cnt+=1
2530     cnt=0
2531     for e in self.raw_property_:
2532       elm=""
2533       if printElemNumber: elm="(%d)" % cnt
2534       res+=prefix+("raw_property%s <\n" % elm)
2535       res+=e.__str__(prefix + "  ", printElemNumber)
2536       res+=prefix+">\n"
2537       cnt+=1
2538     return res
2539
2540
2541   def _BuildTagLookupTable(sparse, maxtag, default=None):
2542     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
2543
2544   kkey = 13
2545   kentity_group = 16
2546   kowner = 17
2547   kkind = 4
2548   kkind_uri = 5
2549   kproperty = 14
2550   kraw_property = 15
2551
2552   _TEXT = _BuildTagLookupTable({
2553     0: "ErrorCode",
2554     4: "kind",
2555     5: "kind_uri",
2556     13: "key",
2557     14: "property",
2558     15: "raw_property",
2559     16: "entity_group",
2560     17: "owner",
2561   }, 17)
2562
2563   _TYPES = _BuildTagLookupTable({
2564     0: ProtocolBuffer.Encoder.NUMERIC,
2565     4: ProtocolBuffer.Encoder.NUMERIC,
2566     5: ProtocolBuffer.Encoder.STRING,
2567     13: ProtocolBuffer.Encoder.STRING,
2568     14: ProtocolBuffer.Encoder.STRING,
2569     15: ProtocolBuffer.Encoder.STRING,
2570     16: ProtocolBuffer.Encoder.STRING,
2571     17: ProtocolBuffer.Encoder.STRING,
2572   }, 17, ProtocolBuffer.Encoder.MAX_TYPE)
2573
2574
2575   _STYLE = """"""
2576   _STYLE_CONTENT_TYPE = """"""
2577   _PROTO_DESCRIPTOR_NAME = 'storage_onestore_v3.EntityProto'
2578 class CompositeProperty(ProtocolBuffer.ProtocolMessage):
2579   has_index_id_ = 0
2580   index_id_ = 0
2581
2582   def __init__(self, contents=None):
2583     self.value_ = []
2584     if contents is not None: self.MergeFromString(contents)
2585
2586   def index_id(self): return self.index_id_
2587
2588   def set_index_id(self, x):
2589     self.has_index_id_ = 1
2590     self.index_id_ = x
2591
2592   def clear_index_id(self):
2593     if self.has_index_id_:
2594       self.has_index_id_ = 0
2595       self.index_id_ = 0
2596
2597   def has_index_id(self): return self.has_index_id_
2598
2599   def value_size(self): return len(self.value_)
2600   def value_list(self): return self.value_
2601
2602   def value(self, i):
2603     return self.value_[i]
2604
2605   def set_value(self, i, x):
2606     self.value_[i] = x
2607
2608   def add_value(self, x):
2609     self.value_.append(x)
2610
2611   def clear_value(self):
2612     self.value_ = []
2613
2614
2615   def MergeFrom(self, x):
2616     assert x is not self
2617     if (x.has_index_id()): self.set_index_id(x.index_id())
2618     for i in xrange(x.value_size()): self.add_value(x.value(i))
2619
2620   def Equals(self, x):
2621     if x is self: return 1
2622     if self.has_index_id_ != x.has_index_id_: return 0
2623     if self.has_index_id_ and self.index_id_ != x.index_id_: return 0
2624     if len(self.value_) != len(x.value_): return 0
2625     for e1, e2 in zip(self.value_, x.value_):
2626       if e1 != e2: return 0
2627     return 1
2628
2629   def IsInitialized(self, debug_strs=None):
2630     initialized = 1
2631     if (not self.has_index_id_):
2632       initialized = 0
2633       if debug_strs is not None:
2634         debug_strs.append('Required field: index_id not set.')
2635     return initialized
2636
2637   def ByteSize(self):
2638     n = 0
2639     n += self.lengthVarInt64(self.index_id_)
2640     n += 1 * len(self.value_)
2641     for i in xrange(len(self.value_)): n += self.lengthString(len(self.value_[i]))
2642     return n + 1
2643
2644   def ByteSizePartial(self):
2645     n = 0
2646     if (self.has_index_id_):
2647       n += 1
2648       n += self.lengthVarInt64(self.index_id_)
2649     n += 1 * len(self.value_)
2650     for i in xrange(len(self.value_)): n += self.lengthString(len(self.value_[i]))
2651     return n
2652
2653   def Clear(self):
2654     self.clear_index_id()
2655     self.clear_value()
2656
2657   def OutputUnchecked(self, out):
2658     out.putVarInt32(8)
2659     out.putVarInt64(self.index_id_)
2660     for i in xrange(len(self.value_)):
2661       out.putVarInt32(18)
2662       out.putPrefixedString(self.value_[i])
2663
2664   def OutputPartial(self, out):
2665     if (self.has_index_id_):
2666       out.putVarInt32(8)
2667       out.putVarInt64(self.index_id_)
2668     for i in xrange(len(self.value_)):
2669       out.putVarInt32(18)
2670       out.putPrefixedString(self.value_[i])
2671
2672   def TryMerge(self, d):
2673     while d.avail() > 0:
2674       tt = d.getVarInt32()
2675       if tt == 8:
2676         self.set_index_id(d.getVarInt64())
2677         continue
2678       if tt == 18:
2679         self.add_value(d.getPrefixedString())
2680         continue
2681
2682
2683       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
2684       d.skipData(tt)
2685
2686
2687   def __str__(self, prefix="", printElemNumber=0):
2688     res=""
2689     if self.has_index_id_: res+=prefix+("index_id: %s\n" % self.DebugFormatInt64(self.index_id_))
2690     cnt=0
2691     for e in self.value_:
2692       elm=""
2693       if printElemNumber: elm="(%d)" % cnt
2694       res+=prefix+("value%s: %s\n" % (elm, self.DebugFormatString(e)))
2695       cnt+=1
2696     return res
2697
2698
2699   def _BuildTagLookupTable(sparse, maxtag, default=None):
2700     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
2701
2702   kindex_id = 1
2703   kvalue = 2
2704
2705   _TEXT = _BuildTagLookupTable({
2706     0: "ErrorCode",
2707     1: "index_id",
2708     2: "value",
2709   }, 2)
2710
2711   _TYPES = _BuildTagLookupTable({
2712     0: ProtocolBuffer.Encoder.NUMERIC,
2713     1: ProtocolBuffer.Encoder.NUMERIC,
2714     2: ProtocolBuffer.Encoder.STRING,
2715   }, 2, ProtocolBuffer.Encoder.MAX_TYPE)
2716
2717
2718   _STYLE = """"""
2719   _STYLE_CONTENT_TYPE = """"""
2720   _PROTO_DESCRIPTOR_NAME = 'storage_onestore_v3.CompositeProperty'
2721 class Index_Property(ProtocolBuffer.ProtocolMessage):
2722
2723
2724   DIRECTION_UNSPECIFIED =    0
2725   ASCENDING    =    1
2726   DESCENDING   =    2
2727
2728   _Direction_NAMES = {
2729     0: "DIRECTION_UNSPECIFIED",
2730     1: "ASCENDING",
2731     2: "DESCENDING",
2732   }
2733
2734   def Direction_Name(cls, x): return cls._Direction_NAMES.get(x, "")
2735   Direction_Name = classmethod(Direction_Name)
2736
2737
2738
2739   MODE_UNSPECIFIED =    0
2740   SEGMENT      =    2
2741   GEOSPATIAL   =    3
2742
2743   _Mode_NAMES = {
2744     0: "MODE_UNSPECIFIED",
2745     2: "SEGMENT",
2746     3: "GEOSPATIAL",
2747   }
2748
2749   def Mode_Name(cls, x): return cls._Mode_NAMES.get(x, "")
2750   Mode_Name = classmethod(Mode_Name)
2751
2752   has_name_ = 0
2753   name_ = ""
2754   has_direction_ = 0
2755   direction_ = 0
2756   has_mode_ = 0
2757   mode_ = 0
2758
2759   def __init__(self, contents=None):
2760     if contents is not None: self.MergeFromString(contents)
2761
2762   def name(self): return self.name_
2763
2764   def set_name(self, x):
2765     self.has_name_ = 1
2766     self.name_ = x
2767
2768   def clear_name(self):
2769     if self.has_name_:
2770       self.has_name_ = 0
2771       self.name_ = ""
2772
2773   def has_name(self): return self.has_name_
2774
2775   def direction(self): return self.direction_
2776
2777   def set_direction(self, x):
2778     self.has_direction_ = 1
2779     self.direction_ = x
2780
2781   def clear_direction(self):
2782     if self.has_direction_:
2783       self.has_direction_ = 0
2784       self.direction_ = 0
2785
2786   def has_direction(self): return self.has_direction_
2787
2788   def mode(self): return self.mode_
2789
2790   def set_mode(self, x):
2791     self.has_mode_ = 1
2792     self.mode_ = x
2793
2794   def clear_mode(self):
2795     if self.has_mode_:
2796       self.has_mode_ = 0
2797       self.mode_ = 0
2798
2799   def has_mode(self): return self.has_mode_
2800
2801
2802   def MergeFrom(self, x):
2803     assert x is not self
2804     if (x.has_name()): self.set_name(x.name())
2805     if (x.has_direction()): self.set_direction(x.direction())
2806     if (x.has_mode()): self.set_mode(x.mode())
2807
2808   def Equals(self, x):
2809     if x is self: return 1
2810     if self.has_name_ != x.has_name_: return 0
2811     if self.has_name_ and self.name_ != x.name_: return 0
2812     if self.has_direction_ != x.has_direction_: return 0
2813     if self.has_direction_ and self.direction_ != x.direction_: return 0
2814     if self.has_mode_ != x.has_mode_: return 0
2815     if self.has_mode_ and self.mode_ != x.mode_: return 0
2816     return 1
2817
2818   def IsInitialized(self, debug_strs=None):
2819     initialized = 1
2820     if (not self.has_name_):
2821       initialized = 0
2822       if debug_strs is not None:
2823         debug_strs.append('Required field: name not set.')
2824     return initialized
2825
2826   def ByteSize(self):
2827     n = 0
2828     n += self.lengthString(len(self.name_))
2829     if (self.has_direction_): n += 1 + self.lengthVarInt64(self.direction_)
2830     if (self.has_mode_): n += 1 + self.lengthVarInt64(self.mode_)
2831     return n + 1
2832
2833   def ByteSizePartial(self):
2834     n = 0
2835     if (self.has_name_):
2836       n += 1
2837       n += self.lengthString(len(self.name_))
2838     if (self.has_direction_): n += 1 + self.lengthVarInt64(self.direction_)
2839     if (self.has_mode_): n += 1 + self.lengthVarInt64(self.mode_)
2840     return n
2841
2842   def Clear(self):
2843     self.clear_name()
2844     self.clear_direction()
2845     self.clear_mode()
2846
2847   def OutputUnchecked(self, out):
2848     out.putVarInt32(26)
2849     out.putPrefixedString(self.name_)
2850     if (self.has_direction_):
2851       out.putVarInt32(32)
2852       out.putVarInt32(self.direction_)
2853     if (self.has_mode_):
2854       out.putVarInt32(48)
2855       out.putVarInt32(self.mode_)
2856
2857   def OutputPartial(self, out):
2858     if (self.has_name_):
2859       out.putVarInt32(26)
2860       out.putPrefixedString(self.name_)
2861     if (self.has_direction_):
2862       out.putVarInt32(32)
2863       out.putVarInt32(self.direction_)
2864     if (self.has_mode_):
2865       out.putVarInt32(48)
2866       out.putVarInt32(self.mode_)
2867
2868   def TryMerge(self, d):
2869     while 1:
2870       tt = d.getVarInt32()
2871       if tt == 20: break
2872       if tt == 26:
2873         self.set_name(d.getPrefixedString())
2874         continue
2875       if tt == 32:
2876         self.set_direction(d.getVarInt32())
2877         continue
2878       if tt == 48:
2879         self.set_mode(d.getVarInt32())
2880         continue
2881
2882
2883       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
2884       d.skipData(tt)
2885
2886
2887   def __str__(self, prefix="", printElemNumber=0):
2888     res=""
2889     if self.has_name_: res+=prefix+("name: %s\n" % self.DebugFormatString(self.name_))
2890     if self.has_direction_: res+=prefix+("direction: %s\n" % self.DebugFormatInt32(self.direction_))
2891     if self.has_mode_: res+=prefix+("mode: %s\n" % self.DebugFormatInt32(self.mode_))
2892     return res
2893
2894 class Index(ProtocolBuffer.ProtocolMessage):
2895   has_entity_type_ = 0
2896   entity_type_ = ""
2897   has_ancestor_ = 0
2898   ancestor_ = 0
2899
2900   def __init__(self, contents=None):
2901     self.property_ = []
2902     if contents is not None: self.MergeFromString(contents)
2903
2904   def entity_type(self): return self.entity_type_
2905
2906   def set_entity_type(self, x):
2907     self.has_entity_type_ = 1
2908     self.entity_type_ = x
2909
2910   def clear_entity_type(self):
2911     if self.has_entity_type_:
2912       self.has_entity_type_ = 0
2913       self.entity_type_ = ""
2914
2915   def has_entity_type(self): return self.has_entity_type_
2916
2917   def ancestor(self): return self.ancestor_
2918
2919   def set_ancestor(self, x):
2920     self.has_ancestor_ = 1
2921     self.ancestor_ = x
2922
2923   def clear_ancestor(self):
2924     if self.has_ancestor_:
2925       self.has_ancestor_ = 0
2926       self.ancestor_ = 0
2927
2928   def has_ancestor(self): return self.has_ancestor_
2929
2930   def property_size(self): return len(self.property_)
2931   def property_list(self): return self.property_
2932
2933   def property(self, i):
2934     return self.property_[i]
2935
2936   def mutable_property(self, i):
2937     return self.property_[i]
2938
2939   def add_property(self):
2940     x = Index_Property()
2941     self.property_.append(x)
2942     return x
2943
2944   def clear_property(self):
2945     self.property_ = []
2946
2947   def MergeFrom(self, x):
2948     assert x is not self
2949     if (x.has_entity_type()): self.set_entity_type(x.entity_type())
2950     if (x.has_ancestor()): self.set_ancestor(x.ancestor())
2951     for i in xrange(x.property_size()): self.add_property().CopyFrom(x.property(i))
2952
2953   def Equals(self, x):
2954     if x is self: return 1
2955     if self.has_entity_type_ != x.has_entity_type_: return 0
2956     if self.has_entity_type_ and self.entity_type_ != x.entity_type_: return 0
2957     if self.has_ancestor_ != x.has_ancestor_: return 0
2958     if self.has_ancestor_ and self.ancestor_ != x.ancestor_: return 0
2959     if len(self.property_) != len(x.property_): return 0
2960     for e1, e2 in zip(self.property_, x.property_):
2961       if e1 != e2: return 0
2962     return 1
2963
2964   def IsInitialized(self, debug_strs=None):
2965     initialized = 1
2966     if (not self.has_entity_type_):
2967       initialized = 0
2968       if debug_strs is not None:
2969         debug_strs.append('Required field: entity_type not set.')
2970     if (not self.has_ancestor_):
2971       initialized = 0
2972       if debug_strs is not None:
2973         debug_strs.append('Required field: ancestor not set.')
2974     for p in self.property_:
2975       if not p.IsInitialized(debug_strs): initialized=0
2976     return initialized
2977
2978   def ByteSize(self):
2979     n = 0
2980     n += self.lengthString(len(self.entity_type_))
2981     n += 2 * len(self.property_)
2982     for i in xrange(len(self.property_)): n += self.property_[i].ByteSize()
2983     return n + 3
2984
2985   def ByteSizePartial(self):
2986     n = 0
2987     if (self.has_entity_type_):
2988       n += 1
2989       n += self.lengthString(len(self.entity_type_))
2990     if (self.has_ancestor_):
2991       n += 2
2992     n += 2 * len(self.property_)
2993     for i in xrange(len(self.property_)): n += self.property_[i].ByteSizePartial()
2994     return n
2995
2996   def Clear(self):
2997     self.clear_entity_type()
2998     self.clear_ancestor()
2999     self.clear_property()
3000
3001   def OutputUnchecked(self, out):
3002     out.putVarInt32(10)
3003     out.putPrefixedString(self.entity_type_)
3004     for i in xrange(len(self.property_)):
3005       out.putVarInt32(19)
3006       self.property_[i].OutputUnchecked(out)
3007       out.putVarInt32(20)
3008     out.putVarInt32(40)
3009     out.putBoolean(self.ancestor_)
3010
3011   def OutputPartial(self, out):
3012     if (self.has_entity_type_):
3013       out.putVarInt32(10)
3014       out.putPrefixedString(self.entity_type_)
3015     for i in xrange(len(self.property_)):
3016       out.putVarInt32(19)
3017       self.property_[i].OutputPartial(out)
3018       out.putVarInt32(20)
3019     if (self.has_ancestor_):
3020       out.putVarInt32(40)
3021       out.putBoolean(self.ancestor_)
3022
3023   def TryMerge(self, d):
3024     while d.avail() > 0:
3025       tt = d.getVarInt32()
3026       if tt == 10:
3027         self.set_entity_type(d.getPrefixedString())
3028         continue
3029       if tt == 19:
3030         self.add_property().TryMerge(d)
3031         continue
3032       if tt == 40:
3033         self.set_ancestor(d.getBoolean())
3034         continue
3035
3036
3037       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
3038       d.skipData(tt)
3039
3040
3041   def __str__(self, prefix="", printElemNumber=0):
3042     res=""
3043     if self.has_entity_type_: res+=prefix+("entity_type: %s\n" % self.DebugFormatString(self.entity_type_))
3044     if self.has_ancestor_: res+=prefix+("ancestor: %s\n" % self.DebugFormatBool(self.ancestor_))
3045     cnt=0
3046     for e in self.property_:
3047       elm=""
3048       if printElemNumber: elm="(%d)" % cnt
3049       res+=prefix+("Property%s {\n" % elm)
3050       res+=e.__str__(prefix + "  ", printElemNumber)
3051       res+=prefix+"}\n"
3052       cnt+=1
3053     return res
3054
3055
3056   def _BuildTagLookupTable(sparse, maxtag, default=None):
3057     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
3058
3059   kentity_type = 1
3060   kancestor = 5
3061   kPropertyGroup = 2
3062   kPropertyname = 3
3063   kPropertydirection = 4
3064   kPropertymode = 6
3065
3066   _TEXT = _BuildTagLookupTable({
3067     0: "ErrorCode",
3068     1: "entity_type",
3069     2: "Property",
3070     3: "name",
3071     4: "direction",
3072     5: "ancestor",
3073     6: "mode",
3074   }, 6)
3075
3076   _TYPES = _BuildTagLookupTable({
3077     0: ProtocolBuffer.Encoder.NUMERIC,
3078     1: ProtocolBuffer.Encoder.STRING,
3079     2: ProtocolBuffer.Encoder.STARTGROUP,
3080     3: ProtocolBuffer.Encoder.STRING,
3081     4: ProtocolBuffer.Encoder.NUMERIC,
3082     5: ProtocolBuffer.Encoder.NUMERIC,
3083     6: ProtocolBuffer.Encoder.NUMERIC,
3084   }, 6, ProtocolBuffer.Encoder.MAX_TYPE)
3085
3086
3087   _STYLE = """"""
3088   _STYLE_CONTENT_TYPE = """"""
3089   _PROTO_DESCRIPTOR_NAME = 'storage_onestore_v3.Index'
3090 class CompositeIndex(ProtocolBuffer.ProtocolMessage):
3091
3092
3093   WRITE_ONLY   =    1
3094   READ_WRITE   =    2
3095   DELETED      =    3
3096   ERROR        =    4
3097
3098   _State_NAMES = {
3099     1: "WRITE_ONLY",
3100     2: "READ_WRITE",
3101     3: "DELETED",
3102     4: "ERROR",
3103   }
3104
3105   def State_Name(cls, x): return cls._State_NAMES.get(x, "")
3106   State_Name = classmethod(State_Name)
3107
3108
3109
3110   PENDING      =    1
3111   ACTIVE       =    2
3112   COMPLETED    =    3
3113
3114   _WorkflowState_NAMES = {
3115     1: "PENDING",
3116     2: "ACTIVE",
3117     3: "COMPLETED",
3118   }
3119
3120   def WorkflowState_Name(cls, x): return cls._WorkflowState_NAMES.get(x, "")
3121   WorkflowState_Name = classmethod(WorkflowState_Name)
3122
3123   has_app_id_ = 0
3124   app_id_ = ""
3125   has_id_ = 0
3126   id_ = 0
3127   has_definition_ = 0
3128   has_state_ = 0
3129   state_ = 0
3130   has_workflow_state_ = 0
3131   workflow_state_ = 0
3132   has_error_message_ = 0
3133   error_message_ = ""
3134   has_only_use_if_required_ = 0
3135   only_use_if_required_ = 0
3136   has_disabled_index_ = 0
3137   disabled_index_ = 0
3138   has_write_division_family_ = 0
3139   write_division_family_ = ""
3140
3141   def __init__(self, contents=None):
3142     self.definition_ = Index()
3143     self.read_division_family_ = []
3144     if contents is not None: self.MergeFromString(contents)
3145
3146   def app_id(self): return self.app_id_
3147
3148   def set_app_id(self, x):
3149     self.has_app_id_ = 1
3150     self.app_id_ = x
3151
3152   def clear_app_id(self):
3153     if self.has_app_id_:
3154       self.has_app_id_ = 0
3155       self.app_id_ = ""
3156
3157   def has_app_id(self): return self.has_app_id_
3158
3159   def id(self): return self.id_
3160
3161   def set_id(self, x):
3162     self.has_id_ = 1
3163     self.id_ = x
3164
3165   def clear_id(self):
3166     if self.has_id_:
3167       self.has_id_ = 0
3168       self.id_ = 0
3169
3170   def has_id(self): return self.has_id_
3171
3172   def definition(self): return self.definition_
3173
3174   def mutable_definition(self): self.has_definition_ = 1; return self.definition_
3175
3176   def clear_definition(self):self.has_definition_ = 0; self.definition_.Clear()
3177
3178   def has_definition(self): return self.has_definition_
3179
3180   def state(self): return self.state_
3181
3182   def set_state(self, x):
3183     self.has_state_ = 1
3184     self.state_ = x
3185
3186   def clear_state(self):
3187     if self.has_state_:
3188       self.has_state_ = 0
3189       self.state_ = 0
3190
3191   def has_state(self): return self.has_state_
3192
3193   def workflow_state(self): return self.workflow_state_
3194
3195   def set_workflow_state(self, x):
3196     self.has_workflow_state_ = 1
3197     self.workflow_state_ = x
3198
3199   def clear_workflow_state(self):
3200     if self.has_workflow_state_:
3201       self.has_workflow_state_ = 0
3202       self.workflow_state_ = 0
3203
3204   def has_workflow_state(self): return self.has_workflow_state_
3205
3206   def error_message(self): return self.error_message_
3207
3208   def set_error_message(self, x):
3209     self.has_error_message_ = 1
3210     self.error_message_ = x
3211
3212   def clear_error_message(self):
3213     if self.has_error_message_:
3214       self.has_error_message_ = 0
3215       self.error_message_ = ""
3216
3217   def has_error_message(self): return self.has_error_message_
3218
3219   def only_use_if_required(self): return self.only_use_if_required_
3220
3221   def set_only_use_if_required(self, x):
3222     self.has_only_use_if_required_ = 1
3223     self.only_use_if_required_ = x
3224
3225   def clear_only_use_if_required(self):
3226     if self.has_only_use_if_required_:
3227       self.has_only_use_if_required_ = 0
3228       self.only_use_if_required_ = 0
3229
3230   def has_only_use_if_required(self): return self.has_only_use_if_required_
3231
3232   def disabled_index(self): return self.disabled_index_
3233
3234   def set_disabled_index(self, x):
3235     self.has_disabled_index_ = 1
3236     self.disabled_index_ = x
3237
3238   def clear_disabled_index(self):
3239     if self.has_disabled_index_:
3240       self.has_disabled_index_ = 0
3241       self.disabled_index_ = 0
3242
3243   def has_disabled_index(self): return self.has_disabled_index_
3244
3245   def read_division_family_size(self): return len(self.read_division_family_)
3246   def read_division_family_list(self): return self.read_division_family_
3247
3248   def read_division_family(self, i):
3249     return self.read_division_family_[i]
3250
3251   def set_read_division_family(self, i, x):
3252     self.read_division_family_[i] = x
3253
3254   def add_read_division_family(self, x):
3255     self.read_division_family_.append(x)
3256
3257   def clear_read_division_family(self):
3258     self.read_division_family_ = []
3259
3260   def write_division_family(self): return self.write_division_family_
3261
3262   def set_write_division_family(self, x):
3263     self.has_write_division_family_ = 1
3264     self.write_division_family_ = x
3265
3266   def clear_write_division_family(self):
3267     if self.has_write_division_family_:
3268       self.has_write_division_family_ = 0
3269       self.write_division_family_ = ""
3270
3271   def has_write_division_family(self): return self.has_write_division_family_
3272
3273
3274   def MergeFrom(self, x):
3275     assert x is not self
3276     if (x.has_app_id()): self.set_app_id(x.app_id())
3277     if (x.has_id()): self.set_id(x.id())
3278     if (x.has_definition()): self.mutable_definition().MergeFrom(x.definition())
3279     if (x.has_state()): self.set_state(x.state())
3280     if (x.has_workflow_state()): self.set_workflow_state(x.workflow_state())
3281     if (x.has_error_message()): self.set_error_message(x.error_message())
3282     if (x.has_only_use_if_required()): self.set_only_use_if_required(x.only_use_if_required())
3283     if (x.has_disabled_index()): self.set_disabled_index(x.disabled_index())
3284     for i in xrange(x.read_division_family_size()): self.add_read_division_family(x.read_division_family(i))
3285     if (x.has_write_division_family()): self.set_write_division_family(x.write_division_family())
3286
3287   def Equals(self, x):
3288     if x is self: return 1
3289     if self.has_app_id_ != x.has_app_id_: return 0
3290     if self.has_app_id_ and self.app_id_ != x.app_id_: return 0
3291     if self.has_id_ != x.has_id_: return 0
3292     if self.has_id_ and self.id_ != x.id_: return 0
3293     if self.has_definition_ != x.has_definition_: return 0
3294     if self.has_definition_ and self.definition_ != x.definition_: return 0
3295     if self.has_state_ != x.has_state_: return 0
3296     if self.has_state_ and self.state_ != x.state_: return 0
3297     if self.has_workflow_state_ != x.has_workflow_state_: return 0
3298     if self.has_workflow_state_ and self.workflow_state_ != x.workflow_state_: return 0
3299     if self.has_error_message_ != x.has_error_message_: return 0
3300     if self.has_error_message_ and self.error_message_ != x.error_message_: return 0
3301     if self.has_only_use_if_required_ != x.has_only_use_if_required_: return 0
3302     if self.has_only_use_if_required_ and self.only_use_if_required_ != x.only_use_if_required_: return 0
3303     if self.has_disabled_index_ != x.has_disabled_index_: return 0
3304     if self.has_disabled_index_ and self.disabled_index_ != x.disabled_index_: return 0
3305     if len(self.read_division_family_) != len(x.read_division_family_): return 0
3306     for e1, e2 in zip(self.read_division_family_, x.read_division_family_):
3307       if e1 != e2: return 0
3308     if self.has_write_division_family_ != x.has_write_division_family_: return 0
3309     if self.has_write_division_family_ and self.write_division_family_ != x.write_division_family_: return 0
3310     return 1
3311
3312   def IsInitialized(self, debug_strs=None):
3313     initialized = 1
3314     if (not self.has_app_id_):
3315       initialized = 0
3316       if debug_strs is not None:
3317         debug_strs.append('Required field: app_id not set.')
3318     if (not self.has_id_):
3319       initialized = 0
3320       if debug_strs is not None:
3321         debug_strs.append('Required field: id not set.')
3322     if (not self.has_definition_):
3323       initialized = 0
3324       if debug_strs is not None:
3325         debug_strs.append('Required field: definition not set.')
3326     elif not self.definition_.IsInitialized(debug_strs): initialized = 0
3327     if (not self.has_state_):
3328       initialized = 0
3329       if debug_strs is not None:
3330         debug_strs.append('Required field: state not set.')
3331     return initialized
3332
3333   def ByteSize(self):
3334     n = 0
3335     n += self.lengthString(len(self.app_id_))
3336     n += self.lengthVarInt64(self.id_)
3337     n += self.lengthString(self.definition_.ByteSize())
3338     n += self.lengthVarInt64(self.state_)
3339     if (self.has_workflow_state_): n += 1 + self.lengthVarInt64(self.workflow_state_)
3340     if (self.has_error_message_): n += 1 + self.lengthString(len(self.error_message_))
3341     if (self.has_only_use_if_required_): n += 2
3342     if (self.has_disabled_index_): n += 2
3343     n += 1 * len(self.read_division_family_)
3344     for i in xrange(len(self.read_division_family_)): n += self.lengthString(len(self.read_division_family_[i]))
3345     if (self.has_write_division_family_): n += 1 + self.lengthString(len(self.write_division_family_))
3346     return n + 4
3347
3348   def ByteSizePartial(self):
3349     n = 0
3350     if (self.has_app_id_):
3351       n += 1
3352       n += self.lengthString(len(self.app_id_))
3353     if (self.has_id_):
3354       n += 1
3355       n += self.lengthVarInt64(self.id_)
3356     if (self.has_definition_):
3357       n += 1
3358       n += self.lengthString(self.definition_.ByteSizePartial())
3359     if (self.has_state_):
3360       n += 1
3361       n += self.lengthVarInt64(self.state_)
3362     if (self.has_workflow_state_): n += 1 + self.lengthVarInt64(self.workflow_state_)
3363     if (self.has_error_message_): n += 1 + self.lengthString(len(self.error_message_))
3364     if (self.has_only_use_if_required_): n += 2
3365     if (self.has_disabled_index_): n += 2
3366     n += 1 * len(self.read_division_family_)
3367     for i in xrange(len(self.read_division_family_)): n += self.lengthString(len(self.read_division_family_[i]))
3368     if (self.has_write_division_family_): n += 1 + self.lengthString(len(self.write_division_family_))
3369     return n
3370
3371   def Clear(self):
3372     self.clear_app_id()
3373     self.clear_id()
3374     self.clear_definition()
3375     self.clear_state()
3376     self.clear_workflow_state()
3377     self.clear_error_message()
3378     self.clear_only_use_if_required()
3379     self.clear_disabled_index()
3380     self.clear_read_division_family()
3381     self.clear_write_division_family()
3382
3383   def OutputUnchecked(self, out):
3384     out.putVarInt32(10)
3385     out.putPrefixedString(self.app_id_)
3386     out.putVarInt32(16)
3387     out.putVarInt64(self.id_)
3388     out.putVarInt32(26)
3389     out.putVarInt32(self.definition_.ByteSize())
3390     self.definition_.OutputUnchecked(out)
3391     out.putVarInt32(32)
3392     out.putVarInt32(self.state_)
3393     if (self.has_only_use_if_required_):
3394       out.putVarInt32(48)
3395       out.putBoolean(self.only_use_if_required_)
3396     for i in xrange(len(self.read_division_family_)):
3397       out.putVarInt32(58)
3398       out.putPrefixedString(self.read_division_family_[i])
3399     if (self.has_write_division_family_):
3400       out.putVarInt32(66)
3401       out.putPrefixedString(self.write_division_family_)
3402     if (self.has_disabled_index_):
3403       out.putVarInt32(72)
3404       out.putBoolean(self.disabled_index_)
3405     if (self.has_workflow_state_):
3406       out.putVarInt32(80)
3407       out.putVarInt32(self.workflow_state_)
3408     if (self.has_error_message_):
3409       out.putVarInt32(90)
3410       out.putPrefixedString(self.error_message_)
3411
3412   def OutputPartial(self, out):
3413     if (self.has_app_id_):
3414       out.putVarInt32(10)
3415       out.putPrefixedString(self.app_id_)
3416     if (self.has_id_):
3417       out.putVarInt32(16)
3418       out.putVarInt64(self.id_)
3419     if (self.has_definition_):
3420       out.putVarInt32(26)
3421       out.putVarInt32(self.definition_.ByteSizePartial())
3422       self.definition_.OutputPartial(out)
3423     if (self.has_state_):
3424       out.putVarInt32(32)
3425       out.putVarInt32(self.state_)
3426     if (self.has_only_use_if_required_):
3427       out.putVarInt32(48)
3428       out.putBoolean(self.only_use_if_required_)
3429     for i in xrange(len(self.read_division_family_)):
3430       out.putVarInt32(58)
3431       out.putPrefixedString(self.read_division_family_[i])
3432     if (self.has_write_division_family_):
3433       out.putVarInt32(66)
3434       out.putPrefixedString(self.write_division_family_)
3435     if (self.has_disabled_index_):
3436       out.putVarInt32(72)
3437       out.putBoolean(self.disabled_index_)
3438     if (self.has_workflow_state_):
3439       out.putVarInt32(80)
3440       out.putVarInt32(self.workflow_state_)
3441     if (self.has_error_message_):
3442       out.putVarInt32(90)
3443       out.putPrefixedString(self.error_message_)
3444
3445   def TryMerge(self, d):
3446     while d.avail() > 0:
3447       tt = d.getVarInt32()
3448       if tt == 10:
3449         self.set_app_id(d.getPrefixedString())
3450         continue
3451       if tt == 16:
3452         self.set_id(d.getVarInt64())
3453         continue
3454       if tt == 26:
3455         length = d.getVarInt32()
3456         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
3457         d.skip(length)
3458         self.mutable_definition().TryMerge(tmp)
3459         continue
3460       if tt == 32:
3461         self.set_state(d.getVarInt32())
3462         continue
3463       if tt == 48:
3464         self.set_only_use_if_required(d.getBoolean())
3465         continue
3466       if tt == 58:
3467         self.add_read_division_family(d.getPrefixedString())
3468         continue
3469       if tt == 66:
3470         self.set_write_division_family(d.getPrefixedString())
3471         continue
3472       if tt == 72:
3473         self.set_disabled_index(d.getBoolean())
3474         continue
3475       if tt == 80:
3476         self.set_workflow_state(d.getVarInt32())
3477         continue
3478       if tt == 90:
3479         self.set_error_message(d.getPrefixedString())
3480         continue
3481
3482
3483       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
3484       d.skipData(tt)
3485
3486
3487   def __str__(self, prefix="", printElemNumber=0):
3488     res=""
3489     if self.has_app_id_: res+=prefix+("app_id: %s\n" % self.DebugFormatString(self.app_id_))
3490     if self.has_id_: res+=prefix+("id: %s\n" % self.DebugFormatInt64(self.id_))
3491     if self.has_definition_:
3492       res+=prefix+"definition <\n"
3493       res+=self.definition_.__str__(prefix + "  ", printElemNumber)
3494       res+=prefix+">\n"
3495     if self.has_state_: res+=prefix+("state: %s\n" % self.DebugFormatInt32(self.state_))
3496     if self.has_workflow_state_: res+=prefix+("workflow_state: %s\n" % self.DebugFormatInt32(self.workflow_state_))
3497     if self.has_error_message_: res+=prefix+("error_message: %s\n" % self.DebugFormatString(self.error_message_))
3498     if self.has_only_use_if_required_: res+=prefix+("only_use_if_required: %s\n" % self.DebugFormatBool(self.only_use_if_required_))
3499     if self.has_disabled_index_: res+=prefix+("disabled_index: %s\n" % self.DebugFormatBool(self.disabled_index_))
3500     cnt=0
3501     for e in self.read_division_family_:
3502       elm=""
3503       if printElemNumber: elm="(%d)" % cnt
3504       res+=prefix+("read_division_family%s: %s\n" % (elm, self.DebugFormatString(e)))
3505       cnt+=1
3506     if self.has_write_division_family_: res+=prefix+("write_division_family: %s\n" % self.DebugFormatString(self.write_division_family_))
3507     return res
3508
3509
3510   def _BuildTagLookupTable(sparse, maxtag, default=None):
3511     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
3512
3513   kapp_id = 1
3514   kid = 2
3515   kdefinition = 3
3516   kstate = 4
3517   kworkflow_state = 10
3518   kerror_message = 11
3519   konly_use_if_required = 6
3520   kdisabled_index = 9
3521   kread_division_family = 7
3522   kwrite_division_family = 8
3523
3524   _TEXT = _BuildTagLookupTable({
3525     0: "ErrorCode",
3526     1: "app_id",
3527     2: "id",
3528     3: "definition",
3529     4: "state",
3530     6: "only_use_if_required",
3531     7: "read_division_family",
3532     8: "write_division_family",
3533     9: "disabled_index",
3534     10: "workflow_state",
3535     11: "error_message",
3536   }, 11)
3537
3538   _TYPES = _BuildTagLookupTable({
3539     0: ProtocolBuffer.Encoder.NUMERIC,
3540     1: ProtocolBuffer.Encoder.STRING,
3541     2: ProtocolBuffer.Encoder.NUMERIC,
3542     3: ProtocolBuffer.Encoder.STRING,
3543     4: ProtocolBuffer.Encoder.NUMERIC,
3544     6: ProtocolBuffer.Encoder.NUMERIC,
3545     7: ProtocolBuffer.Encoder.STRING,
3546     8: ProtocolBuffer.Encoder.STRING,
3547     9: ProtocolBuffer.Encoder.NUMERIC,
3548     10: ProtocolBuffer.Encoder.NUMERIC,
3549     11: ProtocolBuffer.Encoder.STRING,
3550   }, 11, ProtocolBuffer.Encoder.MAX_TYPE)
3551
3552
3553   _STYLE = """"""
3554   _STYLE_CONTENT_TYPE = """"""
3555   _PROTO_DESCRIPTOR_NAME = 'storage_onestore_v3.CompositeIndex'
3556 class SearchIndexEntry(ProtocolBuffer.ProtocolMessage):
3557   has_index_id_ = 0
3558   index_id_ = 0
3559   has_fingerprint_1999_ = 0
3560   fingerprint_1999_ = 0
3561   has_fingerprint_2011_ = 0
3562   fingerprint_2011_ = 0
3563
3564   def __init__(self, contents=None):
3565     self.division_family_ = []
3566     if contents is not None: self.MergeFromString(contents)
3567
3568   def index_id(self): return self.index_id_
3569
3570   def set_index_id(self, x):
3571     self.has_index_id_ = 1
3572     self.index_id_ = x
3573
3574   def clear_index_id(self):
3575     if self.has_index_id_:
3576       self.has_index_id_ = 0
3577       self.index_id_ = 0
3578
3579   def has_index_id(self): return self.has_index_id_
3580
3581   def division_family_size(self): return len(self.division_family_)
3582   def division_family_list(self): return self.division_family_
3583
3584   def division_family(self, i):
3585     return self.division_family_[i]
3586
3587   def set_division_family(self, i, x):
3588     self.division_family_[i] = x
3589
3590   def add_division_family(self, x):
3591     self.division_family_.append(x)
3592
3593   def clear_division_family(self):
3594     self.division_family_ = []
3595
3596   def fingerprint_1999(self): return self.fingerprint_1999_
3597
3598   def set_fingerprint_1999(self, x):
3599     self.has_fingerprint_1999_ = 1
3600     self.fingerprint_1999_ = x
3601
3602   def clear_fingerprint_1999(self):
3603     if self.has_fingerprint_1999_:
3604       self.has_fingerprint_1999_ = 0
3605       self.fingerprint_1999_ = 0
3606
3607   def has_fingerprint_1999(self): return self.has_fingerprint_1999_
3608
3609   def fingerprint_2011(self): return self.fingerprint_2011_
3610
3611   def set_fingerprint_2011(self, x):
3612     self.has_fingerprint_2011_ = 1
3613     self.fingerprint_2011_ = x
3614
3615   def clear_fingerprint_2011(self):
3616     if self.has_fingerprint_2011_:
3617       self.has_fingerprint_2011_ = 0
3618       self.fingerprint_2011_ = 0
3619
3620   def has_fingerprint_2011(self): return self.has_fingerprint_2011_
3621
3622
3623   def MergeFrom(self, x):
3624     assert x is not self
3625     if (x.has_index_id()): self.set_index_id(x.index_id())
3626     for i in xrange(x.division_family_size()): self.add_division_family(x.division_family(i))
3627     if (x.has_fingerprint_1999()): self.set_fingerprint_1999(x.fingerprint_1999())
3628     if (x.has_fingerprint_2011()): self.set_fingerprint_2011(x.fingerprint_2011())
3629
3630   def Equals(self, x):
3631     if x is self: return 1
3632     if self.has_index_id_ != x.has_index_id_: return 0
3633     if self.has_index_id_ and self.index_id_ != x.index_id_: return 0
3634     if len(self.division_family_) != len(x.division_family_): return 0
3635     for e1, e2 in zip(self.division_family_, x.division_family_):
3636       if e1 != e2: return 0
3637     if self.has_fingerprint_1999_ != x.has_fingerprint_1999_: return 0
3638     if self.has_fingerprint_1999_ and self.fingerprint_1999_ != x.fingerprint_1999_: return 0
3639     if self.has_fingerprint_2011_ != x.has_fingerprint_2011_: return 0
3640     if self.has_fingerprint_2011_ and self.fingerprint_2011_ != x.fingerprint_2011_: return 0
3641     return 1
3642
3643   def IsInitialized(self, debug_strs=None):
3644     initialized = 1
3645     if (not self.has_index_id_):
3646       initialized = 0
3647       if debug_strs is not None:
3648         debug_strs.append('Required field: index_id not set.')
3649     return initialized
3650
3651   def ByteSize(self):
3652     n = 0
3653     n += self.lengthVarInt64(self.index_id_)
3654     n += 1 * len(self.division_family_)
3655     for i in xrange(len(self.division_family_)): n += self.lengthString(len(self.division_family_[i]))
3656     if (self.has_fingerprint_1999_): n += 9
3657     if (self.has_fingerprint_2011_): n += 9
3658     return n + 1
3659
3660   def ByteSizePartial(self):
3661     n = 0
3662     if (self.has_index_id_):
3663       n += 1
3664       n += self.lengthVarInt64(self.index_id_)
3665     n += 1 * len(self.division_family_)
3666     for i in xrange(len(self.division_family_)): n += self.lengthString(len(self.division_family_[i]))
3667     if (self.has_fingerprint_1999_): n += 9
3668     if (self.has_fingerprint_2011_): n += 9
3669     return n
3670
3671   def Clear(self):
3672     self.clear_index_id()
3673     self.clear_division_family()
3674     self.clear_fingerprint_1999()
3675     self.clear_fingerprint_2011()
3676
3677   def OutputUnchecked(self, out):
3678     out.putVarInt32(8)
3679     out.putVarInt64(self.index_id_)
3680     for i in xrange(len(self.division_family_)):
3681       out.putVarInt32(18)
3682       out.putPrefixedString(self.division_family_[i])
3683     if (self.has_fingerprint_1999_):
3684       out.putVarInt32(25)
3685       out.put64(self.fingerprint_1999_)
3686     if (self.has_fingerprint_2011_):
3687       out.putVarInt32(33)
3688       out.put64(self.fingerprint_2011_)
3689
3690   def OutputPartial(self, out):
3691     if (self.has_index_id_):
3692       out.putVarInt32(8)
3693       out.putVarInt64(self.index_id_)
3694     for i in xrange(len(self.division_family_)):
3695       out.putVarInt32(18)
3696       out.putPrefixedString(self.division_family_[i])
3697     if (self.has_fingerprint_1999_):
3698       out.putVarInt32(25)
3699       out.put64(self.fingerprint_1999_)
3700     if (self.has_fingerprint_2011_):
3701       out.putVarInt32(33)
3702       out.put64(self.fingerprint_2011_)
3703
3704   def TryMerge(self, d):
3705     while d.avail() > 0:
3706       tt = d.getVarInt32()
3707       if tt == 8:
3708         self.set_index_id(d.getVarInt64())
3709         continue
3710       if tt == 18:
3711         self.add_division_family(d.getPrefixedString())
3712         continue
3713       if tt == 25:
3714         self.set_fingerprint_1999(d.get64())
3715         continue
3716       if tt == 33:
3717         self.set_fingerprint_2011(d.get64())
3718         continue
3719
3720
3721       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
3722       d.skipData(tt)
3723
3724
3725   def __str__(self, prefix="", printElemNumber=0):
3726     res=""
3727     if self.has_index_id_: res+=prefix+("index_id: %s\n" % self.DebugFormatInt64(self.index_id_))
3728     cnt=0
3729     for e in self.division_family_:
3730       elm=""
3731       if printElemNumber: elm="(%d)" % cnt
3732       res+=prefix+("division_family%s: %s\n" % (elm, self.DebugFormatString(e)))
3733       cnt+=1
3734     if self.has_fingerprint_1999_: res+=prefix+("fingerprint_1999: %s\n" % self.DebugFormatFixed64(self.fingerprint_1999_))
3735     if self.has_fingerprint_2011_: res+=prefix+("fingerprint_2011: %s\n" % self.DebugFormatFixed64(self.fingerprint_2011_))
3736     return res
3737
3738
3739   def _BuildTagLookupTable(sparse, maxtag, default=None):
3740     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
3741
3742   kindex_id = 1
3743   kdivision_family = 2
3744   kfingerprint_1999 = 3
3745   kfingerprint_2011 = 4
3746
3747   _TEXT = _BuildTagLookupTable({
3748     0: "ErrorCode",
3749     1: "index_id",
3750     2: "division_family",
3751     3: "fingerprint_1999",
3752     4: "fingerprint_2011",
3753   }, 4)
3754
3755   _TYPES = _BuildTagLookupTable({
3756     0: ProtocolBuffer.Encoder.NUMERIC,
3757     1: ProtocolBuffer.Encoder.NUMERIC,
3758     2: ProtocolBuffer.Encoder.STRING,
3759     3: ProtocolBuffer.Encoder.DOUBLE,
3760     4: ProtocolBuffer.Encoder.DOUBLE,
3761   }, 4, ProtocolBuffer.Encoder.MAX_TYPE)
3762
3763
3764   _STYLE = """"""
3765   _STYLE_CONTENT_TYPE = """"""
3766   _PROTO_DESCRIPTOR_NAME = 'storage_onestore_v3.SearchIndexEntry'
3767 class SearchIndexExternalId(ProtocolBuffer.ProtocolMessage):
3768   has_index_id_ = 0
3769   index_id_ = 0
3770   has_primary_key_ = 0
3771
3772   def __init__(self, contents=None):
3773     self.primary_key_ = Reference()
3774     if contents is not None: self.MergeFromString(contents)
3775
3776   def index_id(self): return self.index_id_
3777
3778   def set_index_id(self, x):
3779     self.has_index_id_ = 1
3780     self.index_id_ = x
3781
3782   def clear_index_id(self):
3783     if self.has_index_id_:
3784       self.has_index_id_ = 0
3785       self.index_id_ = 0
3786
3787   def has_index_id(self): return self.has_index_id_
3788
3789   def primary_key(self): return self.primary_key_
3790
3791   def mutable_primary_key(self): self.has_primary_key_ = 1; return self.primary_key_
3792
3793   def clear_primary_key(self):self.has_primary_key_ = 0; self.primary_key_.Clear()
3794
3795   def has_primary_key(self): return self.has_primary_key_
3796
3797
3798   def MergeFrom(self, x):
3799     assert x is not self
3800     if (x.has_index_id()): self.set_index_id(x.index_id())
3801     if (x.has_primary_key()): self.mutable_primary_key().MergeFrom(x.primary_key())
3802
3803   def Equals(self, x):
3804     if x is self: return 1
3805     if self.has_index_id_ != x.has_index_id_: return 0
3806     if self.has_index_id_ and self.index_id_ != x.index_id_: return 0
3807     if self.has_primary_key_ != x.has_primary_key_: return 0
3808     if self.has_primary_key_ and self.primary_key_ != x.primary_key_: return 0
3809     return 1
3810
3811   def IsInitialized(self, debug_strs=None):
3812     initialized = 1
3813     if (not self.has_index_id_):
3814       initialized = 0
3815       if debug_strs is not None:
3816         debug_strs.append('Required field: index_id not set.')
3817     if (not self.has_primary_key_):
3818       initialized = 0
3819       if debug_strs is not None:
3820         debug_strs.append('Required field: primary_key not set.')
3821     elif not self.primary_key_.IsInitialized(debug_strs): initialized = 0
3822     return initialized
3823
3824   def ByteSize(self):
3825     n = 0
3826     n += self.lengthVarInt64(self.index_id_)
3827     n += self.lengthString(self.primary_key_.ByteSize())
3828     return n + 2
3829
3830   def ByteSizePartial(self):
3831     n = 0
3832     if (self.has_index_id_):
3833       n += 1
3834       n += self.lengthVarInt64(self.index_id_)
3835     if (self.has_primary_key_):
3836       n += 1
3837       n += self.lengthString(self.primary_key_.ByteSizePartial())
3838     return n
3839
3840   def Clear(self):
3841     self.clear_index_id()
3842     self.clear_primary_key()
3843
3844   def OutputUnchecked(self, out):
3845     out.putVarInt32(8)
3846     out.putVarInt64(self.index_id_)
3847     out.putVarInt32(18)
3848     out.putVarInt32(self.primary_key_.ByteSize())
3849     self.primary_key_.OutputUnchecked(out)
3850
3851   def OutputPartial(self, out):
3852     if (self.has_index_id_):
3853       out.putVarInt32(8)
3854       out.putVarInt64(self.index_id_)
3855     if (self.has_primary_key_):
3856       out.putVarInt32(18)
3857       out.putVarInt32(self.primary_key_.ByteSizePartial())
3858       self.primary_key_.OutputPartial(out)
3859
3860   def TryMerge(self, d):
3861     while d.avail() > 0:
3862       tt = d.getVarInt32()
3863       if tt == 8:
3864         self.set_index_id(d.getVarInt64())
3865         continue
3866       if tt == 18:
3867         length = d.getVarInt32()
3868         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
3869         d.skip(length)
3870         self.mutable_primary_key().TryMerge(tmp)
3871         continue
3872
3873
3874       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
3875       d.skipData(tt)
3876
3877
3878   def __str__(self, prefix="", printElemNumber=0):
3879     res=""
3880     if self.has_index_id_: res+=prefix+("index_id: %s\n" % self.DebugFormatInt64(self.index_id_))
3881     if self.has_primary_key_:
3882       res+=prefix+"primary_key <\n"
3883       res+=self.primary_key_.__str__(prefix + "  ", printElemNumber)
3884       res+=prefix+">\n"
3885     return res
3886
3887
3888   def _BuildTagLookupTable(sparse, maxtag, default=None):
3889     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
3890
3891   kindex_id = 1
3892   kprimary_key = 2
3893
3894   _TEXT = _BuildTagLookupTable({
3895     0: "ErrorCode",
3896     1: "index_id",
3897     2: "primary_key",
3898   }, 2)
3899
3900   _TYPES = _BuildTagLookupTable({
3901     0: ProtocolBuffer.Encoder.NUMERIC,
3902     1: ProtocolBuffer.Encoder.NUMERIC,
3903     2: ProtocolBuffer.Encoder.STRING,
3904   }, 2, ProtocolBuffer.Encoder.MAX_TYPE)
3905
3906
3907   _STYLE = """"""
3908   _STYLE_CONTENT_TYPE = """"""
3909   _PROTO_DESCRIPTOR_NAME = 'storage_onestore_v3.SearchIndexExternalId'
3910 class IndexPostfix_IndexValue(ProtocolBuffer.ProtocolMessage):
3911   has_property_name_ = 0
3912   property_name_ = ""
3913   has_value_ = 0
3914
3915   def __init__(self, contents=None):
3916     self.value_ = PropertyValue()
3917     if contents is not None: self.MergeFromString(contents)
3918
3919   def property_name(self): return self.property_name_
3920
3921   def set_property_name(self, x):
3922     self.has_property_name_ = 1
3923     self.property_name_ = x
3924
3925   def clear_property_name(self):
3926     if self.has_property_name_:
3927       self.has_property_name_ = 0
3928       self.property_name_ = ""
3929
3930   def has_property_name(self): return self.has_property_name_
3931
3932   def value(self): return self.value_
3933
3934   def mutable_value(self): self.has_value_ = 1; return self.value_
3935
3936   def clear_value(self):self.has_value_ = 0; self.value_.Clear()
3937
3938   def has_value(self): return self.has_value_
3939
3940
3941   def MergeFrom(self, x):
3942     assert x is not self
3943     if (x.has_property_name()): self.set_property_name(x.property_name())
3944     if (x.has_value()): self.mutable_value().MergeFrom(x.value())
3945
3946   def Equals(self, x):
3947     if x is self: return 1
3948     if self.has_property_name_ != x.has_property_name_: return 0
3949     if self.has_property_name_ and self.property_name_ != x.property_name_: return 0
3950     if self.has_value_ != x.has_value_: return 0
3951     if self.has_value_ and self.value_ != x.value_: return 0
3952     return 1
3953
3954   def IsInitialized(self, debug_strs=None):
3955     initialized = 1
3956     if (not self.has_property_name_):
3957       initialized = 0
3958       if debug_strs is not None:
3959         debug_strs.append('Required field: property_name not set.')
3960     if (not self.has_value_):
3961       initialized = 0
3962       if debug_strs is not None:
3963         debug_strs.append('Required field: value not set.')
3964     elif not self.value_.IsInitialized(debug_strs): initialized = 0
3965     return initialized
3966
3967   def ByteSize(self):
3968     n = 0
3969     n += self.lengthString(len(self.property_name_))
3970     n += self.lengthString(self.value_.ByteSize())
3971     return n + 2
3972
3973   def ByteSizePartial(self):
3974     n = 0
3975     if (self.has_property_name_):
3976       n += 1
3977       n += self.lengthString(len(self.property_name_))
3978     if (self.has_value_):
3979       n += 1
3980       n += self.lengthString(self.value_.ByteSizePartial())
3981     return n
3982
3983   def Clear(self):
3984     self.clear_property_name()
3985     self.clear_value()
3986
3987   def OutputUnchecked(self, out):
3988     out.putVarInt32(10)
3989     out.putPrefixedString(self.property_name_)
3990     out.putVarInt32(18)
3991     out.putVarInt32(self.value_.ByteSize())
3992     self.value_.OutputUnchecked(out)
3993
3994   def OutputPartial(self, out):
3995     if (self.has_property_name_):
3996       out.putVarInt32(10)
3997       out.putPrefixedString(self.property_name_)
3998     if (self.has_value_):
3999       out.putVarInt32(18)
4000       out.putVarInt32(self.value_.ByteSizePartial())
4001       self.value_.OutputPartial(out)
4002
4003   def TryMerge(self, d):
4004     while d.avail() > 0:
4005       tt = d.getVarInt32()
4006       if tt == 10:
4007         self.set_property_name(d.getPrefixedString())
4008         continue
4009       if tt == 18:
4010         length = d.getVarInt32()
4011         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
4012         d.skip(length)
4013         self.mutable_value().TryMerge(tmp)
4014         continue
4015
4016
4017       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
4018       d.skipData(tt)
4019
4020
4021   def __str__(self, prefix="", printElemNumber=0):
4022     res=""
4023     if self.has_property_name_: res+=prefix+("property_name: %s\n" % self.DebugFormatString(self.property_name_))
4024     if self.has_value_:
4025       res+=prefix+"value <\n"
4026       res+=self.value_.__str__(prefix + "  ", printElemNumber)
4027       res+=prefix+">\n"
4028     return res
4029
4030
4031   def _BuildTagLookupTable(sparse, maxtag, default=None):
4032     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
4033
4034   kproperty_name = 1
4035   kvalue = 2
4036
4037   _TEXT = _BuildTagLookupTable({
4038     0: "ErrorCode",
4039     1: "property_name",
4040     2: "value",
4041   }, 2)
4042
4043   _TYPES = _BuildTagLookupTable({
4044     0: ProtocolBuffer.Encoder.NUMERIC,
4045     1: ProtocolBuffer.Encoder.STRING,
4046     2: ProtocolBuffer.Encoder.STRING,
4047   }, 2, ProtocolBuffer.Encoder.MAX_TYPE)
4048
4049
4050   _STYLE = """"""
4051   _STYLE_CONTENT_TYPE = """"""
4052   _PROTO_DESCRIPTOR_NAME = 'storage_onestore_v3.IndexPostfix_IndexValue'
4053 class IndexPostfix(ProtocolBuffer.ProtocolMessage):
4054   has_key_ = 0
4055   key_ = None
4056   has_before_ = 0
4057   before_ = 1
4058   has_before_ascending_ = 0
4059   before_ascending_ = 0
4060
4061   def __init__(self, contents=None):
4062     self.index_value_ = []
4063     self.lazy_init_lock_ = thread.allocate_lock()
4064     if contents is not None: self.MergeFromString(contents)
4065
4066   def index_value_size(self): return len(self.index_value_)
4067   def index_value_list(self): return self.index_value_
4068
4069   def index_value(self, i):
4070     return self.index_value_[i]
4071
4072   def mutable_index_value(self, i):
4073     return self.index_value_[i]
4074
4075   def add_index_value(self):
4076     x = IndexPostfix_IndexValue()
4077     self.index_value_.append(x)
4078     return x
4079
4080   def clear_index_value(self):
4081     self.index_value_ = []
4082   def key(self):
4083     if self.key_ is None:
4084       self.lazy_init_lock_.acquire()
4085       try:
4086         if self.key_ is None: self.key_ = Reference()
4087       finally:
4088         self.lazy_init_lock_.release()
4089     return self.key_
4090
4091   def mutable_key(self): self.has_key_ = 1; return self.key()
4092
4093   def clear_key(self):
4094
4095     if self.has_key_:
4096       self.has_key_ = 0;
4097       if self.key_ is not None: self.key_.Clear()
4098
4099   def has_key(self): return self.has_key_
4100
4101   def before(self): return self.before_
4102
4103   def set_before(self, x):
4104     self.has_before_ = 1
4105     self.before_ = x
4106
4107   def clear_before(self):
4108     if self.has_before_:
4109       self.has_before_ = 0
4110       self.before_ = 1
4111
4112   def has_before(self): return self.has_before_
4113
4114   def before_ascending(self): return self.before_ascending_
4115
4116   def set_before_ascending(self, x):
4117     self.has_before_ascending_ = 1
4118     self.before_ascending_ = x
4119
4120   def clear_before_ascending(self):
4121     if self.has_before_ascending_:
4122       self.has_before_ascending_ = 0
4123       self.before_ascending_ = 0
4124
4125   def has_before_ascending(self): return self.has_before_ascending_
4126
4127
4128   def MergeFrom(self, x):
4129     assert x is not self
4130     for i in xrange(x.index_value_size()): self.add_index_value().CopyFrom(x.index_value(i))
4131     if (x.has_key()): self.mutable_key().MergeFrom(x.key())
4132     if (x.has_before()): self.set_before(x.before())
4133     if (x.has_before_ascending()): self.set_before_ascending(x.before_ascending())
4134
4135   def Equals(self, x):
4136     if x is self: return 1
4137     if len(self.index_value_) != len(x.index_value_): return 0
4138     for e1, e2 in zip(self.index_value_, x.index_value_):
4139       if e1 != e2: return 0
4140     if self.has_key_ != x.has_key_: return 0
4141     if self.has_key_ and self.key_ != x.key_: return 0
4142     if self.has_before_ != x.has_before_: return 0
4143     if self.has_before_ and self.before_ != x.before_: return 0
4144     if self.has_before_ascending_ != x.has_before_ascending_: return 0
4145     if self.has_before_ascending_ and self.before_ascending_ != x.before_ascending_: return 0
4146     return 1
4147
4148   def IsInitialized(self, debug_strs=None):
4149     initialized = 1
4150     for p in self.index_value_:
4151       if not p.IsInitialized(debug_strs): initialized=0
4152     if (self.has_key_ and not self.key_.IsInitialized(debug_strs)): initialized = 0
4153     return initialized
4154
4155   def ByteSize(self):
4156     n = 0
4157     n += 1 * len(self.index_value_)
4158     for i in xrange(len(self.index_value_)): n += self.lengthString(self.index_value_[i].ByteSize())
4159     if (self.has_key_): n += 1 + self.lengthString(self.key_.ByteSize())
4160     if (self.has_before_): n += 2
4161     if (self.has_before_ascending_): n += 2
4162     return n
4163
4164   def ByteSizePartial(self):
4165     n = 0
4166     n += 1 * len(self.index_value_)
4167     for i in xrange(len(self.index_value_)): n += self.lengthString(self.index_value_[i].ByteSizePartial())
4168     if (self.has_key_): n += 1 + self.lengthString(self.key_.ByteSizePartial())
4169     if (self.has_before_): n += 2
4170     if (self.has_before_ascending_): n += 2
4171     return n
4172
4173   def Clear(self):
4174     self.clear_index_value()
4175     self.clear_key()
4176     self.clear_before()
4177     self.clear_before_ascending()
4178
4179   def OutputUnchecked(self, out):
4180     for i in xrange(len(self.index_value_)):
4181       out.putVarInt32(10)
4182       out.putVarInt32(self.index_value_[i].ByteSize())
4183       self.index_value_[i].OutputUnchecked(out)
4184     if (self.has_key_):
4185       out.putVarInt32(18)
4186       out.putVarInt32(self.key_.ByteSize())
4187       self.key_.OutputUnchecked(out)
4188     if (self.has_before_):
4189       out.putVarInt32(24)
4190       out.putBoolean(self.before_)
4191     if (self.has_before_ascending_):
4192       out.putVarInt32(32)
4193       out.putBoolean(self.before_ascending_)
4194
4195   def OutputPartial(self, out):
4196     for i in xrange(len(self.index_value_)):
4197       out.putVarInt32(10)
4198       out.putVarInt32(self.index_value_[i].ByteSizePartial())
4199       self.index_value_[i].OutputPartial(out)
4200     if (self.has_key_):
4201       out.putVarInt32(18)
4202       out.putVarInt32(self.key_.ByteSizePartial())
4203       self.key_.OutputPartial(out)
4204     if (self.has_before_):
4205       out.putVarInt32(24)
4206       out.putBoolean(self.before_)
4207     if (self.has_before_ascending_):
4208       out.putVarInt32(32)
4209       out.putBoolean(self.before_ascending_)
4210
4211   def TryMerge(self, d):
4212     while d.avail() > 0:
4213       tt = d.getVarInt32()
4214       if tt == 10:
4215         length = d.getVarInt32()
4216         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
4217         d.skip(length)
4218         self.add_index_value().TryMerge(tmp)
4219         continue
4220       if tt == 18:
4221         length = d.getVarInt32()
4222         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
4223         d.skip(length)
4224         self.mutable_key().TryMerge(tmp)
4225         continue
4226       if tt == 24:
4227         self.set_before(d.getBoolean())
4228         continue
4229       if tt == 32:
4230         self.set_before_ascending(d.getBoolean())
4231         continue
4232
4233
4234       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
4235       d.skipData(tt)
4236
4237
4238   def __str__(self, prefix="", printElemNumber=0):
4239     res=""
4240     cnt=0
4241     for e in self.index_value_:
4242       elm=""
4243       if printElemNumber: elm="(%d)" % cnt
4244       res+=prefix+("index_value%s <\n" % elm)
4245       res+=e.__str__(prefix + "  ", printElemNumber)
4246       res+=prefix+">\n"
4247       cnt+=1
4248     if self.has_key_:
4249       res+=prefix+"key <\n"
4250       res+=self.key_.__str__(prefix + "  ", printElemNumber)
4251       res+=prefix+">\n"
4252     if self.has_before_: res+=prefix+("before: %s\n" % self.DebugFormatBool(self.before_))
4253     if self.has_before_ascending_: res+=prefix+("before_ascending: %s\n" % self.DebugFormatBool(self.before_ascending_))
4254     return res
4255
4256
4257   def _BuildTagLookupTable(sparse, maxtag, default=None):
4258     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
4259
4260   kindex_value = 1
4261   kkey = 2
4262   kbefore = 3
4263   kbefore_ascending = 4
4264
4265   _TEXT = _BuildTagLookupTable({
4266     0: "ErrorCode",
4267     1: "index_value",
4268     2: "key",
4269     3: "before",
4270     4: "before_ascending",
4271   }, 4)
4272
4273   _TYPES = _BuildTagLookupTable({
4274     0: ProtocolBuffer.Encoder.NUMERIC,
4275     1: ProtocolBuffer.Encoder.STRING,
4276     2: ProtocolBuffer.Encoder.STRING,
4277     3: ProtocolBuffer.Encoder.NUMERIC,
4278     4: ProtocolBuffer.Encoder.NUMERIC,
4279   }, 4, ProtocolBuffer.Encoder.MAX_TYPE)
4280
4281
4282   _STYLE = """"""
4283   _STYLE_CONTENT_TYPE = """"""
4284   _PROTO_DESCRIPTOR_NAME = 'storage_onestore_v3.IndexPostfix'
4285 class IndexPosition(ProtocolBuffer.ProtocolMessage):
4286   has_key_ = 0
4287   key_ = ""
4288   has_before_ = 0
4289   before_ = 1
4290   has_before_ascending_ = 0
4291   before_ascending_ = 0
4292
4293   def __init__(self, contents=None):
4294     if contents is not None: self.MergeFromString(contents)
4295
4296   def key(self): return self.key_
4297
4298   def set_key(self, x):
4299     self.has_key_ = 1
4300     self.key_ = x
4301
4302   def clear_key(self):
4303     if self.has_key_:
4304       self.has_key_ = 0
4305       self.key_ = ""
4306
4307   def has_key(self): return self.has_key_
4308
4309   def before(self): return self.before_
4310
4311   def set_before(self, x):
4312     self.has_before_ = 1
4313     self.before_ = x
4314
4315   def clear_before(self):
4316     if self.has_before_:
4317       self.has_before_ = 0
4318       self.before_ = 1
4319
4320   def has_before(self): return self.has_before_
4321
4322   def before_ascending(self): return self.before_ascending_
4323
4324   def set_before_ascending(self, x):
4325     self.has_before_ascending_ = 1
4326     self.before_ascending_ = x
4327
4328   def clear_before_ascending(self):
4329     if self.has_before_ascending_:
4330       self.has_before_ascending_ = 0
4331       self.before_ascending_ = 0
4332
4333   def has_before_ascending(self): return self.has_before_ascending_
4334
4335
4336   def MergeFrom(self, x):
4337     assert x is not self
4338     if (x.has_key()): self.set_key(x.key())
4339     if (x.has_before()): self.set_before(x.before())
4340     if (x.has_before_ascending()): self.set_before_ascending(x.before_ascending())
4341
4342   def Equals(self, x):
4343     if x is self: return 1
4344     if self.has_key_ != x.has_key_: return 0
4345     if self.has_key_ and self.key_ != x.key_: return 0
4346     if self.has_before_ != x.has_before_: return 0
4347     if self.has_before_ and self.before_ != x.before_: return 0
4348     if self.has_before_ascending_ != x.has_before_ascending_: return 0
4349     if self.has_before_ascending_ and self.before_ascending_ != x.before_ascending_: return 0
4350     return 1
4351
4352   def IsInitialized(self, debug_strs=None):
4353     initialized = 1
4354     return initialized
4355
4356   def ByteSize(self):
4357     n = 0
4358     if (self.has_key_): n += 1 + self.lengthString(len(self.key_))
4359     if (self.has_before_): n += 2
4360     if (self.has_before_ascending_): n += 2
4361     return n
4362
4363   def ByteSizePartial(self):
4364     n = 0
4365     if (self.has_key_): n += 1 + self.lengthString(len(self.key_))
4366     if (self.has_before_): n += 2
4367     if (self.has_before_ascending_): n += 2
4368     return n
4369
4370   def Clear(self):
4371     self.clear_key()
4372     self.clear_before()
4373     self.clear_before_ascending()
4374
4375   def OutputUnchecked(self, out):
4376     if (self.has_key_):
4377       out.putVarInt32(10)
4378       out.putPrefixedString(self.key_)
4379     if (self.has_before_):
4380       out.putVarInt32(16)
4381       out.putBoolean(self.before_)
4382     if (self.has_before_ascending_):
4383       out.putVarInt32(24)
4384       out.putBoolean(self.before_ascending_)
4385
4386   def OutputPartial(self, out):
4387     if (self.has_key_):
4388       out.putVarInt32(10)
4389       out.putPrefixedString(self.key_)
4390     if (self.has_before_):
4391       out.putVarInt32(16)
4392       out.putBoolean(self.before_)
4393     if (self.has_before_ascending_):
4394       out.putVarInt32(24)
4395       out.putBoolean(self.before_ascending_)
4396
4397   def TryMerge(self, d):
4398     while d.avail() > 0:
4399       tt = d.getVarInt32()
4400       if tt == 10:
4401         self.set_key(d.getPrefixedString())
4402         continue
4403       if tt == 16:
4404         self.set_before(d.getBoolean())
4405         continue
4406       if tt == 24:
4407         self.set_before_ascending(d.getBoolean())
4408         continue
4409
4410
4411       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
4412       d.skipData(tt)
4413
4414
4415   def __str__(self, prefix="", printElemNumber=0):
4416     res=""
4417     if self.has_key_: res+=prefix+("key: %s\n" % self.DebugFormatString(self.key_))
4418     if self.has_before_: res+=prefix+("before: %s\n" % self.DebugFormatBool(self.before_))
4419     if self.has_before_ascending_: res+=prefix+("before_ascending: %s\n" % self.DebugFormatBool(self.before_ascending_))
4420     return res
4421
4422
4423   def _BuildTagLookupTable(sparse, maxtag, default=None):
4424     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
4425
4426   kkey = 1
4427   kbefore = 2
4428   kbefore_ascending = 3
4429
4430   _TEXT = _BuildTagLookupTable({
4431     0: "ErrorCode",
4432     1: "key",
4433     2: "before",
4434     3: "before_ascending",
4435   }, 3)
4436
4437   _TYPES = _BuildTagLookupTable({
4438     0: ProtocolBuffer.Encoder.NUMERIC,
4439     1: ProtocolBuffer.Encoder.STRING,
4440     2: ProtocolBuffer.Encoder.NUMERIC,
4441     3: ProtocolBuffer.Encoder.NUMERIC,
4442   }, 3, ProtocolBuffer.Encoder.MAX_TYPE)
4443
4444
4445   _STYLE = """"""
4446   _STYLE_CONTENT_TYPE = """"""
4447   _PROTO_DESCRIPTOR_NAME = 'storage_onestore_v3.IndexPosition'
4448 if _extension_runtime:
4449   pass
4450
4451 __all__ = ['PropertyValue','PropertyValue_ReferenceValuePathElement','PropertyValue_PointValue','PropertyValue_UserValue','PropertyValue_ReferenceValue','Property','Path','Path_Element','Reference','User','EntityProto','CompositeProperty','Index','Index_Property','CompositeIndex','SearchIndexEntry','SearchIndexExternalId','IndexPostfix_IndexValue','IndexPostfix','IndexPosition']