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

= (elem: OclAny): Boolean

Returns true if self is equal to object.

<> (elem: OclAny): Boolean

Returns false if self is equal to object.

< (elem: T): Boolean

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

> (elem: T): Boolean

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

<= (elem: OclAny): Boolean

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

>= (elem: OclAny): Boolean

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

ancestors(): Sequence(OclAny)

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

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.

eAllContents(): Sequence(OclAny)

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

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

current(index: Integer): OclAny

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

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.

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.

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

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.

eInverse(): Sequence(OclAny)

Returns the sequence of all objects referencing self.

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

followingSiblings(): Sequence(OclAny)

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

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

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

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

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

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

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.

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.

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.

oclIsInvalid(): Boolean

Returns true if self is equal to invalid.

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.

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.

oclIsUndefined(): Boolean

Returns true if self is equal to invalid or null.

precedindSiblings(): Sequence(OclAny)

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

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

siblings(): Sequence(OclAny)

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

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

toString(): String

Returns the String representation of the receiver.

+ (str: String): String

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

concat(str: String): String

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

contains(subString: String): Boolean

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

endsWith(subString: String): Boolean

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

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.

first(n: Integer): String

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

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.

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.

isAlpha(): Boolean

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

isAlphanum(): Boolean

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

last(n: Integer): String

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

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.

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.

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.

prefix(str: String): String

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

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.

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.

size(): Integer

Returns the number of characters composing "self".

startsWith(subString: String): Boolean

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

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

strstr(str: String): Boolean

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

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.

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

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.

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.

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.

toInteger(): Integer

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

tokenize(): Sequence(String)

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

tokenize(subString: String): Sequence(String)

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

tokenizeLine(): Sequence(String)

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

toLower(): String

Returns self with all characters converted to lowercase.

toLowerFirst(): String

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

toReal(): Real

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

toUpperFirst(): String

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

toUpper(): String

Returns self with all characters converted to uppercase.

trim(): String

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

+ (str: String): String

Concatenate self with the given string.

abs(): Number

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

div(i: Integer): Integer

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

floor(): Number

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

max(n: Number): Number

Returns the greatest number between self and n.

min(n: Number): Number

Returns the lowest number between self and n.

mod(i: Integer): Integer

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

round(): Integer

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

and(b: Boolean): Boolean

See the table below for the result.

implies(b: Boolean): Boolean

See the table below for the result.

or(b: Boolean): Boolean

See the table below for the result.

not(b: Boolean): Boolean

See the table below for the result.

xor(b: Boolean): Boolean

See the table below for the result.

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

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

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.

asBag(): Bag(T)

Returns a Bag containing all elements of self.

asOrderedSet(): OrderedSet(T)

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

asSequence(): Sequence(T)

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

asSet(): Set(T)

Returns a Set containing all elements of self.

collect(expr: OclExpression): Collection(T2)

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

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

count(elem: T): Integer

Returns how many times object is in the collection self.

excludes(elem: T): Boolean

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

excludesAll(c: Collection(T)): Boolean

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

excluding(elem: T): Collection(T)

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

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.

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

flatten(): Collection(T2)

Returns a collection containing all elements of self recursively flattened.

forAll(expr: OclExpression): Boolean

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

includes(elem: T): Boolean

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

includesAll(c: Collection(T)): Boolean

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

including(elem: T): Collection(T)

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

isEmpty(): Boolean

Returns true if self is empty, false otherwise.

isUnique(expr: OclExpression): Boolean

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

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.

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.

notEmpty(): Boolean

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

one(expr: OclExpression): Boolean

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

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

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

reject(expr: OclExpression): Collection(T)

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

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

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

select(expr: OclExpression): Collection(T)

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

sep(separator: String): Collection(OclAny)

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

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.

size(): Integer

Returns the number of elements contained in self.

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.

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.

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

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

append(elem: T): Sequence(T)

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

at(index: Integer): T

Returns the element of self at the index position.

drop(n: Integer): Sequence(T)

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

dropRight(n: Integer): Sequence(T)

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

endsWith(subCollection: OrderedSet(T)): Boolean

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

endsWith(subCollection: Sequence(T)): Boolean

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

first(): T

Returns the first element of the sequence.

indexOf(elem: T): Integer

Returns the position of object in sequence self.

indexOfSlice(subCollection: Sequence(T)): Integer

Returns the position of the subcollection in the sequence self.

indexOfSlice(subCollection: OrderedSet(T)): Integer

Returns the position of the subcollection in the sequence self.

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

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

last(): T

Returns the last element of self.

lastIndexOf(elem: T): Integer

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

lastIndexOfSlice(subCollection: Sequence(T)): Integer

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

lastIndexOfSlice(subCollection: OrderedSet(T)): Integer

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

prepend(elem: T): Sequence(T)

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

reverse(): Sequence(T)

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

startsWith(subCollection: Sequence(T)): Boolean

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

startsWith(subCollection: OrderedSet(T)): Boolean

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

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

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

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

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

= (c: Set(T)): Boolean

Returns true if self contains the same objects as set.

= (c: OrderedSet(T)): Boolean

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

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

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

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

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

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

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

append(elem: T): OrderedSet(T)

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

at(index: Integer): T

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

drop(n: Integer): OrderedSet(T)

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

dropRight(n: Integer): OrderedSet(T)

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

endsWith(subCollection: OrderedSet(T)): Boolean

Indicates if self ends with the given sub-collection.

endsWith(subCollection: Sequence(T)): Boolean

Indicates if self ends with the given sub-collection.

first(): T

Returns the first element of self.

indexOf(elem: T): Integer

Returns the position of elem in self.

indexOfSlice(subCollection: OrderedSet(T)): Integer

Returns the index of the sub-collection in self.

indexOfSlice(subCollection: Sequence(T)): Integer

Returns the index of the sub-collection in self.

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

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

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

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

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

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

last(): T

Returns the last element of self.

lastIndexOf(elem: T): Integer

Returns the last index of elem in self.

lastIndexOfSlice(subCollection: OrderedSet(T)): Integer

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

lastIndexOfSlice(subCollection: Sequence(T)): Integer

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

prepend(elem: T): OrderedSet(T)

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

= (c: Set(T)): Boolean

Returns true if self contains the same objects as c.

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

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

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

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

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

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

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

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

symmetricDifference(c: Set(T)): Set(T)

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

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

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

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

Returns true if self contains the same objects as set.

= (c: Bag(T)): Boolean

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

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

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

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

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

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

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

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

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