Aller au contenu principal
Version: Next

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;