Some example requires an example model, thus we will use the following model as an example.

# OclAny operations available on all model objects.

Operation | Origin | Standard
--- | --- | ---
= (elem: OclAny): Boolean | Ocl | Yes
<> (elem: OclAny): Boolean | Ocl | Yes
< (elem: T): Boolean | Ocl | Yes
> (elem: T): Boolean | Ocl | Yes
<= (elem: T): Boolean | Ocl | Yes
>= (elem: T): Boolean | Ocl | Yes
ancestors(): Sequence(OclAny) | Acceleo | No
ancestors(oclType: OclType): Sequence(OclType) | Acceleo | No
eAllContents(): Sequence(OclAny) | Acceleo | No
eAllContents(oclType: OclType): Sequence(OclType) | Acceleo | No
current(index: Integer): OclAny | Acceleo | No
current(oclType: OclType): OclType | Acceleo | No
eContainer(oclType: OclType): OclType | Acceleo | No
eContents(oclType: OclType): Sequence(OclType) | Acceleo | No
eGet(featureName: String): OclAny | Acceleo | No
eInverse(): Sequence(OclAny) | Acceleo | No
eInverse(oclType: OclType): Sequence(OclAny) | Acceleo | No
followingSiblings(): Sequence(OclAny) | Acceleo | No
followingSiblings(oclType: OclType): Sequence(OclType) | Acceleo | No
getProperty(key: String): String | Acceleo | No
getProperty(key: String, parameters: Sequence(OclAny)): String | Acceleo | No
getProperty(name:String, key: String): String | Acceleo | No
getProperty(name: String, key: String, parameters: Sequence(OclAny)): String | Acceleo | No
invoke(className: String, methodName: String, arguments: Sequence(OclAny)): OclAny | Acceleo | No
lineSeparator(): String | Acceleo | No
oclAsType(oclType: OclType): OclType | Ocl | Yes
oclIsInvalid(): Boolean | Ocl | Yes
oclIsKindOf(oclType: OclType): Boolean | Ocl | Yes
oclIsTypeOf(oclType: OclType): Boolean | Ocl | Yes
oclIsUndefined(): Boolean | Ocl | Yes
precedindSiblings(): Sequence(OclAny) | Acceleo | No
precedingSiblings(oclType: OclType): Sequence(OclType) | Acceleo | No
siblings(): Sequence(OclAny) | Acceleo | No
siblings(oclType: OclType): Sequence(OclAny) | Acceleo | No
toString(): String | Acceleo | No
+ (str: String): String | Acceleo | No

back to top

## = (elem: OclAny): Boolean

Returns true if self is equal to object.

Expression | Result
--- | ---
['first string' = 'first string'/] | true
['first string' = Sequence{'a', 'b'}/] | false

back to section

## <> (elem: OclAny): Boolean

Returns false if self is equal to object.

Expression | Result
--- | ---
['first string' <> 'first string'/] | false
['first string' <> Sequence{'a', 'b'}/] | true

back to section

## < (elem: T): Boolean

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

Expression | Result
--- | ---
['first string' < 'second string'/] | true
['first string' < 'another string'/] | false

back to section

## > (elem: T): Boolean

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

Expression | Result
--- | ---
['first string' > 'second string'/] | false
['first string' > 'another string'/] | true

back to section

## <= (elem: OclAny): Boolean

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

Expression | Result
--- | ---
['first string' <= 'second string'/] | true
['first string' <= 'first string'/] | true
['first string' <= 'another string'/] | false

back to section

## >= (elem: OclAny): Boolean

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

Expression | Result
--- | ---
['first string' >= 'second string'/] | false
['first string' >= 'first string'/] | true
['first string' >= 'another string'/] | true

back to section

## ancestors(): Sequence(OclAny)

Returns a Sequence containing the full set of the receiver's ancestors.

Expression | Result
--- | ---
[elementOne.ancestors()/] | Sequence{First Child Package, Root Package}

back to section

## ancestors(oclType: OclType): Sequence(OclAny)

Returns the elements of the given type from the set of the receiver's ancestors as a Sequence. The returned sequence's elements are typed with the expected type (so there's no need to invoke oclAsType(oclType) on the sequence or its elements). In this example, the element root is also returned because Model is an instance of Package. All the element returned are ancestors for which oclIsKindOf(oclType) returns true.

Expression | Result
--- | ---
[elementOne.ancestors(EPackage)/] | Sequence{First Child Package, Root Package}
[elementOne.ancestors(EClass)/] | Sequence{}

back to section

## eAllContents(): Sequence(OclAny)

Returns the whole content tree of the receiver as a Sequence.

Expression | Result
--- | ---
[rootPackage.eAllContents()/] | Sequence{First Child Package, Element One, Element Two, Second Child Package, Third Child Package, Element Three, Element Four, Element Five}

back to section

## eAllContents(oclType: OclType): Sequence(OclAny)

Returns the elements of the given type from the whole content tree of the receiver as a Sequence. The returned sequence's elements are typed with the expected type (so there's no need to invoke oclAsType(oclType) on the sequence or its elements).

Expression | Result
--- | ---
[rootPackage.eAllContents(EClass)/] | Sequence{Element One, Element Two, Element Three, Element Four, Element Five}

back to section

## current(index: Integer): OclAny

Returns the value of the context index ranks above the current context.

Expression | Result
--- | ---

[for (anEPackage: EPackage | self.eSubpackages)]
[for (anEClass: EClass | anEPackage.eClassifiers->filter(EClass))]
[current(0)/]
[current(1)/]
[current(2)/]
[/for]
[/for]

The expression "current(0)" returns self, in this case the current value of "anEClass".
The expression "current(1)" returns the current value of "anEPackage".
The expression "current(2)" returns the value of "self" before the first block "for".

back to section

## current(oclType: OclType): OclType

This will have the same effect as current(Integer) except that is will return the first context (self variable) of the given type, at or above the current one.

Expression | Result
--- | ---
[for (anEPackage: EPackage | self.eSubpackages)] [for (anEClass: EClass | anEPackage.eClassifiers->filter(EClass))] [current(EClass)/] [current(EPackage)/] [/for] [/for] | The expression "current(EClass)" returns the current value of "anEClass". The expression "current(EPackage)" returns the current value of "anEPackage".

back to section

## eContainer(oclType: OclType): OclType

Returns the first ancestor of the given type, i.e. the first ancestor for which oclIsKindOf(oclType) evaluates to true. The returned element is typed with the expected type (so there's no need to invoke oclAsType(oclType) on it).

Important: users of Acceleo 2.x should note that, contrary to what took place in acceleo 2.x, this operation never returns self even when self.oclIsKindOf(oclType) is true.

Expression | Result
--- | ---
[elementOne.eContainer(EPackage)/] | First Child Package

back to section

## eContents(oclType: OclType): Sequence(OclType)

Returns a sequence of the direct children of self that are of the given type, i.e. the direct children for which oclIsKindOf(oclType) evaluates to true. The returned sequence's elements are typed with the expected type (so there's no need to invoke oclAsType(oclType) on the sequence or its elements).

Expression | Result
--- | ---
[firstChildPackage.eContents(EClass)/] | Sequence{Element One, Element Two}

back to section

## eGet(featureName: String): OclAny

This will fetch the value of the feature named featureName on the current Object. Return type can as well be a collection as a single value.

Expression | Result
--- | ---
[elementFive.eGet('link')/] | Element Four

back to section

## eInverse(): Sequence(OclAny)

Returns the sequence of all objects referencing self.

Expression | Result
--- | ---
[elementFour.eInverse()/] | Sequence{Second Child Package, Element Five}

