Object Constraint Language (OCL)

• OCL-Spezifikation im UML-Standard
• Zusammenfassung auf dieser Seite (Stand von UML 1.3): www.csci.csusb.edu/dick/samples/ocl.html
• Hier gibt es nochmal ein paar warme Worte: www.klasse.nl/ocl/
• Und hier ein PDF auf dem Stand von 1.4: www.jeckle.de/files/UML1_2/apndxb.pdf
• Für den Fall dass diese Links ungültig werden hier nochmal die gespeicherten Webseiten als Zip (enthält die letzten drei Quellen): OCL.zip

Es gibt zwei Typen von Constraints

• Auf Klassenebene: diese Constraints gelten für Membervariablen der Klasse, und zwar zu jeder zeit während die Klasse existiert (Ausnahme: innerhalb eines Methodenaufrufs dürfen die Bedingungen verletzt werden, nach Abschluss der Methode muss der Zustand aber wieder gültig sein).
  
  Syntax:

  	context Klasse
  	inv: Bedingung 1 
  	inv: Bedingung 2 

• Für Methoden: hier kann pro Methode angegeben werden welche Rahmenbedingungen beim Aufruf der Methode erfüllt sein müssen (Vorbedingung, Schlüsselwort pre) und wie der Rückgabewert oder der Zustand der Klasse zum Methoden-Ende aussieht (Nachbedingung, Schlüsselwort post).
  
  Syntax:

  	context Typename::operationName(parameter1 : Type1, ... ): ReturnType
  	pre: Bedingung 1 
  	pre: Bedingung 2
  	post: Bedingung 3 

Ausdrücke/Operatoren

• Logische Operatoren sind: and, or, xor, implies

   		score > 88.33 and score <= 93.33
  		gender = #female or gender = #male
  		p implies q
  		left xor right
  		next->isEmpty or value <= next.value
  		self.grading and self.questions->size<10
  		p1 <> p2 implies p1.name <> p2.name
  		Student.allInstances->forAll( p1, p2 | p1 <> p2 implies p1.name <> p2.name )

  "implies" bedeutet hier: Wenn die Bedingung vor dem Schlüsselwort gilt, dann gilt implizit auch die zweite Bedingung. Weiteres Beispiel:

  	context Person 
  	inv: self.wife->notEmpty() implies self.wife.gender = Gender::female 

• Relationale Operatoren sind "=", ">", "<", ">=", "<=", "<>"

   		score > 88.33
  		value <= next.value
  		self.questions->size<10

• Die Standard-Rechenoperatoren sind "+", "-", "*" und "/"
• Unäre Operatoren sind "-", "not":

   		-account.value
  		not self.questions->isEmpty

• Literale: Strings, Zahlen:

   		'beeblebrox'
  		42

• Navigations-Operatoren zum Zugriff auf Membervariablen/Operatoren: "." und "->".
  "." greift auf ein Attribut oder eine Operation einer Klasse zu.
  "->" dient für den Zugriff auf Collection-Properties/Operationen.
• Weitere Operationen für den "Real"-Typ (Kommazahl):
  abs() : Real
  floor() : Integer
  round() : Integer
  max(r: Real) : Real
  min (r: Real) : Real
  
• Weitere Operationen für den "Integer"-Typ:
  abs() : Integer
  div(i: Integer) : Integer
  mod(i: Integer) : Integer
  max(i: Integer) : Integer
  min (i: Integer) : Integer
  
• Weitere Operationen für den "String"-Typ:
  size() : Integer
  concat(s: String) : String
  substring(lower: Integer, upper: Integer) : String
  toInteger() : Integer
  toReal () : Real
  

Constraints formulieren

• Jeder Constraint kann optional ein Name gegeben werden, der Name folgt direkt auf das Schlüsselwort inv, pre bzw. post. Beispiel:

  	context Klasse
  	inv  Bedingung1Name: Bedingung 1 
  	inv  Bedingung2Name: Bedingung 2 

• Auf Instanzvariablen oder -methoden kann mit dem Operator self Bezug genommen werden. Beispiel (Alter [=Membervariable iAlter] einer Person soll immer positiv sein):

  	context CPerson
  	inv AlterGroesser0: self.m_iAlter > 0

  Der self-Operator ist optional. Zur Unterscheidung von selbst-definierten Variablen (siehe unten) sollte man ihn allerdings zufügen.
