CollectionUtil

java.lang.Object
- org.eclipse.ocl.util.CollectionUtil

```
public class CollectionUtil
extends Object
```
Utility methods for working with OCL collection values.

Author:

Christian W. Damus (cdamus)

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static <E> Collection<E>`	`append(Collection<E> self, E object)` Implementation of the OCL `OrderedSet::append(object : T) : OrderedSet(T)` `Sequence::append(object : T) : Sequence(T)` operations.
`static <E> Bag<E>`	`asBag(Collection<E> self)` Implementation of the OCL `Set::asBag() : Bag(T)` `Bag::asBag() : Bag(T)` `Sequence::asBag() : Bag(T)` operations.
`static <E> LinkedHashSet<E>`	`asOrderedSet(Collection<E> self)` Implementation of the OCL `Set::asOrderedSet() : OrderedSet(T)` `Bag::asOrderedSet() : OrderedSet(T)` `Sequence::asOrderedSet() : OrderedSet(T)` operations.
`static <E> List<E>`	`asSequence(Collection<E> self)` Implementation of the OCL `Set::asSequence() : Sequence(T)` `Bag::asSequence() : Sequence(T)` `Sequence::asSequence() : Sequence(T)` operations.
`static <E> Set<E>`	`asSet(Collection<E> self)` Implementation of the OCL `Set::asSet() : Set(T)` `Bag::asSet() : Set(T)` `Sequence::asSet() : Set(T)` operations.
`static <E> E`	`at(Collection<E> self, int index)` Implementation of the OCL `OrderedSet::at(index : Integer) : T` `Sequence::at(index : Integer) : T` operations.
`static int`	`count(Collection<?> self, Object object)` Implementation of the OCL `Collection::count(object : T) : Integer` operation.
`static <E> Bag<E>`	`createNewBag()` Creates a new OCL `Bag`.
`static <E> Bag<E>`	`createNewBag(Collection<? extends E> c)` Creates a new OCL `Bag` with initial contents supplied.
`static <E> Collection<E>`	`createNewCollection(Collection<? extends E> c)` Creates a new OCL collection of the same kind and contents as the specified prototype.
`static <E> Collection<E>`	`createNewCollection(CollectionKind kind)` Creates a new OCL `Collection` of the specified kind.
`static <E> Collection<E>`	`createNewCollection(CollectionKind kind, Collection<E> c)` Creates a new OCL `Collection` of the specified kind.
`static <E> Collection<E>`	`createNewCollectionOfSameKind(Collection<?> c)` Creates a new, empty OCL collection of the same kind as the specified prototype.
`static <E> LinkedHashSet<E>`	`createNewOrderedSet()` Creates a new OCL `OrderedSet`.
`static <E> LinkedHashSet<E>`	`createNewOrderedSet(Collection<? extends E> c)` Creates a new OCL `OrderedSet` with initial contents supplied.
`static <E> List<E>`	`createNewSequence()` Creates a new OCL `Sequence`.
`static <E> List<E>`	`createNewSequence(Collection<? extends E> c)` Creates a new OCL `Sequence` with initial contents supplied.
`static <E> Set<E>`	`createNewSet()` Creates a new OCL `Set`.
`static <E> Set<E>`	`createNewSet(Collection<? extends E> c)` Creates a new OCL `Set` with initial contents supplied.
`static boolean`	`equals(Collection<?> self, Collection<?> c)` Implementation of the OCL `Set::=(set : Set(T)) : Boolean` `OrderedSet::=(set : OrderedSet(T)) : Boolean` `Bag::=(bag : Bag(T)) : Boolean` `Sequence::=(s : Sequence(T)) : Boolean` operations.
`static boolean`	`excludes(Collection<?> self, Object object)` Implementation of the OCL `Collection::excludes(object : T) : Boolean` operation.
`static boolean`	`excludesAll(Collection<?> self, Collection<?> c)` Implementation of the OCL `Collection::excludesAll(c : Collection(T)) : Boolean` operation.
`static <E> Collection<E>`	`excluding(Collection<E> self, Object object)` Implementation of the OCL `Set::excluding(object : T) : Set(T)` `Bag::excluding(object : T) : Bag(T)` `Sequence::excluding(object : T) : Sequence(T)` operations.
`static <E> E`	`first(Collection<E> self)` Implementation of the OCL `OrderedSet::first() : T` `Sequence::first() : T` operations.
`static Collection<?>`	`flatten(Collection<?> self)` Implementation of the OCL `Set::flatten() : Set(T2)` `Bag::flatten() : Bag(T2)` `Sequence::flatten() : Sequence(T2)` operations.
`static <C> C`	`getFlattenedElementType(CollectionType<C,?> type)` Obtains the type of the flattened form of the specified collection type.
`static int`	`hashCode(Collection<?> c)` Computes the hash of a collection, accounting for the similar hashing of primitive numeric values that OCL considers equal but Java does not.
`static boolean`	`includes(Collection<?> self, Object object)` Implementation of the OCL `Collection::includes(object : T) : Boolean` operation.
`static boolean`	`includesAll(Collection<?> self, Collection<?> c)` Implementation of the OCL `Collection::includesAll(c : Collection(T)) : Boolean` operation.
`static <E> Collection<E>`	`including(Collection<E> self, E object)` Implementation of the OCL `Set::including(object : T) : Set(T)` `Bag::including(object : T) : Bag(T)` `Sequence::including(object : T) : Sequence(T)` operations.
`static <E> Integer`	`indexOf(Collection<? extends E> self, E object)` Implementation of the OCL `OrderedSet::indexOf(object : T) : Integer` `Sequence::indexOf(object : T) : Integer` operations.
`static <E> Collection<E>`	`insertAt(Collection<E> self, int index, E object)` Implementation of the OCL `OrderedSet::insertAt(index : Integer, object : T) : OrderedSet(T)` `Sequence::insertAt(index : Integer, object : T) : Sequence(T)` operations.
`static <E> Collection<E>`	`intersection(Collection<? extends E> self, Collection<? extends E> c)` Implementation of the OCL `Set::intersection(set : Set(T)) : Set(T)` `Set::intersection(bag : Bag(T)) : Set(T)` `Bag::intersection(set : Set(T)) : Set(T)` `Bag::intersection(bag : Bag(T)) : Set(T)` operations.
`static boolean`	`isEmpty(Collection<?> self)` Implementation of the OCL `Collection::isEmpty() : Boolean` operation.
`static <E> E`	`last(Collection<E> self)` Implementation of the OCL `OrderedSet::lset() : T` `Sequence::lset() : T` operations.
`static Object`	`max(Collection<?> self)` Implementation of the OCL `Collection::max() : T` operation.
`static Object`	`min(Collection<?> self)` Implementation of the OCL `Collection::min() : T` operation.
`static <E> Set<E>`	`minus(Set<? extends E> self, Set<? extends E> set)` Implementation of the OCL `Set::-(set : Set(T)) : Set(T)` operation.
`static boolean`	`notEmpty(Collection<?> self)` Implementation of the OCL `Collection::notEmpty() : Boolean` operation.
`static <E> Collection<E>`	`prepend(Collection<E> self, E object)` Implementation of the OCL `OrderedSet::prepend(object : T) : OrderedSet(T)` `Sequence::prepend(object : T) : Sequence(T)` operations.
`static <PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> Set<Tuple<O,P>>`	`product(EvaluationEnvironment<C,O,P,CLS,E> evalEnv, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, Collection<?> self, Collection<?> c, C tupleType)` Implementation of the OCL `Collection::product(c : Collection(T2)) : Set(Tuple(first : T, second : T2))` operations.
`static <E> Collection<E>`	`subOrderedSet(Collection<E> self, int lower, int upper)` Implementation of the OCL `OrderedSet::subOrderedSet(lower : Integer, upper : Integer) : OrderedSet(T)` operation.
`static <E> Collection<E>`	`subSequence(Collection<E> self, int lower, int upper)` Implementation of the OCL `Sequence::subSequence(lower : Integer, upper : Integer) : Sequence(T)` operation.
`static Object`	`sum(Collection<?> self)` Implementation of the OCL `Collection::sum() : T` operation.
`static <E> Set<E>`	`symmetricDifference(Set<? extends E> self, Set<? extends E> set)` Implementation of the OCL `Set::symmetricDifference(set : Set(T)) : Set(T)` operation.
`static String`	`toString(Collection<?> c)` Computes the string representation of a collection value using syntax like OCL's collection literals (e.g., `OrderedSet{...}`) instead of Java's default (i.e., `[...]`).
`static <E> Collection<E>`	`union(Collection<? extends E> self, Collection<? extends E> c)` Implementation of the OCL `Set::union(set : Set(T)) : Set(T)` `Set::union(bag : Bag(T)) : Bag(T)` `Bag::union(set : Set(T)) : Bag(T)` `Bag::union(bag : Bag(T)) : Bag(T)` `Sequence::union(s : Sequence(T)) : Sequence(T)` operations.

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - includes
```
public static boolean includes(Collection<?> self,
                               Object object)
