# OCL operations reference

Authors: | Laurent Goubet Laurent Delaigue
Contact: | laurent.goubet@obeo.fr, laurent.delaigue@obeo.fr

Copyright © 2009, 2010 Obeo™.

Contents

- Ocl operations for type Classifier
  - allInstances () : Set{T}
- Ocl operations for type OclAny
  - oclAsType ( typespec : Classifier ) : T
  - oclIsInvalid () : Boolean
  - oclIsKindOf( Classifier typespec ) : Boolean
  - oclIsTypeOf( typespec : Classifier ) : Boolean
  - oclIsUndefined () : Boolean
  - <> ( object : OclAny ) : Boolean
  - = ( object : OclAny) : Boolean
  - < ( object : T ) : Boolean
  - > ( object : T ) : Boolean
  - <= ( object : T ) : Boolean
  - >= ( object : T ) : Boolean
- Ocl operations for type String
  - concat ( s : String ) : String
  - size () : Integer
  - substring ( lower : Integer, upper : Integer ) : String
  - toInteger () : Integer
  - toLower () : String
  - toReal () : Real
  - toUpper () : String
- Ocl operations for type Number
  - Number::abs () : Number
  - Number::floor () : Integer
  - Number::max ( r : Number ) : Number
  - Number::min ( r : Number ) : Number
  - Number::round () : Integer
  - Integer::div ( i : Integer ) : Integer
  - Integer::mod ( i : Integer ) : Integer
- Ocl operations for type Collection
  - any ( expr : OclExpression ) : T
  - asBag () : Bag(T)
  - asOrderedSet () : OrderedSet(T)
  - asSequence () : Boolean
  - asSet () : Set(T)
  - collect ( expr : OclExpression ) : Collection(T2)
  - collectNested ( expr : OclExpression ) : Collection(T2)
  - count ( object : T ) : Integer
  - excludes ( object : T ) : Boolean
  - excludesAll ( c2 : Collection(T) ) : Boolean
  - excluding ( object : T ) : Collection(T)
  - exists ( expr : OclExpression ) : Boolean
  - flatten () : Collection(T2)
  - forAll ( expr : OclExpression ) : Boolean
  - includes ( object : T ) : Boolean
  - includesAll ( c2 : Collection(T) ) : Boolean
  - including ( object : T ) : Collection(T)
  - isEmpty () : Boolean
  - isUnique ( expr : OclExpression ) : Boolean
  - notEmpty () : Boolean
  - one ( expr : OclExpression ) : Boolean
  - product ( c2 : Collection(T2) ) : Set(Tuple(first : T, second : T2))
  - reject ( expr : OclExpression ) : Collection(T)
  - select ( expr : OclExpression ) : Collection(T)
  - size () : Integer
  - sortedBy ( expr : OclExpression ) : Sequence(T)
  - sum () : Real
  - Ocl operations for type Sequence
    - = ( seq : Sequence(T) ) : Boolean
    - <> ( seq : Sequence(T) ) : Boolean
    - append ( object : T ) : Sequence(T)
    - at ( index : Integer ) : T
    - first () : T
    - indexOf ( object : T ) : Integer
    - insertAt ( index : Integer, object : T) : Sequence(T)
    - last () : T
    - prepend ( object : T ) : Sequence(T)
    - subSequence ( startIndex : Integer, endIndex : Integer ) : Sequence(T)
    - union ( seq : Sequence(T) ) : Sequence(T)
  - Ocl operations for type Bag
    - = ( bag : Bag(T) ) : Boolean
    - <> ( bag : Bag(T) ) : Boolean
    - intersection ( bag : Bag(T) ) : Bag(T)
    - intersection ( set : Set(T) ) : Set(T)
    - union ( bag : Bag(T) ) : Bag(T)
    - union ( set : Set(T) ) : Bag(T)
  - Ocl operations for type OrderedSet
    - = ( set : Set(T) ) : Boolean
    - = ( orderedset : OrderedSet(T) ) : Boolean
    - <> ( set : Set(T) ) : Boolean
    - <> ( orderedset : OrderedSet(T) ) : Boolean
    - - ( set : Set(T) ) : Set(T)
    - append ( object : T ) : OrderedSet(T)
    - at ( index : Integer ) : T
    - first () : T
    - indexOf ( object : T ) : Integer
    - insertAt ( index : Integer, object : T ) : OrderedSet(T)
    - intersection ( bag : Bag(T) ) : Set(T)
    - intersection ( set : Set(T) ) : Set(T)
    - last () : T
    - prepend ( object : T ) : OrderedSet(T)
    - subOrderedSet ( startIndex : Integer, endIndex : Integer ) : OrderedSet(T)
    - symmetricDifference ( set : Set(T) ) : Set(T)
    - union ( bag : Bag(T) ) : Bag(T)
    - union ( set : Set(T) ) : Set(T)
  - Ocl operations for type Set
    - = ( set : Set(T) ) : Boolean
    - <> ( set : Set(T) ) : Boolean
    - - ( set : Set(T) ) : Set(T)
    - intersection ( bag : Bag(T) ) : Set(T)
    - intersection ( set : Set(T) ) : Set(T)
    - symmetricDifference ( set : Set(T) ) : Set(T)
    - union ( bag : Bag(T) ) : Bag(T)
    - union ( set : Set(T) ) : Set(T)
