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   def __init__(self, contents=None):

    27     self.type_ = ""

    28     self.id_ = 0

    29     self.name_ = ""

    30     self.has_type_ = 0

    31     self.has_id_ = 0

    32     self.has_name_ = 0

    33     if contents is not None: self.MergeFromString(contents)

    34 

    35   def type(self): return self.type_

    36 

    37   def set_type(self, x):

    38     self.has_type_ = 1

    39     self.type_ = x

    40 

    41   def clear_type(self):

    42     self.has_type_ = 0

    43     self.type_ = ""

    44 

    45   def has_type(self): return self.has_type_

    46 

    47   def id(self): return self.id_

    48 

    49   def set_id(self, x):

    50     self.has_id_ = 1

    51     self.id_ = x

    52 

    53   def clear_id(self):

    54     self.has_id_ = 0

    55     self.id_ = 0

    56 

    57   def has_id(self): return self.has_id_

    58 

    59   def name(self): return self.name_

    60 

    61   def set_name(self, x):

    62     self.has_name_ = 1

    63     self.name_ = x

    64 

    65   def clear_name(self):

    66     self.has_name_ = 0

    67     self.name_ = ""

    68 

    69   def has_name(self): return self.has_name_

    70 

    71 

    72   def MergeFrom(self, x):

    73     assert x is not self

    74     if (x.has_type()): self.set_type(x.type())

    75     if (x.has_id()): self.set_id(x.id())

    76     if (x.has_name()): self.set_name(x.name())

    77 

    78   def Equals(self, x):

    79     if x is self: return 1

    80     if self.has_type_ != x.has_type_: return 0

    81     if self.has_type_ and self.type_ != x.type_: return 0

    82     if self.has_id_ != x.has_id_: return 0

    83     if self.has_id_ and self.id_ != x.id_: return 0

    84     if self.has_name_ != x.has_name_: return 0

    85     if self.has_name_ and self.name_ != x.name_: return 0

    86     return 1

    87 

    88   def __eq__(self, other):

    89     return (other is not None) and (other.__class__ == self.__class__) and self.Equals(other)

    90 

    91   def __ne__(self, other):

    92     return not (self == other)

    93 

    94   def IsInitialized(self, debug_strs=None):

    95     initialized = 1

    96     if (not self.has_type_):

    97       initialized = 0

    98       if debug_strs is not None:

    99         debug_strs.append('Required field: type not set.')

   100     return initialized

   101 

   102   def ByteSize(self):

   103     n = 0

   104     n += self.lengthString(len(self.type_))

   105     if (self.has_id_): n += 2 + self.lengthVarInt64(self.id_)

   106     if (self.has_name_): n += 2 + self.lengthString(len(self.name_))

   107     return n + 1

   108 

   109   def Clear(self):

   110     self.clear_type()

   111     self.clear_id()

   112     self.clear_name()

   113 

   114   def OutputUnchecked(self, out):

   115     out.putVarInt32(122)

   116     out.putPrefixedString(self.type_)

   117     if (self.has_id_):

   118       out.putVarInt32(128)

   119       out.putVarInt64(self.id_)

   120     if (self.has_name_):

   121       out.putVarInt32(138)

   122       out.putPrefixedString(self.name_)

   123 

   124   def TryMerge(self, d):

   125     while 1:

   126       tt = d.getVarInt32()

   127       if tt == 116: break

   128       if tt == 122:

   129         self.set_type(d.getPrefixedString())

   130         continue

   131       if tt == 128:

   132         self.set_id(d.getVarInt64())

   133         continue

   134       if tt == 138:

   135         self.set_name(d.getPrefixedString())

   136         continue

   137       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError

   138       d.skipData(tt)

   139 

   140 

   141   def __str__(self, prefix="", printElemNumber=0):

   142     res=""

   143     if self.has_type_: res+=prefix+("type: %s\n" % self.DebugFormatString(self.type_))

   144     if self.has_id_: res+=prefix+("id: %s\n" % self.DebugFormatInt64(self.id_))

   145     if self.has_name_: res+=prefix+("name: %s\n" % self.DebugFormatString(self.name_))

   146     return res

   147 

   148 class PropertyValue_PointValue(ProtocolBuffer.ProtocolMessage):

   149   def __init__(self, contents=None):

   150     self.x_ = 0.0

   151     self.y_ = 0.0

   152     self.has_x_ = 0

   153     self.has_y_ = 0

   154     if contents is not None: self.MergeFromString(contents)

   155 

   156   def x(self): return self.x_

   157 

   158   def set_x(self, x):

   159     self.has_x_ = 1

   160     self.x_ = x

   161 

   162   def clear_x(self):

   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     self.has_y_ = 0

   176     self.y_ = 0.0

   177 

   178   def has_y(self): return self.has_y_

   179 

   180 

   181   def MergeFrom(self, x):

   182     assert x is not self

   183     if (x.has_x()): self.set_x(x.x())

   184     if (x.has_y()): self.set_y(x.y())

   185 

   186   def Equals(self, x):

   187     if x is self: return 1

   188     if self.has_x_ != x.has_x_: return 0

   189     if self.has_x_ and self.x_ != x.x_: return 0

   190     if self.has_y_ != x.has_y_: return 0

   191     if self.has_y_ and self.y_ != x.y_: return 0

   192     return 1

   193 

   194   def __eq__(self, other):

   195     return (other is not None) and (other.__class__ == self.__class__) and self.Equals(other)

   196 

   197   def __ne__(self, other):

   198     return not (self == other)

   199 

   200   def IsInitialized(self, debug_strs=None):

   201     initialized = 1

   202     if (not self.has_x_):

   203       initialized = 0

   204       if debug_strs is not None:

   205         debug_strs.append('Required field: x not set.')

   206     if (not self.has_y_):

   207       initialized = 0

   208       if debug_strs is not None:

   209         debug_strs.append('Required field: y not set.')

   210     return initialized

   211 

   212   def ByteSize(self):

   213     n = 0

   214     return n + 18

   215 

   216   def Clear(self):

   217     self.clear_x()

   218     self.clear_y()

   219 

   220   def OutputUnchecked(self, out):

   221     out.putVarInt32(49)

   222     out.putDouble(self.x_)

   223     out.putVarInt32(57)

   224     out.putDouble(self.y_)

   225 

   226   def TryMerge(self, d):

   227     while 1:

   228       tt = d.getVarInt32()

   229       if tt == 44: break

   230       if tt == 49:

   231         self.set_x(d.getDouble())

   232         continue

   233       if tt == 57:

   234         self.set_y(d.getDouble())

   235         continue

   236       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError

   237       d.skipData(tt)

   238 

   239 

   240   def __str__(self, prefix="", printElemNumber=0):

   241     res=""

   242     if self.has_x_: res+=prefix+("x: %s\n" % self.DebugFormat(self.x_))

   243     if self.has_y_: res+=prefix+("y: %s\n" % self.DebugFormat(self.y_))

   244     return res

   245 

   246 class PropertyValue_UserValue(ProtocolBuffer.ProtocolMessage):

   247   def __init__(self, contents=None):

   248     self.email_ = ""

   249     self.auth_domain_ = ""

   250     self.nickname_ = ""

   251     self.gaiaid_ = 0

   252     self.has_email_ = 0

   253     self.has_auth_domain_ = 0

   254     self.has_nickname_ = 0

   255     self.has_gaiaid_ = 0

   256     if contents is not None: self.MergeFromString(contents)

   257 

   258   def email(self): return self.email_

   259 

   260   def set_email(self, x):

   261     self.has_email_ = 1

   262     self.email_ = x

   263 

   264   def clear_email(self):

   265     self.has_email_ = 0

   266     self.email_ = ""

   267 

   268   def has_email(self): return self.has_email_

   269 

   270   def auth_domain(self): return self.auth_domain_

   271 

   272   def set_auth_domain(self, x):

   273     self.has_auth_domain_ = 1

   274     self.auth_domain_ = x

   275 

   276   def clear_auth_domain(self):

   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     self.has_nickname_ = 0

   290     self.nickname_ = ""

   291 

   292   def has_nickname(self): return self.has_nickname_

   293 

   294   def gaiaid(self): return self.gaiaid_

   295 

   296   def set_gaiaid(self, x):

   297     self.has_gaiaid_ = 1

   298     self.gaiaid_ = x

   299 

   300   def clear_gaiaid(self):

   301     self.has_gaiaid_ = 0

   302     self.gaiaid_ = 0

   303 

   304   def has_gaiaid(self): return self.has_gaiaid_

   305 

   306 

   307   def MergeFrom(self, x):

   308     assert x is not self

   309     if (x.has_email()): self.set_email(x.email())

   310     if (x.has_auth_domain()): self.set_auth_domain(x.auth_domain())

   311     if (x.has_nickname()): self.set_nickname(x.nickname())

   312     if (x.has_gaiaid()): self.set_gaiaid(x.gaiaid())

   313 

   314   def Equals(self, x):

   315     if x is self: return 1

   316     if self.has_email_ != x.has_email_: return 0

   317     if self.has_email_ and self.email_ != x.email_: return 0

   318     if self.has_auth_domain_ != x.has_auth_domain_: return 0

   319     if self.has_auth_domain_ and self.auth_domain_ != x.auth_domain_: return 0

   320     if self.has_nickname_ != x.has_nickname_: return 0

   321     if self.has_nickname_ and self.nickname_ != x.nickname_: return 0

   322     if self.has_gaiaid_ != x.has_gaiaid_: return 0

   323     if self.has_gaiaid_ and self.gaiaid_ != x.gaiaid_: return 0

   324     return 1

   325 

   326   def __eq__(self, other):

   327     return (other is not None) and (other.__class__ == self.__class__) and self.Equals(other)

   328 

   329   def __ne__(self, other):

   330     return not (self == other)

   331 

   332   def IsInitialized(self, debug_strs=None):

   333     initialized = 1

   334     if (not self.has_email_):

   335       initialized = 0

   336       if debug_strs is not None:

   337         debug_strs.append('Required field: email not set.')

   338     if (not self.has_auth_domain_):

   339       initialized = 0

   340       if debug_strs is not None:

   341         debug_strs.append('Required field: auth_domain not set.')

   342     if (not self.has_gaiaid_):

   343       initialized = 0

   344       if debug_strs is not None:

   345         debug_strs.append('Required field: gaiaid not set.')

   346     return initialized

   347 

   348   def ByteSize(self):

   349     n = 0

   350     n += self.lengthString(len(self.email_))

   351     n += self.lengthString(len(self.auth_domain_))

   352     if (self.has_nickname_): n += 1 + self.lengthString(len(self.nickname_))

   353     n += self.lengthVarInt64(self.gaiaid_)

   354     return n + 4

   355 

   356   def Clear(self):

   357     self.clear_email()

   358     self.clear_auth_domain()

   359     self.clear_nickname()

   360     self.clear_gaiaid()

   361 

   362   def OutputUnchecked(self, out):

   363     out.putVarInt32(74)

   364     out.putPrefixedString(self.email_)

   365     out.putVarInt32(82)

   366     out.putPrefixedString(self.auth_domain_)

   367     if (self.has_nickname_):

   368       out.putVarInt32(90)

   369       out.putPrefixedString(self.nickname_)

   370     out.putVarInt32(144)

   371     out.putVarInt64(self.gaiaid_)

   372 

   373   def TryMerge(self, d):

   374     while 1:

   375       tt = d.getVarInt32()

   376       if tt == 68: break

   377       if tt == 74:

   378         self.set_email(d.getPrefixedString())

   379         continue

   380       if tt == 82:

   381         self.set_auth_domain(d.getPrefixedString())

   382         continue

   383       if tt == 90:

   384         self.set_nickname(d.getPrefixedString())

   385         continue

   386       if tt == 144:

   387         self.set_gaiaid(d.getVarInt64())

   388         continue

   389       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError

   390       d.skipData(tt)

   391 

   392 

   393   def __str__(self, prefix="", printElemNumber=0):

   394     res=""

   395     if self.has_email_: res+=prefix+("email: %s\n" % self.DebugFormatString(self.email_))

   396     if self.has_auth_domain_: res+=prefix+("auth_domain: %s\n" % self.DebugFormatString(self.auth_domain_))

   397     if self.has_nickname_: res+=prefix+("nickname: %s\n" % self.DebugFormatString(self.nickname_))

   398     if self.has_gaiaid_: res+=prefix+("gaiaid: %s\n" % self.DebugFormatInt64(self.gaiaid_))

   399     return res

   400 

   401 class PropertyValue_ReferenceValue(ProtocolBuffer.ProtocolMessage):

   402   def __init__(self, contents=None):

   403     self.app_ = ""

   404     self.pathelement_ = []

   405     self.has_app_ = 0

   406     if contents is not None: self.MergeFromString(contents)

   407 

   408   def app(self): return self.app_

   409 

   410   def set_app(self, x):

   411     self.has_app_ = 1

   412     self.app_ = x

   413 

   414   def clear_app(self):

   415     self.has_app_ = 0

   416     self.app_ = ""

   417 

   418   def has_app(self): return self.has_app_

   419 

   420   def pathelement_size(self): return len(self.pathelement_)

   421   def pathelement_list(self): return self.pathelement_

   422 

   423   def pathelement(self, i):

   424     return self.pathelement_[i]

   425 

   426   def mutable_pathelement(self, i):

   427     return self.pathelement_[i]

   428 

   429   def add_pathelement(self):

   430     x = PropertyValue_ReferenceValuePathElement()

   431     self.pathelement_.append(x)

   432     return x

   433 

   434   def clear_pathelement(self):

   435     self.pathelement_ = []

   436 

   437   def MergeFrom(self, x):

   438     assert x is not self

   439     if (x.has_app()): self.set_app(x.app())

   440     for i in xrange(x.pathelement_size()): self.add_pathelement().CopyFrom(x.pathelement(i))

   441 

   442   def Equals(self, x):

   443     if x is self: return 1

   444     if self.has_app_ != x.has_app_: return 0

   445     if self.has_app_ and self.app_ != x.app_: return 0

   446     if len(self.pathelement_) != len(x.pathelement_): return 0

   447     for e1, e2 in zip(self.pathelement_, x.pathelement_):

   448       if e1 != e2: return 0

   449     return 1

   450 

   451   def __eq__(self, other):

   452     return (other is not None) and (other.__class__ == self.__class__) and self.Equals(other)

   453 

   454   def __ne__(self, other):

   455     return not (self == other)

   456 

   457   def IsInitialized(self, debug_strs=None):

   458     initialized = 1

   459     if (not self.has_app_):

   460       initialized = 0

   461       if debug_strs is not None:

   462         debug_strs.append('Required field: app not set.')

   463     for i in xrange(len(self.pathelement_)):

   464       if (not self.pathelement_[i].IsInitialized(debug_strs)): initialized=0

   465     return initialized

   466 

   467   def ByteSize(self):

   468     n = 0

   469     n += self.lengthString(len(self.app_))

   470     n += 2 * len(self.pathelement_)

   471     for i in xrange(len(self.pathelement_)): n += self.pathelement_[i].ByteSize()

   472     return n + 1

   473 

   474   def Clear(self):

   475     self.clear_app()

   476     self.clear_pathelement()

   477 

   478   def OutputUnchecked(self, out):

   479     out.putVarInt32(106)

   480     out.putPrefixedString(self.app_)

   481     for i in xrange(len(self.pathelement_)):

   482       out.putVarInt32(115)

   483       self.pathelement_[i].OutputUnchecked(out)

   484       out.putVarInt32(116)

   485 

   486   def TryMerge(self, d):

   487     while 1:

   488       tt = d.getVarInt32()

   489       if tt == 100: break

   490       if tt == 106:

   491         self.set_app(d.getPrefixedString())

   492         continue

   493       if tt == 115:

   494         self.add_pathelement().TryMerge(d)

   495         continue

   496       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError

   497       d.skipData(tt)

   498 

   499 

   500   def __str__(self, prefix="", printElemNumber=0):

   501     res=""

   502     if self.has_app_: res+=prefix+("app: %s\n" % self.DebugFormatString(self.app_))

   503     cnt=0

   504     for e in self.pathelement_:

   505       elm=""

   506       if printElemNumber: elm="(%d)" % cnt

   507       res+=prefix+("PathElement%s {\n" % elm)

   508       res+=e.__str__(prefix + "  ", printElemNumber)

   509       res+=prefix+"}\n"

   510       cnt+=1

   511     return res

   512 

   513 class PropertyValue(ProtocolBuffer.ProtocolMessage):

   514   def __init__(self, contents=None):

   515     self.int64value_ = 0

   516     self.booleanvalue_ = 0

   517     self.stringvalue_ = ""

   518     self.doublevalue_ = 0.0

   519     self.pointvalue_ = None

   520     self.uservalue_ = None

   521     self.referencevalue_ = None

   522     self.has_int64value_ = 0

   523     self.has_booleanvalue_ = 0

   524     self.has_stringvalue_ = 0

   525     self.has_doublevalue_ = 0

   526     self.has_pointvalue_ = 0

   527     self.has_uservalue_ = 0

   528     self.has_referencevalue_ = 0

   529     self.lazy_init_lock_ = thread.allocate_lock()

   530     if contents is not None: self.MergeFromString(contents)

   531 

   532   def int64value(self): return self.int64value_

   533 

   534   def set_int64value(self, x):

   535     self.has_int64value_ = 1

   536     self.int64value_ = x

   537 

   538   def clear_int64value(self):

   539     self.has_int64value_ = 0

   540     self.int64value_ = 0

   541 

   542   def has_int64value(self): return self.has_int64value_

   543 

   544   def booleanvalue(self): return self.booleanvalue_

   545 

   546   def set_booleanvalue(self, x):

   547     self.has_booleanvalue_ = 1

   548     self.booleanvalue_ = x

   549 

   550   def clear_booleanvalue(self):

   551     self.has_booleanvalue_ = 0

   552     self.booleanvalue_ = 0

   553 

   554   def has_booleanvalue(self): return self.has_booleanvalue_

   555 

   556   def stringvalue(self): return self.stringvalue_

   557 

   558   def set_stringvalue(self, x):

   559     self.has_stringvalue_ = 1

   560     self.stringvalue_ = x

   561 

   562   def clear_stringvalue(self):

   563     self.has_stringvalue_ = 0

   564     self.stringvalue_ = ""

   565 

   566   def has_stringvalue(self): return self.has_stringvalue_

   567 

   568   def doublevalue(self): return self.doublevalue_

   569 

   570   def set_doublevalue(self, x):

   571     self.has_doublevalue_ = 1

   572     self.doublevalue_ = x

   573 

   574   def clear_doublevalue(self):

   575     self.has_doublevalue_ = 0

   576     self.doublevalue_ = 0.0

   577 

   578   def has_doublevalue(self): return self.has_doublevalue_

   579 

   580   def pointvalue(self):

   581     if self.pointvalue_ is None:

   582       self.lazy_init_lock_.acquire()

   583       try:

   584         if self.pointvalue_ is None: self.pointvalue_ = PropertyValue_PointValue()

   585       finally:

   586         self.lazy_init_lock_.release()

   587     return self.pointvalue_

   588 

   589   def mutable_pointvalue(self): self.has_pointvalue_ = 1; return self.pointvalue()

   590 

   591   def clear_pointvalue(self):

   592     self.has_pointvalue_ = 0;

   593     if self.pointvalue_ is not None: self.pointvalue_.Clear()

   594 

   595   def has_pointvalue(self): return self.has_pointvalue_

   596 

   597   def uservalue(self):

   598     if self.uservalue_ is None:

   599       self.lazy_init_lock_.acquire()

   600       try:

   601         if self.uservalue_ is None: self.uservalue_ = PropertyValue_UserValue()

   602       finally:

   603         self.lazy_init_lock_.release()

   604     return self.uservalue_

   605 

   606   def mutable_uservalue(self): self.has_uservalue_ = 1; return self.uservalue()

   607 

   608   def clear_uservalue(self):

   609     self.has_uservalue_ = 0;

   610     if self.uservalue_ is not None: self.uservalue_.Clear()

   611 

   612   def has_uservalue(self): return self.has_uservalue_

   613 

   614   def referencevalue(self):

   615     if self.referencevalue_ is None:

   616       self.lazy_init_lock_.acquire()

   617       try:

   618         if self.referencevalue_ is None: self.referencevalue_ = PropertyValue_ReferenceValue()

   619       finally:

   620         self.lazy_init_lock_.release()

   621     return self.referencevalue_

   622 

   623   def mutable_referencevalue(self): self.has_referencevalue_ = 1; return self.referencevalue()

   624 

   625   def clear_referencevalue(self):

   626     self.has_referencevalue_ = 0;

   627     if self.referencevalue_ is not None: self.referencevalue_.Clear()

   628 

   629   def has_referencevalue(self): return self.has_referencevalue_

   630 

   631 

   632   def MergeFrom(self, x):

   633     assert x is not self

   634     if (x.has_int64value()): self.set_int64value(x.int64value())

   635     if (x.has_booleanvalue()): self.set_booleanvalue(x.booleanvalue())

   636     if (x.has_stringvalue()): self.set_stringvalue(x.stringvalue())

   637     if (x.has_doublevalue()): self.set_doublevalue(x.doublevalue())

   638     if (x.has_pointvalue()): self.mutable_pointvalue().MergeFrom(x.pointvalue())

   639     if (x.has_uservalue()): self.mutable_uservalue().MergeFrom(x.uservalue())

   640     if (x.has_referencevalue()): self.mutable_referencevalue().MergeFrom(x.referencevalue())

   641 

   642   def Equals(self, x):

   643     if x is self: return 1

   644     if self.has_int64value_ != x.has_int64value_: return 0

   645     if self.has_int64value_ and self.int64value_ != x.int64value_: return 0

   646     if self.has_booleanvalue_ != x.has_booleanvalue_: return 0

   647     if self.has_booleanvalue_ and self.booleanvalue_ != x.booleanvalue_: return 0

   648     if self.has_stringvalue_ != x.has_stringvalue_: return 0

   649     if self.has_stringvalue_ and self.stringvalue_ != x.stringvalue_: return 0

   650     if self.has_doublevalue_ != x.has_doublevalue_: return 0

   651     if self.has_doublevalue_ and self.doublevalue_ != x.doublevalue_: return 0

   652     if self.has_pointvalue_ != x.has_pointvalue_: return 0

   653     if self.has_pointvalue_ and self.pointvalue_ != x.pointvalue_: return 0

   654     if self.has_uservalue_ != x.has_uservalue_: return 0

   655     if self.has_uservalue_ and self.uservalue_ != x.uservalue_: return 0

   656     if self.has_referencevalue_ != x.has_referencevalue_: return 0

   657     if self.has_referencevalue_ and self.referencevalue_ != x.referencevalue_: return 0

   658     return 1

   659 

   660   def __eq__(self, other):

   661     return (other is not None) and (other.__class__ == self.__class__) and self.Equals(other)

   662 

   663   def __ne__(self, other):

   664     return not (self == other)

   665 

   666   def IsInitialized(self, debug_strs=None):

   667     initialized = 1

   668     if (self.has_pointvalue_ and not self.pointvalue_.IsInitialized(debug_strs)): initialized = 0

   669     if (self.has_uservalue_ and not self.uservalue_.IsInitialized(debug_strs)): initialized = 0

   670     if (self.has_referencevalue_ and not self.referencevalue_.IsInitialized(debug_strs)): initialized = 0

   671     return initialized

   672 

   673   def ByteSize(self):

   674     n = 0

   675     if (self.has_int64value_): n += 1 + self.lengthVarInt64(self.int64value_)

   676     if (self.has_booleanvalue_): n += 2

   677     if (self.has_stringvalue_): n += 1 + self.lengthString(len(self.stringvalue_))

   678     if (self.has_doublevalue_): n += 9

   679     if (self.has_pointvalue_): n += 2 + self.pointvalue_.ByteSize()

   680     if (self.has_uservalue_): n += 2 + self.uservalue_.ByteSize()

   681     if (self.has_referencevalue_): n += 2 + self.referencevalue_.ByteSize()

   682     return n + 0

   683 

   684   def Clear(self):

   685     self.clear_int64value()

   686     self.clear_booleanvalue()

   687     self.clear_stringvalue()

   688     self.clear_doublevalue()

   689     self.clear_pointvalue()

   690     self.clear_uservalue()

   691     self.clear_referencevalue()

   692 

   693   def OutputUnchecked(self, out):

   694     if (self.has_int64value_):

   695       out.putVarInt32(8)

   696       out.putVarInt64(self.int64value_)

   697     if (self.has_booleanvalue_):

   698       out.putVarInt32(16)

   699       out.putBoolean(self.booleanvalue_)

   700     if (self.has_stringvalue_):

   701       out.putVarInt32(26)

   702       out.putPrefixedString(self.stringvalue_)

   703     if (self.has_doublevalue_):

   704       out.putVarInt32(33)

   705       out.putDouble(self.doublevalue_)

   706     if (self.has_pointvalue_):

   707       out.putVarInt32(43)

   708       self.pointvalue_.OutputUnchecked(out)

   709       out.putVarInt32(44)

   710     if (self.has_uservalue_):

   711       out.putVarInt32(67)

   712       self.uservalue_.OutputUnchecked(out)

   713       out.putVarInt32(68)

   714     if (self.has_referencevalue_):

   715       out.putVarInt32(99)

   716       self.referencevalue_.OutputUnchecked(out)

   717       out.putVarInt32(100)

   718 

   719   def TryMerge(self, d):

   720     while d.avail() > 0:

   721       tt = d.getVarInt32()

   722       if tt == 8:

   723         self.set_int64value(d.getVarInt64())

   724         continue

   725       if tt == 16:

   726         self.set_booleanvalue(d.getBoolean())

   727         continue

   728       if tt == 26:

   729         self.set_stringvalue(d.getPrefixedString())

   730         continue

   731       if tt == 33:

   732         self.set_doublevalue(d.getDouble())

   733         continue

   734       if tt == 43:

   735         self.mutable_pointvalue().TryMerge(d)

   736         continue

   737       if tt == 67:

   738         self.mutable_uservalue().TryMerge(d)

   739         continue

   740       if tt == 99:

   741         self.mutable_referencevalue().TryMerge(d)

   742         continue

   743       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError

   744       d.skipData(tt)

   745 

   746 

   747   def __str__(self, prefix="", printElemNumber=0):

   748     res=""

   749     if self.has_int64value_: res+=prefix+("int64Value: %s\n" % self.DebugFormatInt64(self.int64value_))

   750     if self.has_booleanvalue_: res+=prefix+("booleanValue: %s\n" % self.DebugFormatBool(self.booleanvalue_))

   751     if self.has_stringvalue_: res+=prefix+("stringValue: %s\n" % self.DebugFormatString(self.stringvalue_))

   752     if self.has_doublevalue_: res+=prefix+("doubleValue: %s\n" % self.DebugFormat(self.doublevalue_))

   753     if self.has_pointvalue_:

   754       res+=prefix+"PointValue {\n"

   755       res+=self.pointvalue_.__str__(prefix + "  ", printElemNumber)

   756       res+=prefix+"}\n"

   757     if self.has_uservalue_:

   758       res+=prefix+"UserValue {\n"

   759       res+=self.uservalue_.__str__(prefix + "  ", printElemNumber)

   760       res+=prefix+"}\n"

   761     if self.has_referencevalue_:

   762       res+=prefix+"ReferenceValue {\n"

   763       res+=self.referencevalue_.__str__(prefix + "  ", printElemNumber)

   764       res+=prefix+"}\n"

   765     return res

   766 

   767   kint64Value = 1

   768   kbooleanValue = 2

   769   kstringValue = 3

   770   kdoubleValue = 4

   771   kPointValueGroup = 5

   772   kPointValuex = 6

   773   kPointValuey = 7

   774   kUserValueGroup = 8

   775   kUserValueemail = 9

   776   kUserValueauth_domain = 10

   777   kUserValuenickname = 11

   778   kUserValuegaiaid = 18

   779   kReferenceValueGroup = 12

   780   kReferenceValueapp = 13

   781   kReferenceValuePathElementGroup = 14

   782   kReferenceValuePathElementtype = 15

   783   kReferenceValuePathElementid = 16

   784   kReferenceValuePathElementname = 17

   785 

   786   _TEXT = (

   787    "ErrorCode",

   788    "int64Value",

   789    "booleanValue",

   790    "stringValue",

   791    "doubleValue",

   792    "PointValue",

   793    "x",

   794    "y",

   795    "UserValue",

   796    "email",

   797    "auth_domain",

   798    "nickname",

   799    "ReferenceValue",

   800    "app",

   801    "PathElement",

   802    "type",

   803    "id",

   804    "name",

   805    "gaiaid",

   806   )

   807 

   808   _TYPES = (

   809    ProtocolBuffer.Encoder.NUMERIC,

   810    ProtocolBuffer.Encoder.NUMERIC,

   811 

   812    ProtocolBuffer.Encoder.NUMERIC,

   813 

   814    ProtocolBuffer.Encoder.STRING,

   815 

   816    ProtocolBuffer.Encoder.DOUBLE,

   817 

   818    ProtocolBuffer.Encoder.STARTGROUP,

   819 

   820    ProtocolBuffer.Encoder.DOUBLE,

   821 

   822    ProtocolBuffer.Encoder.DOUBLE,

   823 

   824    ProtocolBuffer.Encoder.STARTGROUP,

   825 

   826    ProtocolBuffer.Encoder.STRING,

   827 

   828    ProtocolBuffer.Encoder.STRING,

   829 

   830    ProtocolBuffer.Encoder.STRING,

   831 

   832    ProtocolBuffer.Encoder.STARTGROUP,

   833 

   834    ProtocolBuffer.Encoder.STRING,

   835 

   836    ProtocolBuffer.Encoder.STARTGROUP,

   837 

   838    ProtocolBuffer.Encoder.STRING,

   839 

   840    ProtocolBuffer.Encoder.NUMERIC,

   841 

   842    ProtocolBuffer.Encoder.STRING,

   843 

   844    ProtocolBuffer.Encoder.NUMERIC,

   845 

   846   )

   847 

   848   _STYLE = """"""

   849   _STYLE_CONTENT_TYPE = """"""

   850 class Property(ProtocolBuffer.ProtocolMessage):

   851 

   852   BLOB         =   14

   853   TEXT         =   15

   854   ATOM_CATEGORY =    1

   855   ATOM_LINK    =    2

   856   ATOM_TITLE   =    3

   857   ATOM_CONTENT =    4

   858   ATOM_SUMMARY =    5

   859   ATOM_AUTHOR  =    6

   860   GD_WHEN      =    7

   861   GD_EMAIL     =    8

   862   GEORSS_POINT =    9

   863   GD_IM        =   10

   864   GD_PHONENUMBER =   11

   865   GD_POSTALADDRESS =   12

   866   GD_RATING    =   13

   867 

   868   _Meaning_NAMES = {

   869     14: "BLOB",

   870     15: "TEXT",

   871     1: "ATOM_CATEGORY",

   872     2: "ATOM_LINK",

   873     3: "ATOM_TITLE",

   874     4: "ATOM_CONTENT",

   875     5: "ATOM_SUMMARY",

   876     6: "ATOM_AUTHOR",

   877     7: "GD_WHEN",

   878     8: "GD_EMAIL",

   879     9: "GEORSS_POINT",

   880     10: "GD_IM",

   881     11: "GD_PHONENUMBER",

   882     12: "GD_POSTALADDRESS",

   883     13: "GD_RATING",

   884   }

   885 

   886   def Meaning_Name(cls, x): return cls._Meaning_NAMES.get(x, "")

   887   Meaning_Name = classmethod(Meaning_Name)

   888 

   889   def __init__(self, contents=None):

   890     self.meaning_ = 0

   891     self.meaning_uri_ = ""

   892     self.name_ = ""

   893     self.value_ = PropertyValue()

   894     self.multiple_ = 0

   895     self.has_meaning_ = 0

   896     self.has_meaning_uri_ = 0

   897     self.has_name_ = 0

   898     self.has_value_ = 0

   899     self.has_multiple_ = 0

   900     if contents is not None: self.MergeFromString(contents)

   901 

   902   def meaning(self): return self.meaning_

   903 

   904   def set_meaning(self, x):

   905     self.has_meaning_ = 1

   906     self.meaning_ = x

   907 

   908   def clear_meaning(self):

   909     self.has_meaning_ = 0

   910     self.meaning_ = 0

   911 

   912   def has_meaning(self): return self.has_meaning_

   913 

   914   def meaning_uri(self): return self.meaning_uri_

   915 

   916   def set_meaning_uri(self, x):

   917     self.has_meaning_uri_ = 1

   918     self.meaning_uri_ = x

   919 

   920   def clear_meaning_uri(self):

   921     self.has_meaning_uri_ = 0

   922     self.meaning_uri_ = ""

   923 

   924   def has_meaning_uri(self): return self.has_meaning_uri_

   925 

   926   def name(self): return self.name_

   927 

   928   def set_name(self, x):

   929     self.has_name_ = 1

   930     self.name_ = x

   931 

   932   def clear_name(self):

   933     self.has_name_ = 0

   934     self.name_ = ""

   935 

   936   def has_name(self): return self.has_name_

   937 

   938   def value(self): return self.value_

   939 

   940   def mutable_value(self): self.has_value_ = 1; return self.value_

   941 

   942   def clear_value(self):self.has_value_ = 0; self.value_.Clear()

   943 

   944   def has_value(self): return self.has_value_

   945 

   946   def multiple(self): return self.multiple_

   947 

   948   def set_multiple(self, x):

   949     self.has_multiple_ = 1

   950     self.multiple_ = x

   951 

   952   def clear_multiple(self):

   953     self.has_multiple_ = 0

   954     self.multiple_ = 0

   955 

   956   def has_multiple(self): return self.has_multiple_

   957 

   958 

   959   def MergeFrom(self, x):

   960     assert x is not self

   961     if (x.has_meaning()): self.set_meaning(x.meaning())

   962     if (x.has_meaning_uri()): self.set_meaning_uri(x.meaning_uri())

   963     if (x.has_name()): self.set_name(x.name())

   964     if (x.has_value()): self.mutable_value().MergeFrom(x.value())

   965     if (x.has_multiple()): self.set_multiple(x.multiple())

   966 

   967   def Equals(self, x):

   968     if x is self: return 1

   969     if self.has_meaning_ != x.has_meaning_: return 0

   970     if self.has_meaning_ and self.meaning_ != x.meaning_: return 0

   971     if self.has_meaning_uri_ != x.has_meaning_uri_: return 0

   972     if self.has_meaning_uri_ and self.meaning_uri_ != x.meaning_uri_: return 0

   973     if self.has_name_ != x.has_name_: return 0

   974     if self.has_name_ and self.name_ != x.name_: return 0

   975     if self.has_value_ != x.has_value_: return 0

   976     if self.has_value_ and self.value_ != x.value_: return 0

   977     if self.has_multiple_ != x.has_multiple_: return 0

   978     if self.has_multiple_ and self.multiple_ != x.multiple_: return 0

   979     return 1

   980 

   981   def __eq__(self, other):

   982     return (other is not None) and (other.__class__ == self.__class__) and self.Equals(other)

   983 

   984   def __ne__(self, other):

   985     return not (self == other)

   986 

   987   def IsInitialized(self, debug_strs=None):

   988     initialized = 1

   989     if (not self.has_name_):

   990       initialized = 0

   991       if debug_strs is not None:

   992         debug_strs.append('Required field: name not set.')

   993     if (not self.has_value_):

   994       initialized = 0

   995       if debug_strs is not None:

   996         debug_strs.append('Required field: value not set.')

   997     elif not self.value_.IsInitialized(debug_strs): initialized = 0

   998     return initialized

   999 

  1000   def ByteSize(self):

  1001     n = 0

  1002     if (self.has_meaning_): n += 1 + self.lengthVarInt64(self.meaning_)

  1003     if (self.has_meaning_uri_): n += 1 + self.lengthString(len(self.meaning_uri_))

  1004     n += self.lengthString(len(self.name_))

  1005     n += self.lengthString(self.value_.ByteSize())

  1006     if (self.has_multiple_): n += 2

  1007     return n + 2

  1008 

  1009   def Clear(self):

  1010     self.clear_meaning()

  1011     self.clear_meaning_uri()

  1012     self.clear_name()

  1013     self.clear_value()

  1014     self.clear_multiple()

  1015 

  1016   def OutputUnchecked(self, out):

  1017     if (self.has_meaning_):

  1018       out.putVarInt32(8)

  1019       out.putVarInt32(self.meaning_)

  1020     if (self.has_meaning_uri_):

  1021       out.putVarInt32(18)

  1022       out.putPrefixedString(self.meaning_uri_)

  1023     out.putVarInt32(26)

  1024     out.putPrefixedString(self.name_)

  1025     if (self.has_multiple_):

  1026       out.putVarInt32(32)

  1027       out.putBoolean(self.multiple_)

  1028     out.putVarInt32(42)

  1029     out.putVarInt32(self.value_.ByteSize())

  1030     self.value_.OutputUnchecked(out)

  1031 

  1032   def TryMerge(self, d):

  1033     while d.avail() > 0:

  1034       tt = d.getVarInt32()

  1035       if tt == 8:

  1036         self.set_meaning(d.getVarInt32())

  1037         continue

  1038       if tt == 18:

  1039         self.set_meaning_uri(d.getPrefixedString())

  1040         continue

  1041       if tt == 26:

  1042         self.set_name(d.getPrefixedString())

  1043         continue

  1044       if tt == 32:

  1045         self.set_multiple(d.getBoolean())

  1046         continue

  1047       if tt == 42:

  1048         length = d.getVarInt32()

  1049         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)

  1050         d.skip(length)

  1051         self.mutable_value().TryMerge(tmp)

  1052         continue

  1053       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError

  1054       d.skipData(tt)

  1055 

  1056 

  1057   def __str__(self, prefix="", printElemNumber=0):

  1058     res=""

  1059     if self.has_meaning_: res+=prefix+("meaning: %s\n" % self.DebugFormatInt32(self.meaning_))

  1060     if self.has_meaning_uri_: res+=prefix+("meaning_uri: %s\n" % self.DebugFormatString(self.meaning_uri_))

  1061     if self.has_name_: res+=prefix+("name: %s\n" % self.DebugFormatString(self.name_))

  1062     if self.has_value_:

  1063       res+=prefix+"value <\n"

  1064       res+=self.value_.__str__(prefix + "  ", printElemNumber)

  1065       res+=prefix+">\n"

  1066     if self.has_multiple_: res+=prefix+("multiple: %s\n" % self.DebugFormatBool(self.multiple_))

  1067     return res

  1068 

  1069   kmeaning = 1

  1070   kmeaning_uri = 2

  1071   kname = 3

  1072   kvalue = 5

  1073   kmultiple = 4

  1074 

  1075   _TEXT = (

  1076    "ErrorCode",

  1077    "meaning",

  1078    "meaning_uri",

  1079    "name",

  1080    "multiple",

  1081    "value",

  1082   )

  1083 

  1084   _TYPES = (

  1085    ProtocolBuffer.Encoder.NUMERIC,

  1086    ProtocolBuffer.Encoder.NUMERIC,

  1087 

  1088    ProtocolBuffer.Encoder.STRING,

  1089 

  1090    ProtocolBuffer.Encoder.STRING,

  1091 

  1092    ProtocolBuffer.Encoder.NUMERIC,

  1093 

  1094    ProtocolBuffer.Encoder.STRING,

  1095 

  1096   )

  1097 

  1098   _STYLE = """"""

  1099   _STYLE_CONTENT_TYPE = """"""

  1100 class Path_Element(ProtocolBuffer.ProtocolMessage):

  1101   def __init__(self, contents=None):

  1102     self.type_ = ""

  1103     self.id_ = 0

  1104     self.name_ = ""

  1105     self.has_type_ = 0

  1106     self.has_id_ = 0

  1107     self.has_name_ = 0

  1108     if contents is not None: self.MergeFromString(contents)

  1109 

  1110   def type(self): return self.type_

  1111 

  1112   def set_type(self, x):

  1113     self.has_type_ = 1

  1114     self.type_ = x

  1115 

  1116   def clear_type(self):

  1117     self.has_type_ = 0

  1118     self.type_ = ""

  1119 

  1120   def has_type(self): return self.has_type_

  1121 

  1122   def id(self): return self.id_

  1123 

  1124   def set_id(self, x):

  1125     self.has_id_ = 1

  1126     self.id_ = x

  1127 

  1128   def clear_id(self):

  1129     self.has_id_ = 0

  1130     self.id_ = 0

  1131 

  1132   def has_id(self): return self.has_id_

  1133 

  1134   def name(self): return self.name_

  1135