CAUSEWAY-3883: flattens WrapperInvocationHandler hierarchy (refactor)

Author: andi-huber

core/runtimeservices/src/main/java/org/apache/causeway/core/runtimeservices/wrapper/handlers/CollectionInvocationHandler.java

@@ -57,7 +57,6 @@
 import org.apache.causeway.core.metamodel.object.MmAssertionUtils;
 import org.apache.causeway.core.metamodel.object.MmEntityUtils;
 import org.apache.causeway.core.metamodel.object.MmUnwrapUtils;
-import org.apache.causeway.core.metamodel.objectmanager.ObjectManager;
 import org.apache.causeway.core.metamodel.spec.ObjectSpecification;
 import org.apache.causeway.core.metamodel.spec.feature.MixedIn;
 import org.apache.causeway.core.metamodel.spec.feature.MixedInMember;
@@ -78,7 +77,7 @@
  * @param <T> type of delegate
  */
 @Log4j2
-public class DomainObjectInvocationHandler<T>
+public final class DomainObjectInvocationHandler<T>
 implements WrapperInvocationHandler {
 
     @Getter(onMethod_ = {@Override}) @Accessors(fluent=true) 
@@ -140,8 +139,7 @@ public DomainObjectInvocationHandler(
                     nsme);
         }
 
-        entityFacet = targetAdapter.objSpec().entityFacet().orElse(null);
-
+        this.entityFacet = targetAdapter.objSpec().entityFacet().orElse(null);
         this.mixeeAdapter = mixeeAdapter;
     }
 
@@ -160,7 +158,7 @@ public Object invoke(final Object proxyObjectUnused, final Method method, final
             return context().invoke(method, args);
         }
 
-        final ManagedObject targetAdapter = getObjectManager().adapt(context().delegate());
+        final ManagedObject targetAdapter = mmc.getObjectManager().adapt(context().delegate());
 
         if(!targetAdapter.specialization().isMixin()) {
             MmAssertionUtils.assertIsBookmarkSupported(targetAdapter);
@@ -371,7 +369,7 @@ private Object handleSetterMethodOnProperty(
             checkUsability(targetAdapter, property);
         });
 
-        var argumentAdapter = getObjectManager().adapt(singleArg);
+        var argumentAdapter = property.getObjectManager().adapt(singleArg);
 
         runValidationTask(()->{
             var interactionResult = property.isAssociationValid(
@@ -459,7 +457,7 @@ private Object handleActionMethod(
             final ObjectAction objectAction) {
 
         var head = objectAction.interactionHead(targetAdapter);
-        var objectManager = getObjectManager();
+        var objectManager = objectAction.getObjectManager();
 
         // adapt argument pojos to managed objects
         var argAdapters = objectAction.getParameterTypes().map(IndexedFunction.zeroBased((paramIndex, paramSpec)->{
@@ -631,10 +629,4 @@ private void zeroArgsElseThrow(final Object[] args, final String name) {
         }
     }
 
-    // -- DEPENDENCIES
-
-    private ObjectManager getObjectManager() {
-        return mmc.getObjectManager();
-    }
-
 }

core/runtimeservices/src/main/java/org/apache/causeway/core/runtimeservices/wrapper/handlers/DomainObjectInvocationHandler.java

@@ -23,6 +23,7 @@
 import java.util.Map;
 
 import org.apache.causeway.applib.services.wrapper.events.CollectionMethodEvent;
+import org.apache.causeway.commons.internal.assertions._Assert;
 import org.apache.causeway.commons.semantics.CollectionSemantics;
 import org.apache.causeway.core.metamodel.spec.feature.OneToManyAssociation;
 import org.apache.causeway.core.runtime.wrap.WrapperInvocationHandler;
@@ -36,16 +37,49 @@
  * @param <T> Domain Object type
  * @param <P> non-scalar type (eg. {@link Collection} or {@link Map}) to be proxied
  */
-abstract class PluralInvocationHandlerAbstract<T, P>
+final class PluralInvocationHandler<T, P>
 implements WrapperInvocationHandler {
 
+    // -- FACTORIES
+    
+   static <T, C extends Collection<?>> PluralInvocationHandler<T, C> forCollection(
+           final C collectionToBeProxied,
+           final DomainObjectInvocationHandler<T> handler,
+           final OneToManyAssociation otma) {
+       
+       _Assert.assertTrue(Collection.class.isAssignableFrom(collectionToBeProxied.getClass()),
+               ()->String.format("Cannot use %s for type %s, these are not compatible.",
+                       PluralInvocationHandler.class.getName() + ".forCollection(..)",
+                       collectionToBeProxied.getClass()));
+       
+       return new PluralInvocationHandler<>(collectionToBeProxied, handler, otma,
+                CollectionSemantics
+                    .valueOfElseFail(collectionToBeProxied.getClass()));
+    }
+    
+   static <T, M extends Map<?,?>> PluralInvocationHandler<T, M> forMap(
+           final M mapToBeProxied,
+           final DomainObjectInvocationHandler<T> handler,
+           final OneToManyAssociation otma) {
+
+       _Assert.assertTrue(Map.class.isAssignableFrom(mapToBeProxied.getClass()),
+               ()->String.format("Cannot use %s for type %s, these are not compatible.",
+                       PluralInvocationHandler.class.getName() + ".forMap(..)",
+                       mapToBeProxied.getClass()));
+       
+       return new PluralInvocationHandler<>(mapToBeProxied, handler, otma,
+               CollectionSemantics.MAP);
+   }
+   
+    // -- CONSTRUCTION
+    
     @Getter(onMethod_ = {@Override}) @Accessors(fluent=true) 
     private final WrapperInvocationHandler.Context context;
 
     private final OneToManyAssociation oneToManyAssociation;
     private final CollectionSemantics collectionSemantics;
-
-    protected PluralInvocationHandlerAbstract(
+    
+    protected PluralInvocationHandler(
             final P collectionOrMapToBeProxied,
             final DomainObjectInvocationHandler<T> handler,
             final OneToManyAssociation otma,

core/runtimeservices/src/main/java/org/apache/causeway/core/runtimeservices/wrapper/handlers/MapInvocationHandler.java

@@ -78,12 +78,12 @@ public <T, E> Collection<E> collectionProxy(
             final DomainObjectInvocationHandler<T> handler,
             final OneToManyAssociation otma) {
 
-        var collectionInvocationHandler = new CollectionInvocationHandler<T, Collection<E>>(
-                        collectionToBeProxied, handler, otma);
+        var collectionInvocationHandler = PluralInvocationHandler
+            .forCollection(collectionToBeProxied, handler, otma);
 
         var proxyBase = CollectionSemantics
-                .valueOfElseFail(collectionToBeProxied.getClass())
-                .getContainerType();
+            .valueOfElseFail(collectionToBeProxied.getClass())
+            .getContainerType();
 
         return instantiateProxy(_Casts.uncheckedCast(proxyBase), collectionInvocationHandler);
     }
@@ -97,8 +97,8 @@ public <T, P, Q> Map<P, Q> mapProxy(
             final DomainObjectInvocationHandler<T> handler,
             final OneToManyAssociation otma) {
 
-        var mapInvocationHandler = new MapInvocationHandler<T, Map<P, Q>>(
-                collectionToBeProxied, handler, otma);
+        var mapInvocationHandler = PluralInvocationHandler
+            .forMap(collectionToBeProxied, handler, otma);
 
         var proxyBase = Map.class;