Guide MVEL

Dans cette page, nous allons détailler les principales instructions qui peuvent être utilisées dans une formule de calcul.

Pour plus de détail, consulter le site officiel.

Contexte

Dans RuleShake Engine, chaque formule de calcul est évaluée dans un contexte mvel. Ce contexte contient un ensemble de fonctions qui facilitent la manipulation des valeurs des variables. Pour plus de détail, voir Dictionnaire des fonctions

Variables

Le contexte est également chargé, avant chaque évaluation d'une formule de calcul, avec les instances des variables d'une collection sous forme d'une Map ou la clé est le code de la variable et la valeur dépend du type et la multiplicité, ou non, de la variable correspondante.

Cette map contient uniquement les variables du premier niveau, c'est-à-dire celles qui sont définies à la racine de la collection.

Si une variable est non multiple, alors la valeur (correspondant à la clé d'une entrée de la map) est l'instance de la variable correspondante qui peut être directement utilisée dans une formule de calcul.

Si une variable est multiple, alors la valeur est une liste des instances de la variable correspondante. Il n'est donc pas possible d'utiliser le code de la variable directement dans une formule de calcul, car elle fait référence à une liste. On peut cependant sélectionner un élément de la liste en spécifiant son index ou bien boucler sur l'ensemble des instances de la variable ou encore utiliser des fonctions propres aux listes.

Si une variable est composite, alors la valeur est une Map contenant ses sous-variables.

Syntaxe de base

Accès à une variable

Pour accéder à une variable, on peut utiliser son code (précédé par les codes de ses parents le cas échéant) :

Exemple

MA_VARIABLE.value

info

L'objet auquel on accède lorsqu'on saisit le code d'une variable est l'objet représentant la variable. Ainsi, pour accéder à la valeur de la variable, on saisit à la suite du code de la variable le nom de la propriété value.

Variables temporaires

Il est possible de définir des variables temporaires utilisables uniquement dans la formule de calcul dans laquelle elles ont été déclarées.

Il est nécessaire d'assigner une valeur à la variable temporaire dès sa déclaration (quite à ce qu'elle soit surchargée plus tard dans la formule de calcul)

Exemple

tmp = 0

Instructions multiples

On peut saisir dans une formule de calcul plusieurs instructions. Ceci peut être utile si la valeur à calculer nécessite plusieurs manipulations avant de retourner la valeur finale.

attention

Il est nécessaire de séparer les instructions avec le caractère ; afin d'indiquer clairement la fin d'une instruction.

Exemple

tmp = 0;
tmp = MA_VARIABLE.value + 10;
return tmp;

Valeurs renvoyées

Par défaut, la valeur de la dernière instruction est retournée par la formule de calcul et donc assignée à la valeur de la variable correspondante.

On peut définir de façon explicite l'instruction du retour avec le mot-clé return. Ce dernier peut être utilisé à n'importe quel position dans la formule de calcul et ne doit pas forcément être présent à la fin.

Commentaires

Il est possible d'ajouter des lignes de commentaires dans une formule de calcul. Ces lignes doivent être précédées par //.

Exemple

// on déclare tmp à 0
tmp = 0;
// on ajoute ensuite la valeur de MA_VARIABLE à laquelle on ajoute la valeur 10
tmp = MA_VARIABLE.value + 10;
// on retourne la valeur de tmp
return tmp;

Conditions

Il est possible d'utiliser des conditions dans une formule de calcul.

If-Then-Else

La première possibilité (et la plus lisible) est d'utiliser les blocs définis par la syntaxe :

if (condition) {
    instuctions exécutées si la condition est vérifiée    
} else {
    instuctions exécutées si la condition n'est pas vérifiée
}

La condition est une expression booléenne ou les caractères suivants sont à utiliser :

• == pour un test d'égalité
• != pour un test d'inégalité
• > pour un test de supériorité stricte
• >= pour un test de supériorité ou d'égalité
• < pour un test d'infériorité stricte
• <= pour un test d'infériorité ou d'égalité

Exemple

