rule

Syntax

visibility rule ruleName(parameters) : returnType {
    body
}
or
visibility rule parentRuleName::ruleName(parameters) : returnType {
    body
}

where:

• visibility: the visibility of the rule.
• parentRuleName: the name of the parent rule (optional).
• ruleName: the name of the rule.
• parameters: an optional list of comma separated parameters (optional).
• returnType: the return type of the rule (optional).
• body: any set of MQL statements.

Each parameter is of the form:

name : type

where:

• name: the name of the parameter.
• type: the type of the parameter (optional).

Description

Rule

The rule statement defines the signature of a rule, as well as the contents to be evaluated.

The name of a rule must be unique within its ruleset: two rules defined in the same ruleset must have different names, regardless their parameters.

The rule may define expected parameters, used to compute the returned value. Any caller of the rule must provide matching arguments. A rule may return any type of object (or may not return anything). You can specify the return type in the rule signature.

The parameters declared by the ruleset are directly available in each rule. Thus, a parameter or a local variable of a rule must not collide with a ruleset parameter.

Subrule

A rule may point at to a parent rule, in which case it means :

• The child rule has direct access to the parameters of its parent rule (including recursive parent rules).
• The child rule can only be called:
  • from its parent rule.
  • from its parent rule direct subrules (i.e. sister rules).

Using subrules may help to organize a ruleset into logical rule trees. The main point is to share parameters: subrules don't have to redefine parent rules parameters.

Examples

package com.mycompany.example;

// Expects a loaded UML 2.1 model as input
// The model is modified and may be saved once the evaluation is completed
public ruleset CreateUMLModel(inout model : uml21) {

    public rule main() {
    
        // loop on each Class of the UML 2.1 model
        foreach (class in model.getInstances("Class")) {
            @transformClass(class) {
        }
    }
    
    private rule transformClass(class : uml21.Class) {
        ...
        // loop on each feature of the class
        foreach (feature in class.feature)) {
            @transformFeature(feature) {
        }
    }
    
    // defines a subrule of transformClass
    private rule transformClass::transformFeature(feature : uml21.Feature) {
    
        // the transformClass 'class' parameter is available here
        System.out.println("Feature " + feature.name + " of class " + class.name);
    }
}

Rule