back to section

## eInverse(oclType: OclType): Sequence(OclAny)

Returns the elements of the given type from the set of the inverse references of self. The returned sequence's elements are typed with the expected type (so there's no need to invoke oclAsType(oclType) on the sequence or its elements).

Expression | Result
--- | ---
[elementFour.eInverse(EClass)/] | Sequence{Element Five}
[elementFour.eInverse(EPackage)/] | Sequence{}

back to section

## followingSiblings(): Sequence(OclAny)

Returns a Sequence containing the full set of the receiver's following siblings.

Expression | Result
--- | ---
[thirdChildPackage.followingSiblings()/] | Sequence{Element Four, Element Five}

back to section

## followingSiblings(oclType: OclType): Sequence(OclType)

Returns the elements of the given type from the set of the receiver's following siblings as a Sequence. The returned sequence's elements are typed with the expected type (so there's no need to invoke oclAsType(oclType) on the sequence or its elements).

Expression | Result
--- | ---
[thirdChildPackage.followingSiblings(EClass)/] | Sequence{Element Four, Element Five}
[thirdChildPackage.followingSiblings(EPackage)/] | Sequence{}

back to section

## getProperty(key: String): String

Returns the value of the property corresponding to the given key. Note that parameterized properties will be returned "as is" by this operation (parameters are not processed).

We are considering two files, a.properties containing:

- a.b.c = This is a parameterized property: {0}

And b.properties containing:

- a.b.c = This is a parameterized property with a name conflict: {0}
- a.b.c.d = This is a standard property

Expression | Result
--- | ---
[getProperty('a.b.c')/] | 'This is a parameterized property: {0}'
[getProperty('a.b.c.d')/] | 'This is a standard property'
[getProperty('a.b.c.d.e')/] | ''

back to section

## getProperty(key: String, parameters: Sequence(OclAny)): String

Returns the value of the property corresponding to the given key, with its parameters substituted with the given values if any.

We are considering two files, a.properties containing:

- a.b.c = This is a parameterized property: {0}

And b.properties containing:

- a.b.c = This is a parameterized property with a name conflict: {0}
- a.b.c.d = This is a standard property

Expression | Result
--- | ---
[getProperty('a.b.c', Sequence{'substitution'})/] | 'This is a parameterized property: substitution'
[getProperty('a.b.c', Sequence{'substitution'})/] | 'This is a parameterized property: {0}'
[getProperty('a.b.c.d', Sequence{'substitution'})/] | 'This is a standard property'

back to section

## getProperty(name:String, key: String): String

Returns the value of the property corresponding to the given key from a properties file corresponding to the given name. Note that parameterized properties will be returned as is with this.

We are considering two files, a.properties containing:

- a.b.c = This is a parameterized property: {0}

And b.properties containing:

- a.b.c = This is a parameterized property with a name conflict: {0}
- a.b.c.d = This is a standard property

Expression | Result
--- | ---
[getProperty('b.properties', 'a.b.c')/] | 'Parameterized property with a name conflict: {0}'
[getProperty('a.properties', 'a.b.c.d')/] | ''

back to section

## getProperty(name: String, key: String, parameters: Sequence(OclAny)): String

Returns the value of the property corresponding to the given key from a properties file corresponding to the given name, with its parameters substituted with the given values if any.

We are considering two files, a.properties containing:

- a.b.c = This is a parameterized property: {0}

And b.properties containing:

- a.b.c = This is a parameterized property with a name conflict: {0}
- a.b.c.d = This is a standard property

Expression | Result
--- | ---
[getProperty('b.properties', 'a.b.c', Sequence{'substitution'})/] | 'Parameterized property with a name conflict: substitution'
[getProperty('b.properties', 'a.b.c', Sequence{})/] | 'Parameterized property with a name conflict: {0}'
[getProperty('a.properties', 'a.b.c.d', Sequence{'substitution'})/] | ''

back to section

## invoke(className: String, methodName: String, arguments: Sequence(OclAny)): OclAny

Invokes the Java method method of class class with the given arguments. This will return OclInvalid if the method cannot be called in any way (bad arguments, mispelled name, mispelled signature, encapsulation errors, ...). This is only intended to be used to call Java methods for now.

Expression | Result
--- | ---
[invoke('java.lang.String', 'toUpperCase()', Sequence{elementOne.name})/] | ELEMENT ONE

back to section

## lineSeparator(): String

Returns the line separator of the current platform (similar to System.getProperty('line.separator')) or the line separator of the Eclipse properties if it has been changed by the user.

Expression | Result
--- | ---
[lineSeparator()/] | '\n' (Unix) or '\r\n' (Dos) or '\r' (Mac Os Classic)

back to section

## oclAsType(oclType: OclType): OclType

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
--- | ---
[elementOne.oclAsType(EClass)/] | Element One
[elementOne.oclAsType(EPackage)/] | Invalid

back to section

## oclIsInvalid(): Boolean

Returns true if self is equal to invalid.

Expression | Result
--- | ---
[elementOne.oclIsInvalid()/] | false

back to section

## oclIsKindOf(oclType: OclType): 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
--- | ---
[elementOne.oclIsKindOf(EClass)/] | true
[elementOne.oclIsKindOf(ENamedElement)/] | true

back to section

## oclIsTypeOf(oclType: OclType): 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
--- | ---
[elementOne.oclIsTypeOf(EClass)/] | true
[elementOne.oclIsTypeOf(ENamedElement)/] | false

back to section

## oclIsUndefined(): Boolean

Returns true if self is equal to invalid or null.

Expression | Result
--- | ---
[elementOne.oclIsUndefined()/] | false

back to section

## precedindSiblings(): Sequence(OclAny)

Returns a Sequence containing the full set of the receiver's preceding siblings.

Expression | Result
--- | ---
[elementFive.precedingSiblings()/] | Sequence{Third Child Package, Element Four}

back to section

## precedingSiblings(oclType: OclType): Sequence(OclType)

Returns the elements of the given type from the set of the receiver's preceding siblings as a Sequence. The returned sequence's elements are typed with the expected type (so there's no need to invoke oclAsType(oclType) on the sequence or its elements).

Expression | Result
--- | ---
[elementFive.precedingSiblings(EPackage)/] | Sequence{Third Child Package}

back to section

## siblings(): Sequence(OclAny)

Returns a Sequence containing the full set of the receiver's siblings.

Expression | Result
--- | ---
[elementFour.siblings()/] | Sequence{Third Child Package, Element Five}

back to section

## siblings(oclType: OclType): Sequence(OclAny)

Returns the elements of the given type from the set of the receiver's siblings as a Sequence. The returned sequence's elements are typed with the expected type (so there's no need to invoke oclAsType(oclType) on the sequence or its elements).

Expression | Result
--- | ---
[elementFour.siblings(EPackage)/] | Sequence{Third Child Package}
[elementFour.siblings(EClass)/] | Sequence{Element Five}

back to section

## toString(): String

Returns the String representation of the receiver.

Expression | Result
--- | ---
[elementOne.toString()/] | org.eclipse.emf.ecore.impl.EClassImpl@4d06b4 (name: Element One) (instanceClassName: null) (abstract: false, interface: false)

back to section

## + (str: String): String

Returns the string representation of the receiver concatenated with the given string.

Expression | Result
--- | ---
[elementOne + 'a'/] | org.eclipse.emf.ecore.impl.EClassImpl@4d06b4 (name: Element One) (instanceClassName: null) (abstract: false, interface: false)a

back to section

# String operations available on strings.

Operation | Origin | Standard
--- | --- | ---
concat(str: String): String | Ocl | Yes
contains(subString: String): Boolean | Acceleo | No
endsWith(subString: String): Boolean | Acceleo | No
equalsIgnoreCase(str: String): Boolean | Acceleo | No
first(n: Integer): String | Acceleo | Yes
index(subString: String): Integer | Acceleo | Yes
index(subString: String, index: Integer): Integer | Acceleo | No
isAlpha(): Boolean | Acceleo | Yes
isAlphanum(): Boolean | Acceleo | Yes
last(n: Integer): String | Acceleo | Yes
lastIndex(subString: String): Integer | Acceleo | No
lastIndex(subString: String, index: Integer): Integer | Acceleo | No
matches(regex: String): Boolean | Acceleo | No
prefix(str: String): String | Acceleo | No
replace(subStringRegex: String, replacementRegex: String): String | Acceleo | No
replaceAll(subStringRegex: String, replacementRegex: String): String | Acceleo | No
size(): Integer | Ocl | Yes
startsWith(subString: String): Boolean | Acceleo | No
strcmp(str: String): Integer | Acceleo | Yes
strstr(str: String): Boolean | Acceleo | Yes
strtok(str: String, n: Integer): String | Acceleo | Yes
substitute(origin: String, replacement: String): String | Acceleo | Yes
substituteAll(origin: String, replacement: String): String | Acceleo | No
substring(start: Integer): String | Acceleo | No
substring(start: Integer, end: Integer): String | Ocl | Yes
toInteger(): Integer | Ocl | Yes
tokenize(): Sequence(String) | Acceleo | No
tokenize(subString: String): Sequence(String) | Acceleo | No
tokenizeLine(): Sequence(String) | Acceleo | No
toLower(): String | Ocl | Yes
toLowerFirst(): String | Acceleo | Yes
toReal(): Real | Ocl | Yes
toUpperFirst(): String | Acceleo | Yes
toUpper(): String | Ocl | Yes
trim(): String | Acceleo | No
+ (str: String): String | Acceleo | No

back to top

## concat(str: String): String

Returns a string containing "self" followed by "str".

Expression | Result
--- | ---
['aString'.concat('anotherString')/] | 'aStringanotherString'

back to section

## contains(subString: String): Boolean

Returns "true" if "self" contains the string "subString", "false" otherwise.

Expression | Result
--- | ---
['aString'.contains('String')/] | true
['aString'.contains('anotherString')/] | false
['aString'.contains('string')/] | false

back to section

## endsWith(subString: String): Boolean

Returns "true" if "self" ends with the string "subString", "false" otherwise.

Expression | Result
--- | ---
['aString'.endsWith('String')/] | true
['aString'.endsWith('anotherString')/] | false
['aString'.endsWith('string')/] | false

back to section

## equalsIgnoreCase(str: String): Boolean

Returns "true" if "self" is equal to the string "str" ignoring case considerations, otherwise returns "false". Two strings are considered equal ignoring the case if they are of the same length and corresponding characters in the two strings are equal ignoring their case.

Expression | Result
--- | ---
['aString'.equalsIgnoreCase('anotherString')/] | false
['aString'.equalsIgnoreCase('aString')/] | true
['aString'.equalsIgnoreCase('astring')/] | true

back to section

## first(n: Integer): String

Returns the first "n" characters of "self", or "self" if its size is less than "n".

Expression | Result
--- | ---
['aString'.first(2)/] | 'aS'
['aString'.first(0)/] | ''
['aString'.first(-1)/] | Invalid
['aString'.first(15)/] | 'aString'

back to section

## index(subString: String): Integer

Returns the index of the string "subString" in "self", or "-1" if "self" contains no occurrence of "subString". Important: String indexes start at 1. Consequently the last character's index in a string is equal to the string's length.

Expression | Result
--- | ---
['aString'.index('a')/] | 1
['aString'.index('String')/] | 2
['aString'.index('Yop')/] | -1

back to section

## index(subString: String, index: Integer): Integer

Returns the index of the string "subString" in "self", or "-1" if "self" contains no occurrence of "subString" starting from the given "index". Important: String indexes start at 1. Consequently the last character's index in a string is equal to the string's length.

Expression | Result
--- | ---
['aString'.index('a', 1)/] | -1
['aString'.index('a', 0)/] | 1
['aString'.index('String', -1)/] | 2

back to section

## isAlpha(): Boolean

Returns "true" if "self" consists only of alphabetical characters, "false" otherwise.

Expression | Result
--- | ---
['aString'.isAlpha()/] | true
['aString1'.isAlpha()/] | false

back to section

## isAlphanum(): Boolean

Returns "true" if "self" consists only of alphanumeric characters, "false" otherwise.

Expression | Result
--- | ---
['aString'.isAlphanum()/] | true
['aString1'.isAlphanum()/] | true

back to section

## last(n: Integer): String

Returns the last "n" characters of "self", or "self" if its size is less than "n".

Expression | Result
--- | ---
['aString'.last(1)/] | 'g'
['aString'.last(0)/] | ''
['aString'.last(15)/] | 'aString'
['aString'.last(-1)/] | Invalid

back to section

## lastIndex(subString: String): Integer

Returns the last index of the string "subString" in "self", or "-1" if "self" contains no occurrence of "subString". Important: String indexes start at 1. Consequently the last character's index in a string is equal to the string's length.

Expression | Result
--- | ---
['aString'.lastIndex('i')/] | 5
['aString'.lastIndex('Yop')/] | -1
['aStringa'.lastIndex('a')/] | 8

back to section

## lastIndex(subString: String, index: Integer): Integer

Returns the last index of the string "subString" in "self", or "-1" if "self" contains no occurrence of "subString" up to the given "index". This operation has the same behavior as the Java operation "java.lang.String#lastIndex(java.lang.String, int)". Important: String indexes start at 1. Consequently the last character's index in a string is equal to the string's length.

Expression | Result
--- | ---
['aStringa'.lastIndex('a', 3)/] | 1
['aStringa'.lastIndex('a', 8)/] | 8
['aStringa'.lastIndex('a', -1)/] | -1
['aStringa'.lastIndex('i', 2)/] | -1

back to section

## matches(regex: String): Boolean

Returns "true" if "self" matches the given regular expression pattern "regex", "false" otherwise. The regex engine used is that of your runtime JDK. The given pattern is passed "as is" to the method matches of the java class String. For more about regular expressions, please refer to the JDK API documentation.

Expression | Result
--- | ---
['characters and spaces'.matches('[\\w\\s]+')/] | true
['characters and spaces'.matches('[\\d\\s]+')/] | false

back to section

## prefix(str: String): String

Returns "self" prefixed by the string "str".

Expression | Result
--- | ---
['aString'.prefix('PREFIX')/] | 'PREFIXaString'
['aString'.prefix('')/] | 'aString'

back to section

## replace(subStringRegex: String, replacementRegex: String): String

Substitutes the first occurrence of the string "subStringRegex" in "self" by the "replacementRegex" string and returns the resulting string. Returns "self" if it contains no occurrence of the "subStringRegex". Note that both the "subStringRegex" and "replacementRegex" are treated as regular expressions.

Expression | Result
--- | ---
['replace operation'.replace('p', 'P')/] | 'rePlace operation'
['repla ce operation'.replace('(\\w+)\\s*', '$1')/] | 'replace operation'

back to section

## replaceAll(subStringRegex: String, replacementRegex: String): String

Substitutes all the strings "subStringRegex" in "self" by the string "replacementRegex" and returns the resulting string. Returns "self" if it contains no occurrence of "subStringRegex". Note that both "subStringRegex" and "replacementRegex" are treated as regular expressions.

Expression | Result
--- | ---
['replaceAll operation'.replaceAll('p', 'P')/] | 'rePlaceAll oPeration'
['Repla ce All Operation'.replaceAll('(\\w+)\\s*', '$1')/] | 'ReplaceAllOperation'

back to section

## size(): Integer

Returns the number of characters composing "self".

Expression | Result
--- | ---
['aString'.size()/] | 7
[''.size()/] | 0

back to section

## startsWith(subString: String): Boolean

Returns "true" if "self" starts with the string "subString", "false" otherwise.

Expression | Result
--- | ---
['aString'.startsWith('aStr')/] | true
['aString'.startsWith('Str')/] | false
['aString'.startsWith('')/] | true

back to section

## strcmp(str: String): Integer

Returns an integer that is either negative, zero or positive depending on whether "str" is alphabetically less than, equal to or greater than "self". Note that upper case letters come before lower case ones, so that 'AA' is closer to 'AC' than it is to 'Ab'.

Expression | Result
--- | ---
['aString'.strcmp('aStr')/] | 3
['aString'.strcmp('a')/] | 6

back to section

## strstr(str: String): Boolean

Searches for string "str" in "self". Returns "true" if found, "false" otherwise. This operation is identical to 'contains'.

Expression | Result
--- | ---
['aString'.strstr('aStr')/] | true
['aString'.strstr('Yop')/] | false

back to section

## strtok(str: String, n: Integer): String

Breaks "self" into a sequence of tokens, each of which delimited by any one of the characters in "str", and returns the next element in this sequence. The parameter flag should be "0" when strtok is called for the first time and will reset the sequence, "1" subsequently so as to access the next element.

Expression | Result
--- | ---
['aString'.strtok('S', 0)/] | 'a'
['aString'.strtok('S', 1)/] | 'tring'
['aString'.strtok('s', 0)/] | 'aString'

back to section

## substitute(origin: String, replacement: String): String

Substitutes the string "origin" in "self" by the string "replacement" and returns the resulting string. Will return "self" if it contains no occurrence of the string "origin".

Expression | Result
--- | ---
['substitute operation'.substitute('t', 'T')/] | 'subsTitute operation'
['substitute operation'.substitute('Yop', 'T')/] | 'substitute operation'

back to section

## substituteAll(origin: String, replacement: String): String

Substitutes all the string "origin" in "self" by the string "replacement" and returns the resulting string. Returns "self" if it contains no occurrence of "origin". Unlike the replaceAll operation, neither "origin" nor "replacement" are considered as regular expressions.

Expression | Result
--- | ---
['substituteAll operation'.substituteAll('t', 'T')/] | 'subsTiTuTeAll operaTion'
['substituteAll operation'.substituteAll('Yop', 'T')/] | 'substituteAll operation'

back to section

## substring(start: Integer): String

Returns a substring of self, starting at startIndex (inclusive), until the end of self. Returns Ø when the startIndex is either negative, zero, or greater than self's length. Important: String indexes start at 1. Consequently the last character's index in a string is equal to the string's length.

Expression | Result
--- | ---
['substring'.substring(1)/] | 'substring'
['substring'.substring(3)/] | 'bstring'
['substring'.substring(0)/] | Invalid

back to section

## substring(start: Integer, end: Index): 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'.substring(1, 5)/] | 'subst'
['substring'.substring(0, 5)/] | Invalid
['substring'.substring(1, 'substring'.size())/] | 'substring'

back to section

## toInteger(): Integer

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

Expression | Result
--- | ---
['5'.toInteger()/] | 5
['-1'.toInteger()/] | -1
['five'.toInteger()/] | Invalid

back to section

## tokenize(): Sequence(String)

Returns a sequence of string containing all the parts of the original string tokenized using all the whitespaces as tokens.

Expression | Result
--- | ---
['this is a string'.tokenize()/] | Sequence{'this', 'is', 'a', 'string'}

back to section

## tokenize(subString: String): Sequence(String)

Returns a sequence containing all parts of self splitted with delimiters defined by the characters in String delim.

Expression | Result
--- | ---
['this is a string'.tokenize('i')/] | Sequence{'th', 's ', 's a str', 'ng'}
['this is a string'.tokenize('o')/] | Sequence{'this is a string'}

back to section

## tokenizeLine(): Sequence(String)

Returns a sequence containing all parts of self splitted with delimiters defined by using the line separator.

Expression | Result
--- | ---
['this is\n a\r\n string'.tokenizeLine()/] | Sequence{'this is', ' a', ' string'}

back to section

## toLower(): String

Returns self with all characters converted to lowercase.

Expression | Result
--- | ---
['TO LoWeR'.toLower()/] | 'to lower'

back to section

## toLowerFirst(): String

Returns a copy of self with its first character converted to lower case and returns it.

Expression | Result
--- | ---
['TO LoWeR First'.toLower()/] | 'tO LoWeR First'

back to section

## toReal(): Real

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

Expression | Result
--- | ---
['3.14'.toReal()/] | 3.14
['pi'.toReal()/] | Invalid

back to section

## toUpperFirst(): String

Returns a copy of self with its first character converted to upper case and returns it.

Expression | Result
--- | ---
['to upper first'.toUpperFirst()/] | 'To upper first'

back to section

## toUpper(): String

Returns self with all characters converted to uppercase.

Expression | Result
--- | ---
['to upper'.toUpperFirst()/] | 'TO UPPER'

back to section

## trim(): String

Removes all leading and trailing white space characters (tabulation, space, line feed, ...) of self.

Expression | Result
--- | ---
[' a text to trim '.trim()/] | 'a text to trim'

back to section

## + (str: String): String

Concatenate self with the given string.

Expression | Result
--- | ---
['hello ' + 'world'/] | 'hello world'

back to section

# Number operations available on integer and floats.

Operation | Origin | Standard
--- | --- | ---
abs(): Number | OCL | Yes
div(i: Integer): Integer (integer only) | OCL | Yes
floor(): Number | OCL | Yes
max(n: Number): Number | OCL | Yes
min(n: Number): Number | OCL | Yes
mod(i: Integer): Integer (integer only) | OCL | Yes
round(): Integer | OCL | Yes

back to top

## abs(): Number

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

Expression | Result
--- | ---
[3.14.abs()/] | 3.14
[-3.14.abs()/] | -3.14
[-(3.14.abs())/] | -3.14
[(-3.14).abs()/] | 3.14

back to section

## div(i: Integer): Integer

(integer only)

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

Expression | Result
--- | ---
[5.div(2)/] | 2
[5.div(0)/] | Invalid

back to section

## floor(): Number

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

Expression | Result
--- | ---
[5.9.floor()/] | 5
[3.1.floor()/] | 3

back to section

## max(n: Number): Number

Returns the greatest number between self and n.

Expression | Result
--- | ---
[3.1111.max(3.2)/] | 3.2

back to section

## min(n: Number): Number

Returns the lowest number between self and n.

Expression | Result
--- | ---
[3.1111.min(3.2)/] | 3.1111

back to section

## mod(i: Integer): Integer

(integer only)

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

Expression | Result
--- | ---
[7.mod(3)/] | 1

back to section

## round(): Integer

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

Expression | Result
--- | ---
[5.9.round()/] | 6

back to section

# Boolean operations available on boolean.

Operation | Origin | Standard
--- | --- | ---
and(b: Boolean): Boolean | OCL | Yes
implies(b: Boolean): Boolean | OCL | Yes
or(b: Boolean): Boolean | OCL | Yes
not(): Boolean | OCL | Yes
xor(b: Boolean): Boolean | OCL | Yes

back to top

## and(b: Boolean): Boolean

See the table below for the result.

| True | False
--- | --- | ---
True | true | false
False | false | false

back to section

## implies(b: Boolean): Boolean

See the table below for the result.

| True | False
--- | --- | ---
True | true | false
False | true | true

back to section

## or(b: Boolean): Boolean

See the table below for the result.

| True | False
--- | --- | ---
True | true | true
False | true | false

back to section

## not(b: Boolean): Boolean

See the table below for the result.

True | False
--- | ---
false | true

back to section

## xor(b: Boolean): Boolean

See the table below for the result.

| True | False
--- | --- | ---
True | false | true
False | true | false

back to section

# Collections operations available on collections.

Operation | Origin | Standard
--- | --- | ---
addAll(collection: Collection(T)): Collection(T) | Acceleo | No
any(expr: OclExpression): OclAny | OCL | Yes
asBag(): Bag(T) | OCL | Yes
asOrderedSet(): OrderedSet(T) | OCL | Yes
asSequence(): Sequence(T) | OCL | Yes
asSet(): Set(T) | OCL | Yes
collect(expr: OclExpression): Collection(T2) | OCL | Yes
collectNested(expr: OclExpression): Collection(T2) | OCL | Yes
count(elem: T): Integer | OCL | Yes
excludes(elem: T): Boolean | OCL | Yes
excludesAll(c: Collection(T)): Boolean | OCL | Yes
excluding(elem: T): Collection(T) | OCL | Yes
exists(expr: OclExpression): Boolean | OCL | Yes
filter(oclType: OclType): Collection(OclType) | Acceleo | No
flatten(): Collection(T2) | OCL | Yes
forAll(expr: OclExpression): Boolean | OCL | Yes
includes(elem: T): Boolean | OCL | Yes
includesAll(c: Collection(T)): Boolean | OCL | Yes
including(elem: T): Collection(T) | OCL | Yes
isEmpty(): Boolean | OCL | Yes
isUnique(expr: OclExpression): Boolean | OCL | Yes
max(): T | OCL | Yes
min(): T | OCL | Yes
notEmpty(): Boolean | OCL | Yes
one(expr: OclExpression): Boolean | OCL | Yes
product(c: Collection(T2)): Set(Tuple(first: T, second: T2)) | OCL | Yes
reject(expr: OclExpression): Collection(T) | OCL | Yes
removeAll(collection: Collection(T)): Collection(T) | Acceleo | No
select(expr: OclExpression): Collection(T) | OCL | Yes
sep(separator: String): Sequence(OclAny) | Acceleo | No
sep(prefix: String, separator: String, suffix: String): Sequence(OclAny) | Acceleo | No
size(): Integer | OCL | Yes
sortedBy(expr: OclExpression): Sequence(T) | OCL | Yes
sum(): T | OCL | Yes

back to top

## addAll(collection: Collection(T)): Collection(T)

Adds all the content of the given collection to the current collection.

Expression | Result
--- | ---
[Sequence{'a', 'b', 'c'}->addAll(Sequence{'d', 'e', 'f'})/] | [Sequence{'a', 'b', 'c', 'd', 'e', 'f'}/]
[OrderedSet{'a', 'b', 'c'}->addAll(Sequence{'d', 'e', 'f'})/] | [OrderedSet{'a', 'b', 'c', 'd', 'e', 'f'}/]
[Sequence{'a', 'b', 'c'}->addAll(Bag{'d', 'e', 'f'})/] | [Sequence{'a', 'b', 'c', 'f', 'e', 'd'}/]
[Sequence{'a', 'b', 'c'}->addAll(Set{'d', 'e', 'f'})/] | [Sequence{'a', 'b', 'c', 'f', 'd', 'e'}/]

back to section

## any(expr: OclExpression): OclAny

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{'aWord', 'anotherWord', 'yetAnotherWord'}->any(s: String | s.startsWith('another'))/] | 'anotherWord'

back to section

## asBag(): Bag(T)

Returns a Bag containing all elements of self.

Expression | Result
--- | ---
[Sequence{'a', 'b', 'c'}->asBag()/] | Bag{'a', 'b', 'c'}
[Set{'a', 'b', 'c'}->asBag()/] | Bag{'a', 'b', 'c'}
[OrderedSet{'a', 'b', 'c'}->asBag()/] | Bag{'a', 'b', 'c'}
[Bag{'a', 'b', 'c'}->asBag()/] | Bag{'a', 'b', 'c'}

back to section

## asOrderedSet(): OrderedSet(T)

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

Expression | Result
--- | ---
[Sequence{'a', 'b', 'c'}->asOrderedSet()/] | OrderedSet{'a', 'b', 'c'}
[Set{'a', 'b', 'c'}->asOrderedSet()/] | OrderedSet{'a', 'b', 'c'}
[OrderedSet{'a', 'b', 'c'}->asOrderedSet()/] | OrderedSet{'a', 'b', 'c'}
[Bag{'a', 'b', 'c'}->asOrderedSet()/] | OrderedSet{'a', 'b', 'c'}

back to section

## asSequence(): Sequence(T)

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

Expression | Result
--- | ---
[Sequence{'a', 'b', 'c'}->asSequence()/] | Sequence{'a', 'b', 'c'}
[Set{'a', 'b', 'c'}->asSequence()/] | Sequence{'a', 'b', 'c'}
[OrderedSet{'a', 'b', 'c'}->asSequence()/] | Sequence{'a', 'b', 'c'}
[Bag{'a', 'b', 'c'}->asSequence()/] | Sequence{'a', 'b', 'c'}

back to section

## asSet(): Set(T)

Returns a Set containing all elements of self.

Expression | Result
--- | ---
[Sequence{'a', 'b', 'c'}->asSet()/] | Set{'a', 'b', 'c'}
[Set{'a', 'b', 'c'}->asSet()/] | Set{'a', 'b', 'c'}
[OrderedSet{'a', 'b', 'c'}->asSet()/] | Set{'a', 'b', 'c'}
[Bag{'a', 'b', 'c'}->asSet()/] | Set{'a', 'b', 'c'}

back to section

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

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

Expression | Result
--- | ---
[Sequence{'a', 'b', 'c'}->collect(s: String | s.toUpper())/] | [Sequence{'A', 'B', 'C'}/]

back to section

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

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

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

Expression | Result
--- | ---
[self.persons->collectNested(children.firstname)/] | [Sequence{Sequence{'James', 'Jane'}, Sequence{'John'}} /]

back to section

## count(elem: T): Integer

Returns how many times object is in the collection self.

Expression | Result
--- | ---
[Sequence{'a', 'b', 'c', 'd', 'a'}->count('a')/] | 2

back to section

## excludes(elem: T): Boolean

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

Expression | Result
--- | ---
[Sequence{'a', 'b', 'c'}->excludes('a')/] | false
[Sequence{'a', 'b', 'c'}->excludes('d')/] | true

back to section

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

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

Expression | Result
--- | ---
[Sequence{'a', 'b', 'c'}->excludesAll(Sequence{'a', 'd'})/] | false
[Sequence{'a', 'b', 'c'}->excludesAll(Sequence{'d', 'f'})/] | true

back to section

## excluding(elem: T): Collection(T)

Returns a collection containing all elements of self minus all occurences of object.

Expression | Result
--- | ---
[Sequence{'a', 'b', 'c'}->excluding('a')/] | Sequence{'b', 'c'}

back to section

## 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{'a', 'b', 'c'}->exists(s: String | s.size() > 1)/] | false
[Sequence{'a', 'b', 'cccc'}->exists(s: String | s.size() > 1)/] | true

back to section

## filter(oclType: OclType): Collection(OclType)

Filters out of the collection all elements that are not instances of the given type or any of its subtypes. The returned collection is typed according to type. Makes it easier to write select(e | e.oclIsKindOf(oclType)).oclAsType(oclType).

Expression | Result
--- | ---
[Sequence{First Child Package, Second Child Package, Element Three}->filter(EClass)/] | Sequence{Element Three}
[Sequence{First Child Package, Second Child Package, Element Three}->filter(EPackage)/] | Sequence{First Child Package, Second Child Package}

back to section

## flatten(): Collection(T2)

Returns a collection containing all elements of self recursively flattened.

Expression | Result
--- | ---
[Sequence{Sequence{'a', 'b', 'c'}, Sequence{'a'}}/] | Sequence{'a', 'b', 'c', 'a'}

back to section

## forAll(expr: OclExpression): Boolean

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

Expression | Result
--- | ---
[Sequence{'a', 'b', 'c'}->forAll(s: String| s.startsWith('a'))/] | false

back to section

## includes(elem: T): Boolean

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

Expression | Result
--- | ---
[Sequence{'a', 'b', 'c'}->includes('a')/] | true

back to section

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

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

Expression | Result
--- | ---
[Sequence{'a', 'b', 'c'}->includesAll(Sequence{'a', 'b'})/] | true

back to section

## including(elem: T): Collection(T)

Returns a collection containing all elements of self followed by object.

Expression | Result
--- | ---
[Sequence{'a', 'b', 'c'}->including('a')/] | Sequence{'a', 'b', 'c', 'a'}

back to section

## isEmpty(): Boolean

Returns true if self is empty, false otherwise.

Expression | Result
--- | ---
[Sequence{'a', 'b', 'c'}->isEmpty()/] | false

back to section

## isUnique(expr: OclExpression): Boolean

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

Expression | Result
--- | ---
[Sequence{'a', 'b', 'c', 'a'}->isUnique(s: String | s.toUpper())/] | false

back to section

## max(): T

The element with the maximum value of all elements in self. Elements must be of a type supporting the max operation. The max operation – supported by the elements – must take one parameter of type T and be both associative and commutative. UnlimitedNatural, Integer and Real fulfill this condition.

Expression | Result
--- | ---
[Sequence{5, 9, 2}->max()/] | 9

back to section

## min(): T

The element with the minimum value of all elements in self. Elements must be of a type supporting the min operation. The min operation – supported by the elements – must take one parameter of type T and be both associative and commutative. UnlimitedNatural, Integer and Real fulfill this condition.

Expression | Result
--- | ---
[Sequence{5, 9, 2}->min()/] | 2

back to section

## notEmpty(): Boolean

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

Expression | Result
--- | ---
[Sequence{'a', 'b', 'c'}->notEmpty()/] | true

back to section

## 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{'a', 'b', 'c'}->one(s: String| s.startsWith('z'))/] | false

back to section

## product(c: 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{'a', 'b'}->product(Sequence{1, 2})/] | Set{Tuple{'a', 1}, Tuple{'b', 1}, Tuple{'b', 2}, Tuple{'a', 2}}

back to section

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

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

Expression | Result
--- | ---
[Sequence{'a', 'b', 'c'}->reject(s: String | s.startsWith('b'))/] | Sequence{'a', 'c'}

back to section

## removeAll(collection: Collection(T)): Collection(T)

Removes all the content of the given collection from the current collection.

Expression | Result
--- | ---
[Sequence{'a', 'b', 'c'}->removeAll(Sequence{'b', 'c'})/] | Sequence{'a'}
[Sequence{'a', 'b', 'c'}->removeAll(Bag{'b', 'c'})/] | Sequence{'a'}
[Sequence{'a', 'b', 'c'}->removeAll(OrderedSet{'b', 'c'})/] | Sequence{'a'}
[Sequence{'a', 'b', 'c'}->removeAll(Set{'b', 'c'})/] | Sequence{'a'}

back to section

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

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

Expression | Result
--- | ---
[Sequence{'a', 'b', 'c'}->select(s: String | not s.startsWith('a'))/] | Sequence{'b', 'c'}

back to section

## sep(separator: String): Collection(OclAny)

Returns all elements from the source collection separated by an element composed of the String separator.

Expression | Result
--- | ---
[Sequence{'a', 'b', 'c'}->sep('haha')/] | Sequence{'a', 'haha', 'b', 'haha', 'c'}

back to section

## sep(prefix: String, separator: String, suffix: String): Collection(OclAny)

Returns all elements from the source collection separated by an element composed of the String separator with the prefix as the first element of the collection and the suffix as the latest element of the collection.

Expression | Result
--- | ---
[Sequence{'a', 'b', 'c'}->sep('prefix', 'haha', 'suffix')/] | Sequence{'prefix', 'a', 'haha', 'b', 'haha', 'c', 'suffix'}

back to section

## size(): Integer

Returns the number of elements contained in self.

Expression | Result
--- | ---
[Sequence{'a', 'b', 'c'}->size()/] | 3

back to section

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

Expression | Result
--- | ---
[Sequence{'aaaa', 'bb', 'ccc'}->sortedBy(s: String | s.size())/] | Sequence{'bb', 'ccc', 'aaaa'}

back to section

## sum(): T

The addition of all elements in self. Elements must be of a type supporting the + operation. The + operation must take one parameter of type T and be both associative: (a+b) c = a(b+c), and commutative: a+b = b+a. UnlimitedNatural, Integer and Real fulfill this condition. If the + operation is not both associative and commutative, the sum expression is not well-formed, which may result in unpredictable results during evaluation. If an implementation is able to detect a lack of associativity or commutativity, the implementation may bypass the evaluation and return an invalid result.

Expression | Result
--- | ---
[Sequence{1, 2, 3}->sum()/] | 6

back to section

# Sequence operations available on sequences.

Operation | Origin | Standard
--- | --- | ---
= (seq: Sequence(T)): Boolean | OCL | Yes
<> (seq: Sequence(T)): Boolean | OCL | Yes
append(elem: T): Sequence(T) | OCL | Yes
at(index: Integer): T | OCL | Yes
drop(n: Integer): Sequence(T) | Acceleo | No
dropRight(n: Integer): Sequence(T) | Acceleo | No
endsWith(subCollection: OrderedSet(T)): Boolean | Acceleo | No
endsWith(subCollection: Sequence(T)): Boolean | Acceleo | No
first(): T | OCL | Yes
indexOf(elem: T): Integer | OCL | Yes
indexOfSlice(subCollection: OrderedSet(T)): Integer | Acceleo | No
indexOfSlice(subCollection: Sequence(T)): Integer | Acceleo | No
insertAt(index: Integer, elem: T): Sequence(T) | OCL | Yes
last(): T | OCL | Yes
lastIndexOf(elem: T): Integer | Acceleo | No
lastIndexOfSlice(subCollection: OrderedSet(T)): Integer | Acceleo | No
lastIndexOfSlice(subCollection: Sequence(T)): Integer | Acceleo | No
prepend(elem: T): Sequence(T) | OCL | Yes
reverse(): Sequence(T) | Acceleo | No
startsWith(subCollection: OrderedSet(T)): Boolean | Acceleo | No
startsWith(subCollection: Sequence(T)): Boolean | Acceleo | No
subSequence(startIndex: Integer, endIndex: Integer):Sequence(T) | OCL | Yes
union(c: Sequence(T)): Sequence(T) | OCL | Yes

back to top

## = (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{'a', 'b', 'c'} = Sequence{'a', 'b', 'c'}/] | true

back to section

## <> (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{'a', 'b', 'c'} <> Sequence{'a', 'b', 'c'}/] | false

back to section

## append(elem: T): Sequence(T)

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

Expression | Result
--- | ---
[Sequence{'a', 'b', 'c'}.append('d')/] | Sequence{'a', 'b', 'c', 'd'}

back to section

## at(index: Integer): T

Returns the element of self at the index position.

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

back to section

## drop(n: Integer): Sequence(T)

Returns the collection after the removal of the n first elements.

Expression | Result
--- | ---
[Sequence{'a', 'b', 'c'}->drop(2)/] | 'c'

back to section

## dropRight(n: Integer): Sequence(T)

Returns the collection after the removal of the n latest elements.

Expression | Result
--- | ---
[Sequence{'a', 'b', 'c'}->dropRight(2)/] | 'a'

back to section

## endsWith(subCollection: OrderedSet(T)): Boolean

Indicates if the self collection ends with the given sub-collection.

Expression | Result
--- | ---
[Sequence{'a', 'b', 'c'}->endsWith(OrderedSet{'b', 'c'})/] | true

back to section

## endsWith(subCollection: Sequence(T)): Boolean

Indicates if the self collection ends with the given sub-collection.

Expression | Result
--- | ---
[Sequence{'a', 'b', 'c'}->endsWith(Sequence{'b', 'c'})/] | true

back to section

## first(): T

Returns the first element of the sequence.

Expression | Result
--- | ---
[Sequence{'a', 'b', 'c'}->first()/] | 'a'

back to section

## indexOf(elem: T): Integer

Returns the position of object in sequence self.

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

back to section

## indexOfSlice(subCollection: Sequence(T)): Integer

Returns the position of the subcollection in the sequence self.

Expression | Result
--- | ---
[Sequence{'a', 'b', 'c'}->indexOfSlice(Sequence{'b', 'c'})/] | 2

back to section

## indexOfSlice(subCollection: OrderedSet(T)): Integer

Returns the position of the subcollection in the sequence self.

Expression | Result
--- | ---
[Sequence{'a', 'b', 'c'}->indexOfSlice(OrderedSet{'b', 'c'})/] | 2

back to section

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

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

Expression | Result
--- | ---
[Sequence{'a', 'b', 'c'}->insertAt(1, 'z')/] | Sequence{'z', 'a', 'b', 'c'}

back to section

## last(): T

Returns the last element of self.

Expression | Result
--- | ---
[Sequence{'a', 'b', 'c'}->last()/] | 'c'

back to section

## lastIndexOf(elem: T): Integer

Returns the last position of the object elem in the sequence self.

Expression | Result
--- | ---
[Sequence{'a', 'b', 'c', 'a'}->lastIndexOf('a')/] | 4

back to section

## lastIndexOfSlice(subCollection: Sequence(T)): Integer

Returns the last position of the subcollection in the sequence self.

Expression | Result
--- | ---
[Sequence{'a', 'b', 'c', 'b', 'c'}->lastIndexOfSlice(Sequence{'b', 'c'})/] | 4

back to section

## lastIndexOfSlice(subCollection: OrderedSet(T)): Integer

Returns the last position of the subcollection in the sequence self.

Expression | Result
--- | ---
[Sequence{'a', 'b', 'c', 'b', 'c'}->lastIndexOfSlice(OrderedSet{'b', 'c'})/] | 4

back to section

## prepend(elem: T): Sequence(T)

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

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

back to section

## reverse(): Sequence(T)

Reverses the order of the collection: the last element becomes the first and vice-versa.

Expression | Result
--- | ---
[Sequence{'a', 'b', 'c'}->reverse()/] | Sequence{'c', 'b', 'a'}

back to section

## startsWith(subCollection: Sequence(T)): Boolean

Returns true if self starts with the given sub-collection.

Expression | Result
--- | ---
[Sequence{'a', 'b', 'c'}->startsWith(Sequence{'a', 'b'})/] | true

back to section

## startsWith(subCollection: OrderedSet(T)): Boolean

Returns true if self starts with the given sub-collection.

Expression | Result
--- | ---
[Sequence{'a', 'b', 'c'}->startsWith(OrderedSet{'a', 'b'})/] | true

back to section

## 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'}->subSequence{1, 2}/] | Sequence{'a', 'b'}

back to section

## union(c: Sequence(T)): Sequence(T)

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

Expression | Result
--- | ---
[Sequence{'a', 'b', 'c'}->union(Sequence{'d', 'e'})/] | Sequence{'a', 'b', 'c', 'd', 'e'}

back to section

# Ordered Set operations available on ordered sets.

Operation | Origin | Standard
--- | --- | ---
= (c: Set(T)): Boolean | OCL | Yes
= (c: OrderedSet(T)): Boolean | OCL | Yes
<> (c: Set(T)): Boolean | OCL | Yes
<> (c: Set(T)): Boolean | OCL | Yes
- (c: Set(T)): Set(T) | OCL | Yes
append(elem: T): OrderedSet(T) | OCL | Yes
at(index: Integer): T | OCL | Yes
drop(n: Integer): OrderedSet(T) | Acceleo | No
dropRight(n: Integer): OrderedSet(T) | Acceleo | No
endsWith(subCollection: OrderedSet(T)): Boolean | Acceleo | No
endsWith(subCollection: Sequence(T)): Boolean | Acceleo | No
first(): T | OCL | Yes
indexOf(elem: T): Integer | OCL | Yes
indexOfSlice(subCollection: OrderedSet(T)): Integer | Acceleo | No
indexOfSlice(subCollection: Sequence(T)): Integer | Acceleo | No
insertAt(index: Integer, elem: T): OrderedSet(T) | OCL | Yes
intersection(c: Bag(T)): Set(T) | OCL | Yes
intersection(c: Set(T)): Set(T) | OCL | Yes
last(): T | OCL | Yes
lastIndexOf(elem: T): Integer | Acceleo | No
lastIndexOfSlice(subCollection: OrderedSet(T)): Integer | Acceleo | No
lastIndexOfSlice(subCollection: Sequence(T)): Integer | Acceleo | No
prepend(elem: T): OrderedSet(T) | OCL | Yes
reverse(): OrderedSet(T) | Acceleo | No
startsWith(subCollection: OrderedSet(T)): Boolean | Acceleo | No
startsWith(subCollection: Sequence(T)): Boolean | Acceleo | No
subOrderedSet(startIndex: Integer, endIndex: Integer): OrderedSet(T) | OCL | Yes
symmetricDifference(c: Set(T)): Set(T) | OCL | Yes
union(c: Bag(T)): Bag(T) | OCL | Yes
union(c: Set(T)): Set(T) | OCL | Yes

back to top

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

Returns true if self contains the same objects as set.

Expression | Result
--- | ---
[OrderedSet{'a', 'b', 'c'} = Set{'a', 'b', 'c'}/] | true

back to section

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

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

Expression | Result
--- | ---
[OrderedSet{'a', 'b', 'c'} = OrderedSet{'a', 'b', 'c'}/] | true

back to section

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

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

Expression | Result
--- | ---
[OrderedSet{'a', 'b', 'c'} <> Set{'a', 'b', 'c'}/] | false

back to section

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

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

Expression | Result
--- | ---
[OrderedSet{'a', 'b', 'c'} <> OrderedSet{'a', 'b', 'c'}/] | false

back to section

## - (c: Set(T)): Set(T)

Returns a Set containing all elements of self minus all elements of c.

Expression | Result
--- | ---
[OrderedSet{'a', 'b', 'c'} - Set{'a', 'c'}/] | OrderedSet{'b'}

back to section

## append(elem: T): OrderedSet(T)

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

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

back to section

## at(index: Integer): T

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

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

back to section

## drop(n: Integer): OrderedSet(T)

Returns an ordered set containing all the element of self minus the n first elements.

Expression | Result
--- | ---
[OrderedSet{'a', 'b', 'c'}->drop(2)/] | OrderedSet{'c'}

back to section

## dropRight(n: Integer): OrderedSet(T)

Returns an ordered set containing all the element of self minus the n last elements.

Expression | Result
--- | ---
[OrderedSet{'a', 'b', 'c'}->dropRight(2)/] | 'a'

back to section

## endsWith(subCollection: OrderedSet(T)): Boolean

Indicates if self ends with the given sub-collection.

Expression | Result
--- | ---
[OrderedSet{'a', 'b', 'c'}->endsWith(OrderedSet{'b', 'c'})/] | true

back to section

## endsWith(subCollection: Sequence(T)): Boolean

Indicates if self ends with the given sub-collection.

Expression | Result
--- | ---
[OrderedSet{'a', 'b', 'c'}->endsWith(Sequence{'b', 'c'})/] | true

back to section

## first(): T

Returns the first element of self.

Expression | Result
--- | ---
[OrderedSet{'a', 'b', 'c'}->first()/] | 'a'

back to section

## indexOf(elem: T): Integer

Returns the position of elem in self.

Expression | Result
--- | ---
[OrderedSet{'a', 'b', 'c'}->indexOf('b')/] | 2

back to section

## indexOfSlice(subCollection: OrderedSet(T)): Integer

Returns the index of the sub-collection in self.

Expression | Result
--- | ---
[OrderedSet{'a', 'b', 'c'}->indexOfSlice(OrderedSet{'b', 'c'})/] | 2

back to section

## indexOfSlice(subCollection: Sequence(T)): Integer

Returns the index of the sub-collection in self.

Expression | Result
--- | ---
[OrderedSet{'a', 'b', 'c'}->indexOfSlice(Sequence{'b', 'c'})/] | 2

back to section

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

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

Expression | Result
--- | ---
[OrderedSet{'a', 'b', 'c'}->insertAt(1, 'z')/] | OrderedSet{'z', 'a', 'b', 'c'}

back to section

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

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

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

back to section

## intersection(c: Set(T)): Set(T)

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

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

back to section

## last(): T

Returns the last element of self.

Expression | Result
--- | ---
[OrderedSet{'a', 'b', 'c'}->last()/] | 'c'

back to section

## lastIndexOf(elem: T): Integer

Returns the last index of elem in self.

Expression | Result
--- | ---
[OrderedSet{'a', 'b', 'c', 'b'}->lastIndexOf('b')/] | 4

back to section

## lastIndexOfSlice(subCollection: OrderedSet(T)): Integer

Returns the last index of the given sub-collection in self.

Expression | Result
--- | ---
[OrderedSet{'a', 'b', 'c', 'b', 'c'}->lastIndexOfSlice(OrderedSet{'b', 'c'})/] | 4

back to section

## lastIndexOfSlice(subCollection: Sequence(T)): Integer

Returns the last index of the given sub-collection in self.

Expression | Result
--- | ---
[OrderedSet{'a', 'b', 'c', 'b', 'c'}->lastIndexOfSlice(Sequence{'b', 'c'})/] | 4

back to section

## prepend(elem: T): OrderedSet(T)

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

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

back to section

<h2reverse(): OrderedSet(T)

Returns self reversed, the first element becoming the last one.

Expression | Result
--- | ---
[OrderedSet{'a', 'b', 'c'}->reverse()/] | OrderedSet{'c', 'b', 'a'}

back to section

## startsWith(subCollection: OrderedSet(T)): Boolean

Indicates if self starts with the given sub-collection.

Expression | Result
--- | ---
[OrderedSet{'a', 'b', 'c'}->startsWith(OrderedSet{'a', 'b'})/] | true

back to section

## startsWith(subCollection: Sequence(T)): Boolean

Indicates if self starts with the given sub-collection.

Expression | Result
--- | ---
[OrderedSet{'a', 'b', 'c'}->startsWith(Sequence{'a', 'b'})/] | true

back to section

## 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'}->subOrderedSet(1, 2)/] | OrderedSet{'a', 'b'}

back to section

## symmetricDifference(c: 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{'a', 'b', 'c'}->symmetricDifference(Set{'a'})/] | Set{'b', 'c'}

back to section

## union(c: Bag(T)): Bag(T)

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

Expression | Result
--- | ---
[OrderedSet{'a', 'b', 'c'}->union(Bag{'d', 'e'})/] | Bag{'a', 'b', 'c', 'd', 'e'}

back to section

## union(c: Set(T)): Set(T)

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

Expression | Result
--- | ---
[OrderedSet{'a', 'b', 'c'}->union(Set{'d', 'e'})/] | Set{'a', 'b', 'c', 'd', 'e'}

back to section

# Set operations available on sets.

Operation | Origin | Standard
--- | --- | ---
= (c: Set(T)): Boolean | OCL | Yes
<> (c: Set(T)): Boolean | OCL | Yes
- (c: Set(T)): Set(T) | OCL | Yes
intersection(c: Bag(T)): Set(T) | OCL | Yes
intersection(c: Set(T)): Set(T) | OCL | Yes
symmetricDifference(c: Set(T)): Set(T) | OCL | Yes
union(c: Bag(T)): Bag(T) | OCL | Yes
union(c: Set(T)): Set(T) | OCL | Yes

back to top

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

Returns true if self contains the same objects as c.

Expression | Result
--- | ---
[Set{'a', 'b', 'c'} = Set{'b', 'c', 'a'}/] | true

back to section

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

Returns true if self does not contains the same objects as c.

Expression | Result
--- | ---
[Set{'a', 'b', 'c'} <> Set{'b', 'c', 'a'}/] | false

back to section

## - (c: Set(T)): Set(T)

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

Expression | Result
--- | ---
[Set{'a', 'b', 'c'} - Set{'a'}/] | Set{'c', 'b'}

back to section

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

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

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

back to section

## intersection(c: Set(T)): Set(T)

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

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

back to section

## symmetricDifference(c: 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{'a', 'b', 'c'}->symmetricDifference(Set{'b', 'c', 'd'})/] | Set{'a', 'd'}

back to section

## union(c: Bag(T)): Bag(T)

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

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

back to section

## union(c: Set(T)): Set(T)

Returns true if self contains the same objects as set.

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

back to section

# Bag operations available on bags.

Operation | Origin | Standard
--- | --- | ---
= (c: Bag(T)): Boolean | OCL | Yes
<> (c: Bag(T)): Boolean | OCL | Yes
intersection(c: Bag(T)): Bag(T) | OCL | Yes
intersection(c: Set(T)): Set(T) | OCL | Yes
union(c: Bag(T)): Bag(T) | OCL | Yes
union(c: Set(T)): Bag(T) | OCL | Yes

back to top

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

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

Expression | Result
--- | ---
[Bag{'a', 'b', 'c'} = Bag{'c', 'b', 'a'}/] | true

back to section

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

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

Expression | Result
--- | ---
[Bag{'a', 'b', 'c'} <> Bag{'b', 'a', 'c'}/] | false

back to section

## intersection(c: Bag(T)): Bag(T)

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

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

back to section

## intersection(c: Set(T)): Set(T)

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

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

back to section

## union(c: Bag(T)): Bag(T)

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

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

back to section