Ying Wang | 7e7f2e9 | 2015-04-16 16:15:24 -0700 | [diff] [blame] | 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 | """Constants and static functions to support protocol buffer wire format.""" |
| 32 | |
| 33 | __author__ = 'robinson@google.com (Will Robinson)' |
| 34 | |
| 35 | import struct |
| 36 | from google.protobuf import descriptor |
| 37 | from google.protobuf import message |
| 38 | |
| 39 | |
| 40 | TAG_TYPE_BITS = 3 # Number of bits used to hold type info in a proto tag. |
| 41 | TAG_TYPE_MASK = (1 << TAG_TYPE_BITS) - 1 # 0x7 |
| 42 | |
| 43 | # These numbers identify the wire type of a protocol buffer value. |
| 44 | # We use the least-significant TAG_TYPE_BITS bits of the varint-encoded |
| 45 | # tag-and-type to store one of these WIRETYPE_* constants. |
| 46 | # These values must match WireType enum in google/protobuf/wire_format.h. |
| 47 | WIRETYPE_VARINT = 0 |
| 48 | WIRETYPE_FIXED64 = 1 |
| 49 | WIRETYPE_LENGTH_DELIMITED = 2 |
| 50 | WIRETYPE_START_GROUP = 3 |
| 51 | WIRETYPE_END_GROUP = 4 |
| 52 | WIRETYPE_FIXED32 = 5 |
| 53 | _WIRETYPE_MAX = 5 |
| 54 | |
| 55 | |
| 56 | # Bounds for various integer types. |
| 57 | INT32_MAX = int((1 << 31) - 1) |
| 58 | INT32_MIN = int(-(1 << 31)) |
| 59 | UINT32_MAX = (1 << 32) - 1 |
| 60 | |
| 61 | INT64_MAX = (1 << 63) - 1 |
| 62 | INT64_MIN = -(1 << 63) |
| 63 | UINT64_MAX = (1 << 64) - 1 |
| 64 | |
| 65 | # "struct" format strings that will encode/decode the specified formats. |
| 66 | FORMAT_UINT32_LITTLE_ENDIAN = '<I' |
| 67 | FORMAT_UINT64_LITTLE_ENDIAN = '<Q' |
| 68 | FORMAT_FLOAT_LITTLE_ENDIAN = '<f' |
| 69 | FORMAT_DOUBLE_LITTLE_ENDIAN = '<d' |
| 70 | |
| 71 | |
| 72 | # We'll have to provide alternate implementations of AppendLittleEndian*() on |
| 73 | # any architectures where these checks fail. |
| 74 | if struct.calcsize(FORMAT_UINT32_LITTLE_ENDIAN) != 4: |
| 75 | raise AssertionError('Format "I" is not a 32-bit number.') |
| 76 | if struct.calcsize(FORMAT_UINT64_LITTLE_ENDIAN) != 8: |
| 77 | raise AssertionError('Format "Q" is not a 64-bit number.') |
| 78 | |
| 79 | |
| 80 | def PackTag(field_number, wire_type): |
| 81 | """Returns an unsigned 32-bit integer that encodes the field number and |
| 82 | wire type information in standard protocol message wire format. |
| 83 | |
| 84 | Args: |
| 85 | field_number: Expected to be an integer in the range [1, 1 << 29) |
| 86 | wire_type: One of the WIRETYPE_* constants. |
| 87 | """ |
| 88 | if not 0 <= wire_type <= _WIRETYPE_MAX: |
| 89 | raise message.EncodeError('Unknown wire type: %d' % wire_type) |
| 90 | return (field_number << TAG_TYPE_BITS) | wire_type |
| 91 | |
| 92 | |
| 93 | def UnpackTag(tag): |
| 94 | """The inverse of PackTag(). Given an unsigned 32-bit number, |
| 95 | returns a (field_number, wire_type) tuple. |
| 96 | """ |
| 97 | return (tag >> TAG_TYPE_BITS), (tag & TAG_TYPE_MASK) |
| 98 | |
| 99 | |
| 100 | def ZigZagEncode(value): |
| 101 | """ZigZag Transform: Encodes signed integers so that they can be |
| 102 | effectively used with varint encoding. See wire_format.h for |
| 103 | more details. |
| 104 | """ |
| 105 | if value >= 0: |
| 106 | return value << 1 |
| 107 | return (value << 1) ^ (~0) |
| 108 | |
| 109 | |
| 110 | def ZigZagDecode(value): |
| 111 | """Inverse of ZigZagEncode().""" |
| 112 | if not value & 0x1: |
| 113 | return value >> 1 |
| 114 | return (value >> 1) ^ (~0) |
| 115 | |
| 116 | |
| 117 | |
| 118 | # The *ByteSize() functions below return the number of bytes required to |
| 119 | # serialize "field number + type" information and then serialize the value. |
| 120 | |
| 121 | |
| 122 | def Int32ByteSize(field_number, int32): |
| 123 | return Int64ByteSize(field_number, int32) |
| 124 | |
| 125 | |
| 126 | def Int32ByteSizeNoTag(int32): |
| 127 | return _VarUInt64ByteSizeNoTag(0xffffffffffffffff & int32) |
| 128 | |
| 129 | |
| 130 | def Int64ByteSize(field_number, int64): |
| 131 | # Have to convert to uint before calling UInt64ByteSize(). |
| 132 | return UInt64ByteSize(field_number, 0xffffffffffffffff & int64) |
| 133 | |
| 134 | |
| 135 | def UInt32ByteSize(field_number, uint32): |
| 136 | return UInt64ByteSize(field_number, uint32) |
| 137 | |
| 138 | |
| 139 | def UInt64ByteSize(field_number, uint64): |
| 140 | return TagByteSize(field_number) + _VarUInt64ByteSizeNoTag(uint64) |
| 141 | |
| 142 | |
| 143 | def SInt32ByteSize(field_number, int32): |
| 144 | return UInt32ByteSize(field_number, ZigZagEncode(int32)) |
| 145 | |
| 146 | |
| 147 | def SInt64ByteSize(field_number, int64): |
| 148 | return UInt64ByteSize(field_number, ZigZagEncode(int64)) |
| 149 | |
| 150 | |
| 151 | def Fixed32ByteSize(field_number, fixed32): |
| 152 | return TagByteSize(field_number) + 4 |
| 153 | |
| 154 | |
| 155 | def Fixed64ByteSize(field_number, fixed64): |
| 156 | return TagByteSize(field_number) + 8 |
| 157 | |
| 158 | |
| 159 | def SFixed32ByteSize(field_number, sfixed32): |
| 160 | return TagByteSize(field_number) + 4 |
| 161 | |
| 162 | |
| 163 | def SFixed64ByteSize(field_number, sfixed64): |
| 164 | return TagByteSize(field_number) + 8 |
| 165 | |
| 166 | |
| 167 | def FloatByteSize(field_number, flt): |
| 168 | return TagByteSize(field_number) + 4 |
| 169 | |
| 170 | |
| 171 | def DoubleByteSize(field_number, double): |
| 172 | return TagByteSize(field_number) + 8 |
| 173 | |
| 174 | |
| 175 | def BoolByteSize(field_number, b): |
| 176 | return TagByteSize(field_number) + 1 |
| 177 | |
| 178 | |
| 179 | def EnumByteSize(field_number, enum): |
| 180 | return UInt32ByteSize(field_number, enum) |
| 181 | |
| 182 | |
| 183 | def StringByteSize(field_number, string): |
| 184 | return BytesByteSize(field_number, string.encode('utf-8')) |
| 185 | |
| 186 | |
| 187 | def BytesByteSize(field_number, b): |
| 188 | return (TagByteSize(field_number) |
| 189 | + _VarUInt64ByteSizeNoTag(len(b)) |
| 190 | + len(b)) |
| 191 | |
| 192 | |
| 193 | def GroupByteSize(field_number, message): |
| 194 | return (2 * TagByteSize(field_number) # START and END group. |
| 195 | + message.ByteSize()) |
| 196 | |
| 197 | |
| 198 | def MessageByteSize(field_number, message): |
| 199 | return (TagByteSize(field_number) |
| 200 | + _VarUInt64ByteSizeNoTag(message.ByteSize()) |
| 201 | + message.ByteSize()) |
| 202 | |
| 203 | |
| 204 | def MessageSetItemByteSize(field_number, msg): |
| 205 | # First compute the sizes of the tags. |
| 206 | # There are 2 tags for the beginning and ending of the repeated group, that |
| 207 | # is field number 1, one with field number 2 (type_id) and one with field |
| 208 | # number 3 (message). |
| 209 | total_size = (2 * TagByteSize(1) + TagByteSize(2) + TagByteSize(3)) |
| 210 | |
| 211 | # Add the number of bytes for type_id. |
| 212 | total_size += _VarUInt64ByteSizeNoTag(field_number) |
| 213 | |
| 214 | message_size = msg.ByteSize() |
| 215 | |
| 216 | # The number of bytes for encoding the length of the message. |
| 217 | total_size += _VarUInt64ByteSizeNoTag(message_size) |
| 218 | |
| 219 | # The size of the message. |
| 220 | total_size += message_size |
| 221 | return total_size |
| 222 | |
| 223 | |
| 224 | def TagByteSize(field_number): |
| 225 | """Returns the bytes required to serialize a tag with this field number.""" |
| 226 | # Just pass in type 0, since the type won't affect the tag+type size. |
| 227 | return _VarUInt64ByteSizeNoTag(PackTag(field_number, 0)) |
| 228 | |
| 229 | |
| 230 | # Private helper function for the *ByteSize() functions above. |
| 231 | |
| 232 | def _VarUInt64ByteSizeNoTag(uint64): |
| 233 | """Returns the number of bytes required to serialize a single varint |
| 234 | using boundary value comparisons. (unrolled loop optimization -WPierce) |
| 235 | uint64 must be unsigned. |
| 236 | """ |
| 237 | if uint64 <= 0x7f: return 1 |
| 238 | if uint64 <= 0x3fff: return 2 |
| 239 | if uint64 <= 0x1fffff: return 3 |
| 240 | if uint64 <= 0xfffffff: return 4 |
| 241 | if uint64 <= 0x7ffffffff: return 5 |
| 242 | if uint64 <= 0x3ffffffffff: return 6 |
| 243 | if uint64 <= 0x1ffffffffffff: return 7 |
| 244 | if uint64 <= 0xffffffffffffff: return 8 |
| 245 | if uint64 <= 0x7fffffffffffffff: return 9 |
| 246 | if uint64 > UINT64_MAX: |
| 247 | raise message.EncodeError('Value out of range: %d' % uint64) |
| 248 | return 10 |
| 249 | |
| 250 | |
| 251 | NON_PACKABLE_TYPES = ( |
| 252 | descriptor.FieldDescriptor.TYPE_STRING, |
| 253 | descriptor.FieldDescriptor.TYPE_GROUP, |
| 254 | descriptor.FieldDescriptor.TYPE_MESSAGE, |
| 255 | descriptor.FieldDescriptor.TYPE_BYTES |
| 256 | ) |
| 257 | |
| 258 | |
| 259 | def IsTypePackable(field_type): |
| 260 | """Return true iff packable = true is valid for fields of this type. |
| 261 | |
| 262 | Args: |
| 263 | field_type: a FieldDescriptor::Type value. |
| 264 | |
| 265 | Returns: |
| 266 | True iff fields of this type are packable. |
| 267 | """ |
| 268 | return field_type not in NON_PACKABLE_TYPES |