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     if (not self.has_multiple_):
1023       initialized = 0
1024       if debug_strs is not None:
1025         debug_strs.append('Required field: multiple not set.')
1026     return initialized
1027
1028   def ByteSize(self):
1029     n = 0
1030     if (self.has_meaning_): n += 1 + self.lengthVarInt64(self.meaning_)
1031     if (self.has_meaning_uri_): n += 1 + self.lengthString(len(self.meaning_uri_))
1032     n += self.lengthString(len(self.name_))
1033     n += self.lengthString(self.value_.ByteSize())
1034     return n + 4
1035
1036   def Clear(self):
1037     self.clear_meaning()
1038     self.clear_meaning_uri()
1039     self.clear_name()
1040     self.clear_value()
1041     self.clear_multiple()
1042
1043   def OutputUnchecked(self, out):
1044     if (self.has_meaning_):
1045       out.putVarInt32(8)
1046       out.putVarInt32(self.meaning_)
1047     if (self.has_meaning_uri_):
1048       out.putVarInt32(18)
1049       out.putPrefixedString(self.meaning_uri_)
1050     out.putVarInt32(26)
1051     out.putPrefixedString(self.name_)
1052     out.putVarInt32(32)
1053     out.putBoolean(self.multiple_)
1054     out.putVarInt32(42)
1055     out.putVarInt32(self.value_.ByteSize())
1056     self.value_.OutputUnchecked(out)
1057
1058   def TryMerge(self, d):
1059     while d.avail() > 0:
1060       tt = d.getVarInt32()
1061       if tt == 8:
1062         self.set_meaning(d.getVarInt32())
1063         continue
1064       if tt == 18:
1065         self.set_meaning_uri(d.getPrefixedString())
1066         continue
1067       if tt == 26:
1068         self.set_name(d.getPrefixedString())
1069         continue
1070       if tt == 32:
1071         self.set_multiple(d.getBoolean())
1072         continue
1073       if tt == 42:
1074         length = d.getVarInt32()
1075         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
1076         d.skip(length)
1077         self.mutable_value().TryMerge(tmp)
1078         continue
1079       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1080       d.skipData(tt)
1081
1082
1083   def __str__(self, prefix="", printElemNumber=0):
1084     res=""
1085     if self.has_meaning_: res+=prefix+("meaning: %s\n" % self.DebugFormatInt32(self.meaning_))
1086     if self.has_meaning_uri_: res+=prefix+("meaning_uri: %s\n" % self.DebugFormatString(self.meaning_uri_))
1087     if self.has_name_: res+=prefix+("name: %s\n" % self.DebugFormatString(self.name_))
1088     if self.has_value_:
1089       res+=prefix+"value <\n"
1090       res+=self.value_.__str__(prefix + "  ", printElemNumber)
1091       res+=prefix+">\n"
1092     if self.has_multiple_: res+=prefix+("multiple: %s\n" % self.DebugFormatBool(self.multiple_))
1093     return res
1094
1095   kmeaning = 1
1096   kmeaning_uri = 2
1097   kname = 3
1098   kvalue = 5
1099   kmultiple = 4
1100
1101   _TEXT = (
1102    "ErrorCode",
1103    "meaning",
1104    "meaning_uri",
1105    "name",
1106    "multiple",
1107    "value",
1108   )
1109
1110   _TYPES = (
1111    ProtocolBuffer.Encoder.NUMERIC,
1112    ProtocolBuffer.Encoder.NUMERIC,
1113
1114    ProtocolBuffer.Encoder.STRING,
1115
1116    ProtocolBuffer.Encoder.STRING,
1117
1118    ProtocolBuffer.Encoder.NUMERIC,
1119
1120    ProtocolBuffer.Encoder.STRING,
1121
1122   )
1123
1124   _STYLE = """"""
1125   _STYLE_CONTENT_TYPE = """"""
1126 class Path_Element(ProtocolBuffer.ProtocolMessage):
1127   has_type_ = 0
1128   type_ = ""
1129   has_id_ = 0
1130   id_ = 0
1131   has_name_ = 0
1132   name_ = ""
1133
1134   def __init__(self, contents=None):
1135     if contents is not None: self.MergeFromString(contents)
1136
1137   def type(self): return self.type_
1138
1139   def set_type(self, x):
1140     self.has_type_ = 1
1141     self.type_ = x
1142
1143   def clear_type(self):
1144     if self.has_type_:
1145       self.has_type_ = 0
1146       self.type_ = ""
1147
1148   def has_type(self): return self.has_type_
1149
1150   def id(self): return self.id_
1151
1152   def set_id(self, x):
1153     self.has_id_ = 1
1154     self.id_ = x
1155
1156   def clear_id(self):
1157     if self.has_id_:
1158       self.has_id_ = 0
1159       self.id_ = 0
1160
1161   def has_id(self): return self.has_id_
1162
1163   def name(self): return self.name_
1164
1165   def set_name(self, x):
1166     self.has_name_ = 1
1167     self.name_ = x
1168
1169   def clear_name(self):
1170     if self.has_name_:
1171       self.has_name_ = 0
1172       self.name_ = ""
1173
1174   def has_name(self): return self.has_name_
1175
1176
1177   def MergeFrom(self, x):
1178     assert x is not self
1179     if (x.has_type()): self.set_type(x.type())
1180     if (x.has_id()): self.set_id(x.id())
1181     if (x.has_name()): self.set_name(x.name())
1182
1183   def Equals(self, x):
1184     if x is self: return 1
1185     if self.has_type_ != x.has_type_: return 0
1186     if self.has_type_ and self.type_ != x.type_: return 0
1187     if self.has_id_ != x.has_id_: return 0
1188     if self.has_id_ and self.id_ != x.id_: return 0
1189     if self.has_name_ != x.has_name_: return 0
1190     if self.has_name_ and self.name_ != x.name_: return 0
1191     return 1
1192
1193   def IsInitialized(self, debug_strs=None):
1194     initialized = 1
1195     if (not self.has_type_):
1196       initialized = 0
1197       if debug_strs is not None:
1198         debug_strs.append('Required field: type not set.')
1199     return initialized
1200
1201   def ByteSize(self):
1202     n = 0
1203     n += self.lengthString(len(self.type_))
1204     if (self.has_id_): n += 1 + self.lengthVarInt64(self.id_)
1205     if (self.has_name_): n += 1 + self.lengthString(len(self.name_))
1206     return n + 1
1207
1208   def Clear(self):
1209     self.clear_type()
1210     self.clear_id()
1211     self.clear_name()
1212
1213   def OutputUnchecked(self, out):
1214     out.putVarInt32(18)
1215     out.putPrefixedString(self.type_)
1216     if (self.has_id_):
1217       out.putVarInt32(24)
1218       out.putVarInt64(self.id_)
1219     if (self.has_name_):
1220       out.putVarInt32(34)
1221       out.putPrefixedString(self.name_)
1222
1223   def TryMerge(self, d):
1224     while 1:
1225       tt = d.getVarInt32()
1226       if tt == 12: break
1227       if tt == 18:
1228         self.set_type(d.getPrefixedString())
1229         continue
1230       if tt == 24:
1231         self.set_id(d.getVarInt64())
1232         continue
1233       if tt == 34:
1234         self.set_name(d.getPrefixedString())
1235         continue
1236       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1237       d.skipData(tt)
1238
1239
1240   def __str__(self, prefix="", printElemNumber=0):
1241     res=""
1242     if self.has_type_: res+=prefix+("type: %s\n" % self.DebugFormatString(self.type_))
1243     if self.has_id_: res+=prefix+("id: %s\n" % self.DebugFormatInt64(self.id_))
1244     if self.has_name_: res+=prefix+("name: %s\n" % self.DebugFormatString(self.name_))
1245     return res
1246
1247 class Path(ProtocolBuffer.ProtocolMessage):
1248
1249   def __init__(self, contents=None):
1250     self.element_ = []
1251     if contents is not None: self.MergeFromString(contents)
1252
1253   def element_size(self): return len(self.element_)
1254   def element_list(self): return self.element_
1255
1256   def element(self, i):
1257     return self.element_[i]
1258
1259   def mutable_element(self, i):
1260     return self.element_[i]
1261
1262   def add_element(self):
1263     x = Path_Element()
1264     self.element_.append(x)
1265     return x
1266
1267   def clear_element(self):
1268     self.element_ = []
1269
1270   def MergeFrom(self, x):
1271     assert x is not self
1272     for i in xrange(x.element_size()): self.add_element().CopyFrom(x.element(i))
1273
1274   def Equals(self, x):
1275     if x is self: return 1
1276     if len(self.element_) != len(x.element_): return 0
1277     for e1, e2 in zip(self.element_, x.element_):
1278       if e1 != e2: return 0
1279     return 1
1280
1281   def IsInitialized(self, debug_strs=None):
1282     initialized = 1
1283     for p in self.element_:
1284       if not p.IsInitialized(debug_strs): initialized=0
1285     return initialized
1286
1287   def ByteSize(self):
1288     n = 0
1289     n += 2 * len(self.element_)
1290     for i in xrange(len(self.element_)): n += self.element_[i].ByteSize()
1291     return n + 0
1292
1293   def Clear(self):
1294     self.clear_element()
1295
1296   def OutputUnchecked(self, out):
1297     for i in xrange(len(self.element_)):
1298       out.putVarInt32(11)
1299       self.element_[i].OutputUnchecked(out)
1300       out.putVarInt32(12)
1301
1302   def TryMerge(self, d):
1303     while d.avail() > 0:
1304       tt = d.getVarInt32()
1305       if tt == 11:
1306         self.add_element().TryMerge(d)
1307         continue
1308       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1309       d.skipData(tt)
1310
1311
1312   def __str__(self, prefix="", printElemNumber=0):
1313     res=""
1314     cnt=0
1315     for e in self.element_:
1316       elm=""
1317       if printElemNumber: elm="(%d)" % cnt
1318       res+=prefix+("Element%s {\n" % elm)
1319       res+=e.__str__(prefix + "  ", printElemNumber)
1320       res+=prefix+"}\n"
1321       cnt+=1
1322     return res
1323
1324   kElementGroup = 1
1325   kElementtype = 2
1326   kElementid = 3
1327   kElementname = 4
1328
1329   _TEXT = (
1330    "ErrorCode",
1331    "Element",
1332    "type",
1333    "id",
1334    "name",
1335   )
1336
1337   _TYPES = (
1338    ProtocolBuffer.Encoder.NUMERIC,
1339    ProtocolBuffer.Encoder.STARTGROUP,
1340
1341    ProtocolBuffer.Encoder.STRING,
1342
1343    ProtocolBuffer.Encoder.NUMERIC,
1344
1345    ProtocolBuffer.Encoder.STRING,
1346
1347   )
1348
1349   _STYLE = """"""
1350   _STYLE_CONTENT_TYPE = """"""
1351 class Reference(ProtocolBuffer.ProtocolMessage):
1352   has_app_ = 0
1353   app_ = ""
1354   has_path_ = 0
1355
1356   def __init__(self, contents=None):
1357     self.path_ = Path()
1358     if contents is not None: self.MergeFromString(contents)
1359
1360   def app(self): return self.app_
1361
1362   def set_app(self, x):
1363     self.has_app_ = 1
1364     self.app_ = x
1365
1366   def clear_app(self):
1367     if self.has_app_:
1368       self.has_app_ = 0
1369       self.app_ = ""
1370
1371   def has_app(self): return self.has_app_
1372
1373   def path(self): return self.path_
1374
1375   def mutable_path(self): self.has_path_ = 1; return self.path_
1376
1377   def clear_path(self):self.has_path_ = 0; self.path_.Clear()
1378
1379   def has_path(self): return self.has_path_
1380
1381
1382   def MergeFrom(self, x):
1383     assert x is not self
1384     if (x.has_app()): self.set_app(x.app())
1385     if (x.has_path()): self.mutable_path().MergeFrom(x.path())
1386
1387   def Equals(self, x):
1388     if x is self: return 1
1389     if self.has_app_ != x.has_app_: return 0
1390     if self.has_app_ and self.app_ != x.app_: return 0
1391     if self.has_path_ != x.has_path_: return 0
1392     if self.has_path_ and self.path_ != x.path_: return 0
1393     return 1
1394
1395   def IsInitialized(self, debug_strs=None):
1396     initialized = 1
1397     if (not self.has_app_):
1398       initialized = 0
1399       if debug_strs is not None:
1400         debug_strs.append('Required field: app not set.')
1401     if (not self.has_path_):
1402       initialized = 0
1403       if debug_strs is not None:
1404         debug_strs.append('Required field: path not set.')
1405     elif not self.path_.IsInitialized(debug_strs): initialized = 0
1406     return initialized
1407
1408   def ByteSize(self):
1409     n = 0
1410     n += self.lengthString(len(self.app_))
1411     n += self.lengthString(self.path_.ByteSize())
1412     return n + 2
1413
1414   def Clear(self):
1415     self.clear_app()
1416     self.clear_path()
1417
1418   def OutputUnchecked(self, out):
1419     out.putVarInt32(106)
1420     out.putPrefixedString(self.app_)
1421     out.putVarInt32(114)
1422     out.putVarInt32(self.path_.ByteSize())
1423     self.path_.OutputUnchecked(out)
1424
1425   def TryMerge(self, d):
1426     while d.avail() > 0:
1427       tt = d.getVarInt32()
1428       if tt == 106:
1429         self.set_app(d.getPrefixedString())
1430         continue
1431       if tt == 114:
1432         length = d.getVarInt32()
1433         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
1434         d.skip(length)
1435         self.mutable_path().TryMerge(tmp)
1436         continue
1437       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1438       d.skipData(tt)
1439
1440
1441   def __str__(self, prefix="", printElemNumber=0):
1442     res=""
1443     if self.has_app_: res+=prefix+("app: %s\n" % self.DebugFormatString(self.app_))
1444     if self.has_path_:
1445       res+=prefix+"path <\n"
1446       res+=self.path_.__str__(prefix + "  ", printElemNumber)
1447       res+=prefix+">\n"
1448     return res
1449
1450   kapp = 13
1451   kpath = 14
1452
1453   _TEXT = (
1454    "ErrorCode",
1455    None,
1456    None,
1457    None,
1458    None,
1459    None,
1460    None,
1461    None,
1462    None,
1463    None,
1464    None,
1465    None,
1466    None,
1467    "app",
1468    "path",
1469   )
1470
1471   _TYPES = (
1472    ProtocolBuffer.Encoder.NUMERIC,
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.MAX_TYPE,
1496
1497    ProtocolBuffer.Encoder.STRING,
1498
1499    ProtocolBuffer.Encoder.STRING,
1500
1501   )
1502
1503   _STYLE = """"""
1504   _STYLE_CONTENT_TYPE = """"""
1505 class User(ProtocolBuffer.ProtocolMessage):
1506   has_email_ = 0
1507   email_ = ""
1508   has_auth_domain_ = 0
1509   auth_domain_ = ""
1510   has_nickname_ = 0
1511   nickname_ = ""
1512   has_gaiaid_ = 0
1513   gaiaid_ = 0
1514   has_obfuscated_gaiaid_ = 0
1515   obfuscated_gaiaid_ = ""
1516
1517   def __init__(self, contents=None):
1518     if contents is not None: self.MergeFromString(contents)
1519
1520   def email(self): return self.email_
1521
1522   def set_email(self, x):
1523     self.has_email_ = 1
1524     self.email_ = x
1525
1526   def clear_email(self):
1527     if self.has_email_:
1528       self.has_email_ = 0
1529       self.email_ = ""
1530
1531   def has_email(self): return self.has_email_
1532
1533   def auth_domain(self): return self.auth_domain_
1534
1535   def set_auth_domain(self, x):
1536     self.has_auth_domain_ = 1
1537     self.auth_domain_ = x
1538
1539   def clear_auth_domain(self):
1540     if self.has_auth_domain_:
1541       self.has_auth_domain_ = 0
1542       self.auth_domain_ = ""
1543
1544   def has_auth_domain(self): return self.has_auth_domain_
1545
1546   def nickname(self): return self.nickname_
1547
1548   def set_nickname(self, x):
1549     self.has_nickname_ = 1
1550     self.nickname_ = x
1551
1552   def clear_nickname(self):
1553     if self.has_nickname_:
1554       self.has_nickname_ = 0
1555       self.nickname_ = ""
1556
1557   def has_nickname(self): return self.has_nickname_
1558
1559   def gaiaid(self): return self.gaiaid_
1560
1561   def set_gaiaid(self, x):
1562     self.has_gaiaid_ = 1
1563     self.gaiaid_ = x
1564
1565   def clear_gaiaid(self):
1566     if self.has_gaiaid_:
1567       self.has_gaiaid_ = 0
1568       self.gaiaid_ = 0
1569
1570   def has_gaiaid(self): return self.has_gaiaid_
1571
1572   def obfuscated_gaiaid(self): return self.obfuscated_gaiaid_
1573
1574   def set_obfuscated_gaiaid(self, x):
1575     self.has_obfuscated_gaiaid_ = 1
1576     self.obfuscated_gaiaid_ = x
1577
1578   def clear_obfuscated_gaiaid(self):
1579     if self.has_obfuscated_gaiaid_:
1580       self.has_obfuscated_gaiaid_ = 0
1581       self.obfuscated_gaiaid_ = ""
1582
1583   def has_obfuscated_gaiaid(self): return self.has_obfuscated_gaiaid_
1584
1585
1586   def MergeFrom(self, x):
1587     assert x is not self
1588     if (x.has_email()): self.set_email(x.email())
1589     if (x.has_auth_domain()): self.set_auth_domain(x.auth_domain())
1590     if (x.has_nickname()): self.set_nickname(x.nickname())
1591     if (x.has_gaiaid()): self.set_gaiaid(x.gaiaid())
1592     if (x.has_obfuscated_gaiaid()): self.set_obfuscated_gaiaid(x.obfuscated_gaiaid())
1593
1594   def Equals(self, x):
1595     if x is self: return 1
1596     if self.has_email_ != x.has_email_: return 0
1597     if self.has_email_ and self.email_ != x.email_: return 0
1598     if self.has_auth_domain_ != x.has_auth_domain_: return 0
1599     if self.has_auth_domain_ and self.auth_domain_ != x.auth_domain_: return 0
1600     if self.has_nickname_ != x.has_nickname_: return 0
1601     if self.has_nickname_ and self.nickname_ != x.nickname_: return 0
1602     if self.has_gaiaid_ != x.has_gaiaid_: return 0
1603     if self.has_gaiaid_ and self.gaiaid_ != x.gaiaid_: return 0
1604     if self.has_obfuscated_gaiaid_ != x.has_obfuscated_gaiaid_: return 0
1605     if self.has_obfuscated_gaiaid_ and self.obfuscated_gaiaid_ != x.obfuscated_gaiaid_: return 0
1606     return 1
1607
1608   def IsInitialized(self, debug_strs=None):
1609     initialized = 1
1610     if (not self.has_email_):
1611       initialized = 0
1612       if debug_strs is not None:
1613         debug_strs.append('Required field: email not set.')
1614     if (not self.has_auth_domain_):
1615       initialized = 0
1616       if debug_strs is not None:
1617         debug_strs.append('Required field: auth_domain not set.')
1618     if (not self.has_gaiaid_):
1619       initialized = 0
1620       if debug_strs is not None:
1621         debug_strs.append('Required field: gaiaid not set.')
1622     return initialized
1623
1624   def ByteSize(self):
1625     n = 0
1626     n += self.lengthString(len(self.email_))
1627     n += self.lengthString(len(self.auth_domain_))
1628     if (self.has_nickname_): n += 1 + self.lengthString(len(self.nickname_))
1629     n += self.lengthVarInt64(self.gaiaid_)
1630     if (self.has_obfuscated_gaiaid_): n += 1 + self.lengthString(len(self.obfuscated_gaiaid_))
1631     return n + 3
1632
1633   def Clear(self):
1634     self.clear_email()
1635     self.clear_auth_domain()
1636     self.clear_nickname()
1637     self.clear_gaiaid()
1638     self.clear_obfuscated_gaiaid()
1639
1640   def OutputUnchecked(self, out):
1641     out.putVarInt32(10)
1642     out.putPrefixedString(self.email_)
1643     out.putVarInt32(18)
1644     out.putPrefixedString(self.auth_domain_)
1645     if (self.has_nickname_):
1646       out.putVarInt32(26)
1647       out.putPrefixedString(self.nickname_)
1648     out.putVarInt32(32)
1649     out.putVarInt64(self.gaiaid_)
1650     if (self.has_obfuscated_gaiaid_):
1651       out.putVarInt32(42)
1652       out.putPrefixedString(self.obfuscated_gaiaid_)
1653
1654   def TryMerge(self, d):
1655     while d.avail() > 0:
1656       tt = d.getVarInt32()
1657       if tt == 10:
1658         self.set_email(d.getPrefixedString())
1659         continue
1660       if tt == 18:
1661         self.set_auth_domain(d.getPrefixedString())
1662         continue
1663       if tt == 26:
1664         self.set_nickname(d.getPrefixedString())
1665         continue
1666       if tt == 32:
1667         self.set_gaiaid(d.getVarInt64())
1668         continue
1669       if tt == 42:
1670         self.set_obfuscated_gaiaid(d.getPrefixedString())
1671         continue
1672       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1673       d.skipData(tt)
1674
1675
1676   def __str__(self, prefix="", printElemNumber=0):
1677     res=""
1678     if self.has_email_: res+=prefix+("email: %s\n" % self.DebugFormatString(self.email_))
1679     if self.has_auth_domain_: res+=prefix+("auth_domain: %s\n" % self.DebugFormatString(self.auth_domain_))
1680     if self.has_nickname_: res+=prefix+("nickname: %s\n" % self.DebugFormatString(self.nickname_))
1681     if self.has_gaiaid_: res+=prefix+("gaiaid: %s\n" % self.DebugFormatInt64(self.gaiaid_))
1682     if self.has_obfuscated_gaiaid_: res+=prefix+("obfuscated_gaiaid: %s\n" % self.DebugFormatString(self.obfuscated_gaiaid_))
1683     return res
1684
1685   kemail = 1
1686   kauth_domain = 2
1687   knickname = 3
1688   kgaiaid = 4
1689   kobfuscated_gaiaid = 5
1690
1691   _TEXT = (
1692    "ErrorCode",
1693    "email",
1694    "auth_domain",
1695    "nickname",
1696    "gaiaid",
1697    "obfuscated_gaiaid",
1698   )
1699
1700   _TYPES = (
1701    ProtocolBuffer.Encoder.NUMERIC,
1702    ProtocolBuffer.Encoder.STRING,
1703
1704    ProtocolBuffer.Encoder.STRING,
1705
1706    ProtocolBuffer.Encoder.STRING,
1707
1708    ProtocolBuffer.Encoder.NUMERIC,
1709
1710    ProtocolBuffer.Encoder.STRING,
1711
1712   )
1713
1714   _STYLE = """"""
1715   _STYLE_CONTENT_TYPE = """"""
1716 class EntityProto(ProtocolBuffer.ProtocolMessage):
1717
1718   GD_CONTACT   =    1
1719   GD_EVENT     =    2
1720   GD_MESSAGE   =    3
1721
1722   _Kind_NAMES = {
1723     1: "GD_CONTACT",
1724     2: "GD_EVENT",
1725     3: "GD_MESSAGE",
1726   }
1727
1728   def Kind_Name(cls, x): return cls._Kind_NAMES.get(x, "")
1729   Kind_Name = classmethod(Kind_Name)
1730
1731   has_key_ = 0
1732   has_entity_group_ = 0
1733   has_owner_ = 0
1734   owner_ = None
1735   has_kind_ = 0
1736   kind_ = 0
1737   has_kind_uri_ = 0
1738   kind_uri_ = ""
1739
1740   def __init__(self, contents=None):
1741     self.key_ = Reference()
1742     self.entity_group_ = Path()
1743     self.property_ = []
1744     self.raw_property_ = []
1745     self.lazy_init_lock_ = thread.allocate_lock()
1746     if contents is not None: self.MergeFromString(contents)
1747
1748   def key(self): return self.key_
1749
1750   def mutable_key(self): self.has_key_ = 1; return self.key_
1751
1752   def clear_key(self):self.has_key_ = 0; self.key_.Clear()
1753
1754   def has_key(self): return self.has_key_
1755
1756   def entity_group(self): return self.entity_group_
1757
1758   def mutable_entity_group(self): self.has_entity_group_ = 1; return self.entity_group_
1759
1760   def clear_entity_group(self):self.has_entity_group_ = 0; self.entity_group_.Clear()
1761
1762   def has_entity_group(self): return self.has_entity_group_
1763
1764   def owner(self):
1765     if self.owner_ is None:
1766       self.lazy_init_lock_.acquire()
1767       try:
1768         if self.owner_ is None: self.owner_ = User()
1769       finally:
1770         self.lazy_init_lock_.release()
1771     return self.owner_
1772
1773   def mutable_owner(self): self.has_owner_ = 1; return self.owner()
1774
1775   def clear_owner(self):
1776     if self.has_owner_:
1777       self.has_owner_ = 0;
1778       if self.owner_ is not None: self.owner_.Clear()
1779
1780   def has_owner(self): return self.has_owner_
1781
1782   def kind(self): return self.kind_
1783
1784   def set_kind(self, x):
1785     self.has_kind_ = 1
1786     self.kind_ = x
1787
1788   def clear_kind(self):
1789     if self.has_kind_:
1790       self.has_kind_ = 0
1791       self.kind_ = 0
1792
1793   def has_kind(self): return self.has_kind_
1794
1795   def kind_uri(self): return self.kind_uri_
1796
1797   def set_kind_uri(self, x):
1798     self.has_kind_uri_ = 1
1799     self.kind_uri_ = x
1800
1801   def clear_kind_uri(self):
1802     if self.has_kind_uri_:
1803       self.has_kind_uri_ = 0
1804       self.kind_uri_ = ""
1805
1806   def has_kind_uri(self): return self.has_kind_uri_
1807
1808   def property_size(self): return len(self.property_)
1809   def property_list(self): return self.property_
1810
1811   def property(self, i):
1812     return self.property_[i]
1813
1814   def mutable_property(self, i):
1815     return self.property_[i]
1816
1817   def add_property(self):
1818     x = Property()
1819     self.property_.append(x)
1820     return x
1821
1822   def clear_property(self):
1823     self.property_ = []
1824   def raw_property_size(self): return len(self.raw_property_)
1825   def raw_property_list(self): return self.raw_property_
1826
1827   def raw_property(self, i):
1828     return self.raw_property_[i]
1829
1830   def mutable_raw_property(self, i):
1831     return self.raw_property_[i]
1832
1833   def add_raw_property(self):
1834     x = Property()
1835     self.raw_property_.append(x)
1836     return x
1837
1838   def clear_raw_property(self):
1839     self.raw_property_ = []
1840
1841   def MergeFrom(self, x):
1842     assert x is not self
1843     if (x.has_key()): self.mutable_key().MergeFrom(x.key())
1844     if (x.has_entity_group()): self.mutable_entity_group().MergeFrom(x.entity_group())
1845     if (x.has_owner()): self.mutable_owner().MergeFrom(x.owner())
1846     if (x.has_kind()): self.set_kind(x.kind())
1847     if (x.has_kind_uri()): self.set_kind_uri(x.kind_uri())
1848     for i in xrange(x.property_size()): self.add_property().CopyFrom(x.property(i))
1849     for i in xrange(x.raw_property_size()): self.add_raw_property().CopyFrom(x.raw_property(i))
1850
1851   def Equals(self, x):
1852     if x is self: return 1
1853     if self.has_key_ != x.has_key_: return 0
1854     if self.has_key_ and self.key_ != x.key_: return 0
1855     if self.has_entity_group_ != x.has_entity_group_: return 0
1856     if self.has_entity_group_ and self.entity_group_ != x.entity_group_: return 0
1857     if self.has_owner_ != x.has_owner_: return 0
1858     if self.has_owner_ and self.owner_ != x.owner_: return 0
1859     if self.has_kind_ != x.has_kind_: return 0
1860     if self.has_kind_ and self.kind_ != x.kind_: return 0
1861     if self.has_kind_uri_ != x.has_kind_uri_: return 0
1862     if self.has_kind_uri_ and self.kind_uri_ != x.kind_uri_: return 0
1863     if len(self.property_) != len(x.property_): return 0
1864     for e1, e2 in zip(self.property_, x.property_):
1865       if e1 != e2: return 0
1866     if len(self.raw_property_) != len(x.raw_property_): return 0
1867     for e1, e2 in zip(self.raw_property_, x.raw_property_):
1868       if e1 != e2: return 0
1869     return 1
1870
1871   def IsInitialized(self, debug_strs=None):
1872     initialized = 1
1873     if (not self.has_key_):
1874       initialized = 0
1875       if debug_strs is not None:
1876         debug_strs.append('Required field: key not set.')
1877     elif not self.key_.IsInitialized(debug_strs): initialized = 0
1878     if (not self.has_entity_group_):
1879       initialized = 0
1880       if debug_strs is not None:
1881         debug_strs.append('Required field: entity_group not set.')
1882     elif not self.entity_group_.IsInitialized(debug_strs): initialized = 0
1883     if (self.has_owner_ and not self.owner_.IsInitialized(debug_strs)): initialized = 0
1884     for p in self.property_:
1885       if not p.IsInitialized(debug_strs): initialized=0
1886     for p in self.raw_property_:
1887       if not p.IsInitialized(debug_strs): initialized=0
1888     return initialized
1889
1890   def ByteSize(self):
1891     n = 0
1892     n += self.lengthString(self.key_.ByteSize())
1893     n += self.lengthString(self.entity_group_.ByteSize())
1894     if (self.has_owner_): n += 2 + self.lengthString(self.owner_.ByteSize())
1895     if (self.has_kind_): n += 1 + self.lengthVarInt64(self.kind_)
1896     if (self.has_kind_uri_): n += 1 + self.lengthString(len(self.kind_uri_))
1897     n += 1 * len(self.property_)
1898     for i in xrange(len(self.property_)): n += self.lengthString(self.property_[i].ByteSize())
1899     n += 1 * len(self.raw_property_)
1900     for i in xrange(len(self.raw_property_)): n += self.lengthString(self.raw_property_[i].ByteSize())
1901     return n + 3
1902
1903   def Clear(self):
1904     self.clear_key()
1905     self.clear_entity_group()
1906     self.clear_owner()
1907     self.clear_kind()
1908     self.clear_kind_uri()
1909     self.clear_property()
1910     self.clear_raw_property()
1911
1912   def OutputUnchecked(self, out):
1913     if (self.has_kind_):
1914       out.putVarInt32(32)
1915       out.putVarInt32(self.kind_)
1916     if (self.has_kind_uri_):
1917       out.putVarInt32(42)
1918       out.putPrefixedString(self.kind_uri_)
1919     out.putVarInt32(106)
1920     out.putVarInt32(self.key_.ByteSize())
1921     self.key_.OutputUnchecked(out)
1922     for i in xrange(len(self.property_)):
1923       out.putVarInt32(114)
1924       out.putVarInt32(self.property_[i].ByteSize())
1925       self.property_[i].OutputUnchecked(out)
1926     for i in xrange(len(self.raw_property_)):
1927       out.putVarInt32(122)
1928       out.putVarInt32(self.raw_property_[i].ByteSize())
1929       self.raw_property_[i].OutputUnchecked(out)
1930     out.putVarInt32(130)
1931     out.putVarInt32(self.entity_group_.ByteSize())
1932     self.entity_group_.OutputUnchecked(out)
1933     if (self.has_owner_):
1934       out.putVarInt32(138)
1935       out.putVarInt32(self.owner_.ByteSize())
1936       self.owner_.OutputUnchecked(out)
1937
1938   def TryMerge(self, d):
1939     while d.avail() > 0:
1940       tt = d.getVarInt32()
1941       if tt == 32:
1942         self.set_kind(d.getVarInt32())
1943         continue
1944       if tt == 42:
1945         self.set_kind_uri(d.getPrefixedString())
1946         continue
1947       if tt == 106:
1948         length = d.getVarInt32()
1949         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
1950         d.skip(length)
1951         self.mutable_key().TryMerge(tmp)
1952         continue
1953       if tt == 114:
1954         length = d.getVarInt32()
1955         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
1956         d.skip(length)
1957         self.add_property().TryMerge(tmp)
1958         continue
1959       if tt == 122:
1960         length = d.getVarInt32()
1961         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
1962         d.skip(length)
1963         self.add_raw_property().TryMerge(tmp)
1964         continue
1965       if tt == 130:
1966         length = d.getVarInt32()
1967         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
1968         d.skip(length)
1969         self.mutable_entity_group().TryMerge(tmp)
1970         continue
1971       if tt == 138:
1972         length = d.getVarInt32()
1973         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
1974         d.skip(length)
1975         self.mutable_owner().TryMerge(tmp)
1976         continue
1977       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1978       d.skipData(tt)
1979
1980
1981   def __str__(self, prefix="", printElemNumber=0):
1982     res=""
1983     if self.has_key_:
1984       res+=prefix+"key <\n"
1985       res+=self.key_.__str__(prefix + "  ", printElemNumber)
1986       res+=prefix+">\n"
1987     if self.has_entity_group_:
1988       res+=prefix+"entity_group <\n"
1989       res+=self.entity_group_.__str__(prefix + "  ", printElemNumber)
1990       res+=prefix+">\n"
1991     if self.has_owner_:
1992       res+=prefix+"owner <\n"
1993       res+=self.owner_.__str__(prefix + "  ", printElemNumber)
1994       res+=prefix+">\n"
1995     if self.has_kind_: res+=prefix+("kind: %s\n" % self.DebugFormatInt32(self.kind_))
1996     if self.has_kind_uri_: res+=prefix+("kind_uri: %s\n" % self.DebugFormatString(self.kind_uri_))
1997     cnt=0
1998     for e in self.property_:
1999       elm=""
2000       if printElemNumber: elm="(%d)" % cnt
2001       res+=prefix+("property%s <\n" % elm)
2002       res+=e.__str__(prefix + "  ", printElemNumber)
2003       res+=prefix+">\n"
2004       cnt+=1
2005     cnt=0
2006     for e in self.raw_property_:
2007       elm=""
2008       if printElemNumber: elm="(%d)" % cnt
2009       res+=prefix+("raw_property%s <\n" % elm)
2010       res+=e.__str__(prefix + "  ", printElemNumber)
2011       res+=prefix+">\n"
2012       cnt+=1
2013     return res
2014
2015   kkey = 13
2016   kentity_group = 16
2017   kowner = 17
2018   kkind = 4
2019   kkind_uri = 5
2020   kproperty = 14
2021   kraw_property = 15
2022
2023   _TEXT = (
2024    "ErrorCode",
2025    None,
2026    None,
2027    None,
2028    "kind",
2029    "kind_uri",
2030    None,
2031    None,
2032    None,
2033    None,
2034    None,
2035    None,
2036    None,
2037    "key",
2038    "property",
2039    "raw_property",
2040    "entity_group",
2041    "owner",
2042   )
2043
2044   _TYPES = (
2045    ProtocolBuffer.Encoder.NUMERIC,
2046    ProtocolBuffer.Encoder.MAX_TYPE,
2047
2048    ProtocolBuffer.Encoder.MAX_TYPE,
2049
2050    ProtocolBuffer.Encoder.MAX_TYPE,
2051
2052    ProtocolBuffer.Encoder.NUMERIC,
2053
2054    ProtocolBuffer.Encoder.STRING,
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.MAX_TYPE,
2069
2070    ProtocolBuffer.Encoder.STRING,
2071
2072    ProtocolBuffer.Encoder.STRING,
2073
2074    ProtocolBuffer.Encoder.STRING,
2075
2076    ProtocolBuffer.Encoder.STRING,
2077
2078    ProtocolBuffer.Encoder.STRING,
2079
2080   )
2081
2082   _STYLE = """"""
2083   _STYLE_CONTENT_TYPE = """"""
2084 class CompositeProperty(ProtocolBuffer.ProtocolMessage):
2085   has_index_id_ = 0
2086   index_id_ = 0
2087
2088   def __init__(self, contents=None):
2089     self.value_ = []
2090     if contents is not None: self.MergeFromString(contents)
2091
2092   def index_id(self): return self.index_id_
2093
2094   def set_index_id(self, x):
2095     self.has_index_id_ = 1
2096     self.index_id_ = x
2097
2098   def clear_index_id(self):
2099     if self.has_index_id_:
2100       self.has_index_id_ = 0
2101       self.index_id_ = 0
2102
2103   def has_index_id(self): return self.has_index_id_
2104
2105   def value_size(self): return len(self.value_)
2106   def value_list(self): return self.value_
2107
2108   def value(self, i):
2109     return self.value_[i]
2110
2111   def set_value(self, i, x):
2112     self.value_[i] = x
2113
2114   def add_value(self, x):
2115     self.value_.append(x)
2116
2117   def clear_value(self):
2118     self.value_ = []
2119
2120
2121   def MergeFrom(self, x):
2122     assert x is not self
2123     if (x.has_index_id()): self.set_index_id(x.index_id())
2124     for i in xrange(x.value_size()): self.add_value(x.value(i))
2125
2126   def Equals(self, x):
2127     if x is self: return 1
2128     if self.has_index_id_ != x.has_index_id_: return 0
2129     if self.has_index_id_ and self.index_id_ != x.index_id_: return 0
2130     if len(self.value_) != len(x.value_): return 0
2131     for e1, e2 in zip(self.value_, x.value_):
2132       if e1 != e2: return 0
2133     return 1
2134
2135   def IsInitialized(self, debug_strs=None):
2136     initialized = 1
2137     if (not self.has_index_id_):
2138       initialized = 0
2139       if debug_strs is not None:
2140         debug_strs.append('Required field: index_id not set.')
2141     return initialized
2142
2143   def ByteSize(self):
2144     n = 0
2145     n += self.lengthVarInt64(self.index_id_)
2146     n += 1 * len(self.value_)
2147     for i in xrange(len(self.value_)): n += self.lengthString(len(self.value_[i]))
2148     return n + 1
2149
2150   def Clear(self):
2151     self.clear_index_id()
2152     self.clear_value()
2153
2154   def OutputUnchecked(self, out):
2155     out.putVarInt32(8)
2156     out.putVarInt64(self.index_id_)
2157     for i in xrange(len(self.value_)):
2158       out.putVarInt32(18)
2159       out.putPrefixedString(self.value_[i])
2160
2161   def TryMerge(self, d):
2162     while d.avail() > 0:
2163       tt = d.getVarInt32()
2164       if tt == 8:
2165         self.set_index_id(d.getVarInt64())
2166         continue
2167       if tt == 18:
2168         self.add_value(d.getPrefixedString())
2169         continue
2170       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
2171       d.skipData(tt)
2172
2173
2174   def __str__(self, prefix="", printElemNumber=0):
2175     res=""
2176     if self.has_index_id_: res+=prefix+("index_id: %s\n" % self.DebugFormatInt64(self.index_id_))
2177     cnt=0
2178     for e in self.value_:
2179       elm=""
2180       if printElemNumber: elm="(%d)" % cnt
2181       res+=prefix+("value%s: %s\n" % (elm, self.DebugFormatString(e)))
2182       cnt+=1
2183     return res
2184
2185   kindex_id = 1
2186   kvalue = 2
2187
2188   _TEXT = (
2189    "ErrorCode",
2190    "index_id",
2191    "value",
2192   )
2193
2194   _TYPES = (
2195    ProtocolBuffer.Encoder.NUMERIC,
2196    ProtocolBuffer.Encoder.NUMERIC,
2197
2198    ProtocolBuffer.Encoder.STRING,
2199
2200   )
2201
2202   _STYLE = """"""
2203   _STYLE_CONTENT_TYPE = """"""
2204 class Index_Property(ProtocolBuffer.ProtocolMessage):
2205
2206   ASCENDING    =    1
2207   DESCENDING   =    2
2208
2209   _Direction_NAMES = {
2210     1: "ASCENDING",
2211     2: "DESCENDING",
2212   }
2213
2214   def Direction_Name(cls, x): return cls._Direction_NAMES.get(x, "")
2215   Direction_Name = classmethod(Direction_Name)
2216
2217   has_name_ = 0
2218   name_ = ""
2219   has_direction_ = 0
2220   direction_ = 1
2221
2222   def __init__(self, contents=None):
2223     if contents is not None: self.MergeFromString(contents)
2224
2225   def name(self): return self.name_
2226
2227   def set_name(self, x):
2228     self.has_name_ = 1
2229     self.name_ = x
2230
2231   def clear_name(self):
2232     if self.has_name_:
2233       self.has_name_ = 0
2234       self.name_ = ""
2235
2236   def has_name(self): return self.has_name_
2237
2238   def direction(self): return self.direction_
2239
2240   def set_direction(self, x):
2241     self.has_direction_ = 1
2242     self.direction_ = x
2243
2244   def clear_direction(self):
2245     if self.has_direction_:
2246       self.has_direction_ = 0
2247       self.direction_ = 1
2248
2249   def has_direction(self): return self.has_direction_
2250
2251
2252   def MergeFrom(self, x):
2253     assert x is not self
2254     if (x.has_name()): self.set_name(x.name())
2255     if (x.has_direction()): self.set_direction(x.direction())
2256
2257   def Equals(self, x):
2258     if x is self: return 1
2259     if self.has_name_ != x.has_name_: return 0
2260     if self.has_name_ and self.name_ != x.name_: return 0
2261     if self.has_direction_ != x.has_direction_: return 0
2262     if self.has_direction_ and self.direction_ != x.direction_: return 0
2263     return 1
2264
2265   def IsInitialized(self, debug_strs=None):
2266     initialized = 1
2267     if (not self.has_name_):
2268       initialized = 0
2269       if debug_strs is not None:
2270         debug_strs.append('Required field: name not set.')
2271     return initialized
2272
2273   def ByteSize(self):
2274     n = 0
2275     n += self.lengthString(len(self.name_))
2276     if (self.has_direction_): n += 1 + self.lengthVarInt64(self.direction_)
2277     return n + 1
2278
2279   def Clear(self):
2280     self.clear_name()
2281     self.clear_direction()
2282
2283   def OutputUnchecked(self, out):
2284     out.putVarInt32(26)
2285     out.putPrefixedString(self.name_)
2286     if (self.has_direction_):
2287       out.putVarInt32(32)
2288       out.putVarInt32(self.direction_)
2289
2290   def TryMerge(self, d):
2291     while 1:
2292       tt = d.getVarInt32()
2293       if tt == 20: break
2294       if tt == 26:
2295         self.set_name(d.getPrefixedString())
2296         continue
2297       if tt == 32:
2298         self.set_direction(d.getVarInt32())
2299         continue
2300       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
2301       d.skipData(tt)
2302
2303
2304   def __str__(self, prefix="", printElemNumber=0):
2305     res=""
2306     if self.has_name_: res+=prefix+("name: %s\n" % self.DebugFormatString(self.name_))
2307     if self.has_direction_: res+=prefix+("direction: %s\n" % self.DebugFormatInt32(self.direction_))
2308     return res
2309
2310 class Index(ProtocolBuffer.ProtocolMessage):
2311   has_entity_type_ = 0
2312   entity_type_ = ""
2313   has_ancestor_ = 0
2314   ancestor_ = 0
2315
2316   def __init__(self, contents=None):
2317     self.property_ = []
2318     if contents is not None: self.MergeFromString(contents)
2319
2320   def entity_type(self): return self.entity_type_
2321
2322   def set_entity_type(self, x):
2323     self.has_entity_type_ = 1
2324     self.entity_type_ = x
2325
2326   def clear_entity_type(self):
2327     if self.has_entity_type_:
2328       self.has_entity_type_ = 0
2329       self.entity_type_ = ""
2330
2331   def has_entity_type(self): return self.has_entity_type_
2332
2333   def ancestor(self): return self.ancestor_
2334
2335   def set_ancestor(self, x):
2336     self.has_ancestor_ = 1
2337     self.ancestor_ = x
2338
2339   def clear_ancestor(self):
2340     if self.has_ancestor_:
2341       self.has_ancestor_ = 0
2342       self.ancestor_ = 0
2343
2344   def has_ancestor(self): return self.has_ancestor_
2345
2346   def property_size(self): return len(self.property_)
2347   def property_list(self): return self.property_
2348
2349   def property(self, i):
2350     return self.property_[i]
2351
2352   def mutable_property(self, i):
2353     return self.property_[i]
2354
2355   def add_property(self):
2356     x = Index_Property()
2357     self.property_.append(x)
2358     return x
2359
2360   def clear_property(self):
2361     self.property_ = []
2362
2363   def MergeFrom(self, x):
2364     assert x is not self
2365     if (x.has_entity_type()): self.set_entity_type(x.entity_type())
2366     if (x.has_ancestor()): self.set_ancestor(x.ancestor())
2367     for i in xrange(x.property_size()): self.add_property().CopyFrom(x.property(i))
2368
2369   def Equals(self, x):
2370     if x is self: return 1
2371     if self.has_entity_type_ != x.has_entity_type_: return 0
2372     if self.has_entity_type_ and self.entity_type_ != x.entity_type_: return 0
2373     if self.has_ancestor_ != x.has_ancestor_: return 0
2374     if self.has_ancestor_ and self.ancestor_ != x.ancestor_: return 0
2375     if len(self.property_) != len(x.property_): return 0
2376     for e1, e2 in zip(self.property_, x.property_):
2377       if e1 != e2: return 0
2378     return 1
2379
2380   def IsInitialized(self, debug_strs=None):
2381     initialized = 1
2382     if (not self.has_entity_type_):
2383       initialized = 0
2384       if debug_strs is not None:
2385         debug_strs.append('Required field: entity_type not set.')
2386     if (not self.has_ancestor_):
2387       initialized = 0
2388       if debug_strs is not None:
2389         debug_strs.append('Required field: ancestor not set.')
2390     for p in self.property_:
2391       if not p.IsInitialized(debug_strs): initialized=0
2392     return initialized
2393
2394   def ByteSize(self):
2395     n = 0
2396     n += self.lengthString(len(self.entity_type_))
2397     n += 2 * len(self.property_)
2398     for i in xrange(len(self.property_)): n += self.property_[i].ByteSize()
2399     return n + 3
2400
2401   def Clear(self):
2402     self.clear_entity_type()
2403     self.clear_ancestor()
2404     self.clear_property()
2405
2406   def OutputUnchecked(self, out):
2407     out.putVarInt32(10)
2408     out.putPrefixedString(self.entity_type_)
2409     for i in xrange(len(self.property_)):
2410       out.putVarInt32(19)
2411       self.property_[i].OutputUnchecked(out)
2412       out.putVarInt32(20)
2413     out.putVarInt32(40)
2414     out.putBoolean(self.ancestor_)
2415
2416   def TryMerge(self, d):
2417     while d.avail() > 0:
2418       tt = d.getVarInt32()
2419       if tt == 10:
2420         self.set_entity_type(d.getPrefixedString())
2421         continue
2422       if tt == 19:
2423         self.add_property().TryMerge(d)
2424         continue
2425       if tt == 40:
2426         self.set_ancestor(d.getBoolean())
2427         continue
2428       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
2429       d.skipData(tt)
2430
2431
2432   def __str__(self, prefix="", printElemNumber=0):
2433     res=""
2434     if self.has_entity_type_: res+=prefix+("entity_type: %s\n" % self.DebugFormatString(self.entity_type_))
2435     if self.has_ancestor_: res+=prefix+("ancestor: %s\n" % self.DebugFormatBool(self.ancestor_))
2436     cnt=0
2437     for e in self.property_:
2438       elm=""
2439       if printElemNumber: elm="(%d)" % cnt
2440       res+=prefix+("Property%s {\n" % elm)
2441       res+=e.__str__(prefix + "  ", printElemNumber)
2442       res+=prefix+"}\n"
2443       cnt+=1
2444     return res
2445
2446   kentity_type = 1
2447   kancestor = 5
2448   kPropertyGroup = 2
2449   kPropertyname = 3
2450   kPropertydirection = 4
2451
2452   _TEXT = (
2453    "ErrorCode",
2454    "entity_type",
2455    "Property",
2456    "name",
2457    "direction",
2458    "ancestor",
2459   )
2460
2461   _TYPES = (
2462    ProtocolBuffer.Encoder.NUMERIC,
2463    ProtocolBuffer.Encoder.STRING,
2464
2465    ProtocolBuffer.Encoder.STARTGROUP,
2466
2467    ProtocolBuffer.Encoder.STRING,
2468
2469    ProtocolBuffer.Encoder.NUMERIC,
2470
2471    ProtocolBuffer.Encoder.NUMERIC,
2472
2473   )
2474
2475   _STYLE = """"""
2476   _STYLE_CONTENT_TYPE = """"""
2477 class CompositeIndex(ProtocolBuffer.ProtocolMessage):
2478
2479   WRITE_ONLY   =    1
2480   READ_WRITE   =    2
2481   DELETED      =    3
2482   ERROR        =    4
2483
2484   _State_NAMES = {
2485     1: "WRITE_ONLY",
2486     2: "READ_WRITE",
2487     3: "DELETED",
2488     4: "ERROR",
2489   }
2490
2491   def State_Name(cls, x): return cls._State_NAMES.get(x, "")
2492   State_Name = classmethod(State_Name)
2493
2494   has_app_id_ = 0
2495   app_id_ = ""
2496   has_id_ = 0
2497   id_ = 0
2498   has_definition_ = 0
2499   has_state_ = 0
2500   state_ = 0
2501
2502   def __init__(self, contents=None):
2503     self.definition_ = Index()
2504     if contents is not None: self.MergeFromString(contents)
2505
2506   def app_id(self): return self.app_id_
2507
2508   def set_app_id(self, x):
2509     self.has_app_id_ = 1
2510     self.app_id_ = x
2511
2512   def clear_app_id(self):
2513     if self.has_app_id_:
2514       self.has_app_id_ = 0
2515       self.app_id_ = ""
2516
2517   def has_app_id(self): return self.has_app_id_
2518
2519   def id(self): return self.id_
2520
2521   def set_id(self, x):
2522     self.has_id_ = 1
2523     self.id_ = x
2524
2525   def clear_id(self):
2526     if self.has_id_:
2527       self.has_id_ = 0
2528       self.id_ = 0
2529
2530   def has_id(self): return self.has_id_
2531
2532   def definition(self): return self.definition_
2533
2534   def mutable_definition(self): self.has_definition_ = 1; return self.definition_
2535
2536   def clear_definition(self):self.has_definition_ = 0; self.definition_.Clear()
2537
2538   def has_definition(self): return self.has_definition_
2539
2540   def state(self): return self.state_
2541
2542   def set_state(self, x):
2543     self.has_state_ = 1
2544     self.state_ = x
2545
2546   def clear_state(self):
2547     if self.has_state_:
2548       self.has_state_ = 0
2549       self.state_ = 0
2550
2551   def has_state(self): return self.has_state_
2552
2553
2554   def MergeFrom(self, x):
2555     assert x is not self
2556     if (x.has_app_id()): self.set_app_id(x.app_id())
2557     if (x.has_id()): self.set_id(x.id())
2558     if (x.has_definition()): self.mutable_definition().MergeFrom(x.definition())
2559     if (x.has_state()): self.set_state(x.state())
2560
2561   def Equals(self, x):
2562     if x is self: return 1
2563     if self.has_app_id_ != x.has_app_id_: return 0
2564     if self.has_app_id_ and self.app_id_ != x.app_id_: return 0
2565     if self.has_id_ != x.has_id_: return 0
2566     if self.has_id_ and self.id_ != x.id_: return 0
2567     if self.has_definition_ != x.has_definition_: return 0
2568     if self.has_definition_ and self.definition_ != x.definition_: return 0
2569     if self.has_state_ != x.has_state_: return 0
2570     if self.has_state_ and self.state_ != x.state_: return 0
2571     return 1
2572
2573   def IsInitialized(self, debug_strs=None):
2574     initialized = 1
2575     if (not self.has_app_id_):
2576       initialized = 0
2577       if debug_strs is not None:
2578         debug_strs.append('Required field: app_id not set.')
2579     if (not self.has_id_):
2580       initialized = 0
2581       if debug_strs is not None:
2582         debug_strs.append('Required field: id not set.')
2583     if (not self.has_definition_):
2584       initialized = 0
2585       if debug_strs is not None:
2586         debug_strs.append('Required field: definition not set.')
2587     elif not self.definition_.IsInitialized(debug_strs): initialized = 0
2588     if (not self.has_state_):
2589       initialized = 0
2590       if debug_strs is not None:
2591         debug_strs.append('Required field: state not set.')
2592     return initialized
2593
2594   def ByteSize(self):
2595     n = 0
2596     n += self.lengthString(len(self.app_id_))
2597     n += self.lengthVarInt64(self.id_)
2598     n += self.lengthString(self.definition_.ByteSize())
2599     n += self.lengthVarInt64(self.state_)
2600     return n + 4
2601
2602   def Clear(self):
2603     self.clear_app_id()
2604     self.clear_id()
2605     self.clear_definition()
2606     self.clear_state()
2607
2608   def OutputUnchecked(self, out):
2609     out.putVarInt32(10)
2610     out.putPrefixedString(self.app_id_)
2611     out.putVarInt32(16)
2612     out.putVarInt64(self.id_)
2613     out.putVarInt32(26)
2614     out.putVarInt32(self.definition_.ByteSize())
2615     self.definition_.OutputUnchecked(out)
2616     out.putVarInt32(32)
2617     out.putVarInt32(self.state_)
2618
2619   def TryMerge(self, d):
2620     while d.avail() > 0:
2621       tt = d.getVarInt32()
2622       if tt == 10:
2623         self.set_app_id(d.getPrefixedString())
2624         continue
2625       if tt == 16:
2626         self.set_id(d.getVarInt64())
2627         continue
2628       if tt == 26:
2629         length = d.getVarInt32()
2630         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
2631         d.skip(length)
2632         self.mutable_definition().TryMerge(tmp)
2633         continue
2634       if tt == 32:
2635         self.set_state(d.getVarInt32())
2636         continue
2637       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
2638       d.skipData(tt)
2639
2640
2641   def __str__(self, prefix="", printElemNumber=0):
2642     res=""
2643     if self.has_app_id_: res+=prefix+("app_id: %s\n" % self.DebugFormatString(self.app_id_))
2644     if self.has_id_: res+=prefix+("id: %s\n" % self.DebugFormatInt64(self.id_))
2645     if self.has_definition_:
2646       res+=prefix+"definition <\n"
2647       res+=self.definition_.__str__(prefix + "  ", printElemNumber)
2648       res+=prefix+">\n"
2649     if self.has_state_: res+=prefix+("state: %s\n" % self.DebugFormatInt32(self.state_))
2650     return res
2651
2652   kapp_id = 1
2653   kid = 2
2654   kdefinition = 3
2655   kstate = 4
2656
2657   _TEXT = (
2658    "ErrorCode",
2659    "app_id",
2660    "id",
2661    "definition",
2662    "state",
2663   )
2664
2665   _TYPES = (
2666    ProtocolBuffer.Encoder.NUMERIC,
2667    ProtocolBuffer.Encoder.STRING,
2668
2669    ProtocolBuffer.Encoder.NUMERIC,
2670
2671    ProtocolBuffer.Encoder.STRING,
2672
2673    ProtocolBuffer.Encoder.NUMERIC,
2674
2675   )
2676
2677   _STYLE = """"""
2678   _STYLE_CONTENT_TYPE = """"""
2679
2680 __all__ = ['PropertyValue','PropertyValue_ReferenceValuePathElement','PropertyValue_PointValue','PropertyValue_UserValue','PropertyValue_ReferenceValue','Property','Path','Path_Element','Reference','User','EntityProto','CompositeProperty','Index','Index_Property','CompositeIndex']