thirdparty/google_appengine/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 from google.net.proto import ProtocolBuffer
  19 import array
  20 import dummy_thread as thread
  21
  22 __pychecker__ = """maxreturns=0 maxbranches=0 no-callinit
  23                    unusednames=printElemNumber,debug_strs no-special"""
  24
  25 class PropertyValue_ReferenceValuePathElement(ProtocolBuffer.ProtocolMessage):
  26   has_type_ = 0
  27   type_ = ""
  28   has_id_ = 0
  29   id_ = 0
  30   has_name_ = 0
  31   name_ = ""
  32
  33   def __init__(self, contents=None):
  34     if contents is not None: self.MergeFromString(contents)
  35
  36   def type(self): return self.type_
  37
  38   def set_type(self, x):
  39     self.has_type_ = 1
  40     self.type_ = x
  41
  42   def clear_type(self):
  43     if self.has_type_:
  44       self.has_type_ = 0
  45       self.type_ = ""
  46
  47   def has_type(self): return self.has_type_
  48
  49   def id(self): return self.id_
  50
  51   def set_id(self, x):
  52     self.has_id_ = 1
  53     self.id_ = x
  54
  55   def clear_id(self):
  56     if self.has_id_:
  57       self.has_id_ = 0
  58       self.id_ = 0
  59
  60   def has_id(self): return self.has_id_
  61
  62   def name(self): return self.name_
  63
  64   def set_name(self, x):
  65     self.has_name_ = 1
  66     self.name_ = x
  67
  68   def clear_name(self):
  69     if self.has_name_:
  70       self.has_name_ = 0
  71       self.name_ = ""
  72
  73   def has_name(self): return self.has_name_
  74
  75
  76   def MergeFrom(self, x):
  77     assert x is not self
  78     if (x.has_type()): self.set_type(x.type())
  79     if (x.has_id()): self.set_id(x.id())
  80     if (x.has_name()): self.set_name(x.name())
  81
  82   def Equals(self, x):
  83     if x is self: return 1
  84     if self.has_type_ != x.has_type_: return 0
  85     if self.has_type_ and self.type_ != x.type_: return 0
  86     if self.has_id_ != x.has_id_: return 0
  87     if self.has_id_ and self.id_ != x.id_: return 0
  88     if self.has_name_ != x.has_name_: return 0
  89     if self.has_name_ and self.name_ != x.name_: return 0
  90     return 1
  91
  92   def IsInitialized(self, debug_strs=None):
  93     initialized = 1
  94     if (not self.has_type_):
  95       initialized = 0
  96       if debug_strs is not None:
  97         debug_strs.append('Required field: type not set.')
  98     return initialized
  99
 100   def ByteSize(self):
 101     n = 0
 102     n += self.lengthString(len(self.type_))
 103     if (self.has_id_): n += 2 + self.lengthVarInt64(self.id_)
 104     if (self.has_name_): n += 2 + self.lengthString(len(self.name_))
 105     return n + 1
 106
 107   def Clear(self):
 108     self.clear_type()
 109     self.clear_id()
 110     self.clear_name()
 111
 112   def OutputUnchecked(self, out):
 113     out.putVarInt32(122)
 114     out.putPrefixedString(self.type_)
 115     if (self.has_id_):
 116       out.putVarInt32(128)
 117       out.putVarInt64(self.id_)
 118     if (self.has_name_):
 119       out.putVarInt32(138)
 120       out.putPrefixedString(self.name_)
 121
 122   def TryMerge(self, d):
 123     while 1:
 124       tt = d.getVarInt32()
 125       if tt == 116: break
 126       if tt == 122:
 127         self.set_type(d.getPrefixedString())
 128         continue
 129       if tt == 128:
 130         self.set_id(d.getVarInt64())
 131         continue
 132       if tt == 138:
 133         self.set_name(d.getPrefixedString())
 134         continue
 135       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 136       d.skipData(tt)
 137
 138
 139   def __str__(self, prefix="", printElemNumber=0):
 140     res=""
 141     if self.has_type_: res+=prefix+("type: %s\n" % self.DebugFormatString(self.type_))
 142     if self.has_id_: res+=prefix+("id: %s\n" % self.DebugFormatInt64(self.id_))
 143     if self.has_name_: res+=prefix+("name: %s\n" % self.DebugFormatString(self.name_))
 144     return res
 145
 146 class PropertyValue_PointValue(ProtocolBuffer.ProtocolMessage):
 147   has_x_ = 0
 148   x_ = 0.0
 149   has_y_ = 0
 150   y_ = 0.0
 151
 152   def __init__(self, contents=None):
 153     if contents is not None: self.MergeFromString(contents)
 154
 155   def x(self): return self.x_
 156
 157   def set_x(self, x):
 158     self.has_x_ = 1
 159     self.x_ = x
 160
 161   def clear_x(self):
 162     if self.has_x_:
 163       self.has_x_ = 0
 164       self.x_ = 0.0
 165
 166   def has_x(self): return self.has_x_
 167
 168   def y(self): return self.y_
 169
 170   def set_y(self, x):
 171     self.has_y_ = 1
 172     self.y_ = x
 173
 174   def clear_y(self):
 175     if self.has_y_:
 176       self.has_y_ = 0
 177       self.y_ = 0.0
 178
 179   def has_y(self): return self.has_y_
 180
 181
 182   def MergeFrom(self, x):
 183     assert x is not self
 184     if (x.has_x()): self.set_x(x.x())
 185     if (x.has_y()): self.set_y(x.y())
 186
 187   def Equals(self, x):
 188     if x is self: return 1
 189     if self.has_x_ != x.has_x_: return 0
 190     if self.has_x_ and self.x_ != x.x_: return 0
 191     if self.has_y_ != x.has_y_: return 0
 192     if self.has_y_ and self.y_ != x.y_: return 0
 193     return 1
 194
 195   def IsInitialized(self, debug_strs=None):
 196     initialized = 1
 197     if (not self.has_x_):
 198       initialized = 0
 199       if debug_strs is not None:
 200         debug_strs.append('Required field: x not set.')
 201     if (not self.has_y_):
 202       initialized = 0
 203       if debug_strs is not None:
 204         debug_strs.append('Required field: y not set.')
 205     return initialized
 206
 207   def ByteSize(self):
 208     n = 0
 209     return n + 18
 210
 211   def Clear(self):
 212     self.clear_x()
 213     self.clear_y()
 214
 215   def OutputUnchecked(self, out):
 216     out.putVarInt32(49)
 217     out.putDouble(self.x_)
 218     out.putVarInt32(57)
 219     out.putDouble(self.y_)
 220
 221   def TryMerge(self, d):
 222     while 1:
 223       tt = d.getVarInt32()
 224       if tt == 44: break
 225       if tt == 49:
 226         self.set_x(d.getDouble())
 227         continue
 228       if tt == 57:
 229         self.set_y(d.getDouble())
 230         continue
 231       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 232       d.skipData(tt)
 233
 234
 235   def __str__(self, prefix="", printElemNumber=0):
 236     res=""
 237     if self.has_x_: res+=prefix+("x: %s\n" % self.DebugFormat(self.x_))
 238     if self.has_y_: res+=prefix+("y: %s\n" % self.DebugFormat(self.y_))
 239     return res
 240
 241 class PropertyValue_UserValue(ProtocolBuffer.ProtocolMessage):
 242   has_email_ = 0
 243   email_ = ""
 244   has_auth_domain_ = 0
 245   auth_domain_ = ""
 246   has_nickname_ = 0
 247   nickname_ = ""
 248   has_gaiaid_ = 0
 249   gaiaid_ = 0
 250   has_obfuscated_gaiaid_ = 0
 251   obfuscated_gaiaid_ = ""
 252
 253   def __init__(self, contents=None):
 254     if contents is not None: self.MergeFromString(contents)
 255
 256   def email(self): return self.email_
 257
 258   def set_email(self, x):
 259     self.has_email_ = 1
 260     self.email_ = x
 261
 262   def clear_email(self):
 263     if self.has_email_:
 264       self.has_email_ = 0
 265       self.email_ = ""
 266
 267   def has_email(self): return self.has_email_
 268
 269   def auth_domain(self): return self.auth_domain_
 270
 271   def set_auth_domain(self, x):
 272     self.has_auth_domain_ = 1
 273     self.auth_domain_ = x
 274
 275   def clear_auth_domain(self):
 276     if self.has_auth_domain_:
 277       self.has_auth_domain_ = 0
 278       self.auth_domain_ = ""
 279
 280   def has_auth_domain(self): return self.has_auth_domain_
 281
 282   def nickname(self): return self.nickname_
 283
 284   def set_nickname(self, x):
 285     self.has_nickname_ = 1
 286     self.nickname_ = x
 287
 288   def clear_nickname(self):
 289     if self.has_nickname_:
 290       self.has_nickname_ = 0
 291       self.nickname_ = ""
 292
 293   def has_nickname(self): return self.has_nickname_
 294
 295   def gaiaid(self): return self.gaiaid_
 296
 297   def set_gaiaid(self, x):
 298     self.has_gaiaid_ = 1
 299     self.gaiaid_ = x
 300
 301   def clear_gaiaid(self):
 302     if self.has_gaiaid_:
 303       self.has_gaiaid_ = 0
 304       self.gaiaid_ = 0
 305
 306   def has_gaiaid(self): return self.has_gaiaid_
 307
 308   def obfuscated_gaiaid(self): return self.obfuscated_gaiaid_
 309
 310   def set_obfuscated_gaiaid(self, x):
 311     self.has_obfuscated_gaiaid_ = 1
 312     self.obfuscated_gaiaid_ = x
 313
 314   def clear_obfuscated_gaiaid(self):
 315     if self.has_obfuscated_gaiaid_:
 316       self.has_obfuscated_gaiaid_ = 0
 317       self.obfuscated_gaiaid_ = ""
 318
 319   def has_obfuscated_gaiaid(self): return self.has_obfuscated_gaiaid_
 320
 321
 322   def MergeFrom(self, x):
 323     assert x is not self
 324     if (x.has_email()): self.set_email(x.email())
 325     if (x.has_auth_domain()): self.set_auth_domain(x.auth_domain())
 326     if (x.has_nickname()): self.set_nickname(x.nickname())
 327     if (x.has_gaiaid()): self.set_gaiaid(x.gaiaid())
 328     if (x.has_obfuscated_gaiaid()): self.set_obfuscated_gaiaid(x.obfuscated_gaiaid())
 329
 330   def Equals(self, x):
 331     if x is self: return 1
 332     if self.has_email_ != x.has_email_: return 0
 333     if self.has_email_ and self.email_ != x.email_: return 0
 334     if self.has_auth_domain_ != x.has_auth_domain_: return 0
 335     if self.has_auth_domain_ and self.auth_domain_ != x.auth_domain_: return 0
 336     if self.has_nickname_ != x.has_nickname_: return 0
 337     if self.has_nickname_ and self.nickname_ != x.nickname_: return 0
 338     if self.has_gaiaid_ != x.has_gaiaid_: return 0
 339     if self.has_gaiaid_ and self.gaiaid_ != x.gaiaid_: return 0
 340     if self.has_obfuscated_gaiaid_ != x.has_obfuscated_gaiaid_: return 0
 341     if self.has_obfuscated_gaiaid_ and self.obfuscated_gaiaid_ != x.obfuscated_gaiaid_: return 0
 342     return 1
 343
 344   def IsInitialized(self, debug_strs=None):
 345     initialized = 1
 346     if (not self.has_email_):
 347       initialized = 0
 348       if debug_strs is not None:
 349         debug_strs.append('Required field: email not set.')
 350     if (not self.has_auth_domain_):
 351       initialized = 0
 352       if debug_strs is not None:
 353         debug_strs.append('Required field: auth_domain not set.')
 354     if (not self.has_gaiaid_):
 355       initialized = 0
 356       if debug_strs is not None:
 357         debug_strs.append('Required field: gaiaid not set.')
 358     return initialized
 359
 360   def ByteSize(self):
 361     n = 0
 362     n += self.lengthString(len(self.email_))
 363     n += self.lengthString(len(self.auth_domain_))
 364     if (self.has_nickname_): n += 1 + self.lengthString(len(self.nickname_))
 365     n += self.lengthVarInt64(self.gaiaid_)
 366     if (self.has_obfuscated_gaiaid_): n += 2 + self.lengthString(len(self.obfuscated_gaiaid_))
 367     return n + 4
 368
 369   def Clear(self):
 370     self.clear_email()
 371     self.clear_auth_domain()
 372     self.clear_nickname()
 373     self.clear_gaiaid()
 374     self.clear_obfuscated_gaiaid()
 375
 376   def OutputUnchecked(self, out):
 377     out.putVarInt32(74)
 378     out.putPrefixedString(self.email_)
 379     out.putVarInt32(82)
 380     out.putPrefixedString(self.auth_domain_)
 381     if (self.has_nickname_):
 382       out.putVarInt32(90)
 383       out.putPrefixedString(self.nickname_)
 384     out.putVarInt32(144)
 385     out.putVarInt64(self.gaiaid_)
 386     if (self.has_obfuscated_gaiaid_):
 387       out.putVarInt32(154)
 388       out.putPrefixedString(self.obfuscated_gaiaid_)
 389
 390   def TryMerge(self, d):
 391     while 1:
 392       tt = d.getVarInt32()
 393       if tt == 68: break
 394       if tt == 74:
 395         self.set_email(d.getPrefixedString())
 396         continue
 397       if tt == 82:
 398         self.set_auth_domain(d.getPrefixedString())
 399         continue
 400       if tt == 90:
 401         self.set_nickname(d.getPrefixedString())
 402         continue
 403       if tt == 144:
 404         self.set_gaiaid(d.getVarInt64())
 405         continue
 406       if tt == 154:
 407         self.set_obfuscated_gaiaid(d.getPrefixedString())
 408         continue
 409       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 410       d.skipData(tt)
 411
 412
 413   def __str__(self, prefix="", printElemNumber=0):
 414     res=""
 415     if self.has_email_: res+=prefix+("email: %s\n" % self.DebugFormatString(self.email_))
 416     if self.has_auth_domain_: res+=prefix+("auth_domain: %s\n" % self.DebugFormatString(self.auth_domain_))
 417     if self.has_nickname_: res+=prefix+("nickname: %s\n" % self.DebugFormatString(self.nickname_))
 418     if self.has_gaiaid_: res+=prefix+("gaiaid: %s\n" % self.DebugFormatInt64(self.gaiaid_))
 419     if self.has_obfuscated_gaiaid_: res+=prefix+("obfuscated_gaiaid: %s\n" % self.DebugFormatString(self.obfuscated_gaiaid_))
 420     return res
 421
 422 class PropertyValue_ReferenceValue(ProtocolBuffer.ProtocolMessage):
 423   has_app_ = 0
 424   app_ = ""
 425
 426   def __init__(self, contents=None):
 427     self.pathelement_ = []
 428     if contents is not None: self.MergeFromString(contents)
 429
 430   def app(self): return self.app_
 431
 432   def set_app(self, x):
 433     self.has_app_ = 1
 434     self.app_ = x
 435
 436   def clear_app(self):
 437     if self.has_app_:
 438       self.has_app_ = 0
 439       self.app_ = ""
 440
 441   def has_app(self): return self.has_app_
 442
 443   def pathelement_size(self): return len(self.pathelement_)
 444   def pathelement_list(self): return self.pathelement_
 445
 446   def pathelement(self, i):
 447     return self.pathelement_[i]
 448
 449   def mutable_pathelement(self, i):
 450     return self.pathelement_[i]
 451
 452   def add_pathelement(self):
 453     x = PropertyValue_ReferenceValuePathElement()
 454     self.pathelement_.append(x)
 455     return x
 456
 457   def clear_pathelement(self):
 458     self.pathelement_ = []
 459
 460   def MergeFrom(self, x):
 461     assert x is not self
 462     if (x.has_app()): self.set_app(x.app())
 463     for i in xrange(x.pathelement_size()): self.add_pathelement().CopyFrom(x.pathelement(i))
 464
 465   def Equals(self, x):
 466     if x is self: return 1
 467     if self.has_app_ != x.has_app_: return 0
 468     if self.has_app_ and self.app_ != x.app_: return 0
 469     if len(self.pathelement_) != len(x.pathelement_): return 0
 470     for e1, e2 in zip(self.pathelement_, x.pathelement_):
 471       if e1 != e2: return 0
 472     return 1
 473
 474   def IsInitialized(self, debug_strs=None):
 475     initialized = 1
 476     if (not self.has_app_):
 477       initialized = 0
 478       if debug_strs is not None:
 479         debug_strs.append('Required field: app not set.')
 480     for p in self.pathelement_:
 481       if not p.IsInitialized(debug_strs): initialized=0
 482     return initialized
 483
 484   def ByteSize(self):
 485     n = 0
 486     n += self.lengthString(len(self.app_))
 487     n += 2 * len(self.pathelement_)
 488     for i in xrange(len(self.pathelement_)): n += self.pathelement_[i].ByteSize()
 489     return n + 1
 490
 491   def Clear(self):
 492     self.clear_app()
 493     self.clear_pathelement()
 494
 495   def OutputUnchecked(self, out):
 496     out.putVarInt32(106)
 497     out.putPrefixedString(self.app_)
 498     for i in xrange(len(self.pathelement_)):
 499       out.putVarInt32(115)
 500       self.pathelement_[i].OutputUnchecked(out)
 501       out.putVarInt32(116)
 502
 503   def TryMerge(self, d):
 504     while 1:
 505       tt = d.getVarInt32()
 506       if tt == 100: break
 507       if tt == 106:
 508         self.set_app(d.getPrefixedString())
 509         continue
 510       if tt == 115:
 511         self.add_pathelement().TryMerge(d)
 512         continue
 513       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 514       d.skipData(tt)
 515
 516
 517   def __str__(self, prefix="", printElemNumber=0):
 518     res=""
 519     if self.has_app_: res+=prefix+("app: %s\n" % self.DebugFormatString(self.app_))
 520     cnt=0
 521     for e in self.pathelement_:
 522       elm=""
 523       if printElemNumber: elm="(%d)" % cnt
 524       res+=prefix+("PathElement%s {\n" % elm)
 525       res+=e.__str__(prefix + "  ", printElemNumber)
 526       res+=prefix+"}\n"
 527       cnt+=1
 528     return res
 529
 530 class PropertyValue(ProtocolBuffer.ProtocolMessage):
 531   has_int64value_ = 0
 532   int64value_ = 0
 533   has_booleanvalue_ = 0
 534   booleanvalue_ = 0
 535   has_stringvalue_ = 0
 536   stringvalue_ = ""
 537   has_doublevalue_ = 0
 538   doublevalue_ = 0.0
 539   has_pointvalue_ = 0
 540   pointvalue_ = None
 541   has_uservalue_ = 0
 542   uservalue_ = None
 543   has_referencevalue_ = 0
 544   referencevalue_ = None
 545
 546   def __init__(self, contents=None):
 547     self.lazy_init_lock_ = thread.allocate_lock()
 548     if contents is not None: self.MergeFromString(contents)
 549
 550   def int64value(self): return self.int64value_
 551
 552   def set_int64value(self, x):
 553     self.has_int64value_ = 1
 554     self.int64value_ = x
 555
 556   def clear_int64value(self):
 557     if self.has_int64value_:
 558       self.has_int64value_ = 0
 559       self.int64value_ = 0
 560
 561   def has_int64value(self): return self.has_int64value_
 562
 563   def booleanvalue(self): return self.booleanvalue_
 564
 565   def set_booleanvalue(self, x):
 566     self.has_booleanvalue_ = 1
 567     self.booleanvalue_ = x
 568
 569   def clear_booleanvalue(self):
 570     if self.has_booleanvalue_:
 571       self.has_booleanvalue_ = 0
 572       self.booleanvalue_ = 0
 573
 574   def has_booleanvalue(self): return self.has_booleanvalue_
 575
 576   def stringvalue(self): return self.stringvalue_
 577
 578   def set_stringvalue(self, x):
 579     self.has_stringvalue_ = 1
 580     self.stringvalue_ = x
 581
 582   def clear_stringvalue(self):
 583     if self.has_stringvalue_:
 584       self.has_stringvalue_ = 0
 585       self.stringvalue_ = ""
 586
 587   def has_stringvalue(self): return self.has_stringvalue_
 588
 589   def doublevalue(self): return self.doublevalue_
 590
 591   def set_doublevalue(self, x):
 592     self.has_doublevalue_ = 1
 593     self.doublevalue_ = x
 594
 595   def clear_doublevalue(self):
 596     if self.has_doublevalue_:
 597       self.has_doublevalue_ = 0
 598       self.doublevalue_ = 0.0
 599
 600   def has_doublevalue(self): return self.has_doublevalue_
 601
 602   def pointvalue(self):
 603     if self.pointvalue_ is None:
 604       self.lazy_init_lock_.acquire()
 605       try:
 606         if self.pointvalue_ is None: self.pointvalue_ = PropertyValue_PointValue()
 607       finally:
 608         self.lazy_init_lock_.release()
 609     return self.pointvalue_
 610
 611   def mutable_pointvalue(self): self.has_pointvalue_ = 1; return self.pointvalue()
 612
 613   def clear_pointvalue(self):
 614     if self.has_pointvalue_:
 615       self.has_pointvalue_ = 0;
 616       if self.pointvalue_ is not None: self.pointvalue_.Clear()
 617
 618   def has_pointvalue(self): return self.has_pointvalue_
 619
 620   def uservalue(self):
 621     if self.uservalue_ is None:
 622       self.lazy_init_lock_.acquire()
 623       try:
 624         if self.uservalue_ is None: self.uservalue_ = PropertyValue_UserValue()
 625       finally:
 626         self.lazy_init_lock_.release()
 627     return self.uservalue_
 628
 629   def mutable_uservalue(self): self.has_uservalue_ = 1; return self.uservalue()
 630
 631   def clear_uservalue(self):
 632     if self.has_uservalue_:
 633       self.has_uservalue_ = 0;
 634       if self.uservalue_ is not None: self.uservalue_.Clear()
 635
 636   def has_uservalue(self): return self.has_uservalue_
 637
 638   def referencevalue(self):
 639     if self.referencevalue_ is None:
 640       self.lazy_init_lock_.acquire()
 641       try:
 642         if self.referencevalue_ is None: self.referencevalue_ = PropertyValue_ReferenceValue()
 643       finally:
 644         self.lazy_init_lock_.release()
 645     return self.referencevalue_
 646
 647   def mutable_referencevalue(self): self.has_referencevalue_ = 1; return self.referencevalue()
 648
 649   def clear_referencevalue(self):
 650     if self.has_referencevalue_:
 651       self.has_referencevalue_ = 0;
 652       if self.referencevalue_ is not None: self.referencevalue_.Clear()
 653
 654   def has_referencevalue(self): return self.has_referencevalue_
 655
 656
 657   def MergeFrom(self, x):
 658     assert x is not self
 659     if (x.has_int64value()): self.set_int64value(x.int64value())
 660     if (x.has_booleanvalue()): self.set_booleanvalue(x.booleanvalue())
 661     if (x.has_stringvalue()): self.set_stringvalue(x.stringvalue())
 662     if (x.has_doublevalue()): self.set_doublevalue(x.doublevalue())
 663     if (x.has_pointvalue()): self.mutable_pointvalue().MergeFrom(x.pointvalue())
 664     if (x.has_uservalue()): self.mutable_uservalue().MergeFrom(x.uservalue())
 665     if (x.has_referencevalue()): self.mutable_referencevalue().MergeFrom(x.referencevalue())
 666
 667   def Equals(self, x):
 668     if x is self: return 1
 669     if self.has_int64value_ != x.has_int64value_: return 0
 670     if self.has_int64value_ and self.int64value_ != x.int64value_: return 0
 671     if self.has_booleanvalue_ != x.has_booleanvalue_: return 0
 672     if self.has_booleanvalue_ and self.booleanvalue_ != x.booleanvalue_: return 0
 673     if self.has_stringvalue_ != x.has_stringvalue_: return 0
 674     if self.has_stringvalue_ and self.stringvalue_ != x.stringvalue_: return 0
 675     if self.has_doublevalue_ != x.has_doublevalue_: return 0
 676     if self.has_doublevalue_ and self.doublevalue_ != x.doublevalue_: return 0
 677     if self.has_pointvalue_ != x.has_pointvalue_: return 0
 678     if self.has_pointvalue_ and self.pointvalue_ != x.pointvalue_: return 0
 679     if self.has_uservalue_ != x.has_uservalue_: return 0
 680     if self.has_uservalue_ and self.uservalue_ != x.uservalue_: return 0
 681     if self.has_referencevalue_ != x.has_referencevalue_: return 0
 682     if self.has_referencevalue_ and self.referencevalue_ != x.referencevalue_: return 0
 683     return 1
 684
 685   def IsInitialized(self, debug_strs=None):
 686     initialized = 1
 687     if (self.has_pointvalue_ and not self.pointvalue_.IsInitialized(debug_strs)): initialized = 0
 688     if (self.has_uservalue_ and not self.uservalue_.IsInitialized(debug_strs)): initialized = 0
 689     if (self.has_referencevalue_ and not self.referencevalue_.IsInitialized(debug_strs)): initialized = 0
 690     return initialized
 691
 692   def ByteSize(self):
 693     n = 0
 694     if (self.has_int64value_): n += 1 + self.lengthVarInt64(self.int64value_)
 695     if (self.has_booleanvalue_): n += 2
 696     if (self.has_stringvalue_): n += 1 + self.lengthString(len(self.stringvalue_))
 697     if (self.has_doublevalue_): n += 9
 698     if (self.has_pointvalue_): n += 2 + self.pointvalue_.ByteSize()
 699     if (self.has_uservalue_): n += 2 + self.uservalue_.ByteSize()
 700     if (self.has_referencevalue_): n += 2 + self.referencevalue_.ByteSize()
 701     return n + 0
 702
 703   def Clear(self):
 704     self.clear_int64value()
 705     self.clear_booleanvalue()
 706     self.clear_stringvalue()
 707     self.clear_doublevalue()
 708     self.clear_pointvalue()
 709     self.clear_uservalue()
 710     self.clear_referencevalue()
 711
 712   def OutputUnchecked(self, out):
 713     if (self.has_int64value_):
 714       out.putVarInt32(8)
 715       out.putVarInt64(self.int64value_)
 716     if (self.has_booleanvalue_):
 717       out.putVarInt32(16)
 718       out.putBoolean(self.booleanvalue_)
 719     if (self.has_stringvalue_):
 720       out.putVarInt32(26)
 721       out.putPrefixedString(self.stringvalue_)
 722     if (self.has_doublevalue_):
 723       out.putVarInt32(33)
 724       out.putDouble(self.doublevalue_)
 725     if (self.has_pointvalue_):
 726       out.putVarInt32(43)
 727       self.pointvalue_.OutputUnchecked(out)
 728       out.putVarInt32(44)
 729     if (self.has_uservalue_):
 730       out.putVarInt32(67)
 731       self.uservalue_.OutputUnchecked(out)
 732       out.putVarInt32(68)
 733     if (self.has_referencevalue_):
 734       out.putVarInt32(99)
 735       self.referencevalue_.OutputUnchecked(out)
 736       out.putVarInt32(100)
 737
 738   def TryMerge(self, d):
 739     while d.avail() > 0:
 740       tt = d.getVarInt32()
 741       if tt == 8:
 742         self.set_int64value(d.getVarInt64())
 743         continue
 744       if tt == 16:
 745         self.set_booleanvalue(d.getBoolean())
 746         continue
 747       if tt == 26:
 748         self.set_stringvalue(d.getPrefixedString())
 749         continue
 750       if tt == 33:
 751         self.set_doublevalue(d.getDouble())
 752         continue
 753       if tt == 43:
 754         self.mutable_pointvalue().TryMerge(d)
 755         continue
 756       if tt == 67:
 757         self.mutable_uservalue().TryMerge(d)
 758         continue
 759       if tt == 99:
 760         self.mutable_referencevalue().TryMerge(d)
 761         continue
 762       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 763       d.skipData(tt)
 764
 765
 766   def __str__(self, prefix="", printElemNumber=0):
 767     res=""
 768     if self.has_int64value_: res+=prefix+("int64Value: %s\n" % self.DebugFormatInt64(self.int64value_))
 769     if self.has_booleanvalue_: res+=prefix+("booleanValue: %s\n" % self.DebugFormatBool(self.booleanvalue_))
 770     if self.has_stringvalue_: res+=prefix+("stringValue: %s\n" % self.DebugFormatString(self.stringvalue_))
 771     if self.has_doublevalue_: res+=prefix+("doubleValue: %s\n" % self.DebugFormat(self.doublevalue_))
 772     if self.has_pointvalue_:
 773       res+=prefix+"PointValue {\n"
 774       res+=self.pointvalue_.__str__(prefix + "  ", printElemNumber)
 775       res+=prefix+"}\n"
 776     if self.has_uservalue_:
 777       res+=prefix+"UserValue {\n"
 778       res+=self.uservalue_.__str__(prefix + "  ", printElemNumber)
 779       res+=prefix+"}\n"
 780     if self.has_referencevalue_:
 781       res+=prefix+"ReferenceValue {\n"
 782       res+=self.referencevalue_.__str__(prefix + "  ", printElemNumber)
 783       res+=prefix+"}\n"
 784     return res
 785
 786   kint64Value = 1
 787   kbooleanValue = 2
 788   kstringValue = 3
 789   kdoubleValue = 4
 790   kPointValueGroup = 5
 791   kPointValuex = 6
 792   kPointValuey = 7
 793   kUserValueGroup = 8
 794   kUserValueemail = 9
 795   kUserValueauth_domain = 10
 796   kUserValuenickname = 11
 797   kUserValuegaiaid = 18
 798   kUserValueobfuscated_gaiaid = 19
 799   kReferenceValueGroup = 12
 800   kReferenceValueapp = 13
 801   kReferenceValuePathElementGroup = 14
 802   kReferenceValuePathElementtype = 15
 803   kReferenceValuePathElementid = 16
 804   kReferenceValuePathElementname = 17
 805
 806   _TEXT = (
 807    "ErrorCode",
 808    "int64Value",
 809    "booleanValue",
 810    "stringValue",
 811    "doubleValue",
 812    "PointValue",
 813    "x",
 814    "y",
 815    "UserValue",
 816    "email",
 817    "auth_domain",
 818    "nickname",
 819    "ReferenceValue",
 820    "app",
 821    "PathElement",
 822    "type",
 823    "id",
 824    "name",
 825    "gaiaid",
 826    "obfuscated_gaiaid",
 827   )
 828
 829   _TYPES = (
 830    ProtocolBuffer.Encoder.NUMERIC,
 831    ProtocolBuffer.Encoder.NUMERIC,
 832
 833    ProtocolBuffer.Encoder.NUMERIC,
 834
 835    ProtocolBuffer.Encoder.STRING,
 836
 837    ProtocolBuffer.Encoder.DOUBLE,
 838
 839    ProtocolBuffer.Encoder.STARTGROUP,
 840
 841    ProtocolBuffer.Encoder.DOUBLE,
 842
 843    ProtocolBuffer.Encoder.DOUBLE,
 844
 845    ProtocolBuffer.Encoder.STARTGROUP,
 846
 847    ProtocolBuffer.Encoder.STRING,
 848
 849    ProtocolBuffer.Encoder.STRING,
 850
 851    ProtocolBuffer.Encoder.STRING,
 852
 853    ProtocolBuffer.Encoder.STARTGROUP,
 854
 855    ProtocolBuffer.Encoder.STRING,
 856
 857    ProtocolBuffer.Encoder.STARTGROUP,
 858
 859    ProtocolBuffer.Encoder.STRING,
 860
 861    ProtocolBuffer.Encoder.NUMERIC,
 862
 863    ProtocolBuffer.Encoder.STRING,
 864
 865    ProtocolBuffer.Encoder.NUMERIC,
 866
 867    ProtocolBuffer.Encoder.STRING,
 868
 869   )
 870
 871   _STYLE = """"""
 872   _STYLE_CONTENT_TYPE = """"""
 873 class Property(ProtocolBuffer.ProtocolMessage):
 874
 875   BLOB         =   14
 876   TEXT         =   15
 877   BYTESTRING   =   16
 878   ATOM_CATEGORY =    1
 879   ATOM_LINK    =    2
 880   ATOM_TITLE   =    3
 881   ATOM_CONTENT =    4
 882   ATOM_SUMMARY =    5
 883   ATOM_AUTHOR  =    6
 884   GD_WHEN      =    7
 885   GD_EMAIL     =    8
 886   GEORSS_POINT =    9
 887   GD_IM        =   10
 888   GD_PHONENUMBER =   11
 889   GD_POSTALADDRESS =   12
 890   GD_RATING    =   13
 891
 892   _Meaning_NAMES = {
 893     14: "BLOB",
 894     15: "TEXT",
 895     16: "BYTESTRING",
 896     1: "ATOM_CATEGORY",
 897     2: "ATOM_LINK",
 898     3: "ATOM_TITLE",
 899     4: "ATOM_CONTENT",
 900     5: "ATOM_SUMMARY",
 901     6: "ATOM_AUTHOR",
 902     7: "GD_WHEN",
 903     8: "GD_EMAIL",
 904     9: "GEORSS_POINT",
 905     10: "GD_IM",
 906     11: "GD_PHONENUMBER",
 907     12: "GD_POSTALADDRESS",
 908     13: "GD_RATING",
 909   }
 910
 911   def Meaning_Name(cls, x): return cls._Meaning_NAMES.get(x, "")
 912   Meaning_Name = classmethod(Meaning_Name)
 913
 914   has_meaning_ = 0
 915   meaning_ = 0
 916   has_meaning_uri_ = 0
 917   meaning_uri_ = ""
 918   has_name_ = 0
 919   name_ = ""
 920   has_value_ = 0
 921   has_multiple_ = 0
 922   multiple_ = 0
 923
 924   def __init__(self, contents=None):
 925     self.value_ = PropertyValue()
 926     if contents is not None: self.MergeFromString(contents)
 927
 928   def meaning(self): return self.meaning_
 929
 930   def set_meaning(self, x):
 931     self.has_meaning_ = 1
 932     self.meaning_ = x
 933
 934   def clear_meaning(self):
 935     if self.has_meaning_:
 936       self.has_meaning_ = 0
 937       self.meaning_ = 0
 938
 939   def has_meaning(self): return self.has_meaning_
 940
 941   def meaning_uri(self): return self.meaning_uri_
 942
 943   def set_meaning_uri(self, x):
 944     self.has_meaning_uri_ = 1
 945     self.meaning_uri_ = x
 946
 947   def clear_meaning_uri(self):
 948     if self.has_meaning_uri_:
 949       self.has_meaning_uri_ = 0
 950       self.meaning_uri_ = ""
 951
 952   def has_meaning_uri(self): return self.has_meaning_uri_
 953
 954   def name(self): return self.name_
 955
 956   def set_name(self, x):
 957     self.has_name_ = 1
 958     self.name_ = x
 959
 960   def clear_name(self):
 961     if self.has_name_:
 962       self.has_name_ = 0
 963       self.name_ = ""
 964
 965   def has_name(self): return self.has_name_
 966
 967   def value(self): return self.value_
 968
 969   def mutable_value(self): self.has_value_ = 1; return self.value_
 970
 971   def clear_value(self):self.has_value_ = 0; self.value_.Clear()
 972
 973   def has_value(self): return self.has_value_
 974
 975   def multiple(self): return self.multiple_
 976
 977   def set_multiple(self, x):
 978     self.has_multiple_ = 1
 979     self.multiple_ = x
 980
 981   def clear_multiple(self):
 982     if self.has_multiple_:
 983       self.has_multiple_ = 0
 984       self.multiple_ = 0
 985
 986   def has_multiple(self): return self.has_multiple_
 987
 988
 989   def MergeFrom(self, x):
 990     assert x is not self
 991     if (x.has_meaning()): self.set_meaning(x.meaning())
 992     if (x.has_meaning_uri()): self.set_meaning_uri(x.meaning_uri())
 993     if (x.has_name()): self.set_name(x.name())
 994     if (x.has_value()): self.mutable_value().MergeFrom(x.value())
 995     if (x.has_multiple()): self.set_multiple(x.multiple())
 996
 997   def Equals(self, x):
 998     if x is self: return 1
 999     if self.has_meaning_ != x.has_meaning_: return 0
