Jump to: navigation, search

Difference between revisions of "Acceleo/OCL Operations Reference"

(First version of the OCL operations reference)
 
(Formatting)
 
(12 intermediate revisions by the same user not shown)
Line 1: Line 1:
h3. OCL operation reference
+
= OCL operation reference =
  
  
Ocl operations for type *Classifier*
+
== Ocl operations for type *Classifier* ==
====================================
+
  
allInstances () : Set{T}
+
=== allInstances () : Set{T} ===
-----------------------------------------------------------------
+
Returns a Set containing all of the existing instances of the current classifier (along with instances of all its inherited classifiers).
  Returns a Set containing all of the existing instances of the current classifier (along with instances of all its
+
  inherited classifiers).
+
  
  examples:
+
{| border="1" cellpadding="5" cellspacing="0"
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| Result
 +
|-
 +
| let a : String = 'a', b : String = 'b', c : Integer = 2 in String.allInstances()
 +
| Set{'a','b'}
 +
|}
  
  .. class:: exampletable
 
  
  +----------------------------------------------------------------------------------+----------------+
+
== Ocl operations for type *OclAny* ==
  | Expression                                                                      | Result        |
+
  +==================================================================================+================+
+
  | let a : String = 'a', b : String = 'b', c : Integer = 2 in String.allInstances() | Set{'a','b'}  |
+
  +----------------------------------------------------------------------------------+----------------+
+
  
Back to Contents_
+
=== 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.
  
Ocl operations for type *OclAny*
+
{| border="1" cellpadding="5" cellspacing="0"
====================================
+
|-
 +
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| Result
 +
|-
 +
| aPerson.oclAsType(Employee)
 +
| an object of Employee type
 +
|}
  
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:
+
=== oclIsInvalid () : Boolean ===
 +
Returns '''true''' if '''self''' is equal to *invalid*.
  
  .. class:: exampletable
+
{| border="1" cellpadding="5" cellspacing="0"
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| 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
 +
|}
  
  +-------------------------------------------------------------+-----------------------------+
 
  | Expression                                                  | Result                      |
 
  +=============================================================+=============================+
 
  | aPerson.oclAsType(Employee)                                | an object of Employee type  |
 
  +-------------------------------------------------------------+-----------------------------+
 
  
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.
  
oclIsInvalid () : Boolean
+
{| border="1" cellpadding="5" cellspacing="0"
-----------------------------------------------------------------
+
|-
  Returns **true** if *self* is equal to *invalid*.
+
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| Result
 +
|-
 +
| anEmployee.oclIsKindOf(Employee)
 +
| true
 +
|-
 +
| anEmployee.oclIsKindOf(Person)
 +
| true
 +
|-
 +
| aCat.oclIsKindOf(Person)
 +
| false
 +
|}
  
  examples:
 
  
  .. class:: exampletable
