OCL Cheat Sheet

OCL 2.0 CheatSheet
Integer / Real
a,b : Integer/Real;
Notazioni:
i,j : Integer;
RT = Integer/Real
S,T : OclType; St : OclState;
Tipi Base
Tipi Collection
S/B ::= Set(T) | Bag(T) ;
Uguaglianze
a=b : Boolean
Uguaglianza
Integer
Set
OS/Sq ::= OrderedSet(T) | Sequence(T)
a<>b : Boolean
Disuguaglianza
Real
Bag
Disuguaglianze
a<b : Boolean
Minoranza stretta
TExp /TExpB /SExp ::= espressioni OCL di tipo T/T/S String
OrderedSet
a>b : Boolean
Maggioranza stretta
sse=iff
Boolean
Sequence
a<=b : Boolean
Minoranza debole
a>=b : Boolean
Maggioranza debole
Tutti gli Oggetti
a,b : OclAny;
Op. Algebriche
a+b : RT
Somma
Uguaglianze
a=b : Boolean
Uguaglianza
a*b : RT
Prodotto
a<>b : Boolean
Disuguaglianza
a-b : RT
Differenza
Stati e Istanze
a.oclIsTypeOf(T) : Boolean
True sse a : T
a/b : Real
Divisione reale
a.oclIsKindOf(T) : Boolean
True sse a : S, con S=T o S derivato di T
-a : RT
Passaggio al reciproco
a.oclIsInState(St) : Boolean
True sse a e' nello stato ST
Altre Operazioni
a.abs() : RT
Valore assoluto
a.oclIsNew() : Boolean
True sse a e' stato appena creato (solo
a.max(b) : RT
Massimo tra a e b
nelle postcondizioni)
a.min(b) : RT
Minimo tra a e b
a.oclIsInvalid() : Boolean
True sse a : OclInvalid
a.floor() : Integer
Parte intera di a
a.oclIsUndefined() : Boolean
True sse a.oclIsInvalid() oppure a=null
a.ceil() : Integer
Piu' piccolo intero maggiore di a
T.allInstances() : Set(T)
Insieme di tutte le istanze del tipo T
a.round() : Integer
Numero intero piu' vicino ad a
Cast
a.oclAsType(T) : T
Cast di a al tipo T
Divisione Intera
i.div(j) : Integer
Divisione intera
i.mod(j) : Integer
Resto della divisione intera
String
s,t : String;
lower,upper : Integer
Boolean
a,b : Boolean
Op. elementari
s.size() : Integer
Lunghezza
Op. Unarie
not a : Boolean
Negazione logica
s.concat(t) : String
Concatenazione di s e t
Op. Binarie
a and b : Boolean
And logico
s.substring( lower, upper ) :
Sottostringa con estremi i
a or b : Boolean
Or logico
String
caratteri in posizione lower e upper
a xor b : Boolean
Or logico esclusivo
Parsing
s.toReal() : Real
Parsing di s e conversione a Real
a implies b : Boolean
Implicazione logica (if a then b)
s.toInteger() : Integer
Parsing di s e conversione a Integer
a <=> b
Congruenza logica (a iff b)
Collection(T)
c,d : Collection(T); o : T
Uguaglianze
c=d : Boolean
Uguaglianza (i criteri dipendono dalla particolare specializzazione di Collection)
c<>d : Boolean
Disuguaglianza
Dimensioni
c.size() : Integer
Numero di elementi
c.isEmpty() : Boolean
True sse c e' vuota
c.notEmpty() : Boolean
True sse c non e' vuota
Appartenenza
c.includes(o) : Boolean
True sse o appartiene a c
c.excludes(o) : Boolean
True sse o non appartiene a c
c.includesAll(d) : Boolean
True sse ogni elemento di d appartiene a c
c.excludesAll(d) : Boolean
True sse nessun elemento di d appartiene a c
Conversioni
c.asSet() : Set(T)
Conversione (non cast) della collezione a Set
c.asBag() : Bag(T)
Conversione (non cast) della collezione a Bag
c.asOrderedSet() : OrderedSet(T)
Conversione (non cast) della collezione a OrderedSet
c.asSequence() : Sequence(T)
Conversione (non cast) della collezione a Sequence
Altre Operazioni
c.sum() : T
Somma di tutti gli elementi di c (T(+) deve essere gruppo commutativo)
c.count(o) : Integer
Numero di occorrenze di o in c