• Assoziationspfaden folgen: Aus einer Assoziation wird bei der Programmierung meist eine Membervariable mit dem Namen der Assoziation. Im Beispiel hat die Person einen Ehepartner, dessen Geschlecht ungleich dem der aktuellen Person sein soll, d.h. in der Person steckt eine Membervariable "partner" vom Typ "CPerson". In diesem Fall hat die Assoziation (und zwar das Ende an der anderen Klasse) den Namen "partner".

  	context CPerson
  	inv GeschlechtPartner: self.m_sGeschlecht <> self.partner.m_sGeschlecht 

Weitere Möglichkeiten

• If-Expression: Für diese Constraint gilt eine von zwei Bedingungen. Welche gewählt wird hängt von einer weiteren Bedingung ab. Beispiel (aus der Definition des NOT-Operators für den primitiven Typ "Boolean"):

  	post:	if self then result = false else result = true endif 

  Hier wird (Post-Constraint) der Rückgabewert des NOT-Operators auf den negierten Wert des Booleschen Werts gesetzt.
  Ein weiteres Beispiel folgt im folgenden Abschnitt.
• Let-Expression: Falls ein Ausdruck mehrmals innerhalb der gleichen Constraint vorkommt, dann kann das Ergebnis dieses Ausdrucks in einer Variablen abgelegt werden, auf die nur innerhalb der Constraint zugegriffen werden kann. Dies geschieht mittels des Schlüsselworts let

  	context	Person
  	inv:	let income : Integer = self.job.salary->sum() in 
  		if isUnemployed then
  			income < 100
  		else
  			income >= 100
  		endif  

  In diesem Beispiel (Invariante für eine Person) soll das Einkommen einer arbeitslosen Person unter 100 liegen, das einer arbeitenden Person über 100. Das Schlüsselwort "in" nach der "let"-Definition gibt an in welchem Ausdruck die Variable "income" gilt.
• Definition beliebiger Variablen: Mittels "def"-Ausdrücken können Variablen oder sogar Operationen definiert werden, die in mehrere Constraints verwendet werden können.

  	context	Person
  	def:	income : Integer = self.job.salary->sum()
  	def:	nickname : String = ’Little Red Rooster’
  	def:	hasTitle(t : String) : Boolean = self.job->exists(title = t) 

  "hasTitle" definiert eine Operation mit einem Parameter "t" vom Typ "String" und hat den Rückgabewert "Boolean". "self.job" führt zu einer Collection, innerhalb dieser wird ein Job mit dem übergebenen Titel gesucht.
  Der Zugriff auf eine so definierte Variable/Operation erfolgt wie auf Membervariablen. Das obige Let-Beispiel nochmal modifiziert:

  	context	Person
  	def:	income : Integer = self.job.salary->sum()
  	inv:	if self.isUnemployed then
  			income < 100
  		else
  			income >= 100
  		endif  

Collections

• OCL bietet drei Arten von Collections, die allesamt vom Typ "Collection" abgeleitet sind
  • Set: Kein Objekt kann doppelt vorkommen:
    Set { 1 , 2 , 5 , 88 }
    Set { 10..24 }
  • Bag: Ein Objekt kann mehrfach vorkommen:
    Bag {1 , 3 , 4, 3, 5 }
    Bag { 10..24 }
  • Sequence: Wie Bag, die Objekte sind allerdings sortiert
    Sequence { 1, 2, 3, 3, 45 }
    Sequence{ 10..24 }
  Jede Collection funktioniert wie Templates aus C++: Der Datentyp der Collection-Elemente wird bei Deklaration von Collections angegeben:
  Collection(Integer): Integer-Collection
  Set (String): Set von String-Werten.
  Ist bei der Deklaration einer Operation der Collection die Angabe des Parametertyps nötig, so wird er als "T" deklariert:
  includes (object: T): Boolean Deklariert einen Parameter namens "object" vom gleichen Typ wie die Objekte in der Collection.
  
  Die OCL-Collections bieten eine Reihe von Properties (siehe folgender Abschnitt), auf diese wird mit dem Pfeil-Operator -> zugegriffen.
  Beispiel: Die Person hat eine Collection von Kindern, "kinder" (Assoziation zur Klasse "CPerson"). Die Methode "UeberweiseKindergeld" benötigt die Bedingung "Person hat Kinder".
  

  	context CPerson::UeberweiseKindergeld(nBetrag : int): void
  	pre KinderVorhanden: self.kinder->size > 0 

