Basic OCL Elements

Expressions, Types, and Values

Basic Types and Operators

The Boolean Type

Example: The result of the following sample expression is true if for every service it can be said that when it offers bonus points it never burns bonus points

context Service
inv: self.pointsEarned > 0 implies not (self.pointsBurned = 0)

Another interesting operation on the Boolean type is the if-then-else
if ‹boolean OCL expression›
then ‹OCL expression›
else ‹OCL expression›
endif


The Integer and Real Types

All these examples are expressions of the Boolean type, which result in true:

2654 * 4.3 + 101 = 11513.2
(3.2).floor() / 3 = 1
1.175 * (-8.9).abs() - 10 = 0.4575
12 > 22.7 = false
12.max(33) = 33
33.max(12) = 33
13.mod(2) = 1
13.div(2) = 6
33.7.min(12) = 12.0
-24.abs() = 24
(-2.4).floor() = -3



The String Types
All these examples are expressions of the Boolean type, and result in true:

'Anneke'.size() = 6
('Anneke' = 'Jos') = false
'Anneke '.concat('and Jos') = 'Anneke and Jos'
'Anneke'.toUpper() = 'ANNEKE'
'Anneke'.toLower() = 'anneke'
'Anneke and Jos'.substring(12, 14) = 'Jos'



Precedence Rules


Comments
An OCL line comment begins with two hyphens. All text from the hyphens to the end of the line is considered to be a comment. Comments longer than one line may be enclosed between /* and */.

-- the expression 20 * 5 + 4 should be evaluated here
20 * 5 + 4 -- this is a comment
/* this is a very long comment that does not enlighten the reader one bit about what the expression is really about */
20 * -- this is a comment 5 + 4 (invalid OCL expression)

The Context of OCL Expression

The link between an entity in a UML diagram and an OCL expression is called the context definition of that OCL expression.

The Context of OCL Expression
The context definition specifies the model entity for which the OCL expression is defined. It is always a specific element defined in a UML diagram, e.g. a class, interface, datatype, or component. This element is called the context of the expression.

The self Keyword

The keyword self is used to refer explicitly to the contextual instance. Whenever the reference to the contextual instance is obvious, the use of the keyword self is optional.

More Than One Expression to a Context

The following two examples have exactly the same meaning:

The following two sets of pre- and postconditions have the same meaning as well:

Classes and Other Types

Invariants

The first way in which an expression with a type as context can be used is as an invariant. An invariant is described using a boolean expression that evaluates to true if the invariant is met. To indicate that the expression is intended to be an invariant, the context declaration is followed by the keyword inv, an optional name, and a colon, as shown in the following example:

context Customer
inv myInvariant23: self.name = 'Edward‘

An invariant may be named, which can be useful for reference in an accompanying text

Definitions of Attributes or Operations

Every instance of the contextual type holds an attribute or operation that conforms to the given definition. To indicate that the expression is intended to be a definition, the context declaration is followed by the keyword def and a colon, as shown in the following examples. In the case of an attribute definition, the name and type of the attribute must be given. The expression following the equal sign is also mandatory. This expression indicates how the value of the attribute must be calculated.

context Customer
def: initial : String = name.substring(1,1)

All operations defined by an OCL expression are considered to be query operations. The name, parameters (including their types), and the return type (if any) of the operation must be given. The expression following the equal sign is also mandatory, and states the result of the operation
context CustomerCard
def: getTotalPoints(d: Date): Integer = transactions-> select(date.isAfter(d)).points->sum()
Attributes and Association Ends

Derivation Rules

An expression whose context is an attribute or association role may be used as a derivation rule. If the context is an attribute, the contextual type is the type that holds the attribute. If the context is an association end, the contextual type is the type at the opposite end of the association.

context LoyaltyAccount::totalPointsEarned : Integer
derive: transactions->select(oclIsTypeOf(Earning)).points->sum()

context CustomerCard::myLevel:ServiceLevel
derive: Membership.currentLevel

Initial Values

An initial value is the value that the attribute or association end will have at the moment that the contextual instance is created. The context declaration is followed by the keyword init, the name of the attribute, and the expression that gives the initial value, as shown in the following two examples:

The difference between an initial value and a derivation rule. A derivation rule states an invariant: The derived element should always have the same value that the rule expresses. An initial value must hold only at the moment when the contextual instance is created. After that moment, the attribute may have a different value at any point in time.

Preconditions and Postconditions

The first two ways in which expressions may be used for operations are pre- and postconditions: two forms of constraints. A precondition is a boolean expression that must be true at the moment when the operation starts its execution. A postcondition is a boolean expression that must be true at the moment when the operation ends its execution. A precondition specifies that the expression must evaluate to true; otherwise, the operation will not be executed.

Body of Query Operations

The context is indicated in the same manner as for pre- and postconditions. Instead of the keywords pre or post, the keyword body is used, followed by the body expression: