use switch expressions in main enums

Author: gavinking

hibernate-core/src/main/java/org/hibernate/CacheMode.java

@@ -162,30 +162,17 @@ public static CacheMode fromJpaModes(CacheRetrieveMode retrieveMode, CacheStoreM
 			retrieveMode = CacheRetrieveMode.BYPASS;
 		}
 
-		switch ( storeMode ) {
-			case USE: {
-				switch ( retrieveMode ) {
-					case USE:
-						return NORMAL;
-					case BYPASS:
-						return PUT;
-				}
-			}
-			case BYPASS: {
-				switch ( retrieveMode ) {
-					case USE:
-						return GET;
-					case BYPASS:
-						return IGNORE;
-				}
-			}
-			case REFRESH: {
-				// technically should combo CacheStoreMode#REFRESH and CacheRetrieveMode#USE be illegal?
-				return REFRESH;
-			}
-			default: {
-				throw new AssertionFailure( "Unrecognized CacheStoreMode: " + storeMode );
-			}
-		}
+		return switch (storeMode) {
+			case USE -> switch (retrieveMode) {
+				case USE -> NORMAL;
+				case BYPASS -> PUT;
+			};
+			case BYPASS -> switch (retrieveMode) {
+				case USE -> GET;
+				case BYPASS -> IGNORE;
+			};
+			// technically should combo CacheStoreMode#REFRESH and CacheRetrieveMode#USE be illegal?
+			case REFRESH -> REFRESH;
+		};
 	}
 }

hibernate-core/src/main/java/org/hibernate/ConnectionAcquisitionMode.java

@@ -6,7 +6,7 @@
  */
 package org.hibernate;
 