- Ocl operations for type Boolean
  - And
  - Implies
  - Or
  - Not
  - Xor
- Glossary

# Ocl operations for type Classifier

## allInstances () : Set{T}

> Returns a Set containing all of the existing instances of the current classifier (along with instances of all its inherited classifiers).

> examples:

> Expression | Result
> --- | ---
> let a : String = 'a', b : String = 'b', c : Integer = 2 in String.allInstances() | Set{'a','b'}

Back to Contents

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

> examples:

> Expression | Result
> --- | ---
> aPerson.oclAsType(Employee) | an object of Employee type

Back to Contents

## oclIsInvalid () : Boolean

> Returns true if self is equal to invalid.

> examples:

> 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

Back to Contents

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

> examples:

> Expression | Result
> --- | ---
> anEmployee.oclIsKindOf(Employee) | true
> anEmployee.oclIsKindOf(Person) | true
> aCat.oclIsKindOf(Person) | false

Back to Contents

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

> examples:

> Expression | Result
> --- | ---
> anEmployee.oclIsTypeOf(Employee) | true
> anEmployee.oclIsTypeOf(Person) | false
> aCat.oclIsTypeOf(Person) | false

Back to Contents

## oclIsUndefined () : Boolean

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

> examples:

> 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

Back to Contents

## <> ( object : OclAny ) : Boolean

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

> examples:

> 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

Back to Contents

## = ( object : OclAny) : Boolean

> Returns true if self is equal to object.

> examples:

> 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

Back to Contents

## < ( object : T ) : Boolean

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

> examples:

> 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

Back to Contents

## > ( object : T ) : Boolean

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

> examples:

> 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

Back to Contents

## <= ( object : T ) : Boolean

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

> examples:

> 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

Back to Contents

## >= ( object : T ) : Boolean

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

> examples:

> 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

Back to Contents

# 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 invalid whereas 'test'.at(1) yields 't'. Likewise, 'test'.substring(2, 2) returns 'e'.

## concat ( s : String ) : String

> Returns a string containing self followed by s.

> examples:

> Expression | Result
> --- | ---
> 'concat'.concat(' ').concat('operation') | 'concat operation'

Back to Contents

## size () : Integer

> Returns the number of characters composing self.

> examples:

> Expression | Result
> --- | ---
> 'size operation'.size() | 14

Back to Contents

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

> examples:

> Expression | Result
> --- | ---
> 'substring operation'.substring(11, 19) | 'operation'
> 'substring operation'.substring(1, 1) | 's'
> 'substring operation'.substring(0, 1) | Ø

Back to Contents

## toInteger () : Integer

> Returns an Integer of value equal to self, or Ø if self does not represent an integer.

> examples:

> Expression | Result
> --- | ---
> '3.0'.toInteger() | Ø
> '4'.toInteger() | 4
> 'toInteger'.toInteger() | Ø

Back to Contents

## toLower () : String

> Returns self with all characters converted to lowercase.

> examples:

> Expression | Result
> --- | ---
> 'LoWeR OpErAtIoN'.toLower() | 'lower operation'

Back to Contents

## toReal () : Real

> Returns a Real of value equal to self, or Ø if self does not represent a real.

> examples:

> Expression | Result
> --- | ---
> '3.0'.toReal() | 3.0
> '4'.toReal() | 4.0
> 'toReal'.toReal() | Ø

Back to Contents

## toUpper () : String

> Returns self with all characters converted to uppercase.

> examples:

> Expression | Result
> --- | ---
> 'UpPeR OpErAtIoN'.toUpper() | 'UPPER OPERATION'

Back to Contents

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

> examples:

> Expression | Result
> --- | ---
> (-2.3).abs() | 2.3
> -5.abs() | 5

Back to Contents

## Number::floor () : Integer

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

> examples:

> Expression | Result
> --- | ---
> (2.3).floor() | 2
> (2.8).floor() | 2
> 2.floor() | 2

Back to Contents

## Number::max ( r : Number ) : Number

> Returns the greatest number between self and r.

> examples:

> 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

Back to Contents

## Number::min ( r : Number ) : Number

> Returns the lowest number between self and r.

> examples:

> Expression | Result
> --- | ---
> 6.min(3) | 6
> 6.min(5.2) | 5.2
> (2.3).min(3) | 2.3
> (2.3).min(5.2) | 2.3

Back to Contents

## Number::round () : Integer

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

> examples:

> Expression | Result
> --- | ---
> (2.3).round() | 2
> (2.5).round() | 3
> (2.8).round() | 3
> 2.round() | 2

Back to Contents

## Integer::div ( i : Integer ) : Integer

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

> examples:

> Expression | Result
> --- | ---
> 3.div(2) | 1
> 11.div(3) | 3

Back to Contents

## Integer::mod ( i : Integer ) : Integer

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

> examples:

> Expression | Result
> --- | ---
> 3.mod(2) | 1
> 11.mod(3) | 2

Back to Contents

# Ocl operations for type Collection

Please note that OCL collections can contain the null value (null) but not the invalid value (Ø). Trying to add Ø within a new or existing collection will yield Ø 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

Back to Contents

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

> examples:

> 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

Back to Contents

## asBag () : Bag(T)

> Returns a Bag containing all elements of self.

> examples:

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

Back to Contents

## asOrderedSet () : OrderedSet(T)

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

> examples:

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

Back to Contents

## asSequence () : Boolean

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

> examples:

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

Back to Contents

## asSet () : Set(T)

> Returns a Set containing all elements of self.

> examples:

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

Back to Contents

## collect ( expr : OclExpression ) : Collection(T2)

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

> examples:

> Expression | Result
> --- | ---
> Sequence{'first', 'second'}->collect(toUpper()) | Sequence{'FIRST', 'SECOND'}

Back to Contents

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

> examples:

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

Back to Contents

## count ( object : T ) : Integer

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

> examples:

> 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

Back to Contents

## excludes ( object : T ) : Boolean

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

> examples:

> Expression | Result
> --- | ---
> Sequence{2.3}->excludes(2.1) | true
> Sequence{2.0}->excludes(2) | false

Back to Contents

## excludesAll ( c2 : Collection(T) ) : Boolean

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

> examples:

> 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

Back to Contents

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

> examples:

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

Back to Contents

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

> examples:

> Expression | Result
> --- | ---
> Sequence{2.3, 5.2}->exists(self > 3) | true

Back to Contents

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

> examples:

> Expression | Result
> --- | ---
> Sequence{Set{1, 2, 3}, Sequence{2.0, 3.0}, Bag{'test'}}->flatten() | Sequence{1, 2, 3, 2.0, 3.0, 'test'}
> Bag{Set{Bag{'test', 2, 3.0}}, Sequence{OrderedSet{2.0, 3, 1}}}->flatten() | Bag{1, 2, 3, 2.0, 3.0, 'test'}
> OrderedSet{Set{Bag{'test', 2, 3.0}}, Sequence{Set{2.0, 3, 1}}}->flatten() | Set{3.0, 2, 1, 3, 'test', 2.0}
> Set{Set{Bag{'test', 2, 3.0}}, Sequence{OrderedSet{2.0, 3, 1}}}->flatten() | Set{3.0, 2, 1, 3, 'test', 2.0}

Back to Contents

## forAll ( expr : OclExpression ) : Boolean

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

> examples:

> Expression | Result
> --- | ---
> Sequence{2.3, 5.2}->forAll(self > 3) | false
> Sequence{2.3, 5.2}->forAll(self > 1.2) | true

