Package com.vaadin.signals.shared

Class SharedNumberSignal

java.lang.Object
com.vaadin.signals.shared.AbstractSignal<Double>
com.vaadin.signals.shared.SharedValueSignal<Double>
com.vaadin.signals.shared.SharedNumberSignal
All Implemented Interfaces:
Signal<Double>, WritableSignal<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

    • value

      public Double value()
      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.effect(EffectAction) or Signal.computed(SignalComputation) callback sets up that effect or computed signal to depend on the signal.

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

    • valueAsInt

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

    • value

      public SignalOperation<Double> value(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.

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

    • mapIntValue

      public <C> Signal<C> mapIntValue(IntFunction<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>