Many tools for Model-Driven Engineering (MDE) which are based on the widespread Eclipse Modelling Framework (EMF) [4] are developed for single tasks like e.g., generating, editing, refactoring, merging, patching or viewing of models. Thus, models are oftentimes exchanged in a series of tools. In such a tool chain, a gra cal model editor or viewer usually sets the degree of well-formedness of a model in order to visualize it. Well-formedness rules are typically de ned in the meta-models, yet not all tools take them into account. As a result, a model can become unprocessable for other tools. This leads to the requirement, that all tools should be based on a common de nition of minimum consistency. An obvious solution for this challenge is to use a common library of consistency-preserving edit operations (CPEOs) for models. However, typical meta-models lead to a large number of CPEOs. Manually specifying and implementing such a high number of CPEOs is hardly feasible and prone to error. This paper presents a new meta-tool which generates a complete set of CPEOs for a given meta-model. We have successfully integrated the generated CPEOs in several developer tools. The video http://youtu.be/w31AcMOd83Y demonstrates our meta-tool in the context of one of our developer tools.
Model-Driven Engineering (MDE) must be supported by tools which can edit or
refactor (e.g., [
The main contribution of this paper is a meta-tool called SERGe (SiDi Edit Rule Generator) which generates a complete set of executable CPEOs for a given meta-model. The generated sets of CPEOs can be integrated by tool developers into an MDE environment as illustrated in Figure 1. In this example, a model generator integrates the functionality of SERGe to initially generate a set of CPEOs. Afterwards, the model generator algorithm can execute these CPEOs to generate models. Moreover, the generated CPEOs comprise a common library which can be reused by further tools, e.g., a model refactor tool.
The generation process for a set of
CPEOs is fully automated and meta-model
independent. SERGe is based on EMF. The
generated CPEOs use EMF Henshin [
SERGe provides a variety of optional con guration settings to tailor the
generation process, e.g., whether to generate CPEOs for supertypes instead of for
each subtype. The former will decrease the number of generated CPEOs
heavily. One can also enable or disable the kinds of CPEOs (create, move, etc.)
that should be generated. These are just a few con gurations that are possible.
SERGe has already been used extensively in di erent research projects, e.g., the
SMG (SiDi Model Generator) [
The easiest way to modify the Abstract Syntax Graph (ASG) of a model is to use basic graph operations e.g., creating or deleting single model objects. However, basic ASG operations do not consider well-formedness rules (e.g., multiplicity constraints) as de ned by the meta-model. Hence, they can lead to inconsistent ASGs, which cannot be processed by other tools.
As an example, we use simpli ed state machines with a meta-model as shown in Figure 2(a). A StateMachine object must have at least one child object of type Region, s. the multiplicity constraint of [1:: ] of the containment reference region. A basic ASG operation which creates only a single StateMachine object violates this constraint. A CPEO on the other hand will create a StateMachine object together with a contained, mandatory child object of type Region.
A CPEO usually comprises several basic ASG operations, but at least those
which are required to implement a consistency-preserving editing behavior.
Figure 2(b) shows the CPEO mentioned above as an EMF Henshin [
Prior to the generation phase, the meta-model is analyzed to identify the relationships between classi ers. This is done by considering incoming references of each classi er and the complete inheritance hierarchy. The source of a reference can either be a parent context or a neighbor context. This depends on the nature of a reference which is either containment in the rst or non-containment in the latter case. Analogously, the target of a reference can either be identied as a 'child' or a 'neighbor'. Naturally, opposite references (e.g., region and stateMachine in the example) have to be considered together. Otherwise invalid CPEOs could be generated. An invalid operation would be the change of the reference target stateMachine without also changing its opposite, namely the containment reference region
Multiplicities of a reference (i.e., the upper bound (ub) and lower bound (lb)) are classi ed by one or more of the invariant groups shown in Figure 2(c). The meta-model analysis categorizes each relationship by considering each multiplicity invariant, which can be found on a reference. It determines if a target of a reference needs mandatory objects. This is the case if the reference multiplicity is classi ed as required. In a relationship between model elements, there can also exist optional objects. This is the case if the reference is attached with a many multiplicity classi cation. Naturally, these classi cations can both apply (a) simple state machine meta-model (b) CPEO 'createStateMachineInModel' classi cation invariant group (lb ub) required lb > 0 bounded ub < 1
xed lb = ub many (ub lb >= 1) _ (ub = 1) (c) multiplicity invariant classi cation (d) CPEO 'changeTransitionTargetToState' to one reference, e.g., for [1:: ] (see Figure 2(a)). This identi cation allows the generation algorithm to decide if a CPEO for the creation of an object may be generated or if this creation may only happen in the context of another CPEO.
During the generation phase every classi er in the given meta-model is visited. By means of the previously analyzed relationships and attributes of each considered classi er, SERGe determines which CPEO kinds will be generated for which classi er, reference or attribute. The starting point for each decision is the nature of a reference (i.e., being containment or noncontainment ). 1 The following CPEO kinds can be generated depending on the occurring multiplicity invariants: creation/deletion of elements, adding/removing neighbors, setting/unsetting/changing of single neighbors or (default) attribute values or moving of children between di erent contexts. Mandatory children and neighbors of elements are integrated recursively inside a CPEO.
The generated CPEOs can also contain precondition checks to avoid falling
below required multiplicities or exceeding bounded multiplicities. This is realized
with Henshin Positive Application Conditions (PAC) and Negative Application
Conditions (NAC).
1 We assume attributes can be handled equally to non-containment references.
There are several approaches to generate executable edit operations for models
beyond basic ASG edit operations. The closest approaches to ours are [
Ehrig and Taenzer [
Alanen and Porres [
To our best knowledge, the coverage of consistency constraints, con gurability and completeness of the generated sets is not met by any other existing meta-tool to generate edit operations.