Back to Contents

## includes ( object : T ) : Boolean

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

> examples:

> Expression | Result
> --- | ---
> Sequence{2.3}->includes(2.1) | false
> Sequence{2.0}->includes(2) | true

Back to Contents

## includesAll ( c2 : Collection(T) ) : Boolean

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

> examples:

> 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

Back to Contents

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

> examples:

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

Back to Contents

## isEmpty () : Boolean

> Returns true if self is empty, false otherwise.

> examples:

> Expression | Result
> --- | ---
> Sequence{2, 'a'}->isEmpty() | false
> Sequence{null}->isEmpty() | false
> Sequence{}->isEmpty() | true

Back to Contents

## isUnique ( expr : OclExpression ) : Boolean

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

> examples:

> Expression | Result
> --- | ---
> Sequence{2.3, 5.2}->isUnique(self > 3) | true
> Sequence{2.3, 5.2}->isUnique(self > 1) | false

Back to Contents

## notEmpty () : Boolean

> Returns true if self contains at least one element, false otherwise.

> examples:

> Expression | Result
> --- | ---
> Sequence{2, 'a'}->notEmpty() | true
> Sequence{null}->notEmpty() | true
> Sequence{}->notEmpty() | false

Back to Contents

## one ( expr : OclExpression ) : Boolean

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

> examples:

> 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

Back to Contents

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

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

> examples (notation of the tuples has been simplified):

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

Back to Contents

## reject ( expr : OclExpression ) : Collection(T)

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

> examples:

> Expression | Result
> --- | ---
> Sequence{1, 2, 3}->reject(i : Integer | i > 1 ) | Sequence{1}
> Bag{1, 2, 3}->reject(i : Integer | i > 1 ) | Bag{1}
> OrderedSet{1, 2, 3}->reject(i : Integer | i > 1 ) | OrderedSet{1}
> Set{1, 2, 3}->reject(i : Integer | i > 1 ) | Set{1}

Back to Contents

## select ( expr : OclExpression ) : Collection(T)

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

> examples:

> Expression | Result
> --- | ---
> Sequence{1, 2, 3}->select(i : Integer | i > 1) | Sequence{2, 3}
> Bag{1, 2, 3}->select(i : Integer | i > 1 ) | Bag{3, 2}
> OrderedSet{1, 2, 3}->select(i : Integer | i > 1 ) | OrderedSet{2, 3}
> Set{1, 2, 3}->select(i : Integer | i > 1 ) | Set{3, 2}

Back to Contents

## size () : Integer

> Returns the number of elements contained in self.

> examples:

> Expression | Result
> --- | ---
> Sequence{2.3, 5}->size() | 2
> Sequence{}->size() | 0

Back to Contents

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

> examples:

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

Back to Contents

## sum () : Real

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

> examples:

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

Back to Contents

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

> examples:

> 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

Back to Contents

### <> ( 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.

> examples:

> 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

Back to Contents

### append ( object : T ) : Sequence(T)

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

> examples:

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

Back to Contents

### at ( index : Integer ) : T

> Returns the element of self at the index position.

> examples:

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

Back to Contents

### first () : T

> Returns the first element of self.

> examples:

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

Back to Contents

### indexOf ( object : T ) : Integer

> Returns the position of object in sequence self.

> examples:

> Expression | Result
> --- | ---
> Sequence{'a', 'b'}->indexOf('a') | 1

Back to Contents

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

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

> examples:

> Expression | Result
> --- | ---
> Sequence{'a', 'b'}->insertAt(0, 'c') | Ø
> 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') | Ø

Back to Contents

### last () : T

> Returns the last element of self.

> examples:

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

Back to Contents

### prepend ( object : T ) : Sequence(T)

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

> examples:

> Expression | Result
> --- | ---
> Sequence{'a', 'b'}->prepend('c') | Sequence{'c', 'a', 'b'}

Back to Contents

### subSequence ( startIndex : Integer, endIndex : Integer ) : Sequence(T)

> Returns a Sequence containing all elements of self between the positions 'startIndex' and 'endIndex'.

> examples:

> Expression | Result
> --- | ---
> Sequence{'a', 'b', 'c', 'd'}->subSequence(2, 3) | Sequence{'b', 'c'}
> Sequence{'a', 'b', 'c', 'd'}->subSequence(4, 4) | Sequence{'d'}

