# 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'.
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
return res
end
- # Get the set of properties introduced in 'self'.
- fun intro_mproperties: Set[MProperty] do
- var res = new HashSet[MProperty]
+ # 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.is_intro then res.add(mpropdef.mproperty)
+ if mpropdef.mproperty.visibility < min_visibility then continue
+ if mpropdef.mproperty.intro_mclassdef.mclass != self then set.add(mpropdef.mproperty)
end
end
- return res
+ 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]
return res
end
- # Get the set of locally refined properties in 'self'.
- fun redef_mproperties: Set[MProperty] do
- var res = new HashSet[MProperty]
- for mclassdef in mclassdefs do
- for mpropdef in mclassdef.mpropdefs do
- if not mpropdef.is_intro then res.add(mpropdef.mproperty)
- end
- end
- 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
return res
end
- # Get the set of all properties inherited by self
- fun inherited_mproperties: Set[MProperty] do
- var res = new HashSet[MProperty]
- for s in ancestors do
- for m in s.intro_mproperties do
- if not self.intro_mproperties.has(m) and not self.redef_mproperties.has(m) then res.add(m)
- end
- end
- return res
- end
-
# Get the list of all virtual types available in 'self'.
fun virtual_types: Set[MVirtualTypeProp] do
var res = new HashSet[MVirtualTypeProp]
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
-
- # Get the list of MModule concern in 'self'
- fun concerns: HashMap[MModule, nullable List[MModule]] do
- var hm = new HashMap[MModule, nullable List[MModule]]
- for mmodule in mmodules do
- var owner = mmodule.public_owner
- if owner == null then
- hm[mmodule] = null
- else
- if hm.has_key(owner) then
- hm[owner].add(mmodule)
- else
- hm[owner] = new List[MModule]
- hm[owner].add(mmodule)
- end
- end
- end
- return hm
- end
-
fun is_class: Bool do
return self.kind == concrete_kind or self.kind == abstract_kind
end
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
nitlanguage / nit.git / blobdiff