- private fun super_elements(element: E, elements: Set[E]): Set[E] is abstract
- private fun sub_elements(element: E, elements: Set[E]): Set[E] is abstract
- private fun is_element_mi(element: E, elements: Set[E]): Bool is abstract
- private fun linearize(elements: Set[E]): Array[E] is abstract
- private fun reverse_linearize(elements: Set[E]): Array[E] is abstract
-end
-
-# MType coloring
-private class MTypeColorer
- super AbstractColorer[MType]
-
- var mmodule: MModule
-
- init(mmodule: MModule) do self.mmodule = mmodule
-
- redef fun super_elements(element, elements) do return self.mmodule.super_mtypes(element, elements)
- redef fun is_element_mi(element, elements) do return self.super_elements(element, elements).length > 1
- redef fun sub_elements(element, elements) do do return self.mmodule.sub_mtypes(element, elements)
- redef fun linearize(elements) do return self.mmodule.linearize_mtypes(elements)
- redef fun reverse_linearize(elements) do return self.mmodule.reverse_linearize_mtypes(elements)
-end
-
-# MClass coloring
-private class MClassColorer
- super AbstractColorer[MClass]
-
- private var mmodule: MModule
-
- init(mmodule: MModule) do self.mmodule = mmodule
-
- redef fun super_elements(element, elements) do return self.mmodule.super_mclasses(element)
- fun parent_elements(element: MClass): Set[MClass] do return self.mmodule.parent_mclasses(element)
- redef fun is_element_mi(element, elements) do return self.parent_elements(element).length > 1
- redef fun sub_elements(element, elements) do do return self.mmodule.sub_mclasses(element)
- redef fun linearize(elements) do return self.mmodule.linearize_mclasses(elements)
- redef fun reverse_linearize(elements) do return self.mmodule.reverse_linearize_mclasses(elements)
-end
-
-# Perfect hashers
-
-# Abstract Perfect Hashing
-private abstract class AbstractHasher[E: Object]
-
- var operator: PHOperator
-
- init(operator: PHOperator) do self.operator = operator
-
- fun compute_masks(elements: Set[E], ids: Map[E, Int]): Map[E, Int] do
- var masks = new HashMap[E, Int]
- for element in elements do
- var supers = new HashSet[E]
- supers.add_all(self.super_elements(element, elements))
- supers.add(element)
- masks[element] = compute_mask(supers, ids)
- end
- return masks
- end
-
- fun compute_mask(supers: Set[E], ids: Map[E, Int]): Int do
- var mask = 0
- loop
- var used = new List[Int]
- for sup in supers do
- var res = operator.op(mask, ids[sup])
- if used.has(res) then
- break
- else
- used.add(res)
- end
- end
- if used.length == supers.length then break
- mask += 1
- end
- return mask
- end
-
- fun compute_hashes(elements: Set[E], ids: Map[E, Int], masks: Map[E, Int]): Map[E, Map[E, Int]] do
- var hashes = new HashMap[E, Map[E, Int]]
- for element in elements do
- var supers = new HashSet[E]
- supers.add_all(self.super_elements(element, elements))
- supers.add(element)
- var inhashes = new HashMap[E, Int]
- var mask = masks[element]
- for sup in supers do
- inhashes[sup] = operator.op(mask, ids[sup])
- end
- hashes[element] = inhashes
- end
- return hashes
- end
-
- fun super_elements(element: E, elements: Set[E]): Set[E] is abstract
-end
-
-# Abstract operator used for perfect hashing
-abstract class PHOperator
- fun op(mask: Int, id:Int): Int is abstract
-end
-
-# Hashing using modulo (MOD) operator
-# slower but compact
-class PHModOperator
- super PHOperator
- init do end
- redef fun op(mask, id) do return mask % id
-end
-
-# Hashing using binary and (AND) operator
-# faster but sparse
-class PHAndOperator
- super PHOperator
- init do end
- redef fun op(mask, id) do return mask.bin_and(id)
-end
-
-# MType Perfect Hashing
-private class MTypeHasher
- super AbstractHasher[MType]
-
- var mmodule: MModule
-
- init(mmodule: MModule, operator: PHOperator) do
- super(operator)
- self.mmodule = mmodule
- end
-
- redef fun super_elements(element, elements) do return self.mmodule.super_mtypes(element, elements)
-end
-
-# MClass Perfect Hashing
-private class MClassHasher
- super AbstractHasher[MClass]
-
- private var mmodule: MModule
-
- init(mmodule: MModule, operator: PHOperator) do
- super(operator)
- self.mmodule = mmodule
- end
-
- redef fun super_elements(element, elements) do return self.mmodule.super_mclasses(element)
-end
-
-# MClass coloring
-class ClassColoring
- super AbstractColorer[MClass]
-
- type T: MClass
-
- private var mmodule: MModule
-
- # caches
- private var super_elements_cache: Map[T, Set[T]] = new HashMap[T, Set[T]]
- private var parent_elements_cache: Map[T, Set[T]] = new HashMap[T, Set[T]]
- private var sub_elements_cache: Map[T, Set[T]] = new HashMap[T, Set[T]]
-
- init(mainmodule: MModule) do self.mmodule = mainmodule
-
- redef fun super_elements(element, elements) do return self.mmodule.super_mclasses(element)
- fun parent_elements(element: MClass): Set[MClass] do return self.mmodule.parent_mclasses(element)
- redef fun is_element_mi(element, elements) do return self.parent_elements(element).length > 1
- redef fun sub_elements(element, elements) do do return self.mmodule.sub_mclasses(element)
- redef fun linearize(elements) do return self.mmodule.linearize_mclasses(elements)
- redef fun reverse_linearize(elements) do return self.mmodule.reverse_linearize_mclasses(elements)
-end
-
-# MProperty coloring
-class PropertyColoring
-
- type MPROP: MProperty
- type MPROPDEF: MPropDef
-
- private var class_coloring: ClassColoring
- private var coloration_result: Map[MPROP, Int] = new HashMap[MPROP, Int]
-
- init(class_coloring: ClassColoring) do
- self.class_coloring = class_coloring
- end
-
- fun colorize: Map[MPROP, Int] do
- colorize_core_properties
- colorize_crown_properties
- return self.coloration_result
- end
-
- fun build_property_tables: Map[MClass, Array[nullable MPROPDEF]] do
- var tables = new HashMap[MClass, Array[nullable MPROPDEF]]
- var mclasses = self.class_coloring.coloration_result.keys
- for mclass in mclasses do
- var table = new Array[nullable MPROPDEF]
- # first, fill table from parents by reverse linearization order
- var parents = self.class_coloring.mmodule.super_mclasses(mclass)
- var lin = self.class_coloring.reverse_linearize(parents)
- for parent in lin do
- for mproperty in self.properties(parent) do
- var color = self.coloration_result[mproperty]
- if table.length <= color then
- for i in [table.length .. color[ do
- table[i] = null
- end
- end
- for mpropdef in mproperty.mpropdefs do
- if mpropdef.mclassdef.mclass == parent then
- table[color] = mpropdef
- end
- end
- end
- end
-
- # then override with local properties
- for mproperty in self.properties(mclass) do
- var color = self.coloration_result[mproperty]
- if table.length <= color then
- for i in [table.length .. color[ do
- table[i] = null
- end
- end
- for mpropdef in mproperty.mpropdefs do
- if mpropdef.mclassdef.mclass == mclass then
- table[color] = mpropdef
- end
- end
- end
- tables[mclass] = table
- end
- return tables
- end
-
- # Colorize properties of the core hierarchy
- private fun colorize_core_properties do
- var mclasses = self.class_coloring.core
- var min_color = 0
-
- for mclass in mclasses do
- var color = min_color
-
- # if the class is root, get the minimal color
- if self.class_coloring.parent_elements(mclass).length == 0 then
- colorize_elements(self.properties(mclass), color)
- else
- # check last color used by parents
- color = max_color(color, self.class_coloring.parent_elements(mclass))
- # check max color used in conflicts
- if self.class_coloring.conflicts_graph.has_key(mclass) then
- color = max_color(color, self.class_coloring.conflicts_graph[mclass])
- end
-
- # colorize
- colorize_elements(self.properties(mclass), color)
- end