python/google/appengine/datastore/document_pb.py

   1 #!/usr/bin/env python
   2 #
   3 # Copyright 2007 Google Inc.
   4 #
   5 # Licensed under the Apache License, Version 2.0 (the "License");
   6 # you may not use this file except in compliance with the License.
   7 # You may obtain a copy of the License at
   8 #
   9 #     http://www.apache.org/licenses/LICENSE-2.0
  10 #
  11 # Unless required by applicable law or agreed to in writing, software
  12 # distributed under the License is distributed on an "AS IS" BASIS,
  13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 # See the License for the specific language governing permissions and
  15 # limitations under the License.
  16 #
  17
  18
  19
  20 from google.net.proto import ProtocolBuffer
  21 import array
  22 import dummy_thread as thread
  23
  24 __pychecker__ = """maxreturns=0 maxbranches=0 no-callinit
  25                    unusednames=printElemNumber,debug_strs no-special"""
  26
  27 if hasattr(ProtocolBuffer, 'ExtendableProtocolMessage'):
  28   _extension_runtime = True
  29   _ExtendableProtocolMessage = ProtocolBuffer.ExtendableProtocolMessage
  30 else:
  31   _extension_runtime = False
  32   _ExtendableProtocolMessage = ProtocolBuffer.ProtocolMessage
  33
  34 from google.appengine.datastore.acl_pb import *
  35 import google.appengine.datastore.acl_pb
  36 class FieldValue_Geo(ProtocolBuffer.ProtocolMessage):
  37   has_lat_ = 0
  38   lat_ = 0.0
  39   has_lng_ = 0
  40   lng_ = 0.0
  41
  42   def __init__(self, contents=None):
  43     if contents is not None: self.MergeFromString(contents)
  44
  45   def lat(self): return self.lat_
  46
  47   def set_lat(self, x):
  48     self.has_lat_ = 1
  49     self.lat_ = x
  50
  51   def clear_lat(self):
  52     if self.has_lat_:
  53       self.has_lat_ = 0
  54       self.lat_ = 0.0
  55
  56   def has_lat(self): return self.has_lat_
  57
  58   def lng(self): return self.lng_
  59
  60   def set_lng(self, x):
  61     self.has_lng_ = 1
  62     self.lng_ = x
  63
  64   def clear_lng(self):
  65     if self.has_lng_:
  66       self.has_lng_ = 0
  67       self.lng_ = 0.0
  68
  69   def has_lng(self): return self.has_lng_
  70
  71
  72   def MergeFrom(self, x):
  73     assert x is not self
  74     if (x.has_lat()): self.set_lat(x.lat())
  75     if (x.has_lng()): self.set_lng(x.lng())
  76
  77   def Equals(self, x):
  78     if x is self: return 1
  79     if self.has_lat_ != x.has_lat_: return 0
  80     if self.has_lat_ and self.lat_ != x.lat_: return 0
  81     if self.has_lng_ != x.has_lng_: return 0
  82     if self.has_lng_ and self.lng_ != x.lng_: return 0
  83     return 1
  84
  85   def IsInitialized(self, debug_strs=None):
  86     initialized = 1
  87     if (not self.has_lat_):
  88       initialized = 0
  89       if debug_strs is not None:
  90         debug_strs.append('Required field: lat not set.')
  91     if (not self.has_lng_):
  92       initialized = 0
  93       if debug_strs is not None:
  94         debug_strs.append('Required field: lng not set.')
  95     return initialized
  96
  97   def ByteSize(self):
  98     n = 0
  99     return n + 18
 100
 101   def ByteSizePartial(self):
 102     n = 0
 103     if (self.has_lat_):
 104       n += 9
 105     if (self.has_lng_):
 106       n += 9
 107     return n
 108
 109   def Clear(self):
 110     self.clear_lat()
 111     self.clear_lng()
 112
 113   def OutputUnchecked(self, out):
 114     out.putVarInt32(41)
 115     out.putDouble(self.lat_)
 116     out.putVarInt32(49)
 117     out.putDouble(self.lng_)
 118
 119   def OutputPartial(self, out):
 120     if (self.has_lat_):
 121       out.putVarInt32(41)
 122       out.putDouble(self.lat_)
 123     if (self.has_lng_):
 124       out.putVarInt32(49)
 125       out.putDouble(self.lng_)
 126
 127   def TryMerge(self, d):
 128     while 1:
 129       tt = d.getVarInt32()
 130       if tt == 36: break
 131       if tt == 41:
 132         self.set_lat(d.getDouble())
 133         continue
 134       if tt == 49:
 135         self.set_lng(d.getDouble())
 136         continue
 137
 138
 139       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 140       d.skipData(tt)
 141
 142
 143   def __str__(self, prefix="", printElemNumber=0):
 144     res=""
 145     if self.has_lat_: res+=prefix+("lat: %s\n" % self.DebugFormat(self.lat_))
 146     if self.has_lng_: res+=prefix+("lng: %s\n" % self.DebugFormat(self.lng_))
 147     return res
 148
 149 class FieldValue(ProtocolBuffer.ProtocolMessage):
 150
 151
 152   TEXT         =    0
 153   HTML         =    1
 154   ATOM         =    2
 155   DATE         =    3
 156   NUMBER       =    4
 157   GEO          =    5
 158
 159   _ContentType_NAMES = {
 160     0: "TEXT",
 161     1: "HTML",
 162     2: "ATOM",
 163     3: "DATE",
 164     4: "NUMBER",
 165     5: "GEO",
 166   }
 167
 168   def ContentType_Name(cls, x): return cls._ContentType_NAMES.get(x, "")
 169   ContentType_Name = classmethod(ContentType_Name)
 170
 171   has_type_ = 0
 172   type_ = 0
 173   has_language_ = 0
 174   language_ = "en"
 175   has_string_value_ = 0
 176   string_value_ = ""
 177   has_geo_ = 0
 178   geo_ = None
 179
 180   def __init__(self, contents=None):
 181     self.lazy_init_lock_ = thread.allocate_lock()
 182     if contents is not None: self.MergeFromString(contents)
 183
 184   def type(self): return self.type_
 185
 186   def set_type(self, x):
 187     self.has_type_ = 1
 188     self.type_ = x
 189
 190   def clear_type(self):
 191     if self.has_type_:
 192       self.has_type_ = 0
 193       self.type_ = 0
 194
 195   def has_type(self): return self.has_type_
 196
 197   def language(self): return self.language_
 198
 199   def set_language(self, x):
 200     self.has_language_ = 1
 201     self.language_ = x
 202
 203   def clear_language(self):
 204     if self.has_language_:
 205       self.has_language_ = 0
 206       self.language_ = "en"
 207
 208   def has_language(self): return self.has_language_
 209
 210   def string_value(self): return self.string_value_
 211
 212   def set_string_value(self, x):
 213     self.has_string_value_ = 1
 214     self.string_value_ = x
 215
 216   def clear_string_value(self):
 217     if self.has_string_value_:
 218       self.has_string_value_ = 0
 219       self.string_value_ = ""
 220
 221   def has_string_value(self): return self.has_string_value_
 222
 223   def geo(self):
 224     if self.geo_ is None:
 225       self.lazy_init_lock_.acquire()
 226       try:
 227         if self.geo_ is None: self.geo_ = FieldValue_Geo()
 228       finally:
 229         self.lazy_init_lock_.release()
 230     return self.geo_
 231
 232   def mutable_geo(self): self.has_geo_ = 1; return self.geo()
 233
 234   def clear_geo(self):
 235
 236     if self.has_geo_:
 237       self.has_geo_ = 0;
 238       if self.geo_ is not None: self.geo_.Clear()
 239
 240   def has_geo(self): return self.has_geo_
 241
 242
 243   def MergeFrom(self, x):
 244     assert x is not self
 245     if (x.has_type()): self.set_type(x.type())
 246     if (x.has_language()): self.set_language(x.language())
 247     if (x.has_string_value()): self.set_string_value(x.string_value())
 248     if (x.has_geo()): self.mutable_geo().MergeFrom(x.geo())
 249
 250   def Equals(self, x):
 251     if x is self: return 1
 252     if self.has_type_ != x.has_type_: return 0
 253     if self.has_type_ and self.type_ != x.type_: return 0
 254     if self.has_language_ != x.has_language_: return 0
 255     if self.has_language_ and self.language_ != x.language_: return 0
 256     if self.has_string_value_ != x.has_string_value_: return 0
 257     if self.has_string_value_ and self.string_value_ != x.string_value_: return 0
 258     if self.has_geo_ != x.has_geo_: return 0
 259     if self.has_geo_ and self.geo_ != x.geo_: return 0
 260     return 1
 261
 262   def IsInitialized(self, debug_strs=None):
 263     initialized = 1
 264     if (self.has_geo_ and not self.geo_.IsInitialized(debug_strs)): initialized = 0
 265     return initialized
 266
 267   def ByteSize(self):
 268     n = 0
 269     if (self.has_type_): n += 1 + self.lengthVarInt64(self.type_)
 270     if (self.has_language_): n += 1 + self.lengthString(len(self.language_))
 271     if (self.has_string_value_): n += 1 + self.lengthString(len(self.string_value_))
 272     if (self.has_geo_): n += 2 + self.geo_.ByteSize()
 273     return n
 274
 275   def ByteSizePartial(self):
 276     n = 0
 277     if (self.has_type_): n += 1 + self.lengthVarInt64(self.type_)
 278     if (self.has_language_): n += 1 + self.lengthString(len(self.language_))
 279     if (self.has_string_value_): n += 1 + self.lengthString(len(self.string_value_))
 280     if (self.has_geo_): n += 2 + self.geo_.ByteSizePartial()
 281     return n
 282
 283   def Clear(self):
 284     self.clear_type()
 285     self.clear_language()
 286     self.clear_string_value()
 287     self.clear_geo()
 288
 289   def OutputUnchecked(self, out):
 290     if (self.has_type_):
 291       out.putVarInt32(8)
 292       out.putVarInt32(self.type_)
 293     if (self.has_language_):
 294       out.putVarInt32(18)
 295       out.putPrefixedString(self.language_)
 296     if (self.has_string_value_):
 297       out.putVarInt32(26)
 298       out.putPrefixedString(self.string_value_)
 299     if (self.has_geo_):
 300       out.putVarInt32(35)
 301       self.geo_.OutputUnchecked(out)
 302       out.putVarInt32(36)
 303
 304   def OutputPartial(self, out):
 305     if (self.has_type_):
 306       out.putVarInt32(8)
 307       out.putVarInt32(self.type_)
 308     if (self.has_language_):
 309       out.putVarInt32(18)
 310       out.putPrefixedString(self.language_)
 311     if (self.has_string_value_):
 312       out.putVarInt32(26)
 313       out.putPrefixedString(self.string_value_)
 314     if (self.has_geo_):
 315       out.putVarInt32(35)
 316       self.geo_.OutputPartial(out)
 317       out.putVarInt32(36)
 318
 319   def TryMerge(self, d):
 320     while d.avail() > 0:
 321       tt = d.getVarInt32()
 322       if tt == 8:
 323         self.set_type(d.getVarInt32())
 324         continue
 325       if tt == 18:
 326         self.set_language(d.getPrefixedString())
 327         continue
 328       if tt == 26:
 329         self.set_string_value(d.getPrefixedString())
 330         continue
 331       if tt == 35:
 332         self.mutable_geo().TryMerge(d)
 333         continue
 334
 335
 336       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 337       d.skipData(tt)
 338
 339
 340   def __str__(self, prefix="", printElemNumber=0):
 341     res=""
 342     if self.has_type_: res+=prefix+("type: %s\n" % self.DebugFormatInt32(self.type_))
 343     if self.has_language_: res+=prefix+("language: %s\n" % self.DebugFormatString(self.language_))
 344     if self.has_string_value_: res+=prefix+("string_value: %s\n" % self.DebugFormatString(self.string_value_))
 345     if self.has_geo_:
 346       res+=prefix+"Geo {\n"
 347       res+=self.geo_.__str__(prefix + "  ", printElemNumber)
 348       res+=prefix+"}\n"
 349     return res
 350
 351
 352   def _BuildTagLookupTable(sparse, maxtag, default=None):
 353     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
 354
 355   ktype = 1
 356   klanguage = 2
 357   kstring_value = 3
 358   kGeoGroup = 4
 359   kGeolat = 5
 360   kGeolng = 6
 361
 362   _TEXT = _BuildTagLookupTable({
 363     0: "ErrorCode",
 364     1: "type",
 365     2: "language",
 366     3: "string_value",
 367     4: "Geo",
 368     5: "lat",
 369     6: "lng",
 370   }, 6)
 371
 372   _TYPES = _BuildTagLookupTable({
 373     0: ProtocolBuffer.Encoder.NUMERIC,
 374     1: ProtocolBuffer.Encoder.NUMERIC,
 375     2: ProtocolBuffer.Encoder.STRING,
 376     3: ProtocolBuffer.Encoder.STRING,
 377     4: ProtocolBuffer.Encoder.STARTGROUP,
 378     5: ProtocolBuffer.Encoder.DOUBLE,
 379     6: ProtocolBuffer.Encoder.DOUBLE,
 380   }, 6, ProtocolBuffer.Encoder.MAX_TYPE)
 381
 382
 383   _STYLE = """"""
 384   _STYLE_CONTENT_TYPE = """"""
 385   _PROTO_DESCRIPTOR_NAME = 'storage_onestore_v3.FieldValue'
 386 class Field(ProtocolBuffer.ProtocolMessage):
 387   has_name_ = 0
 388   name_ = ""
 389   has_value_ = 0
 390
 391   def __init__(self, contents=None):
 392     self.value_ = FieldValue()
 393     if contents is not None: self.MergeFromString(contents)
 394
 395   def name(self): return self.name_
 396
 397   def set_name(self, x):
 398     self.has_name_ = 1
 399     self.name_ = x
 400
 401   def clear_name(self):
 402     if self.has_name_:
 403       self.has_name_ = 0
 404       self.name_ = ""
 405
 406   def has_name(self): return self.has_name_
 407
 408   def value(self): return self.value_
 409
 410   def mutable_value(self): self.has_value_ = 1; return self.value_
 411
 412   def clear_value(self):self.has_value_ = 0; self.value_.Clear()
 413
 414   def has_value(self): return self.has_value_
 415
 416
 417   def MergeFrom(self, x):
 418     assert x is not self
 419     if (x.has_name()): self.set_name(x.name())
 420     if (x.has_value()): self.mutable_value().MergeFrom(x.value())
 421
 422   def Equals(self, x):
 423     if x is self: return 1
 424     if self.has_name_ != x.has_name_: return 0
 425     if self.has_name_ and self.name_ != x.name_: return 0
 426     if self.has_value_ != x.has_value_: return 0
 427     if self.has_value_ and self.value_ != x.value_: return 0
 428     return 1
 429
 430   def IsInitialized(self, debug_strs=None):
 431     initialized = 1
 432     if (not self.has_name_):
 433       initialized = 0
 434       if debug_strs is not None:
 435         debug_strs.append('Required field: name not set.')
 436     if (not self.has_value_):
 437       initialized = 0
 438       if debug_strs is not None:
 439         debug_strs.append('Required field: value not set.')
 440     elif not self.value_.IsInitialized(debug_strs): initialized = 0
 441     return initialized
 442
 443   def ByteSize(self):
 444     n = 0
 445     n += self.lengthString(len(self.name_))
 446     n += self.lengthString(self.value_.ByteSize())
 447     return n + 2
 448
 449   def ByteSizePartial(self):
 450     n = 0
 451     if (self.has_name_):
 452       n += 1
 453       n += self.lengthString(len(self.name_))
 454     if (self.has_value_):
 455       n += 1
 456       n += self.lengthString(self.value_.ByteSizePartial())
 457     return n
 458
 459   def Clear(self):
 460     self.clear_name()
 461     self.clear_value()
 462
 463   def OutputUnchecked(self, out):
 464     out.putVarInt32(10)
 465     out.putPrefixedString(self.name_)
 466     out.putVarInt32(18)
 467     out.putVarInt32(self.value_.ByteSize())
 468     self.value_.OutputUnchecked(out)
 469
 470   def OutputPartial(self, out):
 471     if (self.has_name_):
 472       out.putVarInt32(10)
 473       out.putPrefixedString(self.name_)
 474     if (self.has_value_):
 475       out.putVarInt32(18)
 476       out.putVarInt32(self.value_.ByteSizePartial())
 477       self.value_.OutputPartial(out)
 478
 479   def TryMerge(self, d):
 480     while d.avail() > 0:
 481       tt = d.getVarInt32()
 482       if tt == 10:
 483         self.set_name(d.getPrefixedString())
 484         continue
 485       if tt == 18:
 486         length = d.getVarInt32()
 487         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
 488         d.skip(length)
 489         self.mutable_value().TryMerge(tmp)
 490         continue
 491
 492
 493       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 494       d.skipData(tt)
 495
 496
 497   def __str__(self, prefix="", printElemNumber=0):
 498     res=""
 499     if self.has_name_: res+=prefix+("name: %s\n" % self.DebugFormatString(self.name_))
 500     if self.has_value_:
 501       res+=prefix+"value <\n"
 502       res+=self.value_.__str__(prefix + "  ", printElemNumber)
 503       res+=prefix+">\n"
 504     return res
 505
 506
 507   def _BuildTagLookupTable(sparse, maxtag, default=None):
 508     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
 509
 510   kname = 1
 511   kvalue = 2
 512
 513   _TEXT = _BuildTagLookupTable({
 514     0: "ErrorCode",
 515     1: "name",
 516     2: "value",
 517   }, 2)
 518
 519   _TYPES = _BuildTagLookupTable({
 520     0: ProtocolBuffer.Encoder.NUMERIC,
 521     1: ProtocolBuffer.Encoder.STRING,
 522     2: ProtocolBuffer.Encoder.STRING,
 523   }, 2, ProtocolBuffer.Encoder.MAX_TYPE)
 524
 525
 526   _STYLE = """"""
 527   _STYLE_CONTENT_TYPE = """"""
 528   _PROTO_DESCRIPTOR_NAME = 'storage_onestore_v3.Field'
 529 class FieldTypes(ProtocolBuffer.ProtocolMessage):
 530   has_name_ = 0
 531   name_ = ""
 532
 533   def __init__(self, contents=None):
 534     self.type_ = []
 535     if contents is not None: self.MergeFromString(contents)
 536
 537   def name(self): return self.name_
 538
 539   def set_name(self, x):
 540     self.has_name_ = 1
 541     self.name_ = x
 542
 543   def clear_name(self):
 544     if self.has_name_:
 545       self.has_name_ = 0
 546       self.name_ = ""
 547
 548   def has_name(self): return self.has_name_
 549
 550   def type_size(self): return len(self.type_)
 551   def type_list(self): return self.type_
 552
 553   def type(self, i):
 554     return self.type_[i]
 555
 556   def set_type(self, i, x):
 557     self.type_[i] = x
 558
 559   def add_type(self, x):
 560     self.type_.append(x)
 561
 562   def clear_type(self):
 563     self.type_ = []
 564
 565
 566   def MergeFrom(self, x):
 567     assert x is not self
 568     if (x.has_name()): self.set_name(x.name())
 569     for i in xrange(x.type_size()): self.add_type(x.type(i))
 570
 571   def Equals(self, x):
 572     if x is self: return 1
 573     if self.has_name_ != x.has_name_: return 0
 574     if self.has_name_ and self.name_ != x.name_: return 0
 575     if len(self.type_) != len(x.type_): return 0
 576     for e1, e2 in zip(self.type_, x.type_):
 577       if e1 != e2: return 0
 578     return 1
 579
 580   def IsInitialized(self, debug_strs=None):
 581     initialized = 1
 582     if (not self.has_name_):
 583       initialized = 0
 584       if debug_strs is not None:
 585         debug_strs.append('Required field: name not set.')
 586     return initialized
 587
 588   def ByteSize(self):
 589     n = 0
 590     n += self.lengthString(len(self.name_))
 591     n += 1 * len(self.type_)
 592     for i in xrange(len(self.type_)): n += self.lengthVarInt64(self.type_[i])
 593     return n + 1
 594
 595   def ByteSizePartial(self):
 596     n = 0
 597     if (self.has_name_):
 598       n += 1
 599       n += self.lengthString(len(self.name_))
 600     n += 1 * len(self.type_)
 601     for i in xrange(len(self.type_)): n += self.lengthVarInt64(self.type_[i])
 602     return n
 603
 604   def Clear(self):
 605     self.clear_name()
 606     self.clear_type()
 607
 608   def OutputUnchecked(self, out):
 609     out.putVarInt32(10)
 610     out.putPrefixedString(self.name_)
 611     for i in xrange(len(self.type_)):
 612       out.putVarInt32(16)
 613       out.putVarInt32(self.type_[i])
 614
 615   def OutputPartial(self, out):
 616     if (self.has_name_):
 617       out.putVarInt32(10)
 618       out.putPrefixedString(self.name_)
 619     for i in xrange(len(self.type_)):
 620       out.putVarInt32(16)
 621       out.putVarInt32(self.type_[i])
 622
 623   def TryMerge(self, d):
 624     while d.avail() > 0:
 625       tt = d.getVarInt32()
 626       if tt == 10:
 627         self.set_name(d.getPrefixedString())
 628         continue
 629       if tt == 16:
 630         self.add_type(d.getVarInt32())
 631         continue
 632
 633
 634       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 635       d.skipData(tt)
 636
 637
 638   def __str__(self, prefix="", printElemNumber=0):
 639     res=""
 640     if self.has_name_: res+=prefix+("name: %s\n" % self.DebugFormatString(self.name_))
 641     cnt=0
 642     for e in self.type_:
 643       elm=""
 644       if printElemNumber: elm="(%d)" % cnt
 645       res+=prefix+("type%s: %s\n" % (elm, self.DebugFormatInt32(e)))
 646       cnt+=1
 647     return res
 648
 649
 650   def _BuildTagLookupTable(sparse, maxtag, default=None):
 651     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
 652
 653   kname = 1
 654   ktype = 2
 655
 656   _TEXT = _BuildTagLookupTable({
 657     0: "ErrorCode",
 658     1: "name",
 659     2: "type",
 660   }, 2)
 661
 662   _TYPES = _BuildTagLookupTable({
 663     0: ProtocolBuffer.Encoder.NUMERIC,
 664     1: ProtocolBuffer.Encoder.STRING,
 665     2: ProtocolBuffer.Encoder.NUMERIC,
 666   }, 2, ProtocolBuffer.Encoder.MAX_TYPE)
 667
 668
 669   _STYLE = """"""
 670   _STYLE_CONTENT_TYPE = """"""
 671   _PROTO_DESCRIPTOR_NAME = 'storage_onestore_v3.FieldTypes'
 672 class IndexMetadata(ProtocolBuffer.ProtocolMessage):
 673   has_is_over_field_number_threshold_ = 0
 674   is_over_field_number_threshold_ = 0
 675
 676   def __init__(self, contents=None):
 677     if contents is not None: self.MergeFromString(contents)
 678
 679   def is_over_field_number_threshold(self): return self.is_over_field_number_threshold_
 680
 681   def set_is_over_field_number_threshold(self, x):
 682     self.has_is_over_field_number_threshold_ = 1
 683     self.is_over_field_number_threshold_ = x
 684
 685   def clear_is_over_field_number_threshold(self):
 686     if self.has_is_over_field_number_threshold_:
 687       self.has_is_over_field_number_threshold_ = 0
 688       self.is_over_field_number_threshold_ = 0
 689
 690   def has_is_over_field_number_threshold(self): return self.has_is_over_field_number_threshold_
 691
 692
 693   def MergeFrom(self, x):
 694     assert x is not self
 695     if (x.has_is_over_field_number_threshold()): self.set_is_over_field_number_threshold(x.is_over_field_number_threshold())
 696
 697   def Equals(self, x):
 698     if x is self: return 1
 699     if self.has_is_over_field_number_threshold_ != x.has_is_over_field_number_threshold_: return 0
 700     if self.has_is_over_field_number_threshold_ and self.is_over_field_number_threshold_ != x.is_over_field_number_threshold_: return 0
 701     return 1
 702
 703   def IsInitialized(self, debug_strs=None):
 704     initialized = 1
 705     return initialized
 706
 707   def ByteSize(self):
 708     n = 0
 709     if (self.has_is_over_field_number_threshold_): n += 2
 710     return n
 711
 712   def ByteSizePartial(self):
 713     n = 0
 714     if (self.has_is_over_field_number_threshold_): n += 2
 715     return n
 716
 717   def Clear(self):
 718     self.clear_is_over_field_number_threshold()
 719
 720   def OutputUnchecked(self, out):
 721     if (self.has_is_over_field_number_threshold_):
 722       out.putVarInt32(8)
 723       out.putBoolean(self.is_over_field_number_threshold_)
 724
 725   def OutputPartial(self, out):
 726     if (self.has_is_over_field_number_threshold_):
 727       out.putVarInt32(8)
 728       out.putBoolean(self.is_over_field_number_threshold_)
 729
 730   def TryMerge(self, d):
 731     while d.avail() > 0:
 732       tt = d.getVarInt32()
 733       if tt == 8:
 734         self.set_is_over_field_number_threshold(d.getBoolean())
 735         continue
 736
 737
 738       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 739       d.skipData(tt)
 740
 741
 742   def __str__(self, prefix="", printElemNumber=0):
 743     res=""
 744     if self.has_is_over_field_number_threshold_: res+=prefix+("is_over_field_number_threshold: %s\n" % self.DebugFormatBool(self.is_over_field_number_threshold_))
 745     return res
 746
 747
 748   def _BuildTagLookupTable(sparse, maxtag, default=None):
 749     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
 750
 751   kis_over_field_number_threshold = 1
 752
 753   _TEXT = _BuildTagLookupTable({
 754     0: "ErrorCode",
 755     1: "is_over_field_number_threshold",
 756   }, 1)
 757
 758   _TYPES = _BuildTagLookupTable({
 759     0: ProtocolBuffer.Encoder.NUMERIC,
 760     1: ProtocolBuffer.Encoder.NUMERIC,
 761   }, 1, ProtocolBuffer.Encoder.MAX_TYPE)
 762
 763
 764   _STYLE = """"""
 765   _STYLE_CONTENT_TYPE = """"""
 766   _PROTO_DESCRIPTOR_NAME = 'storage_onestore_v3.IndexMetadata'
 767 class FacetValue(ProtocolBuffer.ProtocolMessage):
 768
 769
 770   ATOM         =    2
 771   NUMBER       =    4
 772
 773   _ContentType_NAMES = {
 774     2: "ATOM",
 775     4: "NUMBER",
 776   }
 777
 778   def ContentType_Name(cls, x): return cls._ContentType_NAMES.get(x, "")
 779   ContentType_Name = classmethod(ContentType_Name)
 780
 781   has_type_ = 0
 782   type_ = 2
 783   has_string_value_ = 0
 784   string_value_ = ""
 785
 786   def __init__(self, contents=None):
 787     if contents is not None: self.MergeFromString(contents)
 788
 789   def type(self): return self.type_
 790
 791   def set_type(self, x):
 792     self.has_type_ = 1
 793     self.type_ = x
 794
 795   def clear_type(self):
 796     if self.has_type_:
 797       self.has_type_ = 0
 798       self.type_ = 2
 799
 800   def has_type(self): return self.has_type_
 801
 802   def string_value(self): return self.string_value_
 803
 804   def set_string_value(self, x):
 805     self.has_string_value_ = 1
 806     self.string_value_ = x
 807
 808   def clear_string_value(self):
 809     if self.has_string_value_:
 810       self.has_string_value_ = 0
 811       self.string_value_ = ""
 812
 813   def has_string_value(self): return self.has_string_value_
 814
 815
 816   def MergeFrom(self, x):
 817     assert x is not self
 818     if (x.has_type()): self.set_type(x.type())
 819     if (x.has_string_value()): self.set_string_value(x.string_value())
 820
 821   def Equals(self, x):
 822     if x is self: return 1
 823     if self.has_type_ != x.has_type_: return 0
 824     if self.has_type_ and self.type_ != x.type_: return 0
 825     if self.has_string_value_ != x.has_string_value_: return 0
 826     if self.has_string_value_ and self.string_value_ != x.string_value_: return 0
 827     return 1
 828
 829   def IsInitialized(self, debug_strs=None):
 830     initialized = 1
 831     return initialized
 832
 833   def ByteSize(self):
 834     n = 0
 835     if (self.has_type_): n += 1 + self.lengthVarInt64(self.type_)
 836     if (self.has_string_value_): n += 1 + self.lengthString(len(self.string_value_))
 837     return n
 838
 839   def ByteSizePartial(self):
 840     n = 0
 841     if (self.has_type_): n += 1 + self.lengthVarInt64(self.type_)
 842     if (self.has_string_value_): n += 1 + self.lengthString(len(self.string_value_))
 843     return n
 844
 845   def Clear(self):
 846     self.clear_type()
 847     self.clear_string_value()
 848
 849   def OutputUnchecked(self, out):
 850     if (self.has_type_):
 851       out.putVarInt32(8)
 852       out.putVarInt32(self.type_)
 853     if (self.has_string_value_):
 854       out.putVarInt32(26)
 855       out.putPrefixedString(self.string_value_)
 856
 857   def OutputPartial(self, out):
 858     if (self.has_type_):
 859       out.putVarInt32(8)
 860       out.putVarInt32(self.type_)
 861     if (self.has_string_value_):
 862       out.putVarInt32(26)
 863       out.putPrefixedString(self.string_value_)
 864
 865   def TryMerge(self, d):
 866     while d.avail() > 0:
 867       tt = d.getVarInt32()
 868       if tt == 8:
 869         self.set_type(d.getVarInt32())
 870         continue
 871       if tt == 26:
 872         self.set_string_value(d.getPrefixedString())
 873         continue
 874
 875
 876       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 877       d.skipData(tt)
 878
 879
 880   def __str__(self, prefix="", printElemNumber=0):
 881     res=""
 882     if self.has_type_: res+=prefix+("type: %s\n" % self.DebugFormatInt32(self.type_))
 883     if self.has_string_value_: res+=prefix+("string_value: %s\n" % self.DebugFormatString(self.string_value_))
 884     return res
 885
 886
 887   def _BuildTagLookupTable(sparse, maxtag, default=None):
 888     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
 889
 890   ktype = 1
 891   kstring_value = 3
 892
 893   _TEXT = _BuildTagLookupTable({
 894     0: "ErrorCode",
 895     1: "type",
 896     3: "string_value",
 897   }, 3)
 898
 899   _TYPES = _BuildTagLookupTable({
 900     0: ProtocolBuffer.Encoder.NUMERIC,
 901     1: ProtocolBuffer.Encoder.NUMERIC,
 902     3: ProtocolBuffer.Encoder.STRING,
 903   }, 3, ProtocolBuffer.Encoder.MAX_TYPE)
 904
 905
 906   _STYLE = """"""
 907   _STYLE_CONTENT_TYPE = """"""
 908   _PROTO_DESCRIPTOR_NAME = 'storage_onestore_v3.FacetValue'
 909 class Facet(ProtocolBuffer.ProtocolMessage):
 910   has_name_ = 0
 911   name_ = ""
 912   has_value_ = 0
 913
 914   def __init__(self, contents=None):
 915     self.value_ = FacetValue()
 916     if contents is not None: self.MergeFromString(contents)
 917
 918   def name(self): return self.name_
 919
 920   def set_name(self, x):
 921     self.has_name_ = 1
 922     self.name_ = x
 923
 924   def clear_name(self):
 925     if self.has_name_:
 926       self.has_name_ = 0
 927       self.name_ = ""
 928
 929   def has_name(self): return self.has_name_
 930
 931   def value(self): return self.value_
 932
 933   def mutable_value(self): self.has_value_ = 1; return self.value_
 934
 935   def clear_value(self):self.has_value_ = 0; self.value_.Clear()
 936
 937   def has_value(self): return self.has_value_
 938
 939
 940   def MergeFrom(self, x):
 941     assert x is not self
 942     if (x.has_name()): self.set_name(x.name())
 943     if (x.has_value()): self.mutable_value().MergeFrom(x.value())
 944
 945   def Equals(self, x):
 946     if x is self: return 1
 947     if self.has_name_ != x.has_name_: return 0
 948     if self.has_name_ and self.name_ != x.name_: return 0
 949     if self.has_value_ != x.has_value_: return 0
 950     if self.has_value_ and self.value_ != x.value_: return 0
 951     return 1
 952
 953   def IsInitialized(self, debug_strs=None):
 954     initialized = 1
 955     if (not self.has_name_):
 956       initialized = 0
 957       if debug_strs is not None:
 958         debug_strs.append('Required field: name not set.')
 959     if (not self.has_value_):
 960       initialized = 0
 961       if debug_strs is not None:
 962         debug_strs.append('Required field: value not set.')
 963     elif not self.value_.IsInitialized(debug_strs): initialized = 0
 964     return initialized
 965
 966   def ByteSize(self):
 967     n = 0
 968     n += self.lengthString(len(self.name_))
 969     n += self.lengthString(self.value_.ByteSize())
 970     return n + 2
 971
 972   def ByteSizePartial(self):
 973     n = 0
 974     if (self.has_name_):
 975       n += 1
 976       n += self.lengthString(len(self.name_))
 977     if (self.has_value_):
 978       n += 1
 979       n += self.lengthString(self.value_.ByteSizePartial())
 980     return n
 981
 982   def Clear(self):
 983     self.clear_name()
 984     self.clear_value()
 985
 986   def OutputUnchecked(self, out):
 987     out.putVarInt32(10)
 988     out.putPrefixedString(self.name_)
 989     out.putVarInt32(18)
 990     out.putVarInt32(self.value_.ByteSize())
 991     self.value_.OutputUnchecked(out)
 992
 993   def OutputPartial(self, out):
 994     if (self.has_name_):
 995       out.putVarInt32(10)
 996       out.putPrefixedString(self.name_)
 997     if (self.has_value_):
 998       out.putVarInt32(18)
 999       out.putVarInt32(self.value_.ByteSizePartial())
