library ocl : ocl = 'http://www.eclipse.org/ocl/3.1.0/OCL.oclstdlib' | |
{ | |
precedence left:NAVIGATION left:UNARY left:MULTIPLICATIVE left:ADDITIVE left:RELATIONAL left:EQUALITY left:AND left:OR left:XOR left:IMPLIES; | |
type Bag<T> : BagType conformsTo NonOrderedCollection<T>,NonUniqueCollection<T> { | |
/** | |
The sub-bag of the source bag for which body is false. | |
**/ | |
iteration reject(i : T | body : Lambda T() : Boolean) : Bag<T> => 'org.eclipse.ocl.examples.library.iterator.RejectIteration'; | |
/** | |
The sub-bag of the source bag for which body is true. | |
**/ | |
iteration select(i : T | body : Lambda T() : Boolean) : Bag<T> => 'org.eclipse.ocl.examples.library.iterator.SelectIteration'; | |
/** | |
True if self and bag contain the same elements, the same number of times. | |
**/ | |
operation "="(object2 : OclSelf) : Boolean precedence=EQUALITY => 'org.eclipse.ocl.examples.library.oclany.OclAnyEqualOperation'; | |
operation "<>"(object2 : OclSelf) : Boolean precedence=EQUALITY => 'org.eclipse.ocl.examples.library.oclany.OclAnyNotEqualOperation'; | |
/** | |
The bag containing all elements of self apart from all occurrences of object. | |
**/ | |
operation excluding(object : OclAny) : Bag<T> => 'org.eclipse.ocl.examples.library.collection.CollectionExcludingOperation'; | |
/** | |
Redefines the Collection operation. If the element type is not a collection type, this results in the same bag as self. | |
If the element type is a collection type, the result is the bag containing all the elements of all the recursively flattened elements of self. | |
**/ | |
operation flatten<T2>() : Bag<T2> => 'org.eclipse.ocl.examples.library.collection.CollectionFlattenOperation'; | |
/** | |
The bag containing all elements of self plus object. | |
**/ | |
operation including(object : T) : Bag<T> => 'org.eclipse.ocl.examples.library.collection.CollectionIncludingOperation'; | |
} | |
/** | |
The standard type Boolean represents the common true/false values. | |
Boolean is itself an instance of the metatype PrimitiveType (from UML). | |
**/ | |
type Boolean : PrimitiveType conformsTo OclAny { | |
/** | |
Returns true if the logical value of self is the same as the numeric value of object2, false otherwise. | |
*/ | |
operation "="(object2 : OclSelf) : Boolean precedence=EQUALITY => 'org.eclipse.ocl.examples.library.oclany.OclAnyEqualOperation'; | |
/** | |
Returns true if the logical value of self is the not same as the numeric value of object2, false otherwise. | |
*/ | |
operation "<>"(object2 : OclSelf) : Boolean precedence=EQUALITY => 'org.eclipse.ocl.examples.library.oclany.OclAnyNotEqualOperation'; | |
/** | |
Returns Set{false, true}. | |
*/ | |
static operation allInstances() : Set<OclSelf> => 'org.eclipse.ocl.examples.library.logical.BooleanAllInstancesOperation'; | |
/** | |
True if both b1 and b are true. | |
**/ | |
operation and(b : Boolean) : Boolean precedence=AND => 'org.eclipse.ocl.examples.library.logical.BooleanAndOperation'; | |
/** | |
True if self is false, or if self is true and b is true. | |
**/ | |
operation implies(b : Boolean) : Boolean precedence=IMPLIES => 'org.eclipse.ocl.examples.library.logical.BooleanImpliesOperation'; | |
/** | |
True if self is false. | |
**/ | |
operation not() : Boolean precedence=UNARY => 'org.eclipse.ocl.examples.library.logical.BooleanNotOperation'; | |
/** | |
True if either self or b is true. | |
**/ | |
operation or(b : Boolean) : Boolean precedence=OR => 'org.eclipse.ocl.examples.library.logical.BooleanOrOperation'; | |
/** | |
Converts self to a string value. | |
**/ | |
operation toString() : String => 'org.eclipse.ocl.examples.library.oclany.OclAnyToStringOperation'; | |
/** | |
True if either self or b is true, but not both. | |
**/ | |
operation xor(b : Boolean) : Boolean precedence=XOR => 'org.eclipse.ocl.examples.library.logical.BooleanXorOperation'; | |
} | |
type Classifier<T> : ClassifierType conformsTo OclAny { | |
/** | |
Return a set of all instances of the type and derived types of self. | |
*/ | |
static operation allInstances() : Set<OclSelf> => 'org.eclipse.ocl.examples.library.classifier.ClassifierAllInstancesOperation'; | |
/** | |
Returns the object for which self is a composed content or null if there is no such object. | |
*/ | |
operation oclContainer<U>() : Classifier<U> => 'org.eclipse.ocl.examples.library.classifier.ClassifierOclContainerOperation'; | |
/** | |
Returns the composed contents of self. | |
*/ | |
operation oclContents<U>() : Set<Classifier<U>> => 'org.eclipse.ocl.examples.library.classifier.ClassifierOclContentsOperation'; | |
} | |
/** | |
Collection is the abstract supertype of all collection types in the OCL Standard Library. | |
Each occurrence of an object in a collection is called an element. | |
If an object occurs twice in a collection, there are two elements. | |
*/ | |
type Collection<T> : CollectionType conformsTo OclAny { | |
/** | |
Returns any element in the source collection for which body evaluates to true. | |
If there is more than one element for which body is true, one of them is returned. | |
There must be at least one element fulfilling body, otherwise the result of this IteratorExp is null. | |
**/ | |
iteration any(i : T | body : Lambda T() : Boolean) : T => 'org.eclipse.ocl.examples.library.iterator.AnyIteration'; | |
/** | |
The Collection of elements that results from applying body to every member of the source set. | |
The result is flattened. Notice that this is based on collectNested, which can be of different type depending on the type of source. | |
collectNested is defined individually for each subclass of CollectionType. | |
**/ | |
iteration collect<V>(i : T | body : Lambda T() : V) : Collection<V> => 'org.eclipse.ocl.examples.library.iterator.CollectIteration'; | |
/** | |
The Collection of elements which results from applying body to every member of the source collection. | |
**/ | |
iteration collectNested<V>(i : T | body : Lambda T() : V) : Collection<T> => 'org.eclipse.ocl.examples.library.iterator.CollectNestedIteration'; | |
/** | |
Results in true if body evaluates to true for at least one element in the source collection. | |
**/ | |
iteration exists(i : T | body : Lambda T() : Boolean) : Boolean => 'org.eclipse.ocl.examples.library.iterator.ExistsIteration'; | |
iteration exists(i : T, j : T | body : Lambda T() : Boolean) : Boolean => 'org.eclipse.ocl.examples.library.iterator.ExistsIteration'; | |
/** | |
Results in true if the body expression evaluates to true for each element in the source collection; otherwise, result is false. | |
**/ | |
iteration forAll(i : T | body : Lambda T() : Boolean) : Boolean => 'org.eclipse.ocl.examples.library.iterator.ForAllIteration'; | |
iteration forAll(i : T, j : T | body : Lambda T() : Boolean) : Boolean => 'org.eclipse.ocl.examples.library.iterator.ForAllIteration'; | |
/** | |
Results in true if body evaluates to a different value for each element in the source collection; otherwise, result is false. | |
**/ | |
iteration isUnique(i : T | body : Lambda T() : OclAny) : Boolean => 'org.eclipse.ocl.examples.library.iterator.IsUniqueIteration'; | |
iteration iterate<Tacc>(i : T; acc : Tacc) : Tacc => 'org.eclipse.ocl.examples.library.iterator.IterateIteration'; | |
/** | |
Results in true if there is exactly one element in the source collection for which body is true. | |
**/ | |
iteration one(i : T | body : Lambda T() : Boolean) : Boolean => 'org.eclipse.ocl.examples.library.iterator.OneIteration'; | |
/** | |
The sub-collection of the source collection for which body is false. | |
**/ | |
iteration reject(i : T | body : Lambda T() : Boolean) : Collection<T> => 'org.eclipse.ocl.examples.library.iterator.RejectIteration'; | |
/** | |
The sub-collection of the source collection for which body is true. | |
**/ | |
iteration select(i : T | body : Lambda T() : Boolean) : Collection<T> => 'org.eclipse.ocl.examples.library.iterator.SelectIteration'; | |
/** | |
Results in the Collection containing all elements of the source collection. | |
The element for which body has the lowest value comes first, and so on. | |
The type of the body expression must have the < operation defined. | |
The < operation must return a Boolean value and must be transitive (i.e., if a < b and b < c then a < c). | |
**/ | |
iteration sortedBy(i : T | body : Lambda T() : OclAny) : OrderedCollection<T> => 'org.eclipse.ocl.examples.library.iterator.SortedByIteration'; | |
/** | |
True if c is a collection of the same kind as self and contains the same elements in the same quantities and in the same order, | |
in the case of an ordered collection type. | |
**/ | |
operation "="(object2 : OclSelf) : Boolean precedence=EQUALITY => 'org.eclipse.ocl.examples.library.oclany.OclAnyEqualOperation'; | |
/** | |
True if c is not equal to self. | |
**/ | |
operation "<>"(object2 : OclSelf) : Boolean precedence=EQUALITY => 'org.eclipse.ocl.examples.library.oclany.OclAnyNotEqualOperation'; | |
/** | |
The Bag that contains all the elements from self. | |
**/ | |
operation asBag() : Bag<T> => 'org.eclipse.ocl.examples.library.collection.CollectionAsBagOperation'; | |
/** | |
An OrderedSet that contains all the elements from self, with duplicates removed, | |
in an order dependent on the particular concrete collection type. | |
**/ | |
operation asOrderedSet() : OrderedSet<T> => 'org.eclipse.ocl.examples.library.collection.CollectionAsOrderedSetOperation'; | |
/** | |
A Sequence that contains all the elements from self, in an order dependent on the particular concrete collection type. | |
**/ | |
operation asSequence() : Sequence<T> => 'org.eclipse.ocl.examples.library.collection.CollectionAsSequenceOperation'; | |
/** | |
The Set containing all the elements from self, with duplicates removed. | |
**/ | |
operation asSet() : Set<T> => 'org.eclipse.ocl.examples.library.collection.CollectionAsSetOperation'; | |
/** | |
The number of times that object occurs in the collection self. | |
**/ | |
operation count(object : OclAny) : Integer => 'org.eclipse.ocl.examples.library.collection.CollectionCountOperation'; | |
/** | |
True if object is not an element of self, false otherwise. | |
**/ | |
operation excludes(object : OclAny) : Boolean => 'org.eclipse.ocl.examples.library.collection.CollectionExcludesOperation'; | |
/** | |
Does self contain none of the elements of c2 ? | |
**/ | |
operation excludesAll<T2>(c2 : Collection<T2>) : Boolean => 'org.eclipse.ocl.examples.library.collection.CollectionExcludesAllOperation'; | |
/** | |
The collection containing all elements of self apart from object. | |
**/ | |
operation excluding(object : OclAny) : Collection<T> => 'org.eclipse.ocl.examples.library.collection.CollectionExcludingOperation'; | |
/** | |
If the element type is not a collection type, this results in the same collection as self. | |
If the element type is a collection type, the result is a collection containing all the elements of all the recursively flattened elements of self. | |
**/ | |
operation flatten<T2>() : Collection<T2> => 'org.eclipse.ocl.examples.library.collection.CollectionFlattenOperation'; | |
/** | |
True if object is an element of self, false otherwise. | |
**/ | |
operation includes(object : OclAny) : Boolean => 'org.eclipse.ocl.examples.library.collection.CollectionIncludesOperation'; | |
/** | |
Does self contain all the elements of c2 ? | |
**/ | |
operation includesAll<T2>(c2 : Collection<T2>) : Boolean => 'org.eclipse.ocl.examples.library.collection.CollectionIncludesAllOperation'; | |
/** | |
The collection containing all elements of self plus object. | |
**/ | |
operation including(object : T) : Collection<T> => 'org.eclipse.ocl.examples.library.collection.CollectionIncludingOperation'; | |
/** | |
Is self the empty collection? | |
Note: null->isEmpty() returns ‘true’ in virtue of the implicit casting from null to Bag{} | |
**/ | |
operation isEmpty() : Boolean => 'org.eclipse.ocl.examples.library.collection.CollectionIsEmptyOperation'; | |
/** | |
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. | |
**/ | |
operation max() : T => 'org.eclipse.ocl.examples.library.collection.CollectionMaxOperation'; | |
/** | |
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. | |
**/ | |
operation min() : T => 'org.eclipse.ocl.examples.library.collection.CollectionMinOperation'; | |
/** | |
Is self not the empty collection? | |
null->notEmpty() returns ‘false’ in virtue of the implicit casting from null to Bag{}. | |
**/ | |
operation notEmpty() : Boolean => 'org.eclipse.ocl.examples.library.collection.CollectionNotEmptyOperation'; | |
/** | |
The cartesian product operation of self and c2. | |
**/ | |
operation product<T2>(c2 : Collection<T2>) : Set<Tuple<first:T,second:T2>> => 'org.eclipse.ocl.examples.library.collection.CollectionProductOperation'; | |
/** | |
The number of elements in the collection self. | |
**/ | |
operation size() : Integer => 'org.eclipse.ocl.examples.library.collection.CollectionSizeOperation'; | |
/** | |
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. | |
**/ | |
operation sum() : T => 'org.eclipse.ocl.examples.library.collection.CollectionSumOperation'; | |
-- operation "->"<T>(object2 : OclAny) : T precedence=NAVIGATION => 'org.eclipse.ocl.examples.library.oclany.OclAnyUnsupportedOperation'; | |
} | |
/** | |
This is enum | |
**/ | |
type Enumeration conformsTo OclAny { | |
/** | |
Return a set of all enumeration values of self. | |
*/ | |
static operation allInstances() : Set<OclSelf> => 'org.eclipse.ocl.examples.library.enumeration.EnumerationAllInstancesOperation'; | |
} | |
/** | |
The standard type Integer represents the mathematical concept of integer. | |
Note that UnlimitedNatural is a subclass of Integer, so for each parameter of type Integer, | |
you can use an unlimited natural as the actual parameter. | |
Integer is itself an instance of the metatype PrimitiveType (from UML). | |
**/ | |
type Integer : PrimitiveType conformsTo Real { | |
/** | |
The negative value of self. | |
**/ | |
operation "-"() : Integer precedence=UNARY => 'org.eclipse.ocl.examples.library.numeric.NumericNegateOperation'; | |
/** | |
The value of the addition of self and i. | |
**/ | |
operation "+"(i : OclSelf) : Integer precedence=ADDITIVE => 'org.eclipse.ocl.examples.library.integer.IntegerPlusOperation'; | |
/** | |
The value of the subtraction of i from self. | |
**/ | |
operation "-"(i : OclSelf) : Integer precedence=ADDITIVE => 'org.eclipse.ocl.examples.library.integer.IntegerMinusOperation'; | |
/** | |
The value of the multiplication of self and i. | |
**/ | |
operation "*"(i : OclSelf) : Integer precedence=MULTIPLICATIVE => 'org.eclipse.ocl.examples.library.numeric.NumericTimesOperation'; | |
/** | |
The value of self divided by i. | |
Evaluates to invalid if r is equal to zero. | |
**/ | |
operation "/"(i : OclSelf) : Real precedence=MULTIPLICATIVE => 'org.eclipse.ocl.examples.library.numeric.NumericDivideOperation'; | |
/** | |
The absolute value of self. | |
**/ | |
operation abs() : Integer => 'org.eclipse.ocl.examples.library.numeric.NumericAbsOperation'; | |
/** | |
The number of times that i fits completely within self. | |
**/ | |
operation div(i : Integer) : Integer => 'org.eclipse.ocl.examples.library.numeric.NumericDivOperation'; | |
/** | |
The result is self modulo i. | |
**/ | |
operation mod(i : Integer) : Integer => 'org.eclipse.ocl.examples.library.numeric.NumericModOperation'; | |
/** | |
The maximum of self an i. | |
**/ | |
operation max(i : OclSelf) : Integer => 'org.eclipse.ocl.examples.library.numeric.NumericMaxOperation'; | |
/** | |
The minimum of self an i. | |
**/ | |
operation min(i : OclSelf) : Integer => 'org.eclipse.ocl.examples.library.numeric.NumericMinOperation'; | |
/** | |
Converts self to a string value. | |
**/ | |
operation toString() : String => 'org.eclipse.ocl.examples.library.oclany.OclAnyToStringOperation'; | |
} | |
/** | |
The NonOrderedCollection type provides the shared functionality of the Bag and Set | |
collections for which the elements are not ordered. | |
The common supertype of NonOrderedCollection is Collection. | |
**/ | |
type NonOrderedCollection<T> : CollectionType conformsTo Collection<T> { | |
/** | |
The closure of applying body transitively to every distinct element of the source collection. | |
**/ | |
iteration closure(i : T | body : Lambda T() : Set<T>) : Set<T> => 'org.eclipse.ocl.examples.library.iterator.ClosureIteration'; | |
iteration collect<V>(i : T | body : Lambda T() : V) : Bag<V> => 'org.eclipse.ocl.examples.library.iterator.CollectIteration'; | |
/** | |
The Bag of elements which results from applying body to every member of the source nonordered collection. | |
**/ | |
iteration collectNested<V>(i : T | body : Lambda T() : V) : Bag<T> => 'org.eclipse.ocl.examples.library.iterator.CollectNestedIteration'; | |
/** | |
The intersection of self and bag. | |
**/ | |
operation intersection(bag : Bag<T>) : Bag<T> => 'org.eclipse.ocl.examples.library.collection.UniqueCollectionIntersectionOperation'; | |
/** | |
The intersection of self and s (i.e., the set of all elements that are in both self and s). | |
**/ | |
operation intersection(s : Set<T>) : Set<T> => 'org.eclipse.ocl.examples.library.collection.UniqueCollectionIntersectionOperation'; | |
/** | |
The union of self and bag. | |
**/ | |
operation union(bag : Bag<T>) : Bag<T> => 'org.eclipse.ocl.examples.library.collection.CollectionUnionOperation'; | |
/** | |
The union of self and s. | |
**/ | |
operation union(s : Set<T>) : Set<T> => 'org.eclipse.ocl.examples.library.collection.CollectionUnionOperation'; | |
} | |
/** | |
The NonUniqueCollection type provides the shared functionality of the Bag and Sequence | |
collections for which the elements are not unique. | |
The common supertype of NonUniqueCollection is Collection. | |
**/ | |
type NonUniqueCollection<T> : CollectionType conformsTo Collection<T> { | |
/** | |
Results in the Sequence containing all elements of the source collection. | |
The element for which body has the lowest value comes first, and so on. | |
The type of the body expression must have the < operation defined. | |
The < operation must return a Boolean value and must be transitive (i.e., if a < b and b < c then a < c). | |
**/ | |
iteration sortedBy(i : T | body : Lambda T() : OclAny) : Sequence<T> => 'org.eclipse.ocl.examples.library.iterator.SortedByIteration'; | |
} | |
/** | |
All types in the UML model and the primitive and collection types in the OCL standard library conforms to the type OclAny. | |
Conceptually, OclAny behaves as a supertype for all the types. | |
Features of OclAny are available on each object in all OCL expressions. | |
OclAny is itself an instance of the metatype AnyType. | |
All classes in a UML model inherit all operations defined on OclAny. | |
To avoid name conflicts between properties in the model and the properties inherited from OclAny, | |
all names on the properties of OclAny start with ‘ocl.’ | |
Although theoretically there may still be name conflicts, they can be avoided. | |
One can also use qualification by OclAny (name of the type) to explicitly refer to the OclAny properties. | |
Operations of OclAny, where the instance of OclAny is called object. | |
**/ | |
type OclAny : AnyType { | |
/** | |
True if self is the same object as object2. Infix operator. | |
**/ | |
operation "="(object2 : OclSelf) : Boolean precedence=EQUALITY => 'org.eclipse.ocl.examples.library.oclany.OclAnyEqualOperation'; | |
/** | |
True if self is a different object from object2. Infix operator. | |
**/ | |
operation "<>"(object2 : OclSelf) : Boolean precedence=EQUALITY => 'org.eclipse.ocl.examples.library.oclany.OclAnyNotEqualOperation'; | |
/** | |
Returns a Set with self as the sole content, unless self is null in which case returns an empty set, | |
*/ | |
operation oclAsSet() : Set<OclSelf> => 'org.eclipse.ocl.examples.library.oclany.OclAnyOclAsSetOperation'; | |
/** | |
Evaluates to self, where self is of the type identified by T. | |
The type T may be any classifier defined in the UML model; | |
if the actual type of self at evaluation time does not conform to T, | |
then the oclAsType operation evaluates to invalid. | |
In the case of feature redefinition, casting an object to a supertype of its actual type | |
does not access the supertype’s definition of the feature; | |
according to the semantics of redefinition, the redefined feature simply does not exist for the object. | |
However, when casting to a supertype, any features additionally defined by the subtype are suppressed. | |
**/ | |
operation oclAsType<TT>(type : Classifier<TT>) : TT => 'org.eclipse.ocl.examples.library.oclany.OclAnyOclAsTypeOperation'; | |
/** | |
Evaluates to true if the self is in the state indentified by statespec. | |
**/ | |
operation oclIsInState(statespec : OclState) : Boolean => 'org.eclipse.ocl.examples.library.oclany.OclAnyOclIsInStateOperation'; | |
/** | |
Evaluates to true if the self is equal to OclInvalid. | |
**/ | |
operation oclIsInvalid() : Boolean => 'org.eclipse.ocl.examples.library.oclany.OclAnyOclIsInvalidOperation'; | |
/** | |
Evaluates to true if the type of self conforms to t. | |
That is, self is of type t or a subtype of t. | |
**/ | |
operation oclIsKindOf<T>(type : Classifier<T>) : Boolean => 'org.eclipse.ocl.examples.library.oclany.OclAnyOclIsKindOfOperation'; | |
/** | |
Can only be used in a postcondition. | |
Evaluates to true if the self is created during performing the operation (for instance, it didn’t exist at precondition time). | |
**/ | |
operation oclIsNew() : Boolean => 'org.eclipse.ocl.examples.library.oclany.OclAnyUnsupportedOperation'; | |
/** | |
Evaluates to true if self is of the type t but not a subtype of t | |
*/ | |
operation oclIsTypeOf<T>(type : Classifier<T>) : Boolean => 'org.eclipse.ocl.examples.library.oclany.OclAnyOclIsTypeOfOperation'; | |
/** | |
Evaluates to true if the self is equal to invalid or equal to null. | |
**/ | |
operation oclIsUndefined() : Boolean => 'org.eclipse.ocl.examples.library.oclany.OclAnyOclIsUndefinedOperation'; | |
/** | |
Evaluates to the type of which self is an instance. | |
**/ | |
operation oclType() : Classifier<OclSelf> => 'org.eclipse.ocl.examples.library.oclany.OclAnyOclTypeOperation'; | |
-- operation "."<T>(object2 : OclAny) : T precedence=NAVIGATION => 'org.eclipse.ocl.examples.library.oclany.OclAnyUnsupportedOperation'; | |
} | |
/** | |
The type OclInvalid is a type that conforms to all other types. | |
It has one single instance, identified as invalid. | |
Any property call applied on invalid results in invalid, except for the operations oclIsUndefined() and oclIsInvalid(). | |
OclInvalid is itself an instance of the metatype InvalidType. | |
**/ | |
type OclInvalid : InvalidType conformsTo OclVoid { | |
/** | |
Returns invalid. | |
*/ | |
static operation allInstances() : Set<OclSelf> => 'org.eclipse.ocl.examples.library.oclinvalid.OclInvalidAllInstancesOperation'; | |
/** | |
Returns invalid. | |
*/ | |
operation "="(object2 : OclSelf) : Boolean precedence=EQUALITY => 'org.eclipse.ocl.examples.library.oclany.OclAnyEqualOperation'; | |
/** | |
Returns invalid. | |
*/ | |
operation "<>"(object2 : OclSelf) : Boolean precedence=EQUALITY => 'org.eclipse.ocl.examples.library.oclany.OclAnyNotEqualOperation'; | |
operation oclBadOperation() : OclInvalid; | |
property oclBadProperty : OclInvalid; | |
/** | |
Returns 'invalid'. | |
*/ | |
operation toString() : String => 'org.eclipse.ocl.examples.library.oclany.OclAnyToStringOperation'; | |
} | |
/** | |
OclMessage | |
This sub clause contains the definition of the standard type OclMessage. | |
As defined in this sub clause, each ocl message type is actually a template type with one parameter. | |
‘T’ denotes the parameter. | |
A concrete ocl message type is created by substituting an operation or signal for the T. | |
The predefined type OclMessage is an instance of MessageType. | |
Every OclMessage is fully determined by either the operation, or signal given as parameter. | |
Note that there is conceptually an undefined (infinite) number of these types, | |
as each is determined by a different operation or signal. | |
These types are unnamed. Every type has as attributes the name of the operation or signal, | |
and either all formal parameters of the operation, or all attributes of the signal. | |
OclMessage is itself an instance of the metatype MessageType. | |
OclMessage has a number of predefined operations, as shown in the OCL Standard Library. | |
**/ | |
type OclMessage conformsTo OclAny { | |
/** | |
True if type of template parameter is an operation call, and the called operation has returned a value. | |
This implies the fact that the message has been sent. False in all other cases. | |
**/ | |
operation hasReturned() : Boolean => 'org.eclipse.ocl.examples.library.oclany.OclAnyUnsupportedOperation'; | |
/** | |
Returns the result of the called operation, if type of template parameter is an operation call, | |
and the called operation has returned a value. Otherwise the invalid value is returned. | |
**/ | |
operation result() : OclAny => 'org.eclipse.ocl.examples.library.oclany.OclAnyUnsupportedOperation'; | |
/** | |
Returns true if the OclMessage represents the sending of a UML Operation call. | |
**/ | |
operation isOperationCall() : Boolean => 'org.eclipse.ocl.examples.library.oclany.OclAnyUnsupportedOperation'; | |
/** | |
Returns true if the OclMessage represents the sending of a UML Signal. | |
**/ | |
operation isSignalSent() : Boolean => 'org.eclipse.ocl.examples.library.oclany.OclAnyUnsupportedOperation'; | |
} | |
/** | |
The pseudo-type OclSelf denotes the statically determinate type of self in Operation | |
and Iteration signatures. Instances of OclSelf are never created. | |
**/ | |
type OclSelf : SelfType conformsTo OclAny {} | |
type OclState conformsTo OclAny { | |
} | |
type OclTuple conformsTo OclAny { | |
operation "="(object2 : OclSelf) : Boolean precedence=EQUALITY => 'org.eclipse.ocl.examples.library.oclany.OclAnyEqualOperation'; | |
operation "<>"(object2 : OclSelf) : Boolean precedence=EQUALITY => 'org.eclipse.ocl.examples.library.oclany.OclAnyNotEqualOperation'; | |
} | |
/** | |
The type OclVoid is a type that conforms to all other types except OclInvalid. | |
It has one single instance, identified as null, that corresponds with the UML LiteralNull value specification. | |
Any property call applied on null results in invalid, except for the | |
oclIsUndefined(), oclIsInvalid(), =(OclAny) and <>(OclAny) operations. | |
However, by virtue of the implicit conversion to a collection literal, | |
an expression evaluating to null can be used as source of collection operations (such as ‘isEmpty’). | |
If the source is the null literal, it is implicitly converted to Bag{}. | |
OclVoid is itself an instance of the metatype VoidType. | |
**/ | |
type OclVoid : VoidType conformsTo OclAny { | |
/** | |
Returns Set{null}. | |
*/ | |
static operation allInstances() : Set<OclSelf> => 'org.eclipse.ocl.examples.library.oclvoid.OclVoidAllInstancesOperation'; | |
/** | |
Redefines the OclAny operation, returning true if object is null, invalid | |
if object is invalid, false otherwise. | |
**/ | |
operation "="(object2 : OclSelf) : Boolean precedence=EQUALITY => 'org.eclipse.ocl.examples.library.oclany.OclAnyEqualOperation'; | |
operation "<>"(object2 : OclSelf) : Boolean precedence=EQUALITY => 'org.eclipse.ocl.examples.library.oclany.OclAnyNotEqualOperation'; | |
operation and(b : Boolean) : Boolean precedence=AND => 'org.eclipse.ocl.examples.library.oclvoid.OclVoidAndOperation'; | |
operation implies(b : Boolean) : Boolean precedence=IMPLIES => 'org.eclipse.ocl.examples.library.oclvoid.OclVoidImpliesOperation'; | |
operation or(b : Boolean) : Boolean precedence=OR => 'org.eclipse.ocl.examples.library.oclvoid.OclVoidOrOperation'; | |
/** | |
Returns 'null'. | |
*/ | |
operation toString() : String => 'org.eclipse.ocl.examples.library.oclany.OclAnyToStringOperation'; | |
} | |
/** | |
The OrderedCollection type provides the shared functionality of the OrderedSet and Sequence | |
collections for which the elements are ordered. | |
The common supertype of OrderedCollection is Collection. | |
**/ | |
type OrderedCollection<T> : CollectionType conformsTo Collection<T> { | |
/** | |
The closure of applying body transitively to every distinct element of the source collection. | |
**/ | |
iteration closure(i : T | body : Lambda T() : OrderedSet<T>) : OrderedSet<T> => 'org.eclipse.ocl.examples.library.iterator.ClosureIteration'; | |
iteration collect<V>(i : T | body : Lambda T() : V) : Sequence<V> => 'org.eclipse.ocl.examples.library.iterator.CollectIteration'; | |
/** | |
The sequence of elements that results from applying body to every member of the source ordered collection. | |
**/ | |
iteration collectNested<V>(i : T | body : Lambda T() : V) : Sequence<T> => 'org.eclipse.ocl.examples.library.iterator.CollectNestedIteration'; | |
/** | |
The i-th element of sequence. | |
**/ | |
operation at(index : Integer) : T => 'org.eclipse.ocl.examples.library.collection.OrderedCollectionAtOperation'; | |
/** | |
The first element in self. | |
**/ | |
operation first() : T => 'org.eclipse.ocl.examples.library.collection.OrderedCollectionFirstOperation'; | |
/** | |
The index of object obj in the ordered collection. | |
**/ | |
operation indexOf(obj : OclAny) : Integer => 'org.eclipse.ocl.examples.library.collection.OrderedCollectionIndexOfOperation'; | |
/** | |
The last element in self. | |
**/ | |
operation last() : T => 'org.eclipse.ocl.examples.library.collection.OrderedCollectionLastOperation'; | |
/** | |
The ordered collection of elements with same elements but with the opposite order. | |
**/ | |
operation reverse() : OrderedCollection<T> => 'org.eclipse.ocl.examples.library.collection.OrderedCollectionReverseOperation'; | |
} | |
/** | |
The OrderedSet is a Set, the elements of which are ordered. | |
It contains no duplicates. OrderedSet is itself an instance of the metatype OrderedSetType. | |
An OrderedSet is not a subtype of Set, neither a subtype of Sequence. | |
The common supertype of Sets and OrderedSets is Collection. | |
**/ | |
type OrderedSet<T> : OrderedSetType conformsTo OrderedCollection<T>,UniqueCollection<T> { | |
/** | |
The ordered set of the source ordered set for which body is false. | |
**/ | |
iteration reject(i : T | body : Lambda T() : Boolean) : OrderedSet<T> => 'org.eclipse.ocl.examples.library.iterator.RejectIteration'; | |
/** | |
The ordered set of the source ordered set for which body is true | |
**/ | |
iteration select(i : T | body : Lambda T() : Boolean) : OrderedSet<T> => 'org.eclipse.ocl.examples.library.iterator.SelectIteration'; | |
operation "="(object2 : OclSelf) : Boolean precedence=EQUALITY => 'org.eclipse.ocl.examples.library.oclany.OclAnyEqualOperation'; | |
operation "<>"(object2 : OclSelf) : Boolean precedence=EQUALITY => 'org.eclipse.ocl.examples.library.oclany.OclAnyNotEqualOperation'; | |
operation "-"(s : Set<OclAny>) : OrderedSet<T> precedence=ADDITIVE => 'org.eclipse.ocl.examples.library.collection.SetMinusOperation'; | |
/** | |
The set of elements, consisting of all elements of self, followed by object. | |
**/ | |
operation append(object : T) : OrderedSet<T> => 'org.eclipse.ocl.examples.library.collection.OrderedCollectionAppendOperation'; | |
/** | |
The ordered set containing all elements of self apart from object. | |
The order of the remaining elements is not changed. | |
**/ | |
operation excluding(object : OclAny) : OrderedSet<T> => 'org.eclipse.ocl.examples.library.collection.CollectionExcludingOperation'; | |
operation flatten<T2>() : OrderedSet<T2> => 'org.eclipse.ocl.examples.library.collection.CollectionFlattenOperation'; | |
/** | |
The ordered set containing all elements of self plus object added as the last element if not already present. | |
**/ | |
operation including(object : T) : OrderedSet<T> => 'org.eclipse.ocl.examples.library.collection.CollectionIncludingOperation'; | |
/** | |
The ordered set consisting of self with object present at position index. | |
**/ | |
operation insertAt(index : Integer, object : T) : OrderedSet<T> => 'org.eclipse.ocl.examples.library.collection.OrderedCollectionInsertAtOperation'; | |
operation intersection(o : Set<T>) : OrderedSet<T> => 'org.eclipse.ocl.examples.library.collection.UniqueCollectionIntersectionOperation'; | |
/** | |
The sequence consisting of object, followed by all elements in self. | |
post: result->size = self->size() + 1 | |
post: result->at(1) = object | |
post: Sequence{1..self->size()}->forAll(index : Integer | | |
self->at(index) = result->at(index + 1)) | |
**/ | |
operation prepend(object : T) : OrderedSet<T> => 'org.eclipse.ocl.examples.library.collection.OrderedCollectionPrependOperation'; | |
/** | |
The ordered set of elements with same elements but with the opposite order. | |
**/ | |
operation reverse() : OrderedSet<T> => 'org.eclipse.ocl.examples.library.collection.OrderedCollectionReverseOperation'; | |
/** | |
The sub-set of self starting at number lower, up to and including element number upper. | |
**/ | |
operation subOrderedSet(lower : Integer, upper : Integer) : OrderedSet<T> => 'org.eclipse.ocl.examples.library.collection.OrderedSetSubOrderedSetOperation'; | |
/** | |
The ordered set containing all the elements that are in self after removal of all elements of s. | |
**/ | |
operation symmetricDifference(s : Set<OclAny>) : OrderedSet<T> => 'org.eclipse.ocl.examples.library.collection.SetSymmetricDifferenceOperation'; | |
/** | |
The ordered set consisting of all elements in self and all elements in o. | |
**/ | |
operation union(o : OrderedSet<T>) : OrderedSet<T> => 'org.eclipse.ocl.examples.library.collection.CollectionUnionOperation'; | |
/** | |
The set consisting of all elements in self and all elements in s. | |
**/ | |
operation union(s : Set<T>) : Set<T> => 'org.eclipse.ocl.examples.library.collection.CollectionUnionOperation'; | |
} | |
/** | |
The standard type Real represents the mathematical concept of real. | |
Note that UnlimitedNatural is a subclass of Integer and that Integer is a subclass of Real, | |
so for each parameter of type Real, you can use an unlimited natural or an integer as the actual parameter. | |
Real is itself an instance of the metatype PrimitiveType (from UML). | |
**/ | |
type Real : PrimitiveType conformsTo OclAny { | |
/** | |
Returns true if the numeric value of self is the same as the numeric value of object2, false otherwise. | |
*/ | |
operation "="(object2 : OclSelf) : Boolean precedence=EQUALITY => 'org.eclipse.ocl.examples.library.oclany.OclAnyEqualOperation'; | |
/** | |
Returns true if the numeric value of self is the not the same as the numeric value of object2, false otherwise. | |
*/ | |
operation "<>"(object2 : OclSelf) : Boolean precedence=EQUALITY => 'org.eclipse.ocl.examples.library.oclany.OclAnyNotEqualOperation'; | |
/** | |
The value of the addition of self and r. | |
**/ | |
operation "+"(r : OclSelf) : Real precedence=ADDITIVE => 'org.eclipse.ocl.examples.library.real.RealPlusOperation'; | |
/** | |
The value of the subtraction of r from self. | |
**/ | |
operation "-"(r : OclSelf) : Real precedence=ADDITIVE => 'org.eclipse.ocl.examples.library.real.RealMinusOperation'; | |
/** | |
The value of the multiplication of self and r. | |
**/ | |
operation "*"(r : OclSelf) : Real precedence=MULTIPLICATIVE => 'org.eclipse.ocl.examples.library.numeric.NumericTimesOperation'; | |
/** | |
The negative value of self. | |
**/ | |
operation "-"() : Real precedence=UNARY => 'org.eclipse.ocl.examples.library.numeric.NumericNegateOperation'; | |
/** | |
The value of self divided by r. Evaluates to invalid if r is equal to zero. | |
**/ | |
operation "/"(r : OclSelf) : Real precedence=MULTIPLICATIVE => 'org.eclipse.ocl.examples.library.numeric.NumericDivideOperation'; | |
/** | |
True if self is greater than r. | |
**/ | |
operation ">"(r : OclSelf) : Boolean precedence=RELATIONAL => 'org.eclipse.ocl.examples.library.numeric.NumericGreaterThanOperation'; | |
/** | |
True if self is less than r. | |
**/ | |
operation "<"(r : OclSelf) : Boolean precedence=RELATIONAL => 'org.eclipse.ocl.examples.library.numeric.NumericLessThanOperation'; | |
/** | |
True if self is less than or equal to r. | |
**/ | |
operation "<="(r : OclSelf) : Boolean precedence=RELATIONAL => 'org.eclipse.ocl.examples.library.numeric.NumericLessThanEqualOperation'; | |
/** | |
True if self is greater than or equal to r. | |
**/ | |
operation ">="(r : OclSelf) : Boolean precedence=RELATIONAL => 'org.eclipse.ocl.examples.library.numeric.NumericGreaterThanEqualOperation'; | |
/** | |
The absolute value of self. | |
**/ | |
operation abs() : Real => 'org.eclipse.ocl.examples.library.numeric.NumericAbsOperation'; | |
/** | |
The largest integer that is less than or equal to self. | |
**/ | |
operation floor() : Integer => 'org.eclipse.ocl.examples.library.numeric.NumericFloorOperation'; | |
/** | |
The maximum of self and r. | |
**/ | |
operation max(r : OclSelf) : Real => 'org.eclipse.ocl.examples.library.numeric.NumericMaxOperation'; | |
/** | |
The minimum of self and r. | |
**/ | |
operation min(r : OclSelf) : Real => 'org.eclipse.ocl.examples.library.numeric.NumericMinOperation'; | |
/** | |
The integer that is closest to self. When there are two such integers, the largest one. | |
**/ | |
operation round() : Integer => 'org.eclipse.ocl.examples.library.numeric.NumericRoundOperation'; | |
/** | |
Converts self to a string value. | |
**/ | |
operation toString() : String => 'org.eclipse.ocl.examples.library.oclany.OclAnyToStringOperation'; | |
} | |
/** | |
A sequence is a collection where the elements are ordered. | |
An element may be part of a sequence more than once. | |
Sequence is itself an instance of the metatype SequenceType. | |
A Sentence is not a subtype of Bag. | |
The common supertype of Sentence and Bags is Collection. | |
**/ | |
type Sequence<T> : SequenceType conformsTo OrderedCollection<T>,NonUniqueCollection<T> { | |
/** | |
The subsequence of the source sequence for which body is false. | |
**/ | |
iteration reject(i : T | body : Lambda T() : Boolean) : Sequence<T> => 'org.eclipse.ocl.examples.library.iterator.RejectIteration'; | |
/** | |
The subsequence of the source sequence for which body is true. | |
**/ | |
iteration select(i : T | body : Lambda T() : Boolean) : Sequence<T> => 'org.eclipse.ocl.examples.library.iterator.SelectIteration'; | |
/** | |
True if self contains the same elements as s in the same order. | |
**/ | |
operation "="(object2 : OclSelf) : Boolean precedence=EQUALITY => 'org.eclipse.ocl.examples.library.oclany.OclAnyEqualOperation'; | |
operation "<>"(object2 : OclSelf) : Boolean precedence=EQUALITY => 'org.eclipse.ocl.examples.library.oclany.OclAnyNotEqualOperation'; | |
/** | |
The sequence of elements, consisting of all elements of self, followed by object. | |
**/ | |
operation append(object : T) : Sequence<T> => 'org.eclipse.ocl.examples.library.collection.OrderedCollectionAppendOperation'; | |
/** | |
The sequence containing all elements of self apart from all occurrences of object. | |
The order of the remaining elements is not changed. | |
**/ | |
operation excluding(object : OclAny) : Sequence<T> => 'org.eclipse.ocl.examples.library.collection.CollectionExcludingOperation'; | |
/** | |
Redefines the Collection operation. If the element type is not a collection type, this results in the same sequence as self. | |
If the element type is a collection type, the result is the sequence containing all the elements | |
of all the recursively flattened elements of self. The order of the elements is partial. | |
**/ | |
operation flatten<T2>() : Sequence<T2> => 'org.eclipse.ocl.examples.library.collection.CollectionFlattenOperation'; | |
/** | |
The sequence containing all elements of self plus object added as the last element. | |
**/ | |
operation including(object : T) : Sequence<T> => 'org.eclipse.ocl.examples.library.collection.CollectionIncludingOperation'; | |
/** | |
The sequence consisting of self with object inserted at position index. | |
**/ | |
operation insertAt(index : Integer, object : T) : Sequence<T> => 'org.eclipse.ocl.examples.library.collection.OrderedCollectionInsertAtOperation'; | |
/** | |
The sequence consisting of object, followed by all elements in self. | |
**/ | |
operation prepend(object : T) : Sequence<T> => 'org.eclipse.ocl.examples.library.collection.OrderedCollectionPrependOperation'; | |
/** | |
The sequence containing the same elements but with the opposite order. | |
**/ | |
operation reverse() : Sequence<T> => 'org.eclipse.ocl.examples.library.collection.OrderedCollectionReverseOperation'; | |
/** | |
The sub-sequence of self starting at number lower, up to and including element number upper. | |
**/ | |
operation subSequence(lower : Integer, upper : Integer) : Sequence<T> => 'org.eclipse.ocl.examples.library.collection.SequenceSubSequenceOperation'; | |
/** | |
The sequence consisting of all elements in self, followed by all elements in s. | |
**/ | |
operation union(s : Sequence<T>) : Sequence<T> => 'org.eclipse.ocl.examples.library.collection.CollectionUnionOperation'; | |
} | |
type Set<T> : SetType conformsTo NonOrderedCollection<T>,UniqueCollection<T> { | |
/** | |
The subset of the source set for which body is false. | |
**/ | |
iteration reject(i : T | body : Lambda T() : Boolean) : Set<T> => 'org.eclipse.ocl.examples.library.iterator.RejectIteration'; | |
/** | |
The subset of set for which expr is true. | |
**/ | |
iteration select(i : T | body : Lambda T() : Boolean) : Set<T> => 'org.eclipse.ocl.examples.library.iterator.SelectIteration'; | |
/** | |
Evaluates to true if self and s contain the same elements. | |
**/ | |
operation "="(object2 : OclSelf) : Boolean precedence=EQUALITY => 'org.eclipse.ocl.examples.library.oclany.OclAnyEqualOperation'; | |
operation "<>"(object2 : OclSelf) : Boolean precedence=EQUALITY => 'org.eclipse.ocl.examples.library.oclany.OclAnyNotEqualOperation'; | |
/** | |
The elements of self, which are not in s. | |
**/ | |
operation "-"(s : Set<OclAny>) : Set<T> precedence=ADDITIVE => 'org.eclipse.ocl.examples.library.collection.SetMinusOperation'; | |
/** | |
The set containing all elements of self without object. | |
**/ | |
operation excluding(object : OclAny) : Set<T> => 'org.eclipse.ocl.examples.library.collection.CollectionExcludingOperation'; | |
/** | |
Redefines the Collection operation. If the element type is not a collection type, this results in the same set as self. | |
If the element type is a collection type, the result is the set containing all the elements of all the recursively flattened elements of self. | |
**/ | |
operation flatten<T2>() : Set<T2> => 'org.eclipse.ocl.examples.library.collection.CollectionFlattenOperation'; | |
/** | |
The set containing all elements of self plus object. | |
**/ | |
operation including(object : T) : Set<T> => 'org.eclipse.ocl.examples.library.collection.CollectionIncludingOperation'; | |
/** | |
The intersection of self and s (i.e., the set of all elements that are in both self and s). | |
**/ | |
operation intersection(s : Set<T>) : Set<T> => 'org.eclipse.ocl.examples.library.collection.UniqueCollectionIntersectionOperation'; | |
/** | |
The sets containing all the elements that are in self or s, but not in both. | |
**/ | |
operation symmetricDifference(s : Set<OclAny>) : Set<T> => 'org.eclipse.ocl.examples.library.collection.SetSymmetricDifferenceOperation'; | |
} | |
/** | |
The standard type String represents strings, which can be both ASCII or Unicode. | |
String is itself an instance of the metatype PrimitiveType (from UML). | |
**/ | |
type String : PrimitiveType conformsTo OclAny { | |
operation "="(object2 : OclSelf) : Boolean precedence=EQUALITY => 'org.eclipse.ocl.examples.library.oclany.OclAnyEqualOperation'; | |
operation "<>"(object2 : OclSelf) : Boolean precedence=EQUALITY => 'org.eclipse.ocl.examples.library.oclany.OclAnyNotEqualOperation'; | |
/** | |
The concatenation of self and s. | |
**/ | |
operation "+"(s : String) : String precedence=ADDITIVE => 'org.eclipse.ocl.examples.library.string.StringConcatOperation'; | |
/** | |
Queries the character at position i in self. | |
**/ | |
operation at(i : Integer) : String => 'org.eclipse.ocl.examples.library.string.StringAtOperation'; | |
/** | |
Obtains the characters of self as a sequence. | |
**/ | |
operation characters() : Sequence<String> => 'org.eclipse.ocl.examples.library.string.StringCharactersOperation'; | |
/** | |
The concatenation of self and s. | |
**/ | |
operation concat(s : String) : String => 'org.eclipse.ocl.examples.library.string.StringConcatOperation'; | |
/** | |
Queries whether s and self are equivalent under case-insensitive collation. | |
**/ | |
operation equalsIgnoreCase(s : String) : Boolean => 'org.eclipse.ocl.examples.library.string.StringEqualsIgnoreCaseOperation'; | |
/** | |
Queries the index in self at which s is a substring of self, or zero if s is not a substring of self. | |
The empty string is considered to be a substring of every string but the empty string, at index 1. | |
No string is a substring of the empty string. | |
**/ | |
operation indexOf(s : String) : Integer => 'org.eclipse.ocl.examples.library.string.StringIndexOfOperation'; | |
/** | |
The number of characters in self. | |
**/ | |
operation size() : Integer => 'org.eclipse.ocl.examples.library.string.StringSizeOperation'; | |
/** | |
The sub-string of self starting at character number lower, up to and including character number upper. Character numbers run from 1 to self.size(). | |
**/ | |
operation substring(lower : Integer, upper : Integer) : String => 'org.eclipse.ocl.examples.library.string.StringSubstringOperation'; | |
/** | |
Converts self to a boolean value. | |
**/ | |
operation toBoolean() : Boolean => 'org.eclipse.ocl.examples.library.string.StringToBooleanOperation'; | |
/** | |
Converts self to an Integer value. | |
**/ | |
operation toInteger() : Integer => 'org.eclipse.ocl.examples.library.string.StringToIntegerOperation'; | |
/** | |
This is a deprecated variant of toLowerCase() preserving compatibility with traditional Eclipse OCL behaviour. | |
**/ | |
operation toLower() : String => 'org.eclipse.ocl.examples.library.string.StringToLowerCaseOperation'; | |
/** | |
Converts self to lower case, using the locale defined by looking up oclLocale in the current environment. | |
Otherwise, returns the same string as self. | |
**/ | |
operation toLowerCase() : String => 'org.eclipse.ocl.examples.library.string.StringToLowerCaseOperation'; | |
/** | |
Converts self to a Real value. | |
**/ | |
operation toReal() : Real => 'org.eclipse.ocl.examples.library.string.StringToRealOperation'; | |
/** | |
Returns self. | |
*/ | |
operation toString() : String => 'org.eclipse.ocl.examples.library.oclany.OclAnyToStringOperation'; | |
/** | |
This is a deprecated variant of toUpperCase() preserving compatibility with traditional Eclipse OCL behaviour. | |
**/ | |
operation toUpper() : String => 'org.eclipse.ocl.examples.library.string.StringToUpperCaseOperation'; | |
/** | |
Converts self to upper case, using the locale defined by looking up oclLocale in the current environment. | |
Otherwise, returns the same string as self. | |
**/ | |
operation toUpperCase() : String => 'org.eclipse.ocl.examples.library.string.StringToUpperCaseOperation'; | |
/** | |
True if self is greater than s, using the locale defined by looking up oclLocale in the current environment. | |
**/ | |
operation ">"(s : OclSelf) : Boolean precedence=RELATIONAL => 'org.eclipse.ocl.examples.library.string.StringGreaterThanOperation'; | |
/** | |
True if self is less than s, using the locale defined by looking up oclLocale in the current environment. | |
**/ | |
operation "<"(s : OclSelf) : Boolean precedence=RELATIONAL => 'org.eclipse.ocl.examples.library.string.StringLessThanOperation'; | |
/** | |
True if self is less than or equal to s, using the locale defined by looking up oclLocale in the current environment. | |
**/ | |
operation "<="(s : OclSelf) : Boolean precedence=RELATIONAL => 'org.eclipse.ocl.examples.library.string.StringLessThanEqualOperation'; | |
/** | |
True if self is greater than or equal to s, using the locale defined by looking up oclLocale in the current environment. | |
**/ | |
operation ">="(s : OclSelf) : Boolean precedence=RELATIONAL => 'org.eclipse.ocl.examples.library.string.StringGreaterThanEqualOperation'; | |
} | |
type Tuple : TupleType conformsTo OclAny {} | |
/** | |
The UniqueCollection type provides the shared functionality of the OrderedSet and Set | |
collections for which the elements are unique. | |
The common supertype of UniqueCollection is Collection. | |
**/ | |
type UniqueCollection<T> : CollectionType conformsTo Collection<T> { | |
/** | |
Results in the ordered set containing all elements of the source collection. | |
The element for which body has the lowest value comes first, and so on. | |
The type of the body expression must have the < operation defined. | |
The < operation must return a Boolean value and must be transitive (i.e., if a < b and b < c, then a < c). | |
**/ | |
iteration sortedBy(i : T | body : Lambda T() : OclAny) : OrderedSet<T> => 'org.eclipse.ocl.examples.library.iterator.SortedByIteration'; | |
} | |
/** | |
The standard type UnlimitedNatural is used to encode the non-negative values of a multiplicity specification. | |
This includes a special unlimited value (*) that encodes the upper value of a multiplicity specification. | |
UnlimitedNatural is itself an instance of the metatype UnlimitedNaturalType. | |
Note that although UnlimitedNatural is a subclass of Integer, the unlimited value cannot be represented as an Integer. | |
Any use of the unlimited value as an integer or real is replaced by the invalid value. | |
**/ | |
type UnlimitedNatural : PrimitiveType conformsTo Integer { | |
operation oclAsType<TT>(type : Classifier<TT>) : TT => 'org.eclipse.ocl.examples.library.numeric.UnlimitedNaturalOclAsTypeOperation'; | |
} | |
} |