Instances of this class can be passed to `Serializer::serialize`

# Instances of this class can be passed to `Serializer::serialize`
interface Serializable
	# Serialize `self` to `serializer`
	#
	# This is a shortcut to `Serializer::serialize`.
	fun serialize_to(serializer: Serializer) do serializer.serialize(self)

	# Actual serialization of `self` to `serializer`
	#
	# This writes the full data of `self` to `serializer`.
	#
	# This method can be redefined in sub classes and refinements.
	# It should use `Serializer::serialize_attribute` to to register real or
	# logical attributes.
	#
	# Any refinement should have its equivalent refinement of
	# `Deserializer::deserialize_class` to support this custom deserialization.
	fun core_serialize_to(serializer: Serializer) do end

	# Accept references or force direct serialization (using `serialize_to`)
	#
	# The subclass change the default behavior, which will accept references,
	# to force to always serialize copies of `self`.
	private fun serialize_to_or_delay(v: Serializer) do v.serialize_reference(self)

	# Create an instance of this class from the `deserializer`
	#
	# This constructor is refined by subclasses to correctly build their instances.
	init from_deserializer(deserializer: Deserializer) is nosuper do end
end

lib/serialization/serialization_core.nit:219,1--248,3

json :: serialization_write $ Serializable

redef class Serializable

	# Serialize `self` to JSON
	#
	# Set `plain = true` to generate standard JSON, without deserialization metadata.
	# Use this option if the generated JSON will be read by other programs or humans.
	# Use the default, `plain = false`, if the JSON is to be deserialized by a Nit program.
	#
	# Set `pretty = true` to generate pretty JSON for human eyes.
	# Use the default, `pretty = false`, to generate minified JSON.
	#
	# This method should not be refined by subclasses,
	# instead `accept_json_serializer` can customize the serialization of an object.
	#
	# See: `JsonSerializer`
	fun serialize_to_json(plain, pretty: nullable Bool): String
	do
		var stream = new StringWriter
		var serializer = new JsonSerializer(stream)
		serializer.plain_json = plain or else false
		serializer.pretty_json = pretty or else false
		serializer.serialize self
		stream.close
		return stream.to_s
	end

	# Serialize `self` to plain JSON
	#
	# Compatibility alias for `serialize_to_json(plain=true)`.
	fun to_json: String do return serialize_to_json(plain=true)

	# Serialize `self` to plain pretty JSON
	#
	# Compatibility alias for `serialize_to_json(plain=true, pretty=true)`.
	fun to_pretty_json: String do return serialize_to_json(plain=true, pretty=true)

	# Refinable service to customize the serialization of this class to JSON
	#
	# This method can be refined to customize the serialization by either
	# writing pure JSON directly on the stream `v.stream` or
	# by using other services of `JsonSerializer`.
	#
	# Most of the time, it is preferable to refine the method `core_serialize_to`
	# which is used by all the serialization engines, not just JSON.
	protected fun accept_json_serializer(v: JsonSerializer)
	do
		v.stream.write "\{"
		v.indent_level += 1
		if not v.plain_json then
			var id = v.cache.new_id_for(self)
			v.new_line_and_indent
			v.stream.write "\"__kind\": \"obj\", \"__id\": "
			v.stream.write id.to_s
			v.stream.write ", \"__class\": \""
			v.stream.write class_name
			v.stream.write "\""
		end
		v.serialize_core(self)

		v.indent_level -= 1
		v.new_line_and_indent
		v.stream.write "\}"
	end
end

lib/json/serialization_write.nit:199,1--262,3

serialization :: inspect $ Serializable

