See the package msgpack
for more details on the serialization
of Nit objects.
msgpack :: MsgPackDeserializer
Deserialize MessagePack format to full Nit objectsmsgpack :: serialization_read $ Bytes
A buffer containing Byte-manipulation facilitiesmsgpack :: serialization_read $ SimpleCollection
Items can be added to these collections.msgpack :: serialization_read $ Bytes
A buffer containing Byte-manipulation facilitiesmsgpack :: serialization_read $ SimpleCollection
Items can be added to these collections.Serializable::inspect
to show more useful information
serialization :: serialization_core
Abstract services to serialize Nit objects to different formatsdeserialize_json
and JsonDeserializer
serialize_to_json
and JsonSerializer
core :: union_find
union–find algorithm using an efficient disjoint-set data structuremsgpack :: serialization_common
Serialization services forserialization_write
and serialization_read
# Deserialize full Nit objects from MessagePack format
#
# See the package `msgpack` for more details on the serialization
# of Nit objects.
module serialization_read
import serialization::caching
import serialization::safe
private import json # for class_inheritance_metamodel
private import serialization::engine_tools
import serialization_common
private import read
import ext
# ---
# Easy services
redef class Bytes
# Deserialize full Nit `nullable Object` from MessagePack formated data
#
# The dynamic type of the deserialized object can be limited to `static_type`.
#
# Warning: Deserialization errors are reported with `print_error`,
# the returned object may be partial or fall back on `null`.
# To handle the errors programmatically, use a `MsgPackDeserializer`.
fun deserialize_msgpack(static_type: nullable String): nullable Object
do
var stream = new BytesReader(self)
var res = stream.deserialize_msgpack(static_type)
stream.close
return res
end
end
redef class Reader
# Deserialize full Nit `nullable Object` from MessagePack formated data
#
# This method use metadata in the MessagePack source to recreate full
# Nit objects serialized by `Writer::serialize_msgpack` or
# `MsgPackSerializer`.
#
# The dynamic type of the deserialized object can be limited to `static_type`.
#
# Warning: Deserialization errors are reported with `print_error`,
# the returned object may be partial or fall back on `null`.
# To handle the errors programmatically, use a `MsgPackDeserializer`.
fun deserialize_msgpack(static_type: nullable String): nullable Object
do
var deserializer = new MsgPackDeserializer(self)
var res = deserializer.deserialize(static_type)
if deserializer.errors.length == 1 then
print_error deserializer.errors.join("")
else if deserializer.errors.not_empty then
print_error "Deserialization Errors:\n* {deserializer.errors.join("\n* ")}"
end
return res
end
end
# ---
# Engine
# Deserialize MessagePack format to full Nit objects
class MsgPackDeserializer
super CachingDeserializer
super MsgPackEngine
super SafeDeserializer
# Source stream
var stream: Reader
# Map of attributes from the root deserialized object to the current object
private var path = new Array[Map[nullable Serializable, nullable Serializable]]
# Metadata arrays with from the root deserialized object to the current object
var path_arrays = new Array[nullable Array[nullable Object]]
# Names of the attributes from the root to the object currently being deserialized
var attributes_path = new Array[String]
# Last encountered object reference id.
#
# See `id_to_object`.
private var just_opened_id: nullable Int = null
redef fun deserialize_attribute(name, static_type)
do
if path.is_empty then
# The was a parsing error or the root is not an object
deserialize_attribute_missing = false
return null
end
var current = path.last
var serialized_value = null
var serialized_value_found = false
if current.keys.has(name) then
# Non-cached string
serialized_value = current[name]
serialized_value_found = true
else
# It may be cached, deserialize all keys until we find it
for key in current.keys.to_a do
if key isa Array[nullable Serializable] or key isa MsgPackExt then
var str = convert_object(key, "String")
if str isa String then
var value = current[key]
current.keys.remove key
current[str] = value
if str == name then
serialized_value = value
serialized_value_found = true
break
end
end
end
end
end
if not serialized_value_found then
# Let the generated code / caller of `deserialize_attribute` raise the missing attribute error
deserialize_attribute_missing = true
return null
end
attributes_path.add name
var res = convert_object(serialized_value, static_type)
attributes_path.pop
deserialize_attribute_missing = false
return res
end
# This may be called multiple times by the same object from defs of a same constructor
redef fun notify_of_creation(new_object)
do
var id = just_opened_id
if id == null then return
cache[id] = new_object
end
# Convert the simple JSON `object` to a Nit object
private fun convert_object(object: nullable Object, static_type: nullable String): nullable Object
do
#print "convert_object {if object != null then object.class_name else "null"}"
if object isa Array[nullable Object] and object.length >= 1 then
# Serialized object?
var first = object.first
if first isa MsgPackExt then
if first.typ == ext_typ_obj then
# An array starts with a *ext*, it must be a serialized object
# New object declaration
var id = first.data.to_i
if cache.has_id(id) then
# FIXME use Warning
errors.add new Error("Deserialization Error: object with id {id} is deserialized twice.")
# Keep going
end
var type_name = null
var i = 1
# Read dynamic type
if object.length >= 2 then
# Try to get the type name as a string
var o = object[i]
if o isa String and static_type == "String" and object.length == 2 then
cache[id] = o
return o
else
var typ = convert_object(object[i], "String")
if typ isa String then
type_name = typ
i += 1
end
end
end
if type_name == null then
# There was no dynamic type
# We could use a `class_name_heuristic` here...
# Fallback to the static type
if static_type != null then
type_name = static_type.strip_nullable
end
if type_name == null then
errors.add new Error("Deserialization Error: could not determine dynamic type of `{object}`.")
return null
end
end
if not accept(type_name, static_type) then return null
var attributes = null
if object.length > i then attributes = object[i]
if not attributes isa Map[nullable Serializable, nullable Serializable] then
# Some other type (could be an error), or there's no attributes
attributes = new Map[nullable Serializable, nullable Serializable]
end
# advance on path
path.push attributes
path_arrays.push object
just_opened_id = id
var value = deserialize_class(type_name)
just_opened_id = null
# revert on path
path.pop
path_arrays.pop
return value
else
errors.add new Error("Deserialization Error: unknown MessagePack ext '{first.typ}'.")
end
end
# Plain array? Try to convert it to the desired static_type
if static_type != null then
return deserialize_class(static_type.strip_nullable)
end
return object
end
if object isa Map[nullable Serializable, nullable Serializable] then
# Plain map
# TODO parse it as an instance of `static_type`
if static_type != null then
path.push object
path_arrays.push null
just_opened_id = null
var value = deserialize_class(static_type.strip_nullable)
path.pop
path_arrays.pop
return value
end
return object
end
if object isa MsgPackExt then
# First try the custom extensions
var custom = deserialize_ext(object, static_type)
if custom == null then
# No custom, go for deser standard references
if object.typ == ext_typ_ref then
# Reference to an object
var id = object.data.to_i
if not cache.has_id(id) then
errors.add new Error("Deserialization Error: object reference id unknown.")
return object
end
return cache.object_for(id)
else if object.typ == ext_typ_char then
# Char
return object.data.to_s.first
else if object.typ == ext_typ_byte then
# Byte
return object.data.first
end
end
end
if object isa String and object.length == 1 and static_type == "Char" then
# Char serialized as a string
return object.chars.first
end
if object isa Int and static_type == "Byte" then
# Byte serialized as an integer
return object.to_b
end
return object
end
redef fun deserialize(static_type)
do
errors.clear
var root = stream.read_msgpack
return convert_object(root, static_type)
end
# Hook to customize the deserialization of MessagePack extensions
#
# Redefine this method in subclasses to return custom Nit objects from
# an application specific extension.
#
# This method is invoked before dealing with the extensions used by the
# Nit serialization metadata [0x40..0x43]. In general, you should ignore
# them by returning `null`, but they can also be intercepted to comply to
# a format from a remote server.
protected fun deserialize_ext(ext: MsgPackExt, static_type: nullable String): nullable Object
do
return null
end
end
redef class SimpleCollection[E]
redef init from_deserializer(v)
do
super
if v isa MsgPackDeserializer then
v.notify_of_creation self
init
var open_array = v.path_arrays.last
var msgpack_items = null
if open_array != null then msgpack_items = open_array.last
if not msgpack_items isa Array[nullable Serializable] then
v.errors.add new Error("Deserialization Error: no items in source of `{class_name}`")
return
end
# Name of the dynamic name of E
var items_type_name = (new GetName[E]).to_s
# Fill array
for o in msgpack_items do
var obj = v.convert_object(o, items_type_name)
if obj isa E then
add obj
else v.errors.add new AttributeTypeError(self, "items", obj, items_type_name)
end
end
end
end
redef class Map[K, V]
redef init from_deserializer(v)
do
super
if v isa MsgPackDeserializer then
v.notify_of_creation self
init
var open_object = v.path_arrays.last
var msgpack_items
if open_object != null then
# Metadata available
msgpack_items = open_object.last
else
msgpack_items = v.path.last
end
if not msgpack_items isa Map[nullable Object, nullable Object] then
v.errors.add new Error("Deserialization Error: no key/values in source of `{class_name}`")
return
end
var keys_type_name = (new GetName[K]).to_s
var values_type_name = (new GetName[V]).to_s
for key_src, value_src in msgpack_items do
var key = v.convert_object(key_src, keys_type_name)
if not key isa K then
v.errors.add new AttributeTypeError(self, "keys", key, keys_type_name)
continue
end
var value = v.convert_object(value_src, values_type_name)
if not value isa V then
v.errors.add new AttributeTypeError(self, "values", value, values_type_name)
continue
end
self[key] = value
end
end
end
end
lib/msgpack/serialization_read.nit:15,1--410,3