Back to Contents

### union ( seq : Sequence(T) ) : Sequence(T)

> Returns a Sequence containing all elements of self followed by all elements of seq.

> examples:

> Expression | Result
> --- | ---
> Sequence{'a', 'b', 'a'}->union(Sequence{'b', 'c'}) | Sequence{'a', 'b', 'a', 'b', 'c'}

Back to Contents

## Ocl operations for type Bag

### = ( bag : Bag(T) ) : Boolean

> Returns true if self contains the same objects as bag in the same quantities.

> examples:

> Expression | Result
> --- | ---
> Bag{4, 5, 'test', 4} = Bag{4, 'test', 5, 4} | true
> Bag{4, 5, 'test'} = Bag{4, 'test', 5} | true
> Bag{4, 5, 'test', 5} = Bag{4, 5, 'test'} | false

Back to Contents

### <> ( bag : Bag(T) ) : Boolean

> Returns true if self does not contain the same objects as bag in the same quantities.

> examples:

> Expression | Result
> --- | ---
> Bag{4, 5, 'test'} = Bag{4, 5, 'test'} | false
> Bag{4, 5, 'test'} = Bag{4, 'test', 5} | false
> Bag{4, 5, 'test', 5} = Bag{4, 5, 'test'} | true

Back to Contents

### intersection ( bag : Bag(T) ) : Bag(T)

> Returns a Bag containing all elements of self that are also contained by bag.

> examples:

> Expression | Result
> --- | ---
> Bag{'a', 'b', 'a'}->intersection(Bag{'a', 'b'}) | Bag{'a', 'b'}
> Bag{'a', 'b', 'a', 'b'}->intersection(Bag{'a', 'b', 'b'}) | Bag{'b', 'a', 'b'}

Back to Contents

### intersection ( set : Set(T) ) : Set(T)

> Returns a Set containing all elements of self that are also contained by set.

> examples:

> Expression | Result
> --- | ---
> Bag{'a', 'b', 'a'}->intersection(Set{'a', 'b', 'c'}) | Set{'a', 'b'}

Back to Contents

### union ( bag : Bag(T) ) : Bag(T)

> Returns a Bag containing all elements of self and all elements of bag.

> examples:

> Expression | Result
> --- | ---
> Bag{'a', 'b', 'a'}->union(Bag{'b', 'c'}) | Bag{'b', 'a', 'b', 'a', 'c'}

Back to Contents

### union ( set : Set(T) ) : Bag(T)

> Returns a Bag containing all elements of self and all elements of set.

> examples:

> Expression | Result
> --- | ---
> Bag{'a', 'b', 'a'}->union(Set{'b', 'c'}) | Bag{'b', 'c', 'a', 'b', 'a'}

Back to Contents

## Ocl operations for type OrderedSet

### = ( set : Set(T) ) : Boolean

> Returns true if self contains the same objects as set.

> examples:

> Expression | Result
> --- | ---
> OrderedSet{3, 5, 4} = Set{3, 5, 4} | true
> OrderedSet{3, 5, 4} = Set{4, 3, 5, 4, 4} | true
> OrderedSet{3, 5, 4} = Set{2, 5 ,4, 4} | false

Back to Contents

### = ( orderedset : OrderedSet(T) ) : Boolean

> Returns true if self contains the same objects as orderedset regardless of element ordering.

> examples:

> Expression | Result
> --- | ---
> OrderedSet{3, 5, 4} = OrderedSet{3, 5, 4} | true
> OrderedSet{4, 5, 'test', 5} = OrderedSet{4, 5, 'test'} | true
> OrderedSet{4, 5, 'test'} = OrderedSet{4, 'test', 5} | true
> OrderedSet{4, 5, 'test'} = OrderedSet{4, 'test'} | false

Back to Contents

### <> ( set : Set(T) ) : Boolean

> Returns true if self does not contain the same objects as set.

> examples:

> Expression | Result
> --- | ---
> OrderedSet{4, 5, 'test', 4} <> Set{4, 5, 'test'} | false
> OrderedSet{4, 5, 'test', 4} <> Set{4, 'test', 5, 4} | false
> OrderedSet{4, 5, 'test', 4} <> Set{4, 5, 'test', 2} | true

