Diese Dokumentation ist für Modellierer bestimmt, die die OCL -Sprachen von Objekten verwenden. Eine detaillierte Dokumentation für Sprachingenieure, die die OCL -Sprache verwenden oder erweitern, finden Sie hier . Wir empfehlen den Sprachingenieuren, diese Dokumentation zu lesen, bevor wir die detaillierte Dokumentation lesen.
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;
}
Weitere Expressionsbeispiele (einschließlich Monticore's Commonexpressions):
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
Die textuelle OCL -Darstellung beruht hauptsächlich auf der Definition in [Rum16, Rum17]. OCL wird verwendet, um die Richtigkeit anderer Modelle zu überprüfen. Hier werden die Book und Customer beispielsweise durch ein Klassendiagramm definiert:
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];
}
In diesem Abschnitt wird das Befehlszeilen -Tool der OCL -Sprache beschrieben. Das Tool bietet typische Funktionen, die bei Verarbeitungsmodellen verwendet werden. Zu diesem Zweck bietet es Funktionen für Funktionen für
Die Anforderungen an das Erstellen und die Verwendung des OCL -Tools sind, dass (mindestens) JDK 8 (JDK 11 und JDK 14 ebenfalls offiziell von uns unterstützt werden), Git und Gradle installiert und zur Verwendung in Bash verfügbar sind. Wenn Sie Docker verwenden, können Sie auch den Docker -Container verwenden, ohne Java, Git oder Gradle zu installieren.
Der folgende Unterabschnitt beschreibt, wie das Tool heruntergeladen wird. In diesem Dokument wird dann beschrieben, wie das Tool aus den Quelldateien erstellt wird. Danach enthält dieses Dokument ein Tutorial für die Verwendung des Tools.
Eine fertige Version des Tools kann in Form einer ausführbaren JAR -Datei heruntergeladen werden. Sie können diesen Download -Link zum Herunterladen des Tools verwenden.
Alternativ können Sie das Tool mit wget herunterladen. Der folgende Befehl lädt die neueste Version des Tools herunter und speichert sie unter dem Namen MCOCL.jar in Ihrem Arbeitsverzeichnis:
wget "monticore.de/download/MCOCL.jar" -O MCOCL.jar
Die neueste Version des Docker -Bilds des Tools kann verwendet werden
docker pull monticore/ocl
Wenn Sie Docker verwenden, ersetzen Sie java -jar MCOCL.jar im Folgenden durch (für Windows PowerShell, Mac Terminal oder Linux Bash)
docker run --rm -v ${PWD}:/input -w /input monticore/ocl
oder (für Windows -Befehlszeile)
docker run --rm -v %CD%:/input -w /input monticore/ocl
Zum Beispiel dieser Befehl aus Schritt 2 dieses Tutorials
java -jar MCOCL.jar -i Example.ocl -pp
wird
docker run --rm -v ${PWD}:/input -w /input monticore/ocl -i Example.ocl -pp
Bei Verwendung von Docker.
Es ist möglich, ein ausführbares Glas des Tools aus den Quelldateien in GitHub zu erstellen. Im Folgenden wird der Prozess zum Erstellen des Tools aus den Quelldateien mithilfe von BASH beschrieben. Führen Sie die folgenden Befehle aus.
Klonen Sie zunächst das Repository:
git clone https://github.com/MontiCore/ocl.git
Ändern Sie das Verzeichnis in das Stammverzeichnis der geklonten Quellen:
cd OCL
Erstellen Sie dann das Projekt durch Ausführen (Info: Sie müssen dafür Gradle installieren lassen):
gradle build
Glückwunsch! Sie finden nun die ausführbare JAR -Datei MCOCL.jar im Verzeichnisziel target/libs in den über cd target/libs ).
In den vorherigen Abschnitten wird beschrieben, wie Sie eine ausführbare JAR -Datei (OCL -Befehlszeilen -Tool) erhalten. Dieser Abschnitt enthält ein Tutorial für die Verwendung des OCL -Tools. In den folgenden Beispielen geht davon aus, dass Sie das Tool MCOCL lokal benannt haben. Wenn Sie das Tool aus den Quellen erstellen oder den obigen wget -Befehl verwenden, ist es Ihnen gut. Wenn Sie das Tool manuell heruntergeladen haben, sollten Sie in Betracht ziehen, das heruntergeladene Glas umzubenennen.
Das Ausführen der JAR -Datei ohne Optionen druckt Nutzungsinformationen der
Werkzeug zur Konsole:
$ 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.
Um ordnungsgemäß zu funktionieren, benötigt das Tool das obligatorische Argument -i,--input <file> , das die Dateipfade von mindestens einer Eingabedatei mit SD-Modellen enthält. Wenn keine anderen Argumente angegeben werden, analysiert das Tool ausschließlich die Modell (en).
Kopieren Sie den MCOCL.jar in ein Verzeichnis Ihrer Wahl. Erstellen Sie anschließend die folgende einfache OCL enthalten:
ocl Example {
}
Speichern Sie die Textdatei als Example.ocl im Verzeichnis, in dem sich MCOCL.jar befindet.
Führen Sie nun den folgenden Befehl aus:
java -jar MCOCL.jar -i Example.ocl
Sie können feststellen, dass das Werkzeug keine Ausgabe in die Konsole druckt. Dies bedeutet, dass das Tool das Example.ocl erfolgreich analysiert hat.
Das Tool bietet einen hübschen Drucker für die OCL-Sprache. Ein hübscher Drucker kann, z. B. die Behebung der Formatierung von Dateien mit OCL, verwendet werden. Um den hübschen Drucker auszuführen, kann die Option -pp,--prettyprint Option verwendet werden. Verwenden der Option ohne Argumente hübsches Zeichnen die in den Eingabedateien in der Konsole enthaltenen Modelle.
Führen Sie den folgenden Befehl aus, um dies auszuprobieren:
java -jar MCOCL.jar -i Example.ocl -pp
Der Befehl druckt das in der Eingabedatei enthaltene hübsche Modell in der Konsole:
ocl Example {
}
Es ist möglich, die in den Eingabedateien enthaltenen Modelle für Ausgabedateien ziemlich abzudrücken. Für diese Aufgabe ist es möglich, die Namen von Ausgabedateien als Argumente für die Option -pp,--prettyprint zu liefern. Wenn Argumente für Ausgabedateien bereitgestellt werden, muss die Anzahl der Ausgabedateien der Anzahl der Eingabedateien entsprechen. Die I-te-Eingabedatei ist in der I-te-Ausgabedatei ziemlich gedruckt.
Führen Sie den folgenden Befehl aus, um dies auszuprobieren:
java -jar MCOCL.jar -i Example.ocl -pp Output.ocl
Der Befehl druckt das in der Eingabedatei enthaltene hübsche Modell in der Output.ocl .
Für die Überprüfung der Kontextbedingungen kann die Option -c,--coco <arg> -Aption verwendet werden. Die Verwendung dieser Option ohne Argumente prüft, ob das Modell alle Kontextbedingungen erfüllt.
Wenn Sie nur daran interessiert sind, zu überprüfen, ob ein Modell nur eine Teilmenge der Kontextbedingungen erfüllt oder ob alle Kontextbedingungen überprüft werden möchten, können Sie dies tun, indem Sie zusätzlich eines der drei Argumente intra , inter und type bereitstellen.
intra die Kontextbedingungen in Bezug auf Verstöße gegen die intra-modellischen Kontextbedingungen aus. Diese Kontextbedingungen überprüfen beispielsweise die Namenskonventionen.inter wird alle intra-modellischen Kontextbedingungen ausgeführt und überprüft, ob Typnamen in Konstruktorsignaturen definiert sind.type führt alle Kontextkonditionen aus. Diese Kontextbedingungen umfassen die Überprüfung, ob verwendete Typen und Methoden vorhanden sind. Das Verhalten bei der Verwendung des type ist gleich dem Standardverhalten, wenn keine Argumente verwendet werden.Führen Sie den folgenden Befehl aus, um ein einfaches Beispiel auszuprobieren:
java -jar MCOCL.jar -i Example.ocl -c -cd4c
Sie können feststellen, dass das Tool bei der Ausführung dieses Befehls nichts in die Konsole druckt. Dies bedeutet, dass das Modell alle Kontext -Konditionen erfüllt.
Betrachten wir nun ein komplexeres Beispiel. Erinnern Sie sich an die OCL Bookshop aus dem Abschnitt An Example Model oben. Kopieren Sie die textuelle Darstellung des OCL Bookshop und speichern Sie sie in einem Datei Bookshop.ocl in dem Verzeichnis, in dem sich die Datei MCOCL.jar befindet. Zu diesem Zweck benötigen Sie eine Symboldatei, die die Symbole eines Klassendiagramms enthält, das dem Bookshop.ocl entspricht. Dies wird im folgenden Abschnitt ausführlicher erläutert. Fügen Sie dem Befehl vorerst nur -p src/test/resources/docs/Bookshop/ -cd4c hinzu, um das Tool zu verwenden, wo die für dieses Beispiel vorbereitete Symboldatei und die Verarbeitung erstellt werden soll.
Sie können die verschiedenen Arten von Kontextbedingungen unter Verwendung der Option -c,--coco <arg> überprüfen:
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
Keiner dieser Befehle sollte Ausgabe erzeugen.
Um einen Fehler zu sehen, können Sie dem Modell einen Fehler hinzufügen. Ersetzen Sie diese Zeile in Bookshop.ocl
{ book | Book book in booksInStock, book.iban == iban }
von
{ book2 | Book book in booksInStock, book.iban == iban }
Wenn book2 undefiniert ist, sollte das Tool jetzt eine Fehlermeldung bei der Überprüfung der Cocos ausdrucken:
$ 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
Bitte denken Sie daran, den "Fehler" rückgängig zu machen.
In diesem Abschnitt verwenden wir den Symbolpfad und geben dem Tool eine Symboldatei (gespeicherte Symboltabelle) eines anderen Modells an, das die erforderlichen Typinformationen enthält.
Erstellen Sie ein neues Verzeichnis mytypes im Verzeichnis, in dem sich das Werkzeug MCOCL.jar befindet. Beispielsweise erforderte das Beispiel für Bookshop.ocl . Sie finden diese Klassendiagrammdatei unter src/test/ressourcen/docs/bookshop/bookshop.cd.
Um es in OCL zu verwenden, müssen Sie zuerst eine Symboldatei konvertieren. Die Symboldatei Bookshop.sym des Klassendiagramms enthält alle erforderlichen Typinformationen, um ihre Typen in OCL zu verwenden. Wenn Sie sich zu diesem Zeitpunkt nicht mit dem CD-Tool beschäftigen möchten, finden Sie auch die fertige Datei unter src/test/ressourcen/docs/bookshop/bookshop.sym. Kopieren Sie es einfach in Ihren mytypes -Ordner. Um das Klassendiagramm in eine Symboldatei umzuwandeln, müssen Sie den MCCD.jar aus dem CD4analyse -Projekt verwenden und die Klassendiagrammdatei mit dem folgenden Befehl konvertieren:
java -jar MCCD.jar -d false --fieldfromrole navigable -i src/test/resources/docs/Bookshop/Bookshop.cd -s mytypes/Bookshop.sym
Der Inhalt der Symboldatei ist für Sie als Sprachbenutzer von geringer Bedeutung. Falls Sie neugierig sind und einen Blick in die Symboldatei betrachten: Die Symboldatei enthält eine JSON -Darstellung der in einem Modell definierten Symbole. In diesem Fall enthält die Symboldatei Informationen zu definierten Typen. Normalerweise generieren die Tools von Monticore -Sprachen automatisch den Inhalt dieser Dateien und Sie als Sprachbenutzer nicht mit ihrem Inhalt beteiligt sein.
Der Pfad, der die Verzeichnisstruktur enthält, die die Symboldatei enthält, wird als "Symbolpfad" bezeichnet. Wenn wir den Symbolpfad zum Tool bereitstellen, sucht er in Symboldateien nach Symbolen, die in Verzeichnissen gespeichert sind, die im Symbolpfad enthalten sind. Wenn wir also möchten, dass das Tool unsere Symboldatei findet, müssen wir den Modellpfad zum Tool über die Option --path <directory> zur Verfügung stellen. Sie können das mit dem gerade erstellten mytypes -Ordner ausprobieren:
java -jar MCOCL.jar -i Bookshop.ocl --path <SYMBOLPATH> -c type -cd4c
Wo <SYMBOLPATH> der Pfad ist, auf dem Sie die heruntergeladene Symboldatei gespeichert haben. In unserem Beispiel, falls Sie das Modell im Verzeichnis mytypes gespeichert haben, führen Sie den folgenden Befehl aus:
java -jar MCOCL.jar -i Bookshop.ocl --path mytypes -c type -cd4c
Beachten Sie, dass dieser Befehl auch das Flag -cd4c verwendet. Um die dem OCL -Tool zur Verfügung gestellten Symbolfolfolfile zu interpretieren, muss verstehen, wie die vom CD -Tool gespeicherten Symbole interpretiert werden können. Das -cd4c -Flag ist eine Abkürzung dafür für CD4Code. Sie können es auch manuell tun, indem Sie die Flaggen von --typeSymbol , --functionSymbol und --variableSymbol verwenden, gefolgt von den Symbolsorten, die als TypeSymbol , FunctionSymbol und VariableSymbol interpretiert werden sollten:
java -jar MCOCL.jar -i Bookshop.ocl --path mytypes -c type --typeSymbol <TYPE_SYMBOL_KINDS> --variableSymbol <VAR_SYMBOL_KINDS> --functionSymbol <FUNC_SYMBOL_KINDS>
wobei <TYPE_SYMBOL_KINDS> , <VAR_SYMBOL_KINDS> und <FUNC_SYMBOL_KINDS> die vollständig qualifizierten Namen der Symbole sind. Wenn Sie mehrere Symboltypen bereitstellen möchten, fügen Sie sie einfach durch einen Raum getrennt hinzu. In unserem Beispiel würde die Erklärung der Symbole aus der CD4analyse wie folgt aussehen:
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
Beachten Sie, dass das Tool jetzt viele Warnungen für Symbole erzeugt, die nicht interpretiert werden konnten. Nicht jedes Symbol einer unterschiedlichen Sprache könnte in OCL interessant sein. Um diese unbeabsichtigten Warnungen zu unterdrücken, können Sie das OCL -Tool erkennen, für welche Symbol -Arten Sie sie nicht mit der Option --ignoreSymKind <SYM_KINDS_TO_IGNORE> empfangen möchten. In unserem Beispiel würde dies so aussehen:
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
Für den täglichen Gebrauch ist dies etwas kompliziert. Denken Sie also daran, dass das Flag -cd4c dies nur auf nur reduzieren kann
java -jar MCOCL.jar -i Bookshop.ocl --path mytypes -c type -cd4c
Der vorherige Abschnitt beschreibt, wie Symbole aus einer vorhandenen Symboldatei geladen werden. Jetzt werden wir das Tool verwenden, um eine Symboldatei für unser Bookshop.ocl -Modell zu speichern. Die gespeicherte Symboldatei enthält Informationen zu den in der OCL -Datei definierten Objekten. Es kann von anderen Modellen für die Verwendung der Symbole importiert werden, die durch diese Objektdefinitionen eingeführt wurden, ähnlich wie wir die Datei Bookshop.ocl geändert Bookshop.sym .
Mit der Option -s,-symboltable <file> erstellt die Symboltabellen der Eingabemodelle und speichert sie in den als Argumenten angegebenen Dateipfade. Entweder darf für jedes Eingabemodell keine Dateipfade bereitgestellt werden oder genau ein Dateipfad muss bereitgestellt werden. Die Symboldatei für das I-te-Eingabemodell wird in der Datei gespeichert, die durch den I-TH-Dateipfad definiert ist. Wenn Sie keine Dateipfade angeben, speichert das Tool die Symboltabelle jedes Eingabemodells im Symbol target/symbols/{packageName}/{fileName}.oclsym wobei packageName der Name des Pakets wie in der Datei enthalten angegeben ist Das Modell und fileName sind der Name der Datei, die das Modell enthält. Die Datei ist relativ zum Arbeitsverzeichnis gespeichert, dh dem Verzeichnis, in dem Sie den Befehl zum Speichern der Symboldateien ausführen. Bitte beachten Sie außerdem, dass das Modell in allen Grüßen gut geformt werden muss, um die Symbole richtig zu speichern, und daher alle Kontextbedingungen zuvor überprüft werden.
Führen Sie den folgenden Befehl aus, um die Symboldatei von Bookshop.ocl zu speichern (die implizite Kontextbedingungsüberprüfungen erfordern die Verwendung der Symbolpfadoption):
java -jar MCOCL.jar -i Bookshop.ocl --path mytypes -cd4c -s
Das Tool erzeugt das target/symbols/docs/Bookshop.oclsym , das jetzt von anderen Modellen, z. B. von Modellen, die einige der im OCL -Datei Bookshop definierten Objekte verwenden müssen, importiert werden können.
Führen Sie beispielsweise den folgenden Befehl aus, um die Symboldatei von Bookshop.ocl in der Datei syms/Bookshop.oclsym zu speichern (erneut die Überprüfung der impliziten Kontextbedingungen erfordern die Option Symbol Pfad):
java -jar MCOCL.jar -i Bookshop.ocl -path mytypes -cd4c -s syms/Bookshop.oclsym
Herzlichen Glückwunsch, Sie haben gerade das Tutorial zum Speichern von SD -Symboldateien abgeschlossen!
