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),