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 FacetValue(ProtocolBuffer.ProtocolMessage):
 673
 674
 675   ATOM         =    2
 676   NUMBER       =    4
 677
 678   _ContentType_NAMES = {
 679     2: "ATOM",
 680     4: "NUMBER",
 681   }
 682
 683   def ContentType_Name(cls, x): return cls._ContentType_NAMES.get(x, "")
 684   ContentType_Name = classmethod(ContentType_Name)
 685
 686   has_type_ = 0
 687   type_ = 2
 688   has_string_value_ = 0
 689   string_value_ = ""
 690
 691   def __init__(self, contents=None):
 692     if contents is not None: self.MergeFromString(contents)
 693
 694   def type(self): return self.type_
 695
 696   def set_type(self, x):
 697     self.has_type_ = 1
 698     self.type_ = x
 699
 700   def clear_type(self):
 701     if self.has_type_:
 702       self.has_type_ = 0
 703       self.type_ = 2
 704
 705   def has_type(self): return self.has_type_
 706
 707   def string_value(self): return self.string_value_
 708
 709   def set_string_value(self, x):
 710     self.has_string_value_ = 1
 711     self.string_value_ = x
 712
 713   def clear_string_value(self):
 714     if self.has_string_value_:
 715       self.has_string_value_ = 0
 716       self.string_value_ = ""
 717
 718   def has_string_value(self): return self.has_string_value_
 719
 720
 721   def MergeFrom(self, x):
 722     assert x is not self
 723     if (x.has_type()): self.set_type(x.type())
 724     if (x.has_string_value()): self.set_string_value(x.string_value())
 725
 726   def Equals(self, x):
 727     if x is self: return 1
 728     if self.has_type_ != x.has_type_: return 0
 729     if self.has_type_ and self.type_ != x.type_: return 0
 730     if self.has_string_value_ != x.has_string_value_: return 0
 731     if self.has_string_value_ and self.string_value_ != x.string_value_: return 0
 732     return 1
 733
 734   def IsInitialized(self, debug_strs=None):
 735     initialized = 1
 736     return initialized
 737
 738   def ByteSize(self):
 739     n = 0
 740     if (self.has_type_): n += 1 + self.lengthVarInt64(self.type_)
 741     if (self.has_string_value_): n += 1 + self.lengthString(len(self.string_value_))
 742     return n
 743
 744   def ByteSizePartial(self):
 745     n = 0
 746     if (self.has_type_): n += 1 + self.lengthVarInt64(self.type_)
 747     if (self.has_string_value_): n += 1 + self.lengthString(len(self.string_value_))
 748     return n
 749
 750   def Clear(self):
 751     self.clear_type()
 752     self.clear_string_value()
 753
 754   def OutputUnchecked(self, out):
 755     if (self.has_type_):
 756       out.putVarInt32(8)
 757       out.putVarInt32(self.type_)
 758     if (self.has_string_value_):
 759       out.putVarInt32(26)
 760       out.putPrefixedString(self.string_value_)
 761
 762   def OutputPartial(self, out):
 763     if (self.has_type_):
 764       out.putVarInt32(8)
 765       out.putVarInt32(self.type_)
 766     if (self.has_string_value_):
 767       out.putVarInt32(26)
 768       out.putPrefixedString(self.string_value_)
 769
 770   def TryMerge(self, d):
 771     while d.avail() > 0:
 772       tt = d.getVarInt32()
 773       if tt == 8:
 774         self.set_type(d.getVarInt32())
 775         continue
 776       if tt == 26:
 777         self.set_string_value(d.getPrefixedString())
 778         continue
 779
 780
 781       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 782       d.skipData(tt)
 783
 784
 785   def __str__(self, prefix="", printElemNumber=0):
 786     res=""
 787     if self.has_type_: res+=prefix+("type: %s\n" % self.DebugFormatInt32(self.type_))
 788     if self.has_string_value_: res+=prefix+("string_value: %s\n" % self.DebugFormatString(self.string_value_))
 789     return res
 790
 791
 792   def _BuildTagLookupTable(sparse, maxtag, default=None):
 793     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
 794
 795   ktype = 1
 796   kstring_value = 3
 797
 798   _TEXT = _BuildTagLookupTable({
 799     0: "ErrorCode",
 800     1: "type",
 801     3: "string_value",
 802   }, 3)
 803
 804   _TYPES = _BuildTagLookupTable({
 805     0: ProtocolBuffer.Encoder.NUMERIC,
 806     1: ProtocolBuffer.Encoder.NUMERIC,
 807     3: ProtocolBuffer.Encoder.STRING,
 808   }, 3, ProtocolBuffer.Encoder.MAX_TYPE)
 809
 810
 811   _STYLE = """"""
 812   _STYLE_CONTENT_TYPE = """"""
 813   _PROTO_DESCRIPTOR_NAME = 'storage_onestore_v3.FacetValue'
 814 class Facet(ProtocolBuffer.ProtocolMessage):
 815   has_name_ = 0
 816   name_ = ""
 817   has_value_ = 0
 818
 819   def __init__(self, contents=None):
 820     self.value_ = FacetValue()
 821     if contents is not None: self.MergeFromString(contents)
 822
 823   def name(self): return self.name_
 824
 825   def set_name(self, x):
 826     self.has_name_ = 1
 827     self.name_ = x
 828
 829   def clear_name(self):
 830     if self.has_name_:
 831       self.has_name_ = 0
 832       self.name_ = ""
 833
 834   def has_name(self): return self.has_name_
 835
 836   def value(self): return self.value_
 837
 838   def mutable_value(self): self.has_value_ = 1; return self.value_
 839
 840   def clear_value(self):self.has_value_ = 0; self.value_.Clear()
 841
 842   def has_value(self): return self.has_value_
 843
 844
 845   def MergeFrom(self, x):
 846     assert x is not self
 847     if (x.has_name()): self.set_name(x.name())
 848     if (x.has_value()): self.mutable_value().MergeFrom(x.value())
 849
 850   def Equals(self, x):
 851     if x is self: return 1
 852     if self.has_name_ != x.has_name_: return 0
 853     if self.has_name_ and self.name_ != x.name_: return 0
 854     if self.has_value_ != x.has_value_: return 0
 855     if self.has_value_ and self.value_ != x.value_: return 0
 856     return 1
 857
 858   def IsInitialized(self, debug_strs=None):
 859     initialized = 1
 860     if (not self.has_name_):
 861       initialized = 0
 862       if debug_strs is not None:
 863         debug_strs.append('Required field: name not set.')
 864     if (not self.has_value_):
 865       initialized = 0
 866       if debug_strs is not None:
 867         debug_strs.append('Required field: value not set.')
 868     elif not self.value_.IsInitialized(debug_strs): initialized = 0
 869     return initialized
 870
 871   def ByteSize(self):
 872     n = 0
 873     n += self.lengthString(len(self.name_))
 874     n += self.lengthString(self.value_.ByteSize())
 875     return n + 2
 876
 877   def ByteSizePartial(self):
 878     n = 0
 879     if (self.has_name_):
 880       n += 1
 881       n += self.lengthString(len(self.name_))
 882     if (self.has_value_):
 883       n += 1
 884       n += self.lengthString(self.value_.ByteSizePartial())
 885     return n
 886
 887   def Clear(self):
 888     self.clear_name()
 889     self.clear_value()
 890
 891   def OutputUnchecked(self, out):
 892     out.putVarInt32(10)
 893     out.putPrefixedString(self.name_)
 894     out.putVarInt32(18)
 895     out.putVarInt32(self.value_.ByteSize())
 896     self.value_.OutputUnchecked(out)
 897
 898   def OutputPartial(self, out):
 899     if (self.has_name_):
 900       out.putVarInt32(10)
 901       out.putPrefixedString(self.name_)
 902     if (self.has_value_):
 903       out.putVarInt32(18)
 904       out.putVarInt32(self.value_.ByteSizePartial())
 905       self.value_.OutputPartial(out)
 906
 907   def TryMerge(self, d):
 908     while d.avail() > 0:
 909       tt = d.getVarInt32()
 910       if tt == 10:
 911         self.set_name(d.getPrefixedString())
 912         continue
 913       if tt == 18:
 914         length = d.getVarInt32()
 915         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
 916         d.skip(length)
 917         self.mutable_value().TryMerge(tmp)
 918         continue
 919
 920
 921       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 922       d.skipData(tt)
 923
 924
 925   def __str__(self, prefix="", printElemNumber=0):
 926     res=""
 927     if self.has_name_: res+=prefix+("name: %s\n" % self.DebugFormatString(self.name_))
 928     if self.has_value_:
 929       res+=prefix+"value <\n"
 930       res+=self.value_.__str__(prefix + "  ", printElemNumber)
 931       res+=prefix+">\n"
 932     return res
 933
 934
 935   def _BuildTagLookupTable(sparse, maxtag, default=None):
 936     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
 937
 938   kname = 1
 939   kvalue = 2
 940
 941   _TEXT = _BuildTagLookupTable({
 942     0: "ErrorCode",
 943     1: "name",
 944     2: "value",
 945   }, 2)
 946
 947   _TYPES = _BuildTagLookupTable({
 948     0: ProtocolBuffer.Encoder.NUMERIC,
 949     1: ProtocolBuffer.Encoder.STRING,
 950     2: ProtocolBuffer.Encoder.STRING,
 951   }, 2, ProtocolBuffer.Encoder.MAX_TYPE)
 952
 953
 954   _STYLE = """"""
 955   _STYLE_CONTENT_TYPE = """"""
 956   _PROTO_DESCRIPTOR_NAME = 'storage_onestore_v3.Facet'
 957 class DocumentMetadata(ProtocolBuffer.ProtocolMessage):
 958   has_version_ = 0
 959   version_ = 0
 960
 961   def __init__(self, contents=None):
 962     if contents is not None: self.MergeFromString(contents)
 963
 964   def version(self): return self.version_
 965
 966   def set_version(self, x):
 967     self.has_version_ = 1
 968     self.version_ = x
 969
 970   def clear_version(self):
 971     if self.has_version_:
 972       self.has_version_ = 0
 973       self.version_ = 0
 974
 975   def has_version(self): return self.has_version_
 976
 977
 978   def MergeFrom(self, x):
 979     assert x is not self
 980     if (x.has_version()): self.set_version(x.version())
 981
 982   def Equals(self, x):
 983     if x is self: return 1
 984     if self.has_version_ != x.has_version_: return 0
 985     if self.has_version_ and self.version_ != x.version_: return 0
 986     return 1
 987
 988   def IsInitialized(self, debug_strs=None):
 989     initialized = 1
 990     return initialized
 991
 992   def ByteSize(self):
 993     n = 0
 994     if (self.has_version_): n += 1 + self.lengthVarInt64(self.version_)
 995     return n
 996
 997   def ByteSizePartial(self):
 998     n = 0
 999     if (self.has_version_): n += 1 + self.lengthVarInt64(self.version_)
