Package com.vaadin.signals

Class ListSignal<T>

java.lang.Object
com.vaadin.signals.AbstractSignal<List<ValueSignal<T>>>
com.vaadin.signals.ListSignal<T>
Type Parameters:
T - the element type
All Implemented Interfaces:
Signal<List<ValueSignal<T>>>
public class ListSignal<T> extends AbstractSignal<List<ValueSignal<T>>>
A signal containing a list of values. Supports atomic updates to the list structure. Each value in the list is accessed as a separate ValueSignal instance which enables atomic updates to the value of that list entry.

  • Constructor Details

    • ListSignal

      public ListSignal(Class<T> elementType)
      Creates a new list signal with the given element type. The signal does not support clustering.
      Parameters:
      elementType - the element type, not null

    • ListSignal

      protected ListSignal(SignalTree tree, Id id, Predicate<SignalCommand> validator, Class<T> elementType)
      Creates a new list signal instance with the given id and validator for the given signal tree with the given element type.
      Parameters:
      tree - the signal tree that contains the value for this signal, not null
      id - the id of the signal node within the signal tree, not null
      validator - the validator to check operations submitted to this singal, not null
      elementType - the element type, not null

  • Method Details

    • extractValue

      protected List<ValueSignal<T>> extractValue(Node.Data data)
      Description copied from class: AbstractSignal
      Extracts the value for this signal from the given signal data node.
      Specified by:
      extractValue in class AbstractSignal<List<ValueSignal<T>>>
      Parameters:
      data - the data node to extract the value from, or null if the node doesn't exist in the tree
      Returns:
      the signal value

    • usageChangeValue

      protected Object usageChangeValue(Node.Data data)
      Description copied from class: AbstractSignal
      Gets a reference value that will be used to determine whether a dependency based on previous usage should be invalidated. This is done by getting one reference value when the dependency occurs and then comparing that to the current value to determine if the value has changed.

      The implementation should return an object that changes if and only if the AbstractSignal.value() of this signal changes.

      Specified by:
      usageChangeValue in class AbstractSignal<List<ValueSignal<T>>>
      Parameters:
      data - the data node to read from, not null
      Returns:
      a reference value to use for validity checks, may be null

    • insertFirst

      public InsertOperation<ValueSignal<T>> insertFirst(T value)
      Inserts a value as the first entry in this list.
      Parameters:
      value - the value to insert
      Returns:
      an operation containing a signal for the inserted entry and the eventual result

    • insertLast

      public InsertOperation<ValueSignal<T>> insertLast(T value)
      Inserts a value as the last entry in this list.
      Parameters:
      value - the value to insert
      Returns:
      an operation containing a signal for the inserted entry and the eventual result

    • insertAt

      public InsertOperation<ValueSignal<T>> insertAt(T value, ListSignal.ListPosition at)
      Inserts a value at the given position in this list. The operation fails if the position is not valid at the time when the operation is processed.
      Parameters:
      value - the value to insert
      at - the insert position, not null
      Returns:
      an operation containing a signal for the inserted entry and the eventual result

    • moveTo

      public SignalOperation<Void> moveTo(AbstractSignal<T> child, ListSignal.ListPosition to)
      Moves the given child signal to the given position in this list. The operation fails if the child is not a child or if this list of if position is not valid at the time when the operation is processed.
      Parameters:
      child - the child signal to move, not null
      to - the position to move to, not null
      Returns:
      an operation containing the eventual result

    • remove

      public SignalOperation<Void> remove(ValueSignal<T> child)
      Removes the given child from this list. The operation fails if the child is not a child of this list at the time when the operation is processed.
      Parameters:
      child - the child to remove, not null
      Returns:
      an operation containing the eventual result

    • clear

      public SignalOperation<Void> clear()
      Removes all children from this list. Note that is this list shares data with a NodeSignal that has map children, then the map children will also be removed.
      Overrides:
      clear in class AbstractSignal<List<ValueSignal<T>>>
      Returns:
      an operation containing the eventual result

    • verifyPosition

      public SignalOperation<Void> verifyPosition(AbstractSignal<?> child, ListSignal.ListPosition expectedPosition)
      Checks that the given child is at the given position in this list. This operation is only meaningful to use as a condition in a transaction. The result of the returned operation will be resolved as successful if the given child is a child of this list and at the given position when the operation is processed.
      Parameters:
      child - the child to test, not null
      expectedPosition - the expected position of the child, not null
      Returns:
      an operation containing the eventual result

    • verifyChild

      public SignalOperation<Void> verifyChild(AbstractSignal<?> child)
      Checks that the given signal is a child in this list. This operation is only meaningful to use as a condition in a transaction. The result of the returned operation will be resolved as successful if the given child is a child of this list and at the given position when the operation is processed.
      Parameters:
      child - the child to look for test, not null
      Returns:
      an operation containing the eventual result

    • withValidator

      public ListSignal<T> withValidator(Predicate<SignalCommand> validator)
      Wraps this signal with a validator. The validator is used to check all value changing commands issued through the new signal instance and all child signals. If this signal has a validator, then the new signal will use both validators. Note that due to the way validators are retained by asNode(), there's a possibility that the validator also receives commands that cannot be directly issued for a list signal or its children.

      This signal will keep its current configuration and changes applied through this instance will be visible through the wrapped instance.

      Parameters:
      validator - the validator to use, not null
      Returns:
      a new list signal that uses the validator, not null

    • asReadonly

      public ListSignal<T> asReadonly()
      Wraps this signal to not accept changes. Child value signals retrieved through the wrapped signal will also not accept changes.

      This signal will keep its current configuration and changes applied through this instance will be visible through the wrapped instance.

      Returns:
      the new readonly list signal, not null

    • asNode

      public NodeSignal asNode()
      Description copied from class: AbstractSignal
      Converts this signal into a node signal. This allows further conversion into any specific signal type through the methods in NodeSignal. The converted signal is backed by the same underlying data and uses the same validator as this signal.
      Overrides:
      asNode in class AbstractSignal<List<ValueSignal<T>>>
      Returns:
      this signal as a node signal, not null

    • equals

      public boolean equals(Object obj)
      Overrides:
      equals in class Object

    • hashCode

      public int hashCode()
      Overrides:
      hashCode in class Object

    • toString

      public String toString()
      Overrides:
      toString in class Object