#128 - Track interface implementors

Author: sebersole

hibernate-models/src/main/java/org/hibernate/models/internal/AbstractClassDetailsRegistry.java

@@ -6,11 +6,15 @@
 
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Predicate;
 
 import org.hibernate.models.UnknownClassException;
+import org.hibernate.models.internal.util.CollectionHelper;
 import org.hibernate.models.spi.ClassDetails;
 import org.hibernate.models.spi.ModelsContext;
 import org.hibernate.models.spi.TypeDetails;
@@ -31,18 +35,18 @@ public abstract class AbstractClassDetailsRegistry implements MutableClassDetail
 	protected final Map<String, ClassDetails> classDetailsMap;
 
 	// subtype per type
-	protected final Map<String, List<ClassDetails>> directSubTypeMap;
+	protected final Map<String, Set<ClassDetails>> directSubTypeMap;
 	// implementor by interface
-	protected final Map<String, List<ClassDetails>> directImplementorMap;
+	protected final Map<String, Set<ClassDetails>> directImplementorMap;
 
 	protected AbstractClassDetailsRegistry(ModelsContext context) {
 		this( new ConcurrentHashMap<>(), new ConcurrentHashMap<>(), new ConcurrentHashMap<>(), context );
 	}
 
 	protected AbstractClassDetailsRegistry(
 			Map<String, ClassDetails> classDetailsMap,
-			Map<String, List<ClassDetails>> directSubTypeMap,
-			Map<String, List<ClassDetails>> directImplementorMap,
+			Map<String, Set<ClassDetails>> directSubTypeMap,
+			Map<String, Set<ClassDetails>> directImplementorMap,
 			ModelsContext context) {
 		this.classDetailsMap = classDetailsMap;
 		this.directSubTypeMap = directSubTypeMap;
@@ -56,8 +60,17 @@ protected AbstractClassDetailsRegistry(
 	}
 
 	@Override
-	public List<ClassDetails> getDirectSubTypes(String superTypeName) {
-		return directSubTypeMap.get( superTypeName );
+	public List<ClassDetails> getDirectSubTypes(String typeName) {
+		final Set<ClassDetails> directSubtypes = getDirectSubtypes( typeName );
+		return CollectionHelper.isNotEmpty( directSubtypes )
+				? new ArrayList<>( directSubtypes )
+				: List.of();
+	}
+
+	@Override
+	public Set<ClassDetails> getDirectSubtypes(String typeName) {
+		final Set<ClassDetails> directSubtypes = directSubTypeMap.get( typeName );
+		return directSubtypes != null ? directSubtypes : Set.of();
 	}
 
 	@Override
@@ -72,58 +85,81 @@ public void forEachDirectSubType(String superTypeName, ClassDetailsConsumer cons
 	}
 
 	@Override
-	public List<ClassDetails> getDirectImplementors(String interfaceName) {
-		return directImplementorMap.get( interfaceName );
+	public Set<ClassDetails> getDirectImplementors(String interfaceName) {
+		final Set<ClassDetails> implementors = directImplementorMap.get( interfaceName );
+		return implementors != null ? implementors : Set.of();
 	}
 
 	@Override
 	public void forEachDirectImplementor(String interfaceName, ClassDetailsConsumer consumer) {
-		final List<ClassDetails> directImplementors = getDirectImplementors( interfaceName );
+		final Set<ClassDetails> directImplementors = getDirectImplementors( interfaceName );
 		if ( directImplementors != null ) {
 			directImplementors.forEach( consumer::consume );
 		}
 	}
 
 	@Override
-	public List<ClassDetails> findConcreteTypes(String base) {
-		final List<ClassDetails> result = new ArrayList<>();
+	public Set<ClassDetails> findConcreteTypes(String base, boolean includeBase) {
+		final Set<ClassDetails> result = new LinkedHashSet<>();
+		walkImplementors( base, includeBase, classDetails -> {
+			if ( !classDetails.isAbstract() && !classDetails.isInterface() ) {
+				result.add( classDetails );
+			}
 
-		forEachDirectSubType( base, (subType) -> {
-			if ( !subType.isAbstract() ) {
-				result.add( subType );
+		});
+		return result;
+	}
+
+	@Override
+	public Set<ClassDetails> collectImplementors(String base, boolean includeBase, Predicate<ClassDetails> exclusions) {
+		final Set<ClassDetails> result = new LinkedHashSet<>();
+		walkImplementors( base, includeBase, classDetails -> {
+			if ( exclusions == null || !exclusions.test( classDetails ) ) {
+				result.add( classDetails );
 			}
-			collectConcreteTypesFromClass( subType, result::add );
 		} );
+		return result;
+	}
 
-		forEachDirectImplementor( base, (implementor) -> {
-			collectConcreteTypesFromInterfaceImplementor( implementor, result::add );
+	@Override
+	public void walkImplementors(String base, boolean includeBase, ClassDetailsConsumer consumer) {
+		if ( includeBase ) {
+			final ClassDetails baseDetails = resolveClassDetails( base );
+			consumer.consume( baseDetails );
+		}
+
+		forEachDirectSubType( base, (subType) -> {
+			consumer.consume( subType );
+			walkSubtypes( subType, consumer );
 		} );
 
-		return result;
+		forEachDirectImplementor( base, (implementor) -> {
+			consumer.consume( implementor );
+			walkInterfaceImplementors( implementor, consumer );
+		} );
 	}
 
-	private void collectConcreteTypesFromClass(ClassDetails base, ClassDetailsConsumer collector) {
+	private void walkSubtypes(ClassDetails base, ClassDetailsConsumer consumer) {
 		forEachDirectSubType( base.getName(), (subType) -> {
-			if ( !subType.isAbstract() ) {
-				collector.consume( subType );
-			}
-			collectConcreteTypesFromClass( subType, collector );
+			consumer.consume( subType );
+			walkSubtypes( subType, consumer );
 		} );
 	}
 
-	private void collectConcreteTypesFromInterfaceImplementor(ClassDetails implementor, ClassDetailsConsumer collector) {
+	private void walkInterfaceImplementors(ClassDetails implementor, ClassDetailsConsumer consumer) {
 		if ( implementor.isInterface() ) {
 			// the direct interface implementor is itself an interface...
 			forEachDirectImplementor( implementor.getName(), (implementorImplementor) -> {
-				collectConcreteTypesFromInterfaceImplementor( implementor, collector );
+				consumer.consume( implementorImplementor );
+				walkInterfaceImplementors( implementorImplementor, consumer );
 			} );
 		}
 		else {
 			// the direct interface implementor is itself a class...
-			if ( !implementor.isAbstract() ) {
-				collector.consume( implementor );
-			}
-			collectConcreteTypesFromClass( implementor, collector );
+			forEachDirectSubType( implementor.getName(), (subtype) -> {
+				consumer.consume( subtype );
+				walkSubtypes( subtype, consumer );
+			} );
 		}
 	}
 
@@ -180,10 +216,10 @@ public void addClassDetails(String name, ClassDetails classDetails) {
 		classDetailsMap.put( name, classDetails );
 
 		if ( classDetails.getSuperClass() != null ) {
-			List<ClassDetails> subTypes = directSubTypeMap.get( classDetails.getSuperClass().getName() );
+			Set<ClassDetails> subTypes = directSubTypeMap.get( classDetails.getSuperClass().getName() );
 			//noinspection Java8MapApi
 			if ( subTypes == null ) {
-				subTypes = new ArrayList<>();
+				subTypes = new LinkedHashSet<>();
 				directSubTypeMap.put( classDetails.getSuperClass().getName(), subTypes );
 			}
 			subTypes.add( classDetails );
@@ -192,9 +228,9 @@ public void addClassDetails(String name, ClassDetails classDetails) {
 		final List<TypeDetails> implementedInterfaces = classDetails.getImplementedInterfaces();
 		if ( implementedInterfaces != null ) {
 			implementedInterfaces.forEach( (implementedInterface) -> {
-				final List<ClassDetails> directImplementors = directImplementorMap.computeIfAbsent(
+				final Set<ClassDetails> directImplementors = directImplementorMap.computeIfAbsent(
 						implementedInterface.getName(),
-						(interfaceName) -> new ArrayList<>()
+						(interfaceName) -> new LinkedHashSet<>()
 				);
 				directImplementors.add( classDetails );
 			} );
@@ -244,7 +280,11 @@ public Map<String, ClassDetails> getClassDetailsMap() {
 		return Collections.unmodifiableMap( classDetailsMap );
 	}
 
-	public Map<String, List<ClassDetails>> getDirectSubTypeMap() {
+	public Map<String, Set<ClassDetails>> getDirectSubTypeMap() {
 		return Collections.unmodifiableMap( directSubTypeMap );
 	}
+
+	public Map<String, Set<ClassDetails>> getDirectImplementorMap() {
+		return Collections.unmodifiableMap( directImplementorMap );
+	}
 }

hibernate-models/src/main/java/org/hibernate/models/spi/ClassDetailsRegistry.java

@@ -5,6 +5,8 @@
 package org.hibernate.models.spi;
 
 import java.util.List;
+import java.util.Set;
+import java.util.function.Predicate;
 
 import org.hibernate.models.UnknownClassException;
 
@@ -18,6 +20,12 @@
  * @author Steve Ebersole
  */
 public interface ClassDetailsRegistry {
+	/**
+	 * Resolves a managed-class by name.  If there is currently no such registration,
+	 * one is created.
+	 */
+	ClassDetails resolveClassDetails(String name);
+
 	/**
 	 * Find the managed-class with the given {@code name}, if there is one.
 	 * Returns {@code null} if there are none registered with that name.
@@ -48,11 +56,18 @@ default ClassDetails getClassDetails(String name) {
 	void forEachClassDetails(ClassDetailsConsumer consumer);
 
 	/**
-	 * Get the list of all direct subtypes for the named managed-class.  Returns
-	 * {@code null} if there are none
+	 * Get the list of all direct subtypes for the named managed-class.
+	 *
+	 * @deprecated Use {@linkplain #getDirectSubtypes(String)} instead.
 	 */
+	@Deprecated
 	List<ClassDetails> getDirectSubTypes(String superTypeName);
 
+	/**
+	 * Get the list of all direct subtypes for the named managed-class.
+	 */
+	Set<ClassDetails> getDirectSubtypes(String superTypeName);
+
 	/**
 	 * Visit each direct subtype of the named managed-class
 	 */
@@ -61,12 +76,18 @@ default ClassDetails getClassDetails(String name) {
 
 	/**
 	 * Get the list of all direct implementors for the named interface.
-	 * Returns {@code null} if there are none.
+	 *
+	 * @return The direct implementors of the named interface.
+	 *
+	 * @apiNote Does not verify that {@code interfaceName} actually names an interface.
 	 */
-	List<ClassDetails> getDirectImplementors(String interfaceName);
+	Set<ClassDetails> getDirectImplementors(String interfaceName);
 
 	/**
 	 * Visit each direct implementor of the named interface
+	 *
+	 * @apiNote Does not verify that {@code interfaceName} actually names an
+	 * interface.  If it does not, no callbacks will happen.
 	 */
 	@SuppressWarnings("unused")
 	void forEachDirectImplementor(String interfaceName, ClassDetailsConsumer consumer);
@@ -75,27 +96,71 @@ default ClassDetails getClassDetails(String name) {
 	 * Find ClassDetails for all non-abstract subtypes / implementors
 	 * of the given base (which might be a class or interface).
 	 *
+	 * @param base The name of the class/interface from which to start walking.
+	 *
+	 * @apiNote If {@code base} is a concrete type, it will also be returned.
+	 * @see #findConcreteTypes(String, boolean)
+	 */
+	default Set<ClassDetails> findConcreteTypes(String base) {
+		return findConcreteTypes( base, true );
+	}
+
+	/**
+	 * Find ClassDetails for all non-abstract subtypes / implementors
+	 * of the given base (which might be a class or interface).
+	 *
+	 * @param base The name of the class/interface from which to start walking.
+	 * @param includeBase Whether to include {@code base} if it is concrete type.
+	 *
 	 * @see #getDirectSubTypes
 	 * @see #getDirectImplementors
 	 */
-	List<ClassDetails> findConcreteTypes(String base);
+	Set<ClassDetails> findConcreteTypes(String base, boolean includeBase);
 
 	/**
-	 * Resolves a managed-class by name.  If there is currently no such registration,
-	 * one is created.
+	 * Walks the inheritance tree downward, starting from {@code base},
+	 * calling the consumer for each subclass and interface which is directly
+	 * an implementor.
+	 *
+	 * @param base The type from which to start.
+	 * @param includeBase Whether to include {@code base} if it is concrete type.
+	 * @param consumer The callback.
 	 */
-	ClassDetails resolveClassDetails(String name);
+	void walkImplementors(String base, boolean includeBase, ClassDetailsConsumer consumer);
 
-	default <S> S as(Class<S> type) {
-		//noinspection unchecked
-		return (S) this;
+	/**
+	 * Walks the inheritance tree, starting from {@code base}, "downward"
+	 * calling the consumer for each subclass and interface which is directly
+	 * an implementor.
+	 *
+	 * @param base The type from which to start.
+	 * @param includeBase Whether to include {@code base} if it is concrete type.
+	 */
+	default Set<ClassDetails> collectImplementors(String base, boolean includeBase) {
+		return collectImplementors( base, includeBase, null );
 	}
 
+	/**
+	 * Walks the inheritance tree, starting from {@code base}, "downward"
+	 * calling the consumer for each subclass and interface which is directly
+	 * an implementor.
+	 *
+	 * @param base The type from which to start.
+	 * @param includeBase Whether to include {@code base} if it is concrete type.
+	 * @param exclusions Exclusive check to filter ClassDetails out of the result.
+	 */
+	Set<ClassDetails> collectImplementors(String base, boolean includeBase, Predicate<ClassDetails> exclusions);
+
 	/**
 	 * Access to the ClassDetailsBuilder used in this registry
 	 */
 	ClassDetailsBuilder getClassDetailsBuilder();
 
+	default <S> S as(Class<S> type) {
+		//noinspection unchecked
+		return (S) this;
+	}
+
 	@FunctionalInterface
 	interface ClassDetailsConsumer {
 		void consume(ClassDetails classDetails);

hibernate-models/src/test/java/org/hibernate/models/testing/tests/classes/Customer.java

@@ -0,0 +1,11 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ * Copyright: Red Hat Inc. and Hibernate Authors
+ */
+package org.hibernate.models.testing.tests.classes;
+
+/**
+ * @author Steve Ebersole
+ */
+public interface Customer extends Person {
+}

hibernate-models/src/test/java/org/hibernate/models/testing/tests/classes/CustomerImpl.java

@@ -0,0 +1,11 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ * Copyright: Red Hat Inc. and Hibernate Authors
+ */
+package org.hibernate.models.testing.tests.classes;
+
+/**
+ * @author Steve Ebersole
+ */
+public class CustomerImpl extends PersonImpl implements Customer {
+}

hibernate-models/src/test/java/org/hibernate/models/testing/tests/classes/Employee.java

@@ -0,0 +1,11 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ * Copyright: Red Hat Inc. and Hibernate Authors
+ */
+package org.hibernate.models.testing.tests.classes;
+
+/**
+ * @author Steve Ebersole
+ */
+public interface Employee extends Person {
+}

hibernate-models/src/test/java/org/hibernate/models/testing/tests/classes/EmployeeImpl.java

@@ -0,0 +1,11 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ * Copyright: Red Hat Inc. and Hibernate Authors
+ */
+package org.hibernate.models.testing.tests.classes;
+
+/**
+ * @author Steve Ebersole
+ */
+public class EmployeeImpl extends PersonImpl implements Employee {
+}