```
    Implementation of the OCL Collection::includes(object : T) : Boolean operation.
    
    Parameters:
    
    self - the source collection
    
    object - an object
    
    Returns:
    
    whether the collection includes the object
  - excludes
```
public static boolean excludes(Collection<?> self,
                               Object object)
```
    Implementation of the OCL Collection::excludes(object : T) : Boolean operation.
    
    Parameters:
    
    self - the source collection
    
    object - an object
    
    Returns:
    
    whether the collection does not include the object
  - count
```
public static int count(Collection<?> self,
                        Object object)
```
    Implementation of the OCL Collection::count(object : T) : Integer operation.
    
    Parameters:
    
    self - the source collection
    
    object - an object
    
    Returns:
    
    the number of occurrences of the object in the collection
  - includesAll
```
public static boolean includesAll(Collection<?> self,
                                  Collection<?> c)
```
    Implementation of the OCL Collection::includesAll(c : Collection(T)) : Boolean operation.
    
    Parameters:
    
    self - the source collection
    
    c - another collection
    
    Returns:
    
    whether the source collection includes all of the elements of the other
  - excludesAll
```
public static boolean excludesAll(Collection<?> self,
                                  Collection<?> c)
```
    Implementation of the OCL Collection::excludesAll(c : Collection(T)) : Boolean operation.
    
    Parameters:
    
    self - the source collection
    
    c - another collection
    
    Returns:
    
    whether the source collection does not contain any of the elements of the other
  - isEmpty
```
public static boolean isEmpty(Collection<?> self)
```
    Implementation of the OCL Collection::isEmpty() : Boolean operation.
    
    Parameters:
    
    self - the source collection
    
    Returns:
    
    whether the collection does not have any elements
  - max
```
public static Object max(Collection<?> self)
```
    Implementation of the OCL Collection::max() : T operation.
    
    Parameters:
    
    self - the source collection
    
    Returns:
    
    the largest of the collection's elements
    
    Since:
    
    3.2
  - min
```
public static Object min(Collection<?> self)
```
    Implementation of the OCL Collection::min() : T operation.
    
    Parameters:
    
    self - the source collection
    
    Returns:
    
    the smallest of the collection's elements
    
    Since:
    
    3.2
  - notEmpty
```
public static boolean notEmpty(Collection<?> self)
```
    Implementation of the OCL Collection::notEmpty() : Boolean operation.
    
    Parameters:
    
    self - the source collection
    
    Returns:
    
    whether the collection has any elements
  - sum
```
public static Object sum(Collection<?> self)
```
    Implementation of the OCL Collection::sum() : T operation.
    
    Parameters:
    
    self - the source collection
    
    Returns:
    
    the sum of the collection's elements
  - equals
```
public static boolean equals(Collection<?> self,
                             Collection<?> c)
