Module is.codion.common.core
Package is.codion.common.value

Interface Value<T>

Type Parameters:
T - the type of the wrapped value
All Superinterfaces:
Consumer<T>, EventObserver<T>, Supplier<T>, ValueObserver<T>
All Known Subinterfaces:
ComponentValue<T,C>, PropertyValue<T>, State, ValueList<T>, Values<T,C>, ValueSet<T>
All Known Implementing Classes:
AbstractComponentValue, AbstractTextComponentValue, AbstractValue
public interface Value<T> extends ValueObserver<T>, Consumer<T>
An observable wrapper for a value. A factory for Value instances.
See Also:

  • Method Details

    • accept

      default void accept(T value)
      Sets the value. Note that change listener notifications depend on the Value.Notify policy associated with this value.
      Specified by:
      accept in interface Consumer<T>
      Parameters:
      value - the value
      Throws:
      IllegalArgumentException - in case the given value is invalid
      See Also:

    • set

      boolean set(T value)
      Sets the value. Note that change listener notifications depend on the Value.Notify policy associated with this value.
      Parameters:
      value - the value
      Returns:
      true if the underlying value changed
      Throws:
      IllegalArgumentException - in case the given value is invalid
      See Also:

    • clear

      void clear()
      Clears this value, by setting it to null or the null value in case this is a non-null value.

    • map

      default boolean map(Function<T,T> mapper)
      Sets a new value mapped from the current value. 
       
 Value<Integer> value = Value.value(0);

 // increment the value by one
 value.map(currentValue -> currentValue + 1);
      Parameters:
      mapper - maps from the current value to a new value
      Returns:
      true if the underlying value changed
      Throws:
      NullPointerException - in case mapper is null

    • mapNull

      default boolean mapNull(Supplier<T> supplier)
      Sets a new value in case the current value is null. 
       
 Value<Integer> value = Value.value(null);

 // replace null with 1
 value.mapNull(() -> 1);

 // has no effect since the value is non-null
 value.mapNull(() -> 2);
      Parameters:
      supplier - supplies the value to use as replacement for null
      Returns:
      true if the underlying value changed
      Throws:
      NullPointerException - in case supplier is null

    • observer

      ValueObserver<T> observer()
      Returns a ValueObserver notified each time this value changes.
      Returns:
      a ValueObserver for this value

    • link

      void link(Value<T> originalValue)
      Creates a bidirectional link between this and the given original value, so that changes in one are reflected in the other. Note that after a call to this method this value is the same as originalValue.
      Parameters:
      originalValue - the original value to link this value to
      Throws:
      IllegalStateException - in case the values are already linked
      IllegalArgumentException - in case the original value is not valid according to this values validators

    • unlink

      void unlink(Value<T> originalValue)
      Unlinks this value from the given original value
      Parameters:
      originalValue - the original value to unlink from this one
      Throws:
      IllegalStateException - in case the values are not linked

    • link

      void link(ValueObserver<T> originalValue)
      Creates a unidirectional link between this value and the given original value observer, so that changes in the original value are reflected in this one. Note that after a call to this method the value of this value is the same as the original value.
      Parameters:
      originalValue - the original value to link this value to
      Throws:
      IllegalArgumentException - in case the original value is not valid according to this values validators

    • unlink

      void unlink(ValueObserver<T> originalValue)
      Unlinks this value from the given original value observer
      Parameters:
      originalValue - the original value to unlink

    • addValidator

      boolean addValidator(Value.Validator<T> validator)
      Adds a validator to this Value. Adding the same validator again has no effect.
      Parameters:
      validator - the validator
      Returns:
      true if this value did not already contain the specified validator
      Throws:
      IllegalArgumentException - in case the current value is invalid according to the validator

    • removeValidator

      boolean removeValidator(Value.Validator<T> validator)
      Removes the given validator from this value
      Parameters:
      validator - the validator
      Returns:
      true if this value contained the specified validator

    • validate

      void validate(T value)
      Validate the given value using all validators
      Parameters:
      value - the value to validate
      Throws:
      IllegalArgumentException - in case the given value is invalid according to a validator

    • value

      static <T> Value<T> value()
      Creates a new Value instance, wrapping a null initial value, using Value.Notify.WHEN_CHANGED.
      Type Parameters:
      T - the value type
      Returns:
      a Value for the given type

    • nonNull

      static <T> Value.Builder<T,?> nonNull(T nullValue)
      Type Parameters:
      T - the value type
      Parameters:
      nullValue - the actual value to use when the value is set to null
      Returns:
      a builder for a non-null Value

    • nullable

      static <T> Value.Builder<T,?> nullable()
      Type Parameters:
      T - the value type
      Returns:
      a builder for a nullable Value

    • nullable

      static <T> Value.Builder<T,?> nullable(T initialValue)
      Type Parameters:
      T - the value type
      Parameters:
      initialValue - the initial value
      Returns:
      a builder for a nullable Value