+++ /dev/null
-# This file is part of NIT ( http://www.nitlanguage.org ).
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-module model_views
-
-import model_visitor
-
-# Provide a configurable view to a model.
-#
-# This can be useful when you need to filter some mentities from a model
-# like private or fictive.
-#
-# TODO doc usage
-class ModelView
- super ModelVisitor
-
- autoinit(model, mainmodule, filter)
-
- # The model to view through `self`.
- var model: Model
-
- # MModule used to flatten mclass hierarchy
- var mainmodule: MModule
-
- # MPackages visible through `self`.
- var mpackages: Set[MPackage] is lazy do
- var mpackages = new HashSet[MPackage]
- for mpackage in model.mpackages do
- if not accept_mentity(mpackage) then continue
- mpackages.add mpackage
- end
- return mpackages
- end
-
- # MGroups visible through `self`.
- var mgroups: Set[MGroup] is lazy do
- var mgroups = new HashSet[MGroup]
- for mpackage in mpackages do
- for mgroup in mpackage.mgroups do
- if not accept_mentity(mgroup) then continue
- mgroups.add mgroup
- end
- end
- return mgroups
- end
-
- # MModules visible through `self`.
- var mmodules: Set[MModule] is lazy do
- var mmodules = new HashSet[MModule]
- for mmodule in model.mmodules do
- if not accept_mentity(mmodule) then continue
- mmodules.add mmodule
- end
- return mmodules
- end
-
- # MClasses visible through `self`.
- var mclasses: Set[MClass] is lazy do
- var mclasses = new HashSet[MClass]
- for mclass in model.mclasses do
- if not accept_mentity(mclass) then continue
- mclasses.add mclass
- end
- return mclasses
- end
-
- # MClassDefs visible through `self`.
- var mclassdefs: Set[MClassDef] is lazy do
- var mclassdefs = new HashSet[MClassDef]
- for mclass in mclasses do
- for mclassdef in mclass.mclassdefs do
- if not accept_mentity(mclassdef) then continue
- mclassdefs.add mclassdef
- end
- end
- return mclassdefs
- end
-
- # MProperties visible through `self`.
- var mproperties: Set[MProperty] is lazy do
- var mproperties = new HashSet[MProperty]
- for mproperty in model.mproperties do
- if not accept_mentity(mproperty) then continue
- mproperties.add mproperty
- end
- return mproperties
- end
-
- # MPropdefs visible through `self`.
- var mpropdefs: Set[MPropDef] is lazy do
- var mpropdefs = new HashSet[MPropDef]
- for mproperty in mproperties do
- for mpropdef in mproperty.mpropdefs do
- if not accept_mentity(mpropdef) then continue
- mpropdefs.add mpropdef
- end
- end
- return mpropdefs
- end
-
- # Lists all MEntities visible through `self`.
- var mentities: Set[MEntity] is lazy do
- var res = new HashSet[MEntity]
- res.add_all mpackages
- res.add_all mgroups
- res.add_all mmodules
- res.add_all mclasses
- res.add_all mclassdefs
- res.add_all mproperties
- res.add_all mpropdefs
- return res
- end
-
- # Searches the MEntity that matches `full_name`.
- fun mentity_by_full_name(full_name: String): nullable MEntity do
- for mentity in mentities do
- if mentity.full_name == full_name then return mentity
- end
- return null
- end
-
- # Searches the MEntities that matches `full_name`.
- fun mentities_by_name(name: String): Array[MEntity] do
- var res = new Array[MEntity]
- for mentity in mentities do
- if mentity.name == name then res.add mentity
- end
- return res
- end
-
- # Build an concerns tree with from `self`
- fun to_tree: MEntityTree do
- var v = new ModelTreeVisitor
- v.filter = self.filter
- for mpackage in mpackages do
- v.enter_visit(mpackage)
- end
- return v.tree
- end
-
- # Build the POSet of `mmodules` importation.
- fun mmodules_poset(mmodules: Set[MModule]): POSet[MModule] do
- return model.mmodule_importation_hierarchy.sub(mmodules)
- end
-
- # Build the POSet of `mclasses` hierarchy.
- fun mclasses_poset(mainmodule: MModule, mclasses: Set[MClass]): POSet[MClass] do
- return mainmodule.flatten_mclass_hierarchy.sub(mclasses)
- end
-end
-
-class LookupNamespaceVisitor
- super ModelVisitor
-
- var namespace: String
-
- private var parts: Array[String] is lazy do return namespace.split_with("::")
-
- var results = new Array[MEntity]
-
- redef fun visit(mentity) do mentity.accept_namespace_visitor(self)
-end
-
-class ModelTreeVisitor
- super ModelVisitor
-
- var tree = new MEntityTree
-
- redef fun visit(mentity) do mentity.accept_tree_visitor(self)
-end
-
-redef class MEntity
- private fun accept_namespace_visitor(v: LookupNamespaceVisitor) do
- if v.parts.is_empty then return
- if name != v.parts.first then return
- v.parts.shift
- if v.parts.is_empty then
- v.results.add self
- return
- end
- visit_all(v)
- end
-
- private fun accept_tree_visitor(v: ModelTreeVisitor) do end
-end
-
-redef class MPackage
- redef fun accept_tree_visitor(v) do
- v.tree.add(null, self)
- visit_all(v)
- end
-end
-
-redef class MGroup
- redef fun accept_tree_visitor(v) do
- var parent = self.parent
- if parent != null then
- v.tree.add(parent, self)
- else
- v.tree.add(mpackage, self)
- end
- visit_all(v)
- end
-end
-
-redef class MModule
- redef fun accept_tree_visitor(v) do
- v.tree.add(mgroup, self)
- visit_all(v)
- end
-end
-
-redef class MClass
- # We don't want to collect classes from full namespace.
- redef fun accept_namespace_visitor(v) do end
-end
-
-redef class MClassDef
- redef fun accept_tree_visitor(v) do
- v.tree.add(mmodule, self)
- visit_all(v)
- end
-end
-
-redef class MProperty
- # We don't want to collect properties from full namespace.
- redef fun accept_namespace_visitor(v) do end
-end
-
-redef class MPropDef
- redef fun accept_tree_visitor(v) do
- v.tree.add(mclassdef, self)
- visit_all(v)
- end
-end
nitlanguage / nit.git / blobdiff