layout_builders: Introduce BMizer class (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 3ead351..eb1ba32 100644 (file)
--- a/src/layout_builders.nit
+++ b/src/layout_builders.nit
@@ -49,33 +49,15 @@ abstract class TypingLayoutBuilder[E: Object]
        fun build_layout(elements: Set[E]): LAYOUT is abstract
 end
 
-# Layout builder for MType using Binary Matrix (BM)
-class BMTypeLayoutBuilder
-       super TypingLayoutBuilder[MType]
+# Typing Layout builder using binary matrix (BM)
+class BMTypingLayoutBuilder[E: Object]
+       super TypingLayoutBuilder[E]
 
-       private var mmodule: MModule
+       private var bmizer: TypingBMizer[E]
 
-       init(mmodule: MModule) do
-               self.mmodule = mmodule
-       end
+       init(bmizer: TypingBMizer[E]) do self.bmizer = bmizer
 
-       # Compute mtypes ids and position using BM
-       redef fun build_layout(mtypes) do
-               var result = new Layout[MType]
-               result.ids = self.compute_ids(mtypes)
-               result.pos = result.ids
-               return result
-       end
-
-       # Give each MType a unic id using a descending linearization of the `mtypes` set
-       private fun compute_ids(elements: Set[MType]): Map[MType, Int] do
-               var ids = new HashMap[MType, Int]
-               var lin = self.mmodule.reverse_linearize_mtypes(elements)
-               for element in lin do
-                       ids[element] = ids.length
-               end
-               return ids
-       end
+       redef fun build_layout(elements) do return bmizer.build_layout(elements)
 end
 
 # Typing Layout builder using Coloring (CL)
@@ -134,35 +116,6 @@ class PHTypeLayoutBuilder
        end
 end
 
-# Layout builder for MClass using Binary Matrix (BM)
-class BMClassLayoutBuilder
-       super TypingLayoutBuilder[MClass]
-
-       private var mmodule: MModule
-
-       init(mmodule: MModule) do
-               self.mmodule = mmodule
-       end
-
-       # Compute mclasses ids and position using BM
-       redef fun build_layout(mclasses) do
-               var result = new Layout[MClass]
-               result.ids = self.compute_ids(mclasses)
-               result.pos = result.ids
-               return result
-       end
-
-       # Give each MClass a unic id using a descending linearization
-       private fun compute_ids(elements: Set[MClass]): Map[MClass, Int] do
-               var ids = new HashMap[MClass, Int]
-               var lin = self.mmodule.reverse_linearize_mclasses(elements)
-               for element in lin do
-                       ids[element] = ids.length
-               end
-               return ids
-       end
-end
-
 # Layout builder for MClass using Perfect Hashing (PH)
 class PHClassLayoutBuilder
        super TypingLayoutBuilder[MClass]
@@ -328,6 +281,52 @@ class PHResolutionLayoutBuilder
        end
 end
 
+# Matrice computers
+
+abstract class TypingBMizer[E: Object]
+
+       var mmodule: MModule
+
+       init(mmodule: MModule) do
+               self.mmodule = mmodule
+       end
+
+       # Compute mtypes ids and position using BM
+       fun build_layout(elements: Set[E]): Layout[E] do
+               var result = new Layout[E]
+               var ids = new HashMap[E, Int]
+               var lin = self.reverse_linearize(elements)
+               for element in lin do
+                       ids[element] = ids.length
+               end
+               result.ids = ids
+               result.pos = ids
+               return result
+       end
+
+       private fun reverse_linearize(elements: Set[E]): Array[E] is abstract
+end
+
+class MTypeBMizer
+       super TypingBMizer[MType]
+
+       init(mmodule: MModule) do super(mmodule)
+
+       redef fun reverse_linearize(elements) do
+               return self.mmodule.reverse_linearize_mtypes(elements)
+       end
+end
+
+class MClassBMizer
+       super TypingBMizer[MClass]
+
+       init(mmodule: MModule) do super(mmodule)
+
+       redef fun reverse_linearize(elements) do
+               return self.mmodule.reverse_linearize_mclasses(elements)
+       end
+end
+
 # Colorers
 
 abstract class TypingColorer[E: Object]

diff --git a/src/separate_compiler.nit b/src/separate_compiler.nit
index 90f6ae4..8b48676 100644 (file)
--- a/src/separate_compiler.nit
+++ b/src/separate_compiler.nit
@@ -331,7 +331,7 @@ class SeparateCompiler
                # Typing Layout
                var layout_builder: TypingLayoutBuilder[MType]
                if modelbuilder.toolcontext.opt_bm_typing.value then
-                       layout_builder = new BMTypeLayoutBuilder(self.mainmodule)
+                       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)
                else if modelbuilder.toolcontext.opt_phand_typing.value then

diff --git a/src/separate_erasure_compiler.nit b/src/separate_erasure_compiler.nit
index 6ad3ec8..7e85d17 100644 (file)
--- a/src/separate_erasure_compiler.nit
+++ b/src/separate_erasure_compiler.nit
@@ -81,7 +81,7 @@ class SeparateErasureCompiler
                else if modelbuilder.toolcontext.opt_phand_typing.value then
                        layout_builder = new PHClassLayoutBuilder(mainmodule, new PHAndOperator)
                else if modelbuilder.toolcontext.opt_bm_typing.value then
-                       layout_builder = new BMClassLayoutBuilder(mainmodule)
+                       layout_builder = new BMTypingLayoutBuilder[MClass](new MClassBMizer(mainmodule))
                else
                        layout_builder = new CLTypingLayoutBuilder[MClass](new MClassColorer(mainmodule))
                end