Documentation:OCLOperators allInstances

It is a common operator. To find all available you can open the OCL-Editor and type in a class:

Your model is central to all expression you will handle. We will use this model to for the examples:

Operators	Description
Thing.allinstances	Gives you a list of all Things
Things.allinstances->select(someInt>3)	Only things with someInt bigger than 3
Thing.allinstances->select( (someInt>3) and (someInt<6))	Only things with someInt bigger than 3 but less than 6. Notice the extra parenthesis to or the Boolean expressions together
Things.allinstances->select(x|x.someInt>3)	Here we introduce the loop variable x. We separate the definition of x from the usage of x with the pipe sign “|”. Loop variables are optional but if names are unique – but you will need to use them to give precision or to if you want to perform operations on the loop context itself.
Things.allinstances.Details	Gives a list of all detail objects that are connected to a Thing. The Detail objects that float around without a Thing will not be in the list
Things.allinstances.Details.Attribute1	A list of nullable strings from the contents from the details attribute1. Note that OCL is null-tolerant – you do not need to check if the Details exists of not – the language handles null checks for you
SubClassThing1.allinstances.Details	Inherited features of classes are directly accessible
Thing.allInstances- >select(x|x.safeCast(SubClassThing1). OnlyAvailableInSubClass='Hello')	Filtering on Specialization is done with an operator SafeCast. This is null safe so for all objects that do not fit the profile the expression returns false

To find all available you can open the OCL-Editor and type in a class:

The operations listed do this:

Operators	Description
Allinstances	All the objects of the class
allinstancesAtTime	All the currently loaded instances
AllStates	Meta information about available states in state machines the class may contain
allSubClasses	Meta information on all the sub classes this class has
AllSuperTypes	Meta information on all the super classes – in inheritance order the class has
associationEnds	Meta information on all the associationEnds
Asstring	The string representation of the class – the asString operation is available on everything
Attributes	Meta information about what attributes the class has
Contraints	Meta information on what constraints the class has
Emptylist	Returns an empty list typed to hold objects of the class
IsDirtyMember
isNull
nullValue	A typed null value
objectFromExternalId	An external identity will be resolved to the object
oclAsType	The type of the class
oclIsKindOf	This is to if a class is a subclass or a the class itself and not unrelated
oclIsTypeOf	Returns true if
oclSingleton	Classes that implements the Singleton pattern – by setting IsSingleton=true – will return the singleton instance with this operator
OclType
safeCast
SuperTypes
TaggedValue	Meta information on tagged values set in the class
TaggedValueOnFeature	Meta information on Tagged values set on a named feature in the class
Typename	The type name as a string
ViewModels	A tuple with the ViewModels for this class a members

Once you have a collection of objects there are certain operators that are applicable to it. Again you can use the OCL-Editor to see what they are:

Operators	Description
->append	Add another object last
->asBag	Collapses to one list
->asSequence	Collapses to one list
->asset	Remove doublets
->at	Get the objects at X where the first index is 1
->at0	Get the objects at X where the first index is 0
->collect	Iterate over the collection and build a tuple result
->count	Count how many meet a certain criteria
->difference	The difference between 2 collections
->excluding	The collection except this single object
->exists	Are there any objects that fulfill the criteria
->filterOnType	Only keep the ones of a certain type
->first	Return the first object
->forAll	Iterate all that fulfills the critera
->groupBy	Build collection of tuples grouped by some aspect
->includes	Does the collection include the object
->includesAll	Does the collection include the whole other collection
->including
->IndexOf	The 1 based index of an object in the collection possibly -1 if not existing
->indexOf0	The 0 based index of an object in the collection possibly -1 if not existing
->intersection	The intersection of two collections
->isEmpty	Returns true if the collection is empty
->last	Returns the last object in the collection
->notEmpty	Returns true of the collection is not empty
->orderBy	Sorts the collection on one or more properties
->orderDescending	Sort the from biggest to smallest
->orderGeneric	Sorts the list of properties with interchangeable sort order: (expr1, OclSortDirection::ascending, expr2, OclSortDirection::descending...)
->prepend	Add an object in front of the list
->reject	Returns the objects not matching the criteria
->select	Returns the objects matching the criteria
->size	Returns the number of elements in the collection
->subsequence	Returns a smaller collection from a start to stop
->symmetricDifference	The symmetric difference between the collections; ie all the objects in collection1 or collection2 but not in both
->union	The set of objects in collection1 and objects in collection2

One important aspect of OCL that is worth noting is that it expands lists of lists to just a list. An example in plain English; Thing.allinstances.Details – this will come back as a set of details that are all the details from all the Things. If OCL had not expanded lists automatically one could have expected a set of sets containing the details per thing. But this is not the case. The automatically expansion of lists of lists is sometime referred to as flattening of a collection – referring to the reduction of topology in the result.

Some OCL examples

Examples	Results
Bag{'5','1','2','2','3','4'}->ascommalist	5, 1, 2, 2, 3, 4
Bag{'5','1','2','2','3','4'}- >union(Bag{'1','2','2','3','6'})->ascommalist	5, 1, 2, 2, 3, 4, 6
Bag{'5','1','2','2','3','4'}- >union(Bag{'1','2','2','3','6'})->asset- >ascommalist	5, 1, 2, 3, 4, 6
Bag{'5','1','2','2','3','4'}- >union(Bag{'1','2','2','3','6'})->asset- >orderby(a|a)->ascommalist	1, 2, 3, 4, 5, 6
Bag{'5','1','2','2','3','4'}- >intersection(Bag{'1','2','2','3','6'})- >orderby(a|a)->ascommalist	1, 2, 2, 3
Bag{'5','1','2','2','3','4'}- >Difference(Bag{'1','2','2','3','6'})->orderby(a|a)- >ascommalist	4, 5
Bag{'5','1','2','2','3','4'}- >SymmetricDifference(Bag{'1','2','2','3','6'})- >orderby(a|a)->ascommalist	4, 5, 6

If you are in the context of a simple type like string, double, int, datetime or Boolean MDriven will expose the simple operations that are available in the .net Framework. Testing this in the OCL-Editor: