manual: CI check with nitunit

[nit.git] / lib / serialization / engine_tools.nit

diff --git a/lib/serialization/engine_tools.nit b/lib/serialization/engine_tools.nit
index 33d36b4..bd4b417 100644 (file)
--- a/lib/serialization/engine_tools.nit
+++ b/lib/serialization/engine_tools.nit
@@ -15,8 +15,8 @@
 # Advanced services for serialization engines
 module engine_tools
 
-import serialization
-intrude import standard::collection::hash_collection
+import serialization_core
+intrude import core::collection::hash_collection
 
 # Maps instances to a value, uses `is_same_serialized` and `serialization_hash`.
 class StrictHashMap[K, V]
@@ -36,6 +36,7 @@ class StrictHashMap[K, V]
                var c = _array[i]
                while c != null do
                        var ck = c._key
+                       assert ck != null
                        if ck.is_same_serialized(k) then
                                break
                        end
@@ -44,3 +45,53 @@ class StrictHashMap[K, V]
                return c
        end
 end
+
+redef interface Object
+       # Is `self` the same as `other` in a serialization context?
+       #
+       # Used to determine if an object has already been serialized.
+       fun is_same_serialized(other: nullable Object): Bool do return is_same_instance(other)
+
+       # Hash value use for serialization
+       #
+       # Used in combination with `is_same_serialized`. If two objects are the same
+       # in a serialization context, they must have the same `serialization_hash`.
+       fun serialization_hash: Int do return object_id
+end
+
+redef class String
+       redef fun serialization_hash do return hash
+       redef fun is_same_serialized(o) do return self == o
+end
+
+redef class Text
+
+       # Strip the `nullable` prefix from the type name `self`
+       #
+       # ~~~
+       # assert "String".strip_nullable == "String"
+       # assert "nullable Array[Int]".strip_nullable == "Array[Int]"
+       # assert "Map[Set[String], Set[Int]]".strip_nullable == "Map[Set[String], Set[Int]]"
+       # ~~~
+       fun strip_nullable: Text
+       do
+               var prefix = "nullable "
+               return if has_prefix(prefix) then substring_from(prefix.length) else self
+       end
+
+       # Strip the `nullable` prefix and the params from the type name `self`
+       #
+       # ~~~
+       # assert "String".strip_nullable_and_params == "String"
+       # assert "nullable Array[Int]".strip_nullable_and_params == "Array"
+       # assert "Map[Set[String], Set[Int]]".strip_nullable_and_params == "Map"
+       # ~~~
+       fun strip_nullable_and_params: Text
+       do
+               var class_name = strip_nullable
+
+               var bracket_index = class_name.index_of('[')
+               if bracket_index == -1 then return class_name
+               return class_name.substring(0, bracket_index)
+       end
+end