+
=== 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'''.
  
  +--------------------------------------------------------------+--------+
+
{| border="1" cellpadding="5" cellspacing="0"
  | Expression                                                  | Result |
+
|-
  +==============================================================+========+
+
! style="background: #BCBCBC;" align="center"| Expression
  | let anObject : String = null in anObject.oclIsUndefined()   | false  |
+
! style="background: #BCBCBC;" align="center"| Result
  +--------------------------------------------------------------+--------+
+
|-
  | let anObject : String = invalid in anObject.oclIsUndefined() | true  |
+
| anEmployee.oclIsTypeOf(Employee)
  +--------------------------------------------------------------+--------+
+
| true
  | let anObject : String = 'null' in anObject.oclIsUndefined() | false |
+
|-
  +--------------------------------------------------------------+--------+
+
| anEmployee.oclIsTypeOf(Person)
 +
| false
 +
|-
 +
| aCat.oclIsTypeOf(Person)
 +
| false
 +
|}
  
Back to Contents_
 
  
oclIsKindOf( Classifier typespec ) : Boolean
+
=== oclIsUndefined () : Boolean ===
-----------------------------------------------------------------
+
Returns **true** if *self* is equal to *invalid* or *null*.
  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:
+
{| border="1" cellpadding="5" cellspacing="0"
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| 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
 +
|}
  
  .. class:: exampletable
 
  
  +----------------------------------+--------+
+
=== <> ( object : OclAny ) : Boolean ===
  | Expression                      | Result |
+
Returns **true** if *self* is a different object from *object*.
  +==================================+========+
+
  | anEmployee.oclIsKindOf(Employee) | true   |
+
  +----------------------------------+--------+
+
  | anEmployee.oclIsKindOf(Person)  | true  |
+
  +----------------------------------+--------+
+
  | aCat.oclIsKindOf(Person)        | false  |
+
  +----------------------------------+--------+
+
  
Back to Contents_
+
{| border="1" cellpadding="5" cellspacing="0"
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| 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
 +
|}
  
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:
 
  
  .. class:: exampletable
+
=== = ( object : OclAny) : Boolean ===
 +
Returns **true** if *self* is equal to *object*.
  
  +----------------------------------+--------+
+
{| border="1" cellpadding="5" cellspacing="0"
  | Expression                       | Result |
+
|-
  +==================================+========+
+
! style="background: #BCBCBC;" align="center"| Expression
  | anEmployee.oclIsTypeOf(Employee) | true   |
+
! style="background: #BCBCBC;" align="center"| Result
  +----------------------------------+--------+
+
|-
  | anEmployee.oclIsTypeOf(Person)  | false  |
+
| let a : String = 'a', b : String = 'a' in a = b
  +----------------------------------+--------+
+
| true
  | aCat.oclIsTypeOf(Person)        | false |
+
|-
  +----------------------------------+--------+
+
| 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_
 
  
oclIsUndefined () : Boolean
+
=== < ( object : T ) : Boolean ===
-----------------------------------------------------------------
+
Returns **true** if *self* is comparable to *object* and less than *object*.
  Returns **true** if *self* is equal to *invalid* or *null*.
+
  
  examples:
+
{| border="1" cellpadding="5" cellspacing="0"
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| 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
 +
|}
  
  .. class:: exampletable
 
  
  +--------------------------------------------------------------+--------+
+
=== > ( object : T ) : Boolean ===
  | Expression                                                  | Result |
+
Returns **true** if *self* is comparable to *object* and greater than *object*.
  +==============================================================+========+
+
  | 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_
+
{| border="1" cellpadding="5" cellspacing="0"
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| 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 : OclAny ) : Boolean
 
-----------------------------------------------------------------
 
  Returns **true** if *self* is a different object from *object*.
 
  
  examples:
+
=== <= ( object : T ) : Boolean ===
 +
Returns **true** if *self* is comparable to *object* and less than or equal to *object*.
  
  .. class:: exampletable
+
{| border="1" cellpadding="5" cellspacing="0"
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| 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
 +
|}
  
  +--------------------------------------------------+--------+
 
  | 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 : T ) : Boolean ===
 +
Returns **true** if *self* is comparable to *object* and greater than or equal to *object*.
  
= ( object : OclAny) : Boolean
+
{| border="1" cellpadding="5" cellspacing="0"
-----------------------------------------------------------------
+
|-
  Returns **true** if *self* is equal to *object*.
+
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| 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
 +
|}
  
  examples:
 
  
  .. class:: exampletable
+
== 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
  | Expression                                      | Result |
+
*invalid* whereas *'test'.at(1)* yields *'t'*. Likewise, *'test'.substring(2, 2)* returns *'e'*.
  +==================================================+========+
+
  | 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_
+
=== concat ( s : String ) : String ===
 +
Returns a string containing *self* followed by *s*.
  
< ( object : T ) : Boolean
+
{| border="1" cellpadding="5" cellspacing="0"
-----------------------------------------------------------------
+
|-
  Returns **true** if *self* is comparable to *object* and less than *object*.
+
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| Result
 +
|-
 +
| 'concat'.concat(' ').concat('operation')
 +
| 'concat operation'
 +
|}
  
  examples:
 
  
  .. class:: exampletable
+
=== size () : Integer ===
 +
Returns the number of characters composing *self*.
  
  +--------------------------------------------------------------+--------+
+
{| border="1" cellpadding="5" cellspacing="0"
  | Expression                                                  | Result |
+
|-
  +==============================================================+========+
+
! style="background: #BCBCBC;" align="center"| Expression
  | let a : Integer = 1, b : Integer = 2 in a < b                | true  |
+
! style="background: #BCBCBC;" align="center"| Result
  +--------------------------------------------------------------+--------+
+
|-
  | let a : Real = 1.5, b : Integer = 2 in a < b                | true  |
+
| 'size operation'.size()
  +--------------------------------------------------------------+--------+
+
| 14
  |let a : String = 'Anteater', b : String = 'Aardvark' in a < b | false  |
+
|}
  +--------------------------------------------------------------+--------+
+
  
Back to Contents_
 
  
> > ( object : T ) : Boolean
+
=== 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*.
  Returns **true** if *self* is comparable to *object* and greater than *object*.
+
  
  examples:
+
{| border="1" cellpadding="5" cellspacing="0"
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| Result
 +
|-
 +
| 'substring operation'.substring(11, 19)
 +
| 'operation'
 +
|-
 +
| 'substring operation'.substring(1, 1)
 +
| 's'
 +
|-
 +
| 'substring operation'.substring(0, 1)
 +
| '''''invalid'''''
 +
|}
  
  .. class:: exampletable
 
  
  +--------------------------------------------------------------+--------+
+
=== toInteger () : Integer ===
  | Expression                                                  | Result |
+
Returns an Integer of value equal to *self*, or |invalid| if *self* does not represent an integer.
  +==============================================================+========+
+
  | 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_
+
{| border="1" cellpadding="5" cellspacing="0"
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| Result
 +
|-
 +
| '3.0'.toInteger()
 +
| '''''invalid'''''
 +
|-
 +
| '4'.toInteger()
 +
| 4
 +
|-
 +
| 'toInteger'.toInteger()
 +
| '''''invalid'''''
 +
|}
  
<= ( object : T ) : Boolean
 
-----------------------------------------------------------------
 
  Returns **true** if *self* is comparable to *object* and less than or equal to *object*.
 
  
  examples:
+
=== toLower () : String ===
 +
Returns *self* with all characters converted to lowercase.
  
  .. class:: exampletable
+
{| border="1" cellpadding="5" cellspacing="0"
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| Result
 +
|-
 +
| 'LoWeR OpErAtIoN'.toLower()
 +
| 'lower operation'
 +
|}
  
  +---------------------------------------------------------------+--------+
 
  | 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_
+
=== toReal () : Real ===
 +
Returns a Real of value equal to *self*, or |invalid| if *self* does not represent a real.
  
> >= ( object : T ) : Boolean
+
{| border="1" cellpadding="5" cellspacing="0"
-----------------------------------------------------------------
+
|-
  Returns **true** if *self* is comparable to *object* and greater than or equal to *object*.
+
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| Result
 +
|-
 +
| '3.0'.toReal()
 +
| 3.0
 +
|-
 +
| '4'.toReal()
 +
| 4.0
 +
|-
 +
| 'toReal'.toReal()
 +
| '''''invalid'''''
 +
|}
  
  examples:
 
  
  .. class:: exampletable
+
=== toUpper () : String ===
 +
Returns *self* with all characters converted to uppercase.
  
  +---------------------------------------------------------------+--------+
+
{| border="1" cellpadding="5" cellspacing="0"
  | Expression                                                    | Result |
+
|-
  +===============================================================+========+
+
! style="background: #BCBCBC;" align="center"| Expression
  | let a : Integer = 1, b : Integer = 2 in a >= b                | false  |
+
! style="background: #BCBCBC;" align="center"| Result
  +---------------------------------------------------------------+--------+
+
|-
  | let a : Real = 1.5, b : Integer = 2 in a >= b                | false  |
+
| 'UpPeR OpErAtIoN'.toUpper()
  +---------------------------------------------------------------+--------+
+
| 'UPPER OPERATION'
  |let a : String = 'Anteater', b : String = 'Aardvark' in a >= b | true  |
+
|}
  +---------------------------------------------------------------+--------+
+
  
Back to Contents_
 
  
Ocl operations for type *String*
+
== 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.
  
**A note on Strings** : OCL Strings begin at index *1*, not *0* as in most languages. Thus *'test'.at(0)* fails in
+
=== Number::abs () : Number ===
*invalid* whereas *'test'.at(1)* yields *'t'*. Likewise, *'test'.substring(2, 2)* returns *'e'*.
+
Returns the absolute value of *self*, *self* if it is already a positive number.
  
concat ( s : String ) : String
+
{| border="1" cellpadding="5" cellspacing="0"
-----------------------------------------------------------------
+
|-
  Returns a string containing *self* followed by *s*.
+
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| Result
 +
|-
 +
| (-2.3).abs()
 +
| 2.3
 +
|-
 +
| -5.abs()
 +
| 5
 +
|}
  
  examples:
 
  
  .. class:: exampletable
+
=== Number::floor () : Integer ===
 +
Returns the integer part of *self* if it is a Real, *self* if it is an Integer.
  
  +-------------------------------------------------------------------+--------------------+
+
{| border="1" cellpadding="5" cellspacing="0"
  | Expression                                                        | Result            |
+
|-
  +===================================================================+====================+
+
! style="background: #BCBCBC;" align="center"| Expression
  | 'concat'.concat(' ').concat('operation')                         | 'concat operation' |
+
! style="background: #BCBCBC;" align="center"| Result
  +-------------------------------------------------------------------+--------------------+
+
|-
 +
| (2.3).floor()
 +
| 2
 +
|-
 +
| (2.8).floor()
 +
| 2
 +
|-
 +
| 2.floor()
 +
| 2
 +
|}
  
Back to Contents_
 
  
size () : Integer
+
=== Number::max ( r : Number ) : Number ===
-----------------------------------------------------------------
+
Returns the greatest number between *self* and *r*.
  Returns the number of characters composing *self*.
+
  
  examples:
+
{| border="1" cellpadding="5" cellspacing="0"
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| Result
 +
|-
 +
| 6.max(3)
 +
| 6
 +
|-
 +
| 6.max(5.2)
 +
| 6.0
 +
|-
 +
| (2.3).max(3)
 +
| 3.0
 +
|-
 +
| (2.3).max(5.2)
 +
| 5.2
 +
|}
  
  .. class:: exampletable
 
  
  +-------------------------------------------------------------+--------+
+
=== Number::min ( r : Number ) : Number ===
  | Expression                                                  | Result |
+
Returns the lowest number between *self* and *r*.
  +=============================================================+========+
+
  | 'size operation'.size()                                    | 14    |
+
  +-------------------------------------------------------------+--------+
+
  
Back to Contents_
+
{| border="1" cellpadding="5" cellspacing="0"
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| Result
 +
|-
 +
| 6.min(3)
 +
| 3
 +
|-
 +
| 6.min(5.2)
 +
| 5.2
 +
|-
 +
| (2.3).min(3)
 +
| 2.3
 +
|-
 +
| (2.3).min(5.2)
 +
| 2.3
 +
|}
  
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:
+
=== Number::round () : Integer ===
 +
Returns the nearest integer to *self* if it is a Real, *self* if it is an Integer.
  
  .. class:: exampletable
+
{| border="1" cellpadding="5" cellspacing="0"
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| Result
 +
|-
 +
| (2.3).round()
 +
| 2
 +
|-
 +
| (2.5).round()
 +
| 3
 +
|-
 +
| (2.8).round()
 +
| 3
 +
|-
 +
| 2.round()
 +
| 2
 +
|}
  
  +---------------------------------------------------------------+----------------+
 
  | Expression                                                    | Result        |
 
  +===============================================================+================+
 
  | 'substring operation'.substring(11, 19)                      | 'operation'    |
 
  +---------------------------------------------------------------+----------------+
 
  | 'substring operation'.substring(1, 1)                        | 's'            |
 
  +---------------------------------------------------------------+----------------+
 
  | 'substring operation'.substring(0, 1)                        | |invalid|      |
 
  +---------------------------------------------------------------+----------------+
 
  
Back to Contents_
+
=== Integer::div ( i : Integer ) : Integer ===
 +
Returns the integer quotient of the division of *self* by *i*.
  
toInteger () : Integer
+
{| border="1" cellpadding="5" cellspacing="0"
-----------------------------------------------------------------
+
|-
  Returns an Integer of value equal to *self*, or |invalid| if *self* does not represent an integer.
+
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| Result
 +
|-
 +
| 3.div(2)
 +
| 1
 +
|-
 +
| 11.div(3)
 +
| 3
 +
|}
 +
 
  
  examples:
+
=== Integer::mod ( i : Integer ) : Integer ===
 +
Returns the integer remainder of the division of *self* by *i*.
  
  .. class:: exampletable
+
{| border="1" cellpadding="5" cellspacing="0"
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| Result
 +
|-
 +
| 3.mod(2)
 +
| 1
 +
|-
 +
| 11.mod(3)
 +
| 2
 +
|}
  
  +---------------------------------------------------------------+----------------+
 
  | Expression                                                    | Result        |
 
  +===============================================================+================+
 
  | '3.0'.toInteger()                                            | |invalid|      |
 
  +---------------------------------------------------------------+----------------+
 
  | '4'.toInteger()                                              | 4              |
 
  +---------------------------------------------------------------+----------------+
 
  | 'toInteger'.toInteger()                                      | |invalid|      |
 
  +---------------------------------------------------------------+----------------+
 
  
Back to Contents_
+
== Ocl operations for type *Collection* ==
  
toLower () : String
+
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.
-----------------------------------------------------------------
+
  Returns *self* with all characters converted to lowercase.
+
  
  examples:
 
  
  .. class:: exampletable
+
{| border="1" cellpadding="5" cellspacing="0" align="center"
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Collection type
 +
! style="background: #BCBCBC;" align="center"| Ordered
 +
! style="background: #BCBCBC;" align="center"| Unique
 +
|-
 +
| Sequence
 +
| true
 +
| false
 +
|-
 +
| OrderedSet
 +
| true
 +
| true
 +
|-
 +
| Bag
 +
| false
 +
| false
 +
|-
 +
| Set
 +
| false
 +
| true
 +
|-
 +
|}
  
  +------------------------------------------------------------+-------------------+
 
  | Expression                                                | Result            |
 
  +============================================================+===================+
 
  | 'LoWeR OpErAtIoN'.toLower()                                | 'lower operation' |
 
  +------------------------------------------------------------+-------------------+
 
  
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*.
  
toReal () : Real
+
{| border="1" cellpadding="5" cellspacing="0"
-----------------------------------------------------------------
+
|-
  Returns a Real of value equal to *self*, or |invalid| if *self* does not represent a real.
+
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| 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
 +
|}
  
  examples:
 
  
  .. class:: exampletable
+
=== asBag () : Bag(T) ===
 +
Returns a Bag containing all elements of *self*.
  
  +---------------------------------------------------------------+----------------+
+
{| border="1" cellpadding="5" cellspacing="0"
  | Expression                                                    | Result        |
+
|-
  +===============================================================+================+
+
! style="background: #BCBCBC;" align="center"| Expression
  | '3.0'.toReal()                                               | 3.0           |
+
! style="background: #BCBCBC;" align="center"| Result
  +---------------------------------------------------------------+----------------+
+
|-
  | '4'.toReal()                                                 | 4.0           |
+
| Sequence{'3', 1, 2.0, '3'}->asBag()
  +---------------------------------------------------------------+----------------+
+
| Bag{2.0, '3', 1, '3'}
  | 'toReal'.toReal()                                             | |invalid|     |
+
|-
  +---------------------------------------------------------------+----------------+
+
| 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_
 
  
toUpper () : String
+
=== asOrderedSet () : OrderedSet(T) ===
-----------------------------------------------------------------
+
Returns an OrderedSet containing all elements of *self*. Element ordering is preserved when possible.
  Returns *self* with all characters converted to uppercase.
+
  
  examples:
+
{| border="1" cellpadding="5" cellspacing="0"
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| 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}
 +
|}
  
  .. class:: exampletable
 
  
  +------------------------------------------------------------+-------------------+
+
=== asSequence () : Boolean ===
  | Expression                                                | Result            |
+
Returns a Sequence containing all elements of *self*. Element ordering is preserved when possible.
  +============================================================+===================+
+
  | 'UpPeR OpErAtIoN'.toUpper()                                | 'UPPER OPERATION' |
+
  +------------------------------------------------------------+-------------------+
+
  
Back to Contents_
+
{| border="1" cellpadding="5" cellspacing="0"
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| 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}
 +
|}
  
Ocl operations for type *Number*
 
====================================
 
  
In addition to the basic math functions (+, -, /, \*) are a number of advanced functions. Take note that *Number*
+
=== asSet () : Set(T) ===
denotes both *Integer* and *Real*, and they're substitutive unless otherwise specified.
+
Returns a Set containing all elements of *self*.
  
Number::abs () : Number
+
{| border="1" cellpadding="5" cellspacing="0"
-----------------------------------------------------------------
+
|-
  Returns the absolute value of *self*, *self* if it is already a positive number.
+
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| 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}
 +
|}
  
  examples:
 
  
  .. class:: exampletable
+
=== collect ( expr : OclExpression ) : Collection(T2) ===
 +
Returns a collection containing the result of applying *expr* on all elements contained in *self*.
  
  +---------------------------------------------------------------+----------------+
+
{| border="1" cellpadding="5" cellspacing="0"
  | Expression                                                    | Result        |
+
|-
  +===============================================================+================+
+
! style="background: #BCBCBC;" align="center"| Expression
  | (-2.3).abs()                                                  | 2.3            |
+
! style="background: #BCBCBC;" align="center"| Result
  +---------------------------------------------------------------+----------------+
+
|-
  | -5.abs()                                                     | 5              |
+
| Sequence{'first', 'second'}->collect(toUpper())
  +---------------------------------------------------------------+----------------+
+
| Sequence{'FIRST', 'SECOND'}
 +
|}
  
Back to Contents_
 
  
Number::floor () : Integer
+
=== 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*.
  Returns the integer part of *self* if it is a Real, *self* if it is an Integer.
+
  
  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}*.
  
  .. class:: exampletable
+
{| border="1" cellpadding="5" cellspacing="0"
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| Result
 +
|-
 +
| self.persons->collectNested(children.firstname)
 +
| Sequence{Sequence{James, Jane}, Sequence{John}}
 +
|}
  
  +---------------------------------------------------------------+----------------+
 
  | Expression                                                    | Result        |
 
  +===============================================================+================+
 
  | (2.3).floor()                                                | 2              |
 
  +---------------------------------------------------------------+----------------+
 
  | (2.8).floor()                                                | 2              |
 
  +---------------------------------------------------------------+----------------+
 
  | 2.floor()                                                    | 2              |
 
  +---------------------------------------------------------------+----------------+
 
  
Back to Contents_
+
=== count ( object : T ) : Integer ===
 +
Returns how many times *object* is in the collection *self*.
  
Number::max ( r : Number ) : Number
+
{| border="1" cellpadding="5" cellspacing="0"
-----------------------------------------------------------------
+
|-
  Returns the greatest number between *self* and *r*.
+
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| 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
 +
|}
  
  examples:
 
  
  .. class:: exampletable
+
=== excludes ( object : T ) : Boolean ===
 +
Returns **true** if *object* is not contained in *self*, **false** otherwise.
  
  +---------------------------------------------------------------+----------------+
+
{| border="1" cellpadding="5" cellspacing="0"
  | Expression                                                    | Result        |
+
|-
  +===============================================================+================+
+
! style="background: #BCBCBC;" align="center"| Expression
  | 6.max(3)                                                      | 6              |
+
! style="background: #BCBCBC;" align="center"| Result
  +---------------------------------------------------------------+----------------+
+
|-
  | 6.max(5.2)                                                    | 6.0            |
+
| Sequence{2.3}->excludes(2.1)
  +---------------------------------------------------------------+----------------+
+
| true
  | (2.3).max(3)                                                  | 3.0            |
+
|-
  +---------------------------------------------------------------+----------------+
+
| Sequence{2.0}->excludes(2)
  | (2.3).max(5.2)                                               | 5.2            |
+
| false
  +---------------------------------------------------------------+----------------+
+
|}
  
Back to Contents_
 
  
Number::min ( r : Number ) : Number
+
=== excludesAll ( c2 : Collection(T) ) : Boolean ===
-----------------------------------------------------------------
+
Returns **true** if no element of *c2* is contained in *self*, **false** otherwise.
  Returns the lowest number between *self* and *r*.
+
  
  examples:
+
{| border="1" cellpadding="5" cellspacing="0"
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| 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
 +
|}
  
  .. class:: exampletable
 
  
  +---------------------------------------------------------------+----------------+
+
=== excluding ( object : T ) : Collection(T) ===
  | Expression                                                    | Result        |
+
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.
  +===============================================================+================+
+
  | 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_
+
{| border="1" cellpadding="5" cellspacing="0"
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| 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'}
 +
|}
  
Number::round () : Integer
 
-----------------------------------------------------------------
 
  Returns the nearest integer to *self* if it is a Real, *self* if it is an Integer.
 
  
  examples:
+
=== 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.
  
  .. class:: exampletable
+
{| border="1" cellpadding="5" cellspacing="0"
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| Result
 +
|-
 +
| Sequence{2.3, 5.2}->exists(self > 3)
 +
| true
 +
|}
  
  +---------------------------------------------------------------+----------------+
 
  | Expression                                                    | Result        |
 
  +===============================================================+================+
 
  | (2.3).round()                                                | 2              |
 
  +---------------------------------------------------------------+----------------+
 
  | (2.5).round()                                                | 3              |
 
  +---------------------------------------------------------------+----------------+
 
  | (2.8).round()                                                | 3              |
 
  +---------------------------------------------------------------+----------------+
 
  | 2.round()                                                    | 2              |
 
  +---------------------------------------------------------------+----------------+
 
  
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.
  
Integer::div ( i : Integer ) : Integer
+
{| border="1" cellpadding="5" cellspacing="0"
-----------------------------------------------------------------
+
|-
  Returns the integer quotient of the division of *self* by *i*.
+
! style="background: #BCBCBC;" align="center"| Expression
 
+
! style="background: #BCBCBC;" align="center"| Result
  examples:
+
|-
 +
| 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}
 +
|}
  
  .. class:: exampletable
 
  
  +---------------------------------------------------------------+----------------+
+
=== forAll ( expr : OclExpression ) : Boolean ===
  | Expression                                                    | Result        |
+
Returns **true** if the all the elements contained in *self* validate the condition *expr*, **false** otherwise.
  +===============================================================+================+
+
  | 3.div(2)                                                      | 1              |
+
  +---------------------------------------------------------------+----------------+
+
  | 11.div(3)                                                    | 3              |
+
  +---------------------------------------------------------------+----------------+
+
 
+
Back to Contents_
+
  
Integer::mod ( i : Integer ) : Integer
+
{| border="1" cellpadding="5" cellspacing="0"
-----------------------------------------------------------------
+
|-
  Returns the integer remainder of the division of *self* by *i*.
+
! style="background: #BCBCBC;" align="center"| Expression
 
+
! style="background: #BCBCBC;" align="center"| Result
  examples:
+
|-
 +
| Sequence{2.3, 5.2}->forAll(self > 3)
 +
| false
 +
|-
 +
| Sequence{2.3, 5.2}->forAll(self > 1.2)
 +
| true
 +
|}
  
  .. class:: exampletable
 
  
  +---------------------------------------------------------------+----------------+
+
=== includes ( object : T ) : Boolean ===
  | Expression                                                    | Result        |
+
Returns **true** if *object* is contained in *self*, **false** otherwise.
  +===============================================================+================+
+
  | 3.mod(2)                                                      | 1              |
+
  +---------------------------------------------------------------+----------------+
+
  | 11.mod(3)                                                    | 2              |
+
  +---------------------------------------------------------------+----------------+
+
  
Back to Contents_
+
{| border="1" cellpadding="5" cellspacing="0"
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| Result
 +
|-
 +
| Sequence{2.3}->includes(2.1)
 +
| false
 +
|-
 +
| Sequence{2.0}->includes(2)
 +
| true
 +
|}
  
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.
+
=== includesAll ( c2 : Collection(T) ) : Boolean ===
 +
Returns **true** if all element of *c2* are contained in *self*, **false** otherwise.
  
.. list-table::
+
{| border="1" cellpadding="5" cellspacing="0"
:header-rows: 1
+
|-
:stub-columns: 1
+
! style="background: #BCBCBC;" align="center"| Expression
         
+
! style="background: #BCBCBC;" align="center"| Result
* - Collection type
+
|-
  - Ordered
+
| Sequence{2.3, 5.2, 'a', 3, null}->includesAll(Set{3, null})
  - Unique
+
| true
* - Sequence
+
|-
  - true
+
| Sequence{2.3, 5.2, 'a', 3}->includesAll(Set{3, null})
  - false
+
| false
* - OrderedSet
+
|}
  - true
+
  - true
+
* - Bag
+
  - false
+
  - false
+
* - Set
+
  - false
+
  - true
+
  
Back to Contents_
 
  
any ( expr : OclExpression ) : T
+
=== 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.
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:
+
  
.. class:: exampletable
+
{| border="1" cellpadding="5" cellspacing="0"
+
|-
+---------------------------------------------------------------+----------------+
+
! style="background: #BCBCBC;" align="center"| Expression
| Expression                                                   | Result         |
+
! style="background: #BCBCBC;" align="center"| Result
+===============================================================+================+
+
|-
| Sequence{1.2, 2.3, 5.2, 0.9}->any(self < 1)                   | 0.9            |
+
| Sequence{'a', 'b'}->including('c')
+---------------------------------------------------------------+----------------+
+
| Sequence{'a', 'b', 'c'}
| Sequence{1.2, 2.3, 5.2, 0.9}->any(self < 2)                   | 1.2            |
+
|-
+---------------------------------------------------------------+----------------+
+
| 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_
 
  
asBag () : Bag(T)
+
=== isEmpty () : Boolean ===
-----------------------------------------------------------------
+
Returns **true** if *self* is empty, **false** otherwise.
Returns a Bag containing all elements of *self*.
+
+
examples:
+
+
.. class:: exampletable
+
+
+-------------------------------------------------------+-----------------------+
+
| 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_
+
{| border="1" cellpadding="5" cellspacing="0"
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| Result
 +
|-
 +
| Sequence{2, 'a'}->isEmpty()
 +
| false
 +
|-
 +
| Sequence{null}->isEmpty()
 +
| false
 +
|-
 +
| Sequence{}->isEmpty()
 +
| true
 +
|}
  
asOrderedSet () : OrderedSet(T)
 
-----------------------------------------------------------------
 
Returns an OrderedSet containing all elements of *self*. Element ordering is preserved when possible.
 
 
examples:
 
 
.. class:: exampletable
 
 
+-------------------------------------------------------+-------------------------+
 
| 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_
+
=== isUnique ( expr : OclExpression ) : Boolean ===
 +
Returns **true** if all elements contained in *self* evaluate to a distinct value for *expr*.
  
asSequence () : Boolean
+
{| border="1" cellpadding="5" cellspacing="0"
-----------------------------------------------------------------
+
|-
Returns a Sequence containing all elements of *self*. Element ordering is preserved when possible.
+
! style="background: #BCBCBC;" align="center"| Expression
+
! style="background: #BCBCBC;" align="center"| Result
examples:
+
|-
+
| Sequence{2.3, 5.2}->isUnique(self > 3)
.. class:: exampletable
+
| true
+
|-
+-------------------------------------------------------+-----------------------+
+
| Sequence{2.3, 5.2}->isUnique(self > 1)
| Expression                                           | Result                |
+
| false
+=======================================================+=======================+
+
|}
| 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)
+
=== notEmpty () : Boolean ===
-----------------------------------------------------------------
+
Returns **true** if *self* contains at least one element, **false** otherwise.
Returns a Set containing all elements of *self*.
+
+
examples:
+
+
.. class:: exampletable
+
+
+-------------------------------------------------------+-----------------------+
+
| 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_
+
{| border="1" cellpadding="5" cellspacing="0"
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| Result
 +
|-
 +
| Sequence{2, 'a'}->notEmpty()
 +
| true
 +
|-
 +
| Sequence{null}->notEmpty()
 +
| true
 +
|-
 +
| Sequence{}->notEmpty()
 +
| false
 +
|}
  
collect ( expr : OclExpression ) : Collection(T2)
 
-----------------------------------------------------------------
 
Returns a collection containing the result of applying *expr* on all elements contained in *self*.
 
 
examples:
 
  
.. class:: exampletable
+
=== 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{'first', 'second'}->collect(toUpper())              | Sequence{'FIRST', 'SECOND'} |
+
+---------------------------------------------------------------+-----------------------------+
+
  
Back to Contents_
+
{| border="1" cellpadding="5" cellspacing="0"
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| 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
 +
|}
  
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}*.
 
 
.. class:: exampletable
 
 
+-------------------------------------------------------+-------------------------------------------------+
 
| Expression                                            | Result                                          |
 
+=======================================================+=================================================+
 
| self.persons->collectNested(children.firstname)      | Sequence{Sequence{James, Jane}, Sequence{John}} |
 
+-------------------------------------------------------+-------------------------------------------------+
 
  
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*.
  
count ( object : T ) : Integer
+
{| border="1" cellpadding="5" cellspacing="0"
-----------------------------------------------------------------
+
|-
  Returns how many times *object* is in the collection *self*.
+
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| 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}}
 +
|}
  
  examples:
 
  
  .. class:: exampletable
+
=== reject ( expr : OclExpression ) : Collection(T) ===
 +
Returns a collection with all elements of *self* except for those who validate the OclExpression *expr*.
  
  +---------------------------------------------------------------+----------------+
+
{| border="1" cellpadding="5" cellspacing="0"
  | Expression                                                    | Result        |
+
|-
  +===============================================================+================+
+
! style="background: #BCBCBC;" align="center"| Expression
  | Sequence{2.3, 5.2}->count(5.2)                               | 1             |
+
! style="background: #BCBCBC;" align="center"| Result
  +---------------------------------------------------------------+----------------+
+
|-
  | Set{3, 'test', 4.0, 4, 4.0, 'test'}->count(null)             | 0              |
+
| Sequence{1, 2, 3}->reject(i : Integer | i > 1 )
  +---------------------------------------------------------------+----------------+
+
| Sequence{1}
  | Set{3, null, 4.0, null, 'test'}->count(null)                 | 1             |
+
|-
  +---------------------------------------------------------------+----------------+
+
| Bag{1, 2, 3}->reject(i : Integer | i > 1 )
  | Bag{3, null, 4.0, null, 'test'}->count(null)                 | 2              |
+
| 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_
 
  
excludes ( object : T ) : Boolean
+
=== select ( expr : OclExpression ) : Collection(T) ===
-----------------------------------------------------------------
+
Returns a collection with all elements of *self* that validate the OclExpression *expr*.
Returns **true** if *object* is not contained in *self*, **false** otherwise.
+
+
examples:
+
  
.. class:: exampletable
+
{| border="1" cellpadding="5" cellspacing="0"
+
|-
+---------------------------------------------------------------+----------------+
+
! style="background: #BCBCBC;" align="center"| Expression
| Expression                                                   | Result        |
+
! style="background: #BCBCBC;" align="center"| Result
+===============================================================+================+
+
|-
| Sequence{2.3}->excludes(2.1)                                 | true          |
+
| Sequence{1, 2, 3}->select(i : Integer | i > 1)
+---------------------------------------------------------------+----------------+
+
| Sequence{2, 3}
| Sequence{2.0}->excludes(2)                                   | false          |
+
|-
+---------------------------------------------------------------+----------------+
+
| 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_
 
  
excludesAll ( c2 : Collection(T) ) : Boolean
+
=== size () : Integer ===
-----------------------------------------------------------------
+
Returns the number of elements contained in *self*.
Returns **true** if no element of *c2* is contained in *self*, **false** otherwise.
+
+
examples:
+
  
.. class:: exampletable
+
{| border="1" cellpadding="5" cellspacing="0"
+
|-
+---------------------------------------------------------------+----------------+
+
! style="background: #BCBCBC;" align="center"| Expression
| Expression                                                   | Result        |
+
! style="background: #BCBCBC;" align="center"| Result
+===============================================================+================+
+
|-
| Sequence{2.3, 5.2, 'a', 3, null}->excludesAll(Set{4, null})   | false          |
+
| Sequence{2.3, 5}->size()
+---------------------------------------------------------------+----------------+
+
| 2
| Sequence{2.3, 5.2, 'a', 3}->excludesAll(Set{4, null})         | true          |
+
|-
+---------------------------------------------------------------+----------------+
+
| Sequence{}->size()
 +
| 0
 +
|}
  
Back to Contents_
 
  
excluding ( object : T ) : Collection(T)
+
=== sortedBy ( expr : OclExpression ) : Sequence(T) ===
-----------------------------------------------------------------
+
Returns a sorted collection containing all elements from *self* sorted in accordance with the OclExpression *expr*.
Returns a collection containing all elements of *self* minus all occurences of *object*.
+
This can be used on all kind of collections yet will always yield a Sequence-typed result except for OrderedSet which returns an OrderedSet.
**Note** : at the time of writing, the OCL standard library sports a bug which changes *OrderedSets* in *Sets* when
+
excluding elements.
+
+
examples:
+
+
.. class:: exampletable
+
+
+-----------------------------------------------------+-------------------------+
+
| 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_
+
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*.
  
exists ( expr : OclExpression ) : Boolean
+
{| border="1" cellpadding="5" cellspacing="0"
-----------------------------------------------------------------
+
|-
Returns **true** if at least one element in *self* validates the condition *expr*, **false** otherwise. The evaluation
+
! style="background: #BCBCBC;" align="center"| Expression
stops as soon as one element validating *expr* is found.
+
! style="background: #BCBCBC;" align="center"| Result
+
|-
examples:
+
| self.employees->sortedBy(age)
 +
| Sequence{employee1, employee2}
 +
|}
  
.. class:: exampletable
 
 
+---------------------------------------------------------------+----------------+
 
| Expression                                                    | Result        |
 
+===============================================================+================+
 
| Sequence{2.3, 5.2}->exists(self > 3)                          | true          |
 
+---------------------------------------------------------------+----------------+
 
  
Back to Contents_
+
=== sum () : Real ===
 +
Returns the sum of all elements contained in *self* if they support the '+' operation.
  
flatten () : Collection(T2)
+
{| border="1" cellpadding="5" cellspacing="0"
-----------------------------------------------------------------
+
|-
Returns a collection containing all elements of *self* recursively flattened.
+
! style="background: #BCBCBC;" align="center"| Expression
**Note** : at the time of writing, the OCL standard library sports a bug which changes *OrderedSets* in *Sets* when
+
! style="background: #BCBCBC;" align="center"| Result
flattening.
+
|-
+
| Sequence{2.3, 5.2} in c->sum()
examples:
+
| 7.5
+
|-
.. class:: exampletable
+
| Sequence{2, 4} in c->sum()
+
| 6
+---------------------------------------------------------------------------+-------------------------------------+
+
|-
| Expression                                                               | Result                              |
+
| Sequence{2, '4'} in c->sum()
+===========================================================================+=====================================+
+
| '''''invalid'''''
| 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
+
== Ocl operations for type *Sequence* ==
-----------------------------------------------------------------
+
Returns **true** if the all the elements contained in *self* validate the condition *expr*, **false** otherwise.
+
+
examples:
+
  
.. class:: exampletable
+
=== = ( 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{2.3, 5.2}->forAll(self > 3)                          | false          |
+
+---------------------------------------------------------------+----------------+
+
| Sequence{2.3, 5.2}->forAll(self > 1.2)                        | true          |
+
+---------------------------------------------------------------+----------------+
+
  
Back to Contents_
+
{| border="1" cellpadding="5" cellspacing="0"
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| 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
 +
|}
  
includes ( object : T ) : Boolean
 
-----------------------------------------------------------------
 
Returns **true** if *object* is contained in *self*, **false** otherwise.
 
 
 
examples:
+
=== <> ( 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*.
  
.. class:: exampletable
+
{| border="1" cellpadding="5" cellspacing="0"
+
|-
+---------------------------------------------------------------+----------------+
+
! style="background: #BCBCBC;" align="center"| Expression
| Expression                                                   | Result        |
+
! style="background: #BCBCBC;" align="center"| Result
+===============================================================+================+
+
|-
| Sequence{2.3}->includes(2.1)                                  | false         |
+
| Sequence{4, 5, 'test'} = Sequence{4, 5, 'test'}
+---------------------------------------------------------------+----------------+
+
| false
| Sequence{2.0}->includes(2)                                    | true           |
+
|-
+---------------------------------------------------------------+----------------+
+
| Sequence{4, 5, 'test'} = Sequence{4, 'test', 5}
 +
| true
 +
|-
 +
| Sequence{4, 5, 'test', 5} = Sequence{4, 5, 'test'}
 +
| true
 +
|}
  
Back to Contents_
 
  
includesAll ( c2 : Collection(T) ) : Boolean
+
=== append ( object : T ) : Sequence(T) ===
-----------------------------------------------------------------
+
Returns a Sequence containing all elements of *self* followed by *object*.
Returns **true** if all element of *c2* are contained in *self*, **false** otherwise.
+
+
examples:
+
  
.. class:: exampletable
+
{| border="1" cellpadding="5" cellspacing="0"
+
|-
+---------------------------------------------------------------+----------------+
+
! style="background: #BCBCBC;" align="center"| Expression
| Expression                                                   | Result        |
+
! style="background: #BCBCBC;" align="center"| Result
+===============================================================+================+
+
|-
| Sequence{2.3, 5.2, 'a', 3, null}->includesAll(Set{3, null})   | true          |
+
| Sequence{'a', 'b'}->append('c')
+---------------------------------------------------------------+----------------+
+
| Sequence{'a', 'b', 'c'}
| Sequence{2.3, 5.2, 'a', 3}->includesAll(Set{3, null})        | false          |
+
|}
+---------------------------------------------------------------+----------------+
+
  
Back to Contents_
 
  
including ( object : T ) : Collection(T)
+
=== at ( index : Integer ) : T ===
-----------------------------------------------------------------
+
Returns the element of *self* at the *index* position.
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:
+
+
.. class:: exampletable
+
+
+-----------------------------------------------------+-------------------------+
+
| 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_
+
{| border="1" cellpadding="5" cellspacing="0"
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| Result
 +
|-
 +
| Sequence{'a', 'b'}->at(1)
 +
| a
 +
|}
  
isEmpty () : Boolean
 
-----------------------------------------------------------------
 
Returns **true** if *self* is empty, **false** otherwise.
 
 
examples:
 
  
.. class:: exampletable
+
=== first () : T ===
+
Returns the first element of *self*.
+---------------------------------------------------------------+----------------+
+
| Expression                                                    | Result        |
+
+===============================================================+================+
+
| Sequence{2, 'a'}->isEmpty()                                  | false          |
+
+---------------------------------------------------------------+----------------+
+
| Sequence{null}->isEmpty()                                    | false          |
+
+---------------------------------------------------------------+----------------+
+
| Sequence{}->isEmpty()                                        | true          |
+
+---------------------------------------------------------------+----------------+
+
  
Back to Contents_
+
{| border="1" cellpadding="5" cellspacing="0"
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| Result
 +
|-
 +
| Sequence{1, 2.0, '3'}->first()
 +
| 1
 +
|}
  
isUnique ( expr : OclExpression ) : Boolean
 
-----------------------------------------------------------------
 
Returns **true** if all elements contained in *self* evaluate to a distinct value for *expr*.
 
 
examples:
 
  
.. class:: exampletable
+
=== indexOf ( object : T ) : Integer ===
+
Returns the position of *object* in sequence *self*.
+---------------------------------------------------------------+----------------+
+
| Expression                                                    | Result        |
+
+===============================================================+================+
+
| Sequence{2.3, 5.2}->isUnique(self > 3)                        | true          |
+
+---------------------------------------------------------------+----------------+
+
| Sequence{2.3, 5.2}->isUnique(self > 1)                        | false          |
+
+---------------------------------------------------------------+----------------+
+
  
Back to Contents_
+
{| border="1" cellpadding="5" cellspacing="0"
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| Result
 +
|-
 +
| Sequence{'a', 'b'}->indexOf('a')
 +
| 1
 +
|}
  
notEmpty () : Boolean
 
-----------------------------------------------------------------
 
Returns **true** if *self* contains at least one element, **false** otherwise.
 
 
examples:
 
  
.. class:: exampletable
+
=== insertAt ( index : Integer, object : T) : Sequence(T) ===
+
Returns a Sequence containing *self* with *object* inserted at the *index* position.
+---------------------------------------------------------------+----------------+
+
| Expression                                                    | Result        |
+
+===============================================================+================+
+
| Sequence{2, 'a'}->notEmpty()                                 | true          |
+
+---------------------------------------------------------------+----------------+
+
| Sequence{null}->notEmpty()                                   | true          |
+
+---------------------------------------------------------------+----------------+
+
| Sequence{}->notEmpty()                                        | false          |
+
+---------------------------------------------------------------+----------------+
+
  
Back to Contents_
+
{| border="1" cellpadding="5" cellspacing="0"
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| 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'''''
 +