```
    Implementation of the OCL
    - Set::=(set : Set(T)) : Boolean
    - OrderedSet::=(set : OrderedSet(T)) : Boolean
    - Bag::=(bag : Bag(T)) : Boolean
    - Sequence::=(s : Sequence(T)) : Boolean
    operations.
    Parameters:
    
    self - the source collection
    
    c - another collection of the same kind
    
    Returns:
    
    whether collections are equal
  - hashCode
```
public static int hashCode(Collection<?> c)
```
    Computes the hash of a collection, accounting for the similar hashing of primitive numeric values that OCL considers equal but Java does not.
    
    Parameters:
    
    c - a collection
    
    Returns:
    
    its hash
  - intersection
```
public static <E> Collection<E> intersection(Collection<? extends E> self,
                                             Collection<? extends E> c)
```
    Implementation of the OCL
    - Set::intersection(set : Set(T)) : Set(T)
    - Set::intersection(bag : Bag(T)) : Set(T)
    - Bag::intersection(set : Set(T)) : Set(T)
    - Bag::intersection(bag : Bag(T)) : Set(T)
    operations.
    Parameters:
    
    self - the source set or bag
    
    c - another set or bag
    
    Returns:
    
    the intersection of the source set or bag with the other set or bag
  - union
```
public static <E> Collection<E> union(Collection<? extends E> self,
                                      Collection<? extends E> c)
