[#2026] Small refactoring and clean ups

DavideD · DavideD · commit dd7c9c718e03 · 2025-01-20T16:40:47.000+01:00
diff --git a/hibernate-reactive-core/src/main/java/org/hibernate/reactive/engine/impl/CollectionTypes.java b/hibernate-reactive-core/src/main/java/org/hibernate/reactive/engine/impl/CollectionTypes.java
@@ -42,7 +42,6 @@
 import static org.hibernate.pretty.MessageHelper.collectionInfoString;
 import static org.hibernate.reactive.util.impl.CompletionStages.completedFuture;
 import static org.hibernate.reactive.util.impl.CompletionStages.loop;
-import static org.hibernate.reactive.util.impl.CompletionStages.nullFuture;
 import static org.hibernate.reactive.util.impl.CompletionStages.voidFuture;
 
 /**
@@ -81,36 +80,35 @@ public static CompletionStage<Object> replace(
 			Object owner,
 			Map<Object, Object> copyCache) throws HibernateException {
 		if ( original == null ) {
-			return replaceNullOriginal( target, session );
+			return completedFuture( replaceNullOriginal( target, session ) );
 		}
 		else if ( !Hibernate.isInitialized( original ) ) {
-			return replaceUninitializedOriginal( type, original, target, session, copyCache );
+			return completedFuture( replaceUninitializedOriginal( type, original, target, session, copyCache ) );
 		}
 		else {
 			return replaceOriginal( type, original, target, session, owner, copyCache );
 		}
 	}
 
 	// todo: make org.hibernate.type.CollectionType#replaceNullOriginal public ?
-
 	/**
 	 * @see CollectionType#replaceNullOriginal(Object, SharedSessionContractImplementor)
 	 */
-	private static CompletionStage<Object> replaceNullOriginal(
+	private static Object replaceNullOriginal(
 			Object target,
 			SessionImplementor session) {
 		if ( target == null ) {
-			return nullFuture();
+			return null;
 		}
 		else if ( target instanceof Collection<?> ) {
 			Collection<?> collection = (Collection<?>) target;
 			collection.clear();
-			return completedFuture( collection );
+			return collection;
 		}
 		else if ( target instanceof Map<?, ?> ) {
 			Map<?, ?> map = (Map<?, ?>) target;
 			map.clear();
-			return completedFuture( map );
+			return map;
 		}
 		else {
 			final PersistenceContext persistenceContext = session.getPersistenceContext();
@@ -127,18 +125,15 @@ else if ( target instanceof Map<?, ?> ) {
 					arrayHolder.endRead();
 					arrayHolder.dirty();
 					persistenceContext.addCollectionHolder( collectionHolder );
-					return completedFuture( arrayHolder.getArray() );
+					return arrayHolder.getArray();
 				}
 			}
 		}
-		return nullFuture();
+		return null;
 	}
 
 	// todo: make org.hibernate.type.CollectionType#replaceUninitializedOriginal public
-	/**
-	 * @see CollectionType#replaceNullOriginal(Object, SharedSessionContractImplementor)
-	 */
-	private static CompletionStage<Object> replaceUninitializedOriginal(
+	private static Object replaceUninitializedOriginal(
 			CollectionType type,
 			Object original,
 			Object target,
@@ -164,7 +159,7 @@ private static CompletionStage<Object> replaceUninitializedOriginal(
 						collectionInfoString( type.getRole(), persistentCollection.getKey() ) );
 			}
 		}
-		return completedFuture( target );
+		return target;
 	}
 
 	/**
@@ -196,11 +191,11 @@ private static CompletionStage<Object> replaceOriginal(
 				//TODO: this is a little inefficient, don't need to do a whole
 				//      deep replaceElements() call
 				return replaceElements( type, result, target, owner, copyCache, session )
-						.thenCompose( unused -> {
+						.thenApply( unused -> {
 							if ( wasClean ) {
 								( (PersistentCollection<?>) target ).clearDirty();
 							}
-							return completedFuture( target );
+							return target;
 						} );
 			}
 			else {
@@ -296,26 +291,22 @@ private static CompletionStage<Object> replaceMapTypeElements(
 			Object owner,
 			Map<Object, Object> copyCache,
 			SessionImplementor session) {
-		final CollectionPersister persister =
-				session.getFactory().getRuntimeMetamodels().getMappingMetamodel()
-						.getCollectionDescriptor( type.getRole() );
-
+		final CollectionPersister persister = session.getFactory().getRuntimeMetamodels()
+				.getMappingMetamodel().getCollectionDescriptor( type.getRole() );
 		final Map<Object, Object> result = target;
 		result.clear();
 
 		return loop(
 				original.entrySet(), entry -> {
 					final Map.Entry<Object, Object> me = entry;
 					return getReplace( persister.getIndexType(), me.getKey(), owner, session, copyCache )
-							.thenCompose( key ->
-												  getReplace(
-														  persister.getElementType(),
-														  me.getValue(),
-														  owner,
-														  session,
-														  copyCache
-												  ).thenAccept( value ->
-																		result.put( key, value ) )
+							.thenCompose( key -> getReplace(
+												  persister.getElementType(),
+												  me.getValue(),
+												  owner,
+												  session,
+												  copyCache
+										  ).thenAccept( value -> result.put( key, value ) )
 							);
 				}
 		).thenApply( unused -> result );
@@ -340,14 +331,11 @@ private static CompletionStage<Object> replaceArrayTypeElements(
 
 		final Type elemType = type.getElementType( session.getFactory() );
 		return loop(
-				0, length, i -> {
-					return getReplace( elemType, Array.get( original, i ), owner, session, copyCache )
-							.thenApply( o -> {
-											Array.set( result, i, o );
-											return result;
-										}
-							);
-				}
+				0, length, i -> getReplace( elemType, Array.get( original, i ), owner, session, copyCache )
+						.thenApply( o -> {
+							Array.set( result, i, o );
+							return result;
+						} )
 		).thenApply( unused -> result );
 	}
 
@@ -389,8 +377,7 @@ private static CompletionStage<Void> preserveSnapshot(
 		final CollectionEntry ce = session.getPersistenceContextInternal().getCollectionEntry( result );
 		if ( ce != null ) {
 			return createSnapshot( original, result, elemType, owner, copyCache, session )
-					.thenAccept( serializable ->
-										 ce.resetStoredSnapshot( result, serializable ) );
+					.thenAccept( serializable -> ce.resetStoredSnapshot( result, serializable ) );
 		}
 		return voidFuture();
 	}
@@ -434,14 +421,8 @@ private static CompletionStage<Serializable> createArraySnapshot(
 			Map<Object, Object> copyCache,
 			SessionImplementor session) {
 		return loop(
-				0, array.length,
-				i ->
-						getReplace( elemType, array[i], owner, session, copyCache )
-								.thenCompose( o -> {
-												  array[i] = o;
-												  return voidFuture();
-											  }
-								)
+				0, array.length, i -> getReplace( elemType, array[i], owner, session, copyCache )
+						.thenAccept( o -> array[i] = o )
 		).thenApply( unused -> array );
 	}
 
@@ -468,10 +449,9 @@ private static CompletionStage<Serializable> createMapSnapshot(
 		return loop(
 				map.entrySet(), entry ->
 						getReplace( elemType, entry.getValue(), resultSnapshot, owner, session, copyCache )
-								.thenCompose( newValue -> {
+								.thenAccept( newValue -> {
 									final Object key = entry.getKey();
 									targetMap.put( key == entry.getValue() ? newValue : key, newValue );
-									return voidFuture();
 								} )
 		).thenApply( v -> (Serializable) targetMap );
 	}
@@ -487,12 +467,8 @@ private static CompletionStage<Serializable> createListSnapshot(
 			SessionImplementor session) {
 		final ArrayList<Object> targetList = new ArrayList<>( list.size() );
 		return loop(
-				list, obj ->
-						getReplace( elemType, obj, owner, session, copyCache )
-								.thenCompose( o -> {
-									targetList.add( o );
-									return voidFuture();
-								} )
+				list, obj -> getReplace( elemType, obj, owner, session, copyCache )
+						.thenAccept( targetList::add )
 		).thenApply( unused -> targetList );
 	}
 
@@ -507,10 +483,8 @@ private static Object instantiateResultIfNecessary(CollectionType type, Object o
 		return target == null
 				|| target == original
 				|| target == UNFETCHED_PROPERTY
-				|| target instanceof PersistentCollection<?> && ( (PersistentCollection<?>) target).isWrapper( original ) ?
-				type.instantiate( -1 ) :
-				target;
+				|| target instanceof PersistentCollection<?> && ( (PersistentCollection<?>) target).isWrapper( original )
+				? type.instantiate( -1 )
+				: target;
 	}
-
-
 }
diff --git a/hibernate-reactive-core/src/main/java/org/hibernate/reactive/engine/impl/EntityTypes.java b/hibernate-reactive-core/src/main/java/org/hibernate/reactive/engine/impl/EntityTypes.java
@@ -160,10 +160,7 @@ public static CompletionStage<Object[]> replace(
 			final Map<Object, Object> copyCache) {
 		Object[] copied = new Object[original.length];
 		return loop(
-				0, types.length,
-				i ->
-						replace( original, target, types, session, owner, copyCache, i, copied )
-
+				0, types.length, i -> replace( original, target, types, session, owner, copyCache, i, copied )
 		).thenApply( v -> copied );
 	}
 
@@ -181,9 +178,7 @@ public static CompletionStage<Object[]> replace(
 		Object[] copied = new Object[original.length];
 		return loop(
 				0, types.length,
-				i ->
-						replace( original, target, types, session, owner, copyCache, foreignKeyDirection, i, copied )
-
+				i -> replace( original, target, types, session, owner, copyCache, foreignKeyDirection, i, copied )
 		).thenApply( v -> copied );
 	}
 
@@ -274,15 +269,16 @@ private static CompletionStage<Object> resolveIdOrUniqueKey(
 					// as a ComponentType. In the case that the entity is unfetched, we need to
 					// explicitly fetch it here before calling replace(). (Note that in Hibernate
 					// ORM this is unnecessary due to transparent lazy fetching.)
-					return ( (ReactiveSessionImpl) session ).reactiveFetch( id, true )
+					return ( (ReactiveSessionImpl) session )
+							.reactiveFetch( id, true )
 							.thenCompose( fetched -> {
-								Object idOrUniqueKey = entityType.getIdentifierOrUniqueKeyType( session.getFactory() )
+								Object idOrUniqueKey = entityType
+										.getIdentifierOrUniqueKeyType( session.getFactory() )
 										.replace( fetched, null, session, owner, copyCache );
 								if ( idOrUniqueKey instanceof CompletionStage ) {
 									return ( (CompletionStage<?>) idOrUniqueKey )
 											.thenCompose( key -> resolve( entityType, key, owner, session ) );
 								}
-
 								return resolve( entityType, idOrUniqueKey, owner, session );
 							} );
 				} );
