For the purpose of these examples we'll assume here that we have a Class *Person* with a reference *children*. Our model contains two persons such as *person1.children = {James, Jane}* and *person2.children = {John}*.

For the purpose of these examples we'll assume here that we have a Class *Person* with a reference *children*. Our model contains two persons such as *person1.children = {James, Jane}* and *person2.children = {John}*.

Returns a collection containing all elements of *self* minus all occurences of *object*. **Note** : at the time of writing, the OCL standard library sports a bug which changes *OrderedSets* in *Sets* when excluding elements.

Returns a collection containing all elements of *self* minus all occurences of *object*. **Note** : at the time of writing, the OCL standard library sports a bug which changes *OrderedSets* in *Sets* when excluding elements.

Returns a collection containing all elements of *self* recursively flattened. **Note** : at the time of writing, the OCL standard library sports a bug which changes *OrderedSets* in *Sets* when flattening.

Returns a collection containing all elements of *self* recursively flattened. **Note** : at the time of writing, the OCL standard library sports a bug which changes *OrderedSets* in *Sets* when flattening.

Returns a collection containing all elements of *self* followed by *object*. **Note** : at the time of writing, the OCL standard library sports a bug which changes *OrderedSets* in *Sets* when including elements.

Returns a collection containing all elements of *self* followed by *object*. **Note** : at the time of writing, the OCL standard library sports a bug which changes *OrderedSets* in *Sets* when including elements.

Ocl operations for type *OclAny*

oclAsType ( typespec : Classifier ) : T

Returns *self* statically typed as typespec if it is an instance of this type. *Note* that this does not alter the runtime value of *self*, it only enables access to subtype operations. This operation allows users to cast self to another type.

Expression

Result

aPerson.oclAsType(Employee)

an object of Employee type

oclIsInvalid () : Boolean

Returns true if self is equal to *invalid*.

Expression

Result

let anObject : String = null in anObject.oclIsUndefined()

false

let anObject : String = invalid in anObject.oclIsUndefined()

true

let anObject : String = 'null' in anObject.oclIsUndefined()

false

oclIsKindOf( Classifier typespec ) : Boolean

Returns **true** if the type of self corresponds to the type or supertype of typespec, false otherwise. This operation allows users to check the class hierarchy of self much like would an instanceof Java.

Expression

Result

anEmployee.oclIsKindOf(Employee)

true

anEmployee.oclIsKindOf(Person)

true

aCat.oclIsKindOf(Person)

false

oclIsTypeOf( typespec : Classifier ) : Boolean

Returns true if the type of self is the same as typespec, or **false** otherwise. This operation allows users to check the exact class type of self.

Expression

Result

anEmployee.oclIsTypeOf(Employee)

true

anEmployee.oclIsTypeOf(Person)

false

aCat.oclIsTypeOf(Person)

false

oclIsUndefined () : Boolean

Returns **true** if *self* is equal to *invalid* or *null*.

Expression

Result

let anObject : String = null in anObject.oclIsUndefined()

true

let anObject : String = invalid in anObject.oclIsUndefined()

true

let anObject : String = 'null' in anObject.oclIsUndefined()

false

<> ( object : OclAny ) : Boolean

Returns **true** if *self* is a different object from *object*.

Expression

Result

let a : String = 'a', b : String = 'a' in a <> b

false

let a : Integer = 2, b : Real = 2.0 in a <> b

false

let a : Integer = -2, b : Integer = 2 in a <> b

true

= ( object : OclAny) : Boolean

Returns **true** if *self* is equal to *object*.

Expression

Result

let a : String = 'a', b : String = 'a' in a = b

true

let a : Integer = 2, b : Real = 2.0 in a = b

true

let a : Integer = -2, b : Integer = 2 in a = b

false

< ( object : T ) : Boolean

Returns **true** if *self* is comparable to *object* and less than *object*.

Expression

Result

let a : Integer = 1, b : Integer = 2 in a < b

true

let a : Real = 1.5, b : Integer = 2 in a < b

true

let a : String = 'Anteater', b : String = 'Aardvark' in a < b

false

> ( object : T ) : Boolean

Returns **true** if *self* is comparable to *object* and greater than *object*.

Expression

Result

let a : Integer = 1, b : Integer = 2 in a > b

false

let a : Real = 1.5, b : Integer = 2 in a > b

false

let a : String = 'Anteater', b : String = 'Aardvark' in a > b

true

<= ( object : T ) : Boolean

Returns **true** if *self* is comparable to *object* and less than or equal to *object*.

Expression

Result

let a : Integer = 1, b : Integer = 2 in a <= b

true

let a : Real = 1.5, b : Integer = 2 in a <= b

true

let a : String = 'Anteater', b : String = 'Aardvark' in a <= b

false

>= ( object : T ) : Boolean

Returns **true** if *self* is comparable to *object* and greater than or equal to *object*.

Expression

Result

let a : Integer = 1, b : Integer = 2 in a >= b

false

let a : Real = 1.5, b : Integer = 2 in a >= b

false

let a : String = 'Anteater', b : String = 'Aardvark' in a >= b

true

Ocl operations for type *String*

A note on Strings** : OCL Strings begin at index *1*, not *0* as in most languages. Thus *'test'.at(0)* fails in

concat ( s : String ) : String

size () : Integer

Returns the number of characters composing *self*.

Expression

Result

'size operation'.size()

14

substring ( lower : Integer, upper : Integer ) : String

Returns a string containing all characters from *self* starting from index *lower* up to index *upper* included. Both *lower* and *upper* parameters should be contained between *1* and *self.size()* included. *lower* cannot be greater than *upper*.

Expression

Result

'substring operation'.substring(11, 19)

'operation'

'substring operation'.substring(1, 1)

's'

'substring operation'.substring(0, 1)

invalid

toInteger () : Integer

Returns an Integer of value equal to *self*, or |invalid| if *self* does not represent an integer.

Expression

Result

'3.0'.toInteger()

invalid

'4'.toInteger()

4

'toInteger'.toInteger()

invalid

toLower () : String

Returns *self* with all characters converted to lowercase.

Expression

Result

'LoWeR OpErAtIoN'.toLower()

'lower operation'

toReal () : Real

Returns a Real of value equal to *self*, or |invalid| if *self* does not represent a real.

Expression

Result

'3.0'.toReal()

3.0

'4'.toReal()

4.0

'toReal'.toReal()

invalid

toUpper () : String

Returns *self* with all characters converted to uppercase.

Expression

Result

'UpPeR OpErAtIoN'.toUpper()

'UPPER OPERATION'

Ocl operations for type *Number*

In addition to the basic math functions (+, -, /, \*) are a number of advanced functions. Take note that *Number* denotes both *Integer* and *Real*, and they're substitutive unless otherwise specified.

Number::abs () : Number

Returns the absolute value of *self*, *self* if it is already a positive number.

Expression

Result

(-2.3).abs()

2.3

-5.abs()

5

Number::floor () : Integer

Returns the integer part of *self* if it is a Real, *self* if it is an Integer.

Expression

Result

(2.3).floor()

2

(2.8).floor()

2

2.floor()

2

Number::max ( r : Number ) : Number

Returns the greatest number between *self* and *r*.

Expression

Result

6.max(3)

6

6.max(5.2)

6.0

(2.3).max(3)

3.0

(2.3).max(5.2)

5.2

Number::min ( r : Number ) : Number

Returns the lowest number between *self* and *r*.

Expression

Result

6.min(3)

3

6.min(5.2)

5.2

(2.3).min(3)

2.3

(2.3).min(5.2)

2.3

Number::round () : Integer

Returns the nearest integer to *self* if it is a Real, *self* if it is an Integer.

Expression

Result

(2.3).round()

2

(2.5).round()

3

(2.8).round()

3

2.round()

2

Integer::div ( i : Integer ) : Integer

Returns the integer quotient of the division of *self* by *i*.

Expression

Result

3.div(2)

1

11.div(3)

3

Integer::mod ( i : Integer ) : Integer

Returns the integer remainder of the division of *self* by *i*.

Expression

Result

3.mod(2)

1

11.mod(3)

2

Ocl operations for type *Collection*

Please note that OCL collections can contain the *null* value (null) but not the *invalid* value (|invalid|). Trying to add |invalid| within a new or existing collection will yield |invalid| as a result. OCL proposes four distinct kinds of collections offering all possibilities of ordering/unicity.

Collection type

Ordered

Unique

Sequence

true

false

OrderedSet

true

true

Bag

false

false

Set

false

