come cleanups in CollectionType; use wildcard capture

Author: gavinking

hibernate-core/src/main/java/org/hibernate/type/CollectionType.java

@@ -10,6 +10,7 @@
 import java.sql.SQLException;
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
@@ -491,14 +492,14 @@ public Object replaceElements(
 
 		// copy elements into newly empty target collection
 		final Type elemType = getElementType( session.getFactory() );
-		for ( Object o : (Collection) original ) {
-			result.add( elemType.replace( o, null, session, owner, copyCache ) );
+		for ( Object element : (Collection) original ) {
+			result.add( elemType.replace( element, null, session, owner, copyCache ) );
 		}
 
 		// if the original is a PersistentCollection, and that original
 		// was not flagged as dirty, then reset the target's dirty flag
 		// here after the copy operation.
-		// </p>
+		//
 		// One thing to be careful of here is a "bare" original collection
 		// in which case we should never ever ever reset the dirty flag
 		// on the target because we simply do not know...
@@ -563,30 +564,35 @@ private static Serializable createArraySnapshot(
 		return array;
 	}
 
-	private static Serializable createMapSnapshot(
-			Map<?, ?> map,
+	private static <K,V> Serializable createMapSnapshot(
+			Map<K, V> map,
 			PersistentCollection<?> result,
 			Type elemType,
 			Object owner,
 			Map<Object, Object> copyCache,
 			SharedSessionContractImplementor session) {
-		final Map<?,?> resultSnapshot = (Map<?,?>) result.getStoredSnapshot();
-		final Map<Object, Object> targetMap;
-		if ( map instanceof SortedMap<?,?> sortedMap ) {
-			//noinspection unchecked, rawtypes
-			targetMap = new TreeMap( sortedMap.comparator() );
+		final Map<K, V> targetMap;
+		final Serializable snapshot;
+		if ( map instanceof SortedMap<K,V> sortedMap ) {
+			final TreeMap<K, V> treeMap = new TreeMap<>( sortedMap.comparator() );
+			targetMap = treeMap;
+			snapshot = treeMap;
 		}
 		else {
-			targetMap = mapOfSize( map.size() );
-		}
-		for ( Map.Entry<?,?> entry : map.entrySet() ) {
-			final Object key = entry.getKey();
-			final Object value = entry.getValue();
+			final HashMap<K, V> hashMap = mapOfSize( map.size() );
+			targetMap = hashMap;
+			snapshot = hashMap;
+		}
+		final Map<?, ?> resultSnapshot = (Map<?,?>) result.getStoredSnapshot();
+		for ( Map.Entry<K,V> entry : map.entrySet() ) {
+			final K key = entry.getKey();
+			final V value = entry.getValue();
 			final Object resultSnapshotValue = resultSnapshot == null ? null : resultSnapshot.get( key );
 			final Object newValue = elemType.replace( value, resultSnapshotValue, session, owner, copyCache );
-			targetMap.put( key == value ? newValue : key, newValue );
+			//noinspection unchecked
+			targetMap.put( key == value ? (K) newValue : key, (V) newValue );
 		}
-		return (Serializable) targetMap;
+		return snapshot;
 	}
 
 	private static ArrayList<Object> createListSnapshot(
@@ -650,8 +656,8 @@ private Object replaceOriginal(
 			Object owner,
 			Map<Object, Object> copyCache) {
 
-		//for arrays, replaceElements() may return a different reference, since
-		//the array length might not match
+		// for arrays, replaceElements() may return a different reference, since
+		// the array length might not match
 		final Object result =
 				replaceElements( original,
 						instantiateResultIfNecessary( original, target ),
@@ -663,9 +669,9 @@ private Object replaceOriginal(
 							&& !collection.isDirty();
 			if ( target instanceof PersistentCollection<?> oldCollection
 				&& oldCollection.isDirectlyAccessible() ) {
-				// When a replace/merge is requested and the underlying collection is directly accessible,
-				// use a new persistent collection, to avoid potential issues
-				// like the underlying collection being unmodifiable and hence failing the element replacement
+				// When a replacement or merge is requested and the underlying collection is directly accessible,
+				// use a new persistent collection, to avoid potential issues like the underlying collection being
+				// unmodifiable and hence failing the element replacement
 				final CollectionPersister collectionPersister = getPersister( session );
 				final Object key = oldCollection.getKey();
 				final PersistentCollection<?> newCollection = instantiate( session, collectionPersister, key );
@@ -704,8 +710,8 @@ private Object replaceUninitializedOriginal(
 			Object target,
 			SharedSessionContractImplementor session,
 			Map<Object, Object> copyCache) {
-		final PersistentCollection<?> persistentCollection = (PersistentCollection<?>) original;
-		if ( persistentCollection.hasQueuedOperations() ) {
+		final PersistentCollection<?> collection = (PersistentCollection<?>) original;
+		if ( collection.hasQueuedOperations() ) {
 			if ( original == target ) {
 				// A managed entity with an uninitialized collection is being merged,
 				// We need to replace any detached entities in the queued operations
@@ -716,8 +722,7 @@ private Object replaceUninitializedOriginal(
 			else {
 				// original is a detached copy of the collection;
 				// it contains queued operations, which will be ignored
-				LOG.ignoreQueuedOperationsOnMerge(
-						collectionInfoString( getRole(), persistentCollection.getKey() ) );
+				LOG.ignoreQueuedOperationsOnMerge( collectionInfoString( getRole(), collection.getKey() ) );
 			}
 		}
 		return target;
@@ -827,8 +832,8 @@ else if ( overridingEager != null ? overridingEager : !persister.isLazy() ) {
 			persistenceContext.addCollectionHolder( collection );
 		}
 		if ( LOG.isTraceEnabled() ) {
-			LOG.tracef( "Created collection wrapper: %s",
-					collectionInfoString( persister, collection, key, session ) );
+			LOG.trace( "Created collection wrapper: "
+						+ collectionInfoString( persister, collection, key, session ) );
 		}
 		return collection;
 	}