You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@isis.apache.org by ah...@apache.org on 2020/10/23 16:21:29 UTC

[isis] 01/02: ISIS-2424: a bit of SpecLoader clean up

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

commit 26b9f11ddfe7ca663a1cd02373015c896adba371
Author: Andi Huber <ah...@apache.org>
AuthorDate: Fri Oct 23 17:14:17 2020 +0200

    ISIS-2424: a bit of SpecLoader clean up
---
 .../metamodel/specloader/SpecificationLoader.java  |  38 +++---
 .../specloader/SpecificationLoaderDefault.java     | 150 ++++++++++-----------
 2 files changed, 89 insertions(+), 99 deletions(-)

diff --git a/core/metamodel/src/main/java/org/apache/isis/core/metamodel/specloader/SpecificationLoader.java b/core/metamodel/src/main/java/org/apache/isis/core/metamodel/specloader/SpecificationLoader.java
index 41fddea..cdb6444 100644
--- a/core/metamodel/src/main/java/org/apache/isis/core/metamodel/specloader/SpecificationLoader.java
+++ b/core/metamodel/src/main/java/org/apache/isis/core/metamodel/specloader/SpecificationLoader.java
@@ -31,13 +31,14 @@ import org.apache.isis.core.metamodel.specloader.specimpl.IntrospectionState;
 import org.apache.isis.core.metamodel.specloader.validator.MetaModelValidator;
 import org.apache.isis.core.metamodel.specloader.validator.ValidationFailures;
 
+import lombok.NonNull;
 import lombok.val;
 
 /**
  * Builds the meta-model, utilizing an instance of {@link ProgrammingModel}
  */
 public interface SpecificationLoader {
-    
+   
     /**
      * Creates the meta-model, that is the set of {@link ObjectSpecification}s.
      * @see {@link #disposeMetaModel()}
@@ -81,12 +82,6 @@ public interface SpecificationLoader {
      */
     void forEach(Consumer<ObjectSpecification> onSpec);
 
-    /**
-     * Lookup a specification that has bean loaded before.
-     * @param objectSpecId
-     */
-    ObjectSpecification lookupBySpecIdElseLoad(ObjectSpecId objectSpecId);
-
     void reloadSpecification(Class<?> domainType);
 
     /**
@@ -98,7 +93,8 @@ public interface SpecificationLoader {
      * 
      * @return {@code null} if {@code domainType==null}, or if the type should be ignored.
      */
-    ObjectSpecification loadSpecification(@Nullable Class<?> domainType, IntrospectionState upTo);
+    @Nullable
+    ObjectSpecification loadSpecification(@Nullable Class<?> domainType, @NonNull IntrospectionState upTo);
 
     /**
      * @param domainTypes
@@ -116,27 +112,35 @@ public interface SpecificationLoader {
 
     // -- SHORTCUTS
 
-    default ObjectSpecification loadSpecification(@Nullable final Class<?> domainType) {
+    @Nullable
+    default ObjectSpecification loadSpecification(@Nullable Class<?> domainType) {
         return loadSpecification(domainType, IntrospectionState.TYPE_INTROSPECTED);
     }
 
+    @Nullable
+    default ObjectSpecification loadSpecification(@Nullable ObjectSpecId objectSpecId) {
+        return loadSpecification(objectSpecId, IntrospectionState.TYPE_INTROSPECTED);
+    }
+    
+    @Nullable
     default ObjectSpecification loadSpecification(
             @Nullable ObjectSpecId objectSpecId, 
-            @Nullable IntrospectionState introspectionState) {
+            @NonNull IntrospectionState introspectionState) {
 
         if(objectSpecId==null) {
             return null;
         }
         val type = lookupType(objectSpecId);
-        return introspectionState!=null 
-                ? loadSpecification(type, introspectionState)
-                : loadSpecification(type);
+        return loadSpecification(type, introspectionState);
     }
 
-    default ObjectSpecification loadSpecification(@Nullable ObjectSpecId objectSpecId) {
-        return loadSpecification(objectSpecId, null);
+    /**
+     * Lookup a specification that has bean loaded before.
+     * @param objectSpecId
+     */
+    @Nullable
+    default ObjectSpecification lookupBySpecIdElseLoad(@Nullable ObjectSpecId objectSpecId) {
+        return loadSpecification(objectSpecId, IntrospectionState.TYPE_AND_MEMBERS_INTROSPECTED);
     }
-
-
     
 }