Back to Contents

### <> ( orderedset : OrderedSet(T) ) : Boolean

> Returns true if self does not contain the same objects as orderedset.

> examples:

> Expression | Result
> --- | ---
> OrderedSet{4, 5, 'test', 4} <> OrderedSet{4, 5, 'test') | false
> OrderedSet{4, 5, 'test', 4} <> OrderedSet{4, 'test', 5, 4} | false
> OrderedSet{4, 5, 'test', 4} <> OrderedSet{4, 5, 'test', 2} | true

Back to Contents

### - ( set : Set(T) ) : Set(T)

> Returns a Set containing all elements of self minus all elements of set.

> examples:

> Expression | Result
> --- | ---
> OrderedSet{'a', 'b', 'c'} - Set{'c', 'a'} | Set{'b'}

Back to Contents

### append ( object : T ) : OrderedSet(T)

> Returns an OrderedSet containing all elements of self followed by object.

> examples:

> Expression | Result
> --- | ---
> OrderedSet{'a', 'b'}->append('c') | OrderedSet{'a', 'b', 'c'}

Back to Contents

### at ( index : Integer ) : T

> Returns the element of self located at position index in the collection.

> examples:

> Expression | Result
> --- | ---
> OrderedSet{'a', 'b'}->at(1) | 'a'

Back to Contents

### first () : T

> Returns the first element of self.

> examples:

> Expression | Result
> --- | ---
> OrderedSet{1, 2.0, '3'}->first() | 1

Back to Contents

### indexOf ( object : T ) : Integer

> Returns the position of object in self.

> examples:

> Expression | Result
> --- | ---
> OrderedSet{'a', 'b'}->indexOf('a') | 1

Back to Contents

### insertAt ( index : Integer, object : T ) : OrderedSet(T)

> Returns an OrderedSet containing self with object inserted at the index position.

> examples:

> Expression | Result
> --- | ---
> OrderedSet{'a', 'b'}->insertAt(1, 'c') | OrderedSet{'c', 'a', 'b'}
> OrderedSet{'a', 'b'}->insertAt(3, 'c') | OrderedSet{'a', 'b', 'c'}

Back to Contents

### intersection ( bag : Bag(T) ) : Set(T)

> Returns a Set containing all elements of self that are also contained by bag.

> examples:

> Expression | Result
> --- | ---
> OrderedSet{'a', 'b', 'a'}->intersection(Bag{'a', 'b'}) | Set{'a', 'b'}

Back to Contents

### intersection ( set : Set(T) ) : Set(T)

> Returns a Set containing all elements of self that are also contained by set.

> examples:

> Expression | Result
> --- | ---
> OrderedSet{'a', 'b', 'a'}->intersection(Set{'a', 'b'}) | Set{'b', 'a'}

Back to Contents

### last () : T

> Returns the last element of self.

> examples:

> Expression | Result
> --- | ---
> OrderedSet{1, 2.0, '3'}->last() | '3'

Back to Contents

### prepend ( object : T ) : OrderedSet(T)

> Returns an OrderedSet containing object followed by all elements of self.

> examples:

> Expression | Result
> --- | ---
> OrderedSet{'a', 'b'}->prepend('c') | OrderedSet{'c', 'a', 'b'}

Back to Contents

### subOrderedSet ( startIndex : Integer, endIndex : Integer ) : OrderedSet(T)

> Returns an OrderedSet containing all elements of self between the positions startIndex and endIndex.

> examples:

> Expression | Result
> --- | ---
> OrderedSet{'a', 'b', 'c', 'd'}->subOrderedSet(2, 3) | OrderedSet{'b', 'c'}
> OrderedSet{'a', 'b', 'c', 'd'}->subOrderedSet(4, 4) | OrderedSet{'d'}

Back to Contents

### symmetricDifference ( set : Set(T) ) : Set(T)

> Returns a Set containing all of the elements of self and set that are not present in both.

> examples:

> Expression | Result
> --- | ---
> OrderedSet{'b', 'a', 'b', 'c'}->symmetricDifference(Set{'a', 'c', 'd'}) | Set{'d', 'b'}

Back to Contents

### union ( bag : Bag(T) ) : Bag(T)

> Returns a Bag containing all elements of self followed by all elements of bag.

> examples:

