RubyGems - libv8 - Versions diffs - 7.3.492.27.1 → 8.4.255.0 - Mend

libv8 7.3.492.27.1 → 8.4.255.0

Files changed (718) hide show

data/vendor/depot_tools/third_party/protobuf26/internal/type_checkers.py DELETED

@@ -1,328 +0,0 @@
-# Protocol Buffers - Google's data interchange format
-# Copyright 2008 Google Inc.  All rights reserved.
-# http://code.google.com/p/protobuf/
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are
-# met:
-#
-#     * Redistributions of source code must retain the above copyright
-# notice, this list of conditions and the following disclaimer.
-#     * Redistributions in binary form must reproduce the above
-# copyright notice, this list of conditions and the following disclaimer
-# in the documentation and/or other materials provided with the
-# distribution.
-#     * Neither the name of Google Inc. nor the names of its
-# contributors may be used to endorse or promote products derived from
-# this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-#PY25 compatible for GAE.
-#
-# Copyright 2008 Google Inc. All Rights Reserved.
-"""Provides type checking routines.
-This module defines type checking utilities in the forms of dictionaries:
-VALUE_CHECKERS: A dictionary of field types and a value validation object.
-TYPE_TO_BYTE_SIZE_FN: A dictionary with field types and a size computing
-  function.
-TYPE_TO_SERIALIZE_METHOD: A dictionary with field types and serialization
-  function.
-FIELD_TYPE_TO_WIRE_TYPE: A dictionary with field typed and their
-  coresponding wire types.
-TYPE_TO_DESERIALIZE_METHOD: A dictionary with field types and deserialization
-  function.
-"""
-__author__ = 'robinson@google.com (Will Robinson)'
-import sys  ##PY25
-if sys.version < '2.6': bytes = str  ##PY25
-from protobuf26.internal import api_implementation
-from protobuf26.internal import decoder
-from protobuf26.internal import encoder
-from protobuf26.internal import wire_format
-from protobuf26 import descriptor
-_FieldDescriptor = descriptor.FieldDescriptor
-def GetTypeChecker(field):
-  """Returns a type checker for a message field of the specified types.
-  Args:
-    field: FieldDescriptor object for this field.
-  Returns:
-    An instance of TypeChecker which can be used to verify the types
-    of values assigned to a field of the specified type.
-  """
-  if (field.cpp_type == _FieldDescriptor.CPPTYPE_STRING and
-      field.type == _FieldDescriptor.TYPE_STRING):
-    return UnicodeValueChecker()
-  if field.cpp_type == _FieldDescriptor.CPPTYPE_ENUM:
-    return EnumValueChecker(field.enum_type)
-  return _VALUE_CHECKERS[field.cpp_type]
-# None of the typecheckers below make any attempt to guard against people
-# subclassing builtin types and doing weird things.  We're not trying to
-# protect against malicious clients here, just people accidentally shooting
-# themselves in the foot in obvious ways.
-class TypeChecker(object):
-  """Type checker used to catch type errors as early as possible
-  when the client is setting scalar fields in protocol messages.
-  """
-  def __init__(self, *acceptable_types):
-    self._acceptable_types = acceptable_types
-  def CheckValue(self, proposed_value):
-    """Type check the provided value and return it.
-    The returned value might have been normalized to another type.
-    """
-    if not isinstance(proposed_value, self._acceptable_types):
-      message = ('%.1024r has type %s, but expected one of: %s' %
-                 (proposed_value, type(proposed_value), self._acceptable_types))
-      raise TypeError(message)
-    return proposed_value
-# IntValueChecker and its subclasses perform integer type-checks
-# and bounds-checks.
-class IntValueChecker(object):
-  """Checker used for integer fields.  Performs type-check and range check."""
-  def CheckValue(self, proposed_value):
-    if not isinstance(proposed_value, (int, long)):
-      message = ('%.1024r has type %s, but expected one of: %s' %
-                 (proposed_value, type(proposed_value), (int, long)))
-      raise TypeError(message)
-    if not self._MIN <= proposed_value <= self._MAX:
-      raise ValueError('Value out of range: %d' % proposed_value)
-    # We force 32-bit values to int and 64-bit values to long to make
-    # alternate implementations where the distinction is more significant
-    # (e.g. the C++ implementation) simpler.
-    proposed_value = self._TYPE(proposed_value)
-    return proposed_value
-class EnumValueChecker(object):
-  """Checker used for enum fields.  Performs type-check and range check."""
-  def __init__(self, enum_type):
-    self._enum_type = enum_type
-  def CheckValue(self, proposed_value):
-    if not isinstance(proposed_value, (int, long)):
-      message = ('%.1024r has type %s, but expected one of: %s' %
-                 (proposed_value, type(proposed_value), (int, long)))
-      raise TypeError(message)
-    if proposed_value not in self._enum_type.values_by_number:
-      raise ValueError('Unknown enum value: %d' % proposed_value)
-    return proposed_value
-class UnicodeValueChecker(object):
-  """Checker used for string fields.
-  Always returns a unicode value, even if the input is of type str.
-  """
-  def CheckValue(self, proposed_value):
-    if not isinstance(proposed_value, (bytes, unicode)):
-      message = ('%.1024r has type %s, but expected one of: %s' %
-                 (proposed_value, type(proposed_value), (bytes, unicode)))
-      raise TypeError(message)
-    # If the value is of type 'bytes' make sure that it is in 7-bit ASCII
-    # encoding.
-    if isinstance(proposed_value, bytes):
-      try:
-        proposed_value = proposed_value.decode('ascii')
-      except UnicodeDecodeError:
-        raise ValueError('%.1024r has type bytes, but isn\'t in 7-bit ASCII '
-                         'encoding. Non-ASCII strings must be converted to '
-                         'unicode objects before being added.' %
-                         (proposed_value))
-    return proposed_value
-class Int32ValueChecker(IntValueChecker):
-  # We're sure to use ints instead of longs here since comparison may be more
-  # efficient.
-  _MIN = -2147483648
-  _MAX = 2147483647
-  _TYPE = int
-class Uint32ValueChecker(IntValueChecker):
-  _MIN = 0
-  _MAX = (1 << 32) - 1
-  _TYPE = int
-class Int64ValueChecker(IntValueChecker):
-  _MIN = -(1 << 63)
-  _MAX = (1 << 63) - 1
-  _TYPE = long
-class Uint64ValueChecker(IntValueChecker):
-  _MIN = 0
-  _MAX = (1 << 64) - 1
-  _TYPE = long
-# Type-checkers for all scalar CPPTYPEs.
-_VALUE_CHECKERS = {
-    _FieldDescriptor.CPPTYPE_INT32: Int32ValueChecker(),
-    _FieldDescriptor.CPPTYPE_INT64: Int64ValueChecker(),
-    _FieldDescriptor.CPPTYPE_UINT32: Uint32ValueChecker(),
-    _FieldDescriptor.CPPTYPE_UINT64: Uint64ValueChecker(),
-    _FieldDescriptor.CPPTYPE_DOUBLE: TypeChecker(
-        float, int, long),
-    _FieldDescriptor.CPPTYPE_FLOAT: TypeChecker(
-        float, int, long),
-    _FieldDescriptor.CPPTYPE_BOOL: TypeChecker(bool, int),
-    _FieldDescriptor.CPPTYPE_STRING: TypeChecker(bytes),
-    }
-# Map from field type to a function F, such that F(field_num, value)
-# gives the total byte size for a value of the given type.  This
-# byte size includes tag information and any other additional space
-# associated with serializing "value".
-TYPE_TO_BYTE_SIZE_FN = {
-    _FieldDescriptor.TYPE_DOUBLE: wire_format.DoubleByteSize,
-    _FieldDescriptor.TYPE_FLOAT: wire_format.FloatByteSize,
-    _FieldDescriptor.TYPE_INT64: wire_format.Int64ByteSize,
-    _FieldDescriptor.TYPE_UINT64: wire_format.UInt64ByteSize,
-    _FieldDescriptor.TYPE_INT32: wire_format.Int32ByteSize,
-    _FieldDescriptor.TYPE_FIXED64: wire_format.Fixed64ByteSize,
-    _FieldDescriptor.TYPE_FIXED32: wire_format.Fixed32ByteSize,
-    _FieldDescriptor.TYPE_BOOL: wire_format.BoolByteSize,
-    _FieldDescriptor.TYPE_STRING: wire_format.StringByteSize,
-    _FieldDescriptor.TYPE_GROUP: wire_format.GroupByteSize,
-    _FieldDescriptor.TYPE_MESSAGE: wire_format.MessageByteSize,
-    _FieldDescriptor.TYPE_BYTES: wire_format.BytesByteSize,
-    _FieldDescriptor.TYPE_UINT32: wire_format.UInt32ByteSize,
-    _FieldDescriptor.TYPE_ENUM: wire_format.EnumByteSize,
-    _FieldDescriptor.TYPE_SFIXED32: wire_format.SFixed32ByteSize,
-    _FieldDescriptor.TYPE_SFIXED64: wire_format.SFixed64ByteSize,
-    _FieldDescriptor.TYPE_SINT32: wire_format.SInt32ByteSize,
-    _FieldDescriptor.TYPE_SINT64: wire_format.SInt64ByteSize
-    }
-# Maps from field types to encoder constructors.
-TYPE_TO_ENCODER = {
-    _FieldDescriptor.TYPE_DOUBLE: encoder.DoubleEncoder,
-    _FieldDescriptor.TYPE_FLOAT: encoder.FloatEncoder,
-    _FieldDescriptor.TYPE_INT64: encoder.Int64Encoder,
-    _FieldDescriptor.TYPE_UINT64: encoder.UInt64Encoder,
-    _FieldDescriptor.TYPE_INT32: encoder.Int32Encoder,
-    _FieldDescriptor.TYPE_FIXED64: encoder.Fixed64Encoder,
-    _FieldDescriptor.TYPE_FIXED32: encoder.Fixed32Encoder,
-    _FieldDescriptor.TYPE_BOOL: encoder.BoolEncoder,
-    _FieldDescriptor.TYPE_STRING: encoder.StringEncoder,
-    _FieldDescriptor.TYPE_GROUP: encoder.GroupEncoder,
-    _FieldDescriptor.TYPE_MESSAGE: encoder.MessageEncoder,
-    _FieldDescriptor.TYPE_BYTES: encoder.BytesEncoder,
-    _FieldDescriptor.TYPE_UINT32: encoder.UInt32Encoder,
-    _FieldDescriptor.TYPE_ENUM: encoder.EnumEncoder,
-    _FieldDescriptor.TYPE_SFIXED32: encoder.SFixed32Encoder,
-    _FieldDescriptor.TYPE_SFIXED64: encoder.SFixed64Encoder,
-    _FieldDescriptor.TYPE_SINT32: encoder.SInt32Encoder,
-    _FieldDescriptor.TYPE_SINT64: encoder.SInt64Encoder,
-    }
-# Maps from field types to sizer constructors.
-TYPE_TO_SIZER = {
-    _FieldDescriptor.TYPE_DOUBLE: encoder.DoubleSizer,
-    _FieldDescriptor.TYPE_FLOAT: encoder.FloatSizer,
-    _FieldDescriptor.TYPE_INT64: encoder.Int64Sizer,
-    _FieldDescriptor.TYPE_UINT64: encoder.UInt64Sizer,
-    _FieldDescriptor.TYPE_INT32: encoder.Int32Sizer,
-    _FieldDescriptor.TYPE_FIXED64: encoder.Fixed64Sizer,
-    _FieldDescriptor.TYPE_FIXED32: encoder.Fixed32Sizer,
-    _FieldDescriptor.TYPE_BOOL: encoder.BoolSizer,
-    _FieldDescriptor.TYPE_STRING: encoder.StringSizer,
-    _FieldDescriptor.TYPE_GROUP: encoder.GroupSizer,
-    _FieldDescriptor.TYPE_MESSAGE: encoder.MessageSizer,
-    _FieldDescriptor.TYPE_BYTES: encoder.BytesSizer,
-    _FieldDescriptor.TYPE_UINT32: encoder.UInt32Sizer,
-    _FieldDescriptor.TYPE_ENUM: encoder.EnumSizer,
-    _FieldDescriptor.TYPE_SFIXED32: encoder.SFixed32Sizer,
-    _FieldDescriptor.TYPE_SFIXED64: encoder.SFixed64Sizer,
-    _FieldDescriptor.TYPE_SINT32: encoder.SInt32Sizer,
-    _FieldDescriptor.TYPE_SINT64: encoder.SInt64Sizer,
-    }
-# Maps from field type to a decoder constructor.
-TYPE_TO_DECODER = {
-    _FieldDescriptor.TYPE_DOUBLE: decoder.DoubleDecoder,
-    _FieldDescriptor.TYPE_FLOAT: decoder.FloatDecoder,
-    _FieldDescriptor.TYPE_INT64: decoder.Int64Decoder,
-    _FieldDescriptor.TYPE_UINT64: decoder.UInt64Decoder,
-    _FieldDescriptor.TYPE_INT32: decoder.Int32Decoder,
-    _FieldDescriptor.TYPE_FIXED64: decoder.Fixed64Decoder,
-    _FieldDescriptor.TYPE_FIXED32: decoder.Fixed32Decoder,
-    _FieldDescriptor.TYPE_BOOL: decoder.BoolDecoder,
-    _FieldDescriptor.TYPE_STRING: decoder.StringDecoder,
-    _FieldDescriptor.TYPE_GROUP: decoder.GroupDecoder,
-    _FieldDescriptor.TYPE_MESSAGE: decoder.MessageDecoder,
-    _FieldDescriptor.TYPE_BYTES: decoder.BytesDecoder,
-    _FieldDescriptor.TYPE_UINT32: decoder.UInt32Decoder,
-    _FieldDescriptor.TYPE_ENUM: decoder.EnumDecoder,
-    _FieldDescriptor.TYPE_SFIXED32: decoder.SFixed32Decoder,
-    _FieldDescriptor.TYPE_SFIXED64: decoder.SFixed64Decoder,
-    _FieldDescriptor.TYPE_SINT32: decoder.SInt32Decoder,
-    _FieldDescriptor.TYPE_SINT64: decoder.SInt64Decoder,
-    }
-# Maps from field type to expected wiretype.
-FIELD_TYPE_TO_WIRE_TYPE = {
-    _FieldDescriptor.TYPE_DOUBLE: wire_format.WIRETYPE_FIXED64,
-    _FieldDescriptor.TYPE_FLOAT: wire_format.WIRETYPE_FIXED32,
-    _FieldDescriptor.TYPE_INT64: wire_format.WIRETYPE_VARINT,
-    _FieldDescriptor.TYPE_UINT64: wire_format.WIRETYPE_VARINT,
-    _FieldDescriptor.TYPE_INT32: wire_format.WIRETYPE_VARINT,
-    _FieldDescriptor.TYPE_FIXED64: wire_format.WIRETYPE_FIXED64,
-    _FieldDescriptor.TYPE_FIXED32: wire_format.WIRETYPE_FIXED32,
-    _FieldDescriptor.TYPE_BOOL: wire_format.WIRETYPE_VARINT,
-    _FieldDescriptor.TYPE_STRING:
-      wire_format.WIRETYPE_LENGTH_DELIMITED,
-    _FieldDescriptor.TYPE_GROUP: wire_format.WIRETYPE_START_GROUP,
-    _FieldDescriptor.TYPE_MESSAGE:
-      wire_format.WIRETYPE_LENGTH_DELIMITED,
-    _FieldDescriptor.TYPE_BYTES:
-      wire_format.WIRETYPE_LENGTH_DELIMITED,
-    _FieldDescriptor.TYPE_UINT32: wire_format.WIRETYPE_VARINT,
-    _FieldDescriptor.TYPE_ENUM: wire_format.WIRETYPE_VARINT,
-    _FieldDescriptor.TYPE_SFIXED32: wire_format.WIRETYPE_FIXED32,
-    _FieldDescriptor.TYPE_SFIXED64: wire_format.WIRETYPE_FIXED64,
-    _FieldDescriptor.TYPE_SINT32: wire_format.WIRETYPE_VARINT,
-    _FieldDescriptor.TYPE_SINT64: wire_format.WIRETYPE_VARINT,
-    }