|}
  
one ( expr : OclExpression ) : Boolean
 
-----------------------------------------------------------------
 
Returns **true** if there is only one element contained in *self* that validates the condition *expr*, **false** otherwise.
 
 
examples:
 
  
.. class:: exampletable
+
=== last () : T ===
+
Returns the last element of *self*.
+---------------------------------------------------------------+----------------+
+
| 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_
+
{| border="1" cellpadding="5" cellspacing="0"
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| Result
 +
|-
 +
| Sequence{1, 2.0, '3'}->last()
 +
| '3'
 +
|}
  
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):
 
  
.. class:: exampletable
+
=== prepend ( object : T ) : Sequence(T) ===
+
Returns a Sequence containing *object* followed by all elements of *self* .
+------------------------------------------+-----------------------------------------------------------------+
+
| 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_
+
{| border="1" cellpadding="5" cellspacing="0"
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| Result
 +
|-
 +
| Sequence{'a', 'b'}->prepend('c')
 +
| Sequence{'c', 'a', 'b'}
 +
|}
  
reject ( expr : OclExpression ) : Collection(T)
 
-----------------------------------------------------------------
 
Returns a collection with all elements of *self* except for those who validate the OclExpression *expr*.
 
 
examples:
 
 
.. class:: exampletable
 
 
+-------------------------------------------------------+-------------------------+
 