```
    Implementation of the OCL
    - Set::union(set : Set(T)) : Set(T)
    - Set::union(bag : Bag(T)) : Bag(T)
    - Bag::union(set : Set(T)) : Bag(T)
    - Bag::union(bag : Bag(T)) : Bag(T)
    - Sequence::union(s : Sequence(T)) : Sequence(T)
    operations.
    Parameters:
    
    self - the source collection
    
    c - another collection
    
    Returns:
    
    the union of the source collection with the other
  - flatten
```
public static Collection<?> flatten(Collection<?> self)
```
    Implementation of the OCL
    - Set::flatten() : Set(T2)
    - Bag::flatten() : Bag(T2)
    - Sequence::flatten() : Sequence(T2)
    operations.
    Parameters:
    
    self - the source collection
    
    Returns:
    
    the flattened collection
  - getFlattenedElementType
```
public static <C> C getFlattenedElementType(CollectionType<C,?> type)
```
    Obtains the type of the flattened form of the specified collection type.
    
    Parameters:
    
    type - a collection type
    
    Returns:
    
    the flattened collection type
    
    Since:
    
    1.2
  - minus
```
public static <E> Set<E> minus(Set<? extends E> self,
                               Set<? extends E> set)
```
    Implementation of the OCL Set::-(set : Set(T)) : Set(T) operation.
    
    Parameters:
    
    self - the source set
    
    set - another set
    
    Returns:
    
    the subtraction of the other set from the source set
  - excluding
```
public static <E> Collection<E> excluding(Collection<E> self,
                                          Object object)
```
    Implementation of the OCL
    - Set::excluding(object : T) : Set(T)
    - Bag::excluding(object : T) : Bag(T)
    - Sequence::excluding(object : T) : Sequence(T)
    operations.
    Parameters:
    
    self - the source collection
    
    object - an object
    
    Returns:
    
    the source collection without any occurences of the object
  - symmetricDifference
```
public static <E> Set<E> symmetricDifference(Set<? extends E> self,
                                             Set<? extends E> set)
```
    Implementation of the OCL Set::symmetricDifference(set : Set(T)) : Set(T) operation.
    
    Parameters:
    
    self - the source set
    
    set - another set
    
    Returns:
    
    the set of elements in either the source or the other set but not in both
  - including
```
public static <E> Collection<E> including(Collection<E> self,
                                          E object)