• Operationen von "Collection":
  size(): Anzahl von Elementen in der Collection.
  includes (object: T): Boolean Ist das übergebene Objekt "T" in der Collection enthalten ?
  excludes (object: T): Boolean Ist das übergebene Objekt "T" NICHT in der Collection enthalten ?
  includesAll (c2: Collection(T) ): Boolean Sind alle Elemente der übergebenen Collection "c2" in dieser Collection enthalten ?
  excludesAll (c2: Collection(T) ): Boolean Ist keines der Elemente der übergebenen Collection "c2" in dieser Collection enthalten ?
  isEmpty(): Boolean Ist die Collection leer ?
  notEmpty(): Boolean Na was wohl ?
  sum(): T Summe über die Elemente (falls summierbar)
  
• Operationen von "Set":
  Hier nur eine einzelne beispielhaft, den Rest kann man aus der OCL-Spezifikation, Kapitel 11.7.2 holen.
  count (object: T): Integer Zählt das Auftreten von "object" im Set.
  
• Operationen von "Sequence":
  Hier nur einige beispielhaft, den Rest kann man aus der OCL-Spezifikation, Kapitel 11.7.5 holen.
  at (i: Integer): T Abrufen des Elements an Stelle "i"
  indexOf (obj: T): Integer Index des übergebenen Elements.
  first(): T Erstes Element der Sequence
  last(): T Letztes Element der Sequence
  
• Iteratoren: In den meisten Fällen reichen einfache Operationen wie oben beschrieben nicht aus, z.B. wenn man über die Collection laufen muss und pro Element eine Bedingung prüfen will. Für diesen Fall werden Iterator-Expressions verwendet.
  Eine Iterator-Expression läuft über eine Collection "source" und führt pro Element eine Bedingung "body" aus. Die Rückgabe dieser Prüfbedingung wird als "result" verwendet. Das "result" kann z.B. eine Collection sein, in diesem Fall könnte im "body" ein Element der Collection zugefügt werden und diese modifizierte Collection als neuer Rückgabewert verwendet werden. Die Collections bieten eine Reihe von Methoden, die Iterator-Expressions darstellen. Ausgangspunkt ist jeweils die "iterate"-Methode, auf der alle anderen Methoden aufbauen:

  	source->iterate(iterator; result : Type1 = InitialValue | body) 

  Die Iterate-Methode hat folgende Teile:
  "iterator" ist eine Iterator-Variable vom gleichen Typ wie die Collection-Elemente, hier steht für jeden Schritt das aktuelle Collection-Element.
  "result" ist der Rückgabewert, vom Typ "Type1" mit dem Initial-Wert "InitialValue".
  "body" ist ein Ausdruck, der in Abhängigkeit vom aktuellen Iterator-Wert etwas mit dem Rückgabewert "result" anstellt.
  Beispiel:
  Die "sum"-Methode für eine Integer-Collection könnte so definiert sein:
  

  	source->sum() = 
  		source->iterate(iterator; result : Integer = 0 | result + iterator)

  
  Die "forAll"-Methode von "Collection" ist so definiert (aus OCL-Spezifikation):
  

  	source->forAll(iterators | body ) =
  		source->iterate(iterators; result : Boolean = true | result and body)

  Sie prüft für jedes Element der Collection ob es eine Body-Bedingung erfüllt. Nur wenn dies für alle Elemente der Fall ist dann ist die Rückgabe "TRUE", sonst "FALSE".
  
  Die "select"-Methode von "Set" ist so definiert (aus OCL-Spezifikation):
  

  	source->select(iterator | body) =
  		source->iterate(iterator; result : Set(T) = Set{} |
  			if body then result->including(iterator)
  				else result
  			endif)

  Sie erzeugt eine neue Sequence, die nur die Elemente enthält die eine Bedingung erfüllen. "including" ist eine Methode von "Set" und gibt ein Set zurück dass alle Elemente plus das neue enthält.

OCL und Rational XDE

Dresden OCL Toolkit