Module is.codion.common.reactive
Package is.codion.common.reactive.observer

Interface Observer<T>

Type Parameters:
T - the type of data propagated to consumers
All Superinterfaces:
Sensor
All Known Subinterfaces:
CalendarPanel.CalendarDate, CalendarPanel.CalendarDateTime, CalendarPanel.CalendarZonedDateTime, ComponentValue<C,T>, EntityConditions.ConditionValue, EntityConditions.Modified, EntityEditor.EditorEntity, EntityEditor.EditorValue<T>, EntityEditor.Exists, EntityEditor.Modified, EntityEditor.Present, EntityTableTreeModel.UnreachableItems, FilterModel.ExcludedItems<T>, FilterModel.IncludedItems<T>, FilterModel.IncludePredicate<T>, FilterTableColumnModel.ColumnSelection.ColumnIndex, FilterTableColumnModel.HiddenColumns<C>, FilterTableColumnModel.VisibleColumns<C>, FilterTableSearchModel.Results, FilterTableSearchModel.Results.CurrentResult, FilterTreeModel.VisibleNodes<T>, ImagePane.ImageValue, MultiSelection.Indexes, MultiSelection.Items<R>, Observable<T>, ObservableState, ObservableValueCollection<T,C>, ObservableValueList<T>, ObservableValueSet<T>, PersistenceEvents.Deleted, PersistenceEvents.Inserted, PersistenceEvents.Updated, Signal<T>, State, Value<T>, ValueCollection<T,C>, ValueList<T>, ValueSet<T>
All Known Implementing Classes:
AbstractComponentValue, AbstractObserver, AbstractTextComponentValue, AbstractValue, PropertyValue
public interface Observer<T> extends Sensor
Manages consumers, notified with data each time something happens, along with the listeners of the Sensor it extends, all of them in the order they were added.

This interface provides default method implementations that delegate to observer(). There are two ways to implement this interface:

  • Extend AbstractObserver - provides concrete implementations where observer() returns this
  • Implement observer() to return a delegate - useful for wrapper types (see Observable for an example)

All implementations are thread-safe and support concurrent access.

See Also:

  • Method Details

    • addConsumer

      default boolean addConsumer(Consumer<? super T> consumer)
      Adds consumer to this Observer. Adding the same consumer a second time has no effect.
      Parameters:
      consumer - the consumer to add
      Returns:
      true if this observer did not already contain the specified consumer
      Throws:
      NullPointerException - in case consumer is null

    • removeConsumer

      default boolean removeConsumer(Consumer<? super T> consumer)
      Removes consumer from this Observer, whether it was added via addConsumer(Consumer) or addWeakConsumer(Consumer).
      Parameters:
      consumer - the consumer to remove
      Returns:
      true if this observer contained the specified consumer

    • addWeakConsumer

      default boolean addWeakConsumer(Consumer<? super T> consumer)
      Uses a WeakReference, adding consumer does not prevent it from being garbage collected. Adding the same consumer a second time has no effect.

      Note: Dead weak references accumulate until cleaned up, which happens automatically when listeners or consumers are added or removed. To trigger cleanup manually without modifying them, call removeWeakConsumer(Consumer) with any non-existing consumer: 

      // Clean up dead weak references
observer.removeWeakConsumer(data -> {});
      Parameters:
      consumer - the consumer
      Returns:
      true if this observer did not already contain the specified consumer

    • removeWeakConsumer

      default boolean removeWeakConsumer(Consumer<? super T> consumer)
      Removes consumer from this Observer, whether it was added via addConsumer(Consumer) or addWeakConsumer(Consumer).
      Parameters:
      consumer - the consumer to remove
      Returns:
      true if this observer contained the specified consumer

    • when

      default Observer<T> when(@Nullable T value)
      Returns a new conditional Observer notified when this observer instance is triggered with the given value

      The conditional observer subscribes to this one only while it has listeners or consumers of its own, attaching on the first and detaching on the last, so one that is never listened to - or whose listeners and consumers are all removed again - leaves nothing behind on this observer. Removing the last of them is therefore how a conditional observer is disposed of; there is nothing else to release.

      Parameters:
      value - the value on which to trigger the observer
      Returns:
      a new conditional Observer

    • when

      default Observer<T> when(Predicate<? super @Nullable T> predicate)
      Returns a new conditional Observer notified when this observer instance is triggered with a value satisfying the given predicate.

      The predicate is tested with each triggering value, including null, and must tolerate null input.

      Subscribes to this observer only while it has listeners or consumers of its own, see when(Object).

      Parameters:
      predicate - the predicate on which to trigger the observer
      Returns:
      a new conditional Observer

    • observer

      Observer<T> observer()
      Returns the underlying Observer to which listener and consumer operations are delegated.

      For AbstractObserver subclasses this method returns this. For wrapper types, this returns the delegate observer.

      Returns:
      the Observer handling listener and consumer management

    • sensor

      default Sensor sensor()
      An observer is its own sensor, via observer().
      Specified by:
      sensor in interface Sensor
      Returns:
      the Sensor handling listener management, this observer's observer()