You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@causeway.apache.org by ah...@apache.org on 2026/08/13 15:23:26 UTC

(causeway) 01/01: CAUSEWAY-4044: refactors 'hierarchical' in to its own class

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

andi-huber pushed a commit to branch 4044-stable.objspec
in repository https://gitbox.apache.org/repos/asf/causeway.git

commit 4930225a58988d33c4f259ed883d4f44f2cc9165
Author: andi-huber <ah...@apache.org>
AuthorDate: Thu Aug 13 17:10:37 2026 +0200

    CAUSEWAY-4044: refactors 'hierarchical' in to its own class
---
 .../causeway/core/metamodel/spec/Hierarchical.java |  23 +---
 .../core/metamodel/spec/ObjectSpecification.java   |  29 +++++
 .../metamodel/spec/ObjectSpecificationRecord.java  |   6 -
 .../metamodel/spec/impl/HierarchicalFactory.java   | 115 +++++++++++++++++
 .../spec/impl/ObjectSpecificationDefault.java      | 137 +++------------------
 5 files changed, 164 insertions(+), 146 deletions(-)

diff --git a/core/metamodel/src/main/java/org/apache/causeway/core/metamodel/spec/Hierarchical.java b/core/metamodel/src/main/java/org/apache/causeway/core/metamodel/spec/Hierarchical.java
index 8dd021a005d..f2c0070531a 100644
--- a/core/metamodel/src/main/java/org/apache/causeway/core/metamodel/spec/Hierarchical.java
+++ b/core/metamodel/src/main/java/org/apache/causeway/core/metamodel/spec/Hierarchical.java
@@ -30,28 +30,17 @@
 
 public interface Hierarchical {
 
-    /**
+    final static Hierarchical EMPTY = new Hierarchical() {
+		@Override public ObjectSpecification superclass() { return null; }
+		@Override public Can<ObjectSpecification> interfaces() { return Can.empty(); }
+	};
+
+	/**
      * Get the set of specifications for all the interfaces that the class
      * represented by this specification implements.
      */
     Can<ObjectSpecification> interfaces();
 
-    /**
-     * Whether <code>this</code> specification represents the same specification,
-     * or a subclass of the specified <code>other</code> specification.
-     * <p>
-     * <tt>subSpec.isOfType(superSpec)</tt> is equivalent to
-     * {@link Class#isAssignableFrom(Class) Java's}
-     * <tt>superType.isAssignableFrom(subType)</tt>.
-     * @return whether <code>this</code> is <b>instanceof</b> <code>other</code>
-     */
-    boolean isOfType(ObjectSpecification other);
-
-    /**
-     * Same as {@link #isOfType(ObjectSpecification)}, except treating wrapper/primitive the same.
-     */
-    boolean isOfTypeResolvePrimitive(ObjectSpecification other);
-
     /**
      * Get the specification for this specification's class's superclass.
      */
diff --git a/core/metamodel/src/main/java/org/apache/causeway/core/metamodel/spec/ObjectSpecification.java b/core/metamodel/src/main/java/org/apache/causeway/core/metamodel/spec/ObjectSpecification.java
index 3c076ff27d7..0dd2bbf19bf 100644
--- a/core/metamodel/src/main/java/org/apache/causeway/core/metamodel/spec/ObjectSpecification.java
+++ b/core/metamodel/src/main/java/org/apache/causeway/core/metamodel/spec/ObjectSpecification.java
@@ -77,6 +77,7 @@
 import org.apache.causeway.core.metamodel.spec.feature.ObjectMember;
 import org.jspecify.annotations.NonNull;
 import org.jspecify.annotations.Nullable;
+import org.springframework.util.ClassUtils;
 
 import lombok.experimental.UtilityClass;
 
@@ -649,6 +650,34 @@ default Stream<ObjectSpecification> streamTypeHierarchyAndInterfaces() {
         return Stream.concat(streamTypeHierarchy(), interfaces().stream());
     }
 
+    /**
+     * Whether <code>this</code> specification represents the same specification,
+     * or a subclass of the specified <code>other</code> specification.
+     * <p>
+     * <tt>subSpec.isOfType(superSpec)</tt> is equivalent to
+     * {@link Class#isAssignableFrom(Class) Java's}
+     * <tt>superType.isAssignableFrom(subType)</tt>.
+     * @return whether <code>this</code> is <b>instanceof</b> <code>other</code>
+     */
+    default boolean isOfType(final ObjectSpecification other) {
+    	var thisClass = this.getCorrespondingClass();
+    	var otherClass = other.getCorrespondingClass();
+
+    	return thisClass == otherClass
+    			|| otherClass.isAssignableFrom(thisClass);
+    }
+
+    /**
+     * Same as {@link #isOfType(ObjectSpecification)}, except treating wrapper/primitive the same.
+     */
+    default boolean isOfTypeResolvePrimitive(final ObjectSpecification other) {
+        var thisClass = ClassUtils.resolvePrimitiveIfNecessary(this.getCorrespondingClass());
+        var otherClass = ClassUtils.resolvePrimitiveIfNecessary(other.getCorrespondingClass());
+
+        return thisClass == otherClass
+                || otherClass.isAssignableFrom(thisClass);
+    }
+
     // -- COMMON SUPER TYPE FINDER
 
     /**
diff --git a/core/metamodel/src/main/java/org/apache/causeway/core/metamodel/spec/ObjectSpecificationRecord.java b/core/metamodel/src/main/java/org/apache/causeway/core/metamodel/spec/ObjectSpecificationRecord.java
index 9ae5991d5df..f2f853eba6c 100644
--- a/core/metamodel/src/main/java/org/apache/causeway/core/metamodel/spec/ObjectSpecificationRecord.java
+++ b/core/metamodel/src/main/java/org/apache/causeway/core/metamodel/spec/ObjectSpecificationRecord.java
@@ -109,12 +109,6 @@ public record ObjectSpecificationRecord(
     @Override public Can<ObjectSpecification> interfaces() {
         return hierarchical.interfaces();
     }
-    @Override public boolean isOfType(final ObjectSpecification other) {
-        return hierarchical.isOfType(other);
-    }
-    @Override public boolean isOfTypeResolvePrimitive(final ObjectSpecification other) {
-        return hierarchical.isOfTypeResolvePrimitive(other);
-    }
     @Override public ObjectSpecification superclass() {
         return hierarchical.superclass();
     }
diff --git a/core/metamodel/src/main/java/org/apache/causeway/core/metamodel/spec/impl/HierarchicalFactory.java b/core/metamodel/src/main/java/org/apache/causeway/core/metamodel/spec/impl/HierarchicalFactory.java
new file mode 100644
index 00000000000..9b783067bdc
--- /dev/null
+++ b/core/metamodel/src/main/java/org/apache/causeway/core/metamodel/spec/impl/HierarchicalFactory.java
@@ -0,0 +1,115 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License.
+ */
+package org.apache.causeway.core.metamodel.spec.impl;
+
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.stream.Stream;
+
+import org.apache.causeway.applib.annotation.DomainObject;
+import org.apache.causeway.commons.collections.Can;
+import org.apache.causeway.commons.internal.reflection._ClassCache;
+import org.apache.causeway.core.metamodel.facetapi.FacetHolder;
+import org.apache.causeway.core.metamodel.services.classsubstitutor.ClassSubstitutorRegistry;
+import org.apache.causeway.core.metamodel.spec.Hierarchical;
+import org.apache.causeway.core.metamodel.spec.ObjectSpecification;
+import org.apache.causeway.core.metamodel.specloader.validator.ValidationFailure;
+import org.jspecify.annotations.Nullable;
+
+record HierarchicalFactory(
+		SpecificationLoaderInternal specLoaderInternal,
+		ClassSubstitutorRegistry classSubstitutorRegistry,
+		/** used for validation messages */
+		FacetHolder facetHolder) {
+
+	Hierarchical createHierarchical(final @Nullable Class<?> cls) {
+		return cls!=null
+			? new HierarchicalRecord
+				(Optional.ofNullable(cls.getSuperclass())
+					.map(specLoaderInternal::loadSpecificationTypeOnly),
+				loadInterfaces(cls))
+			: Hierarchical.EMPTY;
+	}
+
+	// -- HELPER
+
+	private record HierarchicalRecord(
+			Optional<ObjectSpecification> superSpec,
+			Can<ObjectSpecification> interfaceSpecs)
+	implements Hierarchical {
+
+		@Override
+		public Can<ObjectSpecification> interfaces() {
+			return interfaceSpecs;
+		}
+
+		@Override
+		public ObjectSpecification superclass() {
+			return superSpec.orElse(null);
+		}
+
+	}
+
+    private Can<ObjectSpecification> loadInterfaces(final Class<?> cls) {
+    	final Class<?>[] interfaces = cls.getInterfaces();
+
+    	if(interfaces==null)
+			return Can.empty();
+
+    	var classCache = _ClassCache.getInstance();
+
+        final List<ObjectSpecification> interfaceSpecList = Stream.of(interfaces)
+    		// pre-filter common interfaces (performance)
+        	.filter(interfaceType->!interfaceType.getName().startsWith("java."))
+        	//--
+        	.map(interfaceType->{
+        		var substitution = classSubstitutorRegistry.getSubstitution(interfaceType);
+                return substitution.isReplace()
+                		? substitution.replacement()
+        				: substitution.isNeverIntrospect()
+    	    				? null
+    	    				: interfaceType;
+        	})
+        	.filter(Objects::nonNull)
+        	.filter(interfaceType->classCache.head(interfaceType).hasAnnotation(DomainObject.class))
+        	.map(specLoaderInternal::loadSpecificationTypeOnly)
+        	.filter(Objects::nonNull)
+        	.toList();
+
+        if(interfaceSpecList.isEmpty())
+        	return Can.empty();
+
+        if(interfaceSpecList.size()>1) {
+        	ValidationFailure.raiseFormatted(facetHolder,
+        			"Cannot use @DomainObject on more than one interface, as inherited by: %s",
+        			cls.getName());
+        }
+        if (cls.getSuperclass() != null) {
+        	if(classCache.head(cls.getSuperclass()).hasAnnotation(DomainObject.class)) {
+        		ValidationFailure.raiseFormatted(facetHolder,
+        				"Cannot use @DomainObject on both, abstract super class and one interface, as inherited by: %s",
+        				cls.getName());
+        	}
+        }
+
+        return Can.ofCollection(interfaceSpecList);
+    }
+
+}
diff --git a/core/metamodel/src/main/java/org/apache/causeway/core/metamodel/spec/impl/ObjectSpecificationDefault.java b/core/metamodel/src/main/java/org/apache/causeway/core/metamodel/spec/impl/ObjectSpecificationDefault.java
index 420793fc7aa..9200579df42 100644
--- a/core/metamodel/src/main/java/org/apache/causeway/core/metamodel/spec/impl/ObjectSpecificationDefault.java
+++ b/core/metamodel/src/main/java/org/apache/causeway/core/metamodel/spec/impl/ObjectSpecificationDefault.java
@@ -18,17 +18,14 @@
  */
 package org.apache.causeway.core.metamodel.spec.impl;
 
-import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
 import java.util.function.Supplier;
-import java.util.stream.Stream;
 
 import org.apache.causeway.applib.Identifier;
-import org.apache.causeway.applib.annotation.DomainObject;
 import org.apache.causeway.applib.annotation.DomainService;
 import org.apache.causeway.applib.annotation.Introspection.IntrospectionPolicy;
 import org.apache.causeway.applib.annotation.ObjectSupport;
@@ -77,12 +74,10 @@
 import org.apache.causeway.core.metamodel.spec.ObjectSpecificationRecord;
 import org.apache.causeway.core.metamodel.spec.feature.ObjectAction;
 import org.apache.causeway.core.metamodel.spec.feature.ObjectMember;
-import org.apache.causeway.core.metamodel.specloader.validator.ValidationFailure;
 import org.apache.causeway.core.metamodel.spi.EntityTitleSubscriber;
 import org.apache.causeway.core.metamodel.util.Facets;
 import org.jspecify.annotations.NonNull;
 import org.springframework.util.Assert;
-import org.springframework.util.ClassUtils;
 
 import lombok.Getter;
 import lombok.experimental.Accessors;
@@ -99,7 +94,6 @@ final class ObjectSpecificationDefault
     // -- CONSTRUCTION
 
     private final FacetedMethodsFactory facetedMethodsFactory;
-    private final ClassSubstitutorRegistry classSubstitutorRegistry;
     private final _Lazy<Boolean> isInjectableLazy;
     private final _Lazy<Boolean> isDomainServiceLazy;
 
@@ -120,6 +114,8 @@ final class ObjectSpecificationDefault
     private ActionContainer objectActionContainer = ActionContainer.EMPTY;
     @Getter @Accessors(fluent = true)
     private MemberCatalog memberCatalog = MemberCatalog.EMPTY;
+    @Getter @Accessors(fluent = true)
+    private Hierarchical hierarchical = Hierarchical.EMPTY;
 
     private final _Lazy<Optional<ObjectSpecification>> elementSpecification =
     		_Lazy.threadSafe(()->lookupFacet(TypeOfFacet.class)
@@ -131,14 +127,6 @@ final class ObjectSpecificationDefault
     @Getter @Accessors(fluent = true)
     private final Set<ResolvedMethod> potentialOrphans = new HashSet<>();
 
-    private final List<ObjectSpecification> interfaces = new ArrayList<>();
-
-    // defensive immutable lazy copy of interfaces
-    private final _Lazy<Can<ObjectSpecification>> unmodifiableInterfaces =
-    		_Lazy.threadSafe(()->Can.ofCollection(interfaces));
-
-    private ObjectSpecification superclassSpec;
-
     private ValueFacet<?> valueFacet;
     private EntityFacet entityFacet;
     private ViewModelFacet viewmodelFacet;
@@ -172,7 +160,6 @@ public ObjectSpecificationDefault(
             Identifier.classIdentifier(logicalType()));
 
         this.postProcessor = postProcessor;
-        this.classSubstitutorRegistry = classSubstitutorRegistry;
 
         // must install EncapsulationFacet (if any) and MemberAnnotationPolicyFacet (if any)
         facetProcessor.processObjectType(typeMeta.getCorrespondingClass(), this);
@@ -185,9 +172,12 @@ public ObjectSpecificationDefault(
         this.facetedMethodsFactory =
                 new FacetedMethodsFactory(this, facetProcessor, classSubstitutorRegistry);
 
+        final var hierarchicalFactory =
+        		new HierarchicalFactory(specLoaderInternal(), classSubstitutorRegistry, facetHolder);
+
         this.introspectionStateHandler = new IntrospectionStateHandlerThreadSafe(
         		()->{
-        			introspectTypeHierarchy();
+        			introspectTypeHierarchy(hierarchicalFactory);
         	        invalidateCachedFacets();
         		},
         		()->{
@@ -212,6 +202,8 @@ public ObjectSpecificationDefault(
 	@Override public boolean isParented() { return containsFacet(ParentedCollectionFacet.class); }
 	@Override public boolean isImmutable() { return containsFacet(ImmutableFacet.class); }
 	@Override public boolean isHidden() { return containsFacet(HiddenFacet.class); }
+	@Override public ObjectSpecification superclass() { return hierarchical.superclass(); }
+    @Override public Can<ObjectSpecification> interfaces() { return hierarchical.interfaces(); }
 
     // -- CONTRACT
 
@@ -233,23 +225,17 @@ public String toString() {
                 : superclass().getFullIdentifier());
     }
 
-    private void introspectTypeHierarchy() {
-
+    private void introspectTypeHierarchy(final HierarchicalFactory hierarchicalFactory) {
         facetedMethodsFactory.introspectClass();
 
         // name
         addNamedFacetIfRequired();
 
         // go no further if a value
-        if(this.isValue()) {
-            if (log.isDebugEnabled()) {
-                log.debug("skipping type hierarchy introspection for value type {}", getFullIdentifier());
-            }
-            return;
-        }
+        if(this.isValue())
+			return;
 
-        loadSpecOfSuperclass(getCorrespondingClass().getSuperclass());
-        loadSpecOfInterfaces(getCorrespondingClass().getInterfaces());
+        this.hierarchical = hierarchicalFactory.createHierarchical(getCorrespondingClass());
     }
 
     private void introspectMembers(final MixinSpecStreamer mixinSpecStreamer) {
@@ -328,69 +314,6 @@ public Optional<ObjectSpecification> explicitElementSpec() {
         return elementSpecification.get();
     }
 
-    private void loadSpecOfSuperclass(final Class<?> superclass) {
-        if (superclass == null)
-			return;
-
-        this.superclassSpec = specLoaderInternal().loadSpecificationTypeOnly(superclass);
-        if (superclassSpec != null
-        		&& log.isDebugEnabled()) {
-            log.debug("  Superclass {}", superclass.getName());
-        }
-    }
-
-    private void loadSpecOfInterfaces(final Class<?>[] interfaces) {
-    	if(interfaces==null)
-			return;
-
-    	var classCache = _ClassCache.getInstance();
-
-        final List<ObjectSpecification> interfaceSpecList = Stream.of(interfaces)
-    		// pre-filter common interfaces (performance)
-        	.filter(interfaceType->!interfaceType.getName().startsWith("java."))
-        	//--
-        	.map(interfaceType->{
-        		var substitution = classSubstitutorRegistry.getSubstitution(interfaceType);
-                return substitution.isReplace()
-                		? substitution.replacement()
-        				: substitution.isNeverIntrospect()
-    	    				? null
-    	    				: interfaceType;
-        	})
-        	.filter(Objects::nonNull)
-        	.filter(interfaceType->classCache.head(interfaceType).hasAnnotation(DomainObject.class))
-        	.map(specLoaderInternal()::loadSpecificationTypeOnly)
-        	.filter(Objects::nonNull)
-        	.toList();
-
-        if(!interfaceSpecList.isEmpty()) {
-        	if(interfaceSpecList.size()>1) {
-              ValidationFailure.raiseFormatted(facetHolder,
-            		  "Cannot use @DomainObject on more than one interface, as inherited by: %s",
-            		  getCorrespondingClass().getName());
-        	}
-        	if (superclassSpec != null) {
-        		var superType = superclassSpec.getCorrespondingClass();
-        		if(classCache.head(superType).hasAnnotation(DomainObject.class)) {
-        			ValidationFailure.raiseFormatted(facetHolder,
-                  		  "Cannot use @DomainObject on both, abstract super class and one interface, as inherited by: %s",
-                  		  getCorrespondingClass().getName());
-        		}
-        	}
-
-//debug
-//        	System.err.println("%s".formatted(getCorrespondingClass().getName()));
-//        	interfaceSpecList.forEach(i->{
-//        		System.err.println("- %s".formatted(i.getCorrespondingClass().getName()));
-//        	});
-        	synchronized(unmodifiableInterfaces) {
-                this.interfaces.clear();
-                this.interfaces.addAll(interfaceSpecList);
-                unmodifiableInterfaces.clear();
-            }
-        }
-    }
-
     private void invalidateCachedFacets() {
         this.valueFacet = getFacet(ValueFacet.class);
         this.titleFacet = lookupNonFallbackFacet(TitleFacet.class).orElse(null);
@@ -494,26 +417,6 @@ private Optional<FontAwesomeLayers> faLayers(final ManagedObject domainObject){
             .map(FaLayersProvider::getLayers);
     }
 
-    // -- HIERARCHICAL
-
-    @Override
-    public boolean isOfType(final ObjectSpecification other) {
-        var thisClass = this.getCorrespondingClass();
-        var otherClass = other.getCorrespondingClass();
-
-        return thisClass == otherClass
-                || otherClass.isAssignableFrom(thisClass);
-    }
-
-    @Override
-    public boolean isOfTypeResolvePrimitive(final ObjectSpecification other) {
-        var thisClass = ClassUtils.resolvePrimitiveIfNecessary(this.getCorrespondingClass());
-        var otherClass = ClassUtils.resolvePrimitiveIfNecessary(other.getCorrespondingClass());
-
-        return thisClass == otherClass
-                || otherClass.isAssignableFrom(thisClass);
-    }
-
     // -- NAME, DESCRIPTION, PERSISTABILITY
 
     @Override
@@ -547,23 +450,11 @@ public final Optional<Contributing> contributing() {
 
     @Override
     public <Q extends Facet> Optional<Q> lookupFacet(final Class<Q> facetType) {
-        synchronized(unmodifiableInterfaces) {
-        	return Hierarchical.lookupFacet(facetType, facetHolder, this);
-        }
+        return Hierarchical.lookupFacet(facetType, facetHolder, this);
     }
 
     // -- INHERITED
 
-    @Override
-    public ObjectSpecification superclass() {
-        return superclassSpec;
-    }
-
-    @Override
-    public Can<ObjectSpecification> interfaces() {
-        return unmodifiableInterfaces.get();
-    }
-
     @Override
     public Optional<? extends ObjectMember> getMember(final String memberId) {
     	introspectFully();
@@ -590,7 +481,7 @@ public ObjectSpecificationRecord toUnmodifiable() {
 				typeMeta,
 				getFeatureType(),
 				facetHolder,
-				this,//Hierarchical,
+				hierarchical,
 				objectActionContainer,
 				objectAssociationContainer,
 				getServiceRegistry().select(EntityTitleSubscriber.class),