Feedback requested for infrastructure for properties that wish to delay registering listeners

[John Hendrikx]

I've made a draft PR which shows the changes I'm proposing below.

For those interested, it can be found here: 
https://github.com/openjdk/jfx/pull/1023

--John

On 19/01/2023 16:49, John Hendrikx wrote:
> Hi list,
>
> I've been looking into what it would take to make the design of 
> properties which only register listeners when needed easier to 
> implement with JavaFX, both for JavaFX itself as well as for the 
> user.  This is the result of my investigation into ListProperty (and 
> other collection properties) and how hard it would be to change their 
> semantics to only register listeners when they're absolutely required 
> for the correct functioning of the class.
>
> Currently, JavaFX doesn't offer the tools one would need to register 
> listeners in a just-in-time fashion.  This is because there is no 
> notification mechanism available in its observable values when they 
> become observed or unobserved. The closest thing there currently 
> exists is what ObjectBinding and LazyObjectBinding offer:
>
> From ObjectBinding:
>
>     /**
>      * Checks if the binding has at least one listener registered on 
> it. This
>      * is useful for subclasses which want to conserve resources when 
> not observed.
>      *
>      * @return {@code true} if this binding currently has one or more
>      *     listeners registered on it, otherwise {@code false}
>      * @since 19
>      */
>     protected final boolean isObserved() {
>         return helper != null;
>     }
>
> From LazyObjectBinding:
>
>     /**
>      * Called after a listener was added to start observing inputs if 
> they're not observed already.
>      */
>     private void updateSubscriptionAfterAdd() { ... }
>
>     /**
>      * Called after a listener was removed to stop observing inputs if 
> this was the last listener
>      * observing this binding.
>      */
>     private void updateSubscriptionAfterRemove() { ... }
>
> I'm proposing to extend the JavaFX with new methods that can be used 
> to stay informed about the observable's current observed status. These 
> methods will facilitate implementations of properties that wish to 
> delay registering listeners until they are themselves observed. This 
> can save memory, save unnecessary notifications via events and reduces 
> the need for weak listener constructs.
>
> The proposal does not require any new fields, and would default to 
> reporting observable values as being observed. Most JavaFX observable 
> values should be retrofitted to support this functionality -- the ones 
> relying on a form of ExpressionHelper will only require minimal 
> changes with minimal impact.
>
> The methods that I would like to see added are the following:
>
> In ObservableValue:
>
>     /**
>      * Checks if this ObservableValue is currently observed. If 
> unknown or unsupported,
>      * {@code true} is returned.
>      *
>      * @return {@code true} if this ObservableValue currently has one 
> or more
>      *     listeners registered on it, otherwise {@code false}
>      */
>     default boolean isObserved() { return true; }
>
> The above method is useful for debugging, but its primary use is for 
> complex properties which observed status is determined by not only its 
> direct listeners but also any child properties it may offer.  
> ListProperty is such an example, which offers child properties size 
> and empty. Its observed status would be determined like this:
>
>      helper != null || (size0 != null && size0.isObserved()) || 
> (empty0 != null && empty0.isObserved())
>
> Further, we need two protected callback methods.  These should be 
> added in all Binding and Property Base classes (basically all classes 
> that implement addListener/removeListener methods). These are called 
> when the observed status of the property changes:
>
>     /**
>      * Called when this property transitions from unobserved to observed.
>      */
>     protected void observed() {}
>
>     /**
>      * Called when this property transitions from observed to unobserved.
>      */
>     protected void unobserved() {}
>
> These methods are implemented by child properties in order to inform 
> the parent that their observed status has changed, which may require 
> the parent property to change its status as well.
>
> When implemented, LazyObjectBinding can be simplified as some or all 
> of its functionality will be part of ObjectBinding (LazyObjectBinding 
> is not a public class at the moment).  The isObserved method in 
> ObjectBinding would go from protected to public (it's already final).
>
> Implementation for classes that rely on a form of ExpressionHelper is 
> simple; they can check if the helper is null or not (for isObserved) 
> and check if the nullity changed during addListener/removeListener 
> calls to make their call to "observed" or "unobserved".  No additional 
> fields are required.
>
> I've added a proof of concept here 
> (https://github.com/openjdk/jfx/pull/1004) where `ListPropertyBase` 
> was altered to use these new methods to delay its listener 
> registration and to remove its listener when no longer observed. This 
> PoC includes the tests written by Florian Kirmaier which fail on the 
> current ListProperty implementation (but pass with this version).
>
> --John
>