data/vendor/depot_tools/third_party/protobuf26/internal/wire_format.py DELETED

@@ -1,268 +0,0 @@
-# Protocol Buffers - Google's data interchange format
-# Copyright 2008 Google Inc.  All rights reserved.
-# http://code.google.com/p/protobuf/
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are
-# met:
-#
-#     * Redistributions of source code must retain the above copyright
-# notice, this list of conditions and the following disclaimer.
-#     * Redistributions in binary form must reproduce the above
-# copyright notice, this list of conditions and the following disclaimer
-# in the documentation and/or other materials provided with the
-# distribution.
-#     * Neither the name of Google Inc. nor the names of its
-# contributors may be used to endorse or promote products derived from
-# this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-"""Constants and static functions to support protocol buffer wire format."""
-__author__ = 'robinson@google.com (Will Robinson)'
-import struct
-from protobuf26 import descriptor
-from protobuf26 import message
-TAG_TYPE_BITS = 3  # Number of bits used to hold type info in a proto tag.
-TAG_TYPE_MASK = (1 << TAG_TYPE_BITS) - 1  # 0x7
-# These numbers identify the wire type of a protocol buffer value.
-# We use the least-significant TAG_TYPE_BITS bits of the varint-encoded
-# tag-and-type to store one of these WIRETYPE_* constants.
-# These values must match WireType enum in google/protobuf/wire_format.h.
-WIRETYPE_VARINT = 0
-WIRETYPE_FIXED64 = 1
-WIRETYPE_LENGTH_DELIMITED = 2
-WIRETYPE_START_GROUP = 3
-WIRETYPE_END_GROUP = 4
-WIRETYPE_FIXED32 = 5
-_WIRETYPE_MAX = 5
-# Bounds for various integer types.
-INT32_MAX = int((1 << 31) - 1)
-INT32_MIN = int(-(1 << 31))
-UINT32_MAX = (1 << 32) - 1
-INT64_MAX = (1 << 63) - 1
-INT64_MIN = -(1 << 63)
-UINT64_MAX = (1 << 64) - 1
-# "struct" format strings that will encode/decode the specified formats.
-FORMAT_UINT32_LITTLE_ENDIAN = '<I'
-FORMAT_UINT64_LITTLE_ENDIAN = '<Q'
-FORMAT_FLOAT_LITTLE_ENDIAN = '<f'
-FORMAT_DOUBLE_LITTLE_ENDIAN = '<d'
-# We'll have to provide alternate implementations of AppendLittleEndian*() on
-# any architectures where these checks fail.
-if struct.calcsize(FORMAT_UINT32_LITTLE_ENDIAN) != 4:
-  raise AssertionError('Format "I" is not a 32-bit number.')
-if struct.calcsize(FORMAT_UINT64_LITTLE_ENDIAN) != 8:
-  raise AssertionError('Format "Q" is not a 64-bit number.')
-def PackTag(field_number, wire_type):
-  """Returns an unsigned 32-bit integer that encodes the field number and
-  wire type information in standard protocol message wire format.
-  Args:
-    field_number: Expected to be an integer in the range [1, 1 << 29)
-    wire_type: One of the WIRETYPE_* constants.
-  """
-  if not 0 <= wire_type <= _WIRETYPE_MAX:
-    raise message.EncodeError('Unknown wire type: %d' % wire_type)
-  return (field_number << TAG_TYPE_BITS) | wire_type
-def UnpackTag(tag):
-  """The inverse of PackTag().  Given an unsigned 32-bit number,
-  returns a (field_number, wire_type) tuple.
-  """
-  return (tag >> TAG_TYPE_BITS), (tag & TAG_TYPE_MASK)
-def ZigZagEncode(value):
-  """ZigZag Transform:  Encodes signed integers so that they can be
-  effectively used with varint encoding.  See wire_format.h for
-  more details.
-  """
-  if value >= 0:
-    return value << 1
-  return (value << 1) ^ (~0)
-def ZigZagDecode(value):
-  """Inverse of ZigZagEncode()."""
-  if not value & 0x1:
-    return value >> 1
-  return (value >> 1) ^ (~0)
-# The *ByteSize() functions below return the number of bytes required to
-# serialize "field number + type" information and then serialize the value.
-def Int32ByteSize(field_number, int32):
-  return Int64ByteSize(field_number, int32)
-def Int32ByteSizeNoTag(int32):
-  return _VarUInt64ByteSizeNoTag(0xffffffffffffffff & int32)
-def Int64ByteSize(field_number, int64):
-  # Have to convert to uint before calling UInt64ByteSize().
-  return UInt64ByteSize(field_number, 0xffffffffffffffff & int64)
-def UInt32ByteSize(field_number, uint32):
-  return UInt64ByteSize(field_number, uint32)
-def UInt64ByteSize(field_number, uint64):
-  return TagByteSize(field_number) + _VarUInt64ByteSizeNoTag(uint64)
-def SInt32ByteSize(field_number, int32):
-  return UInt32ByteSize(field_number, ZigZagEncode(int32))
-def SInt64ByteSize(field_number, int64):
-  return UInt64ByteSize(field_number, ZigZagEncode(int64))
-def Fixed32ByteSize(field_number, fixed32):
-  return TagByteSize(field_number) + 4
-def Fixed64ByteSize(field_number, fixed64):
-  return TagByteSize(field_number) + 8
-def SFixed32ByteSize(field_number, sfixed32):
-  return TagByteSize(field_number) + 4
-def SFixed64ByteSize(field_number, sfixed64):
-  return TagByteSize(field_number) + 8
-def FloatByteSize(field_number, flt):
-  return TagByteSize(field_number) + 4
-def DoubleByteSize(field_number, double):
-  return TagByteSize(field_number) + 8
-def BoolByteSize(field_number, b):
-  return TagByteSize(field_number) + 1
-def EnumByteSize(field_number, enum):
-  return UInt32ByteSize(field_number, enum)
-def StringByteSize(field_number, string):
-  return BytesByteSize(field_number, string.encode('utf-8'))
-def BytesByteSize(field_number, b):
-  return (TagByteSize(field_number)
-          + _VarUInt64ByteSizeNoTag(len(b))
-          + len(b))
-def GroupByteSize(field_number, message):
-  return (2 * TagByteSize(field_number)  # START and END group.
-          + message.ByteSize())
-def MessageByteSize(field_number, message):
-  return (TagByteSize(field_number)
-          + _VarUInt64ByteSizeNoTag(message.ByteSize())
-          + message.ByteSize())
-def MessageSetItemByteSize(field_number, msg):
-  # First compute the sizes of the tags.
-  # There are 2 tags for the beginning and ending of the repeated group, that
-  # is field number 1, one with field number 2 (type_id) and one with field
-  # number 3 (message).
-  total_size = (2 * TagByteSize(1) + TagByteSize(2) + TagByteSize(3))
-  # Add the number of bytes for type_id.
-  total_size += _VarUInt64ByteSizeNoTag(field_number)
-  message_size = msg.ByteSize()
-  # The number of bytes for encoding the length of the message.
-  total_size += _VarUInt64ByteSizeNoTag(message_size)
-  # The size of the message.
-  total_size += message_size
-  return total_size
-def TagByteSize(field_number):
-  """Returns the bytes required to serialize a tag with this field number."""
-  # Just pass in type 0, since the type won't affect the tag+type size.
-  return _VarUInt64ByteSizeNoTag(PackTag(field_number, 0))
-# Private helper function for the *ByteSize() functions above.
-def _VarUInt64ByteSizeNoTag(uint64):
-  """Returns the number of bytes required to serialize a single varint
-  using boundary value comparisons. (unrolled loop optimization -WPierce)
-  uint64 must be unsigned.
-  """
-  if uint64 <= 0x7f: return 1
-  if uint64 <= 0x3fff: return 2
-  if uint64 <= 0x1fffff: return 3
-  if uint64 <= 0xfffffff: return 4
-  if uint64 <= 0x7ffffffff: return 5
-  if uint64 <= 0x3ffffffffff: return 6
-  if uint64 <= 0x1ffffffffffff: return 7
-  if uint64 <= 0xffffffffffffff: return 8
-  if uint64 <= 0x7fffffffffffffff: return 9
-  if uint64 > UINT64_MAX:
-    raise message.EncodeError('Value out of range: %d' % uint64)
-  return 10
-NON_PACKABLE_TYPES = (
-  descriptor.FieldDescriptor.TYPE_STRING,
-  descriptor.FieldDescriptor.TYPE_GROUP,
-  descriptor.FieldDescriptor.TYPE_MESSAGE,
-  descriptor.FieldDescriptor.TYPE_BYTES
-)
-def IsTypePackable(field_type):
-  """Return true iff packable = true is valid for fields of this type.
-  Args:
-    field_type: a FieldDescriptor::Type value.
-  Returns:
-    True iff fields of this type are packable.
-  """
-  return field_type not in NON_PACKABLE_TYPES