add clarifications as recommended by @sebersole

Author: gavinking

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

@@ -35,22 +35,33 @@
  * and does not force a version increment.
  * <p>
  * When an entity is read from the database, its lock mode
- * determines whether lost updates and non-repeatable reads
- * are possible.
+ * determines whether lost updates and non-repeatable reads are
+ * possible. Assuming the underlying transaction isolation
+ * {@linkplain java.sql.Connection#getTransactionIsolation level}
+ * of the current JDBC database connection is at least
+ * {@linkplain java.sql.Connection#TRANSACTION_READ_COMMITTED
+ * read committed}, then:
  * <ul>
  * <li>{@link #NONE} and {@link #READ} prevent lost updates
  *     only for versioned entities, but do not prevent
  *     non-repeatable reads, and do not prevent lost updates
- *     for entities with no version attribute.
+ *     for entities with no version attribute;
  * <li>{@link #OPTIMISTIC} and {@link #OPTIMISTIC_FORCE_INCREMENT}
  *     prevent lost updates and non-repeatable reads only for
- *     versioned entities.
+ *     versioned entities;
  * <li>{@link #PESSIMISTIC_READ}, {@link #PESSIMISTIC_WRITE},
  *     and {@link #PESSIMISTIC_FORCE_INCREMENT} prevent lost
  *     updates and non-repeatable reads for all entities,
  *     including entities with no version attribute.
  * </ul>
  * <p>
+ * Regardless of the lock mode of a given entity, a non-repeatable
+ * read is always possible when {@link Session#refresh(Object)}
+ * is called for that entity, except when the underlying transaction
+ * isolation level of the current JDBC database connection is at
+ * least {@linkplain java.sql.Connection#TRANSACTION_REPEATABLE_READ
+ * repeatable read}.
+ * <p>
  * This enumeration of lock modes competes with the JPA-defined
  * {@link LockModeType}, but offers additional options, including
  * {@link #UPGRADE_NOWAIT} and {@link #UPGRADE_SKIPLOCKED}.

hibernate-core/src/main/java/org/hibernate/internal/util/beans/BeanInfoHelper.java

@@ -22,14 +22,14 @@ public interface ReturningBeanInfoDelegate<T> {
 		T processBeanInfo(BeanInfo beanInfo) throws Exception;
 	}
 
-	private final Class beanClass;
-	private final Class stopClass;
+	private final Class<?> beanClass;
+	private final Class<?> stopClass;
 
-	public BeanInfoHelper(Class beanClass) {
+	public BeanInfoHelper(Class<?> beanClass) {
 		this( beanClass, Object.class );
 	}
 
-	public BeanInfoHelper(Class beanClass, Class stopClass) {
+	public BeanInfoHelper(Class<?> beanClass, Class<?> stopClass) {
 		this.beanClass = beanClass;
 		this.stopClass = stopClass;
 	}
@@ -46,7 +46,7 @@ public static void visitBeanInfo(Class<?> beanClass, BeanInfoDelegate delegate)
 		visitBeanInfo( beanClass, Object.class, delegate );
 	}
 
-	public static void visitBeanInfo(Class beanClass, Class stopClass, BeanInfoDelegate delegate) {
+	public static void visitBeanInfo(Class<?> beanClass, Class<?> stopClass, BeanInfoDelegate delegate) {
 		try {
 			BeanInfo info = Introspector.getBeanInfo( beanClass, stopClass );
 			try {
@@ -70,11 +70,11 @@ public static void visitBeanInfo(Class beanClass, Class stopClass, BeanInfoDeleg
 		}
 	}
 
-	public static <T> T visitBeanInfo(Class beanClass, ReturningBeanInfoDelegate<T> delegate) {
+	public static <T> T visitBeanInfo(Class<?> beanClass, ReturningBeanInfoDelegate<T> delegate) {
 		return visitBeanInfo( beanClass, null, delegate );
 	}
 
-	public static <T> T visitBeanInfo(Class beanClass, Class stopClass, ReturningBeanInfoDelegate<T> delegate) {
+	public static <T> T visitBeanInfo(Class<?> beanClass, Class<?> stopClass, ReturningBeanInfoDelegate<T> delegate) {
 		try {
 			BeanInfo info = Introspector.getBeanInfo( beanClass, stopClass );
 			try {

hibernate-core/src/main/java/org/hibernate/internal/util/compare/ComparableComparator.java

@@ -13,18 +13,17 @@
  * @author Gavin King
  * @author Steve Ebersole
  */
-@SuppressWarnings("rawtypes")
-public class ComparableComparator<T extends Comparable> implements Comparator<T>, Serializable {
+public class ComparableComparator<T extends Comparable<T>> implements Comparator<T>, Serializable {
 
+	@SuppressWarnings("rawtypes")
 	public static final Comparator INSTANCE = new ComparableComparator();
 
 	@SuppressWarnings("unchecked")
-	public static <T extends Comparable> Comparator<T> instance() {
+	public static <T extends Comparable<T>> Comparator<T> instance() {
 		return INSTANCE;
 	}
 
-	@SuppressWarnings("unchecked")
-	public int compare(Comparable one, Comparable another) {
+	public int compare(T one, T another) {
 		return one.compareTo( another );
 	}
 }

hibernate-core/src/main/java/org/hibernate/query/internal/ParameterMetadataImpl.java

@@ -249,10 +249,7 @@ public Set<String> getNamedParameterNames() {
 
 	@Override
 	public QueryParameterImplementor<?> findQueryParameter(String name) {
-		if ( queryParametersByName == null ) {
-			return null;
-		}
-		return queryParametersByName.get( name );
+		return queryParametersByName == null ? null : queryParametersByName.get( name );
 	}
 
 	@Override

hibernate-core/src/main/java/org/hibernate/type/descriptor/java/AbstractClassJavaType.java

@@ -44,6 +44,7 @@ protected AbstractClassJavaType(Class<T> type) {
 	 * @param type The Java type.
 	 * @param mutabilityPlan The plan for handling mutability aspects of the java type.
 	 */
+	@SuppressWarnings("unchecked")
 	protected AbstractClassJavaType(Class<T> type, MutabilityPlan<T> mutabilityPlan) {
 		this(
 				type,

hibernate-core/src/main/java/org/hibernate/type/descriptor/java/AbstractJavaType.java

@@ -50,7 +50,7 @@ protected AbstractJavaType(Type type, MutabilityPlan<T> mutabilityPlan) {
 		this.mutabilityPlan = mutabilityPlan;
 		this.comparator =
 				type != null && Comparable.class.isAssignableFrom( getJavaTypeClass() )
-						? (Comparator<T>) ComparableComparator.INSTANCE
+						? ComparableComparator.INSTANCE
 						: null;
 	}