cleanups around CallbackRegistryImpl

Author: gavinking

hibernate-core/src/main/java/org/hibernate/internal/util/collections/ArrayHelper.java

@@ -212,6 +212,15 @@ public static <T> T[] join(T[] x, T... y) {
 		return result;
 	}
 
+	@SuppressWarnings("unchecked")
+	@AllowReflection
+	public static <T> T[] add(T[] x, T y) {
+		T[] result = (T[]) Array.newInstance( x.getClass().getComponentType(), x.length + 1 );
+		System.arraycopy( x, 0, result, 0, x.length );
+		result[x.length] = y;
+		return result;
+	}
+
 	public static final boolean[] TRUE = {true};
 	public static final boolean[] FALSE = {false};
 

hibernate-core/src/main/java/org/hibernate/internal/util/collections/MapBackedClassValue.java

@@ -18,7 +18,7 @@
  * @author Sanne Grinovero
  * @since 6.2
  */
-public final class MapBackedClassValue<V> implements ReadOnlyMap<Class,V> {
+public final class MapBackedClassValue<V> implements ReadOnlyMap<Class<?>,V> {
 
 	private volatile Map<Class<?>, V> map;
 
@@ -44,7 +44,7 @@ public MapBackedClassValue(final Map<Class<?>, V> map) {
 	}
 
 	@Override
-	public V get(Class key) {
+	public V get(Class<?> key) {
 		return classValue.get( key );
 	}
 

hibernate-core/src/main/java/org/hibernate/jpa/event/internal/CallbackRegistryImpl.java

@@ -7,7 +7,6 @@
 import java.util.HashMap;
 import java.util.Map;
 
-import jakarta.persistence.PersistenceException;
 
 import org.hibernate.internal.build.AllowReflection;
 import org.hibernate.internal.util.collections.ArrayHelper;
@@ -26,13 +25,13 @@
  */
 final class CallbackRegistryImpl implements CallbackRegistry {
 
-	private final ReadOnlyMap<Class,Callback[]> preCreates;
-	private final ReadOnlyMap<Class,Callback[]> postCreates;
-	private final ReadOnlyMap<Class,Callback[]> preRemoves;
-	private final ReadOnlyMap<Class,Callback[]> postRemoves;
-	private final ReadOnlyMap<Class,Callback[]> preUpdates;
-	private final ReadOnlyMap<Class,Callback[]> postUpdates;
-	private final ReadOnlyMap<Class,Callback[]> postLoads;
+	private final ReadOnlyMap<Class<?>,Callback[]> preCreates;
+	private final ReadOnlyMap<Class<?>,Callback[]> postCreates;
+	private final ReadOnlyMap<Class<?>,Callback[]> preRemoves;
+	private final ReadOnlyMap<Class<?>,Callback[]> postRemoves;
+	private final ReadOnlyMap<Class<?>,Callback[]> preUpdates;
+	private final ReadOnlyMap<Class<?>,Callback[]> postUpdates;
+	private final ReadOnlyMap<Class<?>,Callback[]> postLoads;
 
 	public CallbackRegistryImpl(
 			Map<Class<?>, Callback[]> preCreates,
@@ -51,19 +50,15 @@ public CallbackRegistryImpl(
 		this.postLoads = createBackingMap( postLoads );
 	}
 
-	private static ReadOnlyMap<Class, Callback[]> createBackingMap(final Map<Class<?>, Callback[]> src) {
-		if ( src == null || src.isEmpty() ) {
-			return ReadOnlyMap.EMPTY;
-		}
-		else {
-			return new MapBackedClassValue<>( src );
-		}
+	private static ReadOnlyMap<Class<?>, Callback[]> createBackingMap(final Map<Class<?>, Callback[]> src) {
+		return src == null || src.isEmpty()
+				? ReadOnlyMap.EMPTY
+				: new MapBackedClassValue<>( src );
 	}
 
 	@Override
 	public boolean hasRegisteredCallbacks(Class<?> entityClass, CallbackType callbackType) {
-		final ReadOnlyMap<Class,Callback[]> map = determineAppropriateCallbackMap( callbackType );
-		return notEmpty( map.get( entityClass ) );
+		return notEmpty( getCallbackMap( callbackType ).get( entityClass ) );
 	}
 
 	@Override
@@ -128,39 +123,21 @@ private boolean callback(Callback[] callbacks, Object bean) {
 		}
 	}
 
-	private ReadOnlyMap<Class,Callback[]> determineAppropriateCallbackMap(CallbackType callbackType) {
-		if ( callbackType == CallbackType.PRE_PERSIST ) {
-			return preCreates;
-		}
-
-		if ( callbackType == CallbackType.POST_PERSIST ) {
-			return postCreates;
-		}
-
-		if ( callbackType == CallbackType.PRE_REMOVE ) {
-			return preRemoves;
-		}
-
-		if ( callbackType == CallbackType.POST_REMOVE ) {
-			return postRemoves;
-		}
-
-		if ( callbackType == CallbackType.PRE_UPDATE ) {
-			return preUpdates;
-		}
-
-		if ( callbackType == CallbackType.POST_UPDATE ) {
-			return postUpdates;
-		}
-
-		if ( callbackType == CallbackType.POST_LOAD ) {
-			return postLoads;
-		}
-
-		throw new PersistenceException( "Unrecognized JPA callback type [" + callbackType + "]" );
+	private ReadOnlyMap<Class<?>,Callback[]> getCallbackMap(CallbackType callbackType) {
+		return switch ( callbackType ) {
+			case PRE_PERSIST -> preCreates;
+			case POST_PERSIST -> postCreates;
+			case PRE_REMOVE -> preRemoves;
+			case POST_REMOVE -> postRemoves;
+			case PRE_UPDATE -> preUpdates;
+			case POST_UPDATE -> postUpdates;
+			case POST_LOAD -> postLoads;
+		};
 	}
 
 	public static class Builder {
+		private static final Callback[] NO_CALLBACKS = new Callback[0];
+
 		private final Map<Class<?>, Callback[]> preCreates = new HashMap<>();
 		private final Map<Class<?>, Callback[]> postCreates = new HashMap<>();
 		private final Map<Class<?>, Callback[]> preRemoves = new HashMap<>();
@@ -173,50 +150,30 @@ public static class Builder {
 		public void registerCallbacks(Class<?> entityClass, Callback[] callbacks) {
 			if ( callbacks != null ) {
 				for ( Callback callback : callbacks ) {
-					final Map<Class<?>, Callback[]> map = determineAppropriateCallbackMap( callback.getCallbackType() );
-					Callback[] entityCallbacks = map.get( entityClass );
-					if ( entityCallbacks == null ) {
-						entityCallbacks = new Callback[0];
-					}
-					entityCallbacks = ArrayHelper.join( entityCallbacks, callback );
-					map.put( entityClass, entityCallbacks );
+					addCallback( entityClass, callback );
 				}
 			}
 		}
 
-		private Map<Class<?>, Callback[]> determineAppropriateCallbackMap(CallbackType callbackType) {
-			if ( callbackType == CallbackType.PRE_PERSIST ) {
-				return preCreates;
-			}
-
-			if ( callbackType == CallbackType.POST_PERSIST ) {
-				return postCreates;
-			}
-
-			if ( callbackType == CallbackType.PRE_REMOVE ) {
-				return preRemoves;
-			}
-
-			if ( callbackType == CallbackType.POST_REMOVE ) {
-				return postRemoves;
-			}
-
-			if ( callbackType == CallbackType.PRE_UPDATE ) {
-				return preUpdates;
-			}
-
-			if ( callbackType == CallbackType.POST_UPDATE ) {
-				return postUpdates;
-			}
-
-			if ( callbackType == CallbackType.POST_LOAD ) {
-				return postLoads;
-			}
+		public void addCallback(Class<?> entityClass, Callback callback) {
+			final var callbackMap = getCallbackMap( callback.getCallbackType() );
+			final Callback[] existingCallbacks = callbackMap.getOrDefault( entityClass, NO_CALLBACKS );
+			callbackMap.put( entityClass, ArrayHelper.add( existingCallbacks, callback ) );
+		}
 
-			throw new PersistenceException( "Unrecognized JPA callback type [" + callbackType + "]" );
+		private Map<Class<?>, Callback[]> getCallbackMap(CallbackType callbackType) {
+			return switch ( callbackType ) {
+				case PRE_PERSIST -> preCreates;
+				case POST_PERSIST -> postCreates;
+				case PRE_REMOVE -> preRemoves;
+				case POST_REMOVE -> postRemoves;
+				case PRE_UPDATE -> preUpdates;
+				case POST_UPDATE -> postUpdates;
+				case POST_LOAD -> postLoads;
+			};
 		}
 
-		protected CallbackRegistryImpl build() {
+		protected CallbackRegistry build() {
 			return new CallbackRegistryImpl( preCreates, postCreates, preRemoves, postRemoves, preUpdates, postUpdates, postLoads );
 		}