```
    Implementation of the OCL
    - Set::including(object : T) : Set(T)
    - Bag::including(object : T) : Bag(T)
    - Sequence::including(object : T) : Sequence(T)
    operations.
    Parameters:
    
    self - the source collection
    
    object - an object
    
    Returns:
    
    the source collection with the object added
  - asSet
```
public static <E> Set<E> asSet(Collection<E> self)
```
    Implementation of the OCL
    - Set::asSet() : Set(T)
    - Bag::asSet() : Set(T)
    - Sequence::asSet() : Set(T)
    operations.
    Parameters:
    
    self - the source collection
    
    Returns:
    
    the source collection as a set
  - asBag
```
public static <E> Bag<E> asBag(Collection<E> self)
```
    Implementation of the OCL
    - Set::asBag() : Bag(T)
    - Bag::asBag() : Bag(T)
    - Sequence::asBag() : Bag(T)
    operations.
    Parameters:
    
    self - the source collection
    
    Returns:
    
    the source collection as a bag
  - asSequence
```
public static <E> List<E> asSequence(Collection<E> self)
```
    Implementation of the OCL
    - Set::asSequence() : Sequence(T)
    - Bag::asSequence() : Sequence(T)
    - Sequence::asSequence() : Sequence(T)
    operations.
    Parameters:
    
    self - the source collection
    
    Returns:
    
    the source collection as a sequence
  - asOrderedSet
```
public static <E> LinkedHashSet<E> asOrderedSet(Collection<E> self)
```
    Implementation of the OCL
    - Set::asOrderedSet() : OrderedSet(T)
    - Bag::asOrderedSet() : OrderedSet(T)
    - Sequence::asOrderedSet() : OrderedSet(T)
    operations.
    Parameters:
    
    self - the source collection
    
    Returns:
    
    the source collection as an ordered set
  - product
```
public static <PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> Set<Tuple<O,P>> product(EvaluationEnvironment<C,O,P,CLS,E> evalEnv,
                                                                          Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                                                                          Collection<?> self,
                                                                          Collection<?> c,
                                                                          C tupleType)
```
    Implementation of the OCL Collection::product(c : Collection(T2)) : Set(Tuple(first : T, second : T2)) operations.
    
    Parameters:
    
    evalEnv - the current evaluation environment (for construction of tuples)
    
    env - the current OCL environment (for introspection of the tuple type)
    
    self - the source collection
    
    c - another collection
    
    Returns:
    
    the product of the collections
  - append
```
public static <E> Collection<E> append(Collection<E> self,
                                       E object)
```
    Implementation of the OCL
    - OrderedSet::append(object : T) : OrderedSet(T)
    - Sequence::append(object : T) : Sequence(T)
    operations.
    Parameters:
    
    self - the source collection
    
    object - an object
    
    Returns:
    
    the source collection with the object appended
  - prepend
```
public static <E> Collection<E> prepend(Collection<E> self,
                                        E object)
```
    Implementation of the OCL
    - OrderedSet::prepend(object : T) : OrderedSet(T)
    - Sequence::prepend(object : T) : Sequence(T)
    operations.
    Parameters:
    
    self - the source collection
    
    object - an object
    
    Returns:
    
    the source collection with the object prepended
  - insertAt
```
public static <E> Collection<E> insertAt(Collection<E> self,
                                         int index,
                                         E object)
```
    Implementation of the OCL
    - OrderedSet::insertAt(index : Integer, object : T) : OrderedSet(T)
    - Sequence::insertAt(index : Integer, object : T) : Sequence(T)
    operations.
    Parameters:
    
    self - the source collection
    
    index - the 1-based (in OCL fashion) index
    
    object - an object
    
    Returns:
    
    the source collection with the object inserted at the index
    
    Throws:
    
    IndexOutOfBoundsException - if the index is out of bounds
  - subOrderedSet
```
public static <E> Collection<E> subOrderedSet(Collection<E> self,
                                              int lower,
                                              int upper)
```
    Implementation of the OCL OrderedSet::subOrderedSet(lower : Integer, upper : Integer) : OrderedSet(T) operation.
    
    Parameters:
    
    self - the source set
    
    lower - the 1-based (in OCL fashion) inclusive lower bound
    
    upper - the 1-based (in OCL fashion) inclusive upper bound
    
    Returns:
    
    the slice of the source set
    
    Throws:
    
    IndexOutOfBoundsException - if an index is out of bounds
    
    IllegalArgumentException - if the lower bound is greater than the upper
  - subSequence
```
public static <E> Collection<E> subSequence(Collection<E> self,
                                            int lower,
                                            int upper)
```
    Implementation of the OCL Sequence::subSequence(lower : Integer, upper : Integer) : Sequence(T)

Parameters:: self - the source sequence; lower - the 1-based (in OCL fashion) inclusive lower bound; upper - the 1-based (in OCL fashion) inclusive upper bound
Returns:: the source collection with the object inserted at the index
Throws:: IndexOutOfBoundsException - if an index is out of bounds; IllegalArgumentException - if the lower bound is greater than the upper

at
```
public static <E> E at(Collection<E> self,
                       int index)