| 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_
+
=== subSequence ( startIndex : Integer, endIndex : Integer ) : Sequence(T) ===
 +
Returns a Sequence containing all elements of *self* between the positions 'startIndex' and 'endIndex'.
  
select ( expr : OclExpression ) : Collection(T)
+
{| border="1" cellpadding="5" cellspacing="0"
-----------------------------------------------------------------
+
|-
Returns a collection with all elements of *self* that validate the OclExpression *expr*.
+
! style="background: #BCBCBC;" align="center"| Expression
+
! style="background: #BCBCBC;" align="center"| Result
examples:
+
|-
+
| Sequence{'a', 'b', 'c', 'd'}->subSequence(2, 3)
.. class:: exampletable
+
| Sequence{'b', 'c'}
+
|-
+-------------------------------------------------------+-------------------------+
+
| Sequence{'a', 'b', 'c', 'd'}->subSequence(4, 4)
| Expression                                           | Result                  |
+
| Sequence{'d'}
+=======================================================+=========================+
+
|}
| 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 () : Boolean
+
=== union ( seq : Sequence(T) ) : Sequence(T) ===
-----------------------------------------------------------------
+
Returns a Sequence containing all elements of *self* followed by all elements of *seq*.
Returns the number of elements contained in *self*.
+
+
examples:
+
  
