org.eclipse.ocl.util
Class CollectionUtil

java.lang.Object
  extended by org.eclipse.ocl.util.CollectionUtil

public class CollectionUtil
extends Object

Utility methods for working with OCL collection values.


Method Summary
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 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
<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
<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
clone, equals, finalize, 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

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

Parameters:
self - the source collection
Returns:
the flattened collection

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

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

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

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

at

public static <E> E at(Collection<E> self,
                       int index)
Implementation of the OCL 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

first

public static <E> E first(Collection<E> self)
Implementation of the OCL 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 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 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

Copyright 2002, 2007 IBM Corporation and others.
All Rights Reserved.