Package org.eclipse.core.databinding.observable.set

## Class AbstractObservableSet<E>

- java.lang.Object
- - org.eclipse.core.databinding.observable.AbstractObservable
  - - org.eclipse.core.databinding.observable.set.AbstractObservableSet<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>`

Direct Known Subclasses:
  `ComputedSet`

    public abstract class AbstractObservableSet<E>
    extends AbstractObservable
    implements IObservableSet<E>

Abstract implementation of `IObservableSet`.

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.

Since:
  1.0
Implementation Note:
  If methods are added to the interface which this class implements then implementations of those methods must be added to this class.

### Constructor Summary

Constructors
`protected` `AbstractObservableSet()`
`protected` `AbstractObservableSet​(Realm realm)`

### Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
`boolean` `add​(E o)`
`boolean` `addAll​(Collection<? extends E> c)`
`protected void` `addListener​(Object listenerType, IObservablesListener listener)`
`void` `addSetChangeListener​(ISetChangeListener<? super E> listener)`
`void` `clear()`
`protected Object` `clone()`
`boolean` `contains​(Object o)`
`boolean` `containsAll​(Collection<?> c)`
`boolean` `equals​(Object o)`
`protected void` `fireChange()`
`protected void` `fireEvent​(ObservableEvent event)`
`protected void` `fireSetChange​(SetDiff<E> diff)`
`protected void` `firstListenerAdded()`
`Realm` `getRealm()`
`protected void` `getterCalled()`
`protected abstract Set<E>` `getWrappedSet()`
`int` `hashCode()`
`protected boolean` `hasListeners()`
`boolean` `isEmpty()`
`boolean` `isStale()` Returns whether the state of this observable is stale and is expected to change soon.
`Iterator<E>` `iterator()`
`protected void` `lastListenerRemoved()`
`boolean` `remove​(Object o)`
`boolean` `removeAll​(Collection<?> c)`
`protected void` `removeListener​(Object listenerType, IObservablesListener listener)`
`void` `removeSetChangeListener​(ISetChangeListener<? super E> listener)`
`boolean` `retainAll​(Collection<?> c)`
`void` `setStale​(boolean stale)`
`int` `size()`
`Object[]` `toArray()`
`<T> T[]` `toArray​(T[] a)`
`String` `toString()`

### Methods inherited from class org.eclipse.core.databinding.observable.AbstractObservable

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

### Methods inherited from class java.lang.Object

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

### Methods inherited from interface java.util.Collection

`parallelStream, removeIf, stream, toArray`

### Methods inherited from interface org.eclipse.core.databinding.observable.IObservable

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

### Methods inherited from interface org.eclipse.core.databinding.observable.set.IObservableSet

`getElementType`

### Methods inherited from interface java.lang.Iterable

`forEach`

### Methods inherited from interface java.util.Set

`spliterator`

### Constructor Detail

#### AbstractObservableSet

    protected AbstractObservableSet()

#### AbstractObservableSet

    protected AbstractObservableSet​(Realm realm)

### Method Detail

#### addSetChangeListener

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

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

#### removeSetChangeListener

    public void removeSetChangeListener​(ISetChangeListener<? super E> listener)

Specified by:
  `removeSetChangeListener` in interface `IObservableSet<E>`
Parameters:
  `listener` - the change listener to remove; not `null`

#### getWrappedSet

    protected abstract Set<E> getWrappedSet()

#### fireSetChange

    protected void fireSetChange​(SetDiff<E> diff)

#### contains

    public boolean contains​(Object o)

Specified by:
  `contains` in interface `Collection<E>`
Specified by:
  `contains` in interface `IObservableSet<E>`
Specified by:
  `contains` in interface `Set<E>`

#### containsAll

    public boolean containsAll​(Collection<?> c)

Specified by:
  `containsAll` in interface `Collection<E>`
Specified by:
  `containsAll` in interface `IObservableSet<E>`
Specified by:
  `containsAll` in interface `Set<E>`

#### equals

    public boolean equals​(Object o)

Specified by:
  `equals` in interface `Collection<E>`
Specified by:
  `equals` in interface `IObservableSet<E>`
Specified by:
  `equals` in interface `Set<E>`
Overrides:
  `equals` in class `Object`

#### hashCode

    public int hashCode()

Specified by:
  `hashCode` in interface `Collection<E>`
Specified by:
  `hashCode` in interface `IObservableSet<E>`
Specified by:
  `hashCode` in interface `Set<E>`
Overrides:
  `hashCode` in class `Object`

#### isEmpty

    public boolean isEmpty()

Specified by:
  `isEmpty` in interface `Collection<E>`
Specified by:
  `isEmpty` in interface `IObservableSet<E>`
Specified by:
  `isEmpty` in interface `Set<E>`

#### iterator

    public Iterator<E> iterator()

Specified by:
  `iterator` in interface `Collection<E>`
Specified by:
  `iterator` in interface `IObservableSet<E>`
Specified by:
  `iterator` in interface `Iterable<E>`
Specified by:
  `iterator` in interface `Set<E>`

#### size

    public int size()

Specified by:
  `size` in interface `Collection<E>`
Specified by:
  `size` in interface `IObservableSet<E>`
Specified by:
  `size` in interface `Set<E>`

#### toArray

    public Object[] toArray()

Specified by:
  `toArray` in interface `Collection<E>`
Specified by:
  `toArray` in interface `IObservableSet<E>`
Specified by:
  `toArray` in interface `Set<E>`

#### toArray

    public <T> T[] toArray​(T[] a)

Specified by:
  `toArray` in interface `Collection<E>`
Specified by:
  `toArray` in interface `IObservableSet<E>`
Specified by:
  `toArray` in interface `Set<E>`

#### toString

    public String toString()

Overrides:
  `toString` in class `Object`

#### getterCalled

    protected void getterCalled()

#### add

    public boolean add​(E o)

Specified by:
  `add` in interface `Collection<E>`
Specified by:
  `add` in interface `IObservableSet<E>`
Specified by:
  `add` in interface `Set<E>`

#### addAll

    public boolean addAll​(Collection<? extends E> c)

Specified by:
  `addAll` in interface `Collection<E>`
Specified by:
  `addAll` in interface `IObservableSet<E>`
Specified by:
  `addAll` in interface `Set<E>`

#### remove

    public boolean remove​(Object o)

Specified by:
  `remove` in interface `Collection<E>`
Specified by:
  `remove` in interface `IObservableSet<E>`
Specified by:
  `remove` in interface `Set<E>`

#### removeAll

    public boolean removeAll​(Collection<?> c)

Specified by:
  `removeAll` in interface `Collection<E>`
Specified by:
  `removeAll` in interface `IObservableSet<E>`
Specified by:
  `removeAll` in interface `Set<E>`

#### retainAll

    public boolean retainAll​(Collection<?> c)

Specified by:
  `retainAll` in interface `Collection<E>`
Specified by:
  `retainAll` in interface `IObservableSet<E>`
Specified by:
  `retainAll` in interface `Set<E>`

#### clear

    public void clear()

Specified by:
  `clear` in interface `Collection<E>`
Specified by:
  `clear` in interface `Set<E>`

#### 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`
Returns:
  Returns the stale state.

#### setStale

    public void setStale​(boolean stale)

Parameters:
  `stale` - The stale state to set. This will fire a stale event if the given boolean is true and this observable set was not already stale.

#### fireChange

    protected void fireChange()

Overrides:
  `fireChange` 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`