Difference between revisions of "Acceleo/OCL Operations Reference"

From Eclipsepedia

Jump to: navigation, search
m (Formatting)
m (categories)
Line 1,417: Line 1,417:
  
 
{{Acceleo-index}}
 
{{Acceleo-index}}
 +
 +
[[Category:Modeling]]
 +
[[Category:M2T]]
 +
[[Category:Acceleo]]

Revision as of 07:07, 12 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)                                                      | 6              |
  +---------------------------------------------------------------+----------------+
  | 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.

.. list-table::

:header-rows: 1 :stub-columns: 1

* - 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 | +=======================================================+=========================+ | 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} | +-------------------------------------------------------+-------------------------+


select ( expr : OclExpression ) : Collection(T)

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

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


size () : Boolean

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{'b', 'a'} | +--------------------------------------------------------+--------------------------------+


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

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


Implies

.. list-table:: :class: truthtable :header-rows: 1 :stub-columns: 1

* - Implies - true - false - |invalid| * - true - true - false - |invalid| * - false - true - true - true * - |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|


Not

.. list-table:: :class: truthtable :header-rows: 1 :stub-columns: 1

* - Not - Result * - true - false * - false - true * - |invalid| - |invalid|


Xor

.. list-table:: :class: truthtable :header-rows: 1 :stub-columns: 1

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