> Expression | Result
> --- | ---
> OrderedSet{'a', 'b', 'a'}->union(Bag{'b', 'c'}) | Bag{'a', 'c', 'b', 'b'}

Back to Contents

### union ( set : Set(T) ) : Set(T)

> Returns a Set containing all elements of self followed by all elements of set.

> examples:

> Expression | Result
> --- | ---
> OrderedSet{'a', 'b', 'a'}->union(Set{'b', 'c'}) | Set{'a', 'c', 'b'}

Back to Contents

## Ocl operations for type Set

### = ( set : Set(T) ) : Boolean

> Returns true if self contains the same objects as set.

> examples:

> Expression | Result
> --- | ---
> Set{3, 5, 4} = Set{3, 5, 4} | true
> Set{3, 5, 4} = Set{3, 4, 4, 5} | true
> Set{3, 5, 4} = Set{2, 3, 5, 4} | false

Back to Contents

### <> ( set : Set(T) ) : Boolean

> Returns true if self does not contain the same objects as set.

> examples:

> Expression | Result
> --- | ---
> Set{4, 5, 'test', 4} <> Set{4, 5, 'test'} | false
> Set{4, 5, 'test', 4} <> Set{5, 4, 'test', 4} | false
> Set{4, 5, 'test', 4} <> Set{4, 'test', 5, 2} | true

Back to Contents

### - ( set : Set(T) ) : Set(T)

> Returns a Set containing all elements of self minus all elements of set.

> examples:

> Expression | Result
> --- | ---
> Set{'a', 'b', 'c'} - Set{'c', 'a'} | Set{'b'}

Back to Contents

### intersection ( bag : Bag(T) ) : Set(T)

> Returns a Bag containing all elements of self that are also contained in bag.

> examples:

> Expression | Result
> --- | ---
> Set{'a', 'b', 'a'}->intersection(Bag{'a', 'b', 'c'}) | Set{'a', 'b'}

Back to Contents

### intersection ( set : Set(T) ) : Set(T)

> Returns a Set containing all elements of self that are also contained in set.

> examples:

> Expression | Result
> --- | ---
> Set{'a', 'b', 'a'}->intersection(Set{'a', 'b', 'c'}) | Set{'b', 'a'}

Back to Contents

### symmetricDifference ( set : Set(T) ) : Set(T)

> Returns a Set containing all of the elements of self and set that are not present in both.

> examples:

> Expression | Result
> --- | ---
> Set{'b', 'a', 'b', 'c'}->symmetricDifference(Set{'a', 'c', 'd'}) | Set{'b', 'd'}

Back to Contents

### union ( bag : Bag(T) ) : Bag(T)

> Returns a Bag containing all elements of self and all elements of bag.

> examples:

> Expression | Result
> --- | ---
> Set{'a', 'b', 'a'}->union(Bag{'b', 'c'}) | Bag{'a', 'c', 'b', 'b'}

Back to Contents

### union ( set : Set(T) ) : Set(T)

> Returns a Set containing all elements of self and all elements of set.

> examples:

> Expression | Result
> --- | ---
> Set{'a', 'b', 'a'}->union(Set{'b', 'c'}) | Set{'a', 'c', 'b'}

Back to Contents

# Ocl operations for type Boolean

## And

> And | true | false | Ø
> --- | --- | --- | ---
> true | true | false | true
> false | false | false | false
> Ø | Ø | false | Ø

Back to Contents

## Implies

> Implies | true | false | Ø
> --- | --- | --- | ---
> true | true | false | Ø
> false | true | true | true
> Ø | true | Ø | Ø

Back to Contents

## Or

> Or | true | false | Ø
> --- | --- | --- | ---
> true | true | true | true
> false | true | false | Ø
> Ø | true | Ø | Ø

Back to Contents

## Not

> Not | Result
> --- | ---
> true | false
> false | true
> Ø | Ø

Back to Contents

## Xor

> Xor | true | false | Ø
> --- | --- | --- | ---
> true | false | true | Ø
> false | true | false | Ø
> Ø | Ø | Ø | Ø

Back to Contents

# Glossary

> invalid
>   invalid is the singleton instance of the OCLInvalid type. It is returned whenever an evaluation fails, whatever the cause. Referred to as Ø in this guide.
> Ø
>   See invalid.

Back to Contents