← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/mozc/oneiric

« back to all changes in this revision

Viewing changes to protobuf/files/python/google/protobuf/internal/wire_format.py

  • Committer: Bazaar Package Importer
  • Author(s): Nobuhiro Iwamatsu
  • Date: 2010-07-14 03:26:47 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20100714032647-13qjisj6m8cm8jdx
Tags: 0.12.410.102-1
http://bugs.debian.org/588971
http://bugs.debian.org/588972
* New upstream release (Closes: #588971).
  - Add mozc-server, mozc-utils-gui and scim-mozc packages.
* Update debian/rules.
  Add --gypdir option to build_mozc.py.
* Update debian/control.
  - Bumped standards-version to 3.9.0.
  - Update description.
* Add mozc icon (Closes: #588972).
* Add patch which revises issue 18.
  ibus_mozc_issue18.patch
* kFreeBSD build support.
  support_kfreebsd.patch

Show diffs side-by-side

added added

removed removed

Lines of Context:
protobuf/files/python/google/protobuf/internal/wire_format.py
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