layout_builders: Introduce TypingHasher (for future refactoring)

Signed-off-by: Alexandre Terrasa <alexandre@moz-code.org>

diff --git a/src/layout_builders.nit b/src/layout_builders.nit
index eb1ba32..105c52c 100644 (file)
--- a/src/layout_builders.nit
+++ b/src/layout_builders.nit
@@ -71,94 +71,15 @@ class CLTypingLayoutBuilder[E: Object]
        redef fun build_layout(elements) do return colorer.build_layout(elements)
 end
 
-# Layout builder for MType using Perfect Hashing (PH)
-class PHTypeLayoutBuilder
-       super TypingLayoutBuilder[MType]
-
-       redef type LAYOUT: PHLayout[MType, MType]
-
-       private var hasher: PerfectHasher[MType, MType]
-       private var mmodule: MModule
-
-       init(mmodule: MModule, operator: PHOperator) do
-               self.mmodule = mmodule
-               self.hasher = new PerfectHasher[MType, MType](operator)
-       end
-
-       private fun build_conflicts(mtypes: Set[MType]): Map[MType, Set[MType]] do
-               var conflicts = new HashMap[MType, Set[MType]]
-               for mtype in mtypes do
-                       var supers = self.mmodule.super_mtypes(mtype, mtypes)
-                       supers.add(mtype)
-                       conflicts[mtype] = supers
-               end
-               return conflicts
-       end
-
-       # Compute mtypes ids and position using BM
-       redef fun build_layout(mtypes) do
-               var result = new PHLayout[MType, MType]
-               var conflicts = build_conflicts(mtypes)
-               result.ids = self.compute_ids(mtypes)
-               result.masks = self.hasher.compute_masks(conflicts, result.ids)
-               result.hashes = self.hasher.compute_hashes(conflicts, result.ids, result.masks)
-               return result
-       end
-
-       # Ids start from 1 instead of 0
-       private fun compute_ids(mtypes: Set[MType]): Map[MType, Int] do
-               var ids = new HashMap[MType, Int]
-               var lin = self.mmodule.reverse_linearize_mtypes(mtypes)
-               for mtype in lin do
-                       ids[mtype] = ids.length + 1
-               end
-               return ids
-       end
-end
-
-# Layout builder for MClass using Perfect Hashing (PH)
-class PHClassLayoutBuilder
-       super TypingLayoutBuilder[MClass]
-
-       redef type LAYOUT: PHLayout[MClass, MClass]
+# Typing Layout builder using Perfect Hashing (PH)
+class PHTypingLayoutBuilder[E: Object]
+       super TypingLayoutBuilder[E]
 
-       private var hasher: PerfectHasher[MClass, MClass]
-       private var mmodule: MModule
+       private var hasher: TypingHasher[E]
 
-       init(mmodule: MModule, operator: PHOperator) do
-               self.mmodule = mmodule
-               self.hasher = new PerfectHasher[MClass, MClass](operator)
-       end
+       init(hasher: TypingHasher[E]) do self.hasher = hasher
 
-       private fun build_conflicts(mclasses: Set[MClass]): Map[MClass, Set[MClass]] do
-               var conflicts = new HashMap[MClass, Set[MClass]]
-               for mclass in mclasses do
-                       var supers = self.mmodule.super_mclasses(mclass)
-                       supers.add(mclass)
-                       conflicts[mclass] = supers
-               end
-               return conflicts
-       end
-
-       # Compute mclasses ids and position using BM
-       redef fun build_layout(mclasses) do
-               var result = new PHLayout[MClass, MClass]
-               var conflicts = build_conflicts(mclasses)
-               result.ids = self.compute_ids(mclasses)
-               result.masks = self.hasher.compute_masks(conflicts, result.ids)
-               result.hashes = self.hasher.compute_hashes(conflicts, result.ids, result.masks)
-               return result
-       end
-
-       # Ids start from 1 instead of 0
-       private fun compute_ids(mclasses: Set[MClass]): Map[MClass, Int] do
-               var ids = new HashMap[MClass, Int]
-               var lin = self.mmodule.reverse_linearize_mclasses(mclasses)
-               for mclass in lin do
-                       ids[mclass] = ids.length + 1
-               end
-               return ids
-       end
+       redef fun build_layout(elements) do return hasher.build_layout(elements)
 end
 
 abstract class PropertyLayoutBuilder[E: MProperty]
@@ -759,3 +680,74 @@ class PHAndOperator
        init do end
        redef fun op(mask, id) do return mask.bin_and(id)
 end
