From: Alexandre Terrasa <alexandre@moz-code.org>
Date: Thu, 7 Feb 2013 21:46:31 +0000 (-0500)
Subject: nitg-s: merged TypeLayoutBuilder and ClassLayoutBuilder into generic TypingLayoutBuilder
X-Git-Tag: v0.6~77^2~51
X-Git-Url: http://nitlanguage.org

nitg-s: merged TypeLayoutBuilder and ClassLayoutBuilder into generic TypingLayoutBuilder

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

diff --git a/src/coloring.nit b/src/coloring.nit
index eb0fd81..0aa900f 100644
--- a/src/coloring.nit
+++ b/src/coloring.nit
@@ -36,30 +36,32 @@ end
 
 # Builders
 
-abstract class TypeLayoutBuilder
+abstract class TypingLayoutBuilder[E]
 
-	type LAYOUT: TypingLayout[MType]
+	type LAYOUT: TypingLayout[E]
 
 	private var mmodule: MModule
 	init(mmodule: MModule) do self.mmodule = mmodule
 
-	# Compute mtypes ids and position
-	fun build_layout(mtypes: Set[MType]): LAYOUT is abstract
+	# Compute elements ids and position
+	fun build_layout(elements: Set[E]): LAYOUT is abstract
 
 	# Give each MType a unic id using a descending linearization of the `mtypes` set
-	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
+	private fun compute_ids(elements: Set[E]): Map[E, Int] do
+		var ids = new HashMap[E, Int]
+		var lin = self.reverse_linearize(elements)
+		for element in lin do
+			ids[element] = ids.length
 		end
 		return ids
 	end
+
+	private fun reverse_linearize(elements: Set[E]): Array[E] is abstract
 end
 
 # Layout builder for MType using Binary Matrix (BM)
 class BMTypeLayoutBuilder
-	super TypeLayoutBuilder
+	super TypingLayoutBuilder[MType]
 
 	init(mmodule: MModule) do super
 
@@ -70,11 +72,13 @@ class BMTypeLayoutBuilder
 		result.pos = result.ids
 		return result
 	end
+
+	redef fun reverse_linearize(elements) do return self.mmodule.reverse_linearize_mtypes(elements)
 end
 
 # Layout builder for MType using Coloring (CL)
 class CLTypeLayoutBuilder
-	super TypeLayoutBuilder
+	super TypingLayoutBuilder[MType]
 
 	private var colorer: MTypeColorer
 
@@ -90,11 +94,13 @@ class CLTypeLayoutBuilder
 		result.pos = self.colorer.colorize(mtypes)
 		return result
 	end
+
+	redef fun reverse_linearize(elements) do return self.mmodule.reverse_linearize_mtypes(elements)
 end
 
 # Layout builder for MType using Perfect Hashing (PH)
 class PHTypeLayoutBuilder
-	super TypeLayoutBuilder
+	super TypingLayoutBuilder[MType]
 
 	redef type LAYOUT: PHTypingLayout[MType]
 
@@ -123,32 +129,13 @@ class PHTypeLayoutBuilder
 		end
 		return ids
 	end
-end
-
-abstract class ClassLayoutBuilder
-
-	type LAYOUT: TypingLayout[MClass]
-
-	private var mmodule: MModule
-	init(mmodule: MModule) do self.mmodule = mmodule
-
-	# Compute mclasses ids and position
-	fun build_layout(mclasses: Set[MClass]): LAYOUT is abstract
 
-	# Give each MClass a unic id using a descending linearization of the `mclasses` set
-	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
-		end
-		return ids
-	end
+	redef fun reverse_linearize(elements) do return self.mmodule.reverse_linearize_mtypes(elements)
 end
 
 # Layout builder for MClass using Binary Matrix (BM)
 class BMClassLayoutBuilder
-	super ClassLayoutBuilder
+	super TypingLayoutBuilder[MClass]
 
 	init(mmodule: MModule) do super
 
@@ -159,11 +146,13 @@ class BMClassLayoutBuilder
 		result.pos = result.ids
 		return result
 	end
+
+	redef fun reverse_linearize(elements) do return self.mmodule.reverse_linearize_mclasses(elements)
 end
 
 # Layout builder for MClass using Coloring (CL)
 class CLClassLayoutBuilder
-	super ClassLayoutBuilder
+	super TypingLayoutBuilder[MClass]
 
 	private var colorer: MClassColorer
 
@@ -179,11 +168,13 @@ class CLClassLayoutBuilder
 		result.pos = self.colorer.colorize(mclasses)
 		return result
 	end
+
+	redef fun reverse_linearize(elements) do return self.mmodule.reverse_linearize_mclasses(elements)
 end
 
 # Layout builder for MClass using Perfect Hashing (PH)
 class PHClassLayoutBuilder
-	super ClassLayoutBuilder
+	super TypingLayoutBuilder[MClass]
 
 	redef type LAYOUT: PHTypingLayout[MClass]
 
@@ -212,6 +203,8 @@ class PHClassLayoutBuilder
 		end
 		return ids
 	end
+
+	redef fun reverse_linearize(elements) do return self.mmodule.reverse_linearize_mclasses(elements)
 end
 
 # Colorers
diff --git a/src/separate_compiler.nit b/src/separate_compiler.nit
index 435066e..a727e45 100644
--- a/src/separate_compiler.nit
+++ b/src/separate_compiler.nit
@@ -107,7 +107,7 @@ class SeparateCompiler
 	private var undead_types: Set[MType] = new HashSet[MType]
 	private var partial_types: Set[MType] = new HashSet[MType]
 
-	private var type_layout_builder: TypeLayoutBuilder
+	private var type_layout_builder: TypingLayoutBuilder[MType]
 	private var type_layout: nullable TypingLayout[MType]
 	private var type_tables: nullable Map[MType, Array[nullable MType]] = null
 
diff --git a/src/separate_erasure_compiler.nit b/src/separate_erasure_compiler.nit
index 5c2ed4d..3cce9f9 100644
--- a/src/separate_erasure_compiler.nit
+++ b/src/separate_erasure_compiler.nit
@@ -75,7 +75,7 @@ class SeparateErasureCompiler
 
 		var mclasses = new HashSet[MClass].from(mmbuilder.model.mclasses)
 
-		var layout_builder: ClassLayoutBuilder
+		var layout_builder: TypingLayoutBuilder[MClass]
 		if modelbuilder.toolcontext.opt_phmod_typing.value then
 			layout_builder = new PHClassLayoutBuilder(mainmodule, new PHModOperator)
 			self.header.add_decl("#define HASH(mask, id) ((mask)%(id))")