-import collections
import functools
import io
import struct
-TAG_NULL = 0x00
-TAG_TRUE = 0x01
-TAG_FALSE = 0x02
-TAG_UINT8 = 0x03
-TAG_UINT16 = 0x04
-TAG_UINT32 = 0x05
-TAG_UINT64 = 0x06
-TAG_INT8 = 0x10
-TAG_INT16 = 0x11
-TAG_INT32 = 0x12
-TAG_INT64 = 0x13
-TAG_BINARY = 0x20
-TAG_UTF8 = 0x21
-TAG_UTF16 = 0x22
-TAG_UTF32 = 0x23
-TAG_TUPLE = 0x30
-
-TaggedObject = collections.namedtuple(
- 'TaggedObject',
- [
- 'tag',
- 'instance',
- ],
-)
+from . import tags
def _make_tag_only_serializer(tag, expected_value):
tag = bytes([tag])
fmt = '!BI'
- return struct.pack('!BI', TAG_TUPLE, len(payload)) + payload
+ return struct.pack('!BI', tags.TUPLE, len(payload)) + payload
+def _serialize_list(to):
+ assert isinstance(to.instance, list)
+
+ # TODO Actually handle this case somehow
+ assert len(to.instance) > 0
+
+ # TODO Do this a better way
+ serialized_items = [serialize(i) for i in to.instance]
+ list_tag = serialized_items[0][0]
+
+ def check_and_strip_prefix(b):
+ item_tag = b[0]
+ assert list_tag == item_tag
+ return b[1:]
+
+ payload = b''.join(check_and_strip_prefix(si) for si in serialized_items)
+
+ fmt = '!BBI'
+
+ return struct.pack(fmt, tags.LIST, list_tag, len(payload)) + payload
_TAGS_TO_SERIALIZERS = {
- TAG_NULL: _make_tag_only_serializer(TAG_NULL, None),
- TAG_TRUE: _make_tag_only_serializer(TAG_TRUE, True),
- TAG_FALSE: _make_tag_only_serializer(TAG_FALSE, False),
- TAG_UINT8: _make_struct_serializer('B'),
- TAG_UINT16: _make_struct_serializer('H'),
- TAG_UINT32: _make_struct_serializer('I'),
- TAG_UINT64: _make_struct_serializer('Q'),
- TAG_INT8: _make_struct_serializer('b'),
- TAG_INT16: _make_struct_serializer('h'),
- TAG_INT32: _make_struct_serializer('i'),
- TAG_INT64: _make_struct_serializer('q'),
- TAG_BINARY: _make_string_serializer(lambda s: s),
- TAG_UTF8: _make_string_serializer(lambda s: s.encode('utf-8')),
- TAG_UTF16: _make_string_serializer(lambda s: s.encode('utf-16')),
- TAG_UTF32: _make_string_serializer(lambda s: s.encode('utf-32')),
- TAG_TUPLE: _serialize_tuple,
+ tags.NULL: _make_tag_only_serializer(tags.NULL, None),
+ tags.TRUE: _make_tag_only_serializer(tags.TRUE, True),
+ tags.FALSE: _make_tag_only_serializer(tags.FALSE, False),
+ tags.UINT8: _make_struct_serializer('B'),
+ tags.UINT16: _make_struct_serializer('H'),
+ tags.UINT32: _make_struct_serializer('I'),
+ tags.UINT64: _make_struct_serializer('Q'),
+ tags.INT8: _make_struct_serializer('b'),
+ tags.INT16: _make_struct_serializer('h'),
+ tags.INT32: _make_struct_serializer('i'),
+ tags.INT64: _make_struct_serializer('q'),
+ tags.BINARY: _make_string_serializer(lambda s: s),
+ tags.UTF8: _make_string_serializer(lambda s: s.encode('utf-8')),
+ tags.UTF16: _make_string_serializer(lambda s: s.encode('utf-16')),
+ tags.UTF32: _make_string_serializer(lambda s: s.encode('utf-32')),
+ tags.TUPLE: _serialize_tuple,
+ tags.LIST: _serialize_list,
}
def serialize(to):
def _make_tag_only_parser(tag, value):
def parser(b):
- return 0, TaggedObject(tag = tag, instance = value)
+ return 0, tags.TaggedObject(tag = tag, instance = value)
return parser
def parser(b):
b = b.read(size)
assert len(b) == size
- return size, TaggedObject(tag = tag, instance = unpacker(b)[0])
+ return size, tags.TaggedObject(tag = tag, instance = unpacker(b)[0])
return parser
def parser(b):
bytes_read, payload = _read_length_then_payload(b)
- return bytes_read, TaggedObject(tag = tag, instance = decoder(payload))
+ return bytes_read, tags.TaggedObject(tag = tag, instance = decoder(payload))
return parser
total_bytes_read += partial_bytes_read
instance.append(item)
- return bytes_read, TaggedObject(tag = TAG_TUPLE, instance = tuple(instance))
+ return bytes_read, tags.TaggedObject(tag = tags.TUPLE, instance = tuple(instance))
+
+def _deserialize_list(b):
+ list_tag_bytes = b.read(1)
+ assert len(list_tag_bytes) == 1
+ list_tag = list_tag_bytes[0]
+
+ bytes_read, payload = _read_length_then_payload(b)
+
+ payload_stream = io.BytesIO(payload)
+
+ total_bytes_read = 0
+ instance = []
+
+ while total_bytes_read < len(payload):
+ partial_bytes_read, item = _TAGS_TO_PARSERS[list_tag](payload_stream)
+ total_bytes_read += partial_bytes_read
+ instance.append(item)
+
+ # TODO Return tags = (tags.LIST, list_tag) to function like a generic type
+ return bytes_read, tags.TaggedObject(tag = tags.LIST, instance = instance)
_TAGS_TO_PARSERS = {
- TAG_NULL: _make_tag_only_parser(TAG_NULL, None),
- TAG_TRUE: _make_tag_only_parser(TAG_TRUE, True),
- TAG_FALSE: _make_tag_only_parser(TAG_FALSE, False),
- TAG_UINT8: _make_struct_deserializer(TAG_UINT8, 'B'),
- TAG_UINT16: _make_struct_deserializer(TAG_UINT16, 'H'),
- TAG_UINT32: _make_struct_deserializer(TAG_UINT32, 'I'),
- TAG_UINT64: _make_struct_deserializer(TAG_UINT64, 'Q'),
- TAG_INT8: _make_struct_deserializer(TAG_INT8, 'b'),
- TAG_INT16: _make_struct_deserializer(TAG_INT16, 'h'),
- TAG_INT32: _make_struct_deserializer(TAG_INT32, 'i'),
- TAG_INT64: _make_struct_deserializer(TAG_INT64, 'q'),
- TAG_BINARY: _make_string_deserializer(TAG_BINARY, lambda b: b),
- TAG_UTF8: _make_string_deserializer(TAG_UTF8, lambda b: b.decode('utf-8')),
- TAG_UTF16: _make_string_deserializer(TAG_UTF16, lambda b: b.decode('utf-16')),
- TAG_UTF32: _make_string_deserializer(TAG_UTF32, lambda b: b.decode('utf-32')),
- TAG_TUPLE: _deserialize_tuple,
+ tags.NULL: _make_tag_only_parser(tags.NULL, None),
+ tags.TRUE: _make_tag_only_parser(tags.TRUE, True),
+ tags.FALSE: _make_tag_only_parser(tags.FALSE, False),
+ tags.UINT8: _make_struct_deserializer(tags.UINT8, 'B'),
+ tags.UINT16: _make_struct_deserializer(tags.UINT16, 'H'),
+ tags.UINT32: _make_struct_deserializer(tags.UINT32, 'I'),
+ tags.UINT64: _make_struct_deserializer(tags.UINT64, 'Q'),
+ tags.INT8: _make_struct_deserializer(tags.INT8, 'b'),
+ tags.INT16: _make_struct_deserializer(tags.INT16, 'h'),
+ tags.INT32: _make_struct_deserializer(tags.INT32, 'i'),
+ tags.INT64: _make_struct_deserializer(tags.INT64, 'q'),
+ tags.BINARY: _make_string_deserializer(tags.BINARY, lambda b: b),
+ tags.UTF8: _make_string_deserializer(tags.UTF8, lambda b: b.decode('utf-8')),
+ tags.UTF16: _make_string_deserializer(tags.UTF16, lambda b: b.decode('utf-16')),
+ tags.UTF32: _make_string_deserializer(tags.UTF32, lambda b: b.decode('utf-32')),
+ tags.TUPLE: _deserialize_tuple,
+ tags.LIST: _deserialize_list,
}
def _deserialize_partial(b):
projects / sandbox / blobdiff