| stringServices |
| 'test'.oclAsType(String) |
| 'test'.oclIsUndefined() |
| 'test'.oclIsTypeOf(String) |
| 'test'.oclIsTypeOf(EPackage) |
| 'test'.oclIsKindOf(String) |
| 'test'.oclIsKindOf(EPackage) |
| 'test' <> 'toto' |
| 'test' <> 'test' |
| 'test' = 'toto' |
| 'test' = 'test' |
| 'test'.toString() |
| 'test'.oclAsSet() |
| 'test'.size() |
| '12'.toInteger() |
| '1.2'.toReal() |
| 'test'.toUpper() |
| 'TEST'.toLower() |
| 'test'.contains('es') |
| 'test'.contains('toto') |
| 'test'.endsWith('st') |
| 'test'.endsWith('toto') |
| 'test'.replaceAll('t', 'z') |
| 'test'.tokenize() |
| ' test '.trim() |
| 'test'.strcmp('test') |
| 'test'.strstr('es') |
| 'test'.strstr('toto') |
| 'test'.concat('test') |
| 'test'.equalsIgnoreCase('tEsT') |
| 'test'.equalsIgnoreCase('toto') |
| 'test'.first(2) |
| 'test'.isAlpha() |
| 'test1'.isAlpha() |
| 'test'.isAlphanum() |
| 'test1'.isAlphanum() |
| '111'.isAlphanum() |
| 'test'.last(2) |
| 'test'.lastIndex('a') |
| 'test'.lastIndex('t') |
| 'test'.matches('test') |
| 'test'.prefix('pre') |
| 'test'.replace('te', 'ta') |
| 'test'.startsWith('te') |
| 'test'.startsWith('toto') |
| 'test'.substitute('te', 'ta') |
| 'test'.substituteAll('t', 'z') |
| 'test'.substring(2) |
| 'test'.substring(2,3) |
| 'test'.toUpperCase() |
| 'test'.toUpperFirst() |
| 'TEST'.toLowerCase() |
| 'TEST'.toLowerFirst() |
| 'test'.tokenize() |
| 'test'.at(2) |
| 'test'.characters() |
| 'a' + 'b' |
| 'a' + 'b' + 'c' |
| 'a' + 'test' |
| 'a' + 'test' + 'c' |
| 'a' + p.name |
| 'a' + p.name + 'c' |
| 'a' + p.name + 'c' + 'test' |
| acceleoServices |
| '[' |
| let var : OclAny = self][var.oclAsType(EPackage).name/][/le |
| invoke('misc.MyService','myService(java.lang.Object, java.lang.String)',Sequence{p,'test'}) |
| booleanServices |
| true.oclAsType(Boolean) |
| true.oclIsUndefined() |
| true.oclIsTypeOf(Boolean) |
| true.oclIsTypeOf(EPackage) |
| true.oclIsKindOf(Boolean) |
| true.oclIsKindOf(EPackage) |
| true = false |
| true = true |
| false = true |
| false = false |
| true <> false |
| true <> true |
| false <> true |
| false <> false |
| true.toString() |
| true.oclAsSet() |
| not true |
| not false |
| true and false |
| true and true |
| false and true |
| false and false |
| true or false |
| true or true |
| false or true |
| false or false |
| true xor false |
| true xor true |
| false xor true |
| false xor false |
| true implies false |
| true implies true |
| false implies true |
| false implies false |
| false._and(true) |
| true._and(false) |
| false._or(true) |
| true._or(false) |
| false._implies(true) |
| true._implies(false) |
| true._not() |
| false._not() |
| false._xor(true) |
| true._xor(false) |
| true.toString() |
| false.toString() |
| (true and false) or true implies (false xor true) |
| numericServices |
| var2.oclAsType(Integer) |
| var2.oclIsUndefined() |
| var2.oclIsTypeOf(Integer) |
| var2.oclIsTypeOf(EPackage) |
| var2.oclIsKindOf(Integer) |
| var2.oclIsKindOf(EPackage) |
| var1 = var2 |
| var1 = var1 |
| var1 <> var2 |
| var1 <> var1 |
| var2.toString() |
| var1 + var2 |
| var1 - var2 |
| var2 - var1 |
| var1 * var2 |
| var1 / var2 |
| var2 / var1 |
| var1 < var2 |
| var2 < var1 |
| var1 > var2 |
| var2 > var1 |
| var1 <= var1 |
| var1 <= var2 |
| var2 <= var1 |
| var1 >= var1 |
| var1 >= var2 |
| var2 >= var1 |
| var1.abs() |
| var2.abs() |
| var1.div(var2) |
| var2.div(var1) |
| var1.floor() |
| var2.floor() |
| var1.max(var2) |
| var2.max(var1) |
| var1.min(var2) |
| var2.min(var1) |
| var1.mod(var2) |
| var2.mod(var1) |
| var1.round() |
| var2.round() |
| var1.toString() |
| var2.toString() |
| 1 + (2 - 1)*3 >= 4 + 2 |
| var1.oclAsSet() |
| var1.oclAsType(Real) |
| var1.oclIsUndefined() |
| var1.oclIsTypeOf(Real) |
| var1.oclIsTypeOf(EPackage) |
| var1.oclIsKindOf(Real) |
| var1.oclIsKindOf(EPackage) |
| var1 <> var1 |
| var1 <> var2 |
| var1 = var1 |
| var1 = var2 |
| var1.toString() |
| var1 + var2 |
| var1 - var2 |
| var2 - var1 |
| var1 * var2 |
| var2 / var1 |
| var1 / var2 |
| var1 < var2 |
| var2 < var1 |
| var1 > var2 |
| var2 > var1 |
| var1 <= var1 |
| var1 <= var2 |
| var2 <= var1 |
| var1 >= var1 |
| var1 >= var2 |
| var2 >= var1 |
| var1.abs() |
| var2.abs() |
| var1.floor() |
| var2.floor() |
| var1.max(var2) |
| var2.max(var1) |
| var1.min(var2) |
| var2.min(var1) |
| var1.round() |
| var2.round() |
| var1.toString() |
| var2.toString() |
| 3.0 / 1.5 |
| 0.5 * 2.0 |
| 1.5 + (2.2 - 1.0)*3.2 >= 4.6 / 2.1 |
| var1.oclAsSet() |
| emfServices |
| 'test'.oclAsType(String) |
| c.oclIsUndefined() |
| c.oclIsTypeOf(EClass) |
| c.oclIsTypeOf(EPackage) |
| c.oclIsKindOf(EClass) |
| c.oclIsKindOf(EPackage) |
| c.oclAsType(EClass).name |
| c.toString().startsWith('org.eclipse.emf.ecore.impl.EClassImpl@') |
| c.siblings(EClass)->collect(name) |
| c.precedingSiblings(EClass)->collect(name) |
| c.precedingSiblings()->collect(name) |
| c.followingSiblings(EClass)->collect(name) |
| c.followingSiblings()->collect(name) |
| c.eResource().toString().startsWith('org.eclipse.emf.ecore.xmi.impl.XMIResourceImpl@') |
| c.eGet('name') |
| c.eGet(c.eClass().getEStructuralFeature('name')) |
| c.eGet(c.eClass().getEStructuralFeature('name'), true) |
| c.eContainmentFeature().name |
| c.eContainingFeature().name |
| c.eContainer().oclIsTypeOf(EPackage) |
| c.eContainer(EPackage).name |
| c.eClass().name |
| c.ancestors(EPackage)->collect(name) |
| c.ancestors()->collect(name) |
| c.eAllContents(EAttribute)->collect(name) |
| c <> c.eContainer() |
| c <> c |
| c = c.eContainer() |
| c = c |
| c.eAllContents()->collect(name) |
| c.siblings()->collect(name) |
| c.eContents()->collect(name) |
| c.eCrossReferences()->collect(name) |
| c.oclAsSet().name |
| sequencesServices |
| strings.toString() |
| reals.toString() |
| integers.toString() |
| booleans.toString() |
| collections.toString() |
| strings.oclIsTypeOf(String) |
| reals.oclIsTypeOf(Real) |
| integers.oclIsTypeOf(Integer) |
| booleans.oclIsTypeOf(Boolean) |
| eClasses.oclIsTypeOf(EClass) |
| strings.oclIsKindOf(String) |
| reals.oclIsKindOf(Real) |
| integers.oclIsKindOf(Integer) |
| booleans.oclIsKindOf(Boolean) |
| eClasses.oclIsKindOf(EObject) |
| strings -> last() |
| reals -> last() |
| integers -> last() |
| booleans -> last() |
| eClasses -> last().name |
| collections -> last() |
| strings -> collect(t | t.toString()) |
| integers -> collect(t | t.toString()) |
| booleans -> collect(t | t.toString()) |
| reals -> collect(t | t.toString()) |
| eClasses -> collect(t | t.name) |
| collections -> collect(t | t.toString()) |
| strings -> size() |
| integers -> size() |
| booleans -> size() |
| reals -> size() |
| eClasses -> size() |
| collections -> size() |
| strings -> notEmpty() |
| integers -> notEmpty() |
| booleans -> notEmpty() |
| reals -> notEmpty() |
| eClasses -> notEmpty() |
| collections -> notEmpty() |
| strings -> isEmpty() |
| integers -> isEmpty() |
| booleans -> isEmpty() |
| reals -> isEmpty() |
| eClasses -> isEmpty() |
| collections -> isEmpty() |
| strings -> reverse() |
| integers -> reverse() |
| booleans -> reverse() |
| reals -> reverse() |
| eClasses -> reverse() -> collect(name) |
| collections -> reverse() |
| strings -> first() |
| integers -> first() |
| booleans -> first() |
| reals -> first() |
| eClasses -> first().name |
| collections -> first() |
| strings -> asSequence() |
| integers -> asSequence() |
| booleans -> asSequence() |
| reals -> asSequence() |
| eClasses -> asSequence() -> collect(name) |
| collections -> asSequence() |
| strings -> asOrderedSet() |
| integers -> asOrderedSet() |
| booleans -> asOrderedSet() |
| reals -> asOrderedSet() |
| eClasses -> asOrderedSet() -> collect(name) |
| collections -> asOrderedSet() |
| strings -> sep(',') |
| integers -> sep(',') |
| booleans -> sep(',') |
| reals -> sep(',') |
| collections -> sep(',') |
| strings -> sep('{', ',', '}') |
| integers -> sep('{', ',', '}') |
| booleans -> sep('{', ',', '}') |
| reals -> sep('{', ',', '}') |
| collections -> sep('{', ',', '}') |
| strings -> includesAll(Sequence{'a','b'}) |
| strings -> includesAll(Sequence{'a','b','d'}) |
| integers -> includesAll(Sequence{1,2}) |
| integers -> includesAll(Sequence{1,2,4}) |
| booleans -> includesAll(Sequence{true,false}) |
| Sequence{false} -> includesAll(Sequence{true,false}) |
| reals -> includesAll(Sequence{1.2,2.1}) |
| reals -> includesAll(Sequence{1.2,2.3}) |
| collections -> includesAll(Sequence{Sequence{'a','b','c'}}) |
| collections -> includesAll(Sequence{Sequence{'a','b','d'}}) |
| collections -> includesAll(Sequence{'a','b','d'}) |
| eClasses -> includesAll(p.eClassifiers) |
| Sequence{p.eClassifiers->first()}-> includesAll(p.eClassifiers) |
| strings -> includes('z') |
| strings -> includes('a') |
| integers -> includes(6) |
| integers -> includes(2) |
| Sequence{true,true} -> includes(false) |
| booleans -> includes(false) |
| reals -> includes(5.2) |
| reals -> includes(1.2) |
| eClasses -> includes(p.eClassifiers->first()) |
| Sequence{p.eClassifiers->first()} -> includes(p.eClassifiers->last()) |
| collections -> includes(Sequence{'a','b','c'}) |
| collections -> includes(Sequence{'z','b','c'}) |
| strings -> excludesAll(Sequence{'a','b'}) |
| strings -> excludesAll(Sequence{'a','b','d'}) |
| integers -> excludesAll(Sequence{1,2}) |
| integers -> excludesAll(Sequence{1,2,4}) |
| booleans -> excludesAll(Sequence{true,false}) |
| Sequence{false} -> excludesAll(Sequence{true,false}) |
| reals -> excludesAll(Sequence{1.2,2.1}) |
| reals -> excludesAll(Sequence{1.2,2.3}) |
| collections -> excludesAll(Sequence{Sequence{'a','b','c'}}) |
| collections -> excludesAll(Sequence{Sequence{'a','b','d'}}) |
| collections -> excludesAll(Sequence{'a','b','d'}) |
| eClasses -> excludesAll(p.eClassifiers) |
| Sequence{p.eClassifiers->first()}-> excludesAll(p.eClassifiers) |
| strings -> excludes('z') |
| strings -> excludes('a') |
| integers -> excludes(6) |
| integers -> excludes(2) |
| Sequence{true} -> excludes(false) |
| booleans -> excludes(false) |
| reals -> excludes(5.2) |
| reals -> excludes(1.2) |
| eClasses -> excludes(p.eClassifiers->first()) |
| Sequence{p.eClassifiers->first()} -> excludes(p.eClassifiers->last()) |
| collections -> excludes(Sequence{'a','b','c'}) |
| collections -> excludes(Sequence{'z','b','c'}) |
| strings -> union(Sequence{'a','b'}) |
| strings -> union(Sequence{'a','b','d'}) |
| integers -> union(Sequence{1,2}) |
| integers -> union(Sequence{1,2,4}) |
| booleans -> union(Sequence{true,false}) |
| Sequence{false} -> union(Sequence{true,false}) |
| reals -> union(Sequence{1.2,2.1}) |
| reals -> union(Sequence{1.2,2.3}) |
| collections -> union(Sequence{Sequence{'a','b','c'}}) |
| collections -> union(Sequence{Sequence{'a','b','d'}}) |
| collections -> union(Sequence{'a','b','d'}) |
| eClasses -> union(p.eClassifiers->asSequence()) -> collect(name) |
| strings -> count('z') |
| strings -> count('a') |
| integers -> count(6) |
| integers -> count(2) |
| Sequence{true,true} -> count(false) |
| booleans -> count(false) |
| reals -> count(5.2) |
| reals -> count(1.2) |
| eClasses -> count(p.eClassifiers->first()) |
| Sequence{p.eClassifiers->first()} -> count(p.eClassifiers->last()) |
| collections -> count(Sequence{'a','b','c'}) |
| collections -> count(Sequence{'z','b','c'}) |
| strings -> append('z') |
| strings -> append('a') |
| integers -> append(6) |
| integers -> append(2) |
| Sequence{true,true} -> append(false) |
| booleans -> append(false) |
| reals -> append(5.2) |
| reals -> append(1.2) |
| eClasses -> append(p.eClassifiers->first()) -> collect(name) |
| Sequence{p.eClassifiers->first()} -> append(p.eClassifiers->last()) -> collect(name) |
| collections -> append(Sequence{'a','b','c'}) |
| collections -> append(Sequence{'z','b','c'}) |
| strings -> prepend('z') |
| strings -> prepend('a') |
| integers -> prepend(6) |
| integers -> prepend(2) |
| Sequence{true,true} -> prepend(false) |
| booleans -> prepend(false) |
| reals -> prepend(5.2) |
| reals -> prepend(1.2) |
| eClasses -> prepend(p.eClassifiers->first()) -> collect(name) |
| Sequence{p.eClassifiers->first()} -> prepend(p.eClassifiers->last()) -> collect(name) |
| collections -> prepend(Sequence{'a','b','c'}) |
| collections -> prepend(Sequence{'z','b','c'}) |
| strings -> insertAt(1,'z') |
| strings -> insertAt(1,'a') |
| integers -> insertAt(1,6) |
| integers -> insertAt(1,2) |
| Sequence{true,true} -> insertAt(1,false) |
| booleans -> insertAt(1,false) |
| reals -> insertAt(1,5.2) |
| reals -> insertAt(1,1.2) |
| eClasses -> insertAt(1,p.eClassifiers->first()) -> collect(name) |
| Sequence{p.eClassifiers->first()} -> insertAt(1,p.eClassifiers->last()) -> collect(name) |
| collections -> insertAt(1,Sequence{'a','b','c'}) |
| collections -> insertAt(1,Sequence{'z','b','c'}) |
| strings -> indexOf('a') |
| integers -> indexOf(2) |
| booleans -> indexOf(false) |
| reals -> indexOf(1.2) |
| eClasses -> indexOf(p.eClassifiers->first()) |
| collections -> indexOf(Sequence{'a','b','c'}) |
| strings -> including('z') |
| strings -> including('a') |
| integers -> including(6) |
| integers -> including(2) |
| Sequence{true,true} -> including(false) |
| booleans -> including(false) |
| reals -> including(5.2) |
| reals -> including(1.2) |
| eClasses -> including(p.eClassifiers->first()) -> collect(name) |
| Sequence{p.eClassifiers->first()} -> including(p.eClassifiers->last()) -> collect(name) |
| collections -> including(Sequence{'a','b','c'}) |
| collections -> including(Sequence{'z','b','c'}) |
| strings -> excluding('z') |
| strings -> excluding('a') |
| integers -> excluding(6) |
| integers -> excluding(2) |
| Sequence{true,true} -> excluding(false) |
| booleans -> excluding(false) |
| reals -> excluding(5.2) |
| reals -> excluding(1.2) |
| eClasses -> excluding(p.eClassifiers->first()) -> collect(name) |
| Sequence{p.eClassifiers->first()} -> excluding(p.eClassifiers->last()) -> collect(name) |
| collections -> excluding(Sequence{'a','b','c'}) |
| collections -> excluding(Sequence{'z','b','c'}) |
| strings -> at(1) |
| integers -> at(1) |
| booleans -> at(1) |
| reals -> at(1) |
| eClasses -> at(1).name |
| collections -> at(1) |
| Sequence{'aaa','bb','ccccc'} -> sortedBy(t | t.size()) |
| integers -> sortedBy(t | t) |
| reals -> sortedBy(t | t) |
| booleans -> sortedBy(t | t.toString()) |
| eClasses -> sortedBy(t | t.name) -> collect(name) |
| Sequence{Sequence{'a','b','c'}, Sequence{'a','b'}} -> sortedBy(t | t->size()) |
| integers -> sum() |
| reals -> sum() |
| strings -> exists(t | t = 'b') |
| strings -> exists(t | t = 'z') |
| integers -> exists(t | t = 1) |
| integers -> exists(t | t = 4) |
| reals -> exists(t | t = 1.2) |
| reals -> exists(t | t = 4.2) |
| booleans -> exists(t | t = true) |
| eClasses -> exists(t | t.name = 'ClasseB') |
| collections -> exists(t | t.size() = 3) |
| collections -> exists(t | t.size() = 1) |
| strings -> select(t | t = 'b') |
| strings -> select(t | t = 'z') |
| integers -> select(t | t = 1) |
| integers -> select(t | t = 4) |
| reals -> select(t | t = 1.2) |
| reals -> select(t | t = 4.2) |
| booleans -> select(t | t = true) |
| eClasses -> select(t | t.name = 'ClasseB') -> collect(name) |
| collections -> select(t | t.size() = 3) |
| collections -> select(t | t.size() = 1) |
| strings -> reject(t | t = 'b') |
| strings -> reject(t | t = 'z') |
| integers -> reject(t | t = 1) |
| integers -> reject(t | t = 4) |
| reals -> reject(t | t = 1.2) |
| reals -> reject(t | t = 4.2) |
| booleans -> reject(t | t = true) |
| eClasses -> reject(t | t.name = 'ClasseB') -> collect(name) |
| collections -> reject(t | t.size() = 3) |
| collections -> reject(t | t.size() = 1) |
| strings -> forAll(t | t = 'b') |
| strings -> forAll(t | t = 'z') |
| integers -> forAll(t | t = 1) |
| integers -> forAll(t | t = 4) |
| reals -> forAll(t | t = 1.2) |
| reals -> forAll(t | t = 4.2) |
| booleans -> forAll(t | t = true) |
| eClasses -> forAll(t | t.name = 'ClasseB') |
| collections -> forAll(t | t.size() = 3) |
| collections -> forAll(t | t.size() = 1) |
| strings -> any(t | t = 'b') |
| strings -> any(t | t = 'z') |
| integers -> any(t | t = 1) |
| integers -> any(t | t = 4) |
| reals -> any(t | t = 1.2) |
| reals -> any(t | t = 4.2) |
| booleans -> any(t | t = true) |
| eClasses -> any(t | t.name = 'ClasseB') -> collect(name) |
| collections -> any(t | t.size() = 3) |
| collections -> any(t | t.size() = 1) |
| strings -> one(t | t = 'b') |
| strings -> one(t | t = 'z') |
| integers -> one(t | t = 1) |
| integers -> one(t | t = 4) |
| reals -> one(t | t = 1.2) |
| reals -> one(t | t = 4.2) |
| booleans -> one(t | t = true) |
| eClasses -> one(t | t.name = 'ClasseB') |
| collections -> one(t | t.size() = 3) |
| collections -> one(t | t.size() = 1) |
| strings -> isUnique(toString()) |
| integers -> isUnique(toString()) |
| reals -> isUnique(toString()) |
| booleans -> isUnique(toString()) |
| eClasses -> isUnique(toString()) |
| collections -> isUnique(toString()) |
| strings -> oclIsUndefined() |
| integers -> oclIsUndefined() |
| booleans -> oclIsUndefined() |
| reals -> oclIsUndefined() |
| eClasses -> oclIsUndefined() |
| collections -> oclIsUndefined() |
| strings.oclIsUndefined() |
| integers.oclIsUndefined() |
| booleans.oclIsUndefined() |
| reals.oclIsUndefined() |
| eClasses.oclIsUndefined() |
| collections.oclIsUndefined() |
| Sequence{p,'test',true,1,2.2} -> filter(EPackage) -> first() = p |
| Sequence{p,'test',true,1,2.2} -> filter(EClass) -> size() |
| strings -> subSequence(1,2) |
| integers -> subSequence(1,2) |
| reals -> subSequence(1,2) |
| booleans -> subSequence(1,2) |
| eClasses -> subSequence(1,2) -> collect(name) |
| collections -> subSequence(1,2) |
| orderedSetsServices |
| strings.toString() |
| reals.toString() |
| integers.toString() |
| booleans.toString() |
| collections.toString() |
| strings.oclIsTypeOf(String) |
| reals.oclIsTypeOf(Real) |
| integers.oclIsTypeOf(Integer) |
| booleans.oclIsTypeOf(Boolean) |
| eClasses.oclIsTypeOf(EClass) |
| strings.oclIsKindOf(String) |
| reals.oclIsKindOf(Real) |
| integers.oclIsKindOf(Integer) |
| booleans.oclIsKindOf(Boolean) |
| eClasses.oclIsKindOf(EObject) |
| strings -> last() |
| reals -> last() |
| integers -> last() |
| booleans -> last() |
| eClasses -> last().name |
| collections -> last() |
| strings -> collect(t | t.toString()) |
| integers -> collect(t | t.toString()) |
| booleans -> collect(t | t.toString()) |
| reals -> collect(t | t.toString()) |
| eClasses -> collect(t | t.name) |
| collections -> collect(t | t.toString()) |
| strings -> size() |
| integers -> size() |
| booleans -> size() |
| reals -> size() |
| eClasses -> size() |
| collections -> size() |
| strings -> notEmpty() |
| integers -> notEmpty() |
| booleans -> notEmpty() |
| reals -> notEmpty() |
| eClasses -> notEmpty() |
| collections -> notEmpty() |
| strings -> isEmpty() |
| integers -> isEmpty() |
| booleans -> isEmpty() |
| reals -> isEmpty() |
| eClasses -> isEmpty() |
| collections -> isEmpty() |
| strings -> reverse() |
| integers -> reverse() |
| booleans -> reverse() |
| reals -> reverse() |
| eClasses -> reverse() -> collect(name) |
| collections -> reverse() |
| strings -> first() |
| integers -> first() |
| booleans -> first() |
| reals -> first() |
| eClasses -> first().name |
| collections -> first() |
| strings -> asSequence() |
| integers -> asSequence() |
| booleans -> asSequence() |
| reals -> asSequence() |
| eClasses -> asSequence() -> collect(name) |
| collections -> asSequence() |
| strings -> asOrderedSet() |
| integers -> asOrderedSet() |
| booleans -> asOrderedSet() |
| reals -> asOrderedSet() |
| eClasses -> asOrderedSet() -> collect(name) |
| collections -> asOrderedSet() |
| strings -> sep(',') |
| integers -> sep(',') |
| booleans -> sep(',') |
| reals -> sep(',') |
| collections -> sep(',') |
| strings -> sep('{', ',', '}') |
| integers -> sep('{', ',', '}') |
| booleans -> sep('{', ',', '}') |
| reals -> sep('{', ',', '}') |
| collections -> sep('{', ',', '}') |
| strings -> includesAll(OrderedSet{'a','b'}) |
| strings -> includesAll(OrderedSet{'a','b','d'}) |
| integers -> includesAll(OrderedSet{1,2}) |
| integers -> includesAll(OrderedSet{1,2,4}) |
| booleans -> includesAll(OrderedSet{true,false}) |
| OrderedSet{false} -> includesAll(OrderedSet{true,false}) |
| reals -> includesAll(OrderedSet{1.2,2.1}) |
| reals -> includesAll(OrderedSet{1.2,2.3}) |
| collections -> includesAll(OrderedSet{OrderedSet{'a','b','c'}}) |
| collections -> includesAll(OrderedSet{OrderedSet{'a','b','d'}}) |
| collections -> includesAll(OrderedSet{'a','b','d'}) |
| eClasses -> includesAll(p.eClassifiers) |
| OrderedSet{p.eClassifiers->first()}-> includesAll(p.eClassifiers) |
| strings -> includes('z') |
| strings -> includes('a') |
| integers -> includes(6) |
| integers -> includes(2) |
| OrderedSet{true,true} -> includes(false) |
| booleans -> includes(false) |
| reals -> includes(5.2) |
| reals -> includes(1.2) |
| eClasses -> includes(p.eClassifiers->first()) |
| OrderedSet{p.eClassifiers->first()} -> includes(p.eClassifiers->last()) |
| collections -> includes(OrderedSet{'a','b','c'}) |
| collections -> includes(OrderedSet{'z','b','c'}) |
| strings -> excludesAll(OrderedSet{'a','b'}) |
| strings -> excludesAll(OrderedSet{'a','b','d'}) |
| integers -> excludesAll(OrderedSet{1,2}) |
| integers -> excludesAll(OrderedSet{1,2,4}) |
| booleans -> excludesAll(OrderedSet{true,false}) |
| OrderedSet{false} -> excludesAll(OrderedSet{true,false}) |
| reals -> excludesAll(OrderedSet{1.2,2.1}) |
| reals -> excludesAll(OrderedSet{1.2,2.3}) |
| collections -> excludesAll(OrderedSet{OrderedSet{'a','b','c'}}) |
| collections -> excludesAll(OrderedSet{OrderedSet{'a','b','d'}}) |
| collections -> excludesAll(OrderedSet{'a','b','d'}) |
| eClasses -> excludesAll(p.eClassifiers) |
| OrderedSet{p.eClassifiers->first()}-> excludesAll(p.eClassifiers) |
| strings -> excludes('z') |
| strings -> excludes('a') |
| integers -> excludes(6) |
| integers -> excludes(2) |
| OrderedSet{true} -> excludes(false) |
| booleans -> excludes(false) |
| reals -> excludes(5.2) |
| reals -> excludes(1.2) |
| eClasses -> excludes(p.eClassifiers->first()) |
| OrderedSet{p.eClassifiers->first()} -> excludes(p.eClassifiers->last()) |
| collections -> excludes(OrderedSet{'a','b','c'}) |
| collections -> excludes(OrderedSet{'z','b','c'}) |
| strings -> union(OrderedSet{'a','b'}) |
| strings -> union(OrderedSet{'a','b','d'}) |
| integers -> union(OrderedSet{1,2}) |
| integers -> union(OrderedSet{1,2,4}) |
| booleans -> union(OrderedSet{true,false}) -> sortedBy(toString()) |
| OrderedSet{false} -> union(OrderedSet{true,false}) -> sortedBy(toString()) |
| reals -> union(OrderedSet{1.2,2.1}) -> sortedBy(toString()) |
| reals -> union(OrderedSet{1.2,2.3}) -> sortedBy(toString()) |
| collections -> union(OrderedSet{OrderedSet{'a','b','c'}}) -> sortedBy(toString()) |
| collections -> union(OrderedSet{OrderedSet{'a','b','d'}}) -> sortedBy(toString()) |
| eClasses -> union(p.eClassifiers->asOrderedSet()) -> size() |
| strings -> count('z') |
| strings -> count('a') |
| integers -> count(6) |
| integers -> count(2) |
| OrderedSet{true,true} -> count(false) |
| booleans -> count(false) |
| reals -> count(5.2) |
| reals -> count(1.2) |
| eClasses -> count(p.eClassifiers->first()) |
| OrderedSet{p.eClassifiers->first()} -> count(p.eClassifiers->last()) |
| collections -> count(OrderedSet{'a','b','c'}) |
| collections -> count(OrderedSet{'z','b','c'}) |
| strings -> append('z') |
| strings -> append('a') |
| Sequence{'a','b','c'} -> append('b') |
| integers -> append(6) |
| integers -> append(2) |
| OrderedSet{true,true} -> append(false) |
| booleans -> append(false) |
| reals -> append(5.2) |
| reals -> append(1.2) |
| eClasses -> append(p.eClassifiers->first()) -> collect(name) |
| OrderedSet{p.eClassifiers->first()} -> append(p.eClassifiers->last()) -> collect(name) |
| collections -> append(OrderedSet{'a','b','c'}) |
| collections -> append(OrderedSet{'z','b','c'}) |
| strings -> prepend('z') |
| strings -> prepend('a') |
| integers -> prepend(6) |
| integers -> prepend(2) |
| OrderedSet{true,true} -> prepend(false) |
| booleans -> prepend(false) |
| reals -> prepend(5.2) |
| reals -> prepend(1.2) |
| eClasses -> prepend(p.eClassifiers->first()) -> collect(name) |
| OrderedSet{p.eClassifiers->first()} -> prepend(p.eClassifiers->last()) -> collect(name) |
| collections -> prepend(OrderedSet{'a','b','c'}) |
| collections -> prepend(OrderedSet{'z','b','c'}) |
| strings -> insertAt(1,'z') |
| strings -> insertAt(1,'a') |
| integers -> insertAt(1,6) |
| integers -> insertAt(1,2) |
| OrderedSet{true,true} -> insertAt(1,false) |
| booleans -> insertAt(1,false) |
| reals -> insertAt(1,5.2) |
| reals -> insertAt(1,1.2) |
| eClasses -> insertAt(1,p.eClassifiers->first()) -> collect(name) |
| OrderedSet{p.eClassifiers->first()} -> insertAt(1,p.eClassifiers->last()) -> collect(name) |
| collections -> insertAt(1,OrderedSet{'a','b','c'}) |
| collections -> insertAt(1,OrderedSet{'z','b','c'}) |
| strings -> indexOf('a') |
| integers -> indexOf(2) |
| booleans -> indexOf(false) |
| reals -> indexOf(1.2) |
| eClasses -> indexOf(p.eClassifiers->first()) |
| collections -> indexOf(OrderedSet{'a','b','c'}) |
| strings -> including('z') |
| strings -> including('a') |
| integers -> including(6) |
| integers -> including(2) |
| OrderedSet{true,true} -> including(false) |
| booleans -> including(false) |
| reals -> including(5.2) |
| reals -> including(1.2) |
| eClasses -> including(p.eClassifiers->first()) -> size() |
| OrderedSet{p.eClassifiers->first()} -> including(p.eClassifiers->last()) -> collect(name) -> sortedBy(toString()) |
| collections -> including(OrderedSet{'a','b','c'}) |
| collections -> including(OrderedSet{'z','b','c'}) |
| strings -> excluding('z') |
| strings -> excluding('a') |
| integers -> excluding(6) |
| integers -> excluding(2) |
| OrderedSet{true,true} -> excluding(false) |
| booleans -> excluding(false) |
| reals -> excluding(5.2) |
| eClasses -> excluding(p.eClassifiers->first()) -> collect(name) -> sortedBy(toString()) |
| OrderedSet{p.eClassifiers->first()} -> excluding(p.eClassifiers->last()) -> collect(name) |
| collections -> excluding(OrderedSet{'a','b','c'}) |
| collections -> excluding(OrderedSet{'z','b','c'}) |
| strings -> at(1) |
| integers -> at(1) |
| booleans -> at(1) |
| reals -> at(1) |
| eClasses -> at(1).name |
| collections -> at(1) |
| OrderedSet{'aaa','bb','ccccc'} -> sortedBy(t | t.size()) |
| integers -> sortedBy(t | t) |
| reals -> sortedBy(t | t) |
| booleans -> sortedBy(t | t.toString()) |
| eClasses -> sortedBy(t | t.name) -> collect(name) |
| OrderedSet{OrderedSet{'a','b','c'}, OrderedSet{'a','b'}} -> sortedBy(t | t->size()) |
| integers -> sum() |
| reals -> sum() |
| strings -> exists(t | t = 'b') |
| strings -> exists(t | t = 'z') |
| integers -> exists(t | t = 1) |
| integers -> exists(t | t = 4) |
| reals -> exists(t | t = 1.2) |
| reals -> exists(t | t = 4.2) |
| booleans -> exists(t | t = true) |
| eClasses -> exists(t | t.name = 'ClasseB') |
| collections -> exists(t | t.size() = 3) |
| collections -> exists(t | t.size() = 1) |
| strings -> select(t | t = 'b') |
| strings -> select(t | t = 'z') |
| integers -> select(t | t = 1) |
| integers -> select(t | t = 4) |
| reals -> select(t | t = 1.2) |
| reals -> select(t | t = 4.2) |
| booleans -> select(t | t = true) |
| eClasses -> select(t | t.name = 'ClasseB') -> collect(name) |
| collections -> select(t | t.size() = 3) |
| collections -> select(t | t.size() = 1) |
| strings -> reject(t | t = 'b') |
| strings -> reject(t | t = 'z') |
| integers -> reject(t | t = 1) |
| integers -> reject(t | t = 4) |
| reals -> reject(t | t = 1.2) |
| reals -> reject(t | t = 4.2) |
| booleans -> reject(t | t = true) |
| eClasses -> reject(t | t.name = 'ClasseB') -> collect(name) |
| collections -> reject(t | t.size() = 3) |
| collections -> reject(t | t.size() = 1) |
| strings -> forAll(t | t = 'b') |
| strings -> forAll(t | t = 'z') |
| integers -> forAll(t | t = 1) |
| integers -> forAll(t | t = 4) |
| reals -> forAll(t | t = 1.2) |
| reals -> forAll(t | t = 4.2) |
| booleans -> forAll(t | t = true) |
| eClasses -> forAll(t | t.name = 'ClasseB') |
| collections -> forAll(t | t.size() = 3) |
| collections -> forAll(t | t.size() = 1) |
| strings -> any(t | t = 'b') |
| strings -> any(t | t = 'z') |
| integers -> any(t | t = 1) |
| integers -> any(t | t = 4) |
| reals -> any(t | t = 1.2) |
| reals -> any(t | t = 4.2) |
| booleans -> any(t | t = true) |
| eClasses -> any(t | t.name = 'ClasseB') -> collect(name) |
| collections -> any(t | t.size() = 3) |
| collections -> any(t | t.size() = 1) |
| strings -> one(t | t = 'b') |
| strings -> one(t | t = 'z') |
| integers -> one(t | t = 1) |
| integers -> one(t | t = 4) |
| reals -> one(t | t = 1.2) |
| reals -> one(t | t = 4.2) |
| booleans -> one(t | t = true) |
| eClasses -> one(t | t.name = 'ClasseB') |
| collections -> one(t | t.size() = 3) |
| collections -> one(t | t.size() = 1) |
| strings -> isUnique(toString()) |
| integers -> isUnique(toString()) |
| reals -> isUnique(toString()) |
| booleans -> isUnique(toString()) |
| eClasses -> isUnique(toString()) |
| collections -> isUnique(toString()) |
| strings -> oclIsUndefined() |
| integers -> oclIsUndefined() |
| booleans -> oclIsUndefined() |
| reals -> oclIsUndefined() |
| eClasses -> oclIsUndefined() |
| collections -> oclIsUndefined() |
| strings.oclIsUndefined() |
| integers.oclIsUndefined() |
| booleans.oclIsUndefined() |
| reals.oclIsUndefined() |
| eClasses.oclIsUndefined() |
| collections.oclIsUndefined() |
| OrderedSet{p,'test',true,1,2.2} -> filter(EPackage) -> first() = p |
| OrderedSet{p,'test',true,1,2.2} -> filter(EClass) -> size() |
| collections.oclAsSet() |