1000     if self.has_meaning_ and self.meaning_ != x.meaning_: return 0
1001     if self.has_meaning_uri_ != x.has_meaning_uri_: return 0
1002     if self.has_meaning_uri_ and self.meaning_uri_ != x.meaning_uri_: return 0
1003     if self.has_name_ != x.has_name_: return 0
1004     if self.has_name_ and self.name_ != x.name_: return 0
1005     if self.has_value_ != x.has_value_: return 0
1006     if self.has_value_ and self.value_ != x.value_: return 0
1007     if self.has_multiple_ != x.has_multiple_: return 0
1008     if self.has_multiple_ and self.multiple_ != x.multiple_: return 0
1009     return 1
1010
1011   def IsInitialized(self, debug_strs=None):
1012     initialized = 1
1013     if (not self.has_name_):
1014       initialized = 0
1015       if debug_strs is not None:
1016         debug_strs.append('Required field: name not set.')
1017     if (not self.has_value_):
1018       initialized = 0
1019       if debug_strs is not None:
1020         debug_strs.append('Required field: value not set.')
1021     elif not self.value_.IsInitialized(debug_strs): initialized = 0
1022     return initialized
1023
1024   def ByteSize(self):
1025     n = 0
1026     if (self.has_meaning_): n += 1 + self.lengthVarInt64(self.meaning_)
1027     if (self.has_meaning_uri_): n += 1 + self.lengthString(len(self.meaning_uri_))
1028     n += self.lengthString(len(self.name_))
1029     n += self.lengthString(self.value_.ByteSize())
1030     if (self.has_multiple_): n += 2
1031     return n + 2
1032
1033   def Clear(self):
1034     self.clear_meaning()
1035     self.clear_meaning_uri()
1036     self.clear_name()
1037     self.clear_value()
1038     self.clear_multiple()
1039
1040   def OutputUnchecked(self, out):
1041     if (self.has_meaning_):
1042       out.putVarInt32(8)
1043       out.putVarInt32(self.meaning_)
1044     if (self.has_meaning_uri_):
1045       out.putVarInt32(18)
1046       out.putPrefixedString(self.meaning_uri_)
1047     out.putVarInt32(26)
1048     out.putPrefixedString(self.name_)
1049     if (self.has_multiple_):
1050       out.putVarInt32(32)
1051       out.putBoolean(self.multiple_)
1052     out.putVarInt32(42)
1053     out.putVarInt32(self.value_.ByteSize())
1054     self.value_.OutputUnchecked(out)
1055
1056   def TryMerge(self, d):
1057     while d.avail() > 0:
1058       tt = d.getVarInt32()
1059       if tt == 8:
1060         self.set_meaning(d.getVarInt32())
1061         continue
1062       if tt == 18:
1063         self.set_meaning_uri(d.getPrefixedString())
1064         continue
1065       if tt == 26:
1066         self.set_name(d.getPrefixedString())
1067         continue
1068       if tt == 32:
1069         self.set_multiple(d.getBoolean())
1070         continue
1071       if tt == 42:
1072         length = d.getVarInt32()
1073         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
1074         d.skip(length)
1075         self.mutable_value().TryMerge(tmp)
1076         continue
1077       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1078       d.skipData(tt)
1079
1080
1081   def __str__(self, prefix="", printElemNumber=0):
1082     res=""
1083     if self.has_meaning_: res+=prefix+("meaning: %s\n" % self.DebugFormatInt32(self.meaning_))
1084     if self.has_meaning_uri_: res+=prefix+("meaning_uri: %s\n" % self.DebugFormatString(self.meaning_uri_))
1085     if self.has_name_: res+=prefix+("name: %s\n" % self.DebugFormatString(self.name_))
1086     if self.has_value_:
1087       res+=prefix+"value <\n"
1088       res+=self.value_.__str__(prefix + "  ", printElemNumber)
1089       res+=prefix+">\n"
1090     if self.has_multiple_: res+=prefix+("multiple: %s\n" % self.DebugFormatBool(self.multiple_))
1091     return res
1092
1093   kmeaning = 1
1094   kmeaning_uri = 2
1095   kname = 3
1096   kvalue = 5
1097   kmultiple = 4
1098
1099   _TEXT = (
1100    "ErrorCode",
1101    "meaning",
1102    "meaning_uri",
1103    "name",
1104    "multiple",
1105    "value",
1106   )
1107
1108   _TYPES = (
1109    ProtocolBuffer.Encoder.NUMERIC,
1110    ProtocolBuffer.Encoder.NUMERIC,
1111
1112    ProtocolBuffer.Encoder.STRING,
1113
1114    ProtocolBuffer.Encoder.STRING,
1115
1116    ProtocolBuffer.Encoder.NUMERIC,
1117
1118    ProtocolBuffer.Encoder.STRING,
1119
1120   )
1121
1122   _STYLE = """"""
1123   _STYLE_CONTENT_TYPE = """"""
1124 class Path_Element(ProtocolBuffer.ProtocolMessage):
1125   has_type_ = 0
1126   type_ = ""
1127   has_id_ = 0
1128   id_ = 0
1129   has_name_ = 0
1130   name_ = ""
1131
1132   def __init__(self, contents=None):
1133     if contents is not None: self.MergeFromString(contents)
1134
1135   def type(self): return self.type_
1136
1137   def set_type(self, x):
1138     self.has_type_ = 1
1139     self.type_ = x
1140
1141   def clear_type(self):
1142     if self.has_type_:
1143       self.has_type_ = 0
1144       self.type_ = ""
1145
1146   def has_type(self): return self.has_type_
1147
1148   def id(self): return self.id_
1149
1150   def set_id(self, x):
1151     self.has_id_ = 1
1152     self.id_ = x
1153
1154   def clear_id(self):
1155     if self.has_id_:
1156       self.has_id_ = 0
1157       self.id_ = 0
1158
1159   def has_id(self): return self.has_id_
1160
1161   def name(self): return self.name_
1162
1163   def set_name(self, x):
1164     self.has_name_ = 1
1165     self.name_ = x
1166
1167   def clear_name(self):
1168     if self.has_name_:
1169       self.has_name_ = 0
1170       self.name_ = ""
1171
1172   def has_name(self): return self.has_name_
1173
1174
1175   def MergeFrom(self, x):
1176     assert x is not self
1177     if (x.has_type()): self.set_type(x.type())
1178     if (x.has_id()): self.set_id(x.id())
1179     if (x.has_name()): self.set_name(x.name())
1180
1181   def Equals(self, x):
1182     if x is self: return 1
1183     if self.has_type_ != x.has_type_: return 0
1184     if self.has_type_ and self.type_ != x.type_: return 0
1185     if self.has_id_ != x.has_id_: return 0
1186     if self.has_id_ and self.id_ != x.id_: return 0
1187     if self.has_name_ != x.has_name_: return 0
1188     if self.has_name_ and self.name_ != x.name_: return 0
1189     return 1
1190
1191   def IsInitialized(self, debug_strs=None):
1192     initialized = 1
1193     if (not self.has_type_):
1194       initialized = 0
1195       if debug_strs is not None:
1196         debug_strs.append('Required field: type not set.')
1197     return initialized
1198
1199   def ByteSize(self):
1200     n = 0
1201     n += self.lengthString(len(self.type_))
1202     if (self.has_id_): n += 1 + self.lengthVarInt64(self.id_)
1203     if (self.has_name_): n += 1 + self.lengthString(len(self.name_))
1204     return n + 1
1205
1206   def Clear(self):
1207     self.clear_type()
1208     self.clear_id()
1209     self.clear_name()
1210
1211   def OutputUnchecked(self, out):
1212     out.putVarInt32(18)
1213     out.putPrefixedString(self.type_)
1214     if (self.has_id_):
1215       out.putVarInt32(24)
1216       out.putVarInt64(self.id_)
1217     if (self.has_name_):
1218       out.putVarInt32(34)
1219       out.putPrefixedString(self.name_)
1220
1221   def TryMerge(self, d):
1222     while 1:
1223       tt = d.getVarInt32()
1224       if tt == 12: break
1225       if tt == 18:
1226         self.set_type(d.getPrefixedString())
1227         continue
1228       if tt == 24:
1229         self.set_id(d.getVarInt64())
1230         continue
1231       if tt == 34:
1232         self.set_name(d.getPrefixedString())
1233         continue
1234       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1235       d.skipData(tt)
1236
1237
1238   def __str__(self, prefix="", printElemNumber=0):
1239     res=""
1240     if self.has_type_: res+=prefix+("type: %s\n" % self.DebugFormatString(self.type_))
1241     if self.has_id_: res+=prefix+("id: %s\n" % self.DebugFormatInt64(self.id_))
1242     if self.has_name_: res+=prefix+("name: %s\n" % self.DebugFormatString(self.name_))
1243     return res
1244
1245 class Path(ProtocolBuffer.ProtocolMessage):
1246
1247   def __init__(self, contents=None):
1248     self.element_ = []
1249     if contents is not None: self.MergeFromString(contents)
1250
1251   def element_size(self): return len(self.element_)
1252   def element_list(self): return self.element_
1253
1254   def element(self, i):
1255     return self.element_[i]
1256
1257   def mutable_element(self, i):
1258     return self.element_[i]
1259
1260   def add_element(self):
1261     x = Path_Element()
1262     self.element_.append(x)
1263     return x
1264
1265   def clear_element(self):
1266     self.element_ = []
1267
1268   def MergeFrom(self, x):
1269     assert x is not self
1270     for i in xrange(x.element_size()): self.add_element().CopyFrom(x.element(i))
1271
1272   def Equals(self, x):
1273     if x is self: return 1
1274     if len(self.element_) != len(x.element_): return 0
1275     for e1, e2 in zip(self.element_, x.element_):
1276       if e1 != e2: return 0
1277     return 1
1278
1279   def IsInitialized(self, debug_strs=None):
1280     initialized = 1
1281     for p in self.element_:
1282       if not p.IsInitialized(debug_strs): initialized=0
1283     return initialized
1284
1285   def ByteSize(self):
1286     n = 0
1287     n += 2 * len(self.element_)
1288     for i in xrange(len(self.element_)): n += self.element_[i].ByteSize()
1289     return n + 0
1290
1291   def Clear(self):
1292     self.clear_element()
1293
1294   def OutputUnchecked(self, out):
1295     for i in xrange(len(self.element_)):
1296       out.putVarInt32(11)
1297       self.element_[i].OutputUnchecked(out)
1298       out.putVarInt32(12)
1299
1300   def TryMerge(self, d):
1301     while d.avail() > 0:
1302       tt = d.getVarInt32()
1303       if tt == 11:
1304         self.add_element().TryMerge(d)
1305         continue
1306       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1307       d.skipData(tt)
1308
1309
1310   def __str__(self, prefix="", printElemNumber=0):
1311     res=""
1312     cnt=0
1313     for e in self.element_:
1314       elm=""
1315       if printElemNumber: elm="(%d)" % cnt
1316       res+=prefix+("Element%s {\n" % elm)
1317       res+=e.__str__(prefix + "  ", printElemNumber)
1318       res+=prefix+"}\n"
1319       cnt+=1
1320     return res
1321
1322   kElementGroup = 1
1323   kElementtype = 2
1324   kElementid = 3
1325   kElementname = 4
1326
1327   _TEXT = (
1328    "ErrorCode",
1329    "Element",
1330    "type",
1331    "id",
1332    "name",
1333   )
1334
1335   _TYPES = (
1336    ProtocolBuffer.Encoder.NUMERIC,
1337    ProtocolBuffer.Encoder.STARTGROUP,
1338
1339    ProtocolBuffer.Encoder.STRING,
1340
1341    ProtocolBuffer.Encoder.NUMERIC,
1342
1343    ProtocolBuffer.Encoder.STRING,
1344
1345   )
1346
1347   _STYLE = """"""
1348   _STYLE_CONTENT_TYPE = """"""
1349 class Reference(ProtocolBuffer.ProtocolMessage):
1350   has_app_ = 0
1351   app_ = ""
1352   has_path_ = 0
1353
1354   def __init__(self, contents=None):
1355     self.path_ = Path()
1356     if contents is not None: self.MergeFromString(contents)
1357
1358   def app(self): return self.app_
1359
1360   def set_app(self, x):
1361     self.has_app_ = 1
1362     self.app_ = x
1363
1364   def clear_app(self):
1365     if self.has_app_:
1366       self.has_app_ = 0
1367       self.app_ = ""
1368
1369   def has_app(self): return self.has_app_
1370
1371   def path(self): return self.path_
1372
1373   def mutable_path(self): self.has_path_ = 1; return self.path_
1374
1375   def clear_path(self):self.has_path_ = 0; self.path_.Clear()
1376
1377   def has_path(self): return self.has_path_
1378
1379
1380   def MergeFrom(self, x):
1381     assert x is not self
1382     if (x.has_app()): self.set_app(x.app())
1383     if (x.has_path()): self.mutable_path().MergeFrom(x.path())
1384
1385   def Equals(self, x):
1386     if x is self: return 1
1387     if self.has_app_ != x.has_app_: return 0
1388     if self.has_app_ and self.app_ != x.app_: return 0
1389     if self.has_path_ != x.has_path_: return 0
1390     if self.has_path_ and self.path_ != x.path_: return 0
1391     return 1
1392
1393   def IsInitialized(self, debug_strs=None):
1394     initialized = 1
1395     if (not self.has_app_):
1396       initialized = 0
1397       if debug_strs is not None:
1398         debug_strs.append('Required field: app not set.')
1399     if (not self.has_path_):
1400       initialized = 0
1401       if debug_strs is not None:
1402         debug_strs.append('Required field: path not set.')
1403     elif not self.path_.IsInitialized(debug_strs): initialized = 0
1404     return initialized
1405
1406   def ByteSize(self):
1407     n = 0
1408     n += self.lengthString(len(self.app_))
1409     n += self.lengthString(self.path_.ByteSize())
1410     return n + 2
1411
1412   def Clear(self):
1413     self.clear_app()
1414     self.clear_path()
1415
1416   def OutputUnchecked(self, out):
1417     out.putVarInt32(106)
1418     out.putPrefixedString(self.app_)
1419     out.putVarInt32(114)
1420     out.putVarInt32(self.path_.ByteSize())
1421     self.path_.OutputUnchecked(out)
1422
1423   def TryMerge(self, d):
1424     while d.avail() > 0:
1425       tt = d.getVarInt32()
1426       if tt == 106:
1427         self.set_app(d.getPrefixedString())
1428         continue
1429       if tt == 114:
1430         length = d.getVarInt32()
1431         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
1432         d.skip(length)
1433         self.mutable_path().TryMerge(tmp)
1434         continue
1435       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1436       d.skipData(tt)
1437
1438
1439   def __str__(self, prefix="", printElemNumber=0):
1440     res=""
1441     if self.has_app_: res+=prefix+("app: %s\n" % self.DebugFormatString(self.app_))
1442     if self.has_path_:
1443       res+=prefix+"path <\n"
1444       res+=self.path_.__str__(prefix + "  ", printElemNumber)
1445       res+=prefix+">\n"
1446     return res
1447
1448   kapp = 13
1449   kpath = 14
1450
1451   _TEXT = (
1452    "ErrorCode",
1453    None,
1454    None,
1455    None,
1456    None,
1457    None,
1458    None,
1459    None,
1460    None,
1461    None,
1462    None,
1463    None,
1464    None,
1465    "app",
1466    "path",
1467   )
1468
1469   _TYPES = (
1470    ProtocolBuffer.Encoder.NUMERIC,
1471    ProtocolBuffer.Encoder.MAX_TYPE,
1472
1473    ProtocolBuffer.Encoder.MAX_TYPE,
1474
1475    ProtocolBuffer.Encoder.MAX_TYPE,
1476
1477    ProtocolBuffer.Encoder.MAX_TYPE,
1478
1479    ProtocolBuffer.Encoder.MAX_TYPE,
1480
1481    ProtocolBuffer.Encoder.MAX_TYPE,
1482
1483    ProtocolBuffer.Encoder.MAX_TYPE,
1484
1485    ProtocolBuffer.Encoder.MAX_TYPE,
1486
1487    ProtocolBuffer.Encoder.MAX_TYPE,
1488
1489    ProtocolBuffer.Encoder.MAX_TYPE,
1490
1491    ProtocolBuffer.Encoder.MAX_TYPE,
1492
1493    ProtocolBuffer.Encoder.MAX_TYPE,
1494
1495    ProtocolBuffer.Encoder.STRING,
1496
1497    ProtocolBuffer.Encoder.STRING,
1498
1499   )
1500
1501   _STYLE = """"""
1502   _STYLE_CONTENT_TYPE = """"""
1503 class User(ProtocolBuffer.ProtocolMessage):
1504   has_email_ = 0
1505   email_ = ""
1506   has_auth_domain_ = 0
1507   auth_domain_ = ""
1508   has_nickname_ = 0
1509   nickname_ = ""
1510   has_gaiaid_ = 0
1511   gaiaid_ = 0
1512   has_obfuscated_gaiaid_ = 0
1513   obfuscated_gaiaid_ = ""
1514
1515   def __init__(self, contents=None):
1516     if contents is not None: self.MergeFromString(contents)
1517
1518   def email(self): return self.email_
1519
1520   def set_email(self, x):
1521     self.has_email_ = 1
1522     self.email_ = x
1523
1524   def clear_email(self):
1525     if self.has_email_:
1526       self.has_email_ = 0
1527       self.email_ = ""
1528
1529   def has_email(self): return self.has_email_
1530
1531   def auth_domain(self): return self.auth_domain_
1532
1533   def set_auth_domain(self, x):
1534     self.has_auth_domain_ = 1
1535     self.auth_domain_ = x
1536
1537   def clear_auth_domain(self):
1538     if self.has_auth_domain_:
1539       self.has_auth_domain_ = 0
1540       self.auth_domain_ = ""
1541
1542   def has_auth_domain(self): return self.has_auth_domain_
1543
1544   def nickname(self): return self.nickname_
1545
1546   def set_nickname(self, x):
1547     self.has_nickname_ = 1
1548     self.nickname_ = x
1549
1550   def clear_nickname(self):
1551     if self.has_nickname_:
1552       self.has_nickname_ = 0
1553       self.nickname_ = ""
1554
1555   def has_nickname(self): return self.has_nickname_
1556
1557   def gaiaid(self): return self.gaiaid_
1558
1559   def set_gaiaid(self, x):
1560     self.has_gaiaid_ = 1
1561     self.gaiaid_ = x
1562
1563   def clear_gaiaid(self):
1564     if self.has_gaiaid_:
1565       self.has_gaiaid_ = 0
1566       self.gaiaid_ = 0
1567
1568   def has_gaiaid(self): return self.has_gaiaid_
1569
1570   def obfuscated_gaiaid(self): return self.obfuscated_gaiaid_
1571
1572   def set_obfuscated_gaiaid(self, x):
1573     self.has_obfuscated_gaiaid_ = 1
1574     self.obfuscated_gaiaid_ = x
1575
1576   def clear_obfuscated_gaiaid(self):
1577     if self.has_obfuscated_gaiaid_:
1578       self.has_obfuscated_gaiaid_ = 0
1579       self.obfuscated_gaiaid_ = ""
1580
1581   def has_obfuscated_gaiaid(self): return self.has_obfuscated_gaiaid_
1582
1583
1584   def MergeFrom(self, x):
1585     assert x is not self
1586     if (x.has_email()): self.set_email(x.email())
1587     if (x.has_auth_domain()): self.set_auth_domain(x.auth_domain())
1588     if (x.has_nickname()): self.set_nickname(x.nickname())
1589     if (x.has_gaiaid()): self.set_gaiaid(x.gaiaid())
1590     if (x.has_obfuscated_gaiaid()): self.set_obfuscated_gaiaid(x.obfuscated_gaiaid())
1591
1592   def Equals(self, x):
1593     if x is self: return 1
1594     if self.has_email_ != x.has_email_: return 0
1595     if self.has_email_ and self.email_ != x.email_: return 0
1596     if self.has_auth_domain_ != x.has_auth_domain_: return 0
1597     if self.has_auth_domain_ and self.auth_domain_ != x.auth_domain_: return 0
1598     if self.has_nickname_ != x.has_nickname_: return 0
1599     if self.has_nickname_ and self.nickname_ != x.nickname_: return 0
1600     if self.has_gaiaid_ != x.has_gaiaid_: return 0
1601     if self.has_gaiaid_ and self.gaiaid_ != x.gaiaid_: return 0
1602     if self.has_obfuscated_gaiaid_ != x.has_obfuscated_gaiaid_: return 0
1603     if self.has_obfuscated_gaiaid_ and self.obfuscated_gaiaid_ != x.obfuscated_gaiaid_: return 0
1604     return 1
1605
1606   def IsInitialized(self, debug_strs=None):
1607     initialized = 1
1608     if (not self.has_email_):
1609       initialized = 0
1610       if debug_strs is not None:
1611         debug_strs.append('Required field: email not set.')
1612     if (not self.has_auth_domain_):
1613       initialized = 0
1614       if debug_strs is not None:
1615         debug_strs.append('Required field: auth_domain not set.')
1616     if (not self.has_gaiaid_):
1617       initialized = 0
1618       if debug_strs is not None:
1619         debug_strs.append('Required field: gaiaid not set.')
1620     return initialized
1621
1622   def ByteSize(self):
1623     n = 0
1624     n += self.lengthString(len(self.email_))
1625     n += self.lengthString(len(self.auth_domain_))
1626     if (self.has_nickname_): n += 1 + self.lengthString(len(self.nickname_))
1627     n += self.lengthVarInt64(self.gaiaid_)
1628     if (self.has_obfuscated_gaiaid_): n += 1 + self.lengthString(len(self.obfuscated_gaiaid_))
1629     return n + 3
1630
1631   def Clear(self):
1632     self.clear_email()
1633     self.clear_auth_domain()
1634     self.clear_nickname()
1635     self.clear_gaiaid()
1636     self.clear_obfuscated_gaiaid()
1637
1638   def OutputUnchecked(self, out):
1639     out.putVarInt32(10)
1640     out.putPrefixedString(self.email_)
1641     out.putVarInt32(18)
1642     out.putPrefixedString(self.auth_domain_)
1643     if (self.has_nickname_):
1644       out.putVarInt32(26)
1645       out.putPrefixedString(self.nickname_)
1646     out.putVarInt32(32)
1647     out.putVarInt64(self.gaiaid_)
1648     if (self.has_obfuscated_gaiaid_):
1649       out.putVarInt32(42)
1650       out.putPrefixedString(self.obfuscated_gaiaid_)
1651
1652   def TryMerge(self, d):
1653     while d.avail() > 0:
1654       tt = d.getVarInt32()
1655       if tt == 10:
1656         self.set_email(d.getPrefixedString())
1657         continue
1658       if tt == 18:
1659         self.set_auth_domain(d.getPrefixedString())
1660         continue
1661       if tt == 26:
1662         self.set_nickname(d.getPrefixedString())
1663         continue
1664       if tt == 32:
1665         self.set_gaiaid(d.getVarInt64())
1666         continue
1667       if tt == 42:
1668         self.set_obfuscated_gaiaid(d.getPrefixedString())
1669         continue
1670       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1671       d.skipData(tt)
1672
1673
1674   def __str__(self, prefix="", printElemNumber=0):
1675     res=""
1676     if self.has_email_: res+=prefix+("email: %s\n" % self.DebugFormatString(self.email_))
1677     if self.has_auth_domain_: res+=prefix+("auth_domain: %s\n" % self.DebugFormatString(self.auth_domain_))
1678     if self.has_nickname_: res+=prefix+("nickname: %s\n" % self.DebugFormatString(self.nickname_))
1679     if self.has_gaiaid_: res+=prefix+("gaiaid: %s\n" % self.DebugFormatInt64(self.gaiaid_))
1680     if self.has_obfuscated_gaiaid_: res+=prefix+("obfuscated_gaiaid: %s\n" % self.DebugFormatString(self.obfuscated_gaiaid_))
1681     return res
1682
1683   kemail = 1
1684   kauth_domain = 2
1685   knickname = 3
1686   kgaiaid = 4
1687   kobfuscated_gaiaid = 5
1688
1689   _TEXT = (
1690    "ErrorCode",
1691    "email",
1692    "auth_domain",
1693    "nickname",
1694    "gaiaid",
1695    "obfuscated_gaiaid",
1696   )
1697
1698   _TYPES = (
1699    ProtocolBuffer.Encoder.NUMERIC,
1700    ProtocolBuffer.Encoder.STRING,
1701
1702    ProtocolBuffer.Encoder.STRING,
1703
1704    ProtocolBuffer.Encoder.STRING,
1705
1706    ProtocolBuffer.Encoder.NUMERIC,
1707
1708    ProtocolBuffer.Encoder.STRING,
1709
1710   )
1711
1712   _STYLE = """"""
1713   _STYLE_CONTENT_TYPE = """"""
1714 class EntityProto(ProtocolBuffer.ProtocolMessage):
1715
1716   GD_CONTACT   =    1
1717   GD_EVENT     =    2
1718   GD_MESSAGE   =    3
1719
1720   _Kind_NAMES = {
1721     1: "GD_CONTACT",
1722     2: "GD_EVENT",
1723     3: "GD_MESSAGE",
1724   }
1725
1726   def Kind_Name(cls, x): return cls._Kind_NAMES.get(x, "")
1727   Kind_Name = classmethod(Kind_Name)
1728
1729   has_key_ = 0
1730   has_entity_group_ = 0
1731   has_owner_ = 0
1732   owner_ = None
1733   has_kind_ = 0
1734   kind_ = 0
1735   has_kind_uri_ = 0
1736   kind_uri_ = ""
1737
1738   def __init__(self, contents=None):
1739     self.key_ = Reference()
1740     self.entity_group_ = Path()
1741     self.property_ = []
1742     self.raw_property_ = []
1743     self.lazy_init_lock_ = thread.allocate_lock()
1744     if contents is not None: self.MergeFromString(contents)
1745
1746   def key(self): return self.key_
1747
1748   def mutable_key(self): self.has_key_ = 1; return self.key_
1749
1750   def clear_key(self):self.has_key_ = 0; self.key_.Clear()
1751
1752   def has_key(self): return self.has_key_
1753
1754   def entity_group(self): return self.entity_group_
1755
1756   def mutable_entity_group(self): self.has_entity_group_ = 1; return self.entity_group_
1757
1758   def clear_entity_group(self):self.has_entity_group_ = 0; self.entity_group_.Clear()
1759
1760   def has_entity_group(self): return self.has_entity_group_
1761
1762   def owner(self):
1763     if self.owner_ is None:
1764       self.lazy_init_lock_.acquire()
1765       try:
1766         if self.owner_ is None: self.owner_ = User()
1767       finally:
1768         self.lazy_init_lock_.release()
1769     return self.owner_
1770
1771   def mutable_owner(self): self.has_owner_ = 1; return self.owner()
1772
1773   def clear_owner(self):
1774     if self.has_owner_:
1775       self.has_owner_ = 0;
1776       if self.owner_ is not None: self.owner_.Clear()
1777
1778   def has_owner(self): return self.has_owner_
1779
1780   def kind(self): return self.kind_
1781
1782   def set_kind(self, x):
1783     self.has_kind_ = 1
1784     self.kind_ = x
1785
1786   def clear_kind(self):
1787     if self.has_kind_:
1788       self.has_kind_ = 0
1789       self.kind_ = 0
1790
1791   def has_kind(self): return self.has_kind_
1792
1793   def kind_uri(self): return self.kind_uri_
1794
1795   def set_kind_uri(self, x):
1796     self.has_kind_uri_ = 1
1797     self.kind_uri_ = x
1798
1799   def clear_kind_uri(self):
1800     if self.has_kind_uri_:
1801       self.has_kind_uri_ = 0
1802       self.kind_uri_ = ""
1803
1804   def has_kind_uri(self): return self.has_kind_uri_
1805
1806   def property_size(self): return len(self.property_)
1807   def property_list(self): return self.property_
1808
1809   def property(self, i):
1810     return self.property_[i]
1811
1812   def mutable_property(self, i):
1813     return self.property_[i]
1814
1815   def add_property(self):
1816     x = Property()
1817     self.property_.append(x)
1818     return x
1819
1820   def clear_property(self):
1821     self.property_ = []
1822   def raw_property_size(self): return len(self.raw_property_)
1823   def raw_property_list(self): return self.raw_property_
1824
1825   def raw_property(self, i):
1826     return self.raw_property_[i]
1827
1828   def mutable_raw_property(self, i):
1829     return self.raw_property_[i]
1830
1831   def add_raw_property(self):
1832     x = Property()
1833     self.raw_property_.append(x)
1834     return x
1835
1836   def clear_raw_property(self):
1837     self.raw_property_ = []
1838
1839   def MergeFrom(self, x):
1840     assert x is not self
1841     if (x.has_key()): self.mutable_key().MergeFrom(x.key())
1842     if (x.has_entity_group()): self.mutable_entity_group().MergeFrom(x.entity_group())
1843     if (x.has_owner()): self.mutable_owner().MergeFrom(x.owner())
1844     if (x.has_kind()): self.set_kind(x.kind())
1845     if (x.has_kind_uri()): self.set_kind_uri(x.kind_uri())
1846     for i in xrange(x.property_size()): self.add_property().CopyFrom(x.property(i))
1847     for i in xrange(x.raw_property_size()): self.add_raw_property().CopyFrom(x.raw_property(i))
1848
1849   def Equals(self, x):
1850     if x is self: return 1
1851     if self.has_key_ != x.has_key_: return 0
1852     if self.has_key_ and self.key_ != x.key_: return 0
1853     if self.has_entity_group_ != x.has_entity_group_: return 0
1854     if self.has_entity_group_ and self.entity_group_ != x.entity_group_: return 0
1855     if self.has_owner_ != x.has_owner_: return 0
1856     if self.has_owner_ and self.owner_ != x.owner_: return 0
1857     if self.has_kind_ != x.has_kind_: return 0
1858     if self.has_kind_ and self.kind_ != x.kind_: return 0
1859     if self.has_kind_uri_ != x.has_kind_uri_: return 0
1860     if self.has_kind_uri_ and self.kind_uri_ != x.kind_uri_: return 0
1861     if len(self.property_) != len(x.property_): return 0
1862     for e1, e2 in zip(self.property_, x.property_):
1863       if e1 != e2: return 0
1864     if len(self.raw_property_) != len(x.raw_property_): return 0
1865     for e1, e2 in zip(self.raw_property_, x.raw_property_):
1866       if e1 != e2: return 0
1867     return 1
1868
1869   def IsInitialized(self, debug_strs=None):
1870     initialized = 1
1871     if (not self.has_key_):
1872       initialized = 0
1873       if debug_strs is not None:
1874         debug_strs.append('Required field: key not set.')
1875     elif not self.key_.IsInitialized(debug_strs): initialized = 0
1876     if (not self.has_entity_group_):
1877       initialized = 0
1878       if debug_strs is not None:
1879         debug_strs.append('Required field: entity_group not set.')
1880     elif not self.entity_group_.IsInitialized(debug_strs): initialized = 0
1881     if (self.has_owner_ and not self.owner_.IsInitialized(debug_strs)): initialized = 0
1882     for p in self.property_:
1883       if not p.IsInitialized(debug_strs): initialized=0
1884     for p in self.raw_property_:
1885       if not p.IsInitialized(debug_strs): initialized=0
1886     return initialized
1887
1888   def ByteSize(self):
1889     n = 0
1890     n += self.lengthString(self.key_.ByteSize())
1891     n += self.lengthString(self.entity_group_.ByteSize())
1892     if (self.has_owner_): n += 2 + self.lengthString(self.owner_.ByteSize())
1893     if (self.has_kind_): n += 1 + self.lengthVarInt64(self.kind_)
1894     if (self.has_kind_uri_): n += 1 + self.lengthString(len(self.kind_uri_))
1895     n += 1 * len(self.property_)
1896     for i in xrange(len(self.property_)): n += self.lengthString(self.property_[i].ByteSize())
1897     n += 1 * len(self.raw_property_)
1898     for i in xrange(len(self.raw_property_)): n += self.lengthString(self.raw_property_[i].ByteSize())
1899     return n + 3
1900
1901   def Clear(self):
1902     self.clear_key()
1903     self.clear_entity_group()
1904     self.clear_owner()
1905     self.clear_kind()
1906     self.clear_kind_uri()
1907     self.clear_property()
1908     self.clear_raw_property()
1909
1910   def OutputUnchecked(self, out):
1911     if (self.has_kind_):
1912       out.putVarInt32(32)
1913       out.putVarInt32(self.kind_)
1914     if (self.has_kind_uri_):
1915       out.putVarInt32(42)
1916       out.putPrefixedString(self.kind_uri_)
1917     out.putVarInt32(106)
1918     out.putVarInt32(self.key_.ByteSize())
1919     self.key_.OutputUnchecked(out)
1920     for i in xrange(len(self.property_)):
1921       out.putVarInt32(114)
1922       out.putVarInt32(self.property_[i].ByteSize())
1923       self.property_[i].OutputUnchecked(out)
1924     for i in xrange(len(self.raw_property_)):
1925       out.putVarInt32(122)
1926       out.putVarInt32(self.raw_property_[i].ByteSize())
1927       self.raw_property_[i].OutputUnchecked(out)
1928     out.putVarInt32(130)
1929     out.putVarInt32(self.entity_group_.ByteSize())
1930     self.entity_group_.OutputUnchecked(out)
1931     if (self.has_owner_):
1932       out.putVarInt32(138)
1933       out.putVarInt32(self.owner_.ByteSize())
1934       self.owner_.OutputUnchecked(out)
1935
1936   def TryMerge(self, d):
1937     while d.avail() > 0:
1938       tt = d.getVarInt32()
1939       if tt == 32:
1940         self.set_kind(d.getVarInt32())
1941         continue
1942       if tt == 42:
1943         self.set_kind_uri(d.getPrefixedString())
1944         continue
1945       if tt == 106:
1946         length = d.getVarInt32()
1947         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
1948         d.skip(length)
1949         self.mutable_key().TryMerge(tmp)
1950         continue
1951       if tt == 114:
1952         length = d.getVarInt32()
1953         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
1954         d.skip(length)
1955         self.add_property().TryMerge(tmp)
1956         continue
1957       if tt == 122:
1958         length = d.getVarInt32()
1959         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
1960         d.skip(length)
1961         self.add_raw_property().TryMerge(tmp)
1962         continue
1963       if tt == 130:
1964         length = d.getVarInt32()
1965         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
1966         d.skip(length)
1967         self.mutable_entity_group().TryMerge(tmp)
1968         continue
1969       if tt == 138:
1970         length = d.getVarInt32()
1971         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
1972         d.skip(length)
1973         self.mutable_owner().TryMerge(tmp)
1974         continue
1975       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1976       d.skipData(tt)
1977
1978
1979   def __str__(self, prefix="", printElemNumber=0):
1980     res=""
1981     if self.has_key_:
1982       res+=prefix+"key <\n"
1983       res+=self.key_.__str__(prefix + "  ", printElemNumber)
1984       res+=prefix+">\n"
1985     if self.has_entity_group_:
1986       res+=prefix+"entity_group <\n"
1987       res+=self.entity_group_.__str__(prefix + "  ", printElemNumber)
1988       res+=prefix+">\n"
1989     if self.has_owner_:
1990       res+=prefix+"owner <\n"
1991       res+=self.owner_.__str__(prefix + "  ", printElemNumber)
1992       res+=prefix+">\n"
1993     if self.has_kind_: res+=prefix+("kind: %s\n" % self.DebugFormatInt32(self.kind_))
1994     if self.has_kind_uri_: res+=prefix+("kind_uri: %s\n" % self.DebugFormatString(self.kind_uri_))
1995     cnt=0
1996     for e in self.property_:
1997       elm=""
1998       if printElemNumber: elm="(%d)" % cnt
1999       res+=prefix+("property%s <\n" % elm)
2000       res+=e.__str__(prefix + "  ", printElemNumber)
2001       res+=prefix+">\n"
2002       cnt+=1
2003     cnt=0
2004     for e in self.raw_property_:
2005       elm=""
2006       if printElemNumber: elm="(%d)" % cnt
2007       res+=prefix+("raw_property%s <\n" % elm)
2008       res+=e.__str__(prefix + "  ", printElemNumber)
2009       res+=prefix+">\n"
2010       cnt+=1
2011     return res
2012
2013   kkey = 13
2014   kentity_group = 16
2015   kowner = 17
2016   kkind = 4
2017   kkind_uri = 5
2018   kproperty = 14
2019   kraw_property = 15
2020
2021   _TEXT = (
2022    "ErrorCode",
2023    None,
2024    None,
2025    None,
2026    "kind",
2027    "kind_uri",
2028    None,
2029    None,
2030    None,
2031    None,
2032    None,
2033    None,
2034    None,
2035    "key",
2036    "property",
2037    "raw_property",
2038    "entity_group",
2039    "owner",
2040   )
2041
2042   _TYPES = (
2043    ProtocolBuffer.Encoder.NUMERIC,
2044    ProtocolBuffer.Encoder.MAX_TYPE,
2045
2046    ProtocolBuffer.Encoder.MAX_TYPE,
2047
2048    ProtocolBuffer.Encoder.MAX_TYPE,
2049
2050    ProtocolBuffer.Encoder.NUMERIC,
2051
2052    ProtocolBuffer.Encoder.STRING,
2053
2054    ProtocolBuffer.Encoder.MAX_TYPE,
2055
2056    ProtocolBuffer.Encoder.MAX_TYPE,
2057
2058    ProtocolBuffer.Encoder.MAX_TYPE,
2059
2060    ProtocolBuffer.Encoder.MAX_TYPE,
2061
2062    ProtocolBuffer.Encoder.MAX_TYPE,
2063
2064    ProtocolBuffer.Encoder.MAX_TYPE,
2065
2066    ProtocolBuffer.Encoder.MAX_TYPE,
2067
2068    ProtocolBuffer.Encoder.STRING,
2069
2070    ProtocolBuffer.Encoder.STRING,
2071
2072    ProtocolBuffer.Encoder.STRING,
2073
2074    ProtocolBuffer.Encoder.STRING,
2075
2076    ProtocolBuffer.Encoder.STRING,
2077
2078   )
2079
2080   _STYLE = """"""
2081   _STYLE_CONTENT_TYPE = """"""
2082 class CompositeProperty(ProtocolBuffer.ProtocolMessage):
2083   has_index_id_ = 0
2084   index_id_ = 0
2085
2086   def __init__(self, contents=None):
2087     self.value_ = []
2088     if contents is not None: self.MergeFromString(contents)
2089
2090   def index_id(self): return self.index_id_
2091
2092   def set_index_id(self, x):
2093     self.has_index_id_ = 1
2094     self.index_id_ = x
2095
2096   def clear_index_id(self):
2097     if self.has_index_id_:
2098       self.has_index_id_ = 0
2099       self.index_id_ = 0
2100
2101   def has_index_id(self): return self.has_index_id_
2102
2103   def value_size(self): return len(self.value_)
2104   def value_list(self): return self.value_
2105
2106   def value(self, i):
2107     return self.value_[i]
2108
2109   def set_value(self, i, x):
2110     self.value_[i] = x
2111
2112   def add_value(self, x):
2113     self.value_.append(x)
2114
2115   def clear_value(self):
2116     self.value_ = []
2117
2118
2119   def MergeFrom(self, x):
2120     assert x is not self
2121     if (x.has_index_id()): self.set_index_id(x.index_id())
2122     for i in xrange(x.value_size()): self.add_value(x.value(i))
2123
2124   def Equals(self, x):
2125     if x is self: return 1
2126     if self.has_index_id_ != x.has_index_id_: return 0
2127     if self.has_index_id_ and self.index_id_ != x.index_id_: return 0
2128     if len(self.value_) != len(x.value_): return 0
2129     for e1, e2 in zip(self.value_, x.value_):
2130       if e1 != e2: return 0
2131     return 1
2132
2133   def IsInitialized(self, debug_strs=None):
2134     initialized = 1
2135     if (not self.has_index_id_):
2136       initialized = 0
2137       if debug_strs is not None:
2138         debug_strs.append('Required field: index_id not set.')
2139     return initialized
2140
2141   def ByteSize(self):
2142     n = 0
2143     n += self.lengthVarInt64(self.index_id_)
2144     n += 1 * len(self.value_)
2145     for i in xrange(len(self.value_)): n += self.lengthString(len(self.value_[i]))
2146     return n + 1
2147
2148   def Clear(self):
2149     self.clear_index_id()
2150     self.clear_value()
2151
2152   def OutputUnchecked(self, out):
2153     out.putVarInt32(8)
2154     out.putVarInt64(self.index_id_)
2155     for i in xrange(len(self.value_)):
2156       out.putVarInt32(18)
2157       out.putPrefixedString(self.value_[i])
2158
2159   def TryMerge(self, d):
2160     while d.avail() > 0:
2161       tt = d.getVarInt32()
2162       if tt == 8:
2163         self.set_index_id(d.getVarInt64())
2164         continue
2165       if tt == 18:
2166         self.add_value(d.getPrefixedString())
2167         continue
2168       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
2169       d.skipData(tt)
2170
2171
2172   def __str__(self, prefix="", printElemNumber=0):
2173     res=""
2174     if self.has_index_id_: res+=prefix+("index_id: %s\n" % self.DebugFormatInt64(self.index_id_))
2175     cnt=0
2176     for e in self.value_:
2177       elm=""
2178       if printElemNumber: elm="(%d)" % cnt
2179       res+=prefix+("value%s: %s\n" % (elm, self.DebugFormatString(e)))
2180       cnt+=1
2181     return res
2182
2183   kindex_id = 1
2184   kvalue = 2
2185
2186   _TEXT = (
2187    "ErrorCode",
2188    "index_id",
2189    "value",
2190   )
2191
2192   _TYPES = (
2193    ProtocolBuffer.Encoder.NUMERIC,
2194    ProtocolBuffer.Encoder.NUMERIC,
2195
2196    ProtocolBuffer.Encoder.STRING,
2197
2198   )
2199
2200   _STYLE = """"""
2201   _STYLE_CONTENT_TYPE = """"""
2202 class Index_Property(ProtocolBuffer.ProtocolMessage):
2203
2204   ASCENDING    =    1
2205   DESCENDING   =    2
2206
2207   _Direction_NAMES = {
2208     1: "ASCENDING",
2209     2: "DESCENDING",
2210   }
2211
2212   def Direction_Name(cls, x): return cls._Direction_NAMES.get(x, "")
2213   Direction_Name = classmethod(Direction_Name)
2214
2215   has_name_ = 0
2216   name_ = ""
2217   has_direction_ = 0
2218   direction_ = 1
2219
2220   def __init__(self, contents=None):
2221     if contents is not None: self.MergeFromString(contents)
2222
2223   def name(self): return self.name_
2224
2225   def set_name(self, x):
2226     self.has_name_ = 1
2227     self.name_ = x
2228
2229   def clear_name(self):
2230     if self.has_name_:
2231       self.has_name_ = 0
2232       self.name_ = ""
2233
2234   def has_name(self): return self.has_name_
2235
2236   def direction(self): return self.direction_
2237
2238   def set_direction(self, x):
2239     self.has_direction_ = 1
2240     self.direction_ = x
2241
2242   def clear_direction(self):
2243     if self.has_direction_:
2244       self.has_direction_ = 0
2245       self.direction_ = 1
2246
2247   def has_direction(self): return self.has_direction_
2248
2249
2250   def MergeFrom(self, x):
2251     assert x is not self
2252     if (x.has_name()): self.set_name(x.name())
2253     if (x.has_direction()): self.set_direction(x.direction())
2254
2255   def Equals(self, x):
2256     if x is self: return 1
2257     if self.has_name_ != x.has_name_: return 0
2258     if self.has_name_ and self.name_ != x.name_: return 0
2259     if self.has_direction_ != x.has_direction_: return 0
2260     if self.has_direction_ and self.direction_ != x.direction_: return 0
2261     return 1
2262
2263   def IsInitialized(self, debug_strs=None):
2264     initialized = 1
2265     if (not self.has_name_):
2266       initialized = 0
2267       if debug_strs is not None:
2268         debug_strs.append('Required field: name not set.')
2269     return initialized
2270
2271   def ByteSize(self):
2272     n = 0
2273     n += self.lengthString(len(self.name_))
2274     if (self.has_direction_): n += 1 + self.lengthVarInt64(self.direction_)
2275     return n + 1
2276
2277   def Clear(self):
2278     self.clear_name()
2279     self.clear_direction()
2280
2281   def OutputUnchecked(self, out):
2282     out.putVarInt32(26)
2283     out.putPrefixedString(self.name_)
2284     if (self.has_direction_):
2285       out.putVarInt32(32)
2286       out.putVarInt32(self.direction_)
2287
2288   def TryMerge(self, d):
2289     while 1:
2290       tt = d.getVarInt32()
2291       if tt == 20: break
2292       if tt == 26:
2293         self.set_name(d.getPrefixedString())
2294         continue
2295       if tt == 32:
2296         self.set_direction(d.getVarInt32())
2297         continue
2298       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
2299       d.skipData(tt)
2300
2301
2302   def __str__(self, prefix="", printElemNumber=0):
2303     res=""
2304     if self.has_name_: res+=prefix+("name: %s\n" % self.DebugFormatString(self.name_))
2305     if self.has_direction_: res+=prefix+("direction: %s\n" % self.DebugFormatInt32(self.direction_))
2306     return res
2307
2308 class Index(ProtocolBuffer.ProtocolMessage):
2309   has_entity_type_ = 0
2310   entity_type_ = ""
2311   has_ancestor_ = 0
2312   ancestor_ = 0
2313
2314   def __init__(self, contents=None):
2315     self.property_ = []
2316     if contents is not None: self.MergeFromString(contents)
2317
2318   def entity_type(self): return self.entity_type_
2319
2320   def set_entity_type(self, x):
2321     self.has_entity_type_ = 1
2322     self.entity_type_ = x
2323
2324   def clear_entity_type(self):
2325     if self.has_entity_type_:
2326       self.has_entity_type_ = 0
2327       self.entity_type_ = ""
2328
2329   def has_entity_type(self): return self.has_entity_type_
2330
2331   def ancestor(self): return self.ancestor_
2332
2333   def set_ancestor(self, x):
2334     self.has_ancestor_ = 1
2335     self.ancestor_ = x
2336
2337   def clear_ancestor(self):
2338     if self.has_ancestor_:
2339       self.has_ancestor_ = 0
2340       self.ancestor_ = 0
2341
2342   def has_ancestor(self): return self.has_ancestor_
2343
2344   def property_size(self): return len(self.property_)
2345   def property_list(self): return self.property_
2346
2347   def property(self, i):
2348     return self.property_[i]
2349
2350   def mutable_property(self, i):
2351     return self.property_[i]
2352
2353   def add_property(self):
2354     x = Index_Property()
2355     self.property_.append(x)
2356     return x
2357
2358   def clear_property(self):
2359     self.property_ = []
2360
2361   def MergeFrom(self, x):
2362     assert x is not self
2363     if (x.has_entity_type()): self.set_entity_type(x.entity_type())
2364     if (x.has_ancestor()): self.set_ancestor(x.ancestor())
2365     for i in xrange(x.property_size()): self.add_property().CopyFrom(x.property(i))
2366
2367   def Equals(self, x):
2368     if x is self: return 1
2369     if self.has_entity_type_ != x.has_entity_type_: return 0
2370     if self.has_entity_type_ and self.entity_type_ != x.entity_type_: return 0
2371     if self.has_ancestor_ != x.has_ancestor_: return 0
2372     if self.has_ancestor_ and self.ancestor_ != x.ancestor_: return 0
2373     if len(self.property_) != len(x.property_): return 0
2374     for e1, e2 in zip(self.property_, x.property_):
2375       if e1 != e2: return 0
2376     return 1
2377
2378   def IsInitialized(self, debug_strs=None):
2379     initialized = 1
2380     if (not self.has_entity_type_):
2381       initialized = 0
2382       if debug_strs is not None:
2383         debug_strs.append('Required field: entity_type not set.')
2384     if (not self.has_ancestor_):
2385       initialized = 0
2386       if debug_strs is not None:
2387         debug_strs.append('Required field: ancestor not set.')
2388     for p in self.property_:
2389       if not p.IsInitialized(debug_strs): initialized=0
2390     return initialized
2391
2392   def ByteSize(self):
2393     n = 0
2394     n += self.lengthString(len(self.entity_type_))
2395     n += 2 * len(self.property_)
2396     for i in xrange(len(self.property_)): n += self.property_[i].ByteSize()
2397     return n + 3
2398
2399   def Clear(self):
2400     self.clear_entity_type()
2401     self.clear_ancestor()
2402     self.clear_property()
2403
2404   def OutputUnchecked(self, out):
2405     out.putVarInt32(10)
2406     out.putPrefixedString(self.entity_type_)
2407     for i in xrange(len(self.property_)):
2408       out.putVarInt32(19)
2409       self.property_[i].OutputUnchecked(out)
2410       out.putVarInt32(20)
2411     out.putVarInt32(40)
2412     out.putBoolean(self.ancestor_)
2413
2414   def TryMerge(self, d):
2415     while d.avail() > 0:
2416       tt = d.getVarInt32()
2417       if tt == 10:
2418         self.set_entity_type(d.getPrefixedString())
2419         continue
2420       if tt == 19:
2421         self.add_property().TryMerge(d)
2422         continue
2423       if tt == 40:
2424         self.set_ancestor(d.getBoolean())
2425         continue
2426       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
2427       d.skipData(tt)
2428
2429
2430   def __str__(self, prefix="", printElemNumber=0):
2431     res=""
2432     if self.has_entity_type_: res+=prefix+("entity_type: %s\n" % self.DebugFormatString(self.entity_type_))
2433     if self.has_ancestor_: res+=prefix+("ancestor: %s\n" % self.DebugFormatBool(self.ancestor_))
2434     cnt=0
2435     for e in self.property_:
2436       elm=""
2437       if printElemNumber: elm="(%d)" % cnt
2438       res+=prefix+("Property%s {\n" % elm)
2439       res+=e.__str__(prefix + "  ", printElemNumber)
2440       res+=prefix+"}\n"
2441       cnt+=1
2442     return res
2443
2444   kentity_type = 1
2445   kancestor = 5
2446   kPropertyGroup = 2
2447   kPropertyname = 3
2448   kPropertydirection = 4
2449
2450   _TEXT = (
2451    "ErrorCode",
2452    "entity_type",
2453    "Property",
2454    "name",
2455    "direction",
2456    "ancestor",
2457   )
2458
2459   _TYPES = (
2460    ProtocolBuffer.Encoder.NUMERIC,
2461    ProtocolBuffer.Encoder.STRING,
2462
2463    ProtocolBuffer.Encoder.STARTGROUP,
2464
2465    ProtocolBuffer.Encoder.STRING,
2466
2467    ProtocolBuffer.Encoder.NUMERIC,
2468
2469    ProtocolBuffer.Encoder.NUMERIC,
2470
2471   )
2472
2473   _STYLE = """"""
2474   _STYLE_CONTENT_TYPE = """"""
2475 class CompositeIndex(ProtocolBuffer.ProtocolMessage):
2476
2477   WRITE_ONLY   =    1
2478   READ_WRITE   =    2
2479   DELETED      =    3
2480   ERROR        =    4
2481
2482   _State_NAMES = {
2483     1: "WRITE_ONLY",
2484     2: "READ_WRITE",
2485     3: "DELETED",
2486     4: "ERROR",
2487   }
2488
2489   def State_Name(cls, x): return cls._State_NAMES.get(x, "")
2490   State_Name = classmethod(State_Name)
2491
2492   has_app_id_ = 0
2493   app_id_ = ""
2494   has_id_ = 0
2495   id_ = 0
2496   has_definition_ = 0
2497   has_state_ = 0
2498   state_ = 0
2499
2500   def __init__(self, contents=None):
2501     self.definition_ = Index()
2502     if contents is not None: self.MergeFromString(contents)
2503
2504   def app_id(self): return self.app_id_
2505
2506   def set_app_id(self, x):
2507     self.has_app_id_ = 1
2508     self.app_id_ = x
2509
2510   def clear_app_id(self):
2511     if self.has_app_id_:
2512       self.has_app_id_ = 0
2513       self.app_id_ = ""
2514
2515   def has_app_id(self): return self.has_app_id_
2516
2517   def id(self): return self.id_
2518
2519   def set_id(self, x):
2520     self.has_id_ = 1
2521     self.id_ = x
2522
2523   def clear_id(self):
2524     if self.has_id_:
2525       self.has_id_ = 0
2526       self.id_ = 0
2527
2528   def has_id(self): return self.has_id_
2529
2530   def definition(self): return self.definition_
2531
2532   def mutable_definition(self): self.has_definition_ = 1; return self.definition_
2533
2534   def clear_definition(self):self.has_definition_ = 0; self.definition_.Clear()
2535
2536   def has_definition(self): return self.has_definition_
2537
2538   def state(self): return self.state_
2539
2540   def set_state(self, x):
2541     self.has_state_ = 1
2542     self.state_ = x
2543
2544   def clear_state(self):
2545     if self.has_state_:
2546       self.has_state_ = 0
2547       self.state_ = 0
2548
2549   def has_state(self): return self.has_state_
2550
2551
2552   def MergeFrom(self, x):
2553     assert x is not self
2554     if (x.has_app_id()): self.set_app_id(x.app_id())
2555     if (x.has_id()): self.set_id(x.id())
2556     if (x.has_definition()): self.mutable_definition().MergeFrom(x.definition())
2557     if (x.has_state()): self.set_state(x.state())
2558
2559   def Equals(self, x):
2560     if x is self: return 1
2561     if self.has_app_id_ != x.has_app_id_: return 0
2562     if self.has_app_id_ and self.app_id_ != x.app_id_: return 0
2563     if self.has_id_ != x.has_id_: return 0
2564     if self.has_id_ and self.id_ != x.id_: return 0
2565     if self.has_definition_ != x.has_definition_: return 0
2566     if self.has_definition_ and self.definition_ != x.definition_: return 0
2567     if self.has_state_ != x.has_state_: return 0
2568     if self.has_state_ and self.state_ != x.state_: return 0
2569     return 1
2570
2571   def IsInitialized(self, debug_strs=None):
2572     initialized = 1
2573     if (not self.has_app_id_):
2574       initialized = 0
2575       if debug_strs is not None:
2576         debug_strs.append('Required field: app_id not set.')
2577     if (not self.has_id_):
2578       initialized = 0
2579       if debug_strs is not None:
2580         debug_strs.append('Required field: id not set.')
2581     if (not self.has_definition_):
2582       initialized = 0
2583       if debug_strs is not None:
2584         debug_strs.append('Required field: definition not set.')
2585     elif not self.definition_.IsInitialized(debug_strs): initialized = 0
2586     if (not self.has_state_):
2587       initialized = 0
2588       if debug_strs is not None:
2589         debug_strs.append('Required field: state not set.')
2590     return initialized
2591
2592   def ByteSize(self):
2593     n = 0
2594     n += self.lengthString(len(self.app_id_))
2595     n += self.lengthVarInt64(self.id_)
2596     n += self.lengthString(self.definition_.ByteSize())
2597     n += self.lengthVarInt64(self.state_)
2598     return n + 4
2599
2600   def Clear(self):
2601     self.clear_app_id()
2602     self.clear_id()
2603     self.clear_definition()
2604     self.clear_state()
2605
2606   def OutputUnchecked(self, out):
2607     out.putVarInt32(10)
2608     out.putPrefixedString(self.app_id_)
2609     out.putVarInt32(16)
2610     out.putVarInt64(self.id_)
2611     out.putVarInt32(26)
2612     out.putVarInt32(self.definition_.ByteSize())
2613     self.definition_.OutputUnchecked(out)
2614     out.putVarInt32(32)
2615     out.putVarInt32(self.state_)
2616
2617   def TryMerge(self, d):
2618     while d.avail() > 0:
2619       tt = d.getVarInt32()
2620       if tt == 10:
2621         self.set_app_id(d.getPrefixedString())
2622         continue
2623       if tt == 16:
2624         self.set_id(d.getVarInt64())
2625         continue
2626       if tt == 26:
2627         length = d.getVarInt32()
2628         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
2629         d.skip(length)
2630         self.mutable_definition().TryMerge(tmp)
2631         continue
2632       if tt == 32:
2633         self.set_state(d.getVarInt32())
2634         continue
2635       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
2636       d.skipData(tt)
2637
2638
2639   def __str__(self, prefix="", printElemNumber=0):
2640     res=""
2641     if self.has_app_id_: res+=prefix+("app_id: %s\n" % self.DebugFormatString(self.app_id_))
2642     if self.has_id_: res+=prefix+("id: %s\n" % self.DebugFormatInt64(self.id_))
2643     if self.has_definition_:
2644       res+=prefix+"definition <\n"
2645       res+=self.definition_.__str__(prefix + "  ", printElemNumber)
2646       res+=prefix+">\n"
2647     if self.has_state_: res+=prefix+("state: %s\n" % self.DebugFormatInt32(self.state_))
2648     return res
2649
2650   kapp_id = 1
2651   kid = 2
2652   kdefinition = 3
2653   kstate = 4
2654
2655   _TEXT = (
2656    "ErrorCode",
2657    "app_id",
2658    "id",
2659    "definition",
2660    "state",
2661   )
2662
2663   _TYPES = (
2664    ProtocolBuffer.Encoder.NUMERIC,
2665    ProtocolBuffer.Encoder.STRING,
2666
2667    ProtocolBuffer.Encoder.NUMERIC,
2668
2669    ProtocolBuffer.Encoder.STRING,
2670
2671    ProtocolBuffer.Encoder.NUMERIC,
2672
2673   )
2674
2675   _STYLE = """"""
2676   _STYLE_CONTENT_TYPE = """"""
2677
2678 __all__ = ['PropertyValue','PropertyValue_ReferenceValuePathElement','PropertyValue_PointValue','PropertyValue_UserValue','PropertyValue_ReferenceValue','Property','Path','Path_Element','Reference','User','EntityProto','CompositeProperty','Index','Index_Property','CompositeIndex']