Cette documentation est destinée aux modélisateurs qui utilisent les langages OCL objet. Une documentation détaillée pour les ingénieurs linguistiques utilisant ou l'extension du langage OCL se trouve ici . Nous recommandons aux ingénieurs linguistiques de lire cette documentation avant de lire la documentation détaillée.
ocl Bookshop {
context Shop s inv CustomerPaysBeforeNewOrder: // invariant
forall Customer c in s.customers: // quantifiers available
c.allowedToOrder implies !exists Invoice i in s.invoices:
i.buyer == c && i.moneyPayed < i.invoiceAmount ;
// Method specification for selling a book
context Invoice Stock.sellBook(String iban, int discountPercent, Customer c)
let availableBooks = // set comprehension
{ book | Book book in booksInStock, book.iban == iban }
pre: !availableBooks.isEmpty && // precondition
c.allowedToOrder;
post: let discount = (100 - discountPercent)/100; // postcondition, let
b = result.soldBook // result variable
in
!(b isin booksInStock) &&
booksInStock.size@pre == booksInStock.size + 1 && // @pre
result.invoiceAmount == b.price * discount;
}
D'autres exemples d'expression (y compris les commonexpressions de Monticore):
a + 3*4; // number expressions
a >= b; a < 3; a == "myName"; // equalities
b implies (c && a) || d; // boolean expressions
forall a in S: foo(a) > 3; // quantifiers
exists a in S: foo(a) > 3;
a ?== b; c ?<= d // elvis operators (dealing with optionals)
S.first; S.size; S.addAll(T); // 30 operators for Lists
a in S; S.add(a); // + more for Sets
max(S) > 3; // + more for numbers
La représentation textuelle de l'OCL repose principalement sur la définition de [Rum16, Rum17]. OCL est utilisé pour vérifier l'exactitude des autres modèles. Ici, les types Book et Customer sont, par exemple, définis par un diagramme de classe:
classdiagram Bookshop {
class Book {
String name;
String iban;
double cost;
double price;
}
class Shop;
association [1] Shop -> (invoices) Invoice [*];
association [1] Shop -> (customers) Customer [*];
class Stock {
void addBook(Book b);
Invoice sellBook(Book bookToSell, int discountPercent, Customer buyer);
}
association [1] Stock -> (booksInStock) Book [*];
class Customer {
String name;
String phoneNumber;
int customerNumber;
boolean allowedToOrder;
void payInvoice(double moneyWired, Invoice invoice);
}
class Invoice {
int invoiceNumber;
double invoiceAmount;
double moneyPayed;
}
association [1] Invoice <-> (buyer) Customer [1];
association [1] Invoice <-> (soldBook) Book [1];
}
Cette section décrit l'outil de ligne de commande de la langue OCL. L'outil offre des fonctionnalités typiques utilisées lors du traitement des modèles. À cet effet, il fournit une fonction de fonctionnalité pour
Les exigences pour construire et utiliser l'outil OCL sont que (au moins) JDK 8 (JDK 11 et JDK 14 sont également officiellement soutenus par nous), Git et Gradle sont installés et disponibles pour une utilisation dans Bash. Si vous utilisez Docker, vous pouvez également utiliser le conteneur Docker sans installer Java, Git ou Gradle.
La sous-section suivante décrit comment télécharger l'outil. Ensuite, ce document décrit comment construire l'outil à partir des fichiers source. Ensuite, ce document contient un tutoriel pour l'utilisation de l'outil.
Une version prête à l'usage de l'outil peut être téléchargée sous la forme d'un fichier JAR exécutable. Vous pouvez utiliser ce lien de téléchargement pour télécharger l'outil.
Alternativement, vous pouvez télécharger l'outil à l'aide de wget . La commande suivante télécharge la dernière version de l'outil et l'enregistre sous le nom de MCOCL.jar dans votre répertoire de travail:
wget "monticore.de/download/MCOCL.jar" -O MCOCL.jar
La dernière version de l'image Docker de l'outil peut être obtenue en utilisant
docker pull monticore/ocl
Dans le cas où vous utilisez Docker, remplacez java -jar MCOCL.jar dans ce qui suit par (pour Windows PowerShell, Mac Terminal ou Linux Bash)
docker run --rm -v ${PWD}:/input -w /input monticore/ocl
ou (pour la ligne de commande Windows)
docker run --rm -v %CD%:/input -w /input monticore/ocl
Par exemple, cette commande de l'étape 2 de ce tutoriel
java -jar MCOCL.jar -i Example.ocl -pp
devient
docker run --rm -v ${PWD}:/input -w /input monticore/ocl -i Example.ocl -pp
Lorsque vous utilisez Docker.
Il est possible de créer un pot exécutable de l'outil à partir des fichiers source situés dans GitHub. Ce qui suit décrit le processus de création de l'outil à partir des fichiers source à l'aide de bash. Pour construire un pot exécutable avec bash à partir des fichiers source disponibles dans GitHub, exécutez les commandes suivantes.
Tout d'abord, clonez le référentiel:
git clone https://github.com/MontiCore/ocl.git
Changer le répertoire en répertoire racine des sources clonées:
cd OCL
Ensuite, créez le projet en fonctionnant (Info: vous devez installer Gradle pour cela):
gradle build
Félicitations! Vous pouvez désormais trouver le fichier JAR exécutable MCOCL.jar dans le répertoire target/libs (accessible via cd target/libs ).
Les sections précédentes décrivent comment obtenir un fichier JAR exécutable (outil de ligne de commande OCL). Cette section fournit un tutoriel pour utiliser l'outil OCL. Les exemples suivants supposent que vous avez nommé localement l'outil MCOCL . Si vous construisez l'outil à partir des sources ou utilisé la commande wget ci-dessus, vous allez bien. Si vous avez téléchargé manuellement l'outil, vous devriez envisager de renommer le pot téléchargé.
L'exécution du fichier JAR sans aucune option imprime les informations d'utilisation du
outil à la console:
$ java -jar MCOCL.jar
usage: OCLTool
-c,--coco <arg> Checks the CoCos for the input. Optional
arguments are:
-c intra to check only the intra-model CoCos,
-c inter checks also inter-model CoCos,
-c type (default) checks all CoCos.
-cd4c,--cd4code Load symbol kinds from CD4C. Shortcut for loading
CDTypeSymbol as TypeSymbol,
CDMethodSignatureSymbol as FunctionSymbol, and
FieldSymbol as VariableSymbol. Furthermore,
warnings about not deserializing
CDAssociationSymbol and CDRoleSymbol will be
ignored.
-d,--dev Specifies whether developer level logging should
be used (default is false)
-fs,--functionSymbol <fqns> Takes the fully qualified name of one or more
symbol kind(s) that should be treated as
FunctionSymbol when deserializing symbol files.
Multiple symbol kinds should be separated by
spaces.
-h,--help Prints this help dialog
-i,--input <files> Processes the list of OCL input artifacts.
Argument list is space separated. CoCos are not
checked automatically (see -c).
-is,--ignoreSymKind <fqns> Takes the fully qualified name of one or more
symbol kind(s) for which no warnings about not
being able to deserialize them shall be printed.
Allows cleaner outputs. Multiple symbol kinds
should be separated by spaces.
-p,--path <directory> Sets the artifact path for imported symbols.
Directory will be searched recursively for files
with the ending ".*sym" (for example ".cdsym" or
".sym"). Defaults to the current folder.
-pp,--prettyprint <files> Prints the OCL model to stdout or the specified
file(s) (optional). Multiple files should be
separated by spaces and will be used in the same
order in which the input files (-i option) are
provided.
-s,--symboltable <files> Stores the symbol tables of the input OCL
artifacts in the specified files. For each input
OCL artifact (-i option) please provide one
output symbol file (using same order in which the
input artifacts are provided) to store its
symbols in. For example, -i x.ocl y.ocl -s
a.oclsym b.oclsym will store the symbols of x.ocl
to a.oclsym and the symbols of y.ocl to b.oclsym.
Arguments are separated by spaces. If no
arguments are given, output is stored to
'target/symbols/{packageName}/{artifactName}.ocls
ym'.
-ts,--typeSymbol <fqns> Takes the fully qualified name of one or more
symbol kind(s) that should be treated as
TypeSymbol when deserializing symbol files.
Multiple symbol kinds should be separated by
spaces.
-vs,--variableSymbol <fqns> Takes the fully qualified name of one or more
symbol kind(s) that should be treated as
VariableSymbol when deserializing symbol files.
Multiple symbol kinds should be separated by
spaces.
Pour fonctionner correctement, l'outil a besoin de l'argument obligatoire -i,--input <file> , qui prend les chemins de fichier d'au moins un fichier d'entrée contenant des modèles SD. Si aucun autre argument n'est spécifié, l'outil analyse uniquement le ou les modèles.
Pour essayer, copiez le MCOCL.jar dans un répertoire de votre choix. Ensuite, créez en contenant l'OCL simple suivant:
ocl Example {
}
Enregistrez le fichier texte en tant Example.ocl dans le répertoire où se trouve MCOCL.jar .
Exécutez maintenant la commande suivante:
java -jar MCOCL.jar -i Example.ocl
Vous remarquerez peut-être que l'outil n'imprime aucune sortie à la console. Cela signifie que l'outil a analysé le fichier Example.ocl avec succès.
L'outil fournit une assez imprimante pour le langage OCL. Une assez imprimante peut être utilisée, par exemple, pour corriger le formatage des fichiers contenant OCL. Pour exécuter la jolie imprimante, l'option -pp,--prettyprint peut être utilisée. Utilisation de l'option sans arguments impriment les modèles contenus dans les fichiers d'entrée à la console.
Exécutez la commande suivante pour essayer ceci:
java -jar MCOCL.jar -i Example.ocl -pp
La commande imprime le modèle assez imprimé contenu dans le fichier d'entrée de la console:
ocl Example {
}
Il est possible d'imprimer les modèles contenus dans les fichiers d'entrée sur les fichiers de sortie. Pour cette tâche, il est possible de fournir les noms des fichiers de sortie comme arguments à l'option -pp,--prettyprint . Si des arguments pour les fichiers de sortie sont fournis, le nombre de fichiers de sortie doit être égal au nombre de fichiers d'entrée. Le fichier d'entrée du I -th est assez imprimé dans le fichier de sortie i-tème.
Exécutez la commande suivante pour essayer ceci:
java -jar MCOCL.jar -i Example.ocl -pp Output.ocl
La commande imprime le modèle assez imprimé contenu dans le fichier d'entrée dans le fichier Output.ocl .
Pour vérifier les conditions de contexte, l'option -c,--coco <arg> peut être utilisée. L'utilisation de cette option sans aucun argument vérifie si le modèle satisfait à toutes les conditions de contexte.
Si vous êtes seulement intéressé à vérifier si un modèle ne satisfait qu'à un sous-ensemble des conditions de contexte ou si vous souhaitez expliquer que toutes les conditions de contexte doivent être vérifiées, vous pouvez le faire en fournissant en outre l'un des trois arguments intra , inter et type .
intra exécute uniquement les conditions de contexte concernant les violations des conditions de contexte intra-modèle. Ces conditions de contexte, par exemple, vérifient les conventions de dénomination.inter exécute toutes les conditions de contexte intra-modèle et vérifie en outre si les noms de type dans les signatures de constructeur sont définis.type d'argument exécute toutes les coniditions de contexte. Ces conditions de contexte comprennent la vérification si les types et méthodes utilisés existent. Le comportement lors de l'utilisation du type d'argument est l'égal au comportement par défaut lors de l'utilisation d'aucun argument.Exécutez la commande suivante pour essayer un exemple simple:
java -jar MCOCL.jar -i Example.ocl -c -cd4c
Vous remarquerez peut-être que l'outil n'imprime rien à la console lors de l'exécution de cette commande. Cela signifie que le modèle satisfait à toutes les conjets de contexte.
Voyons maintenant un exemple plus complexe. Rappelez-vous la Bookshop OCL de la section An Example Model ci-dessus. Pour continuer, copiez la représentation textuelle de la Bookshop OCL et enregistrez-la dans un fichier Bookshop.ocl dans le répertoire où se trouve le fichier MCOCL.jar . Pour cela, vous aurez besoin d'un fichier de symboles contenant les symboles d'un diagramme de classe correspondant à la Bookshop.ocl . Cela sera expliqué plus en détail dans la section suivante. Pour l'instant, il suffit d'ajouter -p src/test/resources/docs/Bookshop/ -cd4c à la commande pour utiliser l'outil où trouver le fichier de symbole préparé pour cet exemple et comment le traiter.
Vous pouvez vérifier les différents types de conditions de contexte, en utilisant l'option -c,--coco <arg> :
java -jar MCOCL.jar -i Bookshop.ocl -p src/test/resources/docs/Bookshop/ -cd4c -c intra
java -jar MCOCL.jar -i Bookshop.ocl -p src/test/resources/docs/Bookshop/ -cd4c -c inter
java -jar MCOCL.jar -i Bookshop.ocl -p src/test/resources/docs/Bookshop/ -cd4c -c type
Aucune de ces commandes ne devrait produire une sortie.
Pour voir une erreur, ajoutez une erreur au modèle. Remplacez cette ligne dans Bookshop.ocl
{ book | Book book in booksInStock, book.iban == iban }
par
{ book2 | Book book in booksInStock, book.iban == iban }
Comme book2 n'est pas défini, l'outil doit désormais imprimer un message d'erreur lors de la vérification des cocos:
$ java -jar MCOCL.jar -i Bookshop.ocl -p src/test/resources/docs/Bookshop/ -cd4c -c
[INFO] DeriveSymTypeOfExpression package suspected
[ERROR] 0xA0309 Bookshop.ocl:<13,12> Could not calculate type of expression "book2" on the left side of SetComprehension
N'oubliez pas d'annuler «l'erreur».
Dans cette section, nous utilisons le chemin du symbole et fournissons l'outil avec un fichier de symbole (table de symboles stockés) d'un autre modèle, qui contient les informations de type nécessaire.
Créez un nouveau répertoire mytypes dans le répertoire où se trouve l'outil MCOCL.jar . Par exemple, l'exemple Bookshop.ocl de la première section a nécessité un diagramme de classe qui a spécifié ses données. Vous pouvez trouver ce fichier de diagramme de classe sous SRC / Test / Resources / Docs / Bookshop / Bookshop.cd.
Pour l'utiliser dans OCL, vous devez d'abord le convertir des informations sur un fichier de symbole. Le fichier de symbole Bookshop.sym du diagramme de classe fournit toutes les informations de type nécessaire pour utiliser ses types dans OCL. Si vous ne souhaitez pas vous impliquer dans l'outil CD à ce stade, vous pouvez également trouver le fichier prêt à l'emploi sous SRC / Test / Resources / Docs / Bookshop / Bookshop.Sym. Copiez-le simplement dans votre dossier mytypes . Sinon, pour convertir le diagramme de classe en un fichier de symbole, vous devez utiliser le MCCD.jar à partir du projet CD4analysis et convertir le fichier de diagramme de classe à l'aide de la commande suivante:
java -jar MCCD.jar -d false --fieldfromrole navigable -i src/test/resources/docs/Bookshop/Bookshop.cd -s mytypes/Bookshop.sym
Le contenu du fichier de symboles est d'une importance mineure pour vous en tant qu'utilisateur de langue. Dans le cas où vous êtes curieux et que vous avez un aperçu du fichier de symboles: le fichier de symboles contient une représentation JSON des symboles définis dans un modèle. Dans ce cas, le fichier de symboles contient des informations sur les types définis. Habituellement, les outils des langages Monticore génèrent automatiquement le contenu de ces fichiers et vous, en tant qu'utilisateur de langue, ne devez pas vous préoccuper de leur contenu.
Le chemin contenant la structure du répertoire qui contient le fichier de symbole est appelé "chemin de symbole". Si nous fournissons le chemin de symbole vers l'outil, il recherchera des symboles dans des fichiers de symboles, qui sont stockés dans les répertoires contenus dans le chemin de symbole. Ainsi, si nous voulons que l'outil trouve notre fichier de symboles, nous devons fournir le chemin du modèle vers l'outil via l'option de --path <directory> . Vous pouvez essayer cela en utilisant le dossier mytypes que vous venez de créer:
java -jar MCOCL.jar -i Bookshop.ocl --path <SYMBOLPATH> -c type -cd4c
où <SYMBOLPATH> est le chemin où vous avez stocké le fichier de symbole téléchargé. Dans notre exemple, au cas où vous avez stocké le modèle dans le répertoire mytypes , exécutez la commande suivante:
java -jar MCOCL.jar -i Bookshop.ocl --path mytypes -c type -cd4c
Notez que cette commande utilise également l'indicateur -cd4c . Pour interpréter les symbaliles fournies à l'outil OCL, il doit comprendre comment interpréter les symboles stockés par l'outil CD. L'indicateur -cd4c est un raccourci pour le faire pour CD4Code. Vous pouvez également le faire manuellement en utilisant les drapeaux --typeSymbol , --functionSymbol et --variableSymbol suivis des types de symboles qui doivent être interprétés comme TypeSymbol , FunctionSymbol et VariableSymbol :
java -jar MCOCL.jar -i Bookshop.ocl --path mytypes -c type --typeSymbol <TYPE_SYMBOL_KINDS> --variableSymbol <VAR_SYMBOL_KINDS> --functionSymbol <FUNC_SYMBOL_KINDS>
où <TYPE_SYMBOL_KINDS> , <VAR_SYMBOL_KINDS> , et <FUNC_SYMBOL_KINDS> sont les noms entièrement qualifiés des symboles. Si vous souhaitez fournir plusieurs types de symboles, ajoutez-les simplement séparés par un espace. Dans notre exemple, déclarer les symboles de CD4Analyse ressemblerait à ceci:
java -jar MCOCL.jar -i Bookshop.ocl --path mytypes -c type --typeSymbol de.monticore.cdbasis._symboltable.CDTypeSymbol --variableSymbol de.monticore.symbols.oosymbols._symboltable.FieldSymbol --functionSymbol de.monticore.cd4codebasis._symboltable.CDMethodSignatureSymbol
Notez que l'outil produit désormais de nombreux avertissements sur les symboles qui ne pouvaient pas être interprétés. Tous les symboles d'un langage différent ne peuvent pas être intéressants dans l'OCL. Pour supprimer ces avertissements involontaires, vous pouvez dire à l'outil OCL pour les types de symboles que vous ne souhaitez pas les recevoir à l'aide de l'option --ignoreSymKind <SYM_KINDS_TO_IGNORE> . Dans notre exemple, cela ressemblerait à ceci:
java -jar MCOCL.jar -i Bookshop.ocl --path mytypes -c type --typeSymbol de.monticore.cdbasis._symboltable.CDTypeSymbol --variableSymbol de.monticore.symbols.oosymbols._symboltable.FieldSymbol --functionSymbol de.monticore.cd4codebasis._symboltable.CDMethodSignatureSymbol --ignoreSymKind de.monticore.cdassociation._symboltable.CDAssociationSymbol de.monticore.cdassociation._symboltable.CDRoleSymbol
Pour un usage quotidien, c'est un peu compliqué. N'oubliez donc pas que le drapeau -cd4c peut réduire cela à seulement
java -jar MCOCL.jar -i Bookshop.ocl --path mytypes -c type -cd4c
La section précédente décrit comment charger les symboles à partir d'un fichier de symboles existant. Maintenant, nous allons utiliser l'outil pour stocker un fichier de symboles pour notre modèle Bookshop.ocl . Le fichier de symboles stocké contiendra des informations sur les objets définis dans le fichier OCL. Il peut être importé par d'autres modèles d'utilisation des symboles introduits par ces définitions d'objets, similaires à la façon dont nous avons modifié le fichier Bookshop.ocl pour l'importation des symboles contenus dans le fichier de symbole Bookshop.sym .
L'utilisation de l'option -s,-symboltable <file> construit les tables de symbole des modèles d'entrée et les stocke dans les chemins de fichier donnés comme arguments. Aucun chemin de fichier ne doit être fourni, soit exactement un chemin de fichier doit être fourni pour chaque modèle d'entrée. Le fichier de symboles du modèle d'entrée du I -th est stocké dans le fichier défini par le chemin du fichier i -th. Si vous ne fournissez aucun chemin de fichier, l'outil stocke le tableau des symboles de chaque modèle d'entrée dans le fichier de symbole target/symbols/{packageName}/{fileName}.oclsym où packageName est le nom du package comme spécifié dans le fichier contenant Le modèle et fileName sont le nom du fichier contenant le modèle. Le fichier est stocké par rapport au répertoire de travail, c'est-à-dire le répertoire dans lequel vous exécutez la commande pour stocker les fichiers de symbole. De plus, veuillez noter que pour stocker correctement les symboles, le modèle doit être bien formé à tous égards, et donc toutes les conditions de contexte sont vérifiées à l'avance.
Pour stocker le fichier de symboles de Bookshop.ocl , exécutez la commande suivante (les vérifications implicites de la condition de contexte nécessitent en utilisant l'option de chemin de symbole):
java -jar MCOCL.jar -i Bookshop.ocl --path mytypes -cd4c -s
L'outil produit la target/symbols/docs/Bookshop.oclsym , qui peut désormais être importée par d'autres modèles, par exemple, par des modèles qui doivent utiliser certains des objets définis dans la Bookshop du fichier OCL.
Pour stocker le fichier de symboles de Bookshop.ocl dans le fichier syms/Bookshop.oclsym , par exemple, exécutez la commande suivante (encore une fois, les vérifications implicites de condition de contexte nécessitent l'utilisation de l'option de chemin de symbole):
java -jar MCOCL.jar -i Bookshop.ocl -path mytypes -cd4c -s syms/Bookshop.oclsym
Félicitations, vous venez de terminer le tutoriel sur la sauvegarde des fichiers de symboles SD!