true

any ( expr : OclExpression ) : T

Returns any element contained in *self* that validates the condition *expr*, null otherwise. Evaluation is shortcut as soon as an element validating *expr* is found. Note that the result of this on unordered collections will be random if more than one element validates *expr*.

Expression

Result

Sequence{1.2, 2.3, 5.2, 0.9}->any(self < 1)

0.9

Sequence{1.2, 2.3, 5.2, 0.9}->any(self < 2)

1.2

asBag () : Bag(T)

Returns a Bag containing all elements of *self*.

Expression

Result

Sequence{'3', 1, 2.0, '3'}->asBag()

Bag{2.0, '3', 1, '3'}

Bag{1, 2.0, '3'}->asBag()

Bag{2.0, 1, '3'}

OrderedSet{1, 2.0, '3'}->asBag()

Bag{2.0, 1, '3'}

OrderedSet{1, 1, 2.0, '3'}->asBag()

Bag{'3', 1, 2.0}

Set{1, 2.0, '3'}->asBag()

Bag{2.0, 1, '3'}

Set{1, 1, 2.0, '3'}->asBag()

Bag{2.0, '3', 1}

asOrderedSet () : OrderedSet(T)

Returns an OrderedSet containing all elements of *self*. Element ordering is preserved when possible.

Expression

Result

Sequence{1, 2.0, '3'}->asOrderedSet()

OrderedSet{1, '3', 2.0}

Sequence{1, 1, 2.0, '3'}->asOrderedSet()

OrderedSet{'3', 1, 2.0}

Bag{1, 2.0, '3'}->asOrderedSet()

OrderedSet{2.0, 1, '3'}

Bag{1, 1, 2.0, '3'}->asOrderedSet()

OrderedSet{1, '3', 2.0}

OrderedSet{1, 2.0, '3'}->asOrderedSet()

OrderedSet{1, 2.0, '3'}

Set{1, 2.0, '3'}->asOrderedSet()

OrderedSet{'3', 1, 2.0}

asSequence () : Boolean

Returns a Sequence containing all elements of *self*. Element ordering is preserved when possible.

Expression

Result

Sequence{1, 2.0, '3'}->asSequence()

Sequence{1, 2.0, '3'}

Bag{1, 2.0, '3'}->asSequence()

Sequence{2.0, 1, '3'}

OrderedSet{1, 2.0, '3'}->asSequence()

Sequence{1, 2.0, '3'}

Set{1, 2.0, '3'}->asSequence()

Sequence{'3', 1, 2.0}

asSet () : Set(T)

Returns a Set containing all elements of *self*.

Expression

Result

Sequence{1, 2.0, '3'}->asSet()

Set{1, '3', 2.0}

Sequence{1, 1, 2.0, '3'}->asSet()

Set{'3', 1, 2.0}

Bag{1, 2.0, '3'}->asSet()

Set{2.0, 1, '3'}

Bag{1, 1, 2.0, '3'}->asSet()

Set{1, '3', 2.0}

OrderedSet{1, 2.0, '3'}->asSet()

Set{1, '3', 2.0}

OrderedSet{1, 1, 2.0, '3'}->asSet()

Set{'3', 1, 2.0}

Set{1, 2.0, '3'}->asSet()

Set{2.0, 1, '3'}

Set{1, 1, 2.0, '3'}->asSet()

Set{'3', 1, 2.0}

collect ( expr : OclExpression ) : Collection(T2)

Returns a collection containing the result of applying *expr* on all elements contained in *self*.

Expression

Result

Sequence{'first', 'second'}->collect(toUpper())

Sequence{'FIRST', 'SECOND'}

collectNested ( expr : OclExpression ) : Collection(T2)

Returns a collection containing all the elements contained in *self* on which we applied the OclExpression *expr*. The results won't be flattened. The type of the resulting collection depends on the type of *self*.

For the purpose of these examples we'll assume here that we have a Class *Person* with a reference *children*. Our model contains two persons such as *person1.children = {James, Jane}* and *person2.children = {John}*.

Expression

Result

self.persons->collectNested(children.firstname)

Sequence{Sequence{James, Jane}, Sequence{John}}

count ( object : T ) : Integer

Returns how many times *object* is in the collection *self*.

Expression

Result

Sequence{2.3, 5.2}->count(5.2)

1

