PoC: Fluent bindings for ObservableValue

Author: hjohn

modules/javafx.base/src/main/java/javafx/beans/binding/ObjectBinding.java

@@ -65,11 +65,25 @@ public abstract class ObjectBinding<T> extends ObjectExpression<T> implements
     private boolean valid = false;
     private BindingHelperObserver observer;
     private ExpressionHelper<T> helper = null;
+    private boolean remainInvalidWhenNotObserved;
 
     /**
-     * Creates a default {@code ObjectBinding}.
+     * Constructs a new instance.
+     *
+     * @param remainInvalidWhenNotObserved when {@code true} creates a binding 
+     *   which, whenever its value is computed, remains invalid when not 
+     *   observed, otherwise always becomes valid.
+     */
+    public ObjectBinding(boolean remainInvalidWhenNotObserved) {
+      this.remainInvalidWhenNotObserved = remainInvalidWhenNotObserved;
+    }
+
+    /**
+     * Constructs a new instance which will always become valid when its value
+     * is computed.
      */
     public ObjectBinding() {
+      this(false);
     }
 
     @Override
@@ -155,7 +169,10 @@ public ObservableList<?> getDependencies() {
     public final T get() {
         if (!valid) {
             value = computeValue();
-            valid = true;
+
+            if (!remainInvalidWhenNotObserved || helper != null) {
+                valid = true;
+            }
         }
         return value;
     }
@@ -182,6 +199,17 @@ public final boolean isValid() {
         return valid;
     }
 
+    /**
+     * Returns {@code true} when this binding currently has one or more 
+     * listeners, otherwise {@code false}.
+     *
+     * @return {@code true} when this binding currently has one or more 
+     *   listeners, otherwise {@code false}
+     */
+    protected boolean isObserved() {
+        return helper != null;
+    }
+
     /**
      * Calculates the current value of this binding.
      * <p>

modules/javafx.base/src/main/java/javafx/beans/value/Bindings.java

@@ -0,0 +1,68 @@
+package javafx.beans.value;
+
+import java.util.function.Function;
+
+import javafx.beans.InvalidationListener;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleObjectProperty;
+
+/**
+ * Support class which supplies varies types of bindings.
+ */
+class Bindings {
+
+  public static <T, U> ObservableValue<U> mapping(ObservableValue<T> source, Function<? super T, ? extends U> mapper) {
+    return nullableMapping(source, v -> v == null ? null : mapper.apply(v));
+  }
+
+  public static <T> ObservableValue<T> conditional(ObservableValue<T> source, ObservableValue<Boolean> condition) {
+    return new FlatMapBinding<>(condition, new ConditionalMapper<>(source), null);
+  }
+
+  public static <T, U> ObservableValue<U> flatMapping(ObservableValue<T> source, Function<? super T, ? extends ObservableValue<? extends U>> mapper) {
+    return new FlatMapBinding<>(source, mapper, () -> null);
+  }
+
+  public static <T, U> ObservableValue<U> nullableMapping(ObservableValue<T> source, Function<? super T, ? extends U> mapper) {
+    return new LazyObjectBinding<>() {
+      @Override
+      protected Subscription observeInputs() {
+        InvalidationListener listener = obs -> invalidate();
+
+        source.addListener(listener);  // start observing source
+
+        return () -> source.removeListener(listener);
+      }
+
+      @Override
+      protected U computeValue() {
+        return mapper.apply(source.getValue());
+      }
+    };
+  }
+
+  private static class ConditionalMapper<T> implements Function<Boolean, ObservableValue<? extends T>> {
+    private final ObservableValue<T> source;
+
+    private ObjectProperty<T> lastValue;
+
+    ConditionalMapper(ObservableValue<T> source) {
+      this.source = source;
+    }
+
+    @Override
+    public ObservableValue<? extends T> apply(Boolean v) {
+      if(Boolean.TRUE.equals(v)) {
+        lastValue = null;
+
+        return source;
+      }
+
+      if(lastValue == null) {
+        lastValue = new SimpleObjectProperty<>(source.getValue());
+      }
+
+      return lastValue;
+    }
+  }
+}

modules/javafx.base/src/main/java/javafx/beans/value/FlatMapBinding.java

@@ -0,0 +1,50 @@
+package javafx.beans.value;
+
+import java.util.Objects;
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+class FlatMapBinding<S, T> extends LazyObjectBinding<T> {
+  private final ObservableValue<S> source;
+  private final Function<? super S, ? extends ObservableValue<? extends T>> mapper;
+  private final Supplier<? extends T> nullSupplier;
+
+  private Subscription mappedSubscription = Subscription.EMPTY;
+
+  public FlatMapBinding(
+      ObservableValue<S> source,
+      Function<? super S, ? extends ObservableValue<? extends T>> mapper,
+      Supplier<? extends T> nullSupplier
+  ) {
+    this.source = Objects.requireNonNull(source);
+    this.mapper = Objects.requireNonNull(mapper);
+    this.nullSupplier = nullSupplier;
+  }
+
+  @Override
+  protected T computeValue() {
+    S value = source.getValue();
+    boolean skipNull = value == null && nullSupplier != null;
+    ObservableValue<? extends T> mapped = skipNull ? null : mapper.apply(value);
+
+    if(isObserved()) {
+      mappedSubscription.unsubscribe();
+      mappedSubscription = mapped == null ? Subscription.EMPTY : mapped.subscribeInvalidations(this::invalidate);
+    }
+
+    return skipNull ? nullSupplier.get()
+      : mapped == null ? null
+      : mapped.getValue();
+  }
+
+  @Override
+  protected Subscription observeInputs() {
+    Subscription subscription = source.subscribeInvalidations(this::invalidate);
+
+    return () -> {
+      subscription.unsubscribe();
+      mappedSubscription.unsubscribe();
+      mappedSubscription = Subscription.EMPTY;
+    };
+  }
+}

modules/javafx.base/src/main/java/javafx/beans/value/LazyObjectBinding.java

@@ -0,0 +1,71 @@
+package javafx.beans.value;
+
+import javafx.beans.InvalidationListener;
+import javafx.beans.binding.ObjectBinding;
+
+/**
+ * Extends {@link ObjectBinding} with the ability to lazily register
+ * and eagerly unregister listeners on its dependencies.
+ *
+ * @param <T> the type of the wrapped {@code Object}
+ */
+public abstract class LazyObjectBinding<T> extends ObjectBinding<T> {
+  private Subscription subscription;
+  private boolean wasObserved;
+
+  public LazyObjectBinding() {
+    super(true);  // this toggles a code path in ObjectBinding to make lazy listener registration possible; can be solved better if accepted
+  }
+
+  @Override
+  public void addListener(ChangeListener<? super T> listener) {
+    super.addListener(listener);
+
+    updateSubcription();
+  }
+
+  @Override
+  public void removeListener(ChangeListener<? super T> listener) {
+    super.removeListener(listener);
+
+    updateSubcription();
+  }
+
+  @Override
+  public void addListener(InvalidationListener listener) {
+    super.addListener(listener);
+
+    updateSubcription();
+  }
+
+  @Override
+  public void removeListener(InvalidationListener listener) {
+    super.removeListener(listener);
+
+    updateSubcription();
+  }
+
+  private void updateSubcription() {
+    boolean isObserved = isObserved();
+
+    if(!wasObserved && isObserved) {  // was first observer registered?
+      subscription = observeInputs();  // start observing source
+      get();  // make binding valid as we haven't been tracking the source until now
+    }
+    if(wasObserved && !isObserved) {  // was last observer unregistered?
+      subscription.unsubscribe();
+      subscription = null;
+    }
+
+    wasObserved = isObserved;
+  }
+
+  /**
+   * Called when this binding was previously not observed and a new observer was added. Implementors
+   * must return a {@link Subscription} which will be cancelled when this binding no longer has any
+   * observers.
+   *
+   * @return a {@link Subscription} which will be cancelled when this binding no longer has any observers, never null
+   */
+  protected abstract Subscription observeInputs();
+}