+
+class TypingHasher[E: Object]
+       super PerfectHasher[E, E]
+
+       var mmodule: MModule
+
+       init(operator: PHOperator, mmodule: MModule) do
+               super(operator)
+               self.mmodule = mmodule
+       end
+
+       fun build_layout(elements: Set[E]): PHLayout[E, E] do
+               var result = new PHLayout[E, E]
+               var conflicts = self.build_conflicts(elements)
+               result.ids = self.compute_ids(elements)
+               result.masks = self.compute_masks(conflicts, result.ids)
+               result.hashes = self.compute_hashes(conflicts, result.ids, result.masks)
+               return result
+       end
+
+       # Ids start from 1 instead of 0
+       private fun compute_ids(elements: Set[E]): Map[E, Int] do
+               var ids = new HashMap[E, Int]
+               var lin = self.reverse_linearize(elements)
+               for e in lin do
+                       ids[e] = ids.length + 1
+               end
+               return ids
+       end
+
+       private fun build_conflicts(elements: Set[E]): Map[E, Set[E]] do
+               var conflicts = new HashMap[E, Set[E]]
+               for e in elements do
+                       var supers = self.super_elements(e, elements)
+                       supers.add(e)
+                       conflicts[e] = supers
+               end
+               return conflicts
+       end
+
+       private fun super_elements(element: E, elements: Set[E]): Set[E] is abstract
+       private fun reverse_linearize(elements: Set[E]): Array[E] is abstract
+end
+
+class MTypeHasher
+       super TypingHasher[MType]
+
+       init(operator: PHOperator, mmodule: MModule) do super(operator, mmodule)
+
+       redef fun super_elements(element, elements) do
+               return self.mmodule.super_mtypes(element, elements)
+       end
+
+       redef fun reverse_linearize(elements) do
+               return self.mmodule.reverse_linearize_mtypes(elements)
+       end
+end
+
+class MClassHasher
+       super TypingHasher[MClass]
+
+       init(operator: PHOperator, mmodule: MModule) do super(operator, mmodule)
+
+       redef fun super_elements(element, elements) do
+               return self.mmodule.super_mclasses(element)
+       end
+
+       redef fun reverse_linearize(elements) do
+               return self.mmodule.reverse_linearize_mclasses(elements)
+       end
+end

diff --git a/src/separate_compiler.nit b/src/separate_compiler.nit
index 8b48676..474a27c 100644 (file)
--- a/src/separate_compiler.nit
+++ b/src/separate_compiler.nit
@@ -333,9 +333,9 @@ class SeparateCompiler
                if modelbuilder.toolcontext.opt_bm_typing.value then
                        layout_builder = new BMTypingLayoutBuilder[MType](new MTypeBMizer(self.mainmodule))
                else if modelbuilder.toolcontext.opt_phmod_typing.value then
-                       layout_builder = new PHTypeLayoutBuilder(self.mainmodule, new PHModOperator)
+                       layout_builder = new PHTypingLayoutBuilder[MType](new MTypeHasher(new PHModOperator, self.mainmodule))
                else if modelbuilder.toolcontext.opt_phand_typing.value then
-                       layout_builder = new PHTypeLayoutBuilder(self.mainmodule, new PHAndOperator)
+                       layout_builder = new PHTypingLayoutBuilder[MType](new MTypeHasher(new PHAndOperator, self.mainmodule))
                else
                        layout_builder = new CLTypingLayoutBuilder[MType](new MTypeColorer(self.mainmodule))
                end

diff --git a/src/separate_erasure_compiler.nit b/src/separate_erasure_compiler.nit
index 7e85d17..4590348 100644 (file)
--- a/src/separate_erasure_compiler.nit
+++ b/src/separate_erasure_compiler.nit
@@ -77,9 +77,9 @@ class SeparateErasureCompiler
 
                var layout_builder: TypingLayoutBuilder[MClass]
                if modelbuilder.toolcontext.opt_phmod_typing.value then
-                       layout_builder = new PHClassLayoutBuilder(mainmodule, new PHModOperator)
+                       layout_builder = new PHTypingLayoutBuilder[MClass](new MClassHasher(new PHModOperator, mainmodule))
                else if modelbuilder.toolcontext.opt_phand_typing.value then
-                       layout_builder = new PHClassLayoutBuilder(mainmodule, new PHAndOperator)
+                       layout_builder = new PHTypingLayoutBuilder[MClass](new MClassHasher(new PHAndOperator, mainmodule))
                else if modelbuilder.toolcontext.opt_bm_typing.value then
                        layout_builder = new BMTypingLayoutBuilder[MClass](new MClassBMizer(mainmodule))
                else