Set{3, 'test', 4.0, 4, 4.0, 'test'}->count(null)

0

Set{3, null, 4.0, null, 'test'}->count(null)

1

Bag{3, null, 4.0, null, 'test'}->count(null)

2

excludes ( object : T ) : Boolean

Returns **true** if *object* is not contained in *self*, **false** otherwise.

Expression

Result

Sequence{2.3}->excludes(2.1)

true

Sequence{2.0}->excludes(2)

false

excludesAll ( c2 : Collection(T) ) : Boolean

Returns **true** if no element of *c2* is contained in *self*, **false** otherwise.

Expression

Result

Sequence{2.3, 5.2, 'a', 3, null}->excludesAll(Set{4, null})

false

Sequence{2.3, 5.2, 'a', 3}->excludesAll(Set{4, null})

true

excluding ( object : T ) : Collection(T)

Returns a collection containing all elements of *self* minus all occurences of *object*. **Note** : at the time of writing, the OCL standard library sports a bug which changes *OrderedSets* in *Sets* when excluding elements.

Expression

Result

Sequence{'b', 'a', 'b', 'c'}->excluding('b')

Sequence{'a', 'c'}

Bag{'b', 'a', 'b', 'c'}->excluding('b')

Bag{'c', 'a'}

OrderedSet{'b', 'a', 'b', 'c'}->excluding('b')

Set{'c', 'a'}

Set{'b', 'a', 'b', 'c'}->excluding('b')

Set{'c', 'a'}

exists ( expr : OclExpression ) : Boolean

Returns **true** if at least one element in *self* validates the condition *expr*, **false** otherwise. The evaluation stops as soon as one element validating *expr* is found.

Expression

Result

Sequence{2.3, 5.2}->exists(self > 3)

true

flatten () : Collection(T2)

Returns a collection containing all elements of *self* recursively flattened. **Note** : at the time of writing, the OCL standard library sports a bug which changes *OrderedSets* in *Sets* when flattening.

forAll ( expr : OclExpression ) : Boolean

Returns **true** if the all the elements contained in *self* validate the condition *expr*, **false** otherwise.

Expression

Result

Sequence{2.3, 5.2}->forAll(self > 3)

false

Sequence{2.3, 5.2}->forAll(self > 1.2)

true

includes ( object : T ) : Boolean

Returns **true** if *object* is contained in *self*, **false** otherwise.

Expression

Result

Sequence{2.3}->includes(2.1)

false

Sequence{2.0}->includes(2)

true

includesAll ( c2 : Collection(T) ) : Boolean

Returns **true** if all element of *c2* are contained in *self*, **false** otherwise.

Expression

Result

Sequence{2.3, 5.2, 'a', 3, null}->includesAll(Set{3, null})

true

Sequence{2.3, 5.2, 'a', 3}->includesAll(Set{3, null})

false

including ( object : T ) : Collection(T)

Returns a collection containing all elements of *self* followed by *object*. **Note** : at the time of writing, the OCL standard library sports a bug which changes *OrderedSets* in *Sets* when including elements.

Expression

Result

Sequence{'a', 'b'}->including('c')

Sequence{'a', 'b', 'c'}

Bag{'a', 'b'}->including('c')

Bag{'a', 'c', 'b'}

OrderedSet{'a', 'b'}->including('c')

Set{'a', 'c', 'b'}

Set{'a', 'b'}->including('c')

Set{'a', 'c', 'b'}

isEmpty () : Boolean

Returns **true** if *self* is empty, **false** otherwise.

Expression

Result

Sequence{2, 'a'}->isEmpty()

false

Sequence{null}->isEmpty()

false

Sequence{}->isEmpty()

true

isUnique ( expr : OclExpression ) : Boolean

Returns **true** if all elements contained in *self* evaluate to a distinct value for *expr*.

one ( expr : OclExpression ) : Boolean

Returns **true** if there is only one element contained in *self* that validates the condition *expr*, **false** otherwise.

Expression

Result

Sequence{1.2, 2.3, 5.2, 0.9}->one(self < 1)

true

Sequence{1.2, 2.3, 5.2, 0.9}->one(self < 2)

false

product ( c2 : Collection(T2) ) : Set(Tuple(first : T, second : T2))

Returns a Set of Tuples which represents the cartesian product of *self* with *c2*.

Expression

