+++ /dev/null
-# This file is part of NIT ( http://www.nitlanguage.org ).
-#
-# Copyright 2014 Alexis Laferrière <alexis.laf@xymus.net>
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# Handles serialization and deserialization of objects to/from Json.
-module json_serialization
-
-import serialization
-import json::static
-
-# Serializer of Nit objects to Json string.
-class JsonSerializer
- super Serializer
-
- # Target writing stream
- var stream: Writer
-
- redef fun serialize(object)
- do
- if object == null then
- stream.write "null"
- else object.serialize_to_json(self)
- end
-
- redef fun serialize_attribute(name, value)
- do
- stream.write ", \"{name}\": "
- super
- end
-
- redef fun serialize_reference(object)
- do
- if refs_map.has_key(object) then
- # if already serialized, add local reference
- var id = ref_id_for(object)
- stream.write "\{\"__kind\": \"ref\", \"__id\": {id}\}"
- else
- # serialize here
- serialize object
- end
- end
-
- # Map of references to already serialized objects.
- private var refs_map = new StrictHashMap[Serializable,Int]
-
- # Get the internal serialized reference for this `object`.
- private fun ref_id_for(object: Serializable): Int
- do
- if refs_map.has_key(object) then
- return refs_map[object]
- else
- var id = refs_map.length
- refs_map[object] = id
- return id
- end
- end
-end
-
-# Deserializer from a Json string.
-class JsonDeserializer
- super Deserializer
-
- # Json text to deserialize from.
- private var text: Text
-
- # Root json object parsed from input text.
- var root: nullable Jsonable is noinit
-
- # Depth-first path in the serialized object tree.
- var path = new Array[JsonObject]
-
- # Map of references to already deserialized objects.
- private var id_to_object = new StrictHashMap[Int, Object]
-
- # Last encountered object reference id.
- #
- # See `id_to_object`.
- var just_opened_id: nullable Int = null
-
- init do
- var root = text.parse_json
- if root isa JsonObject then path.add(root)
- self.root = root
- end
-
- redef fun deserialize_attribute(name)
- do
- assert not path.is_empty
- var current = path.last
-
- assert current.keys.has(name)
- var value = current[name]
-
- return convert_object(value)
- end
-
- # This may be called multiple times by the same object from constructors
- # in different nclassdef
- redef fun notify_of_creation(new_object)
- do
- var id = just_opened_id
- if id == null then return # Register `new_object` only once
- id_to_object[id] = new_object
- end
-
- # Convert from simple Json object to Nit object
- private fun convert_object(object: nullable Object): nullable Object
- do
- if object isa JsonObject then
- assert object.keys.has("__kind")
- var kind = object["__kind"]
-
- # ref?
- if kind == "ref" then
- assert object.keys.has("__id")
- var id = object["__id"]
- assert id isa Int
-
- assert id_to_object.has_key(id)
- return id_to_object[id]
- end
-
- # obj?
- if kind == "obj" then
- assert object.keys.has("__id")
- var id = object["__id"]
- assert id isa Int
-
- assert object.keys.has("__class")
- var class_name = object["__class"]
- assert class_name isa String
-
- assert not id_to_object.has_key(id) else print "Error: Object with id '{id}' of {class_name} is deserialized twice."
-
- # advance on path
- path.push object
-
- just_opened_id = id
- var value = deserialize_class(class_name)
- just_opened_id = null
-
- # revert on path
- path.pop
-
- return value
- end
-
- # char?
- if kind == "char" then
- assert object.keys.has("__val")
- var val = object["__val"]
- assert val isa String
-
- if val.length != 1 then print "Error: expected a single char when deserializing '{val}'."
-
- return val.chars.first
- end
-
- print "Malformed Json string: unexpected Json Object kind '{kind or else "null"}'"
- abort
- end
-
- if object isa Array[nullable Object] then
- # special case, isa Array[nullable Serializable]
- var array = new Array[nullable Serializable]
- for e in object do array.add e.as(nullable Serializable)
- return array
- end
-
- return object
- end
-
- redef fun deserialize do return convert_object(root)
-end
-
-redef class Serializable
- private fun serialize_to_json(v: JsonSerializer)
- do
- var id = v.ref_id_for(self)
- v.stream.write "\{\"__kind\": \"obj\", \"__id\": {id}, \"__class\": \"{class_name}\""
- core_serialize_to(v)
- v.stream.write "\}"
- end
-end
-
-redef class Int
- redef fun serialize_to_json(v) do v.stream.write(to_s)
-end
-
-redef class Float
- redef fun serialize_to_json(v) do v.stream.write(to_s)
-end
-
-redef class Bool
- redef fun serialize_to_json(v) do v.stream.write(to_s)
-end
-
-redef class Char
- redef fun serialize_to_json(v) do v.stream.write "\{\"__kind\": \"char\", \"__val\": {to_s.to_json}\}"
-end
-
-redef class String
- redef fun serialize_to_json(v) do v.stream.write(to_json)
-end
-
-redef class NativeString
- redef fun serialize_to_json(v) do to_s.serialize_to_json(v)
-end
-
-redef class Collection[E]
- # Utility to serialize a normal Json array
- private fun serialize_to_pure_json(v: JsonSerializer)
- do
- v.stream.write "["
- var is_first = true
- for e in self do
- if is_first then
- is_first = false
- else v.stream.write ", "
-
- if not v.try_to_serialize(e) then
- v.warn("element of type {e.class_name} is not serializable.")
- end
- end
- v.stream.write "]"
- end
-end
-
-redef class SimpleCollection[E]
- redef fun serialize_to_json(v)
- do
- # Register as pseudo object
- var id = v.ref_id_for(self)
- v.stream.write """{"__kind": "obj", "__id": """
- v.stream.write id.to_s
- v.stream.write """, "__class": """"
- v.stream.write class_name
- v.stream.write """", "__length": """
- v.stream.write length.to_s
- v.stream.write """, "__items": """
- serialize_to_pure_json v
- v.stream.write "\}"
- end
-
- redef init from_deserializer(v: Deserializer)
- do
- if v isa JsonDeserializer then
- v.notify_of_creation self
- init
-
- var length = v.deserialize_attribute("__length").as(Int)
- var arr = v.path.last["__items"].as(SequenceRead[nullable Object])
- for i in length.times do
- var obj = v.convert_object(arr[i])
- self.add obj
- end
- end
- end
-end
-
-redef class Array[E]
- redef fun serialize_to_json(v)
- do
- if class_name == "Array[nullable Serializable]" then
- # Using class_name to get the exact type,
- # we do not want Array[Int] or anything else here.
-
- serialize_to_pure_json v
- else super
- end
-end
-
-redef class Map[K, V]
- redef fun serialize_to_json(v)
- do
- # Register as pseudo object
- var id = v.ref_id_for(self)
-
- v.stream.write """{"__kind": "obj", "__id": """
- v.stream.write id.to_s
- v.stream.write """, "__class": """"
- v.stream.write class_name
- v.stream.write """", "__length": """
- v.stream.write length.to_s
- v.stream.write """, "__keys": """
-
- keys.serialize_to_pure_json v
-
- v.stream.write """, "__values": """
- values.serialize_to_pure_json v
- v.stream.write "\}"
- end
-
- # Instantiate a new `Array` from its serialized representation.
- redef init from_deserializer(v: Deserializer)
- do
- init
-
- if v isa JsonDeserializer then
- v.notify_of_creation self
-
- var length = v.deserialize_attribute("__length").as(Int)
- var keys = v.path.last["__keys"].as(SequenceRead[nullable Object])
- var values = v.path.last["__values"].as(SequenceRead[nullable Object])
- for i in length.times do
- var key = v.convert_object(keys[i])
- var value = v.convert_object(values[i])
- self[key] = value
- end
- end
- end
-end
-
-# Maps instances to a value, uses `is_same_instance`
-#
-# Warning: This class does not implement all the services from `Map`.
-private class StrictHashMap[K, V]
- super Map[K, V]
-
- # private
- var map = new HashMap[K, Array[Couple[K, V]]]
-
- redef var length = 0
-
- redef fun is_empty do return length == 0
-
- # private
- fun node_at(key: K): nullable Couple[K, V]
- do
- if not map.keys.has(key) then return null
-
- var arr = map[key]
- for couple in arr do
- if couple.first.is_same_serialized(key) then
- return couple
- end
- end
-
- return null
- end
-
- redef fun [](key)
- do
- var node = node_at(key)
- assert node != null
- return node.second
- end
-
- redef fun []=(key, value)
- do
- var node = node_at(key)
- if node != null then
- node.second = value
- return
- end
-
- var arr
- if not map.keys.has(key) then
- arr = new Array[Couple[K, V]]
- map[key] = arr
- else arr = map[key]
-
- arr.add new Couple[K, V](key, value)
- self.length += 1
- end
-
- redef fun has_key(key) do return node_at(key) != null
-end
nitlanguage / nit.git / blobdiff