From efb8b2e7df184d2c3e6a97d10b9a556b03ffdb85 Mon Sep 17 00:00:00 2001 From: Gavin King Date: Fri, 24 Jan 2025 16:14:32 +0100 Subject: [PATCH] fix some more warnings and add static imports --- .../org/hibernate/boot/MetadataSources.java | 23 +++++++------ .../internal/EnumeratedValueConverter.java | 24 ++++++-------- .../internal/ManagedResourcesImpl.java | 13 +++++--- .../process/internal/VersionResolution.java | 32 +++++++++---------- .../org/hibernate/mapping/BasicValue.java | 6 ++-- 5 files changed, 48 insertions(+), 50 deletions(-) diff --git a/hibernate-core/src/main/java/org/hibernate/boot/MetadataSources.java b/hibernate-core/src/main/java/org/hibernate/boot/MetadataSources.java index 1ce8a217cfb2..68d85398f814 100644 --- a/hibernate-core/src/main/java/org/hibernate/boot/MetadataSources.java +++ b/hibernate-core/src/main/java/org/hibernate/boot/MetadataSources.java @@ -10,7 +10,6 @@ import java.net.URL; import java.util.ArrayList; import java.util.Collection; -import java.util.Collections; import java.util.HashMap; import java.util.LinkedHashSet; import java.util.List; @@ -37,6 +36,9 @@ import org.hibernate.service.ServiceRegistry; import org.hibernate.type.SerializationException; +import static java.util.Collections.addAll; +import static java.util.Collections.emptyList; +import static java.util.Collections.emptySet; import static org.hibernate.internal.util.collections.CollectionHelper.arrayList; /** @@ -132,7 +134,7 @@ public XmlMappingBinderAccess getXmlMappingBinderAccess() { @Deprecated(since = "7.0") public List> getXmlBindings() { if ( mappingXmlBindings == null && hbmXmlBindings == null ) { - return Collections.emptyList(); + return emptyList(); } if ( hbmXmlBindings == null ) { @@ -143,30 +145,31 @@ public List> getXmlBindings() { return (List) hbmXmlBindings; } - final ArrayList> combined = arrayList( mappingXmlBindings.size() + hbmXmlBindings.size() ); + final ArrayList> combined = + arrayList( mappingXmlBindings.size() + hbmXmlBindings.size() ); combined.addAll( (List) mappingXmlBindings ); combined.addAll( (List) hbmXmlBindings ); return combined; } public List> getMappingXmlBindings() { - return mappingXmlBindings == null ? Collections.emptyList() : mappingXmlBindings; + return mappingXmlBindings == null ? emptyList() : mappingXmlBindings; } public List> getHbmXmlBindings() { - return hbmXmlBindings == null ? Collections.emptyList() : hbmXmlBindings; + return hbmXmlBindings == null ? emptyList() : hbmXmlBindings; } public Collection getAnnotatedPackages() { - return annotatedPackages == null ? Collections.emptySet() : annotatedPackages; + return annotatedPackages == null ? emptySet() : annotatedPackages; } public Collection> getAnnotatedClasses() { - return annotatedClasses == null ? Collections.emptySet() : annotatedClasses; + return annotatedClasses == null ? emptySet() : annotatedClasses; } public Collection getAnnotatedClassNames() { - return annotatedClassNames == null ? Collections.emptySet() : annotatedClassNames; + return annotatedClassNames == null ? emptySet() : annotatedClassNames; } public Map> getExtraQueryImports() { @@ -269,7 +272,7 @@ public MetadataSources addAnnotatedClasses(Class... annotatedClasses) { if ( this.annotatedClasses == null ) { this.annotatedClasses = new LinkedHashSet<>(); } - Collections.addAll( this.annotatedClasses, annotatedClasses ); + addAll( this.annotatedClasses, annotatedClasses ); } return this; } @@ -297,7 +300,7 @@ public MetadataSources addAnnotatedClassName(String annotatedClassName) { */ public MetadataSources addAnnotatedClassNames(String... annotatedClassNames) { if ( annotatedClassNames != null && annotatedClassNames.length > 0 ) { - Collections.addAll( this.annotatedClassNames, annotatedClassNames ); + addAll( this.annotatedClassNames, annotatedClassNames ); } return this; } diff --git a/hibernate-core/src/main/java/org/hibernate/boot/model/process/internal/EnumeratedValueConverter.java b/hibernate-core/src/main/java/org/hibernate/boot/model/process/internal/EnumeratedValueConverter.java index aab35e06f894..b68ae53d5471 100644 --- a/hibernate-core/src/main/java/org/hibernate/boot/model/process/internal/EnumeratedValueConverter.java +++ b/hibernate-core/src/main/java/org/hibernate/boot/model/process/internal/EnumeratedValueConverter.java @@ -8,14 +8,15 @@ import java.util.Map; import java.util.Set; -import org.hibernate.internal.util.ReflectHelper; -import org.hibernate.internal.util.collections.CollectionHelper; import org.hibernate.type.descriptor.converter.spi.BasicValueConverter; import org.hibernate.type.descriptor.java.EnumJavaType; import org.hibernate.type.descriptor.java.JavaType; import org.checkerframework.checker.nullness.qual.Nullable; +import static org.hibernate.internal.util.ReflectHelper.ensureAccessibility; +import static org.hibernate.internal.util.collections.CollectionHelper.mapOfSize; + /** * @author Steve Ebersole */ @@ -33,14 +34,13 @@ public EnumeratedValueConverter( this.enumJavaType = enumJavaType; this.relationalJavaType = relationalJavaType; - ReflectHelper.ensureAccessibility( valueField ); + ensureAccessibility( valueField ); final Class enumJavaTypeClass = enumJavaType.getJavaTypeClass(); final E[] enumConstants = enumJavaTypeClass.getEnumConstants(); - relationalToEnumMap = CollectionHelper.mapOfSize( enumConstants.length ); - enumToRelationalMap = CollectionHelper.mapOfSize( enumConstants.length ); - for ( int i = 0; i < enumConstants.length; i++ ) { - final E enumConstant = enumConstants[i]; + relationalToEnumMap = mapOfSize( enumConstants.length ); + enumToRelationalMap = mapOfSize( enumConstants.length ); + for ( final E enumConstant : enumConstants ) { try { //noinspection unchecked final R relationalValue = (R) valueField.get( enumConstant ); @@ -60,18 +60,12 @@ public Set getRelationalValueSet() { @Override public @Nullable E toDomainValue(@Nullable R relationalForm) { - if ( relationalForm == null ) { - return null; - } - return relationalToEnumMap.get( relationalForm ); + return relationalForm == null ? null : relationalToEnumMap.get( relationalForm ); } @Override public @Nullable R toRelationalValue(@Nullable E domainForm) { - if ( domainForm == null ) { - return null; - } - return enumToRelationalMap.get( domainForm ); + return domainForm == null ? null : enumToRelationalMap.get( domainForm ); } @Override diff --git a/hibernate-core/src/main/java/org/hibernate/boot/model/process/internal/ManagedResourcesImpl.java b/hibernate-core/src/main/java/org/hibernate/boot/model/process/internal/ManagedResourcesImpl.java index de2638a83ea0..60247a3468f7 100644 --- a/hibernate-core/src/main/java/org/hibernate/boot/model/process/internal/ManagedResourcesImpl.java +++ b/hibernate-core/src/main/java/org/hibernate/boot/model/process/internal/ManagedResourcesImpl.java @@ -25,12 +25,15 @@ import jakarta.persistence.AttributeConverter; +import static java.util.Collections.unmodifiableCollection; +import static java.util.Collections.unmodifiableSet; + /** * @author Steve Ebersole */ public class ManagedResourcesImpl implements ManagedResources { - private final Map, ConverterDescriptor> attributeConverterDescriptorMap = new HashMap<>(); + private final Map>, ConverterDescriptor> attributeConverterDescriptorMap = new HashMap<>(); private final Set> annotatedClassReferences = new LinkedHashSet<>(); private final Set annotatedClassNames = new LinkedHashSet<>(); private final Set annotatedPackageNames = new LinkedHashSet<>(); @@ -68,22 +71,22 @@ public ManagedResourcesImpl() { @Override public Collection getAttributeConverterDescriptors() { - return Collections.unmodifiableCollection( attributeConverterDescriptorMap.values() ); + return unmodifiableCollection( attributeConverterDescriptorMap.values() ); } @Override public Collection> getAnnotatedClassReferences() { - return Collections.unmodifiableSet( annotatedClassReferences ); + return unmodifiableSet( annotatedClassReferences ); } @Override public Collection getAnnotatedClassNames() { - return Collections.unmodifiableSet( annotatedClassNames ); + return unmodifiableSet( annotatedClassNames ); } @Override public Collection getAnnotatedPackageNames() { - return Collections.unmodifiableSet( annotatedPackageNames ); + return unmodifiableSet( annotatedPackageNames ); } @Override diff --git a/hibernate-core/src/main/java/org/hibernate/boot/model/process/internal/VersionResolution.java b/hibernate-core/src/main/java/org/hibernate/boot/model/process/internal/VersionResolution.java index 7d5ed863964e..904c4bf83143 100644 --- a/hibernate-core/src/main/java/org/hibernate/boot/model/process/internal/VersionResolution.java +++ b/hibernate-core/src/main/java/org/hibernate/boot/model/process/internal/VersionResolution.java @@ -13,6 +13,7 @@ import org.hibernate.dialect.Dialect; import org.hibernate.mapping.BasicValue; import org.hibernate.metamodel.mapping.JdbcMapping; +import org.hibernate.type.BasicTypeRegistry; import org.hibernate.type.descriptor.converter.spi.BasicValueConverter; import org.hibernate.type.BasicType; import org.hibernate.type.descriptor.java.BasicJavaType; @@ -26,26 +27,24 @@ /** * @author Steve Ebersole */ -@SuppressWarnings("rawtypes") public class VersionResolution implements BasicValue.Resolution { // todo (6.0) : support explicit JTD? // todo (6.0) : support explicit STD? - @SuppressWarnings({"rawtypes", "unchecked"}) public static VersionResolution from( Function implicitJavaTypeAccess, TimeZoneStorageType timeZoneStorageType, - @SuppressWarnings("unused") MetadataBuildingContext context) { + MetadataBuildingContext context) { // todo (6.0) : add support for Dialect-specific interpretation? final TypeConfiguration typeConfiguration = context.getBootstrapContext().getTypeConfiguration(); final java.lang.reflect.Type implicitJavaType = implicitJavaTypeAccess.apply( typeConfiguration ); - final JavaType registered = typeConfiguration.getJavaTypeRegistry().resolveDescriptor( implicitJavaType ); - final BasicJavaType jtd = (BasicJavaType) registered; + final JavaType registered = typeConfiguration.getJavaTypeRegistry().resolveDescriptor( implicitJavaType ); + final BasicJavaType basicJavaType = (BasicJavaType) registered; - final JdbcType recommendedJdbcType = jtd.getRecommendedJdbcType( + final JdbcType recommendedJdbcType = basicJavaType.getRecommendedJdbcType( new JdbcTypeIndicators() { @Override public TypeConfiguration getTypeConfiguration() { @@ -105,25 +104,26 @@ public Dialect getDialect() { } ); - final BasicType basicType = typeConfiguration.getBasicTypeRegistry().resolve( jtd, recommendedJdbcType ); - final BasicType legacyType = typeConfiguration.getBasicTypeRegistry().getRegisteredType( jtd.getJavaType() ); + final BasicTypeRegistry basicTypeRegistry = typeConfiguration.getBasicTypeRegistry(); + final BasicType basicType = basicTypeRegistry.resolve( basicJavaType, recommendedJdbcType ); + final BasicType legacyType = basicTypeRegistry.getRegisteredType( basicJavaType.getJavaType() ); assert legacyType.getJdbcType().getDefaultSqlTypeCode() == recommendedJdbcType.getDefaultSqlTypeCode(); - return new VersionResolution<>( jtd, recommendedJdbcType, basicType, legacyType ); + return new VersionResolution<>( basicJavaType, recommendedJdbcType, basicType, legacyType ); } - private final JavaType javaType; + private final JavaType javaType; private final JdbcType jdbcType; private final JdbcMapping jdbcMapping; - private final BasicType legacyType; + private final BasicType legacyType; public VersionResolution( - JavaType javaType, + JavaType javaType, JdbcType jdbcType, JdbcMapping jdbcMapping, - BasicType legacyType) { + BasicType legacyType) { this.javaType = javaType; this.jdbcType = jdbcType; this.jdbcMapping = jdbcMapping; @@ -136,13 +136,11 @@ public JdbcMapping getJdbcMapping() { } @Override - @SuppressWarnings("unchecked") - public BasicType getLegacyResolvedBasicType() { + public BasicType getLegacyResolvedBasicType() { return legacyType; } @Override - @SuppressWarnings("unchecked") public JavaType getDomainJavaType() { return javaType; } @@ -158,7 +156,7 @@ public JdbcType getJdbcType() { } @Override - public BasicValueConverter getValueConverter() { + public BasicValueConverter getValueConverter() { return legacyType.getValueConverter(); } diff --git a/hibernate-core/src/main/java/org/hibernate/mapping/BasicValue.java b/hibernate-core/src/main/java/org/hibernate/mapping/BasicValue.java index 567f47bc104a..dbde054fc00e 100644 --- a/hibernate-core/src/main/java/org/hibernate/mapping/BasicValue.java +++ b/hibernate-core/src/main/java/org/hibernate/mapping/BasicValue.java @@ -132,9 +132,9 @@ public BasicValue(MetadataBuildingContext buildingContext, Table table) { public BasicValue(BasicValue original) { super( original ); this.explicitTypeName = original.explicitTypeName; - this.explicitLocalTypeParams = original.explicitLocalTypeParams == null - ? null - : new HashMap<>(original.explicitLocalTypeParams); + this.explicitLocalTypeParams = + original.explicitLocalTypeParams == null ? null + : new HashMap<>( original.explicitLocalTypeParams ); this.explicitJavaTypeAccess = original.explicitJavaTypeAccess; this.explicitJdbcTypeAccess = original.explicitJdbcTypeAccess; this.explicitMutabilityPlanAccess = original.explicitMutabilityPlanAccess;