c.flatten() : Collection(S)
Se T=Collection(S), la collezione di tutti gli elementi delle sottocollezioni, self altrimenti
Operazioni Iterative
c->exists( iterators | boolExp ) : Boolean
True sse boolExp e' vera per almeno un elemento
c->forall( iterators | boolExp ) : Boolean
True sse boolExp e' vera per ogni elemento
c->isUnique( iterators | body ) : Boolean
True sse elementi differenti danno valutazioni di body differenti
c->one( iterator | boolExp ) : Boolean
True sse esiste un unico elemento per cui boolExp sia vera
c->any( iterator | boolExp ) : T
Un qualsiasi elemento della collezione per cui boolExp sia vera
c->collect( iterator | SExp ) : Bag(S)/Sequence(S)
La Bag/Sequence contenente tutte le valutazioni (flattened) di body per ogni elemento di c
Set / Bag
s,t : Set(T); b : Bag(T); sb : S/B; o: T;
Unione e inserimento
s.union(sb) : S/B
Unione Insiemistica (eventualmente con ripetizioni)
b.union(sb) : Bag(T)
Unione Insiemistica con ripetizioni
sb.including(o) : S/B
Aggiunta dell'elemento o
Intersezione e rimozione
s.intersection(sb) : Set(T)
Intersezione Insiemistica
b.intersection(sb) : S/B
Intersezione Insiemistica (eventualmente con ripetizioni)
sb .excluding(o) : S/B
Rimozione dell'elemento o
s-t : Boolean
Differenza Insiemistica
Operazioni Iterative
sb->select( iterator | boolExp) : S/B
Set/Bag di tutti gli elementi di sb per cui boolExp e' vera
sb->reject( iterator | boolExp) : S/B
Set/Bag di tutti gli elementi di sb per cui boolExp e' false
sb->collectNested( iterator | TExp ) : Bag(T)
Come collect, ma non esegue il flatten()
sb->sortedBy( iterator | body ) : OS/Sq
OrderedSet/Sequence contenente gli elementi di sb ordinati in maniera debolmente crescente
OrderedSet / Sequence
oss : OS/Sq; s,t : Sequence(T); o : T; i : Integer
Inserimento
oss.append(o) : OS/Sq
Aggiunta dell'elemento o in coda
oss.prepend(o) : OS/Sq
Aggiunta dell'elemento o in testa
oss.insertAt(i, o) : OS/Sq
Aggiunta dell'elemento o alla posizione i
oss.including(o) : OS/Sq
Aggiunta in coda di elemento
s.union(t) : Sequence(T)
Concatenazione di s e t
Rimozione
oss.excluding(o) : OS/Sq
Eliminazione di elemento
Accesso
oss.at(i) : T
Accesso all'elemento in posizione i
oss.indexOf(o) : Integer
Indice della prima occorrenza di o
oss.first() : T
Primo elemento
oss.last() : T
Ultimo elemento
Operazioni Iterative
oss->select( iterator | boolExp ) : OS/Sq
OrderedSet/Sequence di tutti gli elementi di sb per cui boolExp e' vera
oss->reject( iterator | boolExp ) : OS/Sq
OrderedSet/Sequence di tutti gli elementi di sb per cui boolExp e' false
oss->collectNested( iterator | TExp ) : Sequence(T)
Come collect, ma non esegue il flatten()
oss->sortedBy( iterator | body ) : OS/Sq
OrderedSet/Sequence contenente gli elementi di sb ordinati in maniera debolmente crescente
Costrutti del linguaggio
Self
'self'
Riferimento alla classe corrente
Constraints
'context' [name ':' ] class 'inv:' boolExp
Definizione di un invariante per la classe class
'context' class ::’ op’(' params ')’ [ ‘:’ T ] 'pre:' boolExp
Precondizione per l'operazione op della classe class
'context' class ‘::’ op’(' params ')’ [ ‘:’ T ] 'post:' boolExp
Postcondizione per l'operazione op della classe class
'context' class ‘::’ op’(' params ')’ [ ‘:’ T ] 'body:' Texp
Corpo dell'operazione op della classe class
'context' class ‘::’ attr ‘:’ T 'derive' TExp
Definisce il valore dell' attributo composto/ association end attr
'context' class 'def' name ‘:’ T '=' TExp
Definisce name all'interno della classe come il valore di Texp
Let, If, @pre
'let' name ':' T '=' TExp 'in' body
Definisce name all'interno di body
'if' boolExp 'then' TExp 'else' TExpB 'endif'
Se boolExp e' vera, allora TExp, altrimenti TExp2
class '::' attr'@pre'
Nelle postcondizioni, usato per riferirsi al valore dell'attributo class::attr prima dell'operazione
class '::' op'@pre'('params')'
Nelle postcondizioni, usato per riferirsi al valore di ritorno di class::op prima dell'operazione
class '::' ass'@pre'
Nelle postcondizioni, usato per riferirsi al valore dell'associazione class::ass prima dell'operazione

---