Package com.vaadin.flow.signals.shared

Class SharedNumberSignal

java.lang.Object
com.vaadin.flow.signals.shared.AbstractSignal<Double>
com.vaadin.flow.signals.shared.SharedValueSignal<Double>
com.vaadin.flow.signals.shared.SharedNumberSignal
All Implemented Interfaces:
Signal<Double>, Serializable
public class SharedNumberSignal extends SharedValueSignal<Double>
A signal containing a numeric value. The value is updated as a single atomic change. In addition to the regular SharedValueSignal operation, this class also supports atomically incrementing the value.
See Also:

  • Constructor Details

    • SharedNumberSignal

      public SharedNumberSignal()
      Creates a new number signal with a zero value. The signal does not support clustering.

    • SharedNumberSignal

      public SharedNumberSignal(double initialValue)
      Creates a new number signal with the given value. The signal does not support clustering.
      Parameters:
      initialValue - the initial value

    • SharedNumberSignal

      protected SharedNumberSignal(SignalTree tree, Id id, CommandValidator validator)
      Creates a new number signal instance with the given id and validator for the given signal tree.
      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

  • Method Details

    • incrementBy

      public SignalOperation<Double> incrementBy(double delta)
      Atomically increments the value of this signal by the given delta amount. The value is decremented if the delta is negative. The result of the returned operation will be resolved with the update value at the time when this operation was confirmed.
      Parameters:
      delta - the increment amount
      Returns:
      an operation containing the eventual result

    • get

      public Double get()
      Description copied from interface: Signal
      Gets the current value of this signal. The value is read in a way that takes the current transaction into account and in the case of clustering also changes that have been submitted to the cluster but not yet confirmed.

      If the signal implementation supports transactions, then reading the value in a regular (i.e. Transaction.Type.STAGED) transaction makes the transaction depend on the value so that the transaction fails in case the signal value is changed concurrently.

      Reading the value inside an Signal.unboundEffect(EffectAction) or Signal.computed(SignalComputation) callback sets up that effect or computed signal to depend on the signal.

      This method must only be called within a reactive context such as an effect, a computed signal, an explicit Signal.untracked(ValueSupplier) block, or a transaction. Calling it outside such a context throws an IllegalStateException. Use Signal.peek() for one-time reads that do not need dependency tracking.

      Specified by:
      get in interface Signal<Double>
      Overrides:
      get in class AbstractSignal<Double>
      Returns:
      the signal value

    • peek

      public Double peek()
      Description copied from interface: Signal
      Reads the value without setting up any dependencies. This method returns the same value as Signal.get() but without creating a dependency when used inside a transaction, effect or computed signal.

      Unlike Signal.get(), this method can be called outside a reactive context and is the recommended way to read a signal value for one-time use, such as logging, assertions, or initializing non-reactive UI.

      Specified by:
      peek in interface Signal<Double>
      Overrides:
      peek in class AbstractSignal<Double>
      Returns:
      the signal value

    • peekConfirmed

      public Double peekConfirmed()
      Description copied from class: AbstractSignal
      Reads the confirmed value without setting up any dependencies. The confirmed value doesn't consider changes in the current transaction or changes that have been submitted but not yet confirmed in a cluster.
      Overrides:
      peekConfirmed in class AbstractSignal<Double>
      Returns:
      the confirmed signal value

    • getAsInt

      public int getAsInt()
      Gets the value of this signal as an integer. This method works in the same way was get() with regards to transactions and dependency tracking.
      Returns:
      the signal value as an integer

    • set

      public SignalOperation<Double> set(int value)
      Sets the value of this signal as an integer. This method works in the same way was the regular value setter with regards to transactions.
      Parameters:
      value - the integer value to set
      Returns:
      an operation containing the eventual result

    • withValidator

      public SharedNumberSignal withValidator(CommandValidator validator)
      Wraps this signal with a validator. The validator is used to check all value changing commands issued through the new signal instance. If this signal has a validator, then the new signal will use both validators. Note that due to the way validators are retained by SharedValueSignal.asNode(), there's a possibility that the validator also receives commands that cannot be directly issued for a number signal.

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

      Overrides:
      withValidator in class SharedValueSignal<Double>
      Parameters:
      validator - the validator to use, not null
      Returns:
      a new number signal that uses the validator, not null

    • asReadonly

      public SharedNumberSignal asReadonly()
      Wraps this signal to not accept changes.

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

      Overrides:
      asReadonly in class SharedValueSignal<Double>
      Returns:
      the new readonly number signal, not null

    • mapIntValue

      public <C> Signal<C> mapIntValue(SerializableIntFunction<C> mapper)
      Creates a computed signal based on an integer mapper function that is passed the value of this signal. If the mapper function accesses other signal values, then the computed signal will also depend on those signals.
      Type Parameters:
      C - the computed signal type
      Parameters:
      mapper - the integer mapper function to use, not null
      Returns:
      the computed signal, not null

    • equals

      public boolean equals(Object obj)
      Overrides:
      equals in class SharedValueSignal<Double>

    • hashCode

      public int hashCode()
      Overrides:
      hashCode in class SharedValueSignal<Double>

    • toString

      public String toString()
      Overrides:
      toString in class SharedValueSignal<Double>