# Class ComputedSet<E>

java.lang.Object
org.eclipse.core.databinding.observable.AbstractObservable
org.eclipse.core.databinding.observable.set.AbstractObservableSet<E>
org.eclipse.core.databinding.observable.set.ComputedSet<E>

Type Parameters:
  `E` - the type of the elements in this set

All Implemented Interfaces:
  `Iterable<E>, Collection<E>, Set<E>, IObservable, IObservableCollection<E>, IObservableSet<E>`

public abstract class ComputedSet<E> extends AbstractObservableSet<E>
A lazily calculated set that automatically computes and registers listeners on its dependencies as long as all of its dependencies are `IObservable` objects. Any change to one of the observable dependencies causes the set to be recomputed.

This class is thread safe. All state accessing methods must be invoked from the `current realm`. Methods for adding and removing listeners may be invoked from any thread.

Example: compute the set of all primes greater than 1 and less than the value of an `IObservableValue` < `Integer` >.

    final IObservableValue max = WritableValue.withValueType(Integer.TYPE);
    max.setValue(Integer.valueOf(0));
    IObservableSet primes = new ComputedSet() {
            protected Set calculate() {
                    int maxVal = ((Integer) max.getValue()).intValue();

                    Set result = new HashSet();
                    outer: for (int i = 2; i < maxVal; i++) {
                            for (Iterator it = result.iterator(); it.hasNext();) {
                                    Integer knownPrime = (Integer) it.next();
                                    if (i % knownPrime.intValue() == 0)
                                            continue outer;
                            }
                            result.add(Integer.valueOf(i));
                    }
                    return result;
            }
    };

    System.out.println(primes); // => "[]"

    max.setValue(Integer.valueOf(20));
    System.out.println(primes); // => "[2, 3, 5, 7, 11, 13, 17, 19]"

Since:
  1.2

## Constructor Summary

Constructors
Constructor
Description
`ComputedSet()`
Creates a computed set in the default realm and with an unknown (null) element type.
`ComputedSet(Object elementType)`
Creates a computed set in the default realm and with the given element type.
`ComputedSet(Realm realm)`
Creates a computed set in given realm and with an unknown (null) element type.
`ComputedSet(Realm realm, Object elementType)`
Creates a computed set in the given realm and with the given element type.

## Method Summary

Modifier and Type
Method
Description
`void`
`addChangeListener(IChangeListener listener)`
Adds the given change listener to the list of change listeners.
`protected void`
`addListener(Object listenerType, IObservablesListener listener)`
`void`
`addSetChangeListener(ISetChangeListener<? super E> listener)`
`protected abstract Set<E>`
`calculate()`
Subclasses must override this method to calculate the set contents.
`protected Object`
`clone()`
`static <E> IObservableSet<E>`
`create(Supplier<Set<E>> supplier)`
Factory method to create `ComputedSet` objects in an easy manner.
`void`
`dispose()`
Disposes of this observable object, removing all listeners registered with this object, and all listeners this object might have registered on other objects.
`protected int`
`doGetSize()`
`protected void`
`fireEvent(ObservableEvent event)`
`protected void`
`firstListenerAdded()`
`Object`
`getElementType()`
Returns the element type of this observable collection, or `null` if this observable collection is untyped.
`Realm`
`getRealm()`
`protected Set<E>`
`getWrappedSet()`
`protected boolean`
`hasListeners()`
`boolean`
`isStale()`
Returns whether the state of this observable is stale and is expected to change soon.
`protected void`
`lastListenerRemoved()`
`protected void`
`removeListener(Object listenerType, IObservablesListener listener)`

### Methods inherited from class AbstractObservableSet

`add, addAll, clear, contains, containsAll, equals, fireChange, fireSetChange, getterCalled, hashCode, isEmpty, iterator, remove, removeAll, removeSetChangeListener, retainAll, setStale, size, toArray, toArray, toString`

### Methods inherited from class AbstractObservable

`addDisposeListener, addStaleListener, checkRealm, fireStale, isDisposed, removeChangeListener, removeDisposeListener, removeStaleListener`

### Methods inherited from class Object

`finalize, getClass, notify, notifyAll, wait, wait, wait`

### Methods inherited from interface Collection

`parallelStream, removeIf, stream, toArray`

### Methods inherited from interface IObservable

`addDisposeListener, addStaleListener, getRealm, isDisposed, removeChangeListener, removeDisposeListener, removeStaleListener`

