/thirdparty/breakpad/third_party/protobuf/protobuf/python/google/protobuf/internal/encoder.py
Python | 769 lines | 627 code | 62 blank | 80 comment | 52 complexity | 0d38b8df2b7b215d16dc2db5631b8570 MD5 | raw file
1# Protocol Buffers - Google's data interchange format 2# Copyright 2008 Google Inc. All rights reserved. 3# http://code.google.com/p/protobuf/ 4# 5# Redistribution and use in source and binary forms, with or without 6# modification, are permitted provided that the following conditions are 7# met: 8# 9# * Redistributions of source code must retain the above copyright 10# notice, this list of conditions and the following disclaimer. 11# * Redistributions in binary form must reproduce the above 12# copyright notice, this list of conditions and the following disclaimer 13# in the documentation and/or other materials provided with the 14# distribution. 15# * Neither the name of Google Inc. nor the names of its 16# contributors may be used to endorse or promote products derived from 17# this software without specific prior written permission. 18# 19# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 20# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 21# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 22# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 23# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 24# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 25# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 26# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 27# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 28# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 29# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30 31"""Code for encoding protocol message primitives. 32 33Contains the logic for encoding every logical protocol field type 34into one of the 5 physical wire types. 35 36This code is designed to push the Python interpreter's performance to the 37limits. 38 39The basic idea is that at startup time, for every field (i.e. every 40FieldDescriptor) we construct two functions: a "sizer" and an "encoder". The 41sizer takes a value of this field's type and computes its byte size. The 42encoder takes a writer function and a value. It encodes the value into byte 43strings and invokes the writer function to write those strings. Typically the 44writer function is the write() method of a cStringIO. 45 46We try to do as much work as possible when constructing the writer and the 47sizer rather than when calling them. In particular: 48* We copy any needed global functions to local variables, so that we do not need 49 to do costly global table lookups at runtime. 50* Similarly, we try to do any attribute lookups at startup time if possible. 51* Every field's tag is encoded to bytes at startup, since it can't change at 52 runtime. 53* Whatever component of the field size we can compute at startup, we do. 54* We *avoid* sharing code if doing so would make the code slower and not sharing 55 does not burden us too much. For example, encoders for repeated fields do 56 not just call the encoders for singular fields in a loop because this would 57 add an extra function call overhead for every loop iteration; instead, we 58 manually inline the single-value encoder into the loop. 59* If a Python function lacks a return statement, Python actually generates 60 instructions to pop the result of the last statement off the stack, push 61 None onto the stack, and then return that. If we really don't care what 62 value is returned, then we can save two instructions by returning the 63 result of the last statement. It looks funny but it helps. 64* We assume that type and bounds checking has happened at a higher level. 65""" 66 67__author__ = 'kenton@google.com (Kenton Varda)' 68 69import struct 70from google.protobuf.internal import wire_format 71 72 73# This will overflow and thus become IEEE-754 "infinity". We would use 74# "float('inf')" but it doesn't work on Windows pre-Python-2.6. 75_POS_INF = 1e10000 76_NEG_INF = -_POS_INF 77 78 79def _VarintSize(value): 80 """Compute the size of a varint value.""" 81 if value <= 0x7f: return 1 82 if value <= 0x3fff: return 2 83 if value <= 0x1fffff: return 3 84 if value <= 0xfffffff: return 4 85 if value <= 0x7ffffffff: return 5 86 if value <= 0x3ffffffffff: return 6 87 if value <= 0x1ffffffffffff: return 7 88 if value <= 0xffffffffffffff: return 8 89 if value <= 0x7fffffffffffffff: return 9 90 return 10 91 92 93def _SignedVarintSize(value): 94 """Compute the size of a signed varint value.""" 95 if value < 0: return 10 96 if value <= 0x7f: return 1 97 if value <= 0x3fff: return 2 98 if value <= 0x1fffff: return 3 99 if value <= 0xfffffff: return 4 100 if value <= 0x7ffffffff: return 5 101 if value <= 0x3ffffffffff: return 6 102 if value <= 0x1ffffffffffff: return 7 103 if value <= 0xffffffffffffff: return 8 104 if value <= 0x7fffffffffffffff: return 9 105 return 10 106 107 108def _TagSize(field_number): 109 """Returns the number of bytes required to serialize a tag with this field 110 number.""" 111 # Just pass in type 0, since the type won't affect the tag+type size. 112 return _VarintSize(wire_format.PackTag(field_number, 0)) 113 114 115# -------------------------------------------------------------------- 116# In this section we define some generic sizers. Each of these functions 117# takes parameters specific to a particular field type, e.g. int32 or fixed64. 118# It returns another function which in turn takes parameters specific to a 119# particular field, e.g. the field number and whether it is repeated or packed. 120# Look at the next section to see how these are used. 121 122 123def _SimpleSizer(compute_value_size): 124 """A sizer which uses the function compute_value_size to compute the size of 125 each value. Typically compute_value_size is _VarintSize.""" 126 127 def SpecificSizer(field_number, is_repeated, is_packed): 128 tag_size = _TagSize(field_number) 129 if is_packed: 130 local_VarintSize = _VarintSize 131 def PackedFieldSize(value): 132 result = 0 133 for element in value: 134 result += compute_value_size(element) 135 return result + local_VarintSize(result) + tag_size 136 return PackedFieldSize 137 elif is_repeated: 138 def RepeatedFieldSize(value): 139 result = tag_size * len(value) 140 for element in value: 141 result += compute_value_size(element) 142 return result 143 return RepeatedFieldSize 144 else: 145 def FieldSize(value): 146 return tag_size + compute_value_size(value) 147 return FieldSize 148 149 return SpecificSizer 150 151 152def _ModifiedSizer(compute_value_size, modify_value): 153 """Like SimpleSizer, but modify_value is invoked on each value before it is 154 passed to compute_value_size. modify_value is typically ZigZagEncode.""" 155 156 def SpecificSizer(field_number, is_repeated, is_packed): 157 tag_size = _TagSize(field_number) 158 if is_packed: 159 local_VarintSize = _VarintSize 160 def PackedFieldSize(value): 161 result = 0 162 for element in value: 163 result += compute_value_size(modify_value(element)) 164 return result + local_VarintSize(result) + tag_size 165 return PackedFieldSize 166 elif is_repeated: 167 def RepeatedFieldSize(value): 168 result = tag_size * len(value) 169 for element in value: 170 result += compute_value_size(modify_value(element)) 171 return result 172 return RepeatedFieldSize 173 else: 174 def FieldSize(value): 175 return tag_size + compute_value_size(modify_value(value)) 176 return FieldSize 177 178 return SpecificSizer 179 180 181def _FixedSizer(value_size): 182 """Like _SimpleSizer except for a fixed-size field. The input is the size 183 of one value.""" 184 185 def SpecificSizer(field_number, is_repeated, is_packed): 186 tag_size = _TagSize(field_number) 187 if is_packed: 188 local_VarintSize = _VarintSize 189 def PackedFieldSize(value): 190 result = len(value) * value_size 191 return result + local_VarintSize(result) + tag_size 192 return PackedFieldSize 193 elif is_repeated: 194 element_size = value_size + tag_size 195 def RepeatedFieldSize(value): 196 return len(value) * element_size 197 return RepeatedFieldSize 198 else: 199 field_size = value_size + tag_size 200 def FieldSize(value): 201 return field_size 202 return FieldSize 203 204 return SpecificSizer 205 206 207# ==================================================================== 208# Here we declare a sizer constructor for each field type. Each "sizer 209# constructor" is a function that takes (field_number, is_repeated, is_packed) 210# as parameters and returns a sizer, which in turn takes a field value as 211# a parameter and returns its encoded size. 212 213 214Int32Sizer = Int64Sizer = EnumSizer = _SimpleSizer(_SignedVarintSize) 215 216UInt32Sizer = UInt64Sizer = _SimpleSizer(_VarintSize) 217 218SInt32Sizer = SInt64Sizer = _ModifiedSizer( 219 _SignedVarintSize, wire_format.ZigZagEncode) 220 221Fixed32Sizer = SFixed32Sizer = FloatSizer = _FixedSizer(4) 222Fixed64Sizer = SFixed64Sizer = DoubleSizer = _FixedSizer(8) 223 224BoolSizer = _FixedSizer(1) 225 226 227def StringSizer(field_number, is_repeated, is_packed): 228 """Returns a sizer for a string field.""" 229 230 tag_size = _TagSize(field_number) 231 local_VarintSize = _VarintSize 232 local_len = len 233 assert not is_packed 234 if is_repeated: 235 def RepeatedFieldSize(value): 236 result = tag_size * len(value) 237 for element in value: 238 l = local_len(element.encode('utf-8')) 239 result += local_VarintSize(l) + l 240 return result 241 return RepeatedFieldSize 242 else: 243 def FieldSize(value): 244 l = local_len(value.encode('utf-8')) 245 return tag_size + local_VarintSize(l) + l 246 return FieldSize 247 248 249def BytesSizer(field_number, is_repeated, is_packed): 250 """Returns a sizer for a bytes field.""" 251 252 tag_size = _TagSize(field_number) 253 local_VarintSize = _VarintSize 254 local_len = len 255 assert not is_packed 256 if is_repeated: 257 def RepeatedFieldSize(value): 258 result = tag_size * len(value) 259 for element in value: 260 l = local_len(element) 261 result += local_VarintSize(l) + l 262 return result 263 return RepeatedFieldSize 264 else: 265 def FieldSize(value): 266 l = local_len(value) 267 return tag_size + local_VarintSize(l) + l 268 return FieldSize 269 270 271def GroupSizer(field_number, is_repeated, is_packed): 272 """Returns a sizer for a group field.""" 273 274 tag_size = _TagSize(field_number) * 2 275 assert not is_packed 276 if is_repeated: 277 def RepeatedFieldSize(value): 278 result = tag_size * len(value) 279 for element in value: 280 result += element.ByteSize() 281 return result 282 return RepeatedFieldSize 283 else: 284 def FieldSize(value): 285 return tag_size + value.ByteSize() 286 return FieldSize 287 288 289def MessageSizer(field_number, is_repeated, is_packed): 290 """Returns a sizer for a message field.""" 291 292 tag_size = _TagSize(field_number) 293 local_VarintSize = _VarintSize 294 assert not is_packed 295 if is_repeated: 296 def RepeatedFieldSize(value): 297 result = tag_size * len(value) 298 for element in value: 299 l = element.ByteSize() 300 result += local_VarintSize(l) + l 301 return result 302 return RepeatedFieldSize 303 else: 304 def FieldSize(value): 305 l = value.ByteSize() 306 return tag_size + local_VarintSize(l) + l 307 return FieldSize 308 309 310# -------------------------------------------------------------------- 311# MessageSet is special. 312 313 314def MessageSetItemSizer(field_number): 315 """Returns a sizer for extensions of MessageSet. 316 317 The message set message looks like this: 318 message MessageSet { 319 repeated group Item = 1 { 320 required int32 type_id = 2; 321 required string message = 3; 322 } 323 } 324 """ 325 static_size = (_TagSize(1) * 2 + _TagSize(2) + _VarintSize(field_number) + 326 _TagSize(3)) 327 local_VarintSize = _VarintSize 328 329 def FieldSize(value): 330 l = value.ByteSize() 331 return static_size + local_VarintSize(l) + l 332 333 return FieldSize 334 335 336# ==================================================================== 337# Encoders! 338 339 340def _VarintEncoder(): 341 """Return an encoder for a basic varint value (does not include tag).""" 342 343 local_chr = chr 344 def EncodeVarint(write, value): 345 bits = value & 0x7f 346 value >>= 7 347 while value: 348 write(local_chr(0x80|bits)) 349 bits = value & 0x7f 350 value >>= 7 351 return write(local_chr(bits)) 352 353 return EncodeVarint 354 355 356def _SignedVarintEncoder(): 357 """Return an encoder for a basic signed varint value (does not include 358 tag).""" 359 360 local_chr = chr 361 def EncodeSignedVarint(write, value): 362 if value < 0: 363 value += (1 << 64) 364 bits = value & 0x7f 365 value >>= 7 366 while value: 367 write(local_chr(0x80|bits)) 368 bits = value & 0x7f 369 value >>= 7 370 return write(local_chr(bits)) 371 372 return EncodeSignedVarint 373 374 375_EncodeVarint = _VarintEncoder() 376_EncodeSignedVarint = _SignedVarintEncoder() 377 378 379def _VarintBytes(value): 380 """Encode the given integer as a varint and return the bytes. This is only 381 called at startup time so it doesn't need to be fast.""" 382 383 pieces = [] 384 _EncodeVarint(pieces.append, value) 385 return "".join(pieces) 386 387 388def TagBytes(field_number, wire_type): 389 """Encode the given tag and return the bytes. Only called at startup.""" 390 391 return _VarintBytes(wire_format.PackTag(field_number, wire_type)) 392 393# -------------------------------------------------------------------- 394# As with sizers (see above), we have a number of common encoder 395# implementations. 396 397 398def _SimpleEncoder(wire_type, encode_value, compute_value_size): 399 """Return a constructor for an encoder for fields of a particular type. 400 401 Args: 402 wire_type: The field's wire type, for encoding tags. 403 encode_value: A function which encodes an individual value, e.g. 404 _EncodeVarint(). 405 compute_value_size: A function which computes the size of an individual 406 value, e.g. _VarintSize(). 407 """ 408 409 def SpecificEncoder(field_number, is_repeated, is_packed): 410 if is_packed: 411 tag_bytes = TagBytes(field_number, wire_format.WIRETYPE_LENGTH_DELIMITED) 412 local_EncodeVarint = _EncodeVarint 413 def EncodePackedField(write, value): 414 write(tag_bytes) 415 size = 0 416 for element in value: 417 size += compute_value_size(element) 418 local_EncodeVarint(write, size) 419 for element in value: 420 encode_value(write, element) 421 return EncodePackedField 422 elif is_repeated: 423 tag_bytes = TagBytes(field_number, wire_type) 424 def EncodeRepeatedField(write, value): 425 for element in value: 426 write(tag_bytes) 427 encode_value(write, element) 428 return EncodeRepeatedField 429 else: 430 tag_bytes = TagBytes(field_number, wire_type) 431 def EncodeField(write, value): 432 write(tag_bytes) 433 return encode_value(write, value) 434 return EncodeField 435 436 return SpecificEncoder 437 438 439def _ModifiedEncoder(wire_type, encode_value, compute_value_size, modify_value): 440 """Like SimpleEncoder but additionally invokes modify_value on every value 441 before passing it to encode_value. Usually modify_value is ZigZagEncode.""" 442 443 def SpecificEncoder(field_number, is_repeated, is_packed): 444 if is_packed: 445 tag_bytes = TagBytes(field_number, wire_format.WIRETYPE_LENGTH_DELIMITED) 446 local_EncodeVarint = _EncodeVarint 447 def EncodePackedField(write, value): 448 write(tag_bytes) 449 size = 0 450 for element in value: 451 size += compute_value_size(modify_value(element)) 452 local_EncodeVarint(write, size) 453 for element in value: 454 encode_value(write, modify_value(element)) 455 return EncodePackedField 456 elif is_repeated: 457 tag_bytes = TagBytes(field_number, wire_type) 458 def EncodeRepeatedField(write, value): 459 for element in value: 460 write(tag_bytes) 461 encode_value(write, modify_value(element)) 462 return EncodeRepeatedField 463 else: 464 tag_bytes = TagBytes(field_number, wire_type) 465 def EncodeField(write, value): 466 write(tag_bytes) 467 return encode_value(write, modify_value(value)) 468 return EncodeField 469 470 return SpecificEncoder 471 472 473def _StructPackEncoder(wire_type, format): 474 """Return a constructor for an encoder for a fixed-width field. 475 476 Args: 477 wire_type: The field's wire type, for encoding tags. 478 format: The format string to pass to struct.pack(). 479 """ 480 481 value_size = struct.calcsize(format) 482 483 def SpecificEncoder(field_number, is_repeated, is_packed): 484 local_struct_pack = struct.pack 485 if is_packed: 486 tag_bytes = TagBytes(field_number, wire_format.WIRETYPE_LENGTH_DELIMITED) 487 local_EncodeVarint = _EncodeVarint 488 def EncodePackedField(write, value): 489 write(tag_bytes) 490 local_EncodeVarint(write, len(value) * value_size) 491 for element in value: 492 write(local_struct_pack(format, element)) 493 return EncodePackedField 494 elif is_repeated: 495 tag_bytes = TagBytes(field_number, wire_type) 496 def EncodeRepeatedField(write, value): 497 for element in value: 498 write(tag_bytes) 499 write(local_struct_pack(format, element)) 500 return EncodeRepeatedField 501 else: 502 tag_bytes = TagBytes(field_number, wire_type) 503 def EncodeField(write, value): 504 write(tag_bytes) 505 return write(local_struct_pack(format, value)) 506 return EncodeField 507 508 return SpecificEncoder 509 510 511def _FloatingPointEncoder(wire_type, format): 512 """Return a constructor for an encoder for float fields. 513 514 This is like StructPackEncoder, but catches errors that may be due to 515 passing non-finite floating-point values to struct.pack, and makes a 516 second attempt to encode those values. 517 518 Args: 519 wire_type: The field's wire type, for encoding tags. 520 format: The format string to pass to struct.pack(). 521 """ 522 523 value_size = struct.calcsize(format) 524 if value_size == 4: 525 def EncodeNonFiniteOrRaise(write, value): 526 # Remember that the serialized form uses little-endian byte order. 527 if value == _POS_INF: 528 write('\x00\x00\x80\x7F') 529 elif value == _NEG_INF: 530 write('\x00\x00\x80\xFF') 531 elif value != value: # NaN 532 write('\x00\x00\xC0\x7F') 533 else: 534 raise 535 elif value_size == 8: 536 def EncodeNonFiniteOrRaise(write, value): 537 if value == _POS_INF: 538 write('\x00\x00\x00\x00\x00\x00\xF0\x7F') 539 elif value == _NEG_INF: 540 write('\x00\x00\x00\x00\x00\x00\xF0\xFF') 541 elif value != value: # NaN 542 write('\x00\x00\x00\x00\x00\x00\xF8\x7F') 543 else: 544 raise 545 else: 546 raise ValueError('Can\'t encode floating-point values that are ' 547 '%d bytes long (only 4 or 8)' % value_size) 548 549 def SpecificEncoder(field_number, is_repeated, is_packed): 550 local_struct_pack = struct.pack 551 if is_packed: 552 tag_bytes = TagBytes(field_number, wire_format.WIRETYPE_LENGTH_DELIMITED) 553 local_EncodeVarint = _EncodeVarint 554 def EncodePackedField(write, value): 555 write(tag_bytes) 556 local_EncodeVarint(write, len(value) * value_size) 557 for element in value: 558 # This try/except block is going to be faster than any code that 559 # we could write to check whether element is finite. 560 try: 561 write(local_struct_pack(format, element)) 562 except SystemError: 563 EncodeNonFiniteOrRaise(write, element) 564 return EncodePackedField 565 elif is_repeated: 566 tag_bytes = TagBytes(field_number, wire_type) 567 def EncodeRepeatedField(write, value): 568 for element in value: 569 write(tag_bytes) 570 try: 571 write(local_struct_pack(format, element)) 572 except SystemError: 573 EncodeNonFiniteOrRaise(write, element) 574 return EncodeRepeatedField 575 else: 576 tag_bytes = TagBytes(field_number, wire_type) 577 def EncodeField(write, value): 578 write(tag_bytes) 579 try: 580 write(local_struct_pack(format, value)) 581 except SystemError: 582 EncodeNonFiniteOrRaise(write, value) 583 return EncodeField 584 585 return SpecificEncoder 586 587 588# ==================================================================== 589# Here we declare an encoder constructor for each field type. These work 590# very similarly to sizer constructors, described earlier. 591 592 593Int32Encoder = Int64Encoder = EnumEncoder = _SimpleEncoder( 594 wire_format.WIRETYPE_VARINT, _EncodeSignedVarint, _SignedVarintSize) 595 596UInt32Encoder = UInt64Encoder = _SimpleEncoder( 597 wire_format.WIRETYPE_VARINT, _EncodeVarint, _VarintSize) 598 599SInt32Encoder = SInt64Encoder = _ModifiedEncoder( 600 wire_format.WIRETYPE_VARINT, _EncodeVarint, _VarintSize, 601 wire_format.ZigZagEncode) 602 603# Note that Python conveniently guarantees that when using the '<' prefix on 604# formats, they will also have the same size across all platforms (as opposed 605# to without the prefix, where their sizes depend on the C compiler's basic 606# type sizes). 607Fixed32Encoder = _StructPackEncoder(wire_format.WIRETYPE_FIXED32, '<I') 608Fixed64Encoder = _StructPackEncoder(wire_format.WIRETYPE_FIXED64, '<Q') 609SFixed32Encoder = _StructPackEncoder(wire_format.WIRETYPE_FIXED32, '<i') 610SFixed64Encoder = _StructPackEncoder(wire_format.WIRETYPE_FIXED64, '<q') 611FloatEncoder = _FloatingPointEncoder(wire_format.WIRETYPE_FIXED32, '<f') 612DoubleEncoder = _FloatingPointEncoder(wire_format.WIRETYPE_FIXED64, '<d') 613 614 615def BoolEncoder(field_number, is_repeated, is_packed): 616 """Returns an encoder for a boolean field.""" 617 618 false_byte = chr(0) 619 true_byte = chr(1) 620 if is_packed: 621 tag_bytes = TagBytes(field_number, wire_format.WIRETYPE_LENGTH_DELIMITED) 622 local_EncodeVarint = _EncodeVarint 623 def EncodePackedField(write, value): 624 write(tag_bytes) 625 local_EncodeVarint(write, len(value)) 626 for element in value: 627 if element: 628 write(true_byte) 629 else: 630 write(false_byte) 631 return EncodePackedField 632 elif is_repeated: 633 tag_bytes = TagBytes(field_number, wire_format.WIRETYPE_VARINT) 634 def EncodeRepeatedField(write, value): 635 for element in value: 636 write(tag_bytes) 637 if element: 638 write(true_byte) 639 else: 640 write(false_byte) 641 return EncodeRepeatedField 642 else: 643 tag_bytes = TagBytes(field_number, wire_format.WIRETYPE_VARINT) 644 def EncodeField(write, value): 645 write(tag_bytes) 646 if value: 647 return write(true_byte) 648 return write(false_byte) 649 return EncodeField 650 651 652def StringEncoder(field_number, is_repeated, is_packed): 653 """Returns an encoder for a string field.""" 654 655 tag = TagBytes(field_number, wire_format.WIRETYPE_LENGTH_DELIMITED) 656 local_EncodeVarint = _EncodeVarint 657 local_len = len 658 assert not is_packed 659 if is_repeated: 660 def EncodeRepeatedField(write, value): 661 for element in value: 662 encoded = element.encode('utf-8') 663 write(tag) 664 local_EncodeVarint(write, local_len(encoded)) 665 write(encoded) 666 return EncodeRepeatedField 667 else: 668 def EncodeField(write, value): 669 encoded = value.encode('utf-8') 670 write(tag) 671 local_EncodeVarint(write, local_len(encoded)) 672 return write(encoded) 673 return EncodeField 674 675 676def BytesEncoder(field_number, is_repeated, is_packed): 677 """Returns an encoder for a bytes field.""" 678 679 tag = TagBytes(field_number, wire_format.WIRETYPE_LENGTH_DELIMITED) 680 local_EncodeVarint = _EncodeVarint 681 local_len = len 682 assert not is_packed 683 if is_repeated: 684 def EncodeRepeatedField(write, value): 685 for element in value: 686 write(tag) 687 local_EncodeVarint(write, local_len(element)) 688 write(element) 689 return EncodeRepeatedField 690 else: 691 def EncodeField(write, value): 692 write(tag) 693 local_EncodeVarint(write, local_len(value)) 694 return write(value) 695 return EncodeField 696 697 698def GroupEncoder(field_number, is_repeated, is_packed): 699 """Returns an encoder for a group field.""" 700 701 start_tag = TagBytes(field_number, wire_format.WIRETYPE_START_GROUP) 702 end_tag = TagBytes(field_number, wire_format.WIRETYPE_END_GROUP) 703 assert not is_packed 704 if is_repeated: 705 def EncodeRepeatedField(write, value): 706 for element in value: 707 write(start_tag) 708 element._InternalSerialize(write) 709 write(end_tag) 710 return EncodeRepeatedField 711 else: 712 def EncodeField(write, value): 713 write(start_tag) 714 value._InternalSerialize(write) 715 return write(end_tag) 716 return EncodeField 717 718 719def MessageEncoder(field_number, is_repeated, is_packed): 720 """Returns an encoder for a message field.""" 721 722 tag = TagBytes(field_number, wire_format.WIRETYPE_LENGTH_DELIMITED) 723 local_EncodeVarint = _EncodeVarint 724 assert not is_packed 725 if is_repeated: 726 def EncodeRepeatedField(write, value): 727 for element in value: 728 write(tag) 729 local_EncodeVarint(write, element.ByteSize()) 730 element._InternalSerialize(write) 731 return EncodeRepeatedField 732 else: 733 def EncodeField(write, value): 734 write(tag) 735 local_EncodeVarint(write, value.ByteSize()) 736 return value._InternalSerialize(write) 737 return EncodeField 738 739 740# -------------------------------------------------------------------- 741# As before, MessageSet is special. 742 743 744def MessageSetItemEncoder(field_number): 745 """Encoder for extensions of MessageSet. 746 747 The message set message looks like this: 748 message MessageSet { 749 repeated group Item = 1 { 750 required int32 type_id = 2; 751 required string message = 3; 752 } 753 } 754 """ 755 start_bytes = "".join([ 756 TagBytes(1, wire_format.WIRETYPE_START_GROUP), 757 TagBytes(2, wire_format.WIRETYPE_VARINT), 758 _VarintBytes(field_number), 759 TagBytes(3, wire_format.WIRETYPE_LENGTH_DELIMITED)]) 760 end_bytes = TagBytes(1, wire_format.WIRETYPE_END_GROUP) 761 local_EncodeVarint = _EncodeVarint 762 763 def EncodeField(write, value): 764 write(start_bytes) 765 local_EncodeVarint(write, value.ByteSize()) 766 value._InternalSerialize(write) 767 return write(end_bytes) 768 769 return EncodeField