Package: groovy.util

## [Java] Class ObservableSet<E>

- groovy.util.ObservableSet

- All Implemented Interfaces and Traits:
    Set

      public class ObservableSet<E>
      extends Object
      implements Set

  Set decorator that will trigger PropertyChangeEvents when a value changes.
  An optional Closure may be specified and will work as a filter, if it returns true the property will trigger an event (if the value indeed changed), otherwise it won't. The Closure may receive 1 or 2 parameters, the single one being the value, the other one both the key and value, for example:

       // skip all properties whose value is a closure
       def set = new ObservableSet( {!(it instanceof Closure)} )
       <p/>
       // skip all properties whose name matches a regex
       def set = new ObservableSet( { name, value -> !(name =˜ /[A-Z+]/) } )

  The current implementation will trigger specialized events in the following scenarios, you need not register a different listener as those events extend from PropertyChangeEvent
  - ObservableSet.ElementAddedEvent - a new element is added to the set
  - ObservableSet.ElementRemovedEvent - an element is removed from the set
  - ObservableSet.ElementUpdatedEvent - an element changes value (same as regular PropertyChangeEvent)
  - ObservableSet.ElementClearedEvent - all elements have been removed from the list
  - ObservableSet.MultiElementAddedEvent - triggered by calling set.addAll()
  - ObservableSet.MultiElementRemovedEvent - triggered by calling set.removeAll()/set.retainAll()

  Bound properties

  - `content` - read-only.
  - `size` - read-only.