.. class:: exampletable
+
{| border="1" cellpadding="5" cellspacing="0"
+
|-
+---------------------------------------------------------------+----------------+
+
! style="background: #BCBCBC;" align="center"| Expression
| Expression                                                   | Result        |
+
! style="background: #BCBCBC;" align="center"| Result
+===============================================================+================+
+
|-
| Sequence{2.3, 5}->size()                                     | 2              |
+
| Sequence{'a', 'b', 'a'}->union(Sequence{'b', 'c'})
+---------------------------------------------------------------+----------------+
+
| Sequence{'a', 'b', 'a', 'b', 'c'}
| Sequence{}->size()                                            | 0              |
+
|}
+---------------------------------------------------------------+----------------+
+
  
Back to Contents_
 
  
sortedBy ( expr : OclExpression ) : Sequence(T)
+
== Ocl operations for type *Bag* ==
-----------------------------------------------------------------
+
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*.
+
+
.. class:: exampletable
+
+
+-------------------------------------------------------+--------------------------------+
+
| Expression                                            | Result                        |
+
+=======================================================+================================+
+
| self.employees->sortedBy(age)                        | Sequence{employee1, employee2} |
+
+-------------------------------------------------------+--------------------------------+
+
  
Back to Contents_
+
=== = ( bag : Bag(T) ) : Boolean ===
 +
Returns **true** if *self* contains the same objects as *bag* in the same quantities.
  
sum () : Real
+
{| border="1" cellpadding="5" cellspacing="0"
-----------------------------------------------------------------
+
|-
Returns the sum of all elements contained in *self* if they support the '+' operation.
+
! style="background: #BCBCBC;" align="center"| Expression
+
! style="background: #BCBCBC;" align="center"| Result
examples:
+
|-
 +
| 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
 +
|}
  
.. class:: exampletable
 
 
+---------------------------------------------------------------+----------------+
 
| 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|      |
 
+---------------------------------------------------------------+----------------+
 
  
Back to Contents_
+
=== <> ( bag : Bag(T) ) : Boolean ===
 +
Returns **true** if *self* does not contain the same objects as *bag* in the same quantities.
  
Ocl operations for type *Sequence*
+
{| border="1" cellpadding="5" cellspacing="0"
-----------------------------------------------------------------
+
|-
 +
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| 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
 +
|}
  
