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, 2014. Chap 8. Functional Modeling with OCL. Free e-book through UTEP library. 1

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

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

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

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

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

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

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)

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

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

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

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 = balance@pre + amt pre argumentOk: amt > 0 post balanceIncreased: balance = balance@pre + amt pre-value, referring to previous value optional label

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 = balance@pre + calcInterest@pre(rate) context Account::getBalance(): Integer post: result = balance

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

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

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

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

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

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

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

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()

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

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?

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?

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?

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

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

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

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

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

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

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.

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}}

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()

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.

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

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)

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

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

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)

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”.

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)

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

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)

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?

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

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

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)