if (AGE.value >= 18) {
    return "Majeur";
} else {
    return "Mineur";
}

Déclaration ternaire

L'écriture ternaire permet de simplifier l'instruction dans le cas ou les blocs après if et else ne contiennent qu'une seule instruction. La syntaxe ternaire est la suivante :

(condition) ? valeur_si_condition_vérifiée : valeur_si_condition_non_vérifiée;

Exemple

(AGE.value >= 18) ? "Majeur" : "Mineur";

Listes et tables

Une liste ou un tableau représente une collection de données du même type. Une variable multiple est représentée sous forme de liste dans RuleShake.

Une table ou tableau associatif ou encore une map représente une collection de paires (clé, valeur). Une variable composite est représentée sous forme de table dans RuleShake.

info

Si une variable composite est multiple, elle est donc représentée sous forme de liste de tables.

Fonctions utiles

Les listes et tables offrent des fonctions utiles lors de leurs manipulations

size

retourne un entier qui représente la taille (le nombre d'éléments) de la liste ou de la table :

Exemples

MA_VARIABLE_MULTIPLE.size() // retourne le nombre d'instances
MA_VARIABLE_COMPOSITE.size() // retourne le nombre de sous-variables

isEmpty

retourne un booléen qui indique si la liste ou la tableau est vide.

Exemples

MA_VARIABLE_MULTIPLE.isEmpty() 
MA_VARIABLE_COMPOSITE.isEmpty() 

get(param)

retourne une instance d'une liste ou une valeur d'une table.

Pour les listes, la fonction .get(param) prend comme paramètre un entier qui représente la position de l'instance souhaitée.

info

La valeur 0 représente le premier élément de la liste.

Exemple

MA_VARIABLE_MULTIPLE.get(1) // retourne le 2ème élément de la liste

Pour les tables, la fonction .get(param) prend comme paramètre une clé. Dans le cas d'une variable composite, la clé représente le code de la sous-variable.

Exemple

MA_VARIABLE_COMPOSITE.get("FOO") // retourne la sous-variable dont le code est `FOO`

entrySet()

disponible uniquement pour les tables. Permet de construire une liste de pair (clé, valeur) qui composent la table. .entrySet() est utile lorsque l'on souhaite itérer sur les valeurs de la table.

Boucles

Boucle foreach

La boucle foreach est à utiliser lorsqu'on souhaite boucler sur les valeurs d'une liste ou d'une variable multiple. Pour cela, la syntaxe à utiliser est :

foreach (variable_temporaire : code_variable_multiple) {
    instructions qui utilisent variable_temporaire qui représente la valeur d'une instance
}

Il est également possible de boucler sur les valeurs d'une variable composite, dans ce cas les valeurs sont les sous-variables de la variable composite. Pour cela, il faut utiliser le code de cette variable suivi de .entrySet(). La variable temporaire est composée de 2 données :

• variable_temporaire.key qui représente le code la sous-variable
• variable_temporaire.value qui représente la sous-variable

foreach (variable_temporaire : code_variable_composite.entrySet()) {
    instructions qui utilisent variable_temporaire qui représente la valeur d'une sous-variable
}

info

Il est possible de remplacer le mot-clé foreach par for.

Exemples

somme = 0;
for (item : MA_VARIABLE_MULTIPLE) {
    // on accumule dans la variable temporaire somme 
    // les valeurs des instances de MA_VARIABLE_MULTIPLE
    somme += item.value;
}

texte = "";
for (item : MA_VARIABLE_COMPOSITE.entrySet()) {
    // on accumule dans la variable temporaire texte 
    // les codes des sous-variables de MA_VARIABLE_COMPOSITE
    somme += item.key + ", ";
}

Boucle for

La boucle for permet également d'exécuter en boucle un ensemble d'instructions selon la syntaxte :

for (initialisation; terminaison; increment) {
    // code à répéter
}

Exemple

// Calcul factorielle de MA_VARIABLE
f = 1;
for (int i = 1; i <= MA_VARIABLE.value; i++) {
    f = f * i;
}
return f;