= ( 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:
 
 
.. class:: exampletable
 
 
+---------------------------------------------------------------+----------------+
 
| 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_
+
=== intersection ( bag : Bag(T) ) : Bag(T) ===
+
Returns a Bag containing all elements of *self* that are also contained by *bag*.
<> ( 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:
+
+
.. class:: exampletable
+
+
+---------------------------------------------------------------+----------------+
+
| 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_
+
{| border="1" cellpadding="5" cellspacing="0"
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| 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'}
 +
|}
  
append ( object : T ) : Sequence(T)
 
___________________________________________________________________________
 
Returns a Sequence containing all elements of *self* followed by *object*.
 
 
 
examples:
+
=== intersection ( set : Set(T) ) : Set(T) ===
+
Returns a Set containing all elements of *self* that are also contained by *set*.
.. class:: exampletable
+
+
+-----------------------------------------------------+-------------------------+
+
| Expression                                          | Result                  |
+
+=====================================================+=========================+
+
| Sequence{'a', 'b'}->append('c')                    | Sequence{'a', 'b', 'c'} |
+
+-----------------------------------------------------+-------------------------+
+
  
Back to Contents_
+
{| border="1" cellpadding="5" cellspacing="0"
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| Result
 +
|-
 +
| Bag{'a', 'b', 'a'}->intersection(Set{'a', 'b', 'c'})
 +
| Set{'a', 'b'}
 +
|}
  
at ( index : Integer ) : T ___________________________________________________________________________
 
Returns the element of *self* at the *index* position.
 
 
examples:
 
 
.. class:: exampletable
 
 
+-----------------------------------------------------+-------------------------+
 
| Expression                                          | Result                  |
 
+=====================================================+=========================+
 
| Sequence{'a', 'b'}->at(1)                          | a                      |
 
+-----------------------------------------------------+-------------------------+
 
  
Back to Contents_
+
=== union ( bag : Bag(T) ) : Bag(T) ===
 +
Returns a Bag containing all elements of *self* and all elements of *bag*.
  
first () : T ___________________________________________________________________________
+
{| border="1" cellpadding="5" cellspacing="0"
Returns the first element of *self*.
+
|-
+
! style="background: #BCBCBC;" align="center"| Expression
examples:
+
! style="background: #BCBCBC;" align="center"| Result
+
|-
.. class:: exampletable
+
| Bag{'a', 'b', 'a'}->union(Bag{'b', 'c'})
+
| Bag{'b', 'a', 'b', 'a', 'c'}
+-----------------------------------------------------+-------------------------+
+
|}
| Expression                                         | Result                  |
+
+=====================================================+=========================+
+
| Sequence{1, 2.0, '3'}->first()                     | 1                      |
+
+-----------------------------------------------------+-------------------------+
+
  
Back to Contents_
 
  
indexOf ( object : T ) : Integer ___________________________________________________________________________
+
=== union ( set : Set(T) ) : Bag(T) ===
Returns the position of *object* in sequence *self*.
+
Returns a Bag containing all elements of *self* and all elements of *set*.
+
examples:
+
+
.. class:: exampletable
+
+
+-----------------------------------------------------+-------------------------+
+
| Expression                                          | Result                  |
+
+=====================================================+=========================+
+
| Sequence{'a', 'b'}->indexOf('a')                    | 1                      |
+
+-----------------------------------------------------+-------------------------+
+
  
Back to Contents_
+
{| border="1" cellpadding="5" cellspacing="0"
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| Result
 +
|-
 +
| Bag{'a', 'b', 'a'}->union(Set{'b', 'c'})
 +
| Bag{'b', 'c', 'a', 'b', 'a'}
 +
|}
  
insertAt ( index : Integer, object : T) : Sequence(T)
 
___________________________________________________________________________
 
Returns a Sequence containing *self* with *object* inserted at the *index* position.
 
 
examples:
 
 
.. class:: exampletable
 
 
+-----------------------------------------------------+-------------------------+
 
| 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|              |
 
+-----------------------------------------------------+-------------------------+
 
  
Back to Contents_
+
== Ocl operations for type *OrderedSet* ==
 +
=== = ( set : Set(T) ) : Boolean ===
 +
Returns **true** if *self* contains the same objects as *set*.
 +
 
 +
{| border="1" cellpadding="5" cellspacing="0"
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| 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
 +
|}
  
last () : T ___________________________________________________________________________
 
Returns the last element of *self*.
 
 
examples:
 
 
.. class:: exampletable
 
 
 
+-----------------------------------------------------+-------------------------+
+
=== = ( orderedset : OrderedSet(T) ) : Boolean ===
| Expression                                          | Result                  |
+
Returns **true** if *self* contains the same objects as *orderedset* regardless of element ordering.
+=====================================================+=========================+
+
| Sequence{1, 2.0, '3'}->last()                      | '3'                    |
+
+-----------------------------------------------------+-------------------------+
+
  
Back to Contents_
+
{| border="1" cellpadding="5" cellspacing="0"
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| 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
 +
|}
  
prepend ( object : T ) : Sequence(T)
 
___________________________________________________________________________
 
Returns a Sequence containing *object* followed by all elements of *self* .
 
 
examples:
 
 
.. class:: exampletable
 
 
+-----------------------------------------------------+-------------------------+
 
| Expression                                          | Result                  |
 
+=====================================================+=========================+
 
| Sequence{'a', 'b'}->prepend('c')                    | Sequence{'c', 'a', 'b'} |
 
+-----------------------------------------------------+-------------------------+
 
  
Back to Contents_
+
=== <> ( set : Set(T) ) : Boolean ===
 +
Returns **true** if *self* does not contain the same objects as *set*.
  
subSequence ( startIndex : Integer, endIndex : Integer ) : Sequence(T)
+
{| border="1" cellpadding="5" cellspacing="0"
___________________________________________________________________________
+
|-
Returns a Sequence containing all elements of *self* between the positions 'startIndex' and 'endIndex'.
+
! style="background: #BCBCBC;" align="center"| Expression
+
! style="background: #BCBCBC;" align="center"| Result
examples:
+
|-
+
| OrderedSet{4, 5, 'test', 4} <> Set{4, 5, 'test'}
.. class:: exampletable
+
| false
+
|-
+-----------------------------------------------------+-------------------------+
+
| OrderedSet{4, 5, 'test', 4} <> Set{4, 'test', 5, 4}
| Expression                                         | Result                 |
+
| false
+=====================================================+=========================+
+
|-
| Sequence{'a', 'b', 'c', 'd'}->subSequence(2, 3)    | Sequence{'b', 'c'}     |
+
| OrderedSet{4, 5, 'test', 4} <> Set{4, 5, 'test', 2}
+-----------------------------------------------------+-------------------------+
+
| true
| Sequence{'a', 'b', 'c', 'd'}->subSequence(4, 4)    | Sequence{'d'}           |
+
|}
+-----------------------------------------------------+-------------------------+
+
  
Back to Contents_
 
  
union ( seq : Sequence(T) ) : Sequence(T)
+
=== <> ( orderedset : OrderedSet(T) ) : Boolean ===
___________________________________________________________________________
+
Returns **true** if *self* does not contain the same objects as *orderedset*.
Returns a Sequence containing all elements of *self* followed by all elements of *seq*.
+
+
examples:
+
+
.. class:: exampletable
+
+
+-----------------------------------------------------+-----------------------------------+
+
| Expression                                          | Result                            |
+
+=====================================================+===================================+
+
| Sequence{'a', 'b', 'a'}->union(Sequence{'b', 'c'})  | Sequence{'a', 'b', 'a', 'b', 'c'} |
+
+-----------------------------------------------------+-----------------------------------+
+
  
Back to Contents_
+
{| border="1" cellpadding="5" cellspacing="0"
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| 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
 +
|}
  
Ocl operations for type *Bag*
 
-----------------------------------------------------------------
 
  
= ( bag : Bag(T) ) : Boolean ___________________________________________________________________________
+
=== `-` ( set : Set(T) ) : Set(T) ===
Returns **true** if *self* contains the same objects as *bag* in the same quantities.
+
Returns a Set containing all elements of *self* minus all elements of *set*.
+
examples:
+
+
.. class:: exampletable
+
+
+---------------------------------------------------------------+----------------+
+
| 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_
+
{| border="1" cellpadding="5" cellspacing="0"
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| Result
 +
|-
 +
| OrderedSet{'a', 'b', 'c'} - Set{'c', 'a'}
 +
| Set{'b'}
 +
|}
  
<> ( bag : Bag(T) ) : Boolean ___________________________________________________________________________
 
Returns **true** if *self* does not contain the same objects as *bag* in the same quantities.
 
 
examples:
 
 
.. class:: exampletable
 
 
+---------------------------------------------------------------+----------------+
 
| 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_
+
=== append ( object : T ) : OrderedSet(T) ===
 +
Returns an OrderedSet containing all elements of *self* followed by *object*.
  
intersection ( bag : Bag(T) ) : Bag(T)
+
{| border="1" cellpadding="5" cellspacing="0"
___________________________________________________________________________
+
|-
Returns a Bag containing all elements of *self* that are also contained by *bag*.
+
! style="background: #BCBCBC;" align="center"| Expression
+
! style="background: #BCBCBC;" align="center"| Result
examples:
+
|-
+
| OrderedSet{'a', 'b'}->append('c')
.. class:: exampletable
+
| OrderedSet{'a', 'b', 'c'}
+
|}
+-----------------------------------------------------------+-----------------------------------+
+
| 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:
 
 
.. class:: exampletable
 
 
+----------------------------------------------------------+-----------------------------------+
 
| Expression                                              | Result                            |
 
+==========================================================+===================================+
 
| Bag{'a', 'b', 'a'}->intersection(Set{'a', 'b', 'c'})    | Set{'a', 'b'}                    |
 
+----------------------------------------------------------+-----------------------------------+
 
  
Back to Contents_
+
=== at ( index : Integer ) : T ===
 +
Returns the element of *self* located at position *index* in the collection.
  
union ( bag : Bag(T) ) : Bag(T)
+
{| border="1" cellpadding="5" cellspacing="0"
___________________________________________________________________________
+
|-
Returns a Bag containing all elements of *self* and all elements of *bag*.
+
! style="background: #BCBCBC;" align="center"| Expression
+
! style="background: #BCBCBC;" align="center"| Result
examples:
+
|-
+
| OrderedSet{'a', 'b'}->at(1)
.. class:: exampletable
+
| 'a'
+
|}
+-----------------------------------------------------+-----------------------------------+
+
| 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)
+
=== first () : T ===
___________________________________________________________________________
+
Returns the first element of *self*.
Returns a Bag containing all elements of *self* and all elements of *set*.
+
+
examples:
+
+
.. class:: exampletable
+
+
+-----------------------------------------------------+-----------------------------------+
+
| Expression                                          | Result                            |
+
+=====================================================+===================================+
+
| Bag{'a', 'b', 'a'}->union(Set{'b', 'c'})            | Bag{'b', 'c', 'a', 'b', 'a'}      |
+
+-----------------------------------------------------+-----------------------------------+
+
  
Back to Contents_
+
{| border="1" cellpadding="5" cellspacing="0"
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| Result
 +
|-
 +
| OrderedSet{1, 2.0, '3'}->first()
 +
| 1
 +
|}
  
Ocl operations for type *OrderedSet*
 
-----------------------------------------------------------------
 
  
= ( set : Set(T) ) : Boolean ___________________________________________________________________________
+
=== indexOf ( object : T ) : Integer ===
Returns **true** if *self* contains the same objects as *set*.
+
Returns the position of *object* in *self*.
+
examples:
+
+
.. class:: exampletable
+
+
+---------------------------------------------------------------+----------------+
+
| 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_
+
{| border="1" cellpadding="5" cellspacing="0"
+
|-
= ( orderedset : OrderedSet(T) ) : Boolean ___________________________________________________________________________
+
! style="background: #BCBCBC;" align="center"| Expression
Returns **true** if *self* contains the same objects as *orderedset* regardless of element ordering.
+
! style="background: #BCBCBC;" align="center"| Result
+
|-
examples:
+
| OrderedSet{'a', 'b'}->indexOf('a')
+
| 1
.. class:: exampletable
+
|}
+
+---------------------------------------------------------------+----------------+
+
| 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 ___________________________________________________________________________
+
=== insertAt ( index : Integer, object : T ) : OrderedSet(T) ===
Returns **true** if *self* does not contain the same objects as *set*.
+
Returns an OrderedSet containing *self* with *object* inserted at the *index* position.
+
examples:
+
+
.. class:: exampletable
+
+
+---------------------------------------------------------------+----------------+
+
| 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_
+
{| border="1" cellpadding="5" cellspacing="0"
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| Result
 +
|-
 +
| OrderedSet{'a', 'b'}->insertAt(1, 'c')
 +
| OrderedSet{'c', 'a', 'b'}
 +
|-
 +
| OrderedSet{'a', 'b'}->insertAt(3, 'c')
 +
| OrderedSet{'a', 'b', 'c'}
 +
|}
  
<> ( orderedset : OrderedSet(T) ) : Boolean ___________________________________________________________________________
 
Returns **true** if *self* does not contain the same objects as *orderedset*.
 
 
examples:
 
 
.. class:: exampletable
 
 
+---------------------------------------------------------------+----------------+
 
| 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_
+
=== intersection ( bag : Bag(T) ) : Set(T) ===
 +
Returns a Set containing all elements of *self* that are also contained by *bag*.
  
`-` ( set : Set(T) ) : Set(T)
+
{| border="1" cellpadding="5" cellspacing="0"
___________________________________________________________________________
+
|-
Returns a Set containing all elements of *self* minus all elements of *set*.
+
! style="background: #BCBCBC;" align="center"| Expression
+
! style="background: #BCBCBC;" align="center"| Result
examples:
+
|-
+
| OrderedSet{'a', 'b', 'a'}->intersection(Bag{'a', 'b'})
.. class:: exampletable
+
| Set{'a', 'b'}
+
|}
+-----------------------------------------------------+-----------------------------------+
+
| Expression                                         | Result                            |
+
+=====================================================+===================================+
+
| OrderedSet{'a', 'b', 'c'} - Set{'c', 'a'}           | Set{'b'}                         |
+
+-----------------------------------------------------+-----------------------------------+
+
  
Back to Contents_
 
  
append ( object : T ) : OrderedSet(T)
+
=== intersection ( set : Set(T) ) : Set(T) ===
___________________________________________________________________________
+
Returns a Set containing all elements of *self* that are also contained by *set*.
Returns an OrderedSet containing all elements of *self* followed by *object*.
+
+
examples:
+
+
.. class:: exampletable
+
+
+-----------------------------------------------------+---------------------------+
+
| Expression                                          | Result                    |
+
+=====================================================+===========================+
+
| OrderedSet{'a', 'b'}->append('c')                  | OrderedSet{'a', 'b', 'c'} |
+
+-----------------------------------------------------+---------------------------+
+
  
Back to Contents_
+
{| border="1" cellpadding="5" cellspacing="0"
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| Result
 +
|-
 +
| OrderedSet{'a', 'b', 'a'}->intersection(Set{'a', 'b'})
 +
| Set{'a', 'b'}
 +
|}
  
at ( index : Integer ) : T ___________________________________________________________________________
 
Returns the element of *self* located at position *index* in the collection.
 
 
examples:
 
 
.. class:: exampletable
 
 
+-----------------------------------------------------+-------------------------+
 
| Expression                                          | Result                  |
 
+=====================================================+=========================+
 
| OrderedSet{'a', 'b'}->at(1)                        | 'a'                    |
 
+-----------------------------------------------------+-------------------------+
 
  
Back to Contents_
+
=== last () : T ===
 +
Returns the last element of *self*.
  
first () : T ___________________________________________________________________________
+
{| border="1" cellpadding="5" cellspacing="0"
Returns the first element of *self*.
+
|-
+
! style="background: #BCBCBC;" align="center"| Expression
examples:
+
! style="background: #BCBCBC;" align="center"| Result
+
|-
.. class:: exampletable
+
| OrderedSet{1, 2.0, '3'}->last()
+
| '3'
+-----------------------------------------------------+-------------------------+
+
|}
| Expression                                         | Result                  |
+
+=====================================================+=========================+
+
| OrderedSet{1, 2.0, '3'}->first()                   | 1                      |
+
+-----------------------------------------------------+-------------------------+
+
  
Back to Contents_
 
  
indexOf ( object : T ) : Integer ___________________________________________________________________________
+
=== prepend ( object : T ) : OrderedSet(T) ===
Returns the position of *object* in *self*.
+
Returns an OrderedSet containing *object* followed by all elements of *self*.
+
examples:
+
+
.. class:: exampletable
+
+
+-----------------------------------------------------+-------------------------+
+
| Expression                                          | Result                  |
+
+=====================================================+=========================+
+
| OrderedSet{'a', 'b'}->indexOf('a')                  | 1                      |
+
+-----------------------------------------------------+-------------------------+
+
  
Back to Contents_
+
{| border="1" cellpadding="5" cellspacing="0"
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| Result
 +
|-
 +
| OrderedSet{'a', 'b'}->prepend('c')
 +
| OrderedSet{'c', 'a', 'b'}
 +
|}
  
insertAt ( index : Integer, object : T ) : OrderedSet(T)
 
___________________________________________________________________________
 
Returns an OrderedSet containing *self* with *object* inserted at the *index* position.
 
 
examples:
 
 
.. class:: exampletable
 
 
+-----------------------------------------------------+---------------------------+
 
| 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_
+
=== subOrderedSet ( startIndex : Integer, endIndex : Integer ) : OrderedSet(T) ===
 +
Returns an OrderedSet containing all elements of *self* between the positions *startIndex* and *endIndex*.
  
intersection ( bag : Bag(T) ) : Set(T)
+
{| border="1" cellpadding="5" cellspacing="0"
___________________________________________________________________________
+
|-
Returns a Set containing all elements of *self* that are also contained by *bag*.
+
! style="background: #BCBCBC;" align="center"| Expression
+
! style="background: #BCBCBC;" align="center"| Result
examples:
+
|-
+
| OrderedSet{'a', 'b', 'c', 'd'}->subOrderedSet(2, 3)
.. class:: exampletable
+
| OrderedSet{'b', 'c'}
+
|-
+--------------------------------------------------------+--------------------------------+
+
| OrderedSet{'a', 'b', 'c', 'd'}->subOrderedSet(4, 4)
| Expression                                             | Result                        |
+
| OrderedSet{'d'}
+========================================================+================================+
+
|}
| OrderedSet{'a', 'b', 'a'}->intersection(Bag{'a', 'b'}) | Set{'a', 'b'}                 |
+
+--------------------------------------------------------+--------------------------------+
+
  
Back to Contents_
 
  
intersection ( set : Set(T) ) : Set(T)
+
=== symmetricDifference ( set : Set(T) ) : Set(T) ===
___________________________________________________________________________
+
Returns a Set containing all of the elements of *self* and *set* that are not present in both.
Returns a Set containing all elements of *self* that are also contained by *set*.
+
+
examples:
+
+
.. class:: exampletable
+
+
+--------------------------------------------------------+--------------------------------+
+
| Expression                                            | Result                        |
+
+========================================================+================================+
+
| OrderedSet{'a', 'b', 'a'}->intersection(Set{'a', 'b'}) | Set{'b', 'a'}                  |
+
+--------------------------------------------------------+--------------------------------+
+
  
Back to Contents_
+
{| border="1" cellpadding="5" cellspacing="0"
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| Result
 +
|-
 +
| OrderedSet{'b', 'a', 'b', 'c'}->symmetricDifference(Set{'a', 'c', 'd'})
 +
| Set{'d', 'b'}
 +
|}
  
last () : T ___________________________________________________________________________
 
Returns the last element of *self*.
 
 
examples:
 
 
.. class:: exampletable
 
 
+-----------------------------------------------------+-------------------------+
 
| Expression                                          | Result                  |
 
+=====================================================+=========================+
 
|OrderedSet{1, 2.0, '3'}->last()                      | '3'                    |
 
+-----------------------------------------------------+-------------------------+
 
  
Back to Contents_
+
=== union ( bag : Bag(T) ) : Bag(T) ===
 +
Returns a Bag containing all elements of *self* followed by all elements of *bag*.
  
prepend ( object : T ) : OrderedSet(T)
+
{| border="1" cellpadding="5" cellspacing="0"
___________________________________________________________________________
+
|-
Returns an OrderedSet containing *object* followed by all elements of *self*.
+
! style="background: #BCBCBC;" align="center"| Expression
+
! style="background: #BCBCBC;" align="center"| Result
examples:
+
|-
+
| OrderedSet{'a', 'b', 'a'}->union(Bag{'b', 'c'})
.. class:: exampletable
+
| Bag{'a', 'c', 'b', 'b'}
+
|}
+-----------------------------------------------------+---------------------------+
+
| Expression                                         | Result                    |
+
+=====================================================+===========================+
+
| OrderedSet{'a', 'b'}->prepend('c')                 | OrderedSet{'c', 'a', 'b'} |
+
+-----------------------------------------------------+---------------------------+
+
  
Back to Contents_
 
  
subOrderedSet ( startIndex : Integer, endIndex : Integer ) : OrderedSet(T)
+
=== union ( set : Set(T) ) : Set(T) ===
___________________________________________________________________________
+
Returns a Set containing all elements of *self* followed by all elements of *set*.
Returns an OrderedSet containing all elements of *self* between the positions *startIndex* and *endIndex*.
+
+
examples:
+
+
.. class:: exampletable
+
+
+-----------------------------------------------------+---------------------------+
+
| 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_
+
{| border="1" cellpadding="5" cellspacing="0"
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| Result
 +
|-
 +
| OrderedSet{'a', 'b', 'a'}->union(Set{'b', 'c'})
 +
| Set{'a', 'c', 'b'}
 +
|}
  
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:
 
 
.. class:: exampletable
 
 
+-------------------------------------------------------------------------+---------------+
 
| Expression                                                              | Result        |
 
+=========================================================================+===============+
 
| OrderedSet{'b', 'a', 'b', 'c'}->symmetricDifference(Set{'a', 'c', 'd'}) | Set{'d', 'b'} |
 
+-------------------------------------------------------------------------+---------------+
 
  
Back to Contents_
+
== Ocl operations for type *Set* ==
  
union ( bag : Bag(T) ) : Bag(T)
+
=== = ( set : Set(T) ) : Boolean ===
___________________________________________________________________________
+
Returns **true** if *self* contains the same objects as *set*.
Returns a Bag containing all elements of *self* followed by all elements of *bag*.
+
+
examples:
+
+
.. class:: exampletable
+
+
+-----------------------------------------------------+-----------------------------------+
+
| Expression                                          | Result                            |
+
+=====================================================+===================================+
+
| OrderedSet{'a', 'b', 'a'}->union(Bag{'b', 'c'})    | Bag{'a', 'c', 'b', 'b'}          |
+
+-----------------------------------------------------+-----------------------------------+
+
  
Back to Contents_
+
{| border="1" cellpadding="5" cellspacing="0"
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| 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
 +
|}
  
union ( set : Set(T) ) : Set(T)
 
___________________________________________________________________________
 
Returns a Set containing all elements of *self* followed by all elements of *set*.
 
 
examples:
 
 
.. class:: exampletable
 
 
+-----------------------------------------------------+-----------------------------------+
 
| Expression                                          | Result                            |
 
+=====================================================+===================================+
 
| OrderedSet{'a', 'b', 'a'}->union(Set{'b', 'c'})    | Set{'a', 'c', 'b'}                |
 
+-----------------------------------------------------+-----------------------------------+
 
  
Back to Contents_
+
=== <> ( set : Set(T) ) : Boolean ===
 +
Returns **true** if *self* does not contain the same objects as *set*.
  
Ocl operations for type *Set*
+
{| border="1" cellpadding="5" cellspacing="0"
-----------------------------------------------------------------
+
|-
 +
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| 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
 +
|}
  
= ( set : Set(T) ) : Boolean ___________________________________________________________________________
 
Returns **true** if *self* contains the same objects as *set*.
 
 
examples:
 
 
.. class:: exampletable
 
 
+---------------------------------------------------------------+----------------+
 
| 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) ) : Set(T) ===
 +
