[isis] branch master updated: ISIS-2882: fixes prev. commit

[ah...@apache.org]

This is an automated email from the ASF dual-hosted git repository.

ahuber pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/isis.git


The following commit(s) were added to refs/heads/master by this push:
     new e58e273  ISIS-2882: fixes prev. commit
e58e273 is described below

commit e58e273a93004c37ba37b0593ab1d91763368dc2
Author: Andi Huber <ah...@apache.org>
AuthorDate: Mon Dec 20 10:37:28 2021 +0100

    ISIS-2882: fixes prev. commit
    
    - support for type check on non-scalar managed-objects
    
    - support for type check on primitive  managed-objects
---
 .../isis/core/metamodel/spec/ManagedObjects.java   | 43 +++++++++++++++-------
 1 file changed, 29 insertions(+), 14 deletions(-)

diff --git a/core/metamodel/src/main/java/org/apache/isis/core/metamodel/spec/ManagedObjects.java b/core/metamodel/src/main/java/org/apache/isis/core/metamodel/spec/ManagedObjects.java
index fd05830..826f9bf 100644
--- a/core/metamodel/src/main/java/org/apache/isis/core/metamodel/spec/ManagedObjects.java
+++ b/core/metamodel/src/main/java/org/apache/isis/core/metamodel/spec/ManagedObjects.java
@@ -33,6 +33,7 @@ import java.util.function.UnaryOperator;
 import java.util.stream.Stream;
 
 import org.springframework.lang.Nullable;
+import org.springframework.util.ClassUtils;
 
 import org.apache.isis.applib.annotation.Where;
 import org.apache.isis.applib.services.bookmark.Bookmark;
@@ -126,26 +127,40 @@ public final class ManagedObjects {
     // -- INSTANCE-OF CHECKS
 
     /**
-     * guard against incompatible type
+     * Whether given {@code object} is an instance of given {@code elementType}.
+     */
+    public static boolean isInstanceOf(
+            final @Nullable ManagedObject object,
+            final @NonNull ObjectSpecification elementType) {
+        val upperBound = ClassUtils.resolvePrimitiveIfNecessary(elementType.getCorrespondingClass());
+        if(ManagedObjects.isNullOrUnspecifiedOrEmpty(object)) {
+            return true;
+        }
+        if(object instanceof PackedManagedObject) {
+            return ((PackedManagedObject)object).unpack().stream()
+            .allMatch(element->isInstanceOf(element, elementType));
+        }
+        val objectActualType = ClassUtils.resolvePrimitiveIfNecessary(object.getSpecification().getCorrespondingClass());
+        return upperBound.isAssignableFrom(objectActualType);
+    }
+
+    /**
+     * Guard against incompatible type.
      */
     public static @NonNull UnaryOperator<ManagedObject> assertInstanceOf(final ObjectSpecification elementType) {
-        val upperBound = elementType.getCorrespondingClass();
-        return newValue -> {
-            if(ManagedObjects.isNullOrUnspecifiedOrEmpty(newValue)) {
-                return newValue;
+        return object -> {
+            if(isInstanceOf(object, elementType)) {
+                return object;
             }
-            val newValueActualType = newValue.getSpecification().getCorrespondingClass();
-            if(!upperBound.isAssignableFrom(newValueActualType)) {
-                throw _Exceptions.illegalArgument("Proposed new value has incompatible type %s,"
-                        + "must be an instance of %s.",
-                        newValueActualType.getName(),
-                        upperBound.getName());
-            }
-            return newValue;
+            val upperBound = ClassUtils.resolvePrimitiveIfNecessary(elementType.getCorrespondingClass());
+            val objectActualType = ClassUtils.resolvePrimitiveIfNecessary(object.getSpecification().getCorrespondingClass());
+            throw _Exceptions.illegalArgument("Object has incompatible type %s,"
+                    + "must be an instance of %s.",
+                    objectActualType.getName(),
+                    upperBound.getName());
         };
     }
 
-
     // -- IDENTIFICATION
 
     public static Optional<ObjectSpecification> spec(final @Nullable ManagedObject managedObject) {