-import org.hibernate.internal.util.StringHelper;
+import static org.hibernate.internal.util.StringHelper.isEmpty;
 
 /**
  * Indicates the manner in which JDBC {@linkplain java.sql.Connection connections}
@@ -32,24 +32,22 @@ public enum ConnectionAcquisitionMode {
 	AS_NEEDED;
 
 	public static ConnectionAcquisitionMode interpret(String value) {
-		if ( "immediate".equalsIgnoreCase( value ) || "immediately".equalsIgnoreCase( value ) ) {
-			return IMMEDIATELY;
-		}
-
-		return AS_NEEDED;
+		return "immediate".equalsIgnoreCase( value ) || "immediately".equalsIgnoreCase( value )
+				? IMMEDIATELY
+				: AS_NEEDED;
 	}
 
 	public static ConnectionAcquisitionMode interpret(Object setting) {
 		if ( setting == null ) {
 			return null;
 		}
 
-		if ( setting instanceof ConnectionAcquisitionMode ) {
-			return (ConnectionAcquisitionMode) setting;
+		if ( setting instanceof ConnectionAcquisitionMode mode ) {
+			return mode;
 		}
 
 		final String value = setting.toString();
-		if ( StringHelper.isEmpty( value ) ) {
+		if ( isEmpty( value ) ) {
 			return null;
 		}
 

hibernate-core/src/main/java/org/hibernate/ConnectionReleaseMode.java

@@ -8,7 +8,7 @@
 
 import java.util.Locale;
 
-import org.hibernate.internal.util.StringHelper;
+import static org.hibernate.internal.util.StringHelper.isEmpty;
 
 /**
  * Enumerates various policies for releasing JDBC {@linkplain java.sql.Connection
@@ -74,12 +74,12 @@ public static ConnectionReleaseMode interpret(Object setting) {
 			return null;
 		}
 
-		if ( setting instanceof ConnectionReleaseMode ) {
-			return (ConnectionReleaseMode) setting;
+		if ( setting instanceof ConnectionReleaseMode mode ) {
+			return mode;
 		}
 
 		final String value = setting.toString();
-		if ( StringHelper.isEmpty( value ) ) {
+		if ( isEmpty( value ) ) {
 			return null;
 		}
 

hibernate-core/src/main/java/org/hibernate/FlushMode.java

@@ -83,18 +83,12 @@ public static FlushMode interpretExternalSetting(String externalName) {
 	}
 
 	private int level() {
-		switch (this) {
-			case ALWAYS:
-				return 20;
-			case AUTO:
-				return 10;
-			case COMMIT:
-				return 5;
-			case MANUAL:
-				return 0;
-			default:
-				throw new AssertionFailure("Impossible FlushMode");
-		}
+		return switch (this) {
+			case ALWAYS -> 20;
+			case AUTO -> 10;
+			case COMMIT -> 5;
+			case MANUAL -> 0;
+		};
 	}
 
 	public static FlushMode fromJpaFlushMode(FlushModeType flushModeType) {

hibernate-core/src/main/java/org/hibernate/LockMode.java

@@ -245,27 +245,15 @@ public String toExternalForm() {
 	 * forced version increment will occur.
 	 */
 	private int level() {
-		switch (this) {
-			case NONE:
-				return 0;
-			case READ:
-				return 1;
-			case OPTIMISTIC:
-				return 2;
-			case OPTIMISTIC_FORCE_INCREMENT:
-				return 3;
-			case PESSIMISTIC_READ:
-				return 4;
-			case UPGRADE_NOWAIT:
-			case UPGRADE_SKIPLOCKED:
-			case PESSIMISTIC_WRITE:
-				return 5;
-			case PESSIMISTIC_FORCE_INCREMENT:
-			case WRITE:
-				return 6;
-			default:
-				throw new AssertionFailure( "Unrecognized LockMode: " + this );
-		}
+		return switch (this) {
+			case NONE -> 0;
+			case READ -> 1;
+			case OPTIMISTIC -> 2;
+			case OPTIMISTIC_FORCE_INCREMENT -> 3;
+			case PESSIMISTIC_READ -> 4;
+			case UPGRADE_NOWAIT, UPGRADE_SKIPLOCKED, PESSIMISTIC_WRITE -> 5;
+			case PESSIMISTIC_FORCE_INCREMENT, WRITE -> 6;
+		};
 	}
 
 	public static LockMode fromExternalForm(String externalForm) {
@@ -291,29 +279,17 @@ public static LockMode fromExternalForm(String externalForm) {
 	 *         all other settings defaulted.
 	 */
 	public LockOptions toLockOptions() {
-		switch (this) {
-			case NONE:
-				return LockOptions.NONE;
-			case READ:
-				return LockOptions.READ;
-			case OPTIMISTIC:
-				return LockOptions.OPTIMISTIC;
-			case OPTIMISTIC_FORCE_INCREMENT:
-				return LockOptions.OPTIMISTIC_FORCE_INCREMENT;
-			case UPGRADE_NOWAIT:
-				return LockOptions.UPGRADE_NOWAIT;
-			case UPGRADE_SKIPLOCKED:
-				return LockOptions.UPGRADE_SKIPLOCKED;
-			case PESSIMISTIC_READ:
-				return LockOptions.PESSIMISTIC_READ;
-			case PESSIMISTIC_WRITE:
-				return LockOptions.PESSIMISTIC_WRITE;
-			case PESSIMISTIC_FORCE_INCREMENT:
-				return LockOptions.PESSIMISTIC_FORCE_INCREMENT;
-			case WRITE:
-				throw new UnsupportedOperationException("WRITE is not a valid LockMode as an argument");
-			default:
-				throw new AssertionFailure( "Unrecognized LockMode: " + this );
-		}
+		return switch (this) {
+			case NONE -> LockOptions.NONE;
+			case READ -> LockOptions.READ;
+			case OPTIMISTIC -> LockOptions.OPTIMISTIC;
+			case OPTIMISTIC_FORCE_INCREMENT -> LockOptions.OPTIMISTIC_FORCE_INCREMENT;
+			case UPGRADE_NOWAIT -> LockOptions.UPGRADE_NOWAIT;
+			case UPGRADE_SKIPLOCKED -> LockOptions.UPGRADE_SKIPLOCKED;
+			case PESSIMISTIC_READ -> LockOptions.PESSIMISTIC_READ;
+			case PESSIMISTIC_WRITE -> LockOptions.PESSIMISTIC_WRITE;
+			case PESSIMISTIC_FORCE_INCREMENT -> LockOptions.PESSIMISTIC_FORCE_INCREMENT;
+			case WRITE -> throw new UnsupportedOperationException( "WRITE is not a valid LockMode as an argument" );
+		};
 	}
 }

hibernate-core/src/main/java/org/hibernate/ScrollMode.java

@@ -20,41 +20,39 @@ public enum ScrollMode {
 	 *
 	 * @see ResultSet#TYPE_FORWARD_ONLY
 	 */
-	FORWARD_ONLY( ResultSet.TYPE_FORWARD_ONLY ),
+	FORWARD_ONLY,
 
 	/**
 	 * Requests a scrollable result which is sensitive to changes
 	 * in the underlying data.
 	 *
 	 * @see ResultSet#TYPE_SCROLL_SENSITIVE
 	 */
-	SCROLL_SENSITIVE( ResultSet.TYPE_SCROLL_SENSITIVE ),
+	SCROLL_SENSITIVE,
 
 	/**
 	 * Requests a scrollable result which is insensitive to changes
 	 * in the underlying data.
-	 *
+	 * <p>
 	 * Note that since the Hibernate session acts as a cache, you
 	 * might need to explicitly evict objects, if you need to see
 	 * changes made by other transactions.
 	 *
 	 * @see ResultSet#TYPE_SCROLL_INSENSITIVE
 	 */
-	SCROLL_INSENSITIVE( ResultSet.TYPE_SCROLL_INSENSITIVE );
-
-	private final int resultSetType;
-
-	ScrollMode(int level) {
-		this.resultSetType = level;
-	}
+	SCROLL_INSENSITIVE;
 
 	/**
 	 * Get the corresponding JDBC scroll type code constant value.
 	 *
 	 * @return the JDBC result set type code
 	 */
 	public int toResultSetType() {
-		return resultSetType;
+		return switch (this) {
+			case FORWARD_ONLY -> ResultSet.TYPE_FORWARD_ONLY;
+			case SCROLL_SENSITIVE -> ResultSet.TYPE_SCROLL_SENSITIVE;
+			case SCROLL_INSENSITIVE -> ResultSet.TYPE_SCROLL_INSENSITIVE;
+		};
 	}
 
 	/**
@@ -65,7 +63,6 @@ public int toResultSetType() {
 	 * @return {@code true} if this mode is less than the other.
 	 */
 	public boolean lessThan(ScrollMode other) {
-		return this.resultSetType < other.resultSetType;
+		return this.toResultSetType() < other.toResultSetType();
 	}
-
 }

hibernate-core/src/main/java/org/hibernate/TimeZoneStorageStrategy.java

@@ -31,11 +31,12 @@ public enum TimeZoneStorageStrategy {
 	 * Does not store the time zone, and instead:
 	 * <ul>
 	 * <li>when persisting to the database, normalizes JDBC timestamps to the
-	 * {@linkplain org.hibernate.cfg.AvailableSettings#JDBC_TIME_ZONE}
-	 * or to the JVM default time zone otherwise.
+	 *     {@linkplain org.hibernate.cfg.AvailableSettings#JDBC_TIME_ZONE
+	 *     configured JDBC time zone}, or to the JVM default time zone
+	 *     id no JDBC time zone is configured, or
 	 * <li>when reading back from the database, sets the offset or zone
-	 * of {@code OffsetDateTime}/{@code ZonedDateTime} properties
-	 * to the JVM default time zone.
+	 *     of {@code OffsetDateTime}/{@code ZonedDateTime} properties
+	 *     to the JVM default time zone.
 	 * </ul>
 	 * <p>
 	 * Provided partly for backward compatibility with older

hibernate-core/src/main/java/org/hibernate/annotations/CacheConcurrencyStrategy.java

@@ -6,7 +6,6 @@
  */
 package org.hibernate.annotations;
 
-import org.hibernate.AssertionFailure;
 import org.hibernate.cache.spi.access.AccessType;
 
 /**
@@ -140,20 +139,13 @@ public enum CacheConcurrencyStrategy {
 	 *         return {@code null} for {@link #NONE}.
 	 */
 	public AccessType toAccessType() {
-		switch ( this ) {
-			case NONE:
-				return null;
-			case READ_ONLY:
-				return AccessType.READ_ONLY;
-			case NONSTRICT_READ_WRITE:
-				return AccessType.NONSTRICT_READ_WRITE;
-			case READ_WRITE:
-				return AccessType.READ_WRITE;
-			case TRANSACTIONAL:
-				return AccessType.TRANSACTIONAL;
-			default:
-				throw new AssertionFailure( "unknown CacheConcurrencyStrategy" );
-		}
+		return switch (this) {
+			case NONE -> null;
+			case READ_ONLY -> AccessType.READ_ONLY;
+			case NONSTRICT_READ_WRITE -> AccessType.NONSTRICT_READ_WRITE;
+			case READ_WRITE -> AccessType.READ_WRITE;
+			case TRANSACTIONAL -> AccessType.TRANSACTIONAL;
+		};
 	}
 
 	/**
@@ -170,18 +162,12 @@ public static CacheConcurrencyStrategy fromAccessType(AccessType accessType) {
 			return NONE;
 		}
 		else {
-			switch ( accessType ) {
-				case READ_ONLY:
-					return READ_ONLY;
-				case READ_WRITE:
-					return READ_WRITE;
-				case NONSTRICT_READ_WRITE:
-					return NONSTRICT_READ_WRITE;
-				case TRANSACTIONAL:
-					return TRANSACTIONAL;
-				default:
-					return NONE;
-			}
+			return switch (accessType) {
+				case READ_ONLY -> READ_ONLY;
+				case READ_WRITE -> READ_WRITE;
+				case NONSTRICT_READ_WRITE -> NONSTRICT_READ_WRITE;
+				case TRANSACTIONAL -> TRANSACTIONAL;
+			};
 		}
 	}
 

hibernate-core/src/main/java/org/hibernate/annotations/CacheLayout.java

@@ -42,5 +42,5 @@ public enum CacheLayout {
 	 * Stores the full state into the query cache.
 	 * This is useful when the chances for the object being part of the second level cache are very low.
 	 */
-	FULL;
+	FULL
 }

hibernate-core/src/main/java/org/hibernate/annotations/OnDeleteAction.java

@@ -66,8 +66,8 @@ public static OnDeleteAction fromExternalForm(Object value) {
 			return null;
 		}
 
-		if ( value instanceof OnDeleteAction ) {
-			return (OnDeleteAction) value;
+		if ( value instanceof OnDeleteAction onDeleteAction ) {
+			return onDeleteAction;
 		}
 
 		final String valueString = value.toString();