### Methods inherited from interface Iterable

`forEach`

### Methods inherited from interface Set

`spliterator`

## Constructor Details

### ComputedSet

public ComputedSet()
Creates a computed set in the default realm and with an unknown (null) element type.

### ComputedSet

public ComputedSet(Object elementType)
Creates a computed set in the default realm and with the given element type.

Parameters:
  `elementType` - the element type, may be `null` to indicate unknown element type

### ComputedSet

public ComputedSet(Realm realm)
Creates a computed set in given realm and with an unknown (null) element type.

Parameters:
  `realm` - the realm

### ComputedSet

public ComputedSet(Realm realm, Object elementType)
Creates a computed set in the given realm and with the given element type.

Parameters:
  `realm` - the realm
  `elementType` - the element type, may be `null` to indicate unknown element type

## Method Details

### create

public static <E> IObservableSet<E> create(Supplier<Set<E>> supplier)
Factory method to create `ComputedSet` objects in an easy manner.

The created list has a null `IObservableSet.getElementType()`.

Parameters:
  `supplier` - `Supplier`, which is tracked using `ObservableTracker` to find out observables it uses, in the same manner as `calculate()`.
Returns:
  `ComputedSet` whose elements are computed using the given `Supplier`.
Since:
  1.12

### doGetSize

protected int doGetSize()

### getWrappedSet

protected Set<E> getWrappedSet()

Specified by:
  `getWrappedSet` in class `AbstractObservableSet<E>`

### calculate

protected abstract Set<E> calculate()
Subclasses must override this method to calculate the set contents. Any dependencies used to calculate the set must be `IObservable`, and implementers must use one of the interface methods tagged TrackedGetter for ComputedSet to recognize it as a dependency.

Returns:
  the object's set.

### isStale

public boolean isStale()
Description copied from interface: `IObservable`
Returns whether the state of this observable is stale and is expected to change soon. A non-stale observable that becomes stale will notify its stale listeners. A stale object that becomes non-stale does so by changing its state and notifying its change listeners, it does not notify its stale listeners about becoming non-stale. Clients that do not expect asynchronous changes may ignore staleness of observable objects.

Specified by:
  `isStale` in interface `IObservable`
Overrides:
  `isStale` in class `AbstractObservableSet<E>`
Returns:
  Returns the stale state.

### getElementType

public Object getElementType()
Description copied from interface: `IObservableCollection`
Returns the element type of this observable collection, or `null` if this observable collection is untyped.

Returns:
  the element type or `null` if untyped

### addChangeListener

public void addChangeListener(IChangeListener listener)
Description copied from interface: `IObservable`
Adds the given change listener to the list of change listeners. Change listeners are notified about changes of the state of this observable in a generic way, without specifying the change that happened. To get the changed state, a change listener needs to query for the current state of this observable.

Specified by:
  `addChangeListener` in interface `IObservable`
Overrides:
  `addChangeListener` in class `AbstractObservable`
Parameters:
  `listener` - the listener to add; not `null`

### addSetChangeListener

public void addSetChangeListener(ISetChangeListener<? super E> listener)

Specified by:
  `addSetChangeListener` in interface `IObservableSet<E>`
Overrides:
  `addSetChangeListener` in class `AbstractObservableSet<E>`
Parameters:
  `listener` - the change listener to add; not `null`

### dispose

public void dispose()
Description copied from interface: `IObservable`
Disposes of this observable object, removing all listeners registered with this object, and all listeners this object might have registered on other objects.

Specified by:
  `dispose` in interface `IObservable`
Overrides:
  `dispose` in class `AbstractObservable`

### addListener

protected void addListener(Object listenerType, IObservablesListener listener)

Parameters:
  `listenerType` - arbitrary object to identify a type of the listener
  `listener` - the listener to add; not `null`

### removeListener

protected void removeListener(Object listenerType, IObservablesListener listener)

Parameters:
  `listenerType` - arbitrary object to identify a type of the listener
  `listener` - the listener to remove; not `null`

### hasListeners

protected boolean hasListeners()

### fireEvent

protected void fireEvent(ObservableEvent event)

### firstListenerAdded

protected void firstListenerAdded()

### lastListenerRemoved

protected void lastListenerRemoved()

### getRealm

public Realm getRealm()

Returns:
  Returns the realm.

### clone

protected Object clone() throws CloneNotSupportedException

Overrides:
  `clone` in class `Object`
Throws:
  `CloneNotSupportedException`