```
Implementation of the OCL
- OrderedSet::at(index : Integer) : T
- Sequence::at(index : Integer) : T
operations.
Parameters:

self - the source collection

index - the 1-based (in OCL fashion) index

Returns:

the object at the specified index of the source collection

Throws:

IndexOutOfBoundsException - if the index is out of bounds

first
```
public static <E> E first(Collection<E> self)
```
Implementation of the OCL
- OrderedSet::first() : T
- Sequence::first() : T
operations.
Parameters:

self - the source collection

Returns:

the first object of the source collection

last
```
public static <E> E last(Collection<E> self)
```
Implementation of the OCL
- OrderedSet::lset() : T
- Sequence::lset() : T
operations.
Parameters:

self - the source collection

Returns:

the last object in the source collection

indexOf
```
public static <E> Integer indexOf(Collection<? extends E> self,
                                  E object)
```
Implementation of the OCL
- OrderedSet::indexOf(object : T) : Integer
- Sequence::indexOf(object : T) : Integer
operations.
Parameters:

self - the source collection

object - an object

Returns:

the index of the object in the source collection

createNewSet

public static <E> Set<E> createNewSet()

Creates a new OCL Set.

createNewSet

public static <E> Set<E> createNewSet(Collection<? extends E> c)

Creates a new OCL Set with initial contents supplied.

createNewBag

public static <E> Bag<E> createNewBag()

Creates a new OCL Bag.

createNewBag

public static <E> Bag<E> createNewBag(Collection<? extends E> c)

Creates a new OCL Bag with initial contents supplied.

createNewOrderedSet

public static <E> LinkedHashSet<E> createNewOrderedSet()

Creates a new OCL OrderedSet.

createNewOrderedSet

public static <E> LinkedHashSet<E> createNewOrderedSet(Collection<? extends E> c)

Creates a new OCL OrderedSet with initial contents supplied.

createNewSequence

public static <E> List<E> createNewSequence()

Creates a new OCL Sequence.

createNewSequence

public static <E> List<E> createNewSequence(Collection<? extends E> c)

Creates a new OCL Sequence with initial contents supplied.

createNewCollectionOfSameKind
```
public static <E> Collection<E> createNewCollectionOfSameKind(Collection<?> c)
```
Creates a new, empty OCL collection of the same kind as the specified prototype.

Parameters:

c - a collection

Returns:

a new, empty collection of the same kind as c

createNewCollection
```
public static <E> Collection<E> createNewCollection(Collection<? extends E> c)
```
Creates a new OCL collection of the same kind and contents as the specified prototype.

Parameters:

c - a collection

Returns:

a copy of c

createNewCollection
```
public static <E> Collection<E> createNewCollection(CollectionKind kind)
```
Creates a new OCL Collection of the specified kind.

Parameters:

kind - the OCL collection kind

Returns:

the new collection

createNewCollection
```
public static <E> Collection<E> createNewCollection(CollectionKind kind,
                                                    Collection<E> c)
```
Creates a new OCL Collection of the specified kind.

Parameters:

kind - the OCL collection kind

c - the contents of the new collection

Returns:

the new collection of the specified kind, containing the same elements as c

toString
```
public static String toString(Collection<?> c)
```
Computes the string representation of a collection value using syntax like OCL's collection literals (e.g., OrderedSet{...}) instead of Java's default (i.e., [...]).

Parameters:

c - a collection (not null)

Returns:

the string representation of the specified collection

Since:

1.2

Class CollectionUtil

Method Summary

Methods inherited from class java.lang.Object

Method Detail

includes

excludes

count

includesAll

excludesAll

isEmpty

max

min

notEmpty

sum

equals

hashCode

intersection

union

flatten

getFlattenedElementType

minus

excluding

symmetricDifference

including

asSet

asBag

asSequence

asOrderedSet

product

append

prepend

insertAt

subOrderedSet

subSequence

at

first

last

indexOf

createNewSet

createNewSet

createNewBag

createNewBag

createNewOrderedSet

createNewOrderedSet

createNewSequence

createNewSequence

createNewCollectionOfSameKind

createNewCollection

createNewCollection

createNewCollection

toString