miscellaneous code cleanups

Author: gavinking

hibernate-core/src/main/java/org/hibernate/boot/model/internal/GeneratorBinder.java

@@ -43,7 +43,6 @@
 import org.hibernate.internal.CoreLogging;
 import org.hibernate.internal.CoreMessageLogger;
 import org.hibernate.internal.util.StringHelper;
-import org.hibernate.internal.util.collections.CollectionHelper;
 import org.hibernate.mapping.GeneratorCreator;
 import org.hibernate.mapping.KeyValue;
 import org.hibernate.mapping.PersistentClass;
@@ -74,6 +73,7 @@
 import static org.hibernate.id.IdentifierGenerator.GENERATOR_NAME;
 import static org.hibernate.internal.util.NullnessUtil.castNonNull;
 import static org.hibernate.internal.util.StringHelper.qualify;
+import static org.hibernate.internal.util.collections.CollectionHelper.combineUntyped;
 import static org.hibernate.resource.beans.internal.Helper.allowExtensionsInCdi;
 
 /**
@@ -883,7 +883,7 @@ static void createIdGeneratorsFromGeneratorAnnotations(
 					Locale.ROOT,
 					"Identifier attribute '%s' has too many generator annotations: %s",
 					getPath( propertyHolder, inferredData ),
-					CollectionHelper.combineUntyped( idGeneratorAnnotations, generatorAnnotations )
+					combineUntyped( idGeneratorAnnotations, generatorAnnotations )
 			) );
 		}
 		if ( !idGeneratorAnnotations.isEmpty() ) {

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

@@ -5,7 +5,6 @@
 package org.hibernate.internal.util.collections;
 
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
@@ -20,6 +19,13 @@
 import java.util.function.BiConsumer;
 import java.util.function.Function;
 
+import static java.util.Arrays.asList;
+import static java.util.Collections.emptyList;
+import static java.util.Collections.emptyMap;
+import static java.util.Collections.emptySet;
+import static java.util.Collections.singletonList;
+import static java.util.Collections.singletonMap;
+
 /**
  * Various helper util methods for handling collections.
  *
@@ -130,7 +136,7 @@ public static <K> LinkedHashSet<K> linkedSet() {
 	 *
 	 * @return The proper size.
 	 */
-	public static int determineProperSizing(Map original) {
+	public static int determineProperSizing(Map<?,?> original) {
 		return determineProperSizing( original.size() );
 	}
 
@@ -147,17 +153,12 @@ public static <K, V> HashMap<K, V> makeCopy(
 		if ( original == null ) {
 			return null;
 		}
-
-		final HashMap<K, V> copy = new HashMap<>( determineProperSizing( original ) );
-
-		original.forEach(
-				(key, value) -> copy.put(
-						keyTransformer.apply( key ),
-						valueTransformer.apply( value )
-				)
-		);
-
-		return copy;
+		else {
+			final HashMap<K, V> copy = new HashMap<>( determineProperSizing( original ) );
+			original.forEach( (key, value) -> copy.put( keyTransformer.apply( key ),
+					valueTransformer.apply( value ) ) );
+			return copy;
+		}
 	}
 
 	public static <K, V> Map<K, V> makeMap(
@@ -171,19 +172,15 @@ public static <K, V, E> Map<K, V> makeMap(
 			Function<E,K> keyProducer,
 			Function<E,V> valueProducer) {
 		if ( isEmpty( collection ) ) {
-			return Collections.emptyMap();
+			return emptyMap();
 		}
-
-		final Map<K, V> map = new HashMap<>( determineProperSizing( collection.size() ));
-
-		for ( E element : collection ) {
-			map.put(
-					keyProducer.apply( element ),
-					valueProducer.apply( element )
-			);
+		else {
+			final Map<K, V> map = new HashMap<>( determineProperSizing( collection.size() ) );
+			for ( E element : collection ) {
+				map.put( keyProducer.apply( element ), valueProducer.apply( element ) );
+			}
+			return map;
 		}
-
-		return map;
 	}
 
 	/**
@@ -194,7 +191,7 @@ public static <K, V, E> Map<K, V> makeMap(
 	 *
 	 * @return The proper size.
 	 */
-	public static int determineProperSizing(Set original) {
+	public static int determineProperSizing(Set<?> original) {
 		return determineProperSizing( original.size() );
 	}
 
@@ -207,8 +204,7 @@ public static int determineProperSizing(Set original) {
 	 * @return The proper size.
 	 */
 	public static int determineProperSizing(int numberOfElements) {
-		int actual = ( (int) ( numberOfElements / LOAD_FACTOR ) ) + 1;
-		return Math.max( actual, MINIMUM_INITIAL_CAPACITY );
+		return Math.max( ( (int) ( numberOfElements / LOAD_FACTOR ) ) + 1, MINIMUM_INITIAL_CAPACITY );
 	}
 
 	/**
@@ -255,26 +251,26 @@ public static <T> Set<T> makeCopy(Set<T> source) {
 		if ( source == null ) {
 			return null;
 		}
-
-		final int size = source.size();
-		final Set<T> copy = CollectionHelper.setOfSize( size + 1 );
-		copy.addAll( source );
-		return copy;
+		else {
+			final Set<T> copy = setOfSize( source.size() + 1 );
+			copy.addAll( source );
+			return copy;
+		}
 	}
 
 	public static boolean isEmpty(Collection<?> collection) {
 		return collection == null || collection.isEmpty();
 	}
 
-	public static boolean isEmpty(Map map) {
+	public static boolean isEmpty(Map<?,?> map) {
 		return map == null || map.isEmpty();
 	}
 
-	public static boolean isNotEmpty(Collection collection) {
+	public static boolean isNotEmpty(Collection<?> collection) {
 		return !isEmpty( collection );
 	}
 
-	public static boolean isNotEmpty(Map map) {
+	public static boolean isNotEmpty(Map<?,?> map) {
 		return !isEmpty( map );
 	}
 
@@ -305,23 +301,20 @@ public static <T> Set<T> setOf(T... values) {
 	}
 
 	public static <T> Set<T> setOf(Collection<T> values) {
-		if ( isEmpty( values ) ) {
-			return Collections.emptySet();
-		}
-		return new HashSet<>( values );
+		return isEmpty( values ) ? emptySet() : new HashSet<>( values );
 	}
 
 	public static Properties asProperties(Map<?,?> map) {
-		if ( map instanceof Properties ) {
-			return ( (Properties) map );
+		if ( map instanceof Properties properties ) {
+			return properties;
 		}
-
-		final Properties properties = new Properties();
-		if ( isNotEmpty( map ) ) {
-			properties.putAll( map );
+		else {
+			final Properties properties = new Properties();
+			if ( isNotEmpty( map ) ) {
+				properties.putAll( map );
+			}
+			return properties;
 		}
-
-		return properties;
 	}
 
 	/**
@@ -354,10 +347,10 @@ public static <T> Set<T> toSmallSet(Set<T> set) {
 	public static <K, V> Map<K, V> toSmallMap(final Map<K, V> map) {
 		switch ( map.size() ) {
 			case 0:
-				return Collections.EMPTY_MAP;
+				return emptyMap();
 			case 1:
 				Map.Entry<K, V> entry = map.entrySet().iterator().next();
-				return Collections.singletonMap( entry.getKey(), entry.getValue() );
+				return singletonMap( entry.getKey(), entry.getValue() );
 			default:
 				//TODO assert tests pass even if this is set to return an unmodifiable Map
 				return map;
@@ -374,9 +367,9 @@ public static <K, V> Map<K, V> toSmallMap(final Map<K, V> map) {
 	public static <V> List<V> toSmallList(ArrayList<V> arrayList) {
 		switch ( arrayList.size() ) {
 			case 0:
-				return Collections.EMPTY_LIST;
+				return emptyList();
 			case 1:
-				return Collections.singletonList( arrayList.get( 0 ) );
+				return singletonList( arrayList.get( 0 ) );
 			default:
 				arrayList.trimToSize();
 				return arrayList;
@@ -410,48 +403,15 @@ public static <K,S> Map<K, S> asMap(Object[] elements) {
 	public static Map<String,String> toMap(String... pairs) {
 		assert pairs.length % 2 == 0;
 		if ( pairs.length == 2 ) {
-			return Collections.singletonMap( pairs[0], pairs[1] );
-		}
-
-		final Map<String,String> result = new HashMap<>();
-		applyToMap( result, pairs );
-		return result;
-	}
-
-	private static void applyToMap(Map<String,String> map, String... pairs) {
-		assert pairs.length % 2 == 0;
-		for ( int i = 0; i < pairs.length; i+=2 ) {
-			map.put( pairs[i], pairs[i+1] );
-		}
-	}
-
-	public static Map<String,?> toMap(Object... pairs) {
-		assert pairs.length % 2 == 0;
-		if ( pairs.length == 2 ) {
-			return Collections.singletonMap( (String) pairs[0], pairs[1] );
+			return singletonMap( pairs[0], pairs[1] );
 		}
-
-		final Map<String,String> result = new HashMap<>();
-		applyToMap( result, pairs );
-		return result;
-	}
-
-	public static Map<String,Object> toSettingsMap(Object... pairs) {
-		assert pairs.length % 2 == 0;
-		if ( pairs.length == 2 ) {
-			return Collections.singletonMap( (String) pairs[0], pairs[1] );
-		}
-
-		final Map<String,Object> result = new HashMap<>();
-		applyToMap( result, pairs );
-		return result;
-	}
-
-	@SuppressWarnings({ "unchecked", "rawtypes" })
-	private static void applyToMap(Map<String,?> map, Object... pairs) {
-		assert pairs.length % 2 == 0;
-		for ( int i = 0; i < pairs.length; i+=2 ) {
-			( (Map) map ).put( pairs[i], pairs[i+1] );
+		else {
+			final Map<String,String> result = new HashMap<>();
+			assert pairs.length % 2 == 0;
+			for ( int i = 0; i < pairs.length; i+=2 ) {
+				result.put( pairs[i], pairs[i+1] );
+			}
+			return result;
 		}
 	}
 
@@ -465,23 +425,6 @@ public static String[] asPairs(Map<String,String> map) {
 		return pairs;
 	}
 
-	public static Properties toProperties(Object... pairs) {
-		final Properties properties = new Properties();
-		if ( pairs.length > 0 ) {
-			assert pairs.length % 2 == 0;
-			for ( int i = 0; i < pairs.length; i+=2 ) {
-				properties.put( pairs[i], pairs[i+1] );
-			}
-		}
-		return properties;
-	}
-
-	public static void applyToProperties(Properties properties, Object... pairs) {
-		assert pairs.length % 2 == 0;
-		for ( int i = 0; i < pairs.length; i+=2 ) {
-			properties.put( pairs[i], pairs[i+1] );
-		}
-	}
 
 	public static <O> List<O> combine(List<O> list1, List<O> list2) {
 		final ArrayList<O> combined = arrayList( list1.size() + list2.size() );
@@ -498,6 +441,7 @@ public static List combineUntyped(List list1, List list2) {
 		return combined;
 	}
 
+	@SafeVarargs
 	public static <O> List<O> combine(List<O>... lists) {
 		final ArrayList<O> combined = new ArrayList<>();
 		for ( int i = 0; i < lists.length; i++ ) {
@@ -518,10 +462,11 @@ public static int size(Map<?,?> values) {
 		return values == null ? 0 : values.size();
 	}
 
+	@SafeVarargs
 	public static <X> Set<X> toSet(X... values) {
 		final HashSet<X> result = new HashSet<>();
 		if ( isNotEmpty( values ) ) {
-			result.addAll( Arrays.asList( values ) );
+			result.addAll( asList( values ) );
 		}
 		return result;
 	}
@@ -532,16 +477,19 @@ public static <E> List<E> mutableJoin(Collection<E> first, Collection<E> second)
 		if ( totalCount == 0 ) {
 			return new ArrayList<>();
 		}
-		final ArrayList<E> joined = new ArrayList<>( totalCount );
-		if ( first != null ) {
-			joined.addAll( first );
-		}
-		if ( second != null ) {
-			joined.addAll( second );
+		else {
+			final ArrayList<E> joined = new ArrayList<>( totalCount );
+			if ( first != null ) {
+				joined.addAll( first );
+			}
+			if ( second != null ) {
+				joined.addAll( second );
+			}
+			return joined;
 		}
-		return joined;
 	}
 
+	@SafeVarargs
 	public static <E> List<E> mutableJoin(Collection<E> first, Collection<E>... others) {
 		// it can be empty, but not null
 		assert first != null;