1. The Object Constraint Language
Jos Warmer and Anneke Kleppe. OCL: The Constraint Language of the UML, Journal of Object-Oriented Programming, 2(2):10-13, May 1999.
Jos Warmer and Anneke Kleppe. The Object Constraint Language, second edition, Addison-Wesley, 2003.
Raul Wazlawick, Object-Oriented Analysis and Design for Information Systems, Morgan Kaufmann, Chap 8. Functional Modeling with OCL. Free e-book through UTEP library. 1

2. Outline Motivation Basics of OCL OCL types OCL collections
Other features 2

3. Motivation---Problem
UML diagrams don’t tell everything
Can’t express a rich semantics of and all relevant information about an application
Lack expressiveness
Q: What does the following class diagram tell?
parents
Person
0..2
0..*
children

4. Motivation---Problem
Is this a valid object diagram?
Q: What’s wrong with it?
Q: How to fix it using Z?
parents
Person
0..2
0..*
children
parents
joe: Person
children 4

5. Motivation---Solution
Specify constraints explicitly
A person can’t be one’s own parents or children, e.g.,
this  parents
inv: not parents->includes(self)
parents
Person
0..2
0..*
children

6. Exercise Formulate constraints for a derived association. parents 0..2
ancestors
0..*
Person
0..*
children
0..*
/family tree
descendants

7. What Is OCL? Standard “add-on” to UML
OCL expressions dependent on types from UML diagrams
Language for expressing additional information (e.g., constraints and business rules) about UML models

8. Characteristics of OCL
Constraint and query languages
UML 1.1: Constraints
UML 2.0: Queries, reference values, conditions, business rules
Math foundation but no math symbols
Set theory and predicate logic
Strongly typed language
Checking possible
Declarative language
What vs. how (algorithmic or procedural)
No side effect
High level of abstraction (platform independence)

9. Outline Motivation Basics of OCL OCL types OCL collections
Other features 9

10. Basics of OCL Associating OCL expressions to UML models
Directly to diagrams as notes
Separate accompanying texts, e.g.,
context Person
inv: age >= 0
Person
-age
inv: age >= 0

11. Basic: Specifying Invariants
Invariants: state conditions that must be always be met by all instances of context types (classes or interfaces)
self: contextual instance, an instance to which the OCL expression is attached
context Company inv:
self.numberOfEmployees > 50
context c: Company inv:
c.numberOfEmployees > 50
context c: Company inv minimumEmployees:
An explicit specification of contextual instance, c
an optional label

12. Basic: Pre and Post-conditions
Pre and post-conditions: conditions that must be true at the moment when an operation begins and ends its execution.
context Account::deposit(amt: Integer): void
pre: amt > 0
post: balance = + amt
pre argumentOk: amt > 0
post balanceIncreased: balance = + amt
pre-value, referring to previous value
optional label

13. Referring to Pre-value and Result
@pre: denotes the value of a property at the start of an operation
result: denotes the result of an operation
context Account::payInterest(rate: Real): void
post: balance = +
context Account::getBalance(): Integer
post: result = balance

14. Navigating in OCL Expressions
Use dot notation to navigate through associations
Direction and multiplicity matter
Use role names or class names
Customer
Account
0..* 1
accounts
owner
context Account
inv: self.owner … evaluate to a single Customer
self.customer …
context Customer
inv: self.accounts->size() … -- evaluate to a collection
self.account … of accounts
single line (--) or multiple lines (/* … */)
Arrow notation for collection operations

15. Exercise Write pre and post-conditions Pair (5 minutes) Person
- gender: Sex
+ marry(p: Person): void
0..1
spouse

16. Exercise
Formulate constraints or business rules for the following class diagram. 16

17. Exercise
Model the following software by drawing a class diagram and formulating the constraints the class diagram has to satisfy. The software system automates test taking by allowing an instructor to prepare test questions and students to take tests.
The system shall allow an instructor to add test questions, Each question is a multiple choice question consisting of a stem---that presents the problem to be solved or the question to be answered---and a set of options---that are possible answers. Test questions are classified by topics, difficulty levels, and similarity.
The system shall allow an instructor to create a test on specific topics by suggesting a set of questions that meets the instructor's request (e.g., number of questions and their distributions among different topics and difficulty levels).
The system shall allow students to take tests prepared by the instructor.
The system shall grade tests taken by students to calculate test scores.
The system shall allow both the instructor and the students view their scores. However, students are allowed to view only their tests. 17

18. Exercise Consider the following classes from the Battleship game.
State that the active player is always one of the players of the game.
Specify the changeTurn operation.
Introduce a new operation to obtain the active player.
Game
activePlayer …
changeTurn 2
Player 18

19. Outline Motivation Basics of OCL OCL types OCL collections
Other features 19

