Class ReactiveVariable<T>

Method Details

• equality

  public boolean equality()

  Returns true if this ReactiveVariable performs full equality check on assignment. This method merely returns what was last passed to equality(boolean). Defaults to true.

  Returns:

  true if full equality check is enabled, false if reference equality is used

  See Also:

  • equality(boolean)
  • ReactiveValue.equals(Object)
  • ReactiveValue.same(ReactiveValue)

• equality

  public ReactiveVariable<T> equality(boolean equality)

  Configures full or reference equality. When this ReactiveVariable is assigned, dependent reactive computations are notified about the change if there is any. In order to check whether the stored value has changed, ReactiveVariable can either perform full equality check via ReactiveValue.equals(Object) or simple reference equality check via ReactiveValue.same(ReactiveValue). This method can be used to configure which equality test is used. Default is to do full equality check.

  This method should be called before the ReactiveVariable is used for the first time.

  Parameters:

  equality - true to do full equality check, false to test only reference equality

  Returns:

  this (fluent method)

  See Also:

  • equality()
  • ReactiveValue.equals(Object)
  • ReactiveValue.same(ReactiveValue)

• version

  public long version()

  Returns current version of this ReactiveVariable. Every ReactiveVariable has an associated version number, which is incremented after every change. Initial version is 1. Version number does not change if there was no actual change as determined by equality() setting. Reading the version number with this method does not create reactive dependency on the ReactiveVariable.

  Returns:

  current version of this ReactiveVariable

  See Also:

  • ReactiveVariable.Version

• value

  public ReactiveValue<T> value()

  Reads the current ReactiveValue from this ReactiveVariable and sets up reactive dependency.

  This ReactiveVariable is recorded as a dependency in current ReactiveScope (as identified by ReactiveScope.current(). If there is no current ReactiveScope, no dependency is recorded and this method just returns the ReactiveValue.

  ReactiveValue's ReactiveValue.get() is not called, so reactive blocking and exception, if any, are not propagated. They are left encapsulated in the returned ReactiveValue. Call get() if propagation of reactive blocking and exceptions is desirable.

  Returns:

  current ReactiveValue of this ReactiveVariable, never null

  See Also:

  • get()
  • value(ReactiveValue)

• value

  public void value(ReactiveValue<T> value)

  Sets current ReactiveValue of this ReactiveVariable and notifies dependent reactive computations. This is the more general version of set(Object) that allows setting arbitrary ReactiveValue.

  The value may have ReactiveValue.blocking() flag set and it may contain ReactiveValue.exception(). This is useful in situations when ReactiveVariable is used as a bridge between hookless-based code and event-driven code. The event-driven code may signal that it is not yet ready by setting its ReactiveVariable to a blocking value. It may also communicate exceptions reactively by wrapping them in ReactiveValue and storing it in ReactiveVariable.

  If current ReactiveValue is actually changed as determined by equality() setting, version() is incremented and dependent reactive computations (the ones that accessed value() or get()) are notified about the change. If there is no actual change (new value compares equal to the old value per equality() setting), then the state of this ReactiveVariable does not change, old ReactiveValue is kept, version() remains the same, and no change notifications are sent.

  Parameters:

  value - new ReactiveValue to store in this ReactiveVariable

  Throws:

  NullPointerException - if value is null

  See Also:

  • set(Object)
  • value()

• hashCode

  public int hashCode()

  Returns identity hash code. This implementation is semantically identical to Object.hashCode(). It is just a little faster in order to speed up operations that use ReactiveVariable as a key in Map.

  Overrides:

  hashCode in class Object

  Returns:

  identity hash code

• get

  public T get()

  Returns the value held by this ReactiveVariable. In most situations, this is the more convenient alternative to value(). It is equivalent to calling value() and then calling ReactiveValue.get() on the returned ReactiveValue.

  If the stored ReactiveValue has ReactiveValue.blocking() flag set, reactive blocking is propagated into current ReactiveScope if there is any. If the stored ReactiveValue holds an exception, the exception is propagated wrapped in CompletionException. Otherwise this method just returns ReactiveValue.result().

  This ReactiveVariable is recorded as a dependency in current ReactiveScope (as identified by ReactiveScope.current() if there is any.

  Returns:

  current value stored in this ReactiveVariable

  Throws:

  CompletionException - if the stored ReactiveValue holds an exception

  See Also:

  • value()
  • ReactiveValue.get()
  • set(Object)

• set

  public void set(T value)

  Sets current value of this ReactiveVariable. In most situations, this is the more convenient alternative to value(ReactiveValue). It is equivalent to wrapping value in ReactiveValue and passing it to value(ReactiveValue).

  If current ReactiveValue is actually changed as determined by equality() setting, version() is incremented and dependent reactive computations (the ones that accessed value() or get()) are notified about the change. Note that change is detected if the old ReactiveValue has ReactiveValue.blocking() flag set or if it holds an exception (ReactiveValue.exception()). If there is no actual change (new ReactiveValue compares equal to the old ReactiveValue per equality() setting), then the state of this ReactiveVariable does not change, old ReactiveValue is kept, version() remains the same, and no change notifications are sent.

  Parameters:

  value - new value to store in this ReactiveVariable

  See Also:

  • value(ReactiveValue)
  • ReactiveValue(Object)
  • get()

• keepalive

  public ReactiveVariable<T> keepalive(Object keepalive)

  Adds strong reference to the specified target object. This is sometimes useful to control garbage collection. Only one target object is supported. If this method is called twice, the first target is discarded.

  Hookless keeps strong references in the direction from reactive computations to their reactive dependencies and weak references in opposite direction. This usually results in expected garbage collector behavior.

  However, when ReactiveVariable is embedded in a higher level reactive object, reactive computations hold strong references to the embedded ReactiveVariable instead of pointing to the outer reactive object, which makes the outer object vulnerable to premature collection. If the outer object is supposed to exist as long as its embedded ReactiveVariable is referenced, for example when it has ReactiveTrigger subscribed to changes in the ReactiveVariable, the outer object should call this method on its embedded ReactiveVariable, passing itself as the target object. This will ensure the outer object will live for as long as its embedded ReactiveVariable.

  Parameters:

  keepalive - target object that will be strongly referenced by this ReactiveVariable

  Returns:

  this (fluent method)

• toString

  public String toString()

  Returns diagnostic string representation of this ReactiveVariable. Stored ReactiveValue is included in the result, but no reactive dependency is created by calling this method.

  Overrides:

  toString in class Object

  Returns:

  string representation of this ReactiveVariable