Package com.vaadin.signals

Class MapSignal<T>

java.lang.Object
com.vaadin.signals.Signal<Map<String,ValueSignal<T>>>
com.vaadin.signals.MapSignal<T>
Type Parameters:
T - the element type
public class MapSignal<T> extends Signal<Map<String,ValueSignal<T>>>
A signal containing a map of values with string keys. Supports atomic updates to the map structure. Each value in the map is accessed as a separate ValueSignal instance which enables atomic updates to the value of that map entry.

  • Constructor Details

    • MapSignal

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

    • MapSignal

      protected MapSignal(SignalTree tree, Id id, Predicate<SignalCommand> validator, Class<T> elementType)
      Creates a new map 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 Map<String,ValueSignal<T>> extractValue(Node.Data data)
      Description copied from class: Signal
      Extracts the value for this signal from the given signal data node.
      Specified by:
      extractValue in class Signal<Map<String,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: Signal
      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 Signal.value() of this signal changes.

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

    • put

      public SignalOperation<T> put(String key, T value)
      Associates the given value with the given key. If an entry already exists for the given key, then that entry is updated. If no entry exists, then a new entry is created.

      The result of the returned operation will be resolved with the previous value at the time when this operation was confirmed. The previous value is null if no entry existed or if it existed with a null value.

      Note that this operation does not give direct access to the child signal that was created or updated. Use putIfAbsent(String, Object) for that purpose.

      Parameters:
      key - the key to use, not null
      value - the value to set
      Returns:
      an operation containing the eventual result

    • putIfAbsent

      public InsertOperation<ValueSignal<T>> putIfAbsent(String key, T value)
      Creates a new entry with the given value if an entry with the given key doesn't already exist. If an entry exists, then the given value is ignored. The returned operation has a reference to a signal that corresponds to the given key regardless of whether an entry existed for the key. The operation will be resolved as successful regardless of whether they key was already used.
      Parameters:
      key - the key to use, not null
      value - the value to set
      Returns:
      an operation containing a signal for the entry and the eventual result

    • remove

      public SignalOperation<T> remove(String key)
      Removes the mapping for the given key. The operation will be resolved as successful if a mapping existed and as a failure if there was no mapping. In case of a successful operation, the result value will be the value associated with the key when the operation was processed.
      Parameters:
      key - the key to use, not null
      Returns:
      an operation containing the eventual result

    • clear

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

    • verifyKey

      public SignalOperation<Void> verifyKey(String key, Signal<?> expectedChild)
      Checks that the given child is mapped to the given key in this map. 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 mapped to the given key in this map when the operation is processed.
      Parameters:
      key - the key to check, not null
      expectedChild - the expected child signal, not null
      Returns:
      an operation containing the eventual result

    • verifyHasKey

      public SignalOperation<Void> verifyHasKey(String key)
      Checks that there is a mapping for the given key in this map. 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 key has a mapping in this map when the operation is processed.
      Parameters:
      key - the key to check, not null
      Returns:
      an operation containing the eventual result

    • verifyKeyAbsent

      public SignalOperation<Void> verifyKeyAbsent(String key)
      Checks that there is no mapping for the given key in this map. 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 key has no mapping in this map when the operation is processed.
      Parameters:
      key - the key to check, not null
      Returns:
      an operation containing the eventual result

    • withValidator

      public MapSignal<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 map 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 map signal that uses the validator, not null

    • asReadonly

      public MapSignal<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 map signal, not null

    • asNode

      public NodeSignal asNode()
      Description copied from class: Signal
      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 Signal<Map<String,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