MetaDepth is especially useful to define languages spawning
multiple meta-levels. For example, in UML one can think of object diagrams to be instances of class diagrams. Hence class+objects diagrams
can be considered a multi-level language, and can be defined in MetaDepth through a unique meta-model. This has the advantage of a simpler
definition, and that the system's infrastructure takes care of the instantiation relations between objects and classes.
These languages appear in many other
domains like web engineering (page node types/page instances), role control access (role types/roles), and many more.
Some reusable abstractions [abstractions.zip].
This zip file contains reusable model abstractions, some of which were described in this paper.
The archive contains a README.txt file indicating how to use the abstractions.
A two-level language for defining product types [model3.mdepth].
Please note that the bottom-most model is incorrect (on purpose), so that constraint nonRep is violated. You can check that by typing
"context MyLibrary" and then "verify"
A meta-model for Petri nets [PetriNets.mdepth],
a Petri net [aPetriNet.mdepth], a simulator in EOL [PNSim.eol].
MetaDepth can also be used as a normal two-level meta-modelling environment. This shows an example where EOL can be used to define the
behaviour of models. You can load a petri net by typing load "aPetriNet". The first line of this file contains a command that
loads the Petri net meta-model. Finally, you can load (and execute) the behaviour by typing load EOL "PNSim". Should you have several
Petri net models loaded at the same time, you can choose which one to execute by changing the current context. Please note that the EOL operation
that is executed when the file is loaded is called "main".
A meta-model for Finite State Automata [FSA.mdepth],
which also contains an automaton example, and a simulator in EOL [FSAexec.eol].
First, load the language definition by typing load "FSA". Load (and execute) the behaviour by typing load EOL "FSAexec".
A meta-model for both class and object diagrams. [ClassDiagram.mdepth]
This example shows how a simple meta-model can define a two-level language. As you may note, association ends are instantiated similar to
other clabjects, the ontological type is given as a modifier after the association end.
A (very) simple multi-level language for concrete syntax. [Graphics3.mdepth]
This is another example of a multi-level language for defining the concrete syntax of meta-models. This language is instantiated once (and associated
with a meta-model) to define the concrete syntax of the associated meta-model. Then it is instantiated again to carry the information of the
visualizations of the instances of the associated meta-model.
Other simpler examples and small tests:
[st.mdepth] Shows examples on the use of EOL to compute derived attribute values for collections.
[Nature.mdepth] Shows the use of enumerations in a simple three-level model stack.
[EAPI.mdepth] Shows a simple example on the use of EOL's API in constraints.