diff --git a/core/metamodel/src/main/java/org/apache/isis/core/metamodel/specloader/SpecificationLoaderDefault.java b/core/metamodel/src/main/java/org/apache/isis/core/metamodel/specloader/SpecificationLoaderDefault.java
index d1c5595..527fe7f 100644
--- a/core/metamodel/src/main/java/org/apache/isis/core/metamodel/specloader/SpecificationLoaderDefault.java
+++ b/core/metamodel/src/main/java/org/apache/isis/core/metamodel/specloader/SpecificationLoaderDefault.java
@@ -75,8 +75,6 @@ import org.apache.isis.core.metamodel.specloader.validator.ValidationFailures;
 import org.apache.isis.core.metamodel.valuetypes.ValueTypeProviderDefault;
 import org.apache.isis.core.metamodel.valuetypes.ValueTypeRegistry;
 
-import static org.apache.isis.commons.internal.base._With.requires;
-
 import lombok.Getter;
 import lombok.NonNull;
 import lombok.Setter;
@@ -306,33 +304,6 @@ public class SpecificationLoaderDefault implements SpecificationLoader {
         return validationResult.get();
     }
 
-    private _Lazy<ValidationFailures> validationResult = 
-            _Lazy.threadSafe(this::collectFailuresFromMetaModel);
-
-    private final AtomicBoolean validationInProgress = new AtomicBoolean(false);
-    private final BlockingQueue<ObjectSpecification> validationQueue = new LinkedBlockingQueue<>();
-    
-    private ValidationFailures collectFailuresFromMetaModel() {
-        validationInProgress.set(true);               
-        val failures = new ValidationFailures();
-        programmingModel.streamValidators()
-        .map(MetaModelValidatorAbstract.class::cast)
-        .forEach(validator -> {
-            log.debug("Running validator: {}", validator);
-            try {
-                validator.collectFailuresInto(failures);
-            } catch (Throwable t) {
-                log.error(t);
-                throw t;
-            } finally {
-                log.debug("Done validator: {}", validator);
-            }
-        });
-        log.debug("Done");
-        validationInProgress.set(false);
-        return failures;
-    }
-
     @Override
     public void disposeMetaModel() {
         cache.clear();
@@ -377,53 +348,12 @@ public class SpecificationLoaderDefault implements SpecificationLoader {
         return true;
     }
 
-    @Nullable
-    private ObjectSpecification loadSpecification(
-            final @Nullable Class<?> type,
-            final Function<Class<?>, BeanSort> beanClassifier,
-            final IntrospectionState upTo) {
-
-        if(type==null) {
-            return null;
-        }
-
-        requires(upTo, "upTo");
-        
-        val substitute = classSubstitutorRegistry.getSubstitution(type);
-        if (substitute.isNeverIntrospect()) {
-            return null; // never inspect
-        }
-        
-        val substitutedType = substitute.apply(type);
-        
-        final ObjectSpecification cachedSpec;
-        
-        // we try not to block on long running code ... 'spec.introspectUpTo(upTo);'
-        synchronized (cache) {
-            cachedSpec = cache.computeIfAbsent(substitutedType, __->
-                createSpecification(substitutedType, beanClassifier.apply(type)));
-        }
-
-        cachedSpec.introspectUpTo(upTo);
-
-        return cachedSpec;
-    }
-
-    @Nullable
-    private ObjectSpecification primeSpecification(
-            final @Nullable Class<?> type,
-            final @NonNull BeanSort sort) {
-        return loadSpecification(type, __->sort, IntrospectionState.NOT_INTROSPECTED);
-        
-    }
-
-    
     @Override @Nullable
     public ObjectSpecification loadSpecification(
             final @Nullable Class<?> type,
-            final IntrospectionState upTo) {
+            final @NonNull IntrospectionState upTo) {
 
-        return loadSpecification(
+        return _loadSpecification(
                 type, 
                 __->isisBeanTypeRegistry
                     .lookupIntrospectableType(type)
@@ -492,23 +422,79 @@ public class SpecificationLoaderDefault implements SpecificationLoader {
     }
 
     @Override
-    public ObjectSpecification lookupBySpecIdElseLoad(ObjectSpecId objectSpecId) {
-        val spec = cache.getByObjectType(objectSpecId);
-        if(spec!=null) {
-            return spec;
-        }
-        // fallback
-        return loadSpecification(objectSpecId, IntrospectionState.TYPE_AND_MEMBERS_INTROSPECTED);
-    }
-    
-    @Override
     public Class<?> lookupType(ObjectSpecId objectSpecId) {
         return cache.resolveType(objectSpecId);
     }
+    
+    // -- VALIDATION STUFF
+    
+    private _Lazy<ValidationFailures> validationResult = 
+            _Lazy.threadSafe(this::collectFailuresFromMetaModel);
 
+    private final AtomicBoolean validationInProgress = new AtomicBoolean(false);
+    private final BlockingQueue<ObjectSpecification> validationQueue = new LinkedBlockingQueue<>();
+    
+    private ValidationFailures collectFailuresFromMetaModel() {
+        validationInProgress.set(true);               
+        val failures = new ValidationFailures();
+        programmingModel.streamValidators()
+        .map(MetaModelValidatorAbstract.class::cast)
+        .forEach(validator -> {
+            log.debug("Running validator: {}", validator);
+            try {
+                validator.collectFailuresInto(failures);
+            } catch (Throwable t) {
+                log.error(t);
+                throw t;
+            } finally {
+                log.debug("Done validator: {}", validator);
+            }
+        });
+        log.debug("Done");
+        validationInProgress.set(false);
+        return failures;
+    }
 
     // -- HELPER
     
+    @Nullable
+    private ObjectSpecification primeSpecification(
+            final @Nullable Class<?> type,
+            final @NonNull BeanSort sort) {
+        return _loadSpecification(type, __->sort, IntrospectionState.NOT_INTROSPECTED);
+        
+    }
+    
+    @Nullable
+    private ObjectSpecification _loadSpecification(
+            final @Nullable Class<?> type,
+            final @NonNull Function<Class<?>, BeanSort> beanClassifier,
+            final @NonNull IntrospectionState upTo) {
+
+        if(type==null) {
+            return null;
+        }
+
+        val substitute = classSubstitutorRegistry.getSubstitution(type);
+        if (substitute.isNeverIntrospect()) {
+            return null; // never inspect
+        }
+        
+        val substitutedType = substitute.apply(type);
+        
+        final ObjectSpecification cachedSpec;
+        
+        // we try not to block on long running code ... 'spec.introspectUpTo(upTo);'
+        synchronized (cache) {
+            cachedSpec = cache.computeIfAbsent(substitutedType, __->
+                createSpecification(substitutedType, beanClassifier.apply(type)));
+        }
+
+        cachedSpec.introspectUpTo(upTo);
+
+        return cachedSpec;
+    }
+    
     private void guardAgainstMetamodelLockedAfterFullIntrospection(final Class<?> cls) {
         if(isMetamodelFullyIntrospected() 
                 && isisConfiguration.getCore().getMetaModel().getIntrospector().isLockAfterFullIntrospection()) {