def AppendVarUInt32(self, value):
"""Appends an unsigned 32-bit integer to the internal buffer,
encoded as a varint.
"""
if not 0 <= value <= wire_format.UINT32_MAX:
raise message.EncodeError('Value out of range: %d' % value)
self.AppendVarUInt64(value)
def _BytesForNonRepeatedElement(value, field_number, field_type):
try:
fn = type_checkers.TYPE_TO_BYTE_SIZE_FN[field_type]
return fn(field_number, value)
except KeyError:
raise message_mod.EncodeError('Unrecognized field type: %d' %
field_type)
def Put16(self, value):
"""Encode a fixed size 16 bit value in the buffer."""
if value < 0 or value >= (1 << 16):
raise message.EncodeError('u16 too big')
self.buf.append((value >> 8) & 0xff)
self.buf.append((value >> 0) & 0xff)
return
def SerializeToString(self):
errors = []
if not self.IsInitialized():
raise message_mod.EncodeError(
'Message is missing required fields: ' +
','.join(self.FindInitializationErrors()))
return self.SerializePartialToString().encode('latin-1')
def AppendSFixed64NoTag(self, value):
"""Appends a signed 64-bit integer to our buffer, in little-endian
byte-order.
"""
sign = (value & 0x8000000000000000) and -1 or 0
if value >> 64 != sign:
raise message.EncodeError('SFixed64 out of range: %d' % value)
self._stream.AppendLittleEndian64(value & 0xffffffffffffffff)
def SerializeToString(self):
# Check if the message has all of its required fields set.
errors = []
if not self.IsInitialized():
raise message_mod.EncodeError(
'Message is missing required fields: ' +
','.join(self.FindInitializationErrors()))
return self.SerializePartialToString()
def AppendVarint32(self, value):
"""Appends a signed 32-bit integer to the internal buffer,
encoded as a varint. (Note that a negative varint32 will
always require 10 bytes of space.)
"""
if not wire_format.INT32_MIN <= value <= wire_format.INT32_MAX:
raise message.EncodeError('Value out of range: %d' % value)
self.AppendVarint64(value)
def Put32(self, value):
"""Encode a fixed size 32 bit value in the buffer."""
if value < 0 or value >= (1 << 32):
raise message.EncodeError('u32 too big')
self.buf.append((value >> 24) & 0xff)
self.buf.append((value >> 16) & 0xff)
self.buf.append((value >> 8) & 0xff)
self.buf.append((value >> 0) & 0xff)
return
def AppendSFixed64(self, field_number, value):
"""Appends a signed 64-bit integer to our buffer, in little-endian
byte-order.
"""
sign = (value & 0x8000000000000000) and -1 or 0
if value >> 64 != sign:
raise message.EncodeError('SFixed64 out of range: %d' % value)
self._AppendTag(field_number, wire_format.WIRETYPE_FIXED64)
self._stream.AppendLittleEndian64(value & 0xffffffffffffffff)
def AppendVarint64(self, value):
"""Appends a signed 64-bit integer to the internal buffer,
encoded as a varint.
"""
if not wire_format.INT64_MIN <= value <= wire_format.INT64_MAX:
raise message.EncodeError('Value out of range: %d' % value)
if value < 0:
value += (1 << 64)
self.AppendVarUInt64(value)
def AppendLittleEndian64(self, unsigned_value):
"""Appends an unsigned 64-bit integer to the internal buffer,
in little-endian byte order.
"""
if not 0 <= unsigned_value <= wire_format.UINT64_MAX:
raise message.EncodeError(
'Unsigned 64-bit out of range: %d' % unsigned_value)
self._buffer.fromstring(struct.pack(
wire_format.FORMAT_UINT64_LITTLE_ENDIAN, unsigned_value))
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 _VarUInt64ByteSizeNoTag(uint64):
"""Returns the bytes required to serialize a single varint.
uint64 must be unsigned.
"""
if uint64 > UINT64_MAX:
raise message.EncodeError('Value out of range: %d' % uint64)
bytes = 1
while uint64 > 0x7f:
bytes += 1
uint64 >>= 7
return bytes
def Put64(self, value):
"""Encode a fixed size 64 bit value in the buffer."""
if value < 0 or value >= (1 << 64):
raise message.EncodeError('u64 too big')
self.buf.append((value >> 56) & 0xff)
self.buf.append((value >> 48) & 0xff)
self.buf.append((value >> 40) & 0xff)
self.buf.append((value >> 32) & 0xff)
self.buf.append((value >> 24) & 0xff)
self.buf.append((value >> 16) & 0xff)
self.buf.append((value >> 8) & 0xff)
self.buf.append((value >> 0) & 0xff)
return
def AppendVarUInt64(self, unsigned_value):
"""Appends an unsigned 64-bit integer to the internal buffer,
encoded as a varint.
"""
if not 0 <= unsigned_value <= wire_format.UINT64_MAX:
raise message.EncodeError('Value out of range: %d' % unsigned_value)
while True:
bits = unsigned_value & 0x7f
unsigned_value >>= 7
if not unsigned_value:
self._buffer.append(bits)
break
self._buffer.append(0x80|bits)
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
def _BytesForNonRepeatedElement(value, field_number, field_type):
"""Returns the number of bytes needed to serialize a non-repeated element.
The returned byte count includes space for tag information and any
other additional space associated with serializing value.
Args:
value: Value we're serializing.
field_number: Field number of this value. (Since the field number
is stored as part of a varint-encoded tag, this has an impact
on the total bytes required to serialize the value).
field_type: The type of the field. One of the TYPE_* constants
within FieldDescriptor.
"""
try:
fn = type_checkers.TYPE_TO_BYTE_SIZE_FN[field_type]
return fn(field_number, value)
except KeyError:
raise message_mod.EncodeError('Unrecognized field type: %d' % field_type)
def _VarUInt64ByteSizeNoTag(uint64):
if uint64 <= 127:
return 1
if uint64 <= 16383:
return 2
if uint64 <= 2097151:
return 3
if uint64 <= 268435455:
return 4
if uint64 <= 34359738367:
return 5
if uint64 <= 4398046511103:
return 6
if uint64 <= 562949953421311:
return 7
if uint64 <= 72057594037927935:
return 8
if uint64 <= 9223372036854775807:
return 9
if uint64 > UINT64_MAX:
raise message.EncodeError('Value out of range: %d' % uint64)
return 10
def PutVarInt64(self, value):
"""Encode a 64 bit varint value in the buffer."""
if value >= 0x8000000000000000 or value < -0x8000000000000000:
raise message.EncodeError('int64 too big')
self._PutVarInt(value)
def PutVarUint64(self, value):
"""Encode a 64 bit unsigned varint value in the buffer."""
if value < 0 or value >= 0x10000000000000000:
raise message.EncodeError('uint64 too big')
self._PutVarInt(value)
def PackTag(field_number, wire_type):
if not 0 <= wire_type <= _WIRETYPE_MAX:
raise message.EncodeError('Unknown wire type: %d' % wire_type)
return field_number << TAG_TYPE_BITS | wire_type