redef class Serializable

	# Improve the default inspection reading serializable attributes
	#
	# Simple immutable data are inspected as they would be written in Nit code.
	#
	# ~~~
	# assert 123.inspect == "123"
	# assert 1.5.inspect == "1.5"
	# assert 0xa1u8.inspect == "0xa1u8"
	# assert 'c'.inspect == "'c'"
	# assert "asdf\n".inspect == "\"asdf\\n\""
	# ~~~
	#
	# Inspections of mutable serializable objects show their dynamic type,
	# their `object_id` and their first level attributes. When testing,
	# the `object_id` is replaced by an id unique to each call to `inspect`.
	#
	# ~~~
	# class MyClass
	#     serialize
	#
	#     var i: Int
	#     var o: nullable Object
	# end
	#
	# var class_with_null = new MyClass(123)
	# assert class_with_null.to_s == class_with_null.inspect
	# assert class_with_null.to_s == "<MyClass#0 i:123, o:null>"
	#
	# var class_with_other = new MyClass(456, class_with_null)
	# assert class_with_other.to_s == "<MyClass#0 i:456, o:<MyClass#1>>"
	#
	# var class_with_cycle = new MyClass(789)
	# class_with_cycle.o = class_with_cycle
	# assert class_with_cycle.to_s == "<MyClass#0 i:789, o:<MyClass#0>>"
	# ~~~
	#
	# Items of collections are flattened and appended to the output.
	#
	# ~~~
	# assert [1, 2, 3].inspect == "<Array[Int]#0 [1, 2, 3]>"
	#
	# var set = new HashSet[Object].from([1, 1.5, "two": Object])
	# assert set.inspect == """<HashSet[Object]#0 [1, 1.5, "two"]>"""
	#
	# var map = new Map[Int, String]
	# map[1] = "one"
	# map[2] = "two"
	# assert map.inspect == """<HashMap[Int, String]#0 {1:"one", 2:"two"}>"""
	# ~~~
	#
	# Inspections producing over 80 characters are cut short.
	#
	# ~~~
	# var long_class = new MyClass(123456789, "Some " + "very "*8 + "long string")
	# assert long_class.to_s == "<MyClass#0 i:123456789, o:\"Some very very very very very very very very long s…>"
	# ~~~
	redef fun inspect
	do
		var stream = new StringWriter
		var serializer = new InspectSerializer(stream)
		serializer.serialize self
		stream.close
		var str = stream.to_s

		# Cut long inspects
		var max_length = 80
		if str.length > max_length then
			str = str.substring(0, max_length-2) + "…>"
		end

		return str
	end

	private fun accept_inspect_serializer(v: InspectSerializer)
	do
		v.stream.write "<"

		v.stream.write class_name
		v.stream.write "#"

		var id = object_id
		if inspect_testing then id = v.cache.new_id_for(self)
		v.stream.write id.to_s

		accept_inspect_serializer_core v

		v.stream.write ">"
	end

	private fun accept_inspect_serializer_core(v: InspectSerializer)
	do v.serialize_core(self)
end

lib/serialization/inspect.nit:96,1--189,3

msgpack :: serialization_write $ Serializable

redef class Serializable

	# Serialize `self` to MessagePack bytes
	#
	# Set `plain = true` to generate standard MessagePack, without deserialization metadata.
	# Use this option if the generated MessagePack will be read by non-Nit programs.
	# Use the default, `plain = false`, if the MessagePack bytes are to be deserialized by a Nit program.
	fun serialize_msgpack(plain: nullable Bool): Bytes
	do
		var stream = new BytesWriter
		stream.serialize_msgpack(self, plain)
		stream.close
		return stream.bytes
	end

	# Hook to customize the serialization of this class to MessagePack
	#
	# This method can be refined to customize the serialization by either
	# writing pure JSON directly on the stream `v.stream` or
	# by using other services of `MsgPackSerializer`.
	#
	# Most of the time, it is better to refine the method `core_serialize_to`
	# which is used by all the serialization engines, not just MessagePack.
	protected fun accept_msgpack_serializer(v: MsgPackSerializer)
	do

		# Count the number of attributes
		var attribute_counter = new AttributeCounter
		accept_msgpack_attribute_counter attribute_counter
		var n_attributes = attribute_counter.count

		if not v.plain_msgpack then

			var n_meta_items = 2
			if n_attributes > 0 then n_meta_items += 1
			n_meta_items += msgpack_extra_array_items # obj+id, class_name, attributes

			# Metadata
			var id = v.cache.new_id_for(self)
			v.stream.write_msgpack_array n_meta_items
			v.stream.write_msgpack_ext(v.ext_typ_obj, id.to_bytes)
			v.serialize_meta_string class_name

			if n_attributes > 0 then v.stream.write_msgpack_map n_attributes
		else
			v.stream.write_msgpack_map n_attributes
		end

		v.serialize_core self
	end

	# Hook to customize the behavior of the `AttributeCounter`
	#
	# By default, this method makes `v` visits all serializable attributes.
	protected fun accept_msgpack_attribute_counter(v: AttributeCounter)
	do
		v.serialize_core self
	end

	# Hook to request a larger than usual metadata array
	#
	# Use by `SimpleCollection` and `Map` to append the items after
	# the metadata and attributes.
	protected fun msgpack_extra_array_items: Int do return 0