Returns a Set containing all elements of *self* minus all elements of *set*.
  
<> ( set : Set(T) ) : Boolean ___________________________________________________________________________
+
{| border="1" cellpadding="5" cellspacing="0"
Returns **true** if *self* does not contain the same objects as *set*.
+
|-
+
! style="background: #BCBCBC;" align="center"| Expression
examples:
+
! style="background: #BCBCBC;" align="center"| Result
+
|-
.. class:: exampletable
+
| Set{'a', 'b', 'c'} - Set{'c', 'a'}
+
| Set{'b'}
+---------------------------------------------------------------+----------------+
+
|}
| 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)
+
=== intersection ( bag : Bag(T) ) : Set(T) ===
___________________________________________________________________________
+
Returns a Bag containing all elements of *self* that are also contained in *bag*.
Returns a Set containing all elements of *self* minus all elements of *set*.
+
+
examples:
+
+
.. class:: exampletable
+
+
+-----------------------------------------------------+-----------------------------------+
+
| Expression                                          | Result                            |
+
+=====================================================+===================================+
+
| Set{'a', 'b', 'c'} - Set{'c', 'a'}                  | Set{'b'}                          |
+
+-----------------------------------------------------+-----------------------------------+
+
  
Back to Contents_
+
{| border="1" cellpadding="5" cellspacing="0"
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| Result
 +
|-
 +
| Set{'a', 'b', 'a'}->intersection(Bag{'a', 'b', 'c'})
 +
| Set{'a', 'b'}
 +
|}
  
intersection ( bag : Bag(T) ) : Set(T)
 
___________________________________________________________________________
 
Returns a Bag containing all elements of *self* that are also contained in *bag*.
 
 
examples:
 
 
.. class:: exampletable
 
 
+-------------------------------------------------------+-----------------------------------+
 
| 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*.
  
intersection ( set : Set(T) ) : Set(T)
+
{| border="1" cellpadding="5" cellspacing="0"
___________________________________________________________________________
+
|-
Returns a Set containing all elements of *self* that are also contained in *set*.
+
! style="background: #BCBCBC;" align="center"| Expression
+
! style="background: #BCBCBC;" align="center"| Result
examples:
+
|-
+
| Set{'a', 'b', 'a'}->intersection(Set{'a', 'b', 'c'})
.. class:: exampletable
+
| Set{'b', 'a'}
+
|}
+-------------------------------------------------------+-----------------------------------+
+
| Expression                                           | Result                            |
+
+=======================================================+===================================+
+
| Set{'a', 'b', 'a'}->intersection(Set{'a', 'b', 'c'}) | Set{'b', 'a'}                     |
+
+-------------------------------------------------------+-----------------------------------+
+
  