- - ### Nested Class Summary

    Nested classes
    Modifiers | Name | Description
    --- | --- | ---
    `enum` | `ObservableSet.ChangeType` | Enumerates the specialized set change events.
    `static class` | `ObservableSet.ElementAddedEvent` | Event fired when one element is added.
    `static class` | `ObservableSet.ElementClearedEvent` | Event fired when the set is cleared.
    `static class` | `ObservableSet.ElementEvent` | Base event type for observable set content changes.
    `static class` | `ObservableSet.ElementRemovedEvent` | Event fired when one element is removed.
    `static class` | `ObservableSet.MultiElementAddedEvent` | Event fired when multiple elements are added.
    `static class` | `ObservableSet.MultiElementRemovedEvent` | Event fired when multiple elements are removed.
    `protected class` | `ObservableSet.ObservableIterator` | Iterator wrapper that reports removals as observable set events.

  - ### Field Summary

    Fields
    Modifiers | Name | Description
    --- | --- | ---
    `static String` | `CONTENT_PROPERTY` | Bound property name for set content changes.
    `static String` | `SIZE_PROPERTY` | Bound property name for set size changes.

  - ### Constructor Summary

    Constructors
    Constructor and description
    `ObservableSet()` Creates an observable set backed by a HashSet.
    `ObservableSet(Set<E> delegate)` Creates an observable set backed by the supplied delegate.
    `ObservableSet(Closure test)` Creates an observable set backed by a HashSet.
    `ObservableSet(Set<E> delegate, Closure test)` Creates an observable set backed by the supplied delegate.

  - ### Methods Summary

    Methods
    Type Params | Return Type | Name and description
    --- | --- | ---
    `` | `public boolean` | `add(E e)` Adds the specified element to this set if it is not already present (optional operation). More formally, adds the specified element `e` to this set if the set contains no element `e2` such that `Objects.equals(e, e2)`. If this set already contains the element, the call leaves the set unchanged and returns `false`. In combination with the restriction on constructors, this ensures that sets never contain duplicate elements. The stipulation above does not imply that sets must accept all elements; sets may refuse to add any particular element, including `null`, and throw an exception, as described in the specification for Collection.add. Individual set implementations should clearly document any restrictions on the elements that they may contain. throws: UnsupportedOperationException if the `add` operation is not supported by this set throws: ClassCastException if the class of the specified element prevents it from being added to this set throws: NullPointerException if the specified element is null and this set does not permit null elements throws: IllegalArgumentException if some property of the specified element prevents it from being added to this set Parameters: `e` - element to be added to this set Returns: `true` if this set did not already contain the specified element
    `` | `public boolean` | `addAll(Collection<? extends E> c)` Adds all of the elements in the specified collection to this set if they're not already present (optional operation). If the specified collection is also a set, the `addAll` operation effectively modifies this set so that its value is the union of the two sets. The behavior of this operation is undefined if the specified collection is modified while the operation is in progress. throws: UnsupportedOperationException if the `addAll` operation is not supported by this set throws: ClassCastException if the class of an element of the specified collection prevents it from being added to this set throws: NullPointerException if the specified collection contains one or more null elements and this set does not permit null elements, or if the specified collection is null throws: IllegalArgumentException if some property of an element of the specified collection prevents it from being added to this set Parameters: `c` - collection containing elements to be added to this set Returns: `true` if this set changed as a result of the call See Also: add(Object)
    `` | `public void` | `addPropertyChangeListener(PropertyChangeListener listener)` Registers a listener for all observable set events.
    `` | `public void` | `addPropertyChangeListener(String propertyName, PropertyChangeListener listener)` Registers a listener for a named bound property.
    `` | `public void` | `clear()` Removes all of the elements from this set (optional operation). The set will be empty after this call returns. throws: UnsupportedOperationException if the `clear` method is not supported by this set
    `` | `public boolean` | `contains(Object o)` Returns `true` if this set contains the specified element. More formally, returns `true` if and only if this set contains an element `e` such that `Objects.equals(o, e)`. throws: ClassCastException if the type of the specified element is incompatible with this set (optional) throws: NullPointerException if the specified element is null and this set does not permit null elements (optional) Parameters: `o` - element whose presence in this set is to be tested Returns: `true` if this set contains the specified element
    `` | `public boolean` | `containsAll(Collection<?> objects)` Returns `true` if this set contains all of the elements of the specified collection. If the specified collection is also a set, this method returns `true` if it is a subset of this set. throws: ClassCastException if the types of one or more elements in the specified collection are incompatible with this set (optional) throws: NullPointerException if the specified collection contains one or more null elements and this set does not permit null elements (optional), or if the specified collection is null Parameters: `c` - collection to be checked for containment in this set Returns: `true` if this set contains all of the elements of the specified collection See Also: contains(Object)
    `` | `protected void` | `fireElementAddedEvent(Object element)` Fires a single-element added event.
    `` | `protected void` | `fireElementClearedEvent(List values)` Fires a cleared event containing removed values.
    `` | `protected void` | `fireElementEvent(ObservableSet.ElementEvent event)` Publishes an element event to registered listeners.
    `` | `protected void` | `fireElementRemovedEvent(Object element)` Fires a single-element removed event.
    `` | `protected void` | `fireMultiElementAddedEvent(List values)` Fires a multi-element added event.
    `` | `protected void` | `fireMultiElementRemovedEvent(List values)` Fires a multi-element removed event.
    `` | `protected void` | `fireSizeChangedEvent(int oldValue, int newValue)` Fires the bound size change event.
    `` | `public Set<E>` | `getContent()` Returns an unmodifiable snapshot view of the backing set.
    `` | `protected Set<E>` | `getDelegateSet()` Returns the mutable backing set.
    `` | `public PropertyChangeListener[]` | `getPropertyChangeListeners()` Returns listeners registered for all properties.
    `` | `public PropertyChangeListener[]` | `getPropertyChangeListeners(String propertyName)` Returns listeners registered for a named property.
    `` | `protected Closure` | `getTest()` Returns the optional event filter closure.
    `` | `public boolean` | `hasListeners(String propertyName)` Reports whether listeners are registered for a named property.
    `` | `public boolean` | `isEmpty()` Returns `true` if this set contains no elements. Returns: `true` if this set contains no elements
    `` | `public Iterator<E>` | `iterator()` Returns an iterator over the elements in this set. The elements are returned in no particular order (unless this set is an instance of some class that provides a guarantee). Returns: an iterator over the elements in this set
    `` | `public boolean` | `remove(Object o)` Removes the specified element from this set if it is present (optional operation). More formally, removes an element `e` such that `Objects.equals(o, e)`, if this set contains such an element. Returns `true` if this set contained the element (or equivalently, if this set changed as a result of the call). (This set will not contain the element once the call returns.) throws: ClassCastException if the type of the specified element is incompatible with this set (optional) throws: NullPointerException if the specified element is null and this set does not permit null elements (optional) throws: UnsupportedOperationException if the `remove` operation is not supported by this set Parameters: `o` - object to be removed from this set, if present Returns: `true` if this set contained the specified element
    `` | `public boolean` | `removeAll(Collection<?> c)` Removes from this set all of its elements that are contained in the specified collection (optional operation). If the specified collection is also a set, this operation effectively modifies this set so that its value is the asymmetric set difference of the two sets. throws: UnsupportedOperationException if the `removeAll` operation is not supported by this set throws: ClassCastException if the class of an element of this set is incompatible with the specified collection (optional) throws: NullPointerException if this set contains a null element and the specified collection does not permit null elements (optional), or if the specified collection is null Parameters: `c` - collection containing elements to be removed from this set Returns: `true` if this set changed as a result of the call See Also: remove(Object) contains(Object)
    `` | `public void` | `removePropertyChangeListener(PropertyChangeListener listener)` Removes a listener registered for all properties.
    `` | `public void` | `removePropertyChangeListener(String propertyName, PropertyChangeListener listener)` Removes a listener registered for a named property.
    `` | `public boolean` | `retainAll(Collection<?> c)` Retains only the elements in this set that are contained in the specified collection (optional operation). In other words, removes from this set all of its elements that are not contained in the specified collection. If the specified collection is also a set, this operation effectively modifies this set so that its value is the intersection of the two sets. throws: UnsupportedOperationException if the `retainAll` operation is not supported by this set throws: ClassCastException if the class of an element of this set is incompatible with the specified collection (optional) throws: NullPointerException if this set contains a null element and the specified collection does not permit null elements (optional), or if the specified collection is null Parameters: `c` - collection containing elements to be retained in this set Returns: `true` if this set changed as a result of the call See Also: remove(Object)
    `` | `public int` | `size()` Returns the number of elements in this set (its cardinality). If this set contains more than `Integer.MAX_VALUE` elements, returns `Integer.MAX_VALUE`. Returns: the number of elements in this set (its cardinality)
    `` | `public Object[]` | `toArray()` Returns an array containing all of the elements in this set. If this set makes any guarantees as to what order its elements are returned by its iterator, this method must return the elements in the same order. The returned array will be "safe" in that no references to it are maintained by this set. (In other words, this method must allocate a new array even if this set is backed by an array). The caller is thus free to modify the returned array. This method acts as bridge between array-based and collection-based APIs. Returns: an array containing all the elements in this set
    `<T>` | `public T[]` | `toArray(T[] ts)` Returns an array containing all of the elements in this set; the runtime type of the returned array is that of the specified array. If the set fits in the specified array, it is returned therein. Otherwise, a new array is allocated with the runtime type of the specified array and the size of this set. If this set fits in the specified array with room to spare (i.e., the array has more elements than this set), the element in the array immediately following the end of the set is set to `null`. (This is useful in determining the length of this set only if the caller knows that this set does not contain any null elements.) If this set makes any guarantees as to what order its elements are returned by its iterator, this method must return the elements in the same order. Like the toArray() method, this method acts as bridge between array-based and collection-based APIs. Further, this method allows precise control over the runtime type of the output array, and may, under certain circumstances, be used to save allocation costs. Suppose `x` is a set known to contain only strings. The following code can be used to dump the set into a newly allocated array of `String`:
            String[] y = x.toArray(new String[0]);
    Note that `toArray(new Object[0])` is identical in function to `toArray()`. throws: ArrayStoreException if the runtime type of the specified array is not a supertype of the runtime type of every element in this set throws: NullPointerException if the specified array is null Parameters: `a` - the array into which the elements of this set are to be stored, if it is big enough; otherwise, a new array of the same runtime type is allocated for this purpose. Returns: an array containing all the elements in this set

  - ### Inherited Methods Summary

    Inherited Methods
    Methods inherited from class | Name
    --- | ---
    `class Object` | `equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### public static final String CONTENT_PROPERTY

      Bound property name for set content changes.

    - #### public static final String SIZE_PROPERTY

      Bound property name for set size changes.

  - ### Constructor Detail

    - #### public ObservableSet()

      Creates an observable set backed by a HashSet.

    - #### public ObservableSet(Set<E> delegate)

      Creates an observable set backed by the supplied delegate.

      Parameters:
        `delegate` - the backing set

    - #### public ObservableSet(Closure test)

      Creates an observable set backed by a HashSet.

      Parameters:
        `test` - optional event filter

    - #### public ObservableSet(Set<E> delegate, Closure test)

      Creates an observable set backed by the supplied delegate.

      Parameters:
        `delegate` - the backing set
        `test` - optional event filter

  - ### Method Detail

    - #### public boolean add(E e)

      Adds the specified element to this set if it is not already present (optional operation). More formally, adds the specified element `e` to this set if the set contains no element `e2` such that `Objects.equals(e, e2)`. If this set already contains the element, the call leaves the set unchanged and returns `false`. In combination with the restriction on constructors, this ensures that sets never contain duplicate elements.

      The stipulation above does not imply that sets must accept all elements; sets may refuse to add any particular element, including `null`, and throw an exception, as described in the specification for Collection.add. Individual set implementations should clearly document any restrictions on the elements that they may contain.

      throws:
        UnsupportedOperationException if the `add` operation is not supported by this set
      throws:
        ClassCastException if the class of the specified element prevents it from being added to this set
      throws:
        NullPointerException if the specified element is null and this set does not permit null elements
      throws:
        IllegalArgumentException if some property of the specified element prevents it from being added to this set
      Parameters:
        `e` - element to be added to this set
      Returns:
        `true` if this set did not already contain the specified element

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

      Adds all of the elements in the specified collection to this set if they're not already present (optional operation). If the specified collection is also a set, the `addAll` operation effectively modifies this set so that its value is the union of the two sets. The behavior of this operation is undefined if the specified collection is modified while the operation is in progress.

      throws:
        UnsupportedOperationException if the `addAll` operation is not supported by this set
      throws:
        ClassCastException if the class of an element of the specified collection prevents it from being added to this set
      throws:
        NullPointerException if the specified collection contains one or more null elements and this set does not permit null elements, or if the specified collection is null
      throws:
        IllegalArgumentException if some property of an element of the specified collection prevents it from being added to this set
      Parameters:
        `c` - collection containing elements to be added to this set
      Returns:
        `true` if this set changed as a result of the call
      See Also:
        add(Object)

    - #### public void addPropertyChangeListener(PropertyChangeListener listener)

      Registers a listener for all observable set events.

      Parameters:
        `listener` - the listener to add

    - #### public void addPropertyChangeListener(String propertyName, PropertyChangeListener listener)

      Registers a listener for a named bound property.

      Parameters:
        `propertyName` - the property to observe
        `listener` - the listener to add

    - #### public void clear()

      Removes all of the elements from this set (optional operation). The set will be empty after this call returns.

      throws:
        UnsupportedOperationException if the `clear` method is not supported by this set

    - #### public boolean contains(Object o)

      Returns `true` if this set contains the specified element. More formally, returns `true` if and only if this set contains an element `e` such that `Objects.equals(o, e)`.

      throws:
        ClassCastException if the type of the specified element is incompatible with this set (optional)
      throws:
        NullPointerException if the specified element is null and this set does not permit null elements (optional)
      Parameters:
        `o` - element whose presence in this set is to be tested
      Returns:
        `true` if this set contains the specified element

    - #### public boolean containsAll(Collection<?> objects)

      Returns `true` if this set contains all of the elements of the specified collection. If the specified collection is also a set, this method returns `true` if it is a subset of this set.

      throws:
        ClassCastException if the types of one or more elements in the specified collection are incompatible with this set (optional)
      throws:
        NullPointerException if the specified collection contains one or more null elements and this set does not permit null elements (optional), or if the specified collection is null
      Parameters:
        `c` - collection to be checked for containment in this set
      Returns:
        `true` if this set contains all of the elements of the specified collection
      See Also:
        contains(Object)

    - #### protected void fireElementAddedEvent(Object element)

      Fires a single-element added event.

    - #### protected void fireElementClearedEvent(List values)

      Fires a cleared event containing removed values.

    - #### protected void fireElementEvent(ObservableSet.ElementEvent event)

      Publishes an element event to registered listeners.

    - #### protected void fireElementRemovedEvent(Object element)

      Fires a single-element removed event.

    - #### protected void fireMultiElementAddedEvent(List values)

      Fires a multi-element added event.

    - #### protected void fireMultiElementRemovedEvent(List values)

      Fires a multi-element removed event.

    - #### protected void fireSizeChangedEvent(int oldValue, int newValue)

      Fires the bound size change event.

    - #### public Set<E> getContent()

      Returns an unmodifiable snapshot view of the backing set.

      Returns:
        the set content

    - #### protected Set<E> getDelegateSet()

      Returns the mutable backing set.

      Returns:
        the delegate set

    - #### public PropertyChangeListener[] getPropertyChangeListeners()

      Returns listeners registered for all properties.

      Returns:
        the registered listeners

    - #### public PropertyChangeListener[] getPropertyChangeListeners(String propertyName)

      Returns listeners registered for a named property.

      Parameters:
        `propertyName` - the observed property name
      Returns:
        the registered listeners

    - #### protected Closure getTest()

      Returns the optional event filter closure.

      Returns:
        the event filter, or `null`

    - #### public boolean hasListeners(String propertyName)

      Reports whether listeners are registered for a named property.

      Parameters:
        `propertyName` - the property name to inspect
      Returns:
        `true` if listeners are registered

    - #### public boolean isEmpty()

      Returns `true` if this set contains no elements.

      Returns:
        `true` if this set contains no elements

    - #### public Iterator<E> iterator()

      Returns an iterator over the elements in this set. The elements are returned in no particular order (unless this set is an instance of some class that provides a guarantee).

      Returns:
        an iterator over the elements in this set

    - #### public boolean remove(Object o)

      Removes the specified element from this set if it is present (optional operation). More formally, removes an element `e` such that `Objects.equals(o, e)`, if this set contains such an element. Returns `true` if this set contained the element (or equivalently, if this set changed as a result of the call). (This set will not contain the element once the call returns.)

      throws:
        ClassCastException if the type of the specified element is incompatible with this set (optional)
      throws:
        NullPointerException if the specified element is null and this set does not permit null elements (optional)
      throws:
        UnsupportedOperationException if the `remove` operation is not supported by this set
      Parameters:
        `o` - object to be removed from this set, if present
      Returns:
        `true` if this set contained the specified element

    - #### public boolean removeAll(Collection<?> c)

      Removes from this set all of its elements that are contained in the specified collection (optional operation). If the specified collection is also a set, this operation effectively modifies this set so that its value is the asymmetric set difference of the two sets.

      throws:
        UnsupportedOperationException if the `removeAll` operation is not supported by this set
      throws:
        ClassCastException if the class of an element of this set is incompatible with the specified collection (optional)
      throws:
        NullPointerException if this set contains a null element and the specified collection does not permit null elements (optional), or if the specified collection is null
      Parameters:
        `c` - collection containing elements to be removed from this set
      Returns:
        `true` if this set changed as a result of the call
      See Also:
        remove(Object)
        contains(Object)

    - #### public void removePropertyChangeListener(PropertyChangeListener listener)

      Removes a listener registered for all properties.

      Parameters:
        `listener` - the listener to remove

    - #### public void removePropertyChangeListener(String propertyName, PropertyChangeListener listener)

      Removes a listener registered for a named property.

      Parameters:
        `propertyName` - the observed property name
        `listener` - the listener to remove

    - #### public boolean retainAll(Collection<?> c)

      Retains only the elements in this set that are contained in the specified collection (optional operation). In other words, removes from this set all of its elements that are not contained in the specified collection. If the specified collection is also a set, this operation effectively modifies this set so that its value is the intersection of the two sets.

      throws:
        UnsupportedOperationException if the `retainAll` operation is not supported by this set
      throws:
        ClassCastException if the class of an element of this set is incompatible with the specified collection (optional)
      throws:
        NullPointerException if this set contains a null element and the specified collection does not permit null elements (optional), or if the specified collection is null
      Parameters:
        `c` - collection containing elements to be retained in this set
      Returns:
        `true` if this set changed as a result of the call
      See Also:
        remove(Object)

    - #### public int size()

      Returns the number of elements in this set (its cardinality). If this set contains more than `Integer.MAX_VALUE` elements, returns `Integer.MAX_VALUE`.

      Returns:
        the number of elements in this set (its cardinality)

    - #### public Object[] toArray()

      Returns an array containing all of the elements in this set. If this set makes any guarantees as to what order its elements are returned by its iterator, this method must return the elements in the same order.

      The returned array will be "safe" in that no references to it are maintained by this set. (In other words, this method must allocate a new array even if this set is backed by an array). The caller is thus free to modify the returned array.

      This method acts as bridge between array-based and collection-based APIs.

      Returns:
        an array containing all the elements in this set

    - #### <T> public T[] toArray(T[] ts)

      Returns an array containing all of the elements in this set; the runtime type of the returned array is that of the specified array. If the set fits in the specified array, it is returned therein. Otherwise, a new array is allocated with the runtime type of the specified array and the size of this set.

      If this set fits in the specified array with room to spare (i.e., the array has more elements than this set), the element in the array immediately following the end of the set is set to `null`. (This is useful in determining the length of this set only if the caller knows that this set does not contain any null elements.)

      If this set makes any guarantees as to what order its elements are returned by its iterator, this method must return the elements in the same order.

      Like the toArray() method, this method acts as bridge between array-based and collection-based APIs. Further, this method allows precise control over the runtime type of the output array, and may, under certain circumstances, be used to save allocation costs.

      Suppose `x` is a set known to contain only strings. The following code can be used to dump the set into a newly allocated array of `String`:

              String[] y = x.toArray(new String[0]);

      Note that `toArray(new Object[0])` is identical in function to `toArray()`.
      throws:
        ArrayStoreException if the runtime type of the specified array is not a supertype of the runtime type of every element in this set
      throws:
        NullPointerException if the specified array is null
      Parameters:
        `a` - the array into which the elements of this set are to be stored, if it is big enough; otherwise, a new array of the same runtime type is allocated for this purpose.
      Returns:
        an array containing all the elements in this set