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>, Observer<T>, ValueObserver<T>
All Known Subinterfaces:
ComponentValue<T,C>, EntityEditModel.EditableValue<T>, 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.

Nullable integer based Value:

 
 Value<Integer> integer = Value.value();
 integer.set(42);
 integer.addConsumer(this::onValueChange);
 integer.nullable(); // true

Non-null String based Value, using "none" as a null substitute:

 
 Value<String> string = Value.builder()
         .nonNull("none")
         .value("hello")
         .notify(Notify.WHEN_SET)
         .validator(this::validateString)
         .listener(this::onStringSet)
         .build();
 string.nullable();// false
 string.set("hey");
 string.set(null); // reverts to the null substitute: "none"

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

    • 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 or if a cycle is detected
      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<? super 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<? super 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 nullable 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

    • value

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

    • builder

      static Value.BuilderFactory builder()
      Returns:
      a new Value.BuilderFactory instance