PageRenderTime 48ms CodeModel.GetById 33ms app.highlight 12ms RepoModel.GetById 1ms app.codeStats 1ms

/thirdparty/breakpad/third_party/protobuf/protobuf/python/google/protobuf/internal/wire_format.py

http://github.com/tomahawk-player/tomahawk
Python | 268 lines | 114 code | 76 blank | 78 comment | 19 complexity | e3293864a9a46ceb488ee2280cc6d136 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"""Constants and static functions to support protocol buffer wire format."""
 32
 33__author__ = 'robinson@google.com (Will Robinson)'
 34
 35import struct
 36from google.protobuf import descriptor
 37from google.protobuf import message
 38
 39
 40TAG_TYPE_BITS = 3  # Number of bits used to hold type info in a proto tag.
 41TAG_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.
 47WIRETYPE_VARINT = 0
 48WIRETYPE_FIXED64 = 1
 49WIRETYPE_LENGTH_DELIMITED = 2
 50WIRETYPE_START_GROUP = 3
 51WIRETYPE_END_GROUP = 4
 52WIRETYPE_FIXED32 = 5
 53_WIRETYPE_MAX = 5
 54
 55
 56# Bounds for various integer types.
 57INT32_MAX = int((1 << 31) - 1)
 58INT32_MIN = int(-(1 << 31))
 59UINT32_MAX = (1 << 32) - 1
 60
 61INT64_MAX = (1 << 63) - 1
 62INT64_MIN = -(1 << 63)
 63UINT64_MAX = (1 << 64) - 1
 64
 65# "struct" format strings that will encode/decode the specified formats.
 66FORMAT_UINT32_LITTLE_ENDIAN = '<I'
 67FORMAT_UINT64_LITTLE_ENDIAN = '<Q'
 68FORMAT_FLOAT_LITTLE_ENDIAN = '<f'
 69FORMAT_DOUBLE_LITTLE_ENDIAN = '<d'
 70
 71
 72# We'll have to provide alternate implementations of AppendLittleEndian*() on
 73# any architectures where these checks fail.
 74if struct.calcsize(FORMAT_UINT32_LITTLE_ENDIAN) != 4:
 75  raise AssertionError('Format "I" is not a 32-bit number.')
 76if struct.calcsize(FORMAT_UINT64_LITTLE_ENDIAN) != 8:
 77  raise AssertionError('Format "Q" is not a 64-bit number.')
 78
 79
 80def 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
 93def 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
100def 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
110def 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
122def Int32ByteSize(field_number, int32):
123  return Int64ByteSize(field_number, int32)
124
125
126def Int32ByteSizeNoTag(int32):
127  return _VarUInt64ByteSizeNoTag(0xffffffffffffffff & int32)
128
129
130def Int64ByteSize(field_number, int64):
131  # Have to convert to uint before calling UInt64ByteSize().
132  return UInt64ByteSize(field_number, 0xffffffffffffffff & int64)
133
134
135def UInt32ByteSize(field_number, uint32):
136  return UInt64ByteSize(field_number, uint32)
137
138
139def UInt64ByteSize(field_number, uint64):
140  return TagByteSize(field_number) + _VarUInt64ByteSizeNoTag(uint64)
141
142
143def SInt32ByteSize(field_number, int32):
144  return UInt32ByteSize(field_number, ZigZagEncode(int32))
145
146
147def SInt64ByteSize(field_number, int64):
148  return UInt64ByteSize(field_number, ZigZagEncode(int64))
149
150
151def Fixed32ByteSize(field_number, fixed32):
152  return TagByteSize(field_number) + 4
153
154
155def Fixed64ByteSize(field_number, fixed64):
156  return TagByteSize(field_number) + 8
157
158
159def SFixed32ByteSize(field_number, sfixed32):
160  return TagByteSize(field_number) + 4
161
162
163def SFixed64ByteSize(field_number, sfixed64):
164  return TagByteSize(field_number) + 8
165
166
167def FloatByteSize(field_number, flt):
168  return TagByteSize(field_number) + 4
169
170
171def DoubleByteSize(field_number, double):
172  return TagByteSize(field_number) + 8
173
174
175def BoolByteSize(field_number, b):
176  return TagByteSize(field_number) + 1
177
178
179def EnumByteSize(field_number, enum):
180  return UInt32ByteSize(field_number, enum)
181
182
183def StringByteSize(field_number, string):
184  return BytesByteSize(field_number, string.encode('utf-8'))
185
186
187def BytesByteSize(field_number, b):
188  return (TagByteSize(field_number)
189          + _VarUInt64ByteSizeNoTag(len(b))
190          + len(b))
191
192
193def GroupByteSize(field_number, message):
194  return (2 * TagByteSize(field_number)  # START and END group.
195          + message.ByteSize())
196
197
198def MessageByteSize(field_number, message):
199  return (TagByteSize(field_number)
200          + _VarUInt64ByteSizeNoTag(message.ByteSize())
201          + message.ByteSize())
202
203
204def 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
224def 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
232def _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
251NON_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
259def 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