end

lib/msgpack/serialization_write.nit:174,1--238,3

android :: bundle $ Serializable

redef class Serializable
	# Called by `Bundle::[]=` to dynamically choose the appropriate method according
	# to the value type to store
	# Non-primitive Object (`String` excluded) will be stored as a serialized json `String`
	# Refine your class to customize this method behaviour
	protected fun add_to_bundle(bundle: NativeBundle, key: JavaString)
	do
		sys.jni_env.push_local_frame(1)
		var serialized_string = new StringWriter
		var serializer = new JsonSerializer(serialized_string)
		serializer.serialize(self)

		bundle.put_string(key, serialized_string.to_s.to_java_string)
	end
end

lib/android/bundle/bundle.nit:670,1--684,3

interface Serializable

Summary

Instances of this class can be passed to Serializer::serialize

Introduced properties

accept_inspect_serializer

accept_inspect_serializer_core

accept_json_serializer

accept_msgpack_attribute_counter

accept_msgpack_serializer

add_to_bundle

core_serialize_to

defaultinit

from_deserializer

msgpack_extra_array_items

serialize_msgpack

serialize_to

serialize_to_json

serialize_to_or_delay

to_json

to_pretty_json

Redefined properties

SELF

inspect

Instances of this class can be passed to Serializer::serialize

Introduced properties

private fun accept_inspect_serializer(v: InspectSerializer)

private fun accept_inspect_serializer_core(v: InspectSerializer)

protected fun accept_json_serializer(v: JsonSerializer)

protected fun accept_msgpack_attribute_counter(v: AttributeCounter)

protected fun accept_msgpack_serializer(v: MsgPackSerializer)

protected fun add_to_bundle(bundle: NativeBundle, key: JavaString)

fun core_serialize_to(serializer: Serializer)

init defaultinit

init from_deserializer(deserializer: Deserializer)

protected fun msgpack_extra_array_items: Int

fun serialize_msgpack(plain: nullable Bool): Bytes

fun serialize_to(serializer: Serializer)

fun serialize_to_json(plain: nullable Bool, pretty: nullable Bool): String

private fun serialize_to_or_delay(v: Serializer)

fun to_json: String

fun to_pretty_json: String

Redefined properties

redef type SELF: Serializable

redef fun inspect: String

Summary

All properties

!=

==

CLASS

SELF

accept_inspect_serializer

accept_inspect_serializer_core

accept_json_serializer

accept_msgpack_attribute_counter

accept_msgpack_serializer

add_to_bundle

class_factory

class_name

core_serialize_to

defaultinit

defaultinit

from_deserializer

get_class

hash

init

inspect

inspect_head

is_same_instance

is_same_serialized

is_same_type

msgpack_extra_array_items

native_class_name

object_id

output

output_class_name

serialization_hash

serialize_msgpack

serialize_to

serialize_to_json

serialize_to_or_delay

Instances of this class can be passed to `Serializer::serialize`

Instances of this class can be passed to `Serializer::serialize`