Esta documentação é destinada a modeladores que usam os idiomas Object OCL. Uma documentação detalhada para engenheiros de idiomas que usam ou estendendo o idioma OCL está localizada aqui . Recomendamos que os engenheiros de idiomas leiam esta documentação antes de ler a documentação detalhada.
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;
}
Outros exemplos de expressão (incluindo o Monticore 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
A representação textual da OCL depende principalmente da definição em [rum16, rum17]. OCL é usado para verificar a correção de outros modelos. Aqui, o Book e os tipos Customer são, por exemplo, definidos por um diagrama 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];
}
Esta seção descreve a ferramenta de linha de comando do idioma OCL. A ferramenta fornece funcionalidade típica usada ao processamento de modelos. Para este efeito, fornece funcionalidade para
Os requisitos para a construção e o uso da ferramenta OCL são que (pelo menos) JDK 8 (JDK 11 e JDK 14 também são oficialmente apoiados por nós), Git e Gradle estão instalados e estão disponíveis para uso em Bash. Se você estiver usando o Docker, também poderá usar o contêiner do Docker sem instalar Java, Git ou Gradle.
A subseção a seguir descreve como baixar a ferramenta. Em seguida, este documento descreve como criar a ferramenta a partir dos arquivos de origem. Posteriormente, este documento contém um tutorial para usar a ferramenta.
Uma versão pronta para uso da ferramenta pode ser baixada na forma de um arquivo JAR executável. Você pode usar este link para download para baixar a ferramenta.
Como alternativa, você pode baixar a ferramenta usando wget . O comando a seguir baixar a versão mais recente da ferramenta e a salva sob o nome MCOCL.jar em seu diretório de trabalho:
wget "monticore.de/download/MCOCL.jar" -O MCOCL.jar
A versão mais recente da imagem do docker da ferramenta pode ser obtida usando
docker pull monticore/ocl
Caso você esteja usando o Docker, substitua java -jar MCOCL.jar no seguinte por (para Windows PowerShell, Mac Terminal ou Linux Bash)
docker run --rm -v ${PWD}:/input -w /input monticore/ocl
ou (para a linha de comando do Windows)
docker run --rm -v %CD%:/input -w /input monticore/ocl
Por exemplo, este comando da etapa 2 deste tutorial
java -jar MCOCL.jar -i Example.ocl -pp
torna -se
docker run --rm -v ${PWD}:/input -w /input monticore/ocl -i Example.ocl -pp
Ao usar o Docker.
É possível criar um frasco executável da ferramenta a partir dos arquivos de origem localizados no GitHub. A seguir, descreve o processo para criar a ferramenta a partir dos arquivos de origem usando o Bash. Para criar um frasco executável com o Bash a partir dos arquivos de origem disponíveis no GitHub, execute os seguintes comandos.
Primeiro, clone o repositório:
git clone https://github.com/MontiCore/ocl.git
Altere o diretório para o diretório raiz das fontes clonadas:
cd OCL
Em seguida, crie o projeto executando (Info: você precisa instalar o gradle para isso):
gradle build
Parabéns! Agora você pode encontrar o arquivo jar executável MCOCL.jar no Directory target/libs (acessível via cd target/libs ).
As seções anteriores descrevem como obter um arquivo JAR executável (ferramenta de linha de comando OCL). Esta seção fornece um tutorial para usar a ferramenta OCL. Os exemplos a seguir assumem que você nomeou localmente a ferramenta MCOCL . Se você criar a ferramenta a partir das fontes ou usar o comando wget acima, estará bem. Se você baixou manualmente a ferramenta, considere renomear o frasco baixado.
Executar o arquivo jar sem nenhuma opção imprime informações de uso do
ferramenta para o 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.
Para funcionar corretamente, a ferramenta precisa do argumento obrigatório -i,--input <file> , que segue os caminhos do arquivo de pelo menos um arquivo de entrada que contém modelos SD. Se nenhum outro argumento for especificado, a ferramenta analisa apenas o (s) modelo (s).
Para experimentar isso, copie o MCOCL.jar em um diretório de sua escolha. Depois, crie contendo o seguinte OCL simples:
ocl Example {
}
Salve o arquivo de texto como Example.ocl no diretório em que MCOCL.jar está localizado.
Agora execute o seguinte comando:
java -jar MCOCL.jar -i Example.ocl
Você pode notar que a ferramenta não imprime saída no console. Isso significa que a ferramenta analisou o Example.ocl do arquivo.ocl com sucesso.
A ferramenta fornece uma impressora bonita para o idioma OCL. Uma impressora bonita pode ser usada, por exemplo, para corrigir a formatação de arquivos que contêm OCL. Para executar a beira-impressora, a opção -pp,--prettyprint pode ser usada. Usando a opção sem argumentos impressos, os modelos contidos nos arquivos de entrada no console.
Execute o seguinte comando para experimentar o seguinte:
java -jar MCOCL.jar -i Example.ocl -pp
O comando imprime o modelo bastante impresso contido no arquivo de entrada no console:
ocl Example {
}
É possível impressão bonita Os modelos contidos nos arquivos de entrada para produzir arquivos de saída. Para esta tarefa, é possível fornecer os nomes dos arquivos de saída como argumentos para a opção -pp,--prettyprint . Se os argumentos para arquivos de saída forem fornecidos, o número de arquivos de saída deverá ser igual ao número de arquivos de entrada. O arquivo de entrada I-és é bem impresso no i-és de saída.
Execute o seguinte comando para experimentar o seguinte:
java -jar MCOCL.jar -i Example.ocl -pp Output.ocl
O comando imprime o modelo impresso em bastão contido no arquivo de entrada no arquivo Output.ocl .
Para verificar as condições do contexto, a opção -c,--coco <arg> pode ser usada. Usar esta opção sem nenhum argumento verifica se o modelo satisfaz todas as condições de contexto.
Se você estiver interessado apenas em verificar se um modelo satisfaz apenas um subconjunto das condições do contexto ou deseja explicar que todas as condições de contexto devem ser verificadas, você pode fazer isso adicionando adicionalmente um dos três argumentos intra , inter e type .
intra executa apenas condições de contexto relativas a violações das condições de contexto intra-modelo. Essas condições de contexto, por exemplo, verificam convenções de nomeação.inter executa todas as condições de contexto intra-modelo e verifica se o tipo de nomes de tipos nas assinaturas do construtor é definido.type de argumento executa todas as conidições de contexto. Essas condições de contexto incluem verificar se existem tipos e métodos usados. O comportamento ao usar o type argumento é igual ao comportamento padrão ao usar nenhum argumento.Execute o seguinte comando para experimentar um exemplo simples:
java -jar MCOCL.jar -i Example.ocl -c -cd4c
Você pode notar que a ferramenta não imprime nada no console ao executar este comando. Isso significa que o modelo satisfaz todas as condições de contexto.
Vamos agora considerar um exemplo mais complexo. Lembre -se da Bookshop da OCL na seção An Example Model acima. Para continuar, copie a representação textual da Bookshop da OCL e salve -a em um arquivo Bookshop.ocl no diretório em que o arquivo MCOCL.jar está localizado. Para isso, você precisará de um arquivo de símbolos contendo os símbolos de um diagrama de classe correspondente ao Bookshop.ocl . Isso será explicado com mais detalhes na seção a seguir. Por enquanto, basta adicionar -p src/test/resources/docs/Bookshop/ -cd4c ao comando para usar, diga à ferramenta onde encontrar o arquivo de símbolo preparado para este exemplo e como processá -lo.
Você pode verificar os diferentes tipos de condições de contexto, usando a opção -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
Nenhum desses comandos deve produzir saída.
Para ver um erro, vamos adicionar um erro ao modelo. Substitua esta linha em Bookshop.ocl
{ book | Book book in booksInStock, book.iban == iban }
por
{ book2 | Book book in booksInStock, book.iban == iban }
Como book2 é indefinido, a ferramenta agora deve imprimir uma mensagem de erro ao verificar os 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
Lembre -se de desfazer o "erro".
Nesta seção, usamos o caminho do símbolo e fornecemos à ferramenta um arquivo de símbolo (tabela de símbolo armazenada) de outro modelo, que contém as informações de tipo necessário.
Crie um novo diretório mytypes no diretório em que a ferramenta MCOCL.jar está localizada. Por exemplo, o exemplo do Bookshop.ocl da primeira seção exigiu um diagrama de classe que especificou seus tipos de dados. Você pode encontrar este arquivo de diagrama de classe em SRC/Test/Resources/Docs/BookShop/BookShop.cd.
Para usá -lo na OCL, primeiro você precisa converter informações de um arquivo de símbolo. O símbolo Arquivo Bookshop.sym do diagrama de classe fornece todas as informações de tipo necessário para usar seus tipos na OCL. Se você não deseja se envolver com a ferramenta CD neste momento, também pode encontrar o arquivo pronto para uso no SRC/Test/Resources/Docs/BookShop/BookShop.sym. Basta copiá -lo na pasta mytypes . Caso contrário, para converter o diagrama de classe em um arquivo de símbolos, você precisa usar o MCCD.jar no projeto CD4Analysis e converter o arquivo de diagrama de classes usando o seguinte comando:
java -jar MCCD.jar -d false --fieldfromrole navigable -i src/test/resources/docs/Bookshop/Bookshop.cd -s mytypes/Bookshop.sym
O conteúdo do arquivo de símbolo é de menor importância para você como usuário de idioma. Caso você esteja curioso e tenha uma olhada no arquivo de símbolos: o arquivo de símbolos contém uma representação JSON dos símbolos definidos em um modelo. Nesse caso, o arquivo de símbolo contém informações sobre tipos definidos. Geralmente, as ferramentas dos idiomas Monticore geram automaticamente o conteúdo desses arquivos e você, como usuário de idiomas, não deve se preocupar com o conteúdo deles.
O caminho que contém a estrutura do diretório que contém o arquivo de símbolo é chamado de "caminho do símbolo". Se fornecermos o caminho do símbolo para a ferramenta, ele procurará símbolos em arquivos de símbolos, que são armazenados nos diretórios contidos no caminho do símbolo. Portanto, se queremos que a ferramenta encontre nosso arquivo de símbolo, precisamos fornecer o caminho do modelo para a ferramenta através da opção --path <directory> . Você pode tentar isso usando a pasta mytypes que você acabou de criar:
java -jar MCOCL.jar -i Bookshop.ocl --path <SYMBOLPATH> -c type -cd4c
Onde <SYMBOLPATH> é o caminho em que você armazenou o arquivo de símbolo baixado. Em nosso exemplo, se você armazenou o modelo no diretório mytypes , execute o seguinte comando:
java -jar MCOCL.jar -i Bookshop.ocl --path mytypes -c type -cd4c
Observe que este comando também usa o sinalizador -cd4c . Para interpretar os Symbolfiles fornecidos à ferramenta OCL, ele precisa entender como interpretar os símbolos armazenados pela ferramenta CD. O sinalizador -cd4c é uma abreviação para fazer isso para o CD4Code. Você também pode fazê -lo manualmente usando as bandeiras --typeSymbol , --functionSymbol e --variableSymbol , seguidos pelos tipos de símbolos que devem ser interpretados como TypeSymbol , FunctionSymbol e VariableSymbol :
java -jar MCOCL.jar -i Bookshop.ocl --path mytypes -c type --typeSymbol <TYPE_SYMBOL_KINDS> --variableSymbol <VAR_SYMBOL_KINDS> --functionSymbol <FUNC_SYMBOL_KINDS>
Onde <TYPE_SYMBOL_KINDS> , <VAR_SYMBOL_KINDS> e <FUNC_SYMBOL_KINDS> são os nomes totalmente qualificados dos símbolos. Caso você queira fornecer vários tipos de símbolos, basta adicioná -los separados por um espaço. Em nosso exemplo, declarar os símbolos da CD4Analysis seria o seguinte:
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
Observe que a ferramenta agora produz muitos avisos sobre símbolos que não puderam ser interpretados. Nem todo símbolo de uma linguagem diferente pode ser interessante na OCL. Para suprimir esses avisos não intencionais, você pode informar a ferramenta OCL para quais tipos de símbolos você não deseja recebê -los usando a opção --ignoreSymKind <SYM_KINDS_TO_IGNORE> . Em nosso exemplo, isso seria assim:
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
Para uso diário, isso é um pouco complicado. Lembre -se de que o sinalizador -cd4c pode reduzir isso apenas para
java -jar MCOCL.jar -i Bookshop.ocl --path mytypes -c type -cd4c
A seção anterior descreve como carregar símbolos de um arquivo de símbolo existente. Agora, usaremos a ferramenta para armazenar um arquivo de símbolos para o nosso modelo Bookshop.ocl . O arquivo de símbolo armazenado conterá informações sobre os objetos definidos no arquivo OCL. Ele pode ser importado por outros modelos para usar os símbolos introduzidos por essas definições de objetos, semelhante à maneira como alteramos o arquivo Bookshop.ocl para importar os símbolos contidos no símbolo arquivo Bookshop.sym .
O uso da opção -s,-symboltable <file> cria as tabelas de símbolos dos modelos de entrada e as armazena nos caminhos de arquivo fornecidos como argumentos. Não devem ser fornecidos caminhos de arquivo ou exatamente um caminho de arquivo deve ser fornecido para cada modelo de entrada. O arquivo de símbolo para o modelo de entrada I-és é armazenado no arquivo definido pelo caminho do arquivo i-és. Se você não fornecer caminhos de arquivo, a ferramenta armazena a tabela de símbolos de cada modelo de entrada no arquivo de arquivo de símbolos target/symbols/{packageName}/{fileName}.oclsym onde packageName é o nome do pacote, conforme especificado no arquivo que contém O modelo e fileName é o nome do arquivo que contém o modelo. O arquivo é armazenado em relação ao diretório de trabalho, ou seja, o diretório no qual você executa o comando para armazenar os arquivos de símbolos. Além disso, observe que, para armazenar os símbolos corretamente, o modelo deve ser bem formado em todos os aspectos e, portanto, todas as condições de contexto são verificadas com antecedência.
Para armazenar o arquivo de símbolo do Bookshop.ocl , execute o seguinte comando (as verificações implícitas de condição de contexto requerem o uso da opção Path Symbol):
java -jar MCOCL.jar -i Bookshop.ocl --path mytypes -cd4c -s
A ferramenta produz o arquivo de arquivo target/symbols/docs/Bookshop.oclsym , que agora pode ser importado por outros modelos, por exemplo, por modelos que precisam usar alguns dos objetos definidos na Bookshop de arquivos da OCL.
Para armazenar o arquivo de símbolos do Bookshop.ocl no arquivo syms/Bookshop.oclsym , por exemplo, execute o seguinte comando (novamente, as verificações implícitas de condição de contexto requerem o uso da opção de caminho do símbolo):
java -jar MCOCL.jar -i Bookshop.ocl -path mytypes -cd4c -s syms/Bookshop.oclsym
Parabéns, você acabou de terminar o tutorial sobre a economia de arquivos de símbolo SD!