1000       self.value_.OutputPartial(out)
1001
1002   def TryMerge(self, d):
1003     while d.avail() > 0:
1004       tt = d.getVarInt32()
1005       if tt == 10:
1006         self.set_name(d.getPrefixedString())
1007         continue
1008       if tt == 18:
1009         length = d.getVarInt32()
1010         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
1011         d.skip(length)
1012         self.mutable_value().TryMerge(tmp)
1013         continue
1014
1015
1016       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1017       d.skipData(tt)
1018
1019
1020   def __str__(self, prefix="", printElemNumber=0):
1021     res=""
1022     if self.has_name_: res+=prefix+("name: %s\n" % self.DebugFormatString(self.name_))
1023     if self.has_value_:
1024       res+=prefix+"value <\n"
1025       res+=self.value_.__str__(prefix + "  ", printElemNumber)
1026       res+=prefix+">\n"
1027     return res
1028
1029
1030   def _BuildTagLookupTable(sparse, maxtag, default=None):
1031     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
1032
1033   kname = 1
1034   kvalue = 2
1035
1036   _TEXT = _BuildTagLookupTable({
1037     0: "ErrorCode",
1038     1: "name",
1039     2: "value",
1040   }, 2)
1041
1042   _TYPES = _BuildTagLookupTable({
1043     0: ProtocolBuffer.Encoder.NUMERIC,
1044     1: ProtocolBuffer.Encoder.STRING,
1045     2: ProtocolBuffer.Encoder.STRING,
1046   }, 2, ProtocolBuffer.Encoder.MAX_TYPE)
1047
1048
1049   _STYLE = """"""
1050   _STYLE_CONTENT_TYPE = """"""
1051   _PROTO_DESCRIPTOR_NAME = 'storage_onestore_v3.Facet'
1052 class DocumentMetadata(ProtocolBuffer.ProtocolMessage):
1053   has_version_ = 0
1054   version_ = 0
1055
1056   def __init__(self, contents=None):
1057     if contents is not None: self.MergeFromString(contents)
1058
1059   def version(self): return self.version_
1060
1061   def set_version(self, x):
1062     self.has_version_ = 1
1063     self.version_ = x
1064
1065   def clear_version(self):
1066     if self.has_version_:
1067       self.has_version_ = 0
1068       self.version_ = 0
1069
1070   def has_version(self): return self.has_version_
1071
1072
1073   def MergeFrom(self, x):
1074     assert x is not self
1075     if (x.has_version()): self.set_version(x.version())
1076
1077   def Equals(self, x):
1078     if x is self: return 1
1079     if self.has_version_ != x.has_version_: return 0
1080     if self.has_version_ and self.version_ != x.version_: return 0
1081     return 1
1082
1083   def IsInitialized(self, debug_strs=None):
1084     initialized = 1
1085     return initialized
1086
1087   def ByteSize(self):
1088     n = 0
1089     if (self.has_version_): n += 1 + self.lengthVarInt64(self.version_)
1090     return n
1091
1092   def ByteSizePartial(self):
1093     n = 0
1094     if (self.has_version_): n += 1 + self.lengthVarInt64(self.version_)
1095     return n
1096
1097   def Clear(self):
1098     self.clear_version()
1099
1100   def OutputUnchecked(self, out):
1101     if (self.has_version_):
1102       out.putVarInt32(8)
1103       out.putVarInt64(self.version_)
1104
1105   def OutputPartial(self, out):
1106     if (self.has_version_):
1107       out.putVarInt32(8)
1108       out.putVarInt64(self.version_)
1109
1110   def TryMerge(self, d):
1111     while d.avail() > 0:
1112       tt = d.getVarInt32()
1113       if tt == 8:
1114         self.set_version(d.getVarInt64())
1115         continue
1116
1117
1118       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1119       d.skipData(tt)
1120
1121
1122   def __str__(self, prefix="", printElemNumber=0):
1123     res=""
1124     if self.has_version_: res+=prefix+("version: %s\n" % self.DebugFormatInt64(self.version_))
1125     return res
1126
1127
1128   def _BuildTagLookupTable(sparse, maxtag, default=None):
1129     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
1130
1131   kversion = 1
1132
1133   _TEXT = _BuildTagLookupTable({
1134     0: "ErrorCode",
1135     1: "version",
1136   }, 1)
1137
1138   _TYPES = _BuildTagLookupTable({
1139     0: ProtocolBuffer.Encoder.NUMERIC,
1140     1: ProtocolBuffer.Encoder.NUMERIC,
1141   }, 1, ProtocolBuffer.Encoder.MAX_TYPE)
1142
1143
1144   _STYLE = """"""
1145   _STYLE_CONTENT_TYPE = """"""
1146   _PROTO_DESCRIPTOR_NAME = 'storage_onestore_v3.DocumentMetadata'
1147 class Document(ProtocolBuffer.ProtocolMessage):
1148
1149
1150   DISK         =    0
1151
1152   _Storage_NAMES = {
1153     0: "DISK",
1154   }
1155
1156   def Storage_Name(cls, x): return cls._Storage_NAMES.get(x, "")
1157   Storage_Name = classmethod(Storage_Name)
1158
1159   has_id_ = 0
1160   id_ = ""
1161   has_language_ = 0
1162   language_ = "en"
1163   has_order_id_ = 0
1164   order_id_ = 0
1165   has_storage_ = 0
1166   storage_ = 0
1167   has_acl_ = 0
1168   acl_ = None
1169
1170   def __init__(self, contents=None):
1171     self.field_ = []
1172     self.facet_ = []
1173     self.lazy_init_lock_ = thread.allocate_lock()
1174     if contents is not None: self.MergeFromString(contents)
1175
1176   def id(self): return self.id_
1177
1178   def set_id(self, x):
1179     self.has_id_ = 1
1180     self.id_ = x
1181
1182   def clear_id(self):
1183     if self.has_id_:
1184       self.has_id_ = 0
1185       self.id_ = ""
1186
1187   def has_id(self): return self.has_id_
1188
1189   def language(self): return self.language_
1190
1191   def set_language(self, x):
1192     self.has_language_ = 1
1193     self.language_ = x
1194
1195   def clear_language(self):
1196     if self.has_language_:
1197       self.has_language_ = 0
1198       self.language_ = "en"
1199
1200   def has_language(self): return self.has_language_
1201
1202   def field_size(self): return len(self.field_)
1203   def field_list(self): return self.field_
1204
1205   def field(self, i):
1206     return self.field_[i]
1207
1208   def mutable_field(self, i):
1209     return self.field_[i]
1210
1211   def add_field(self):
1212     x = Field()
1213     self.field_.append(x)
1214     return x
1215
1216   def clear_field(self):
1217     self.field_ = []
1218   def order_id(self): return self.order_id_
1219
1220   def set_order_id(self, x):
1221     self.has_order_id_ = 1
1222     self.order_id_ = x
1223
1224   def clear_order_id(self):
1225     if self.has_order_id_:
1226       self.has_order_id_ = 0
1227       self.order_id_ = 0
1228
1229   def has_order_id(self): return self.has_order_id_
1230
1231   def storage(self): return self.storage_
1232
1233   def set_storage(self, x):
1234     self.has_storage_ = 1
1235     self.storage_ = x
1236
1237   def clear_storage(self):
1238     if self.has_storage_:
1239       self.has_storage_ = 0
1240       self.storage_ = 0
1241
1242   def has_storage(self): return self.has_storage_
1243
1244   def acl(self):
1245     if self.acl_ is None:
1246       self.lazy_init_lock_.acquire()
1247       try:
1248         if self.acl_ is None: self.acl_ = AccessControlList()
1249       finally:
1250         self.lazy_init_lock_.release()
1251     return self.acl_
1252
1253   def mutable_acl(self): self.has_acl_ = 1; return self.acl()
1254
1255   def clear_acl(self):
1256
1257     if self.has_acl_:
1258       self.has_acl_ = 0;
1259       if self.acl_ is not None: self.acl_.Clear()
1260
1261   def has_acl(self): return self.has_acl_
1262
1263   def facet_size(self): return len(self.facet_)
1264   def facet_list(self): return self.facet_
1265
1266   def facet(self, i):
1267     return self.facet_[i]
1268
1269   def mutable_facet(self, i):
1270     return self.facet_[i]
1271
1272   def add_facet(self):
1273     x = Facet()
1274     self.facet_.append(x)
1275     return x
1276
1277   def clear_facet(self):
1278     self.facet_ = []
1279
1280   def MergeFrom(self, x):
1281     assert x is not self
1282     if (x.has_id()): self.set_id(x.id())
1283     if (x.has_language()): self.set_language(x.language())
1284     for i in xrange(x.field_size()): self.add_field().CopyFrom(x.field(i))
1285     if (x.has_order_id()): self.set_order_id(x.order_id())
1286     if (x.has_storage()): self.set_storage(x.storage())
1287     if (x.has_acl()): self.mutable_acl().MergeFrom(x.acl())
1288     for i in xrange(x.facet_size()): self.add_facet().CopyFrom(x.facet(i))
1289
1290   def Equals(self, x):
1291     if x is self: return 1
1292     if self.has_id_ != x.has_id_: return 0
1293     if self.has_id_ and self.id_ != x.id_: return 0
1294     if self.has_language_ != x.has_language_: return 0
1295     if self.has_language_ and self.language_ != x.language_: return 0
1296     if len(self.field_) != len(x.field_): return 0
1297     for e1, e2 in zip(self.field_, x.field_):
1298       if e1 != e2: return 0
1299     if self.has_order_id_ != x.has_order_id_: return 0
1300     if self.has_order_id_ and self.order_id_ != x.order_id_: return 0
1301     if self.has_storage_ != x.has_storage_: return 0
1302     if self.has_storage_ and self.storage_ != x.storage_: return 0
1303     if self.has_acl_ != x.has_acl_: return 0
1304     if self.has_acl_ and self.acl_ != x.acl_: return 0
1305     if len(self.facet_) != len(x.facet_): return 0
1306     for e1, e2 in zip(self.facet_, x.facet_):
1307       if e1 != e2: return 0
1308     return 1
1309
1310   def IsInitialized(self, debug_strs=None):
1311     initialized = 1
1312     for p in self.field_:
1313       if not p.IsInitialized(debug_strs): initialized=0
1314     if (self.has_acl_ and not self.acl_.IsInitialized(debug_strs)): initialized = 0
1315     for p in self.facet_:
1316       if not p.IsInitialized(debug_strs): initialized=0
1317     return initialized
1318
1319   def ByteSize(self):
1320     n = 0
1321     if (self.has_id_): n += 1 + self.lengthString(len(self.id_))
1322     if (self.has_language_): n += 1 + self.lengthString(len(self.language_))
1323     n += 1 * len(self.field_)
1324     for i in xrange(len(self.field_)): n += self.lengthString(self.field_[i].ByteSize())
1325     if (self.has_order_id_): n += 1 + self.lengthVarInt64(self.order_id_)
1326     if (self.has_storage_): n += 1 + self.lengthVarInt64(self.storage_)
1327     if (self.has_acl_): n += 1 + self.lengthString(self.acl_.ByteSize())
1328     n += 1 * len(self.facet_)
1329     for i in xrange(len(self.facet_)): n += self.lengthString(self.facet_[i].ByteSize())
1330     return n
1331
1332   def ByteSizePartial(self):
1333     n = 0
1334     if (self.has_id_): n += 1 + self.lengthString(len(self.id_))
1335     if (self.has_language_): n += 1 + self.lengthString(len(self.language_))
1336     n += 1 * len(self.field_)
1337     for i in xrange(len(self.field_)): n += self.lengthString(self.field_[i].ByteSizePartial())
1338     if (self.has_order_id_): n += 1 + self.lengthVarInt64(self.order_id_)
1339     if (self.has_storage_): n += 1 + self.lengthVarInt64(self.storage_)
1340     if (self.has_acl_): n += 1 + self.lengthString(self.acl_.ByteSizePartial())
1341     n += 1 * len(self.facet_)
1342     for i in xrange(len(self.facet_)): n += self.lengthString(self.facet_[i].ByteSizePartial())
1343     return n
1344
1345   def Clear(self):
1346     self.clear_id()
1347     self.clear_language()
1348     self.clear_field()
1349     self.clear_order_id()
1350     self.clear_storage()
1351     self.clear_acl()
1352     self.clear_facet()
1353
1354   def OutputUnchecked(self, out):
1355     if (self.has_id_):
1356       out.putVarInt32(10)
1357       out.putPrefixedString(self.id_)
1358     if (self.has_language_):
1359       out.putVarInt32(18)
1360       out.putPrefixedString(self.language_)
1361     for i in xrange(len(self.field_)):
1362       out.putVarInt32(26)
1363       out.putVarInt32(self.field_[i].ByteSize())
1364       self.field_[i].OutputUnchecked(out)
1365     if (self.has_order_id_):
1366       out.putVarInt32(32)
1367       out.putVarInt32(self.order_id_)
1368     if (self.has_storage_):
1369       out.putVarInt32(40)
1370       out.putVarInt32(self.storage_)
1371     if (self.has_acl_):
1372       out.putVarInt32(50)
1373       out.putVarInt32(self.acl_.ByteSize())
1374       self.acl_.OutputUnchecked(out)
1375     for i in xrange(len(self.facet_)):
1376       out.putVarInt32(66)
1377       out.putVarInt32(self.facet_[i].ByteSize())
1378       self.facet_[i].OutputUnchecked(out)
1379
1380   def OutputPartial(self, out):
1381     if (self.has_id_):
1382       out.putVarInt32(10)
1383       out.putPrefixedString(self.id_)
1384     if (self.has_language_):
1385       out.putVarInt32(18)
1386       out.putPrefixedString(self.language_)
1387     for i in xrange(len(self.field_)):
1388       out.putVarInt32(26)
1389       out.putVarInt32(self.field_[i].ByteSizePartial())
1390       self.field_[i].OutputPartial(out)
1391     if (self.has_order_id_):
1392       out.putVarInt32(32)
1393       out.putVarInt32(self.order_id_)
1394     if (self.has_storage_):
1395       out.putVarInt32(40)
1396       out.putVarInt32(self.storage_)
1397     if (self.has_acl_):
1398       out.putVarInt32(50)
1399       out.putVarInt32(self.acl_.ByteSizePartial())
1400       self.acl_.OutputPartial(out)
1401     for i in xrange(len(self.facet_)):
1402       out.putVarInt32(66)
1403       out.putVarInt32(self.facet_[i].ByteSizePartial())
1404       self.facet_[i].OutputPartial(out)
1405
1406   def TryMerge(self, d):
1407     while d.avail() > 0:
1408       tt = d.getVarInt32()
1409       if tt == 10:
1410         self.set_id(d.getPrefixedString())
1411         continue
1412       if tt == 18:
1413         self.set_language(d.getPrefixedString())
1414         continue
1415       if tt == 26:
1416         length = d.getVarInt32()
1417         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
1418         d.skip(length)
1419         self.add_field().TryMerge(tmp)
1420         continue
1421       if tt == 32:
1422         self.set_order_id(d.getVarInt32())
1423         continue
1424       if tt == 40:
1425         self.set_storage(d.getVarInt32())
1426         continue
1427       if tt == 50:
1428         length = d.getVarInt32()
1429         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
1430         d.skip(length)
1431         self.mutable_acl().TryMerge(tmp)
1432         continue
1433       if tt == 66:
1434         length = d.getVarInt32()
1435         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
1436         d.skip(length)
1437         self.add_facet().TryMerge(tmp)
1438         continue
1439
1440
1441       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1442       d.skipData(tt)
1443
1444
1445   def __str__(self, prefix="", printElemNumber=0):
1446     res=""
1447     if self.has_id_: res+=prefix+("id: %s\n" % self.DebugFormatString(self.id_))
1448     if self.has_language_: res+=prefix+("language: %s\n" % self.DebugFormatString(self.language_))
1449     cnt=0
1450     for e in self.field_:
1451       elm=""
1452       if printElemNumber: elm="(%d)" % cnt
1453       res+=prefix+("field%s <\n" % elm)
1454       res+=e.__str__(prefix + "  ", printElemNumber)
1455       res+=prefix+">\n"
1456       cnt+=1
1457     if self.has_order_id_: res+=prefix+("order_id: %s\n" % self.DebugFormatInt32(self.order_id_))
1458     if self.has_storage_: res+=prefix+("storage: %s\n" % self.DebugFormatInt32(self.storage_))
1459     if self.has_acl_:
1460       res+=prefix+"acl <\n"
1461       res+=self.acl_.__str__(prefix + "  ", printElemNumber)
1462       res+=prefix+">\n"
1463     cnt=0
1464     for e in self.facet_:
1465       elm=""
1466       if printElemNumber: elm="(%d)" % cnt
1467       res+=prefix+("facet%s <\n" % elm)
1468       res+=e.__str__(prefix + "  ", printElemNumber)
1469       res+=prefix+">\n"
1470       cnt+=1
1471     return res
1472
1473
1474   def _BuildTagLookupTable(sparse, maxtag, default=None):
1475     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
1476
1477   kid = 1
1478   klanguage = 2
1479   kfield = 3
1480   korder_id = 4
1481   kstorage = 5
1482   kacl = 6
1483   kfacet = 8
1484
1485   _TEXT = _BuildTagLookupTable({
1486     0: "ErrorCode",
1487     1: "id",
1488     2: "language",
1489     3: "field",
1490     4: "order_id",
1491     5: "storage",
1492     6: "acl",
1493     8: "facet",
1494   }, 8)
1495
1496   _TYPES = _BuildTagLookupTable({
1497     0: ProtocolBuffer.Encoder.NUMERIC,
1498     1: ProtocolBuffer.Encoder.STRING,
1499     2: ProtocolBuffer.Encoder.STRING,
1500     3: ProtocolBuffer.Encoder.STRING,
1501     4: ProtocolBuffer.Encoder.NUMERIC,
1502     5: ProtocolBuffer.Encoder.NUMERIC,
1503     6: ProtocolBuffer.Encoder.STRING,
1504     8: ProtocolBuffer.Encoder.STRING,
1505   }, 8, ProtocolBuffer.Encoder.MAX_TYPE)
1506
1507
1508   _STYLE = """"""
1509   _STYLE_CONTENT_TYPE = """"""
1510   _PROTO_DESCRIPTOR_NAME = 'storage_onestore_v3.Document'
1511 if _extension_runtime:
1512   pass
1513
1514 __all__ = ['FieldValue','FieldValue_Geo','Field','FieldTypes','IndexMetadata','FacetValue','Facet','DocumentMetadata','Document']