Back to Contents_
 
  
symmetricDifference ( set : Set(T) ) : Set(T)
+
=== symmetricDifference ( set : Set(T) ) : Set(T) ===
___________________________________________________________________________
+
Returns a Set containing all of the elements of *self* and *set* that are not present in both.
Returns a Set containing all of the elements of *self* and *set* that are not present in both.
+
+
examples:
+
+
.. class:: exampletable
+
+
+------------------------------------------------------------------+-------------------------+
+
| Expression                                                      | Result                  |
+
+==================================================================+=========================+
+
| Set{'b', 'a', 'b', 'c'}->symmetricDifference(Set{'a', 'c', 'd'}) | Set{'b', 'd'}          |
+
+------------------------------------------------------------------+-------------------------+
+
  
Back to Contents_
+
{| border="1" cellpadding="5" cellspacing="0"
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| Result
 +
|-
 +
| Set{'b', 'a', 'b', 'c'}->symmetricDifference(Set{'a', 'c', 'd'})
 +
| Set{'b', 'd'}
 +
|}
  
union ( bag : Bag(T) ) : Bag(T)
 
___________________________________________________________________________
 
Returns a Bag containing all elements of *self* and all elements of *bag*.
 
 
examples:
 
 
.. class:: exampletable
 
 
+-----------------------------------------------------+-----------------------------------+
 
| Expression                                          | Result                            |
 
+=====================================================+===================================+
 
| Set{'a', 'b', 'a'}->union(Bag{'b', 'c'})            | Bag{'a', 'c', 'b', 'b'}          |
 
+-----------------------------------------------------+-----------------------------------+
 
  
Back to Contents_
+
=== union ( bag : Bag(T) ) : Bag(T) ===
 +
Returns a Bag containing all elements of *self* and all elements of *bag*.
  
union ( set : Set(T) ) : Set(T)
+
{| border="1" cellpadding="5" cellspacing="0"
___________________________________________________________________________
+
|-
Returns a Set containing all elements of *self* and all elements of *set*.
+
! style="background: #BCBCBC;" align="center"| Expression
+
! style="background: #BCBCBC;" align="center"| Result
examples:
+
|-
+
| Set{'a', 'b', 'a'}->union(Bag{'b', 'c'})
.. class:: exampletable
+
| Bag{'a', 'c', 'b', 'b'}
+
|}
+-----------------------------------------------------+-----------------------------------+
+
| Expression                                         | Result                            |
+
+=====================================================+===================================+
+
| Set{'a', 'b', 'a'}->union(Set{'b', 'c'})           | Set{'a', 'c', 'b'}               |
+
+-----------------------------------------------------+-----------------------------------+
+
  
Back to Contents_
 
  
Ocl operations for type *Boolean*
+
=== union ( set : Set(T) ) : Set(T) ===
=================================
+
Returns a Set containing all elements of *self* and all elements of *set*.
  
And
+
{| border="1" cellpadding="5" cellspacing="0"
-----------------------------------------------------------------
+
|-
 +
! style="background: #BCBCBC;" align="center"| Expression
 +
! style="background: #BCBCBC;" align="center"| Result
 +
|-
 +
| Set{'a', 'b', 'a'}->union(Set{'b', 'c'})
 +
| Set{'a', 'c', 'b'}
 +
|}
  
.. list-table::
 
:class: truthtable
 
:header-rows: 1
 
:stub-columns: 1
 
         
 
* - And
 
  - true
 
  - false
 
  - |invalid|
 
* - true
 
  - true
 
  - false
 
  - true
 
* - false
 
  - false
 
  - false
 
  - false
 
* - |invalid|
 
  - |invalid|
 
  - false
 
  - |invalid|
 
  
Back to Contents_
+
== Ocl operations for type *Boolean* ==
  
Implies
+
=== And ===
-----------------------------------------------------------------
+
  
.. list-table::
+
{| border="1" cellpadding="5" cellspacing="0"
:class: truthtable
+
|-
:header-rows: 1
+
! style="background: #BCBCBC;" align="center"| And
:stub-columns: 1
+
! style="background: #BCBCBC;" align="center"| True
         
+
! style="background: #BCBCBC;" align="center"| False
* - Implies
+
! style="background: #BCBCBC;" align="center"| Invalid
  - true
+
|-
  - false
+
! style="background: #BCBCBC;" align="center"| True
  - |invalid|
+
| true
* - true
+
| false
  - true
+
| true
  - false
+
|-
  - |invalid|
+
! style="background: #BCBCBC;" align="center"| False
* - false
+
| false
  - true
+
| false
  - true
+
| false
  - true
+
|-
* - |invalid|
+
! style="background: #BCBCBC;" align="center"| Invalid
  - true
+
| invalid
  - |invalid|
+
| false
  - |invalid|
+
| invalid
 +
|}
  
Back to Contents_
+
=== Implies ===
 +
 
 +
{| border="1" cellpadding="5" cellspacing="0"
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Implies
 +
! style="background: #BCBCBC;" align="center"| True
 +
! style="background: #BCBCBC;" align="center"| False
 +
! style="background: #BCBCBC;" align="center"| Invalid
 +
|-
 +
! style="background: #BCBCBC;" align="center"| True
 +
| true
 +
| false
 +
| invalid
 +
|-
 +
! style="background: #BCBCBC;" align="center"| False
 +
| true
 +
| true
 +
| true
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Invalid
 +
| true
 +
| invalid
 +
| invalid
 +
|}
 +
 
 +
 
 +
=== Or ===
 +
 
 +
{| border="1" cellpadding="5" cellspacing="0"
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Or
 +
! style="background: #BCBCBC;" align="center"| True
 +
! style="background: #BCBCBC;" align="center"| False
 +
! style="background: #BCBCBC;" align="center"| Invalid
 +
|-
 +
! style="background: #BCBCBC;" align="center"| True
 +
| true
 +
| true
 +
| true
 +
|-
 +
! style="background: #BCBCBC;" align="center"| False
 +
| true
 +
| false
 +
| invalid
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Invalid
 +
| true
 +
| invalid
 +
| invalid
 +
|}
  
Or
 
-----------------------------------------------------------------
 
 
.. list-table::
 
:class: truthtable
 
:header-rows: 1
 
:stub-columns: 1
 
 
* - Or
 
  - true
 
  - false
 
  - |invalid|
 
* - true
 
  - true
 
  - true
 
  - true
 
* - false
 
  - true
 
  - false
 
  - |invalid|
 
* - |invalid|
 
  - true
 
  - |invalid|
 
  - |invalid|
 
  
Back to Contents_
+
=== Not ===
 +
{| border="1" cellpadding="5" cellspacing="0"
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Not
 +
! style="background: #BCBCBC;" align="center"| Result
 +
|-
 +
! style="background: #BCBCBC;" align="center"| True
 +
| false
 +
|-
 +
! style="background: #BCBCBC;" align="center"| False
 +
| true
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Invalid
 +
| invalid
 +
|}
  
Not
 
-----------------------------------------------------------------
 
  
.. list-table::
+
=== Xor ===
:class: truthtable
+
:header-rows: 1
+
:stub-columns: 1
+
  
* - Not
+
{| border="1" cellpadding="5" cellspacing="0"
  - Result
+
|-
* - true
+
! style="background: #BCBCBC;" align="center"| Xor
  - false
+
! style="background: #BCBCBC;" align="center"| True
* - false
+
! style="background: #BCBCBC;" align="center"| False
  - true
+
! style="background: #BCBCBC;" align="center"| Invalid
* - |invalid|
+
|-
  - |invalid|
+
! style="background: #BCBCBC;" align="center"| True
 +
| false
 +
| true
 +
| invalid
 +
|-
 +
! style="background: #BCBCBC;" align="center"| False
 +
| true
 +
| false
 +
| invalid
 +
|-
 +
! style="background: #BCBCBC;" align="center"| Invalid
 +
| invalid
 +
| invalid
 +
| invalid
 +
|}
  
Back to Contents_
 
  
Xor
+
{{Acceleo-index}}
-----------------------------------------------------------------
+
  
.. list-table::
+
[[Category:Modeling]]
:class: truthtable
+
[[Category:M2T]]
:header-rows: 1
+
[[Category:Acceleo]]
:stub-columns: 1
+
         
+
* - Xor
+
  - true
+
  - false
+
  - |invalid|
+
* - true
+
  - false
+
  - true
+
  - |invalid|
+
* - false
+
  - true
+
  - false
+
  - |invalid|
+
* - |invalid|
+
  - |invalid|
+
  - |invalid|
+
  - |invalid|
+

Latest revision as of 01:40, 20 January 2011

Contents

OCL operation reference

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

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


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
  • 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*.

Expression Result
'concat'.concat(' ').concat('operation') 'concat operation'


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.

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}


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

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


notEmpty () : Boolean

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

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


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

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


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

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

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


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

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

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


Ocl operations for type *Bag*

= ( bag : Bag(T) ) : Boolean

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


Ocl operations for type *OrderedSet*

= ( set : Set(T) ) : Boolean

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

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


= ( orderedset : OrderedSet(T) ) : Boolean

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

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


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

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

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


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

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

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


`-` ( set : Set(T) ) : Set(T)

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

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


append ( object : T ) : OrderedSet(T)

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

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


at ( index : Integer ) : T

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

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


first () : T

Returns the first element of *self*.

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


indexOf ( object : T ) : Integer

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

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


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

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

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


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

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

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


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

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

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


last () : T

Returns the last element of *self*.

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


prepend ( object : T ) : OrderedSet(T)

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

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


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

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

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


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

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

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


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

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

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


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

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

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


Ocl operations for type *Set*

= ( set : Set(T) ) : Boolean

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

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


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

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

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


`-` ( set : Set(T) ) : Set(T)

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

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


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

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

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


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

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

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


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

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

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


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

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

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


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

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

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


Ocl operations for type *Boolean*

And

And True False Invalid
True true false true
False false false false
Invalid invalid false invalid

Implies

Implies True False Invalid
True true false invalid
False true true true
Invalid true invalid invalid


Or

Or True False Invalid
True true true true
False true false invalid
Invalid true invalid invalid


Not

Not Result
True false
False true
Invalid invalid


Xor

Xor True False Invalid
True false true invalid
False true false invalid
Invalid invalid invalid invalid



Acceleo Portal
Project Project · Installation · New & noteworthy · Release review · API policy · Retention policy · Next · Checklist
Features Acceleo Features · Runtime · Acceleo editor · Views & Perspective · Debugger · Profiler · Traceability · Wishlist · Interpreter · Maven
User documentation Getting Started · Acceleo operations reference · OCL operations reference · Text Production Rules · Migration From Acceleo 2.x · Best Practices · Videos · FAQ
Developer documentation Source code · How to contribute · Compatibility · MOFM2T specification · OCL specification
Community Conferences · Twitter & Blogs · Professional Support · Report a bug