-import typing
-
-# Layouts
-
-class TypingLayout[E]
- # Unic ids or each element
- var ids: Map[E, Int] = new HashMap[E, Int]
- # Fixed positions of each element in all tables
- var pos: Map[E, Int] = new HashMap[E, Int]
-end
-
-class PHTypingLayout[E]
- super TypingLayout[E]
- # Masks used by hash function
- var masks: Map[E, Int] = new HashMap[E, Int]
- # Positions of each element for each tables
- var hashes: Map[E, Map[E, Int]] = new HashMap[E, Map[E, Int]]
-end
-
-class PropertyLayout[E]
- # Fixed positions of each element in all tables
- var pos: Map[E, Int] = new HashMap[E, Int]
-end
-
-# Layout for resolution tables
-class ResolutionLayout
- # Unic ids for each resolved type
- var ids: Map[MType, Int] = new HashMap[MType, Int]
- # Fixed positions of resolved type
- var pos: Map[MType, Int] = new HashMap[MType, Int]
-end
-
-class PHResolutionLayout
- super ResolutionLayout
- # Masks associated to each owner of a resolution table
- var masks: Map[MClassType, Int] = new HashMap[MClassType, Int]
- # Positions of each resolvec type for resolution tables
- var hashes: Map[MClassType, Map[MType, Int]] = new HashMap[MClassType, Map[MType, Int]]
-end
-
-# Builders
-
-abstract class TypingLayoutBuilder[E]
-
- type LAYOUT: TypingLayout[E]
-
- private var mmodule: MModule
- init(mmodule: MModule) do self.mmodule = mmodule
-
- # 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(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 TypingLayoutBuilder[MType]
-
- init(mmodule: MModule) do super
-
- # Compute mtypes ids and position using BM
- redef fun build_layout(mtypes) do
- var result = new TypingLayout[MType]
- result.ids = self.compute_ids(mtypes)
- 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 TypingLayoutBuilder[MType]
-
- private var colorer: MTypeColorer
-
- init(mmodule: MModule) do
- super
- self.colorer = new MTypeColorer(mmodule)
- end
-
- # Compute mtypes ids and position using BM
- redef fun build_layout(mtypes) do
- var result = new TypingLayout[MType]
- result.ids = self.compute_ids(mtypes)
- 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 TypingLayoutBuilder[MType]
-
- redef type LAYOUT: PHTypingLayout[MType]
-
- private var hasher: MTypeHasher
-
- init(mmodule: MModule, operator: PHOperator) do
- super
- self.hasher = new MTypeHasher(mmodule, operator)
- end
-
- # Compute mtypes ids and position using BM
- redef fun build_layout(mtypes) do
- var result = new PHTypingLayout[MType]
- result.ids = self.compute_ids(mtypes)
- result.masks = self.hasher.compute_masks(mtypes, result.ids)
- result.hashes = self.hasher.compute_hashes(mtypes, result.ids, result.masks)
- return result
- end
-
- # Ids start from 1 instead of 0
- redef fun compute_ids(mtypes) 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
-
- 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 TypingLayoutBuilder[MClass]
-
- init(mmodule: MModule) do super
-
- # Compute mclasses ids and position using BM
- redef fun build_layout(mclasses) do
- var result = new TypingLayout[MClass]
- result.ids = self.compute_ids(mclasses)
- 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 TypingLayoutBuilder[MClass]
-
- private var colorer: MClassColorer
-
- init(mmodule: MModule) do
- super
- self.colorer = new MClassColorer(mmodule)
- end
-
- # Compute mclasses ids and position using BM
- redef fun build_layout(mclasses) do
- var result = new TypingLayout[MClass]
- result.ids = self.compute_ids(mclasses)
- 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 TypingLayoutBuilder[MClass]
-
- redef type LAYOUT: PHTypingLayout[MClass]
-
- private var hasher: MClassHasher
-
- init(mmodule: MModule, operator: PHOperator) do
- super
- self.hasher = new MClassHasher(mmodule, operator)
- end
-
- # Compute mclasses ids and position using BM
- redef fun build_layout(mclasses) do
- var result = new PHTypingLayout[MClass]
- result.ids = self.compute_ids(mclasses)
- result.masks = self.hasher.compute_masks(mclasses, result.ids)
- result.hashes = self.hasher.compute_hashes(mclasses, result.ids, result.masks)
- return result
- end
-
- # Ids start from 1 instead of 0
- redef fun compute_ids(mclasses) 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 reverse_linearize(elements) do return self.mmodule.reverse_linearize_mclasses(elements)
-end
-
-abstract class PropertyLayoutBuilder[E: MProperty]
-
- type LAYOUT: PropertyLayout[E]
-
- private var mmodule: MModule
- init(mmodule: MModule) do self.mmodule = mmodule
-
- # Compute properties ids and position
- fun build_layout(mclasses: Set[MClass]): LAYOUT is abstract
-end
-
-# Layout builder for MProperty using Coloring (CL)
-class CLPropertyLayoutBuilder[E: MProperty]
- super PropertyLayoutBuilder[E]
-
- private var colorer: MPropertyColorer[E]
-
- init(mmodule: MModule) do
- super
- self.colorer = new MPropertyColorer[E](mmodule)
- end
-
- # Compute mclasses ids and position using BM
- redef fun build_layout(mclasses) do
- var result = new PropertyLayout[E]
- result.pos = self.colorer.colorize(mclasses)
- return result
- end
-end
-
-abstract class ResolutionLayoutBuilder
-
- type LAYOUT: ResolutionLayout
-
- init do end
-
- fun build_layout(elements: Map[MClassType, Set[MType]]): LAYOUT is abstract
-
- fun compute_ids(elements: Map[MClassType, Set[MType]]): Map[MType, Int] do
- var ids = new HashMap[MType, Int]
- var color = 0
- for mclasstype, mclasstypes in elements do
- for element in mclasstypes do
- if ids.has_key(element) then continue
- ids[element] = color
- color += 1