1000     return n
1001
1002   def Clear(self):
1003     self.clear_version()
1004
1005   def OutputUnchecked(self, out):
1006     if (self.has_version_):
1007       out.putVarInt32(8)
1008       out.putVarInt64(self.version_)
1009
1010   def OutputPartial(self, out):
1011     if (self.has_version_):
1012       out.putVarInt32(8)
1013       out.putVarInt64(self.version_)
1014
1015   def TryMerge(self, d):
1016     while d.avail() > 0:
1017       tt = d.getVarInt32()
1018       if tt == 8:
1019         self.set_version(d.getVarInt64())
1020         continue
1021
1022
1023       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1024       d.skipData(tt)
1025
1026
1027   def __str__(self, prefix="", printElemNumber=0):
1028     res=""
1029     if self.has_version_: res+=prefix+("version: %s\n" % self.DebugFormatInt64(self.version_))
1030     return res
1031
1032
1033   def _BuildTagLookupTable(sparse, maxtag, default=None):
1034     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
1035
1036   kversion = 1
1037
1038   _TEXT = _BuildTagLookupTable({
1039     0: "ErrorCode",
1040     1: "version",
1041   }, 1)
1042
1043   _TYPES = _BuildTagLookupTable({
1044     0: ProtocolBuffer.Encoder.NUMERIC,
1045     1: ProtocolBuffer.Encoder.NUMERIC,
1046   }, 1, ProtocolBuffer.Encoder.MAX_TYPE)
1047
1048
1049   _STYLE = """"""
1050   _STYLE_CONTENT_TYPE = """"""
1051   _PROTO_DESCRIPTOR_NAME = 'storage_onestore_v3.DocumentMetadata'
1052 class Document(ProtocolBuffer.ProtocolMessage):
1053
1054
1055   DISK         =    0
1056
1057   _Storage_NAMES = {
1058     0: "DISK",
1059   }
1060
1061   def Storage_Name(cls, x): return cls._Storage_NAMES.get(x, "")
1062   Storage_Name = classmethod(Storage_Name)
1063
1064   has_id_ = 0
1065   id_ = ""
1066   has_language_ = 0
1067   language_ = "en"
1068   has_order_id_ = 0
1069   order_id_ = 0
1070   has_storage_ = 0
1071   storage_ = 0
1072   has_acl_ = 0
1073   acl_ = None
1074
1075   def __init__(self, contents=None):
1076     self.field_ = []
1077     self.facet_ = []
1078     self.lazy_init_lock_ = thread.allocate_lock()
1079     if contents is not None: self.MergeFromString(contents)
1080
1081   def id(self): return self.id_
1082
1083   def set_id(self, x):
1084     self.has_id_ = 1
1085     self.id_ = x
1086
1087   def clear_id(self):
1088     if self.has_id_:
1089       self.has_id_ = 0
1090       self.id_ = ""
1091
1092   def has_id(self): return self.has_id_
1093
1094   def language(self): return self.language_
1095
1096   def set_language(self, x):
1097     self.has_language_ = 1
1098     self.language_ = x
1099
1100   def clear_language(self):
1101     if self.has_language_:
1102       self.has_language_ = 0
1103       self.language_ = "en"
1104
1105   def has_language(self): return self.has_language_
1106
1107   def field_size(self): return len(self.field_)
1108   def field_list(self): return self.field_
1109
1110   def field(self, i):
1111     return self.field_[i]
1112
1113   def mutable_field(self, i):
1114     return self.field_[i]
1115
1116   def add_field(self):
1117     x = Field()
1118     self.field_.append(x)
1119     return x
1120
1121   def clear_field(self):
1122     self.field_ = []
1123   def order_id(self): return self.order_id_
1124
1125   def set_order_id(self, x):
1126     self.has_order_id_ = 1
1127     self.order_id_ = x
1128
1129   def clear_order_id(self):
1130     if self.has_order_id_:
1131       self.has_order_id_ = 0
1132       self.order_id_ = 0
1133
1134   def has_order_id(self): return self.has_order_id_
1135
1136   def storage(self): return self.storage_
1137
1138   def set_storage(self, x):
1139     self.has_storage_ = 1
1140     self.storage_ = x
1141
1142   def clear_storage(self):
1143     if self.has_storage_:
1144       self.has_storage_ = 0
1145       self.storage_ = 0
1146
1147   def has_storage(self): return self.has_storage_
1148
1149   def acl(self):
1150     if self.acl_ is None:
1151       self.lazy_init_lock_.acquire()
1152       try:
1153         if self.acl_ is None: self.acl_ = AccessControlList()
1154       finally:
1155         self.lazy_init_lock_.release()
1156     return self.acl_
1157
1158   def mutable_acl(self): self.has_acl_ = 1; return self.acl()
1159
1160   def clear_acl(self):
1161
1162     if self.has_acl_:
1163       self.has_acl_ = 0;
1164       if self.acl_ is not None: self.acl_.Clear()
1165
1166   def has_acl(self): return self.has_acl_
1167
1168   def facet_size(self): return len(self.facet_)
1169   def facet_list(self): return self.facet_
1170
1171   def facet(self, i):
1172     return self.facet_[i]
1173
1174   def mutable_facet(self, i):
1175     return self.facet_[i]
1176
1177   def add_facet(self):
1178     x = Facet()
1179     self.facet_.append(x)
1180     return x
1181
1182   def clear_facet(self):
1183     self.facet_ = []
1184
1185   def MergeFrom(self, x):
1186     assert x is not self
1187     if (x.has_id()): self.set_id(x.id())
1188     if (x.has_language()): self.set_language(x.language())
1189     for i in xrange(x.field_size()): self.add_field().CopyFrom(x.field(i))
1190     if (x.has_order_id()): self.set_order_id(x.order_id())
1191     if (x.has_storage()): self.set_storage(x.storage())
1192     if (x.has_acl()): self.mutable_acl().MergeFrom(x.acl())
1193     for i in xrange(x.facet_size()): self.add_facet().CopyFrom(x.facet(i))
1194
1195   def Equals(self, x):
1196     if x is self: return 1
1197     if self.has_id_ != x.has_id_: return 0
1198     if self.has_id_ and self.id_ != x.id_: return 0
1199     if self.has_language_ != x.has_language_: return 0
1200     if self.has_language_ and self.language_ != x.language_: return 0
1201     if len(self.field_) != len(x.field_): return 0
1202     for e1, e2 in zip(self.field_, x.field_):
1203       if e1 != e2: return 0
1204     if self.has_order_id_ != x.has_order_id_: return 0
1205     if self.has_order_id_ and self.order_id_ != x.order_id_: return 0
1206     if self.has_storage_ != x.has_storage_: return 0
1207     if self.has_storage_ and self.storage_ != x.storage_: return 0
1208     if self.has_acl_ != x.has_acl_: return 0
1209     if self.has_acl_ and self.acl_ != x.acl_: return 0
1210     if len(self.facet_) != len(x.facet_): return 0
1211     for e1, e2 in zip(self.facet_, x.facet_):
1212       if e1 != e2: return 0
1213     return 1
1214
1215   def IsInitialized(self, debug_strs=None):
1216     initialized = 1
1217     for p in self.field_:
1218       if not p.IsInitialized(debug_strs): initialized=0
1219     if (self.has_acl_ and not self.acl_.IsInitialized(debug_strs)): initialized = 0
1220     for p in self.facet_:
1221       if not p.IsInitialized(debug_strs): initialized=0
1222     return initialized
1223
1224   def ByteSize(self):
1225     n = 0
1226     if (self.has_id_): n += 1 + self.lengthString(len(self.id_))
1227     if (self.has_language_): n += 1 + self.lengthString(len(self.language_))
1228     n += 1 * len(self.field_)
1229     for i in xrange(len(self.field_)): n += self.lengthString(self.field_[i].ByteSize())
1230     if (self.has_order_id_): n += 1 + self.lengthVarInt64(self.order_id_)
1231     if (self.has_storage_): n += 1 + self.lengthVarInt64(self.storage_)
1232     if (self.has_acl_): n += 1 + self.lengthString(self.acl_.ByteSize())
1233     n += 1 * len(self.facet_)
1234     for i in xrange(len(self.facet_)): n += self.lengthString(self.facet_[i].ByteSize())
1235     return n
1236
1237   def ByteSizePartial(self):
1238     n = 0
1239     if (self.has_id_): n += 1 + self.lengthString(len(self.id_))
1240     if (self.has_language_): n += 1 + self.lengthString(len(self.language_))
1241     n += 1 * len(self.field_)
1242     for i in xrange(len(self.field_)): n += self.lengthString(self.field_[i].ByteSizePartial())
1243     if (self.has_order_id_): n += 1 + self.lengthVarInt64(self.order_id_)
1244     if (self.has_storage_): n += 1 + self.lengthVarInt64(self.storage_)
1245     if (self.has_acl_): n += 1 + self.lengthString(self.acl_.ByteSizePartial())
1246     n += 1 * len(self.facet_)
1247     for i in xrange(len(self.facet_)): n += self.lengthString(self.facet_[i].ByteSizePartial())
1248     return n
1249
1250   def Clear(self):
1251     self.clear_id()
1252     self.clear_language()
1253     self.clear_field()
1254     self.clear_order_id()
1255     self.clear_storage()
1256     self.clear_acl()
1257     self.clear_facet()
1258
1259   def OutputUnchecked(self, out):
1260     if (self.has_id_):
1261       out.putVarInt32(10)
1262       out.putPrefixedString(self.id_)
1263     if (self.has_language_):
1264       out.putVarInt32(18)
1265       out.putPrefixedString(self.language_)
1266     for i in xrange(len(self.field_)):
1267       out.putVarInt32(26)
1268       out.putVarInt32(self.field_[i].ByteSize())
1269       self.field_[i].OutputUnchecked(out)
1270     if (self.has_order_id_):
1271       out.putVarInt32(32)
1272       out.putVarInt32(self.order_id_)
1273     if (self.has_storage_):
1274       out.putVarInt32(40)
1275       out.putVarInt32(self.storage_)
1276     if (self.has_acl_):
1277       out.putVarInt32(50)
1278       out.putVarInt32(self.acl_.ByteSize())
1279       self.acl_.OutputUnchecked(out)
1280     for i in xrange(len(self.facet_)):
1281       out.putVarInt32(66)
1282       out.putVarInt32(self.facet_[i].ByteSize())
1283       self.facet_[i].OutputUnchecked(out)
1284
1285   def OutputPartial(self, out):
1286     if (self.has_id_):
1287       out.putVarInt32(10)
1288       out.putPrefixedString(self.id_)
1289     if (self.has_language_):
1290       out.putVarInt32(18)
1291       out.putPrefixedString(self.language_)
1292     for i in xrange(len(self.field_)):
1293       out.putVarInt32(26)
1294       out.putVarInt32(self.field_[i].ByteSizePartial())
1295       self.field_[i].OutputPartial(out)
1296     if (self.has_order_id_):
1297       out.putVarInt32(32)
1298       out.putVarInt32(self.order_id_)
1299     if (self.has_storage_):
1300       out.putVarInt32(40)
1301       out.putVarInt32(self.storage_)
1302     if (self.has_acl_):
1303       out.putVarInt32(50)
1304       out.putVarInt32(self.acl_.ByteSizePartial())
1305       self.acl_.OutputPartial(out)
1306     for i in xrange(len(self.facet_)):
1307       out.putVarInt32(66)
1308       out.putVarInt32(self.facet_[i].ByteSizePartial())
1309       self.facet_[i].OutputPartial(out)
1310
1311   def TryMerge(self, d):
1312     while d.avail() > 0:
1313       tt = d.getVarInt32()
1314       if tt == 10:
1315         self.set_id(d.getPrefixedString())
1316         continue
1317       if tt == 18:
1318         self.set_language(d.getPrefixedString())
1319         continue
1320       if tt == 26:
1321         length = d.getVarInt32()
1322         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
1323         d.skip(length)
1324         self.add_field().TryMerge(tmp)
1325         continue
1326       if tt == 32:
1327         self.set_order_id(d.getVarInt32())
1328         continue
1329       if tt == 40:
1330         self.set_storage(d.getVarInt32())
1331         continue
1332       if tt == 50:
1333         length = d.getVarInt32()
1334         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
1335         d.skip(length)
1336         self.mutable_acl().TryMerge(tmp)
1337         continue
1338       if tt == 66:
1339         length = d.getVarInt32()
1340         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
1341         d.skip(length)
1342         self.add_facet().TryMerge(tmp)
1343         continue
1344
1345
1346       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1347       d.skipData(tt)
1348
1349
1350   def __str__(self, prefix="", printElemNumber=0):
1351     res=""
1352     if self.has_id_: res+=prefix+("id: %s\n" % self.DebugFormatString(self.id_))
1353     if self.has_language_: res+=prefix+("language: %s\n" % self.DebugFormatString(self.language_))
1354     cnt=0
1355     for e in self.field_:
1356       elm=""
1357       if printElemNumber: elm="(%d)" % cnt
1358       res+=prefix+("field%s <\n" % elm)
1359       res+=e.__str__(prefix + "  ", printElemNumber)
1360       res+=prefix+">\n"
1361       cnt+=1
1362     if self.has_order_id_: res+=prefix+("order_id: %s\n" % self.DebugFormatInt32(self.order_id_))
1363     if self.has_storage_: res+=prefix+("storage: %s\n" % self.DebugFormatInt32(self.storage_))
1364     if self.has_acl_:
1365       res+=prefix+"acl <\n"
1366       res+=self.acl_.__str__(prefix + "  ", printElemNumber)
1367       res+=prefix+">\n"
1368     cnt=0
1369     for e in self.facet_:
1370       elm=""
1371       if printElemNumber: elm="(%d)" % cnt
1372       res+=prefix+("facet%s <\n" % elm)
1373       res+=e.__str__(prefix + "  ", printElemNumber)
1374       res+=prefix+">\n"
1375       cnt+=1
1376     return res
1377
1378
1379   def _BuildTagLookupTable(sparse, maxtag, default=None):
1380     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
1381
1382   kid = 1
1383   klanguage = 2
1384   kfield = 3
1385   korder_id = 4
1386   kstorage = 5
1387   kacl = 6
1388   kfacet = 8
1389
1390   _TEXT = _BuildTagLookupTable({
1391     0: "ErrorCode",
1392     1: "id",
1393     2: "language",
1394     3: "field",
1395     4: "order_id",
1396     5: "storage",
1397     6: "acl",
1398     8: "facet",
1399   }, 8)
1400
1401   _TYPES = _BuildTagLookupTable({
1402     0: ProtocolBuffer.Encoder.NUMERIC,
1403     1: ProtocolBuffer.Encoder.STRING,
1404     2: ProtocolBuffer.Encoder.STRING,
1405     3: ProtocolBuffer.Encoder.STRING,
1406     4: ProtocolBuffer.Encoder.NUMERIC,
1407     5: ProtocolBuffer.Encoder.NUMERIC,
1408     6: ProtocolBuffer.Encoder.STRING,
1409     8: ProtocolBuffer.Encoder.STRING,
1410   }, 8, ProtocolBuffer.Encoder.MAX_TYPE)
1411
1412
1413   _STYLE = """"""
1414   _STYLE_CONTENT_TYPE = """"""
1415   _PROTO_DESCRIPTOR_NAME = 'storage_onestore_v3.Document'
1416 if _extension_runtime:
1417   pass
1418
1419 __all__ = ['FieldValue','FieldValue_Geo','Field','FieldTypes','FacetValue','Facet','DocumentMetadata','Document']