X-Git-Url: http://nitlanguage.org

diff --git a/src/model_utils.nit b/src/model_utils.nit
index 7963eda..5347128 100644
--- a/src/model_utils.nit
+++ b/src/model_utils.nit
@@ -17,8 +17,7 @@
 # Model exploration and traversing facilities
 module model_utils
 
-import toolcontext
-import exprbuilder
+import modelbuilder
 
 redef class MModule
 	# Get the list of mclasses refined in 'self'.
@@ -39,19 +38,20 @@ redef class MModule
 		end
 		return mclasses
 	end
-
-	# Get all mclasses in 'self' with their state
-	fun mclasses: HashMap[MClass, Int] do
-		var mclasses = new HashMap[MClass, Int]
-		for c in intro_mclasses do mclasses[c] = c_is_intro
-		for r in redef_mclasses do mclasses[r] = c_is_refined
-		for i in imported_mclasses do mclasses[i] = c_is_imported
-		return mclasses
-	end
 end
 
 redef class MClass
 
+	# Get the public owner of 'self'.
+	fun public_owner: MModule do
+		var public_owner = self.intro_mmodule.public_owner
+		if public_owner == null then
+			return self.intro_mmodule
+		else
+			return public_owner
+		end
+	end
+
 	# Get direct parents of 'self'.
 	fun parents: Set[MClass] do
 		var ret = new HashSet[MClass]
@@ -125,6 +125,57 @@ redef class MClass
 		return res
 	end
 
+	# the set of properties introduced in 'self'.
+	fun intro_mproperties(min_visibility: MVisibility): Set[MProperty] do
+		var set = new HashSet[MProperty]
+		for mclassdef in mclassdefs do
+			for mprop in mclassdef.intro_mproperties do
+				if mprop.visibility < min_visibility then continue
+				set.add(mprop)
+			end
+		end
+		return set
+	end
+
+	# the set of locally refined properties in 'self'.
+	fun redef_mproperties(min_visibility: MVisibility): Set[MProperty] do
+		var set = new HashSet[MProperty]
+		for mclassdef in mclassdefs do
+			for mpropdef in mclassdef.mpropdefs do
+				if mpropdef.mproperty.visibility < min_visibility then continue
+				if mpropdef.mproperty.intro_mclassdef.mclass != self then set.add(mpropdef.mproperty)
+			end
+		end
+		return set
+	end
+
+	# the set of methods inherited by 'self'.
+	fun inherited_mproperties(mainmodule: MModule, min_visibility: MVisibility): Set[MProperty] do
+		var set = new HashSet[MProperty]
+		for parent in in_hierarchy(mainmodule).direct_greaters do
+			set.add_all(parent.intro_mproperties(min_visibility))
+			set.add_all(parent.inherited_mproperties(mainmodule, min_visibility))
+		end
+		return set
+	end
+
+	# the set of introduced and redefined mproperties
+	fun local_mproperties(min_visibility: MVisibility): Set[MProperty] do
+		var set = new HashSet[MProperty]
+		set.add_all(intro_mproperties(min_visibility))
+		set.add_all(redef_mproperties(min_visibility))
+		return set
+	end
+
+	# the set of all accessible mproperties for this class
+	fun all_mproperties(mainmodule: MModule, min_visibility: MVisibility): Set[MProperty] do
+		var set = new HashSet[MProperty]
+		set.add_all(local_mproperties(min_visibility))
+		set.add_all(inherited_mproperties(mainmodule, min_visibility))
+		return set
+	end
+
+
 	# Get the list of locally refined methods in 'self'.
 	fun redef_methods: Set[MMethod] do
 		var res = new HashSet[MMethod]
@@ -138,7 +189,6 @@ redef class MClass
 		return res
 	end
 
-	# Get the list of methods inherited by 'self'.
 	fun inherited_methods: Set[MMethod] do
 		var res = new HashSet[MMethod]
 		for s in ancestors do
@@ -180,12 +230,6 @@ redef class MClass
 		return res
 	end
 
-	fun mmodules: Set[MModule] do
-		var mdls = new HashSet[MModule]
-		for mclassdef in mclassdefs do mdls.add(mclassdef.mmodule)
-		return mdls
-	end
-
 	fun is_class: Bool do
 		return self.kind == concrete_kind or self.kind == abstract_kind
 	end
@@ -203,7 +247,39 @@ redef class MClass
 	end
 end
 
-# MClass State
-fun c_is_intro: Int do return 1
-fun c_is_refined: Int do return 2
-fun c_is_imported: Int do return 3
+# Sorters
+
+# Sort mmodules by their name
+class MModuleNameSorter
+	super AbstractSorter[MModule]
+	redef fun compare(a, b) do return a.name <=> b.name
+	init do end
+end
+
+# Sort mclasses by their name
+class MClassNameSorter
+	super AbstractSorter[MClass]
+	redef fun compare(a, b) do return a.name <=> b.name
+	init do end
+end
+
+# Sort mclassdefs by their name
+class MClassDefNameSorter
+	super AbstractSorter[MClassDef]
+	redef fun compare(a, b) do return a.mclass.name <=> b.mclass.name
+	init do end
+end
+
+# Sort mproperties by their name
+class MPropertyNameSorter
+	super AbstractSorter[MProperty]
+	redef fun compare(a, b) do return a.name <=> b.name
+	init do end
+end
+
+# Sort mpropdefs by their name
+class MPropDefNameSorter
+	super AbstractSorter[MPropDef]
+	redef fun compare(a, b) do return a.mproperty.name <=> b.mproperty.name
+	init do end
+end