Result

Sequence{3, 4}->product(Bag{3.0, 4.0})

Set{Tuple{3, 3.0}, Tuple{3, 4.0}, Tuple{4, 3.0}, Tuple{4, 4.0}}

Set{3, 4}->product(OrderedSet{3.0, 4.0})

Set{Tuple{3, 3.0}, Tuple{3, 4.0}, Tuple{4, 3.0}, Tuple{4, 4.0}}

reject ( expr : OclExpression ) : Collection(T)

Returns a collection with all elements of *self* except for those who validate the OclExpression *expr*.

Expression

Result

i > 1 )

Sequence{1}

i > 1 )

Bag{1}

i > 1 )

OrderedSet{1}

i > 1 )

Set{1}

select ( expr : OclExpression ) : Collection(T)

Returns a collection with all elements of *self* that validate the OclExpression *expr*.

Expression

Result

i > 1)

Sequence{2, 3}

i > 1 )

Bag{3, 2}

i > 1 )

OrderedSet{2, 3}

i > 1 )

Set{3, 2}

size () : Integer

Returns the number of elements contained in *self*.

Expression

Result

Sequence{2.3, 5}->size()

2

Sequence{}->size()

0

sortedBy ( expr : OclExpression ) : Sequence(T)

Returns a sorted collection containing all elements from *self* sorted in accordance with the OclExpression *expr*.
This can be used on all kind of collections yet will always yield a Sequence-typed result except for OrderedSet which returns an OrderedSet.

For the purpose of these examples we'll assume here that we have a Class *Employee* with an attribute *age*. Our model contains two employees such as *employee1.age = 24* and *employee2.age = 27*.

Expression

Result

self.employees->sortedBy(age)

Sequence{employee1, employee2}

sum () : Real

Returns the sum of all elements contained in *self* if they support the '+' operation.

Expression

Result

Sequence{2.3, 5.2} in c->sum()

7.5

Sequence{2, 4} in c->sum()

6

Sequence{2, '4'} in c->sum()

invalid

Ocl operations for type *Sequence*

= ( seq : Sequence(T) ) : Boolean

Returns **true** if *self* contains the very same objects as *seq* in the very same order as they are in *seq*.

Expression

Result

Sequence{4, 5, 'test'} = Sequence{4, 5, 'test'}

true

Sequence{4, 5, 'test'} = Sequence{4, 'test', 5}

false

Sequence{4, 5, 'test', 5} = Sequence{4, 5, 'test'}

false

<> ( seq : Sequence(T) ) : Boolean

Returns **true** if *self* does not contain the same objects as *seq*, or if these objects are not in the same order as they are in *seq*.

Expression

Result

Sequence{4, 5, 'test'} = Sequence{4, 5, 'test'}

false

Sequence{4, 5, 'test'} = Sequence{4, 'test', 5}

true

Sequence{4, 5, 'test', 5} = Sequence{4, 5, 'test'}

true

append ( object : T ) : Sequence(T)

Returns a Sequence containing all elements of *self* followed by *object*.

Expression

Result

Sequence{'a', 'b'}->append('c')

Sequence{'a', 'b', 'c'}

at ( index : Integer ) : T

Returns the element of *self* at the *index* position.

Expression

Result

Sequence{'a', 'b'}->at(1)

a

first () : T

Returns the first element of *self*.

Expression

Result

Sequence{1, 2.0, '3'}->first()

1

indexOf ( object : T ) : Integer

Returns the position of *object* in sequence *self*.

Expression

Result

Sequence{'a', 'b'}->indexOf('a')

1

insertAt ( index : Integer, object : T) : Sequence(T)

Returns a Sequence containing *self* with *object* inserted at the *index* position.

Expression

Result

Sequence{'a', 'b'}->insertAt(0, 'c')

invalid

Sequence{'a', 'b'}->insertAt(1, 'c')

Sequence{'c', 'a', 'b'}

Sequence{'a', 'b'}->insertAt(3, 'c')

Sequence{'a', 'b', 'c'}

Sequence{'a', 'b'}->insertAt(4, 'c')

invalid

last () : T

Returns the last element of *self*.

Expression

Result

Sequence{1, 2.0, '3'}->last()

'3'

prepend ( object : T ) : Sequence(T)

Returns a Sequence containing *object* followed by all elements of *self* .