20. Types in OCL Two different kinds Value vs. object types
Predefined types (as defined in standard library)
Basic types: Integer, Real, String, Boolean
Collection types: Set, OrderedSet, Bag, Sequence
User-defined types: classes, interfaces, and enumerations.
Value vs. object types
Immutable vs. mutable types
All predefined types are value types, i.e., there is no mutation operation defined. 20

21. Basic Types Several basic types with operations Type Values Operations
Boolean
false, true
or, and, xor, not, =, <>, implies
Integer
-10, 0, 10, …
=, <>, <, >, <=, >=, +, -, *, /, mod(), div(), abs(), max(), min(), round(), floor()
Real
-1.5, 3.14, …
String
‘Carmen’
=, <>, concat(), size(), toLower(), toUpper(), substring()

22. Integer and Real No restriction on size and precision
Operations: =, <>, <, >, <=, >=, +, -, *, /, mod, div, abs, max, min, round, floor
Prefix vs. infix operations, e.g.,
5.max(10)
5.+(10)
5 + 10
Axioms of associativity and commutitivity hold:
a + (b + c) = (a + b) + c
a + b = b + a

23. String
Operations: concat, size, toLower, toUpper, substring, =, <>
Constants: 'cs 5381'
1-based index for substring, substring(l,u)
Q: Pre- and post-conditions of substring?

24. Boolean
Operations: or, and, xor, not, =, <>, implies, if-then-else-endif
Order of evaluation and "undefined" value
Undefined represented by OclVoid, conforming to all types (cf. oclIsUndefined() from OclAny)
Mostly strict interpretation except for boolean operators
Q: Truth table for: and, or, xor, implies, not?

25. OclAny Supertype of all types
Operations useful for every type of OCL instance, e.g.,
= (o2: OclAny): Boolean
<> (o2: OclAny): Boolean
oclIsUndefined(): Boolean
oclIsTypeOf(t: OclType): Boolean
oclIsKindOf(t: OclType): Boolean
oclIsNew(): Boolean
oclAsType(t: OclType): OclType
T::allInstances(): Set(T)
*Both = and <> are mostly redefined by subtypes
Q: Use of oclAsType?
Accessing subtype's features and supertype's overridden features
Q: Difference between oclIsTypeOf and oclIsKindOf?

26. Using and Navigating User-defined Types
Can use (class) attributes and query operations of user-defined types
Can use associations and aggregations
Use role names or, if unambiguous, type names
If multiplicity > 1, collections based on properties
Set: {unique} (default)
OrderedSet: {unique, ordered}
Bag: {notUnique}
Sequence: {notUnique, ordered}
context Account
inv: self.owner.name <> ''
context Customer
inv: self.accounts->size() > 0
Customer
Account
0..* 1
accounts
owner

27. Navigating User-defined Types
Navigating more than one association with multiplicity "many"
Bag
Sequence if at least one is marked {ordered}
context Bank
inv: self.customers.accounts->forAll(balance > 0)
0..*
Bank
Customer
0..*
Account
customers
accounts

28. Exercise Write OCL constraints stating:
A board has nn places, where n  10, and each place of a board is uniquely identified by a pair of the 0-based column (x) and row (y) indices
Two players have their own boards but of the same size. 2 1
Board
size *
Place
x, y
Game
Player
places 28

29. <<enumeration>>
Using Enumeration
Use “::” notation
context Account
inv: type = AccountType::gold implies minBalance > and
type = AccountType::silder implies minBalance > 5000
<<enumeration>>
AccountType
gold
silver
Account 1
type

30. Using Association Class
Use class name (with a lowercase character) and role names
context Course
inv: self.outcome->forAll(score > 90)
context Outcome
inv: score > 90
Inv: students.enrolled -- the student associated with this outcome
0..*
0..*
Course
Student
students
Outcome
score: Integer

31. Outline Motivation Basics of OCL OCL types OCL collections
Other features 31

32. Collections in OCL Why? Standard collection types
Multiple objects produced by navigating associations
Standard collection types
Parameterized with elements types, e.g., Set(Account)
Value/immutable types, not reference types
One abstract and four concrete types
Collection
Set, OrderedSet, Bag, Sequence
Determined based on properties of associations, e.g., unique, ordered, and sorted.

33. Collection Types Properties Constants Type Duplicate? Ordered? Set
Bag
Sequence N Y
*Ordered doesn’t mean sorted.
Constants
Set{10, 100}
OrderedSet{'apple', 'orange'}
Bag{10, 10, 100}
Sequence{10, 10, 100}, Sequence{1..10}, Sequence{1..(5 + 5)}
Set{Set{1}, Set{10}}

34. Collection Operations
Large number of predefined operations
Arrow notation, e.g., c->size()
Rationale: allow same-named, user-defined operations, e.g., c.size()
Customer
Account
0..* 1
accounts
owner
context Account context Account
inv: not owner->isEmpty() inv: not owner.isEmpty()

35. Collection Operations
Defined on all collection types
Operation
Description
count(o)
excludes(o)
excludesAll(c)
includes(o)
includesAll(c)
isEmpty()
notEmpty()
size()
sum()
Number of occurrences of o in the collection (self)
Is o not an element of the collection?
Are all the elements of c not present in the collection?
Is o an element of the collection?
Are all the elements of c contained in the collection?
Does the collection contain no element?
Does the collection contain one or more elements?
Number of elements in the collection
Addition of all elements in the collection
Type-specific operations
append, including, excluding, first, last, insertAt, etc.

36. Exercise Write pre- and post-conditions for:
includes
excludes
includesAll
excludesAll
isEmpty
notEmpty
Hint: use forAll operations for includesAll and excludesAll.

37. Exercise Write pre and postconditions for: Set
union(s: Set(T)): Set(T)
=(s: Set(T)): Boolean
including(o: T): Set(T)
OrderedSet
append(o: T): OrderedSet(T)
insertAt(i: Integer, o: T): OrderedSet(T)
Bag
excluding(o: T): Bag(T)
Sequence
subSequence(l: Integer, u: Integer): Sequence(T)

38. Iteration Operations
Loop over elements by taking one element at a time
Iterator variables
Optional variable declared and used within body
Indicate the element being iterated
Always of the element type, thus, type declaration is optional
context Customer
inv: self.accounts->forAll(a: Account | a.owner = self)
inv: accounts->forAll(a | a.owner = self)
inv: accounts->forAll(owner = self)
Customer
Account
0..* 1
accounts
owner

39. Iteration Operations Operation Description any(expr) collect(expr)
exists(expr)
forAll(expr)
isUnique(expr)
iterate(x: S; y: T| expr)
one(expr)
reject(expr)
select(expr)
sortedBy(expr)
Returns any element for which expr is true
Returns a collection that results from evaluating expr for each element of self
Has at least one element for which expr is true?
Is expr true for all elements?
Does expr has unique value for all elements?
Iterates over all elements
Has only one element for which expr is true?
Returns a collection containing all elements for which expr is false
Returns a collection containing all elements for which expr is true
Returns a collection containing all elements ordered by expr

40. Examples accounts->any(a: Account | a.balance > 1000)
accounts->collect(name) -- all the names
accounts->exists(balance > 5000)
accounts->forAll(balance >= 0)
accounts->isUnique(name)
accounts->iterate(a: Account; sum: Integer = 0 | sum + a.balance)
accounts->one(name = “Carmen”)
accounts->reject(balance > 1000)
accounts->select(balance <= 1000)
accounts->sortedBy(balance)

41. Select vs. Collect Q: Difference between select and collect?
Note that the dot notation is short for collect, e.g.,
context Bank
inv: self.customers.accounts->forAll(balance > 0)
inv: self.customers->collect(accounts)->forAll(balance > 0)
Customer
0..*
accounts
customers
Account
balance: Integer
Bank
Note that results are flattened for “collect” and not for “collectNested”.

42. The Iterate Operation Most fundamental and generic loop operation
All other loop operations are special cases
iterate(elem: T1; result: T2 = expr | expr-elem-result)
Example
Set{1, 2, 3}->sum()
Set{1, 2, 3}->iterate(i: Integer; r: Integer = 0 | r + i)

43. Exercise Pair (3 minutes)
Write the pre- and post-conditions of the getBelowAverage operation that returns all the accounts of a customer of which balances are below the average balance of the customer’s accounts.
Customer
+ getBelowAverage(): Set(Account)
Account
+ getBalance(): Real 1
0..*
accounts

44. Exercise
Write pre- and post-conditions of the following operations in terms of the iterate operation:
size, count, sum, and excluding(o: T): Sequence(T)
Define the following operations in terms of the iterate operation:
forAll, any, one, select, reject
E.g., source->exists(vars|body) =
source->iterate(vars; result: Boolean = false| result or body)

45. Initial Values and Derivation Rules
Specify initial values for attributes and association ends
context Account::balance
init: 0
Specify derivation rules for derived attributes and associations
context Person::printedName
derive: lastName.concat(', ').concat(firtName)
Q: How to indicate derived attributes and associations in UML?
Q: Difference between initial values and derivation rules?

46. Outline Motivation Basics of OCL OCL types OCL collections
Other features 46

47. Introducing New Attributes and Operations
Can add new attributes and operations to UML models
context Account
def: isJointlyOwned: Boolean = owners->size() > 1
def: numOfOwners(): Integer = owners->size()
Customer
0..*
owners
Account
balance: Integer

48. Message Sending
The isSent (^) operator in post-conditions specifies communication (e.g., method call or signal) has taken place.
context Subject::hasChanged()
post: observer^update(10, 20)
post: observer^update(?: Integer, ?: Integer)