Refactor parent-child relations

Author: pcastornii

README.md

@@ -157,8 +157,8 @@ the `View`. It is important to keep this in mind to prevent the `Component` from
 violating MVVM responsibility principles.
 
 The `ComponentMediator` is the interface that the `ViewModel` uses to interact with the `Component`. This interface
-is needed for two reasons: first, it allows the `ViewModel` to be tested independently; second, it allows the `Component`
-to access both the `View` and the `ViewModel`, without exposing the `View` to the `ViewModel`.
+is needed for two reasons: first, it allows the `ViewModel` to be tested independently; second, it allows the
+`ViewModel` to use the `Component` without knowing the View, since the Component has knowledge of the View.
 
 The `ComponentMediator` is implemented as a non-static inner class within the `Component`, which allows it to work with
 both the `View` and the `ViewModel` without violating MVVM principles.

mvvm4fx-core/src/main/java/com/techsenger/mvvm4fx/core/AbstractChildComponent.java

@@ -31,13 +31,15 @@ protected abstract class Mediator extends AbstractParentComponent.Mediator imple
         private final ReadOnlyObjectWrapper<ParentViewModel> parent = new ReadOnlyObjectWrapper<>();
 
         public Mediator() {
-            AbstractChildComponent.this.parent.addListener((ov, oldV, newV) -> {
-                if (newV == null) {
-                    this.parent.set(null);
-                } else {
-                    this.parent.set(newV.getView().getViewModel());
-                }
-            });
+            this.parent.bind(
+                AbstractChildComponent.this.parent.map(p -> {
+                    if (p != null) {
+                        return p.getView().getViewModel();
+                    } else {
+                        return null;
+                    }
+                })
+            );
         }
 
         @Override
@@ -67,16 +69,13 @@ public ParentComponent<?> getParent() {
         return this.parent.get();
     }
 
-    /**
-     * Sets the parent component for this component.
-     * <p>
-     * This method is normally called automatically when the component is added as a child to another component.
-     * It can also be used explicitly when only the child-to-parent relationship needs to be established, without
-     * adding the component to the parent's list of children.
-     *
-     * @param parent the parent component to set
-     */
-    protected void setParent(ParentComponent<?> parent) {
+    @Override
+    public <T extends ParentComponent<?>> T getParent(Class<T> parentClass) {
+        return (T) getParent();
+    }
+
+    @Override
+    public void setParent(ParentComponent<?> parent) {
         this.parent.set(parent);
     }
 

mvvm4fx-core/src/main/java/com/techsenger/mvvm4fx/core/AbstractParentComponent.java

@@ -16,10 +16,9 @@
 
 package com.techsenger.mvvm4fx.core;
 
-import com.techsenger.toolkit.fx.collections.ListSynchronizer;
+import com.techsenger.toolkit.fx.binding.ListBinder;
 import java.util.List;
 import javafx.collections.FXCollections;
-import javafx.collections.ListChangeListener;
 import javafx.collections.ObservableList;
 
 /**
@@ -31,7 +30,7 @@ public abstract class AbstractParentComponent<T extends AbstractParentView<?>> e
 
     protected abstract class Mediator extends AbstractComponent.Mediator implements ParentMediator {
 
-        private final ListSynchronizer childrenSynchronizer;
+        private final ListBinder childrenBinder;
 
         private final ObservableList<ChildViewModel> modifiableChildren = FXCollections.observableArrayList();
 
@@ -40,8 +39,8 @@ protected abstract class Mediator extends AbstractComponent.Mediator implements
 
         public Mediator() {
             var outerChildren = AbstractParentComponent.this.modifiableChildren;
-            childrenSynchronizer = new ListSynchronizer<ChildComponent<?>, ChildViewModel>(outerChildren,
-                    modifiableChildren, (v) -> v.getView().getViewModel());
+            childrenBinder = ListBinder.bindContent(modifiableChildren, outerChildren,
+                    (v) -> v.getView().getViewModel());
         }
 
         @Override
@@ -57,18 +56,6 @@ public ObservableList<ChildViewModel> getChildren() {
 
     public AbstractParentComponent(T view) {
         super(view);
-        modifiableChildren.addListener((ListChangeListener<ChildComponent<?>>) (change) -> {
-            while (change.next()) {
-                if (change.wasAdded()) {
-                    change.getAddedSubList().stream().map(e -> (AbstractChildComponent<?>) e)
-                            .forEach(e -> e.setParent(this));
-                }
-                if (change.wasRemoved()) {
-                    change.getRemoved().stream().map(e -> (AbstractChildComponent<?>) e)
-                            .forEach(e -> e.setParent(null));
-                }
-            }
-        });
     }
 
     @Override
@@ -101,7 +88,13 @@ public ObservableList<ChildComponent<?>> getChildren() {
     @Override
     protected abstract AbstractParentComponent.Mediator createMediator();
 
-    protected ObservableList<ChildComponent<?>> getModifiableChildren() {
-        return modifiableChildren;
+    protected void addChild(ChildComponent<?> child) {
+        this.modifiableChildren.add(child);
+        child.setParent(this);
+    }
+
+    protected void removeChild(ChildComponent<?> child) {
+        this.modifiableChildren.remove(child);
+        child.setParent(null);
     }
 }

mvvm4fx-core/src/main/java/com/techsenger/mvvm4fx/core/ChildComponent.java

@@ -30,12 +30,31 @@ public interface ChildComponent<T extends ChildView<?>> extends ParentComponent<
      *
      * @return the property containing the parent component
      */
-    ReadOnlyObjectProperty<ParentComponent<?>> parentProperty();
+    ReadOnlyObjectProperty<? extends ParentComponent<?>> parentProperty();
 
     /**
      * Returns the value of {@link #parentProperty()}.
      *
      * @return the parent component, or {@code null} if this component has no parent
      */
     ParentComponent<?> getParent();
+
+    /**
+     * Returns the value of {@link #parentProperty()} cast to the specified type.
+     *
+     * @param <T> the expected type of the parent component
+     * @param parentClass the class object representing the expected parent type
+     * @return the parent component cast to the specified type, or {@code null} if this component has no parent
+     * @throws ClassCastException if the parent exists but is not of the specified type
+     */
+    <T extends ParentComponent<?>> T getParent(Class<T> parentClass);
+
+    /**
+     * Sets the parent component of this component.
+     *
+     * <p>Framework contract: This method is intended to be called exclusively by {@link ParentComponent}
+     * implementations while managing the component hierarchy. Direct invocation by user code results in undefined
+     * behavior.
+     */
+    void setParent(ParentComponent<?> parent);
 }