Hibernate
/
hibernate-orm
mirror of https://github.com/hibernate/hibernate-orm
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

use @code instead of <tt> in Javadoc

This commit is contained in:
Gavin King 2021-12-24 19:32:48 +01:00 committed by Steve Ebersole
parent fb8186d3e8
commit 8adc1d8d70
109 changed files with 545 additions and 545 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
hibernate-c3p0/src/main/java/org/hibernate/c3p0/internal/C3P0ConnectionProvider.java
View File

@ -32,7 +32,7 @@ import org.jboss.logging.Logger;
/** /**
* A connection provider that uses a C3P0 connection pool. Hibernate will use this by * A connection provider that uses a C3P0 connection pool. Hibernate will use this by
* default if the <tt>hibernate.c3p0.*</tt> properties are set. * default if the {@code hibernate.c3p0.*} properties are set.
* *
* @author various people * @author various people
* @see ConnectionProvider * @see ConnectionProvider

4
hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/TeradataDialect.java
View File

@ -288,9 +288,9 @@ public class TeradataDialect extends Dialect {
} }
/** /**
* Does this dialect support the <tt>FOR UPDATE</tt> syntax? * Does this dialect support the {@code FOR UPDATE} syntax?
* *
* @return empty string ... Teradata does not support <tt>FOR UPDATE</tt> syntax * @return empty string ... Teradata does not support {@code FOR UPDATE} syntax
*/ */
@Override @Override
public String getForUpdateString() { public String getForUpdateString() {

2
hibernate-core/src/main/java/org/hibernate/CacheMode.java
View File

@ -40,7 +40,7 @@ public enum CacheMode {
/** /**
* The session will never read items from the cache, but will add items * The session will never read items from the cache, but will add items
* to the cache as it reads them from the database. In this mode, the * to the cache as it reads them from the database. In this mode, the
* effect of <tt>hibernate.cache.use_minimal_puts</tt> is bypassed, in * effect of {@code hibernate.cache.use_minimal_puts} is bypassed, in
* order to <em>force</em> a cache refresh. * order to <em>force</em> a cache refresh.
*/ */
REFRESH( CacheStoreMode.REFRESH, CacheRetrieveMode.BYPASS ); REFRESH( CacheStoreMode.REFRESH, CacheRetrieveMode.BYPASS );

16
hibernate-core/src/main/java/org/hibernate/FetchMode.java
View File

@ -8,10 +8,10 @@ package org.hibernate;
/** /**
* Represents an association fetching strategy. This is used * Represents an association fetching strategy. This is used
* together with the <tt>Criteria</tt> API to specify runtime * together with the {@code Criteria} API to specify runtime
* fetching strategies. * fetching strategies.
* <p> * <p>
* For HQL queries, use the <tt>FETCH</tt> keyword instead. * For HQL queries, use the {@code FETCH} keyword instead.
* *
* @see Criteria#setFetchMode(String, FetchMode) * @see Criteria#setFetchMode(String, FetchMode)
* *
@ -24,26 +24,26 @@ public enum FetchMode {
DEFAULT, DEFAULT,
/** /**
* Fetch using an outer join. Equivalent to <tt>fetch="join"</tt>. * Fetch using an outer join. Equivalent to {@code fetch="join"}.
*/ */
JOIN, JOIN,
/** /**
* Fetch eagerly, using a separate select. Equivalent to * Fetch eagerly, using a separate select. Equivalent to
* <tt>fetch="select"</tt>. * {@code fetch="select"}.
*/ */
SELECT; SELECT;
/** /**
* Fetch lazily. Equivalent to <tt>outer-join="false"</tt>. * Fetch lazily. Equivalent to {@code outer-join="false"}.
* *
* @deprecated use <tt>FetchMode.SELECT</tt> * @deprecated use {@code FetchMode.SELECT}
*/ */
@Deprecated @Deprecated
public static final FetchMode LAZY = SELECT; public static final FetchMode LAZY = SELECT;
/** /**
* Fetch eagerly, using an outer join. Equivalent to <tt>outer-join="true"</tt>. * Fetch eagerly, using an outer join. Equivalent to {@code outer-join="true"}.
* *
* @deprecated use <tt>FetchMode.JOIN</tt> * @deprecated use {@code FetchMode.JOIN}
*/ */
@Deprecated @Deprecated
public static final FetchMode EAGER = JOIN; public static final FetchMode EAGER = JOIN;

14
hibernate-core/src/main/java/org/hibernate/Hibernate.java
View File

@ -43,9 +43,9 @@ import org.hibernate.proxy.LazyInitializer;
/** /**
* <ul> * <ul>
* <li>Provides access to the full range of Hibernate built-in types. <tt>Type</tt> * <li>Provides access to the full range of Hibernate built-in types. {@code Type}
* instances may be used to bind values to query parameters. * instances may be used to bind values to query parameters.
* <li>A factory for new <tt>Blob</tt>s and <tt>Clob</tt>s. * <li>A factory for new {@code Blob}s and {@code Clob}s.
* <li>Defines static methods for manipulation of proxies. * <li>Defines static methods for manipulation of proxies.
* </ul> * </ul>
* *
@ -70,8 +70,8 @@ public final class Hibernate {
* Note: This only ensures initialization of a proxy object or collection; * Note: This only ensures initialization of a proxy object or collection;
* it is not guaranteed that the elements INSIDE the collection will be initialized/materialized. * it is not guaranteed that the elements INSIDE the collection will be initialized/materialized.
* *
* @param proxy a persistable object, proxy, persistent collection or <tt>null</tt> * @param proxy a persistable object, proxy, persistent collection or {@code null}
* @throws HibernateException if we can't initialize the proxy at this time, eg. the <tt>Session</tt> was closed * @throws HibernateException if we can't initialize the proxy at this time, eg. the {@code Session} was closed
*/ */
public static void initialize(Object proxy) throws HibernateException { public static void initialize(Object proxy) throws HibernateException {
if ( proxy == null ) { if ( proxy == null ) {
@ -96,7 +96,7 @@ public final class Hibernate {
/** /**
* Check if the proxy or persistent collection is initialized. * Check if the proxy or persistent collection is initialized.
* *
* @param proxy a persistable object, proxy, persistent collection or <tt>null</tt> * @param proxy a persistable object, proxy, persistent collection or {@code null}
* @return true if the argument is already initialized, or is not a proxy or collection * @return true if the argument is already initialized, or is not a proxy or collection
*/ */
@SuppressWarnings("SimplifiableIfStatement") @SuppressWarnings("SimplifiableIfStatement")
@ -199,7 +199,7 @@ public final class Hibernate {
/** /**
* Check if the property is initialized. If the named property does not exist * Check if the property is initialized. If the named property does not exist
* or is not persistent, this method always returns <tt>true</tt>. * or is not persistent, this method always returns {@code true}.
* *
* @param proxy The potential proxy * @param proxy The potential proxy
* @param propertyName the name of a persistent attribute of the object * @param propertyName the name of a persistent attribute of the object
@ -286,7 +286,7 @@ public final class Hibernate {
/** /**
* Operations for obtaining references to persistent collections of a certain type. * Operations for obtaining references to persistent collections of a certain type.
* *
* @param <C> the type of collection, for example, <tt>List&lt;User&gt;</tt> * @param <C> the type of collection, for example, {@code List&lt;User&gt;}
*/ */
public static final class CollectionInterface<C> { public static final class CollectionInterface<C> {
private final Supplier<C> detached; private final Supplier<C> detached;

90
hibernate-core/src/main/java/org/hibernate/Interceptor.java
View File

@ -19,15 +19,15 @@ import org.hibernate.type.Type;
* Inspection occurs before property values are written and after they are read * Inspection occurs before property values are written and after they are read
* from the database. * from the database.
* *
* There might be a single instance of <tt>Interceptor</tt> for a <tt>SessionFactory</tt>, or a new instance * There might be a single instance of {@code Interceptor} for a {@code SessionFactory}, or a new instance
* might be specified for each <tt>Session</tt>. Whichever approach is used, the interceptor must be * might be specified for each {@code Session}. Whichever approach is used, the interceptor must be
* serializable if the <tt>Session</tt> is to be serializable. This means that <tt>SessionFactory</tt>-scoped * serializable if the {@code Session} is to be serializable. This means that {@code SessionFactory}-scoped
* interceptors should implement <tt>readResolve()</tt>. * interceptors should implement {@code readResolve()}.
* *
* The <tt>Session</tt> may not be invoked from a callback (nor may a callback cause a collection or proxy to * The {@code Session} may not be invoked from a callback (nor may a callback cause a collection or proxy to
* be lazily initialized). * be lazily initialized).
* *
* Instead of implementing this interface directly, it is usually better to extend <tt>EmptyInterceptor</tt> * Instead of implementing this interface directly, it is usually better to extend {@code EmptyInterceptor}
* and override only the callback methods of interest. * and override only the callback methods of interest.
* *
* @see SessionBuilder#interceptor(Interceptor) * @see SessionBuilder#interceptor(Interceptor)
@ -38,19 +38,19 @@ import org.hibernate.type.Type;
*/ */
public interface Interceptor { public interface Interceptor {
/** /**
* Called just before an object is initialized. The interceptor may change the <tt>state</tt>, which will * Called just before an object is initialized. The interceptor may change the {@code state}, which will
* be propagated to the persistent object. Note that when this method is called, <tt>entity</tt> will be * be propagated to the persistent object. Note that when this method is called, {@code entity} will be
* an empty uninitialized instance of the class. * an empty uninitialized instance of the class.
* <p/> * <p/>
* NOTE: The indexes across the <tt>state</tt>, <tt>propertyNames</tt> and <tt>types</tt> arrays match. * NOTE: The indexes across the {@code state}, {@code propertyNames} and {@code types} arrays match.
* *
* @param entity The entity instance being loaded * @param entity The entity instance being loaded
* @param id The identifier value being loaded * @param id The identifier value being loaded
* @param state The entity state (which will be pushed into the entity instance) * @param state The entity state (which will be pushed into the entity instance)
* @param propertyNames The names of the entity properties, corresponding to the <tt>state</tt>. * @param propertyNames The names of the entity properties, corresponding to the {@code state}.
* @param types The types of the entity properties, corresponding to the <tt>state</tt>. * @param types The types of the entity properties, corresponding to the {@code state}.
* *
* @return {@code true} if the user modified the <tt>state</tt> in any way. * @return {@code true} if the user modified the {@code state} in any way.
* *
* @throws CallbackException Thrown if the interceptor encounters any problems handling the callback. * @throws CallbackException Thrown if the interceptor encounters any problems handling the callback.
* *
@ -63,19 +63,19 @@ public interface Interceptor {
} }
/** /**
* Called just before an object is initialized. The interceptor may change the <tt>state</tt>, which will * Called just before an object is initialized. The interceptor may change the {@code state}, which will
* be propagated to the persistent object. Note that when this method is called, <tt>entity</tt> will be * be propagated to the persistent object. Note that when this method is called, {@code entity} will be
* an empty uninitialized instance of the class. * an empty uninitialized instance of the class.
* <p/> * <p/>
* NOTE: The indexes across the <tt>state</tt>, <tt>propertyNames</tt> and <tt>types</tt> arrays match. * NOTE: The indexes across the {@code state}, {@code propertyNames} and {@code types} arrays match.
* *
* @param entity The entity instance being loaded * @param entity The entity instance being loaded
* @param id The identifier value being loaded * @param id The identifier value being loaded
* @param state The entity state (which will be pushed into the entity instance) * @param state The entity state (which will be pushed into the entity instance)
* @param propertyNames The names of the entity properties, corresponding to the <tt>state</tt>. * @param propertyNames The names of the entity properties, corresponding to the {@code state}.
* @param types The types of the entity properties, corresponding to the <tt>state</tt>. * @param types The types of the entity properties, corresponding to the {@code state}.
* *
* @return {@code true} if the user modified the <tt>state</tt> in any way. * @return {@code true} if the user modified the {@code state} in any way.
* *
* @throws CallbackException Thrown if the interceptor encounters any problems handling the callback. * @throws CallbackException Thrown if the interceptor encounters any problems handling the callback.
*/ */
@ -89,13 +89,13 @@ public interface Interceptor {
/** /**
* Called when an object is detected to be dirty, during a flush. The interceptor may modify the detected * Called when an object is detected to be dirty, during a flush. The interceptor may modify the detected
* <tt>currentState</tt>, which will be propagated to both the database and the persistent object. * {@code currentState}, which will be propagated to both the database and the persistent object.
* Note that not all flushes end in actual synchronization with the database, in which case the * Note that not all flushes end in actual synchronization with the database, in which case the
* new <tt>currentState</tt> will be propagated to the object, but not necessarily (immediately) to * new {@code currentState} will be propagated to the object, but not necessarily (immediately) to
* the database. It is strongly recommended that the interceptor <b>not</b> modify the <tt>previousState</tt>. * the database. It is strongly recommended that the interceptor <b>not</b> modify the {@code previousState}.
* <p/> * <p/>
* NOTE: The indexes across the <tt>currentState</tt>, <tt>previousState</tt>, <tt>propertyNames</tt> and * NOTE: The indexes across the {@code currentState}, {@code previousState}, {@code propertyNames} and
* <tt>types</tt> arrays match. * {@code types} arrays match.
* *
* @param entity The entity instance detected as being dirty and being flushed * @param entity The entity instance detected as being dirty and being flushed
* @param id The identifier of the entity * @param id The identifier of the entity
@ -104,7 +104,7 @@ public interface Interceptor {
* @param propertyNames The names of the entity properties * @param propertyNames The names of the entity properties
* @param types The types of the entity properties * @param types The types of the entity properties
* *
* @return {@code true} if the user modified the <tt>currentState</tt> in any way. * @return {@code true} if the user modified the {@code currentState} in any way.
* *
* @throws CallbackException Thrown if the interceptor encounters any problems handling the callback. * @throws CallbackException Thrown if the interceptor encounters any problems handling the callback.
* *
@ -123,13 +123,13 @@ public interface Interceptor {
/** /**
* Called when an object is detected to be dirty, during a flush. The interceptor may modify the detected * Called when an object is detected to be dirty, during a flush. The interceptor may modify the detected
* <tt>currentState</tt>, which will be propagated to both the database and the persistent object. * {@code currentState}, which will be propagated to both the database and the persistent object.
* Note that not all flushes end in actual synchronization with the database, in which case the * Note that not all flushes end in actual synchronization with the database, in which case the
* new <tt>currentState</tt> will be propagated to the object, but not necessarily (immediately) to * new {@code currentState} will be propagated to the object, but not necessarily (immediately) to
* the database. It is strongly recommended that the interceptor <b>not</b> modify the <tt>previousState</tt>. * the database. It is strongly recommended that the interceptor <b>not</b> modify the {@code previousState}.
* <p/> * <p/>
* NOTE: The indexes across the <tt>currentState</tt>, <tt>previousState</tt>, <tt>propertyNames</tt> and * NOTE: The indexes across the {@code currentState}, {@code previousState}, {@code propertyNames} and
* <tt>types</tt> arrays match. * {@code types} arrays match.
* *
* @param entity The entity instance detected as being dirty and being flushed * @param entity The entity instance detected as being dirty and being flushed
* @param id The identifier of the entity * @param id The identifier of the entity
@ -138,7 +138,7 @@ public interface Interceptor {
* @param propertyNames The names of the entity properties * @param propertyNames The names of the entity properties
* @param types The types of the entity properties * @param types The types of the entity properties
* *
* @return {@code true} if the user modified the <tt>currentState</tt> in any way. * @return {@code true} if the user modified the {@code currentState} in any way.
* *
* @throws CallbackException Thrown if the interceptor encounters any problems handling the callback. * @throws CallbackException Thrown if the interceptor encounters any problems handling the callback.
*/ */
@ -156,8 +156,8 @@ public interface Interceptor {
} }
/** /**
* Called before an object is saved. The interceptor may modify the <tt>state</tt>, which will be used for * Called before an object is saved. The interceptor may modify the {@code state}, which will be used for
* the SQL <tt>INSERT</tt> and propagated to the persistent object. * the SQL {@code INSERT} and propagated to the persistent object.
* *
* @param entity The entity instance whose state is being inserted * @param entity The entity instance whose state is being inserted
* @param id The identifier of the entity * @param id The identifier of the entity
@ -165,7 +165,7 @@ public interface Interceptor {
* @param propertyNames The names of the entity properties. * @param propertyNames The names of the entity properties.
* @param types The types of the entity properties * @param types The types of the entity properties
* *
* @return <tt>true</tt> if the user modified the <tt>state</tt> in any way. * @return {@code true} if the user modified the {@code state} in any way.
* *
* @throws CallbackException Thrown if the interceptor encounters any problems handling the callback. * @throws CallbackException Thrown if the interceptor encounters any problems handling the callback.
*/ */
@ -173,7 +173,7 @@ public interface Interceptor {
throws CallbackException; throws CallbackException;
/** /**
* Called before an object is deleted. It is not recommended that the interceptor modify the <tt>state</tt>. * Called before an object is deleted. It is not recommended that the interceptor modify the {@code state}.
* *
* @param entity The entity instance being deleted * @param entity The entity instance being deleted
* @param id The identifier of the entity * @param id The identifier of the entity
@ -190,7 +190,7 @@ public interface Interceptor {
throws CallbackException {} throws CallbackException {}
/** /**
* Called before an object is deleted. It is not recommended that the interceptor modify the <tt>state</tt>. * Called before an object is deleted. It is not recommended that the interceptor modify the {@code state}.
* *
* @param entity The entity instance being deleted * @param entity The entity instance being deleted
* @param id The identifier of the entity * @param id The identifier of the entity
@ -310,24 +310,24 @@ public interface Interceptor {
* Called to distinguish between transient and detached entities. The return value determines the * Called to distinguish between transient and detached entities. The return value determines the
* state of the entity with respect to the current session. * state of the entity with respect to the current session.
* <ul> * <ul>
* <li><tt>Boolean.TRUE</tt> - the entity is transient * <li>{@code Boolean.TRUE} - the entity is transient
* <li><tt>Boolean.FALSE</tt> - the entity is detached * <li>{@code Boolean.FALSE} - the entity is detached
* <li><tt>null</tt> - Hibernate uses the <tt>unsaved-value</tt> mapping and other heuristics to * <li>{@code null} - Hibernate uses the {@code unsaved-value} mapping and other heuristics to
* determine if the object is unsaved * determine if the object is unsaved
* </ul> * </ul>
* @param entity a transient or detached entity * @param entity a transient or detached entity
* @return Boolean or <tt>null</tt> to choose default behaviour * @return Boolean or {@code null} to choose default behaviour
*/ */
default Boolean isTransient(Object entity) { default Boolean isTransient(Object entity) {
return null; return null;
} }
/** /**
* Called from <tt>flush()</tt>. The return value determines whether the entity is updated * Called from {@code flush()}. The return value determines whether the entity is updated
* <ul> * <ul>
* <li>an array of property indices - the entity is dirty * <li>an array of property indices - the entity is dirty
* <li>an empty array - the entity is not dirty * <li>an empty array - the entity is not dirty
* <li><tt>null</tt> - use Hibernate's default dirty-checking algorithm * <li>{@code null} - use Hibernate's default dirty-checking algorithm
* </ul> * </ul>
* *
* @param entity The entity for which to find dirty properties. * @param entity The entity for which to find dirty properties.
@ -355,11 +355,11 @@ public interface Interceptor {
} }
/** /**
* Called from <tt>flush()</tt>. The return value determines whether the entity is updated * Called from {@code flush()}. The return value determines whether the entity is updated
* <ul> * <ul>
* <li>an array of property indices - the entity is dirty * <li>an array of property indices - the entity is dirty
* <li>an empty array - the entity is not dirty * <li>an empty array - the entity is not dirty
* <li><tt>null</tt> - use Hibernate's default dirty-checking algorithm * <li>{@code null} - use Hibernate's default dirty-checking algorithm
* </ul> * </ul>
* *
* @param entity The entity for which to find dirty properties. * @param entity The entity for which to find dirty properties.
@ -387,7 +387,7 @@ public interface Interceptor {
} }
/** /**
* Instantiate the entity. Return <tt>null</tt> to indicate that Hibernate should use * Instantiate the entity. Return {@code null} to indicate that Hibernate should use
* the default constructor of the class. The identifier property of the returned instance * the default constructor of the class. The identifier property of the returned instance
* should be initialized with the given identifier. * should be initialized with the given identifier.
*/ */
@ -451,7 +451,7 @@ public interface Interceptor {
} }
/** /**
* Called when a Hibernate transaction is begun via the Hibernate <tt>Transaction</tt> * Called when a Hibernate transaction is begun via the Hibernate {@code Transaction}
* API. Will not be called if transactions are being controlled via some other * API. Will not be called if transactions are being controlled via some other
* mechanism (CMT, for example). * mechanism (CMT, for example).
* *

16
hibernate-core/src/main/java/org/hibernate/LockMode.java
View File

@ -21,7 +21,7 @@ package org.hibernate;
public enum LockMode { public enum LockMode {
/** /**
* No lock required. If an object is requested with this lock * No lock required. If an object is requested with this lock
* mode, a <tt>READ</tt> lock will be obtained if it is * mode, a {@code READ} lock will be obtained if it is
* necessary to actually read the state from the database, * necessary to actually read the state from the database,
* rather than pull it from a cache. * rather than pull it from a cache.
* <p> * <p>
@ -36,7 +36,7 @@ public enum LockMode {
READ( 5, "read" ), READ( 5, "read" ),
/** /**
* An upgrade lock. Objects loaded in this lock mode are * An upgrade lock. Objects loaded in this lock mode are
* materialized using an SQL <tt>select ... for update</tt>. * materialized using an SQL {@code select ... for update}.
* *
* @deprecated instead use PESSIMISTIC_WRITE * @deprecated instead use PESSIMISTIC_WRITE
*/ */
@ -44,24 +44,24 @@ public enum LockMode {
UPGRADE( 10, "upgrade" ), UPGRADE( 10, "upgrade" ),
/** /**
* Attempt to obtain an upgrade lock, using an Oracle-style * Attempt to obtain an upgrade lock, using an Oracle-style
* <tt>select for update nowait</tt>. The semantics of * {@code select for update nowait}. The semantics of
* this lock mode, once obtained, are the same as * this lock mode, once obtained, are the same as
* <tt>UPGRADE</tt>. * {@code UPGRADE}.
*/ */
UPGRADE_NOWAIT( 10, "upgrade-nowait" ), UPGRADE_NOWAIT( 10, "upgrade-nowait" ),
/** /**
* Attempt to obtain an upgrade lock, using an Oracle-style * Attempt to obtain an upgrade lock, using an Oracle-style
* <tt>select for update skip locked</tt>. The semantics of * {@code select for update skip locked}. The semantics of
* this lock mode, once obtained, are the same as * this lock mode, once obtained, are the same as
* <tt>UPGRADE</tt>. * {@code UPGRADE}.
*/ */
UPGRADE_SKIPLOCKED( 10, "upgrade-skiplocked" ), UPGRADE_SKIPLOCKED( 10, "upgrade-skiplocked" ),
/** /**
* A <tt>WRITE</tt> lock is obtained when an object is updated * A {@code WRITE} lock is obtained when an object is updated
* or inserted. This lock mode is for internal use only and is * or inserted. This lock mode is for internal use only and is
* not a valid mode for <tt>load()</tt> or <tt>lock()</tt> (both * not a valid mode for {@code load()} or {@code lock()} (both
* of which throw exceptions if WRITE is specified). * of which throw exceptions if WRITE is specified).
*/ */
WRITE( 10, "write" ), WRITE( 10, "write" ),

2
hibernate-core/src/main/java/org/hibernate/LockOptions.java
View File

@ -155,7 +155,7 @@ public class LockOptions implements Serializable {
* Determine the {@link LockMode} to apply to the given alias. If no * Determine the {@link LockMode} to apply to the given alias. If no
* mode was explicitly {@link #setAliasSpecificLockMode set}, the * mode was explicitly {@link #setAliasSpecificLockMode set}, the
* {@link #getLockMode overall mode} is returned. If the overall lock mode is * {@link #getLockMode overall mode} is returned. If the overall lock mode is
* <tt>null</tt> as well, {@link LockMode#NONE} is returned. * {@code null} as well, {@link LockMode#NONE} is returned.
* <p/> * <p/>
* Differs from {@link #getAliasSpecificLockMode} in that here we fallback to we only return * Differs from {@link #getAliasSpecificLockMode} in that here we fallback to we only return
* the overall lock mode. * the overall lock mode.

2
hibernate-core/src/main/java/org/hibernate/NonUniqueResultException.java
View File

@ -7,7 +7,7 @@
package org.hibernate; package org.hibernate;
/** /**
* Thrown when the application calls <tt>Query.uniqueResult()</tt> and * Thrown when the application calls {@code Query.uniqueResult()} and
* the query returned more than one result. Unlike all other Hibernate * the query returned more than one result. Unlike all other Hibernate
* exceptions, this one is recoverable! * exceptions, this one is recoverable!
* *

8
hibernate-core/src/main/java/org/hibernate/ObjectNotFoundException.java
View File

@ -7,11 +7,11 @@
package org.hibernate; package org.hibernate;
/** /**
* Thrown when <tt>Session.load()</tt> fails to select a row with * Thrown when {@code Session.load()} fails to select a row with
* the given primary key (identifier value). This exception might not * the given primary key (identifier value). This exception might not
* be thrown when <tt>load()</tt> is called, even if there was no * be thrown when {@code load()} is called, even if there was no
* row on the database, because <tt>load()</tt> returns a proxy if * row on the database, because {@code load()} returns a proxy if
* possible. Applications should use <tt>Session.get()</tt> to test if * possible. Applications should use {@code Session.get()} to test if
* a row exists in the database. * a row exists in the database.
* <p> * <p>
* Like all Hibernate exceptions, this exception is considered * Like all Hibernate exceptions, this exception is considered

2
hibernate-core/src/main/java/org/hibernate/PersistentObjectException.java
View File

@ -7,7 +7,7 @@
package org.hibernate; package org.hibernate;
/** /**
* Thrown when the user passes a persistent instance to a <tt>Session</tt> * Thrown when the user passes a persistent instance to a {@code Session}
* method that expects a transient instance. * method that expects a transient instance.
* *
* @author Gavin King * @author Gavin King

2
hibernate-core/src/main/java/org/hibernate/PropertyValueException.java
View File

@ -12,7 +12,7 @@ import org.hibernate.internal.util.StringHelper;
* Thrown when the (illegal) value of a property can not be persisted. * Thrown when the (illegal) value of a property can not be persisted.
* There are two main causes: * There are two main causes:
* <ul> * <ul>
* <li>a property declared <tt>not-null="true"</tt> is null * <li>a property declared {@code not-null="true"} is null
* <li>an association references an unsaved transient instance * <li>an association references an unsaved transient instance
* </ul> * </ul>
* @author Gavin King * @author Gavin King

8
hibernate-core/src/main/java/org/hibernate/ScrollableResults.java
View File

@ -12,10 +12,10 @@ import org.hibernate.query.Query;
/** /**
* A result iterator that allows moving around within the results * A result iterator that allows moving around within the results
* by arbitrary increments. The <tt>Query</tt> / <tt>ScrollableResults</tt> * by arbitrary increments. The {@code Query} / {@code ScrollableResults}
* pattern is very similar to the JDBC <tt>PreparedStatement</tt>/ * pattern is very similar to the JDBC {@code PreparedStatement}/
* <tt>ResultSet</tt> pattern and the semantics of methods of this interface * {@code ResultSet} pattern and the semantics of methods of this interface
* are similar to the similarly named methods on <tt>ResultSet</tt>. * are similar to the similarly named methods on {@code ResultSet}.
* <p> * <p>
* Contrary to JDBC, columns of results are numbered from zero. * Contrary to JDBC, columns of results are numbered from zero.
* *

82
hibernate-core/src/main/java/org/hibernate/Session.java
View File

@ -17,34 +17,34 @@ import org.hibernate.stat.SessionStatistics;
* The main runtime interface between a Java application and Hibernate. This is the * The main runtime interface between a Java application and Hibernate. This is the
* central API class abstracting the notion of a persistence service. * central API class abstracting the notion of a persistence service.
* <p> * <p>
* The lifecycle of a <tt>Session</tt> is bounded by the beginning and end of a logical * The lifecycle of a {@code Session} is bounded by the beginning and end of a logical
* transaction. (Long transactions might span several database transactions.) * transaction. (Long transactions might span several database transactions.)
* <p> * <p>
* The main function of the <tt>Session</tt> is to offer create, read and delete operations * The main function of the {@code Session} is to offer create, read and delete operations
* for instances of mapped entity classes. Instances may exist in one of three states: * for instances of mapped entity classes. Instances may exist in one of three states:
* <ul> * <ul>
* <li><i>transient:</i> never persistent, not associated with any <tt>Session</tt> * <li><i>transient:</i> never persistent, not associated with any {@code Session}
* <li><i>persistent:</i> associated with a unique <tt>Session</tt> * <li><i>persistent:</i> associated with a unique {@code Session}
* <li><i>detached:</i> previously persistent, not associated with any <tt>Session</tt> * <li><i>detached:</i> previously persistent, not associated with any {@code Session}
* </ul> * </ul>
* Transient instances may be made persistent by calling <tt>save()</tt>, * Transient instances may be made persistent by calling {@code save()},
* <tt>persist()</tt> or <tt>saveOrUpdate()</tt>. Persistent instances may be made transient * {@code persist()} or {@code saveOrUpdate()}. Persistent instances may be made transient
* by calling<tt> delete()</tt>. Any instance returned by a <tt>get()</tt> or * by calling{@code delete()}. Any instance returned by a {@code get()} or
* <tt>load()</tt> method is persistent. Detached instances may be made persistent * {@code load()} method is persistent. Detached instances may be made persistent
* by calling <tt>update()</tt>, <tt>saveOrUpdate()</tt>, <tt>lock()</tt> or <tt>replicate()</tt>. * by calling {@code update()}, {@code saveOrUpdate()}, {@code lock()} or {@code replicate()}.
* The state of a transient or detached instance may also be made persistent as a new * The state of a transient or detached instance may also be made persistent as a new
* persistent instance by calling <tt>merge()</tt>. * persistent instance by calling {@code merge()}.
* <p> * <p>
* <tt>save()</tt> and <tt>persist()</tt> result in an SQL <tt>INSERT</tt>, <tt>delete()</tt> * {@code save()} and {@code persist()} result in an SQL {@code INSERT}, {@code delete()}
* in an SQL <tt>DELETE</tt> and <tt>update()</tt> or <tt>merge()</tt> in an SQL <tt>UPDATE</tt>. * in an SQL {@code DELETE} and {@code update()} or {@code merge()} in an SQL {@code UPDATE}.
* Changes to <i>persistent</i> instances are detected at flush time and also result in an SQL * Changes to <i>persistent</i> instances are detected at flush time and also result in an SQL
* <tt>UPDATE</tt>. <tt>saveOrUpdate()</tt> and <tt>replicate()</tt> result in either an * {@code UPDATE}. {@code saveOrUpdate()} and {@code replicate()} result in either an
* <tt>INSERT</tt> or an <tt>UPDATE</tt>. * {@code INSERT} or an {@code UPDATE}.
* <p> * <p>
* It is not intended that implementors be threadsafe. Instead each thread/transaction * It is not intended that implementors be threadsafe. Instead each thread/transaction
* should obtain its own instance from a <tt>SessionFactory</tt>. * should obtain its own instance from a {@code SessionFactory}.
* <p> * <p>
* A <tt>Session</tt> instance is serializable if its persistent classes are serializable. * A {@code Session} instance is serializable if its persistent classes are serializable.
* <p> * <p>
* A typical transaction should use the following idiom: * A typical transaction should use the following idiom:
* <pre> * <pre>
@ -65,8 +65,8 @@ import org.hibernate.stat.SessionStatistics;
* } * }
* </pre> * </pre>
* <p> * <p>
* If the <tt>Session</tt> throws an exception, the transaction must be rolled back * If the {@code Session} throws an exception, the transaction must be rolled back
* and the session discarded. The internal state of the <tt>Session</tt> might not * and the session discarded. The internal state of the {@code Session} might not
* be consistent with the database after the exception occurs. * be consistent with the database after the exception occurs.
* *
* @see SessionFactory * @see SessionFactory
@ -251,14 +251,14 @@ public interface Session extends SharedSessionContract, EntityManager {
* @param entityName The entity name * @param entityName The entity name
* @param object an instance of a persistent class * @param object an instance of a persistent class
* *
* @return true if the given instance is associated with this <tt>Session</tt> * @return true if the given instance is associated with this {@code Session}
*/ */
boolean contains(String entityName, Object object); boolean contains(String entityName, Object object);
/** /**
* Remove this instance from the session cache. Changes to the instance will * Remove this instance from the session cache. Changes to the instance will
* not be synchronized with the database. This operation cascades to associated * not be synchronized with the database. This operation cascades to associated
* instances if the association is mapped with <tt>cascade="evict"</tt>. * instances if the association is mapped with {@code cascade="evict"}.
* *
* @param object The entity to evict * @param object The entity to evict
* *
@ -327,7 +327,7 @@ public interface Session extends SharedSessionContract, EntityManager {
* assuming that the instance exists. This method might return a proxied instance that * assuming that the instance exists. This method might return a proxied instance that
* is initialized on-demand, when a non-identifier method is accessed. * is initialized on-demand, when a non-identifier method is accessed.
* <p> * <p>
* You should not use this method to determine if an instance exists (use <tt>get()</tt> * You should not use this method to determine if an instance exists (use {@code get()}
* instead). Use this only to retrieve an instance that you assume exists, where non-existence * instead). Use this only to retrieve an instance that you assume exists, where non-existence
* would be an actual error. * would be an actual error.
* *
@ -343,7 +343,7 @@ public interface Session extends SharedSessionContract, EntityManager {
* assuming that the instance exists. This method might return a proxied instance that * assuming that the instance exists. This method might return a proxied instance that
* is initialized on-demand, when a non-identifier method is accessed. * is initialized on-demand, when a non-identifier method is accessed.
* <p> * <p>
* You should not use this method to determine if an instance exists (use <tt>get()</tt> * You should not use this method to determine if an instance exists (use {@code get()}
* instead). Use this only to retrieve an instance that you assume exists, where non-existence * instead). Use this only to retrieve an instance that you assume exists, where non-existence
* would be an actual error. * would be an actual error.
* *
@ -383,7 +383,7 @@ public interface Session extends SharedSessionContract, EntityManager {
/** /**
* Persist the given transient instance, first assigning a generated identifier. (Or * Persist the given transient instance, first assigning a generated identifier. (Or
* using the current value of the identifier property if the <tt>assigned</tt> * using the current value of the identifier property if the {@code assigned}
* generator is used.) This operation cascades to associated instances if the * generator is used.) This operation cascades to associated instances if the
* association is mapped with {@code cascade="save-update"} * association is mapped with {@code cascade="save-update"}
* *
@ -395,7 +395,7 @@ public interface Session extends SharedSessionContract, EntityManager {
/** /**
* Persist the given transient instance, first assigning a generated identifier. (Or * Persist the given transient instance, first assigning a generated identifier. (Or
* using the current value of the identifier property if the <tt>assigned</tt> * using the current value of the identifier property if the {@code assigned}
* generator is used.) This operation cascades to associated instances if the * generator is used.) This operation cascades to associated instances if the
* association is mapped with {@code cascade="save-update"} * association is mapped with {@code cascade="save-update"}
* *
@ -515,7 +515,7 @@ public interface Session extends SharedSessionContract, EntityManager {
/** /**
* Remove a persistent instance from the datastore. The argument may be * Remove a persistent instance from the datastore. The argument may be
* an instance associated with the receiving <tt>Session</tt> or a transient * an instance associated with the receiving {@code Session} or a transient
* instance with an identifier associated with existing persistent state. * instance with an identifier associated with existing persistent state.
* This operation cascades to associated instances if the association is mapped * This operation cascades to associated instances if the association is mapped
* with {@code cascade="delete"} * with {@code cascade="delete"}
@ -526,7 +526,7 @@ public interface Session extends SharedSessionContract, EntityManager {
/** /**
* Remove a persistent instance from the datastore. The <b>object</b> argument may be * Remove a persistent instance from the datastore. The <b>object</b> argument may be
* an instance associated with the receiving <tt>Session</tt> or a transient * an instance associated with the receiving {@code Session} or a transient
* instance with an identifier associated with existing persistent state. * instance with an identifier associated with existing persistent state.
* This operation cascades to associated instances if the association is mapped * This operation cascades to associated instances if the association is mapped
* with {@code cascade="delete"} * with {@code cascade="delete"}
@ -538,10 +538,10 @@ public interface Session extends SharedSessionContract, EntityManager {
/** /**
* Obtain the specified lock level upon the given object. This may be used to * Obtain the specified lock level upon the given object. This may be used to
* perform a version check (<tt>LockMode.READ</tt>), to upgrade to a pessimistic * perform a version check ({@code LockMode.READ}), to upgrade to a pessimistic
* lock (<tt>LockMode.PESSIMISTIC_WRITE</tt>), or to simply reassociate a transient instance * lock ({@code LockMode.PESSIMISTIC_WRITE}), or to simply reassociate a transient instance
* with a session (<tt>LockMode.NONE</tt>). This operation cascades to associated * with a session ({@code LockMode.NONE}). This operation cascades to associated
* instances if the association is mapped with <tt>cascade="lock"</tt>. * instances if the association is mapped with {@code cascade="lock"}.
* <p/> * <p/>
* Convenient form of {@link LockRequest#lock(Object)} via {@link #buildLockRequest(LockOptions)} * Convenient form of {@link LockRequest#lock(Object)} via {@link #buildLockRequest(LockOptions)}
* *
@ -555,10 +555,10 @@ public interface Session extends SharedSessionContract, EntityManager {
/** /**
* Obtain the specified lock level upon the given object. This may be used to * Obtain the specified lock level upon the given object. This may be used to
* perform a version check (<tt>LockMode.OPTIMISTIC</tt>), to upgrade to a pessimistic * perform a version check ({@code LockMode.OPTIMISTIC}), to upgrade to a pessimistic
* lock (<tt>LockMode.PESSIMISTIC_WRITE</tt>), or to simply reassociate a transient instance * lock ({@code LockMode.PESSIMISTIC_WRITE}), or to simply reassociate a transient instance
* with a session (<tt>LockMode.NONE</tt>). This operation cascades to associated * with a session ({@code LockMode.NONE}). This operation cascades to associated
* instances if the association is mapped with <tt>cascade="lock"</tt>. * instances if the association is mapped with {@code cascade="lock"}.
* <p/> * <p/>
* Convenient form of {@link LockRequest#lock(String, Object)} via {@link #buildLockRequest(LockOptions)} * Convenient form of {@link LockRequest#lock(String, Object)} via {@link #buildLockRequest(LockOptions)}
* *
@ -593,7 +593,7 @@ public interface Session extends SharedSessionContract, EntityManager {
* <ul> * <ul>
* <li>where a database trigger alters the object state upon insert or update * <li>where a database trigger alters the object state upon insert or update
* <li>after executing direct SQL (eg. a mass update) in the same session * <li>after executing direct SQL (eg. a mass update) in the same session
* <li>after inserting a <tt>Blob</tt> or <tt>Clob</tt> * <li>after inserting a {@code Blob} or {@code Clob}
* </ul> * </ul>
* *
* @param object a persistent or detached instance * @param object a persistent or detached instance
@ -608,7 +608,7 @@ public interface Session extends SharedSessionContract, EntityManager {
* <ul> * <ul>
* <li>where a database trigger alters the object state upon insert or update * <li>where a database trigger alters the object state upon insert or update
* <li>after executing direct SQL (eg. a mass update) in the same session * <li>after executing direct SQL (eg. a mass update) in the same session
* <li>after inserting a <tt>Blob</tt> or <tt>Clob</tt> * <li>after inserting a {@code Blob} or {@code Clob}
* </ul> * </ul>
* *
* @param entityName a persistent class * @param entityName a persistent class
@ -618,7 +618,7 @@ public interface Session extends SharedSessionContract, EntityManager {
/** /**
* Re-read the state of the given instance from the underlying database, with * Re-read the state of the given instance from the underlying database, with
* the given <tt>LockMode</tt>. It is inadvisable to use this to implement * the given {@code LockMode}. It is inadvisable to use this to implement
* long-running sessions that span many business tasks. This method is, however, * long-running sessions that span many business tasks. This method is, however,
* useful in certain special circumstances. * useful in certain special circumstances.
* <p/> * <p/>
@ -633,7 +633,7 @@ public interface Session extends SharedSessionContract, EntityManager {
/** /**
* Re-read the state of the given instance from the underlying database, with * Re-read the state of the given instance from the underlying database, with
* the given <tt>LockMode</tt>. It is inadvisable to use this to implement * the given {@code LockMode}. It is inadvisable to use this to implement
* long-running sessions that span many business tasks. This method is, however, * long-running sessions that span many business tasks. This method is, however,
* useful in certain special circumstances. * useful in certain special circumstances.
* *
@ -644,7 +644,7 @@ public interface Session extends SharedSessionContract, EntityManager {
/** /**
* Re-read the state of the given instance from the underlying database, with * Re-read the state of the given instance from the underlying database, with
* the given <tt>LockMode</tt>. It is inadvisable to use this to implement * the given {@code LockMode}. It is inadvisable to use this to implement
* long-running sessions that span many business tasks. This method is, however, * long-running sessions that span many business tasks. This method is, however,
* useful in certain special circumstances. * useful in certain special circumstances.
* *
@ -666,7 +666,7 @@ public interface Session extends SharedSessionContract, EntityManager {
/** /**
* Completely clear the session. Evict all loaded instances and cancel all pending * Completely clear the session. Evict all loaded instances and cancel all pending
* saves, updates and deletions. Do not close open iterators or instances of * saves, updates and deletions. Do not close open iterators or instances of
* <tt>ScrollableResults</tt>. * {@code ScrollableResults}.
*/ */
void clear(); void clear();

4
hibernate-core/src/main/java/org/hibernate/SessionFactory.java
View File

@ -215,7 +215,7 @@ public interface SessionFactory extends EntityManagerFactory, HibernateEntityMan
Statistics getStatistics(); Statistics getStatistics();
/** /**
* Destroy this <tt>SessionFactory</tt> and release all resources (caches, * Destroy this {@code SessionFactory} and release all resources (caches,
* connection pools, etc). * connection pools, etc).
* <p/> * <p/>
* It is the responsibility of the application to ensure that there are no * It is the responsibility of the application to ensure that there are no
@ -336,7 +336,7 @@ public interface SessionFactory extends EntityManagerFactory, HibernateEntityMan
/** /**
* Get the {@link CollectionMetadata} for all mapped collections. * Get the {@link CollectionMetadata} for all mapped collections.
* *
* @return a map from <tt>String</tt> to <tt>CollectionMetadata</tt> * @return a map from {@code String} to {@code CollectionMetadata}
* *
* @throws HibernateException Generally empty map is returned instead of throwing. * @throws HibernateException Generally empty map is returned instead of throwing.
* *

4
hibernate-core/src/main/java/org/hibernate/action/internal/BulkOperationCleanupAction.java
View File

@ -37,8 +37,8 @@ import org.hibernate.sql.ast.tree.insert.InsertStatement;
* An {@link org.hibernate.engine.spi.ActionQueue} {@link Executable} for ensuring * An {@link org.hibernate.engine.spi.ActionQueue} {@link Executable} for ensuring
* shared cache cleanup in relation to performed bulk HQL queries. * shared cache cleanup in relation to performed bulk HQL queries.
* <p/> * <p/>
* NOTE: currently this executes for <tt>INSERT</tt> queries as well as * NOTE: currently this executes for {@code INSERT} queries as well as
* <tt>UPDATE</tt> and <tt>DELETE</tt> queries. For <tt>INSERT</tt> it is * {@code UPDATE} and {@code DELETE} queries. For {@code INSERT} it is
* really not needed as we'd have no invalid entity/collection data to * really not needed as we'd have no invalid entity/collection data to
* cleanup (we'd still nee to invalidate the appropriate update-timestamps * cleanup (we'd still nee to invalidate the appropriate update-timestamps
* regions) as a result of this query. * regions) as a result of this query.

4
hibernate-core/src/main/java/org/hibernate/boot/MetadataSources.java
View File

@ -567,7 +567,7 @@ public class MetadataSources implements Serializable {
/** /**
* Read all mappings from a jar file. * Read all mappings from a jar file.
* <p/> * <p/>
* Assumes that any file named <tt>*.hbm.xml</tt> is a mapping document. * Assumes that any file named {@code *.hbm.xml} is a mapping document.
* *
* @param jar a jar file * @param jar a jar file
* *
@ -592,7 +592,7 @@ public class MetadataSources implements Serializable {
/** /**
* Read all mapping documents from a directory tree. * Read all mapping documents from a directory tree.
* <p/> * <p/>
* Assumes that any file named <tt>*.hbm.xml</tt> is a mapping document. * Assumes that any file named {@code *.hbm.xml} is a mapping document.
* *
* @param dir The directory * @param dir The directory
* *

2
hibernate-core/src/main/java/org/hibernate/boot/internal/InFlightMetadataCollectorImpl.java
View File

@ -1748,7 +1748,7 @@ public class InFlightMetadataCollectorImpl implements InFlightMetadataCollector
* Checking all dependencies recursively seems quite expensive, but the original code just relied * Checking all dependencies recursively seems quite expensive, but the original code just relied
* on some sort of table name sorting which failed in certain circumstances. * on some sort of table name sorting which failed in certain circumstances.
* <p/> * <p/>
* See <tt>ANN-722</tt> and <tt>ANN-730</tt> * See {@code ANN-722} and {@code ANN-730}
* *
* @param orderedFkSecondPasses The list containing the <code>FkSecondPass</code> instances ready * @param orderedFkSecondPasses The list containing the <code>FkSecondPass</code> instances ready
* for processing. * for processing.

4
hibernate-core/src/main/java/org/hibernate/boot/model/naming/ObjectNameNormalizer.java
View File

@ -22,8 +22,8 @@ public abstract class ObjectNameNormalizer {
* Normalizes the quoting of identifiers. * Normalizes the quoting of identifiers.
* <p/> * <p/>
* This implements the rules set forth in JPA 2 (section "2.13 Naming of Database Objects") which * This implements the rules set forth in JPA 2 (section "2.13 Naming of Database Objects") which
* states that the double-quote (") is the character which should be used to denote a <tt>quoted * states that the double-quote (") is the character which should be used to denote a {@code quoted
* identifier</tt>. Here, we handle recognizing that and converting it to the more elegant * identifier}. Here, we handle recognizing that and converting it to the more elegant
* backtick (`) approach used in Hibernate.. Additionally we account for applying what JPA2 terms * backtick (`) approach used in Hibernate.. Additionally we account for applying what JPA2 terms
* "globally quoted identifiers". * "globally quoted identifiers".
* *

2
hibernate-core/src/main/java/org/hibernate/cache/spi/CacheImplementor.java vendored
View File

@ -86,7 +86,7 @@ public interface CacheImplementor extends Service, Cache, Serializable {
QueryResultsCache getDefaultQueryResultsCache(); QueryResultsCache getDefaultQueryResultsCache();
/** /**
* Get query cache by <tt>region name</tt> or create a new one if none exist. * Get query cache by {@code region name} or create a new one if none exist.
* *
* If the region name is null, then default query cache region will be returned. * If the region name is null, then default query cache region will be returned.
* *

30
hibernate-core/src/main/java/org/hibernate/cfg/AvailableSettings.java
View File

@ -771,13 +771,13 @@ public interface AvailableSettings {
String DEFAULT_BATCH_FETCH_SIZE = "hibernate.default_batch_fetch_size"; String DEFAULT_BATCH_FETCH_SIZE = "hibernate.default_batch_fetch_size";
/** /**
* Use <tt>java.io</tt> streams to read / write binary data from / to JDBC * Use {@code java.io} streams to read / write binary data from / to JDBC
*/ */
String USE_STREAMS_FOR_BINARY = "hibernate.jdbc.use_streams_for_binary"; String USE_STREAMS_FOR_BINARY = "hibernate.jdbc.use_streams_for_binary";
/** /**
* Use JDBC scrollable <tt>ResultSet</tt>s. This property is only necessary when there is * Use JDBC scrollable {@code ResultSet}s. This property is only necessary when there is
* no <tt>ConnectionProvider</tt>, ie. the user is supplying JDBC connections. * no {@code ConnectionProvider}, ie. the user is supplying JDBC connections.
*/ */
String USE_SCROLLABLE_RESULTSET = "hibernate.jdbc.use_scrollable_resultset"; String USE_SCROLLABLE_RESULTSET = "hibernate.jdbc.use_scrollable_resultset";
@ -790,7 +790,7 @@ public interface AvailableSettings {
/** /**
* Gives the JDBC driver a hint as to the number of rows that should be fetched from the database * Gives the JDBC driver a hint as to the number of rows that should be fetched from the database
* when more rows are needed. If <tt>0</tt>, JDBC driver default settings will be used. * when more rows are needed. If {@code 0}, JDBC driver default settings will be used.
*/ */
String STATEMENT_FETCH_SIZE = "hibernate.jdbc.fetch_size"; String STATEMENT_FETCH_SIZE = "hibernate.jdbc.fetch_size";
@ -821,7 +821,7 @@ public interface AvailableSettings {
String AUTO_CLOSE_SESSION = "hibernate.transaction.auto_close_session"; String AUTO_CLOSE_SESSION = "hibernate.transaction.auto_close_session";
/** /**
* Enable automatic flush during the JTA <tt>beforeCompletion()</tt> callback * Enable automatic flush during the JTA {@code beforeCompletion()} callback
*/ */
String FLUSH_BEFORE_COMPLETION = "hibernate.transaction.flush_before_completion"; String FLUSH_BEFORE_COMPLETION = "hibernate.transaction.flush_before_completion";
@ -1137,24 +1137,24 @@ public interface AvailableSettings {
String PROXOOL_CONFIG_PREFIX = "hibernate.proxool"; String PROXOOL_CONFIG_PREFIX = "hibernate.proxool";
/** /**
* Proxool property to configure the Proxool Provider using an XML (<tt>/path/to/file.xml</tt>) * Proxool property to configure the Proxool Provider using an XML ({@code /path/to/file.xml})
*/ */
String PROXOOL_XML = "hibernate.proxool.xml"; String PROXOOL_XML = "hibernate.proxool.xml";
/** /**
* Proxool property to configure the Proxool Provider using a properties file (<tt>/path/to/proxool.properties</tt>) * Proxool property to configure the Proxool Provider using a properties file ({@code /path/to/proxool.properties})
*/ */
String PROXOOL_PROPERTIES = "hibernate.proxool.properties"; String PROXOOL_PROPERTIES = "hibernate.proxool.properties";
/** /**
* Proxool property to configure the Proxool Provider from an already existing pool (<tt>true</tt> / <tt>false</tt>) * Proxool property to configure the Proxool Provider from an already existing pool ({@code true} / {@code false})
*/ */
String PROXOOL_EXISTING_POOL = "hibernate.proxool.existing_pool"; String PROXOOL_EXISTING_POOL = "hibernate.proxool.existing_pool";
/** /**
* Proxool property with the Proxool pool alias to use * Proxool property with the Proxool pool alias to use
* (Required for <tt>PROXOOL_EXISTING_POOL</tt>, <tt>PROXOOL_PROPERTIES</tt>, or * (Required for {@code PROXOOL_EXISTING_POOL}, {@code PROXOOL_PROPERTIES}, or
* <tt>PROXOOL_XML</tt>) * {@code PROXOOL_XML})
*/ */
String PROXOOL_POOL_ALIAS = "hibernate.proxool.pool_alias"; String PROXOOL_POOL_ALIAS = "hibernate.proxool.pool_alias";
@ -1187,7 +1187,7 @@ public interface AvailableSettings {
String CACHE_KEYS_FACTORY = "hibernate.cache.keys_factory"; String CACHE_KEYS_FACTORY = "hibernate.cache.keys_factory";
/** /**
* The <tt>CacheProvider</tt> implementation class * The {@code CacheProvider} implementation class
*/ */
String CACHE_PROVIDER_CONFIG = "hibernate.cache.provider_configuration_file_resource_path"; String CACHE_PROVIDER_CONFIG = "hibernate.cache.provider_configuration_file_resource_path";
@ -1210,7 +1210,7 @@ public interface AvailableSettings {
String QUERY_CACHE_FACTORY = "hibernate.cache.query_cache_factory"; String QUERY_CACHE_FACTORY = "hibernate.cache.query_cache_factory";
/** /**
* The <tt>CacheProvider</tt> region name prefix * The {@code CacheProvider} region name prefix
*/ */
String CACHE_REGION_PREFIX = "hibernate.cache.region_prefix"; String CACHE_REGION_PREFIX = "hibernate.cache.region_prefix";
@ -1434,10 +1434,10 @@ public interface AvailableSettings {
* File order matters, the statements of a give file are executed before the statements of the * File order matters, the statements of a give file are executed before the statements of the
* following files. * following files.
* <p/> * <p/>
* These statements are only executed if the schema is created ie if <tt>hibernate.hbm2ddl.auto</tt> * These statements are only executed if the schema is created ie if {@code hibernate.hbm2ddl.auto}
* is set to <tt>create</tt> or <tt>create-drop</tt>. * is set to {@code create} or {@code create-drop}.
* <p/> * <p/>
* The default value is <tt>/import.sql</tt> * The default value is {@code /import.sql}
* <p/> * <p/>
* {@link #HBM2DDL_CREATE_SCRIPT_SOURCE} / {@link #HBM2DDL_DROP_SCRIPT_SOURCE} should be preferred * {@link #HBM2DDL_CREATE_SCRIPT_SOURCE} / {@link #HBM2DDL_DROP_SCRIPT_SOURCE} should be preferred
* moving forward * moving forward

28
hibernate-core/src/main/java/org/hibernate/cfg/Configuration.java
View File

@ -239,11 +239,11 @@ public class Configuration {
} }
/** /**
* Use the mappings and properties specified in an application resource named <tt>hibernate.cfg.xml</tt>. * Use the mappings and properties specified in an application resource named {@code hibernate.cfg.xml}.
* *
* @return this for method chaining * @return this for method chaining
* *
* @throws HibernateException Generally indicates we cannot find <tt>hibernate.cfg.xml</tt> * @throws HibernateException Generally indicates we cannot find {@code hibernate.cfg.xml}
* *
* @see #configure(String) * @see #configure(String)
*/ */
@ -253,7 +253,7 @@ public class Configuration {
/** /**
* Use the mappings and properties specified in the given application resource. The format of the resource is * Use the mappings and properties specified in the given application resource. The format of the resource is
* defined in <tt>hibernate-configuration-3.0.dtd</tt>. * defined in {@code hibernate-configuration-3.0.dtd}.
* *
* @param resource The resource to use * @param resource The resource to use
* *
@ -278,7 +278,7 @@ public class Configuration {
/** /**
* Use the mappings and properties specified in the given document. The format of the document is defined in * Use the mappings and properties specified in the given document. The format of the document is defined in
* <tt>hibernate-configuration-3.0.dtd</tt>. * {@code hibernate-configuration-3.0.dtd}.
* *
* @param url URL from which you wish to load the configuration * @param url URL from which you wish to load the configuration
* *
@ -294,7 +294,7 @@ public class Configuration {
/** /**
* Use the mappings and properties specified in the given application file. The format of the file is defined in * Use the mappings and properties specified in the given application file. The format of the file is defined in
* <tt>hibernate-configuration-3.0.dtd</tt>. * {@code hibernate-configuration-3.0.dtd}.
* *
* @param configFile File from which you wish to load the configuration * @param configFile File from which you wish to load the configuration
* *
@ -402,12 +402,12 @@ public class Configuration {
/** /**
* Add a cached mapping file. A cached file is a serialized representation * Add a cached mapping file. A cached file is a serialized representation
* of the DOM structure of a particular mapping. It is saved from a previous * of the DOM structure of a particular mapping. It is saved from a previous
* call as a file with the name <tt>xmlFile + ".bin"</tt> where xmlFile is * call as a file with the name {@code xmlFile + ".bin"} where xmlFile is
* the name of the original mapping file. * the name of the original mapping file.
* </p> * </p>
* If a cached <tt>xmlFile + ".bin"</tt> exists and is newer than * If a cached {@code xmlFile + ".bin"} exists and is newer than
* <tt>xmlFile</tt> the <tt>".bin"</tt> file will be read directly. Otherwise * {@code xmlFile} the {@code ".bin"} file will be read directly. Otherwise
* xmlFile is read and then serialized to <tt>xmlFile + ".bin"</tt> for use * xmlFile is read and then serialized to {@code xmlFile + ".bin"} for use
* the next time. * the next time.
* *
* @param xmlFile The cacheable mapping file to be added. * @param xmlFile The cacheable mapping file to be added.
@ -463,7 +463,7 @@ public class Configuration {
} }
/** /**
* Read mappings from a <tt>URL</tt> * Read mappings from a {@code URL}
* *
* @param url The url for the mapping document to be read. * @param url The url for the mapping document to be read.
* @return this (for method chaining purposes) * @return this (for method chaining purposes)
@ -476,7 +476,7 @@ public class Configuration {
} }
/** /**
* Read mappings from a DOM <tt>Document</tt> * Read mappings from a DOM {@code Document}
* *
* @param doc The DOM document * @param doc The DOM document
* @return this (for method chaining purposes) * @return this (for method chaining purposes)
@ -529,7 +529,7 @@ public class Configuration {
/** /**
* Read a mapping as an application resource using the convention that a class * Read a mapping as an application resource using the convention that a class
* named <tt>foo.bar.Foo</tt> is mapped by a file <tt>foo/bar/Foo.hbm.xml</tt> * named {@code foo.bar.Foo} is mapped by a file {@code foo/bar/Foo.hbm.xml}
* which can be resolved as a classpath resource. * which can be resolved as a classpath resource.
* *
* @param persistentClass The mapped class * @param persistentClass The mapped class
@ -572,7 +572,7 @@ public class Configuration {
/** /**
* Read all mappings from a jar file * Read all mappings from a jar file
* <p/> * <p/>
* Assumes that any file named <tt>*.hbm.xml</tt> is a mapping document. * Assumes that any file named {@code *.hbm.xml} is a mapping document.
* *
* @param jar a jar file * @param jar a jar file
* @return this (for method chaining purposes) * @return this (for method chaining purposes)
@ -587,7 +587,7 @@ public class Configuration {
/** /**
* Read all mapping documents from a directory tree. * Read all mapping documents from a directory tree.
* <p/> * <p/>
* Assumes that any file named <tt>*.hbm.xml</tt> is a mapping document. * Assumes that any file named {@code *.hbm.xml} is a mapping document.
* *
* @param dir The directory * @param dir The directory
* @return this (for method chaining purposes) * @return this (for method chaining purposes)

2
hibernate-core/src/main/java/org/hibernate/cfg/DefaultNamingStrategy.java
View File

@ -12,7 +12,7 @@ import org.hibernate.AssertionFailure;
import org.hibernate.internal.util.StringHelper; import org.hibernate.internal.util.StringHelper;
/** /**
* The default <tt>NamingStrategy</tt> * The default {@code NamingStrategy}
* @see ImprovedNamingStrategy a better alternative * @see ImprovedNamingStrategy a better alternative
* @author Gavin King * @author Gavin King
*/ */

100
hibernate-core/src/main/java/org/hibernate/cfg/Environment.java
View File

@ -24,125 +24,125 @@ import org.jboss.logging.Logger;
/** /**
* Provides access to configuration info passed in <tt>Properties</tt> objects. * Provides access to configuration info passed in {@code Properties} objects.
* <p> * <p>
* Hibernate has two property scopes: * Hibernate has two property scopes:
* <ul> * <ul>
* <li><b>Factory-level</b> properties may be passed to the <tt>SessionFactory</tt> when it * <li><b>Factory-level</b> properties may be passed to the {@code SessionFactory} when it
* is instantiated. Each instance might have different property values. If no * is instantiated. Each instance might have different property values. If no
* properties are specified, the factory calls <tt>Environment.getProperties()</tt>. * properties are specified, the factory calls {@code Environment.getProperties()}.
* <li><b>System-level</b> properties are shared by all factory instances and are always * <li><b>System-level</b> properties are shared by all factory instances and are always
* determined by the <tt>Environment</tt> properties. * determined by the {@code Environment} properties.
* </ul> * </ul>
* The only system-level properties are * The only system-level properties are
* <ul> * <ul>
* <li><tt>hibernate.jdbc.use_streams_for_binary</tt> * <li>{@code hibernate.jdbc.use_streams_for_binary}
* <li><tt>hibernate.cglib.use_reflection_optimizer</tt> * <li>{@code hibernate.cglib.use_reflection_optimizer}
* </ul> * </ul>
* <tt>Environment</tt> properties are populated by calling <tt>System.getProperties()</tt> * {@code Environment} properties are populated by calling {@code System.getProperties()}
* and then from a resource named <tt>/hibernate.properties</tt> if it exists. System * and then from a resource named {@code /hibernate.properties} if it exists. System
* properties override properties specified in <tt>hibernate.properties</tt>. * properties override properties specified in {@code hibernate.properties}.
* <p> * <p>
* The <tt>SessionFactory</tt> is controlled by the following properties. * The {@code SessionFactory} is controlled by the following properties.
* Properties may be either be <tt>System</tt> properties, properties * Properties may be either be {@code System} properties, properties
* defined in a resource named <tt>/hibernate.properties</tt> or an instance of * defined in a resource named {@code /hibernate.properties} or an instance of
* <tt>java.util.Properties</tt> passed to * {@code java.util.Properties} passed to
* <tt>Configuration.build()</tt> * {@code Configuration.build()}
* <p> * <p>
* <table> * <table>
* <tr><td><b>property</b></td><td><b>meaning</b></td></tr> * <tr><td><b>property</b></td><td><b>meaning</b></td></tr>
* <tr> * <tr>
* <td><tt>hibernate.dialect</tt></td> * <td>{@code hibernate.dialect}</td>
* <td>classname of <tt>org.hibernate.dialect.Dialect</tt> subclass</td> * <td>classname of {@code org.hibernate.dialect.Dialect} subclass</td>
* </tr> * </tr>
* <tr> * <tr>
* <td><tt>hibernate.connection.provider_class</tt></td> * <td>{@code hibernate.connection.provider_class}</td>
* <td>classname of <tt>ConnectionProvider</tt> * <td>classname of {@code ConnectionProvider}
* subclass (if not specified heuristics are used)</td> * subclass (if not specified heuristics are used)</td>
* </tr> * </tr>
* <tr><td><tt>hibernate.connection.username</tt></td><td>database username</td></tr> * <tr><td>{@code hibernate.connection.username}</td><td>database username</td></tr>
* <tr><td><tt>hibernate.connection.password</tt></td><td>database password</td></tr> * <tr><td>{@code hibernate.connection.password}</td><td>database password</td></tr>
* <tr> * <tr>
* <td><tt>hibernate.connection.url</tt></td> * <td>{@code hibernate.connection.url}</td>
* <td>JDBC URL (when using <tt>java.sql.DriverManager</tt>)</td> * <td>JDBC URL (when using {@code java.sql.DriverManager})</td>
* </tr> * </tr>
* <tr> * <tr>
* <td><tt>hibernate.connection.driver_class</tt></td> * <td>{@code hibernate.connection.driver_class}</td>
* <td>classname of JDBC driver</td> * <td>classname of JDBC driver</td>
* </tr> * </tr>
* <tr> * <tr>
* <td><tt>hibernate.connection.isolation</tt></td> * <td>{@code hibernate.connection.isolation}</td>
* <td>JDBC transaction isolation level (only when using * <td>JDBC transaction isolation level (only when using
* <tt>java.sql.DriverManager</tt>) * {@code java.sql.DriverManager})
* </td> * </td>
* </tr> * </tr>
* <td><tt>hibernate.connection.pool_size</tt></td> * <td>{@code hibernate.connection.pool_size}</td>
* <td>the maximum size of the connection pool (only when using * <td>the maximum size of the connection pool (only when using
* <tt>java.sql.DriverManager</tt>) * {@code java.sql.DriverManager})
* </td> * </td>
* </tr> * </tr>
* <tr> * <tr>
* <td><tt>hibernate.connection.datasource</tt></td> * <td>{@code hibernate.connection.datasource}</td>
* <td>datasource JNDI name (when using <tt>javax.sql.Datasource</tt>)</td> * <td>datasource JNDI name (when using {@code javax.sql.Datasource})</td>
* </tr> * </tr>
* <tr> * <tr>
* <td><tt>hibernate.jndi.url</tt></td><td>JNDI <tt>InitialContext</tt> URL</td> * <td>{@code hibernate.jndi.url}</td><td>JNDI {@code InitialContext} URL</td>
* </tr> * </tr>
* <tr> * <tr>
* <td><tt>hibernate.jndi.class</tt></td><td>JNDI <tt>InitialContext</tt> classname</td> * <td>{@code hibernate.jndi.class}</td><td>JNDI {@code InitialContext} classname</td>
* </tr> * </tr>
* <tr> * <tr>
* <td><tt>hibernate.max_fetch_depth</tt></td> * <td>{@code hibernate.max_fetch_depth}</td>
* <td>maximum depth of outer join fetching</td> * <td>maximum depth of outer join fetching</td>
* </tr> * </tr>
* <tr> * <tr>
* <td><tt>hibernate.jdbc.batch_size</tt></td> * <td>{@code hibernate.jdbc.batch_size}</td>
* <td>enable use of JDBC2 batch API for drivers which support it</td> * <td>enable use of JDBC2 batch API for drivers which support it</td>
* </tr> * </tr>
* <tr> * <tr>
* <td><tt>hibernate.jdbc.fetch_size</tt></td> * <td>{@code hibernate.jdbc.fetch_size}</td>
* <td>set the JDBC fetch size</td> * <td>set the JDBC fetch size</td>
* </tr> * </tr>
* <tr> * <tr>
* <td><tt>hibernate.jdbc.use_scrollable_resultset</tt></td> * <td>{@code hibernate.jdbc.use_scrollable_resultset}</td>
* <td>enable use of JDBC2 scrollable resultsets (you only need to specify * <td>enable use of JDBC2 scrollable resultsets (you only need to specify
* this property when using user supplied connections)</td> * this property when using user supplied connections)</td>
* </tr> * </tr>
* <tr> * <tr>
* <td><tt>hibernate.jdbc.use_getGeneratedKeys</tt></td> * <td>{@code hibernate.jdbc.use_getGeneratedKeys}</td>
* <td>enable use of JDBC3 PreparedStatement.getGeneratedKeys() to retrieve * <td>enable use of JDBC3 PreparedStatement.getGeneratedKeys() to retrieve
* natively generated keys after insert. Requires JDBC3+ driver and JRE1.4+</td> * natively generated keys after insert. Requires JDBC3+ driver and JRE1.4+</td>
* </tr> * </tr>
* <tr> * <tr>
* <td><tt>hibernate.hbm2ddl.auto</tt></td> * <td>{@code hibernate.hbm2ddl.auto}</td>
* <td>enable auto DDL export</td> * <td>enable auto DDL export</td>
* </tr> * </tr>
* <tr> * <tr>
* <td><tt>hibernate.default_schema</tt></td> * <td>{@code hibernate.default_schema}</td>
* <td>use given schema name for unqualified tables (always optional)</td> * <td>use given schema name for unqualified tables (always optional)</td>
* </tr> * </tr>
* <tr> * <tr>
* <td><tt>hibernate.default_catalog</tt></td> * <td>{@code hibernate.default_catalog}</td>
* <td>use given catalog name for unqualified tables (always optional)</td> * <td>use given catalog name for unqualified tables (always optional)</td>
* </tr> * </tr>
* <tr> * <tr>
* <td><tt>hibernate.session_factory_name</tt></td> * <td>{@code hibernate.session_factory_name}</td>
* <td>If set, the factory attempts to bind this name to itself in the * <td>If set, the factory attempts to bind this name to itself in the
* JNDI context. This name is also used to support cross JVM <tt> * JNDI context. This name is also used to support cross JVM {@code
* Session</tt> (de)serialization.</td> * Session} (de)serialization.</td>
* </tr> * </tr>
* <tr> * <tr>
* <td><tt>hibernate.transaction.jta.platform</tt></td> * <td>{@code hibernate.transaction.jta.platform}</td>
* <td>classname of <tt>org.hibernate.engine.transaction.jta.platform.spi.JtaPlatform</tt> * <td>classname of {@code org.hibernate.engine.transaction.jta.platform.spi.JtaPlatform}
* implementor</td> * implementor</td>
* </tr> * </tr>
* <tr> * <tr>
* <td><tt>hibernate.transaction.factory_class</tt></td> * <td>{@code hibernate.transaction.factory_class}</td>
* <td>the factory to use for instantiating <tt>Transaction</tt>s. * <td>the factory to use for instantiating {@code Transaction}s.
* (Defaults to <tt>JdbcTransactionFactory</tt>.)</td> * (Defaults to {@code JdbcTransactionFactory}.)</td>
* </tr> * </tr>
* <tr> * <tr>
* <td><tt>hibernate.query.substitutions</tt></td><td>query language token substitutions</td> * <td>{@code hibernate.query.substitutions}</td><td>query language token substitutions</td>
* </tr> * </tr>
* </table> * </table>
* *
@ -308,8 +308,8 @@ public final class Environment implements AvailableSettings {
} }
/** /**
* Return <tt>System</tt> properties, extended by any properties specified * Return {@code System} properties, extended by any properties specified
* in <tt>hibernate.properties</tt>. * in {@code hibernate.properties}.
* @return Properties * @return Properties
*/ */
public static Properties getProperties() { public static Properties getProperties() {

4
hibernate-core/src/main/java/org/hibernate/cfg/MetadataSourceType.java
View File

@ -15,11 +15,11 @@ import org.hibernate.HibernateException;
*/ */
public enum MetadataSourceType { public enum MetadataSourceType {
/** /**
* Indicates metadata coming from <tt>hbm.xml</tt> files * Indicates metadata coming from {@code hbm.xml} files
*/ */
HBM( "hbm" ), HBM( "hbm" ),
/** /**
* Indicates metadata coming from either annotations, <tt>orx.xml</tt> or a combination of the two. * Indicates metadata coming from either annotations, {@code orx.xml} or a combination of the two.
*/ */
CLASS( "class" ); CLASS( "class" );

26
hibernate-core/src/main/java/org/hibernate/classic/Lifecycle.java
View File

@ -12,32 +12,32 @@ import org.hibernate.Session;
import java.io.Serializable; import java.io.Serializable;
/** /**
* Provides callbacks from the <tt>Session</tt> to the persistent object. * Provides callbacks from the {@code Session} to the persistent object.
* Persistent classes <b>may</b> implement this interface but they are not * Persistent classes <b>may</b> implement this interface but they are not
* required to. * required to.
* <ul> * <ul>
* <li><b>onSave:</b> called just before the object is saved * <li><b>onSave:</b> called just before the object is saved
* <li><b>onUpdate:</b> called just before an object is updated, * <li><b>onUpdate:</b> called just before an object is updated,
* ie. when <tt>Session.update()</tt> is called * ie. when {@code Session.update()} is called
* <li><b>onDelete:</b> called just before an object is deleted * <li><b>onDelete:</b> called just before an object is deleted
* <b>onLoad:</b> called just after an object is loaded * <b>onLoad:</b> called just after an object is loaded
* </ul> * </ul>
* <p> * <p>
* <tt>onLoad()</tt> may be used to initialize transient properties of the * {@code onLoad()} may be used to initialize transient properties of the
* object from its persistent state. It may <b>not</b> be used to load * object from its persistent state. It may <b>not</b> be used to load
* dependent objects since the <tt>Session</tt> interface may not be * dependent objects since the {@code Session} interface may not be
* invoked from inside this method. * invoked from inside this method.
* <p> * <p>
* A further intended usage of <tt>onLoad()</tt>, <tt>onSave()</tt> and * A further intended usage of {@code onLoad()}, {@code onSave()} and
* <tt>onUpdate()</tt> is to store a reference to the <tt>Session</tt> * {@code onUpdate()} is to store a reference to the {@code Session}
* for later use. * for later use.
* <p> * <p>
* If <tt>onSave()</tt>, <tt>onUpdate()</tt> or <tt>onDelete()</tt> return * If {@code onSave()}, {@code onUpdate()} or {@code onDelete()} return
* <tt>VETO</tt>, the operation is silently vetoed. If a * {@code VETO}, the operation is silently vetoed. If a
* <tt>CallbackException</tt> is thrown, the operation is vetoed and the * {@code CallbackException} is thrown, the operation is vetoed and the
* exception is passed back to the application. * exception is passed back to the application.
* <p> * <p>
* Note that <tt>onSave()</tt> is called after an identifier is assigned * Note that {@code onSave()} is called after an identifier is assigned
* to the object, except when identity column key generation is used. * to the object, except when identity column key generation is used.
* *
* @see CallbackException * @see CallbackException
@ -66,7 +66,7 @@ public interface Lifecycle {
} }
/** /**
* Called when an entity is passed to <tt>Session.update()</tt>. * Called when an entity is passed to {@code Session.update()}.
* This method is <em>not</em> called every time the object's * This method is <em>not</em> called every time the object's
* state is persisted during a flush. * state is persisted during a flush.
* @param s the session * @param s the session
@ -89,7 +89,7 @@ public interface Lifecycle {
/** /**
* Called after an entity is loaded. <em>It is illegal to * Called after an entity is loaded. <em>It is illegal to
* access the <tt>Session</tt> from inside this method.</em> * access the {@code Session} from inside this method.</em>
* However, the object may keep a reference to the session * However, the object may keep a reference to the session
* for later use. * for later use.
* *
@ -104,7 +104,7 @@ public interface Lifecycle {
/** /**
* Called after an entity is loaded. <em>It is illegal to * Called after an entity is loaded. <em>It is illegal to
* access the <tt>Session</tt> from inside this method.</em> * access the {@code Session} from inside this method.</em>
* However, the object may keep a reference to the session * However, the object may keep a reference to the session
* for later use. * for later use.
* *

4
hibernate-core/src/main/java/org/hibernate/collection/internal/PersistentBag.java
View File

@ -26,8 +26,8 @@ import org.hibernate.type.Type;
/** /**
* An unordered, unkeyed collection that can contain the same element * An unordered, unkeyed collection that can contain the same element
* multiple times. The Java collections API, curiously, has no <tt>Bag</tt>. * multiple times. The Java collections API, curiously, has no {@code Bag}.
* Most developers seem to use <tt>List</tt>s to represent bag semantics, * Most developers seem to use {@code List}s to represent bag semantics,
* so Hibernate follows this practice. * so Hibernate follows this practice.
* *
* @author Gavin King * @author Gavin King

8
hibernate-core/src/main/java/org/hibernate/collection/internal/PersistentIdentifierBag.java
View File

@ -24,14 +24,14 @@ import org.hibernate.persister.collection.CollectionPersister;
import org.hibernate.type.Type; import org.hibernate.type.Type;
/** /**
* An <tt>IdentifierBag</tt> implements "bag" semantics more efficiently than * An {@code IdentifierBag} implements "bag" semantics more efficiently than
* a regular <tt>Bag</tt> by adding a synthetic identifier column to the * a regular {@code Bag} by adding a synthetic identifier column to the
* table. This identifier is unique for all rows in the table, allowing very * table. This identifier is unique for all rows in the table, allowing very
* efficient updates and deletes. The value of the identifier is never exposed * efficient updates and deletes. The value of the identifier is never exposed
* to the application. * to the application.
* <p> * <p>
* <tt>IdentifierBag</tt>s may not be used for a many-to-one association. * {@code IdentifierBag}s may not be used for a many-to-one association.
* Furthermore, there is no reason to use <tt>inverse="true"</tt>. * Furthermore, there is no reason to use {@code inverse="true"}.
* *
* @author Gavin King * @author Gavin King
*/ */

4
hibernate-core/src/main/java/org/hibernate/collection/internal/PersistentList.java
View File

@ -21,8 +21,8 @@ import org.hibernate.persister.collection.CollectionPersister;
import org.hibernate.type.Type; import org.hibernate.type.Type;
/** /**
* A persistent wrapper for a <tt>java.util.List</tt>. Underlying * A persistent wrapper for a {@code java.util.List}. Underlying
* collection is an <tt>ArrayList</tt>. * collection is an {@code ArrayList}.
* *
* @see ArrayList * @see ArrayList
* @author Gavin King * @author Gavin King

4
hibernate-core/src/main/java/org/hibernate/collection/internal/PersistentMap.java
View File

@ -25,8 +25,8 @@ import org.hibernate.type.Type;
/** /**
* A persistent wrapper for a <tt>java.util.Map</tt>. Underlying collection * A persistent wrapper for a {@code java.util.Map}. Underlying collection
* is a <tt>HashMap</tt>. * is a {@code HashMap}.
* *
* @see HashMap * @see HashMap
* @author Gavin King * @author Gavin King

4
hibernate-core/src/main/java/org/hibernate/collection/internal/PersistentSet.java
View File

@ -24,8 +24,8 @@ import org.hibernate.type.Type;
/** /**
* A persistent wrapper for a <tt>java.util.Set</tt>. The underlying * A persistent wrapper for a {@code java.util.Set}. The underlying
* collection is a <tt>HashSet</tt>. * collection is a {@code HashSet}.
* *
* @see java.util.HashSet * @see java.util.HashSet
* @author Gavin King * @author Gavin King

4
hibernate-core/src/main/java/org/hibernate/collection/internal/PersistentSortedMap.java
View File

@ -20,8 +20,8 @@ import org.hibernate.engine.spi.SharedSessionContractImplementor;
import org.hibernate.persister.collection.BasicCollectionPersister; import org.hibernate.persister.collection.BasicCollectionPersister;
/** /**
* A persistent wrapper for a <tt>java.util.SortedMap</tt>. Underlying * A persistent wrapper for a {@code java.util.SortedMap}. Underlying
* collection is a <tt>TreeMap</tt>. * collection is a {@code TreeMap}.
* *
* @see TreeMap * @see TreeMap
* @author <a href="mailto:doug.currie@alum.mit.edu">e</a> * @author <a href="mailto:doug.currie@alum.mit.edu">e</a>

4
hibernate-core/src/main/java/org/hibernate/collection/internal/PersistentSortedSet.java
View File

@ -17,8 +17,8 @@ import org.hibernate.engine.spi.SharedSessionContractImplementor;
import org.hibernate.persister.collection.BasicCollectionPersister; import org.hibernate.persister.collection.BasicCollectionPersister;
/** /**
* A persistent wrapper for a <tt>java.util.SortedSet</tt>. Underlying * A persistent wrapper for a {@code java.util.SortedSet}. Underlying
* collection is a <tt>TreeSet</tt>. * collection is a {@code TreeSet}.
* *
* @see java.util.TreeSet * @see java.util.TreeSet
* @author <a href="mailto:doug.currie@alum.mit.edu">e</a> * @author <a href="mailto:doug.currie@alum.mit.edu">e</a>

2
hibernate-core/src/main/java/org/hibernate/context/internal/ThreadLocalSessionContext.java
View File

@ -42,7 +42,7 @@ import org.jboss.logging.Logger;
* a session upon first request and then clean it up after the {@link Transaction} * a session upon first request and then clean it up after the {@link Transaction}
* associated with that session is committed/rolled-back. In order for ensuring that happens, the * associated with that session is committed/rolled-back. In order for ensuring that happens, the
* sessions generated here are unusable until after {@link Session#beginTransaction()} has been * sessions generated here are unusable until after {@link Session#beginTransaction()} has been
* called. If <tt>close()</tt> is called on a session managed by this class, it will be automatically * called. If {@code close()} is called on a session managed by this class, it will be automatically
* unbound. * unbound.
* *
* Additionally, the static {@link #bind} and {@link #unbind} methods are provided to allow application * Additionally, the static {@link #bind} and {@link #unbind} methods are provided to allow application

68
hibernate-core/src/main/java/org/hibernate/dialect/Dialect.java
View File

@ -1439,9 +1439,9 @@ public abstract class Dialect implements ConversionContext {
/** /**
* Get the name of the database type associated with the given * Get the name of the database type associated with the given
* <tt>java.sql.Types</tt> typecode. * {@code java.sql.Types} typecode.
* *
* @param code <tt>java.sql.Types</tt> typecode * @param code {@code java.sql.Types} typecode
* @param size the length, precision, scale of the column * @param size the length, precision, scale of the column
* *
* @return the database type name * @return the database type name
@ -1475,7 +1475,7 @@ public abstract class Dialect implements ConversionContext {
/** /**
* Get the name of the database type associated with the given * Get the name of the database type associated with the given
* <tt>SqlTypeDescriptor</tt>. * {@code SqlTypeDescriptor}.
* *
* @param jdbcType the SQL type * @param jdbcType the SQL type
* @param size the length, precision, scale of the column * @param size the length, precision, scale of the column
@ -1526,7 +1526,7 @@ public abstract class Dialect implements ConversionContext {
/** /**
* Subclasses register a type name for the given type code and maximum * Subclasses register a type name for the given type code and maximum
* column length. <tt>$l</tt> in the type name with be replaced by the * column length. {@code $l} in the type name with be replaced by the
* column length (if appropriate). * column length (if appropriate).
* *
* @param code The {@link Types} typecode * @param code The {@link Types} typecode
@ -1538,7 +1538,7 @@ public abstract class Dialect implements ConversionContext {
} }
/** /**
* Subclasses register a type name for the given type code. <tt>$l</tt> in * Subclasses register a type name for the given type code. {@code $l} in
* the type name with be replaced by the column length (if appropriate). * the type name with be replaced by the column length (if appropriate).
* *
* @param code The {@link Types} typecode * @param code The {@link Types} typecode
@ -1876,15 +1876,15 @@ public abstract class Dialect implements ConversionContext {
/** /**
* If this dialect supports specifying lock timeouts, are those timeouts * If this dialect supports specifying lock timeouts, are those timeouts
* rendered into the <tt>SQL</tt> string as parameters. The implication * rendered into the {@code SQL} string as parameters. The implication
* is that Hibernate will need to bind the timeout value as a parameter * is that Hibernate will need to bind the timeout value as a parameter
* in the {@link PreparedStatement}. If true, the param position * in the {@link PreparedStatement}. If true, the param position
* is always handled as the last parameter; if the dialect specifies the * is always handled as the last parameter; if the dialect specifies the
* lock timeout elsewhere in the <tt>SQL</tt> statement then the timeout * lock timeout elsewhere in the {@code SQL} statement then the timeout
* value should be directly rendered into the statement and this method * value should be directly rendered into the statement and this method
* should return false. * should return false.
* *
* @return True if the lock timeout is rendered into the <tt>SQL</tt> * @return True if the lock timeout is rendered into the {@code SQL}
* string as a parameter; false otherwise. * string as a parameter; false otherwise.
*/ */
public boolean isLockTimeoutParameterized() { public boolean isLockTimeoutParameterized() {
@ -1961,7 +1961,7 @@ public abstract class Dialect implements ConversionContext {
* Get the string to append to SELECT statements to acquire locks * Get the string to append to SELECT statements to acquire locks
* for this dialect. * for this dialect.
* *
* @return The appropriate <tt>FOR UPDATE</tt> clause string. * @return The appropriate {@code FOR UPDATE} clause string.
*/ */
public String getForUpdateString() { public String getForUpdateString() {
return " for update"; return " for update";
@ -1973,7 +1973,7 @@ public abstract class Dialect implements ConversionContext {
* the same as getForUpdateString. * the same as getForUpdateString.
* *
* @param timeout in milliseconds, -1 for indefinite wait and 0 for no wait. * @param timeout in milliseconds, -1 for indefinite wait and 0 for no wait.
* @return The appropriate <tt>LOCK</tt> clause string. * @return The appropriate {@code LOCK} clause string.
*/ */
public String getWriteLockString(int timeout) { public String getWriteLockString(int timeout) {
return getForUpdateString(); return getForUpdateString();
@ -1987,7 +1987,7 @@ public abstract class Dialect implements ConversionContext {
* *
* @param aliases The columns to be read locked. * @param aliases The columns to be read locked.
* @param timeout in milliseconds, -1 for indefinite wait and 0 for no wait. * @param timeout in milliseconds, -1 for indefinite wait and 0 for no wait.
* @return The appropriate <tt>LOCK</tt> clause string. * @return The appropriate {@code LOCK} clause string.
*/ */
public String getWriteLockString(String aliases, int timeout) { public String getWriteLockString(String aliases, int timeout) {
// by default we simply return the getWriteLockString(timeout) result since // by default we simply return the getWriteLockString(timeout) result since
@ -2001,7 +2001,7 @@ public abstract class Dialect implements ConversionContext {
* the same as getForUpdateString. * the same as getForUpdateString.
* *
* @param timeout in milliseconds, -1 for indefinite wait and 0 for no wait. * @param timeout in milliseconds, -1 for indefinite wait and 0 for no wait.
* @return The appropriate <tt>LOCK</tt> clause string. * @return The appropriate {@code LOCK} clause string.
*/ */
public String getReadLockString(int timeout) { public String getReadLockString(int timeout) {
return getForUpdateString(); return getForUpdateString();
@ -2015,7 +2015,7 @@ public abstract class Dialect implements ConversionContext {
* *
* @param aliases The columns to be read locked. * @param aliases The columns to be read locked.
* @param timeout in milliseconds, -1 for indefinite wait and 0 for no wait. * @param timeout in milliseconds, -1 for indefinite wait and 0 for no wait.
* @return The appropriate <tt>LOCK</tt> clause string. * @return The appropriate {@code LOCK} clause string.
*/ */
public String getReadLockString(String aliases, int timeout) { public String getReadLockString(String aliases, int timeout) {
// by default we simply return the getReadLockString(timeout) result since // by default we simply return the getReadLockString(timeout) result since
@ -2039,21 +2039,21 @@ public abstract class Dialect implements ConversionContext {
} }
/** /**
* Does this dialect support <tt>FOR UPDATE</tt> in conjunction with * Does this dialect support {@code FOR UPDATE} in conjunction with
* outer joined rows? * outer joined rows?
* *
* @return True if outer joined rows can be locked via <tt>FOR UPDATE</tt>. * @return True if outer joined rows can be locked via {@code FOR UPDATE}.
*/ */
public boolean supportsOuterJoinForUpdate() { public boolean supportsOuterJoinForUpdate() {
return true; return true;
} }
/** /**
* Get the <tt>FOR UPDATE OF column_list</tt> fragment appropriate for this * Get the {@code FOR UPDATE OF column_list} fragment appropriate for this
* dialect given the aliases of the columns to be write locked. * dialect given the aliases of the columns to be write locked.
* *
* @param aliases The columns to be write locked. * @param aliases The columns to be write locked.
* @return The appropriate <tt>FOR UPDATE OF column_list</tt> clause string. * @return The appropriate {@code FOR UPDATE OF column_list} clause string.
*/ */
public String getForUpdateString(String aliases) { public String getForUpdateString(String aliases) {
// by default we simply return the getForUpdateString() result since // by default we simply return the getForUpdateString() result since
@ -2062,12 +2062,12 @@ public abstract class Dialect implements ConversionContext {
} }
/** /**
* Get the <tt>FOR UPDATE OF column_list</tt> fragment appropriate for this * Get the {@code FOR UPDATE OF column_list} fragment appropriate for this
* dialect given the aliases of the columns to be write locked. * dialect given the aliases of the columns to be write locked.
* *
* @param aliases The columns to be write locked. * @param aliases The columns to be write locked.
* @param lockOptions the lock options to apply * @param lockOptions the lock options to apply
* @return The appropriate <tt>FOR UPDATE OF column_list</tt> clause string. * @return The appropriate {@code FOR UPDATE OF column_list} clause string.
*/ */
public String getForUpdateString(String aliases, LockOptions lockOptions) { public String getForUpdateString(String aliases, LockOptions lockOptions) {
LockMode lockMode = lockOptions.getLockMode(); LockMode lockMode = lockOptions.getLockMode();
@ -2085,9 +2085,9 @@ public abstract class Dialect implements ConversionContext {
} }
/** /**
* Retrieves the <tt>FOR UPDATE NOWAIT</tt> syntax specific to this dialect. * Retrieves the {@code FOR UPDATE NOWAIT} syntax specific to this dialect.
* *
* @return The appropriate <tt>FOR UPDATE NOWAIT</tt> clause string. * @return The appropriate {@code FOR UPDATE NOWAIT} clause string.
*/ */
public String getForUpdateNowaitString() { public String getForUpdateNowaitString() {
// by default we report no support for NOWAIT lock semantics // by default we report no support for NOWAIT lock semantics
@ -2095,9 +2095,9 @@ public abstract class Dialect implements ConversionContext {
} }
/** /**
* Retrieves the <tt>FOR UPDATE SKIP LOCKED</tt> syntax specific to this dialect. * Retrieves the {@code FOR UPDATE SKIP LOCKED} syntax specific to this dialect.
* *
* @return The appropriate <tt>FOR UPDATE SKIP LOCKED</tt> clause string. * @return The appropriate {@code FOR UPDATE SKIP LOCKED} clause string.
*/ */
public String getForUpdateSkipLockedString() { public String getForUpdateSkipLockedString() {
// by default we report no support for SKIP_LOCKED lock semantics // by default we report no support for SKIP_LOCKED lock semantics
@ -2105,29 +2105,29 @@ public abstract class Dialect implements ConversionContext {
} }
/** /**
* Get the <tt>FOR UPDATE OF column_list NOWAIT</tt> fragment appropriate * Get the {@code FOR UPDATE OF column_list NOWAIT} fragment appropriate
* for this dialect given the aliases of the columns to be write locked. * for this dialect given the aliases of the columns to be write locked.
* *
* @param aliases The columns to be write locked. * @param aliases The columns to be write locked.
* @return The appropriate <tt>FOR UPDATE OF colunm_list NOWAIT</tt> clause string. * @return The appropriate {@code FOR UPDATE OF colunm_list NOWAIT} clause string.
*/ */
public String getForUpdateNowaitString(String aliases) { public String getForUpdateNowaitString(String aliases) {
return getForUpdateString( aliases ); return getForUpdateString( aliases );
} }
/** /**
* Get the <tt>FOR UPDATE OF column_list SKIP LOCKED</tt> fragment appropriate * Get the {@code FOR UPDATE OF column_list SKIP LOCKED} fragment appropriate
* for this dialect given the aliases of the columns to be write locked. * for this dialect given the aliases of the columns to be write locked.
* *
* @param aliases The columns to be write locked. * @param aliases The columns to be write locked.
* @return The appropriate <tt>FOR UPDATE colunm_list SKIP LOCKED</tt> clause string. * @return The appropriate {@code FOR UPDATE colunm_list SKIP LOCKED} clause string.
*/ */
public String getForUpdateSkipLockedString(String aliases) { public String getForUpdateSkipLockedString(String aliases) {
return getForUpdateString( aliases ); return getForUpdateString( aliases );
} }
/** /**
* Some dialects support an alternative means to <tt>SELECT FOR UPDATE</tt>, * Some dialects support an alternative means to {@code SELECT FOR UPDATE},
* whereby a "lock hint" is appended to the table name in the from clause. * whereby a "lock hint" is appended to the table name in the from clause.
* <p/> * <p/>
* contributed by <a href="http://sourceforge.net/users/heschulz">Helge Schulz</a> * contributed by <a href="http://sourceforge.net/users/heschulz">Helge Schulz</a>
@ -2144,9 +2144,9 @@ public abstract class Dialect implements ConversionContext {
* Modifies the given SQL by applying the appropriate updates for the specified * Modifies the given SQL by applying the appropriate updates for the specified
* lock modes and key columns. * lock modes and key columns.
* <p/> * <p/>
* The behavior here is that of an ANSI SQL <tt>SELECT FOR UPDATE</tt>. This * The behavior here is that of an ANSI SQL {@code SELECT FOR UPDATE}. This
* method is really intended to allow dialects which do not support * method is really intended to allow dialects which do not support
* <tt>SELECT FOR UPDATE</tt> to achieve this in their own fashion. * {@code SELECT FOR UPDATE} to achieve this in their own fashion.
* *
* @param sql the SQL string to modify * @param sql the SQL string to modify
* @param aliasedLockOptions lock options indexed by aliased table names. * @param aliasedLockOptions lock options indexed by aliased table names.
@ -2809,7 +2809,7 @@ public abstract class Dialect implements ConversionContext {
} }
/** /**
* Does this dialect support the <tt>ALTER TABLE</tt> syntax? * Does this dialect support the {@code ALTER TABLE} syntax?
* *
* @return True if we support altering of tables; false otherwise. * @return True if we support altering of tables; false otherwise.
*/ */
@ -3107,8 +3107,8 @@ public abstract class Dialect implements ConversionContext {
} }
/** /**
* Does this dialect support parameters within the <tt>SELECT</tt> clause of * Does this dialect support parameters within the {@code SELECT} clause of
* <tt>INSERT ... SELECT ...</tt> statements? * {@code INSERT ... SELECT ...} statements?
* *
* @return True if this is supported; false otherwise. * @return True if this is supported; false otherwise.
* @since 3.2 * @since 3.2
@ -3148,7 +3148,7 @@ public abstract class Dialect implements ConversionContext {
} }
/** /**
* Does this dialect require that integer divisions be wrapped in <tt>cast()</tt> * Does this dialect require that integer divisions be wrapped in {@code cast()}
* calls to tell the db parser the expected type. * calls to tell the db parser the expected type.
* *
* @return True if integer divisions must be cast()ed to float * @return True if integer divisions must be cast()ed to float

2
hibernate-core/src/main/java/org/hibernate/dialect/identity/SQLServerIdentityColumnSupport.java
View File

@ -11,7 +11,7 @@ package org.hibernate.dialect.identity;
*/ */
public class SQLServerIdentityColumnSupport extends AbstractTransactSQLIdentityColumnSupport { public class SQLServerIdentityColumnSupport extends AbstractTransactSQLIdentityColumnSupport {
/** /**
* Use <tt>insert table(...) values(...) select SCOPE_IDENTITY()</tt> * Use {@code insert table(...) values(...) select SCOPE_IDENTITY()}
* <p/> * <p/>
* {@inheritDoc} * {@inheritDoc}
*/ */

2
hibernate-core/src/main/java/org/hibernate/dialect/lock/AbstractSelectLockingStrategy.java
View File

@ -12,7 +12,7 @@ import org.hibernate.persister.entity.Lockable;
/** /**
* Base {@link LockingStrategy} implementation to support implementations * Base {@link LockingStrategy} implementation to support implementations
* based on issuing <tt>SQL</tt> <tt>SELECT</tt> statements * based on issuing {@code SQL} {@code SELECT} statements
* *
* @author Steve Ebersole * @author Steve Ebersole
*/ */

2
hibernate-core/src/main/java/org/hibernate/dialect/pagination/AbstractLimitHandler.java
View File

@ -76,7 +76,7 @@ public abstract class AbstractLimitHandler implements LimitHandler {
/** /**
* Does the offset/limit clause come at the start of the * Does the offset/limit clause come at the start of the
* <tt>SELECT</tt> statement, or at the end of the query? * {@code SELECT} statement, or at the end of the query?
* *
* @return true if limit parameters come before other parameters * @return true if limit parameters come before other parameters
*/ */

2
hibernate-core/src/main/java/org/hibernate/engine/config/spi/ConfigurationService.java
View File

@ -66,7 +66,7 @@ public interface ConfigurationService extends Service {
public <T> T getSetting(String name, Class<T> expected, T defaultValue); public <T> T getSetting(String name, Class<T> expected, T defaultValue);
/** /**
* Cast <tt>candidate</tt> to the instance of <tt>expected</tt> type. * Cast {@code candidate} to the instance of {@code expected} type.
* *
* @param expected The type of instance expected to return. * @param expected The type of instance expected to return.
* @param candidate The candidate object to be casted. * @param candidate The candidate object to be casted.

4
hibernate-core/src/main/java/org/hibernate/engine/internal/ForeignKeys.java
View File

@ -235,7 +235,7 @@ public final class ForeignKeys {
/** /**
* Is this instance persistent or detached? * Is this instance persistent or detached?
* <p/> * <p/>
* If <tt>assumed</tt> is non-null, don't hit the database to make the determination, instead assume that * If {@code assumed} is non-null, don't hit the database to make the determination, instead assume that
* value; the client code must be prepared to "recover" in the case that this assumed result is incorrect. * value; the client code must be prepared to "recover" in the case that this assumed result is incorrect.
* *
* @param entityName The name of the entity * @param entityName The name of the entity
@ -263,7 +263,7 @@ public final class ForeignKeys {
/** /**
* Is this instance, which we know is not persistent, actually transient? * Is this instance, which we know is not persistent, actually transient?
* <p/> * <p/>
* If <tt>assumed</tt> is non-null, don't hit the database to make the determination, instead assume that * If {@code assumed} is non-null, don't hit the database to make the determination, instead assume that
* value; the client code must be prepared to "recover" in the case that this assumed result is incorrect. * value; the client code must be prepared to "recover" in the case that this assumed result is incorrect.
* *
* @param entityName The name of the entity * @param entityName The name of the entity

2
hibernate-core/src/main/java/org/hibernate/engine/jdbc/spi/SqlExceptionHelper.java
View File

@ -71,7 +71,7 @@ public class SqlExceptionHelper {
/** /**
* Inject the exception converter to use. * Inject the exception converter to use.
* <p/> * <p/>
* NOTE : <tt>null</tt> is allowed and signifies to use the default. * NOTE : {@code null} is allowed and signifies to use the default.
* *
* @param sqlExceptionConverter The converter to use. * @param sqlExceptionConverter The converter to use.
*/ */

2
hibernate-core/src/main/java/org/hibernate/engine/profile/FetchProfile.java
View File

@ -114,7 +114,7 @@ public class FetchProfile {
} }
/** /**
* Getter for property 'fetches'. Map of {@link Fetch} instances, keyed by association <tt>role</tt> * Getter for property 'fetches'. Map of {@link Fetch} instances, keyed by association {@code role}
* *
* @return Value for property 'fetches'. * @return Value for property 'fetches'.
*/ */

4
hibernate-core/src/main/java/org/hibernate/engine/spi/IdentifierValue.java
View File

@ -15,7 +15,7 @@ import org.jboss.logging.Logger;
/** /**
* A strategy for determining if an identifier value is an identifier of * A strategy for determining if an identifier value is an identifier of
* a new transient instance or a previously persistent transient instance. * a new transient instance or a previously persistent transient instance.
* The strategy is determined by the <tt>unsaved-value</tt> attribute in * The strategy is determined by the {@code unsaved-value} attribute in
* the mapping file. * the mapping file.
* *
* @author Gavin King * @author Gavin King
@ -116,7 +116,7 @@ public class IdentifierValue implements UnsavedValueStrategy {
/** /**
* Assume the transient instance is newly instantiated if * Assume the transient instance is newly instantiated if
* its identifier is null or equal to <tt>value</tt> * its identifier is null or equal to {@code value}
*/ */
public IdentifierValue(Object value) { public IdentifierValue(Object value) {
this.value = value; this.value = value;

6
hibernate-core/src/main/java/org/hibernate/engine/spi/Mapping.java
View File

@ -10,9 +10,9 @@ import org.hibernate.MappingException;
import org.hibernate.type.Type; import org.hibernate.type.Type;
/** /**
* Defines operations common to "compiled" mappings (ie. <tt>SessionFactory</tt>) * Defines operations common to "compiled" mappings (ie. {@code SessionFactory})
* and "uncompiled" mappings (ie. <tt>Configuration</tt>) that are used by * and "uncompiled" mappings (ie. {@code Configuration}) that are used by
* implementors of <tt>Type</tt>. * implementors of {@code Type}.
* *
* @see Type * @see Type
* @see org.hibernate.internal.SessionFactoryImpl * @see org.hibernate.internal.SessionFactoryImpl

16
hibernate-core/src/main/java/org/hibernate/engine/spi/PersistenceContext.java
View File

@ -331,14 +331,14 @@ public interface PersistenceContext {
Object narrowProxy(Object proxy, EntityPersister persister, EntityKey key, Object object); Object narrowProxy(Object proxy, EntityPersister persister, EntityKey key, Object object);
/** /**
* Return the existing proxy associated with the given <tt>EntityKey</tt>, or the * Return the existing proxy associated with the given {@code EntityKey}, or the
* third argument (the entity associated with the key) if no proxy exists. Init * third argument (the entity associated with the key) if no proxy exists. Init
* the proxy to the target implementation, if necessary. * the proxy to the target implementation, if necessary.
*/ */
Object proxyFor(EntityPersister persister, EntityKey key, Object impl); Object proxyFor(EntityPersister persister, EntityKey key, Object impl);
/** /**
* Return the existing proxy associated with the given <tt>EntityKey</tt>, or the * Return the existing proxy associated with the given {@code EntityKey}, or the
* argument (the entity associated with the key) if no proxy exists. * argument (the entity associated with the key) if no proxy exists.
* (slower than the form above) * (slower than the form above)
*/ */
@ -406,7 +406,7 @@ public interface PersistenceContext {
Object id); Object id);
/** /**
* Get the collection instance associated with the <tt>CollectionKey</tt> * Get the collection instance associated with the {@code CollectionKey}
*/ */
PersistentCollection getCollection(CollectionKey collectionKey); PersistentCollection getCollection(CollectionKey collectionKey);
@ -424,12 +424,12 @@ public interface PersistenceContext {
void initializeNonLazyCollections() throws HibernateException; void initializeNonLazyCollections() throws HibernateException;
/** /**
* Get the <tt>PersistentCollection</tt> object for an array * Get the {@code PersistentCollection} object for an array
*/ */
PersistentCollection getCollectionHolder(Object array); PersistentCollection getCollectionHolder(Object array);
/** /**
* Register a <tt>PersistentCollection</tt> object for an array. * Register a {@code PersistentCollection} object for an array.
* Associates a holder with an array - MUST be called after loading * Associates a holder with an array - MUST be called after loading
* array, since the array instance is not created until endLoad(). * array, since the array instance is not created until endLoad().
*/ */
@ -583,8 +583,8 @@ public interface PersistenceContext {
String toString(); String toString();
/** /**
* Search <tt>this</tt> persistence context for an associated entity instance which is considered the "owner" of * Search {@code this} persistence context for an associated entity instance which is considered the "owner" of
* the given <tt>childEntity</tt>, and return that owner's id value. This is performed in the scenario of a * the given {@code childEntity}, and return that owner's id value. This is performed in the scenario of a
* uni-directional, non-inverse one-to-many collection (which means that the collection elements do not maintain * uni-directional, non-inverse one-to-many collection (which means that the collection elements do not maintain
* a direct reference to the owner). * a direct reference to the owner).
* <p/> * <p/>
@ -592,7 +592,7 @@ public interface PersistenceContext {
* context and for those of the correct entity (sub) type to extract its collection role property value and see * context and for those of the correct entity (sub) type to extract its collection role property value and see
* if the child is contained within that collection. If so, we have found the owner; if not, we go on. * if the child is contained within that collection. If so, we have found the owner; if not, we go on.
* <p/> * <p/>
* Also need to account for <tt>mergeMap</tt> which acts as a local copy cache managed for the duration of a merge * Also need to account for {@code mergeMap} which acts as a local copy cache managed for the duration of a merge
* operation. It represents a map of the detached entity instances pointing to the corresponding managed instance. * operation. It represents a map of the detached entity instances pointing to the corresponding managed instance.
* *
* @param entityName The entity name for the entity type which would own the child * @param entityName The entity name for the entity type which would own the child

2
hibernate-core/src/main/java/org/hibernate/engine/spi/SessionBuilderImplementor.java
View File

@ -9,7 +9,7 @@ package org.hibernate.engine.spi;
import org.hibernate.SessionBuilder; import org.hibernate.SessionBuilder;
/** /**
* Defines the internal contract between the <tt>SessionBuilder</tt> and other parts of * Defines the internal contract between the {@code SessionBuilder} and other parts of
* Hibernate.. * Hibernate..
* *
* @see SessionBuilder * @see SessionBuilder

4
hibernate-core/src/main/java/org/hibernate/engine/spi/SessionFactoryImplementor.java
View File

@ -50,8 +50,8 @@ import org.hibernate.type.descriptor.WrapperOptions;
import org.hibernate.type.spi.TypeConfiguration; import org.hibernate.type.spi.TypeConfiguration;
/** /**
* Defines the internal contract between the <tt>SessionFactory</tt> and other parts of * Defines the internal contract between the {@code SessionFactory} and other parts of
* Hibernate such as implementors of <tt>Type</tt>. * Hibernate such as implementors of {@code Type}.
* *
* @see SessionFactory * @see SessionFactory
* @see org.hibernate.internal.SessionFactoryImpl * @see org.hibernate.internal.SessionFactoryImpl

16
hibernate-core/src/main/java/org/hibernate/engine/spi/SharedSessionContractImplementor.java
View File

@ -76,7 +76,7 @@ public interface SharedSessionContractImplementor
// 5) #disableTransactionAutoJoin // 5) #disableTransactionAutoJoin
/** /**
* Get the creating <tt>SessionFactoryImplementor</tt> * Get the creating {@code SessionFactoryImplementor}
*/ */
SessionFactoryImplementor getFactory(); SessionFactoryImplementor getFactory();
@ -207,7 +207,7 @@ public interface SharedSessionContractImplementor
CacheTransactionSynchronization getCacheTransactionSynchronization(); CacheTransactionSynchronization getCacheTransactionSynchronization();
/** /**
* Does this <tt>Session</tt> have an active Hibernate transaction * Does this {@code Session} have an active Hibernate transaction
* or is there a JTA transaction in progress? * or is there a JTA transaction in progress?
*/ */
boolean isTransactionInProgress(); boolean isTransactionInProgress();
@ -265,14 +265,14 @@ public interface SharedSessionContractImplementor
/** /**
* Load an instance without checking if it was deleted. * Load an instance without checking if it was deleted.
* <p/> * <p/>
* When <tt>nullable</tt> is disabled this method may create a new proxy or * When {@code nullable} is disabled this method may create a new proxy or
* return an existing proxy; if it does not exist, throw an exception. * return an existing proxy; if it does not exist, throw an exception.
* <p/> * <p/>
* When <tt>nullable</tt> is enabled, the method does not create new proxies * When {@code nullable} is enabled, the method does not create new proxies
* (but might return an existing proxy); if it does not exist, return * (but might return an existing proxy); if it does not exist, return
* <tt>null</tt>. * {@code null}.
* <p/> * <p/>
* When <tt>eager</tt> is enabled, the object is eagerly fetched * When {@code eager} is enabled, the object is eagerly fetched
*/ */
Object internalLoad(String entityName, Object id, boolean eager, boolean nullable) Object internalLoad(String entityName, Object id, boolean eager, boolean nullable)
throws HibernateException; throws HibernateException;
@ -285,7 +285,7 @@ public interface SharedSessionContractImplementor
/** /**
* Get the <tt>EntityPersister</tt> for any instance * Get the {@code EntityPersister} for any instance
* *
* @param entityName optional entity name * @param entityName optional entity name
* @param object the entity instance * @param object the entity instance
@ -293,7 +293,7 @@ public interface SharedSessionContractImplementor
EntityPersister getEntityPersister(String entityName, Object object) throws HibernateException; EntityPersister getEntityPersister(String entityName, Object object) throws HibernateException;
/** /**
* Get the entity instance associated with the given <tt>Key</tt>, * Get the entity instance associated with the given {@code Key},
* calling the Interceptor if necessary * calling the Interceptor if necessary
*/ */
Object getEntityUsingInterceptor(EntityKey key) throws HibernateException; Object getEntityUsingInterceptor(EntityKey key) throws HibernateException;

4
hibernate-core/src/main/java/org/hibernate/engine/spi/VersionValue.java
View File

@ -15,7 +15,7 @@ import org.jboss.logging.Logger;
/** /**
* A strategy for determining if a version value is a version of * A strategy for determining if a version value is a version of
* a new transient instance or a previously persistent transient instance. * a new transient instance or a previously persistent transient instance.
* The strategy is determined by the <tt>unsaved-value</tt> attribute in * The strategy is determined by the {@code unsaved-value} attribute in
* the mapping file. * the mapping file.
* *
* @author Gavin King * @author Gavin King
@ -105,7 +105,7 @@ public class VersionValue implements UnsavedValueStrategy {
/** /**
* Assume the transient instance is newly instantiated if * Assume the transient instance is newly instantiated if
* its version is null or equal to <tt>value</tt> * its version is null or equal to {@code value}
* *
* @param value value to compare to * @param value value to compare to
*/ */

2
hibernate-core/src/main/java/org/hibernate/event/spi/PreDeleteEvent.java
View File

@ -10,7 +10,7 @@ import org.hibernate.persister.entity.EntityPersister;
/** /**
* Represents a <tt>pre-delete</tt> event, which occurs just prior to * Represents a {@code pre-delete} event, which occurs just prior to
* performing the deletion of an entity from the database. * performing the deletion of an entity from the database.
* *
* @author Gavin King * @author Gavin King

2
hibernate-core/src/main/java/org/hibernate/event/spi/PreInsertEvent.java
View File

@ -9,7 +9,7 @@ package org.hibernate.event.spi;
import org.hibernate.persister.entity.EntityPersister; import org.hibernate.persister.entity.EntityPersister;
/** /**
* Represents a <tt>pre-insert</tt> event, which occurs just prior to * Represents a {@code pre-insert} event, which occurs just prior to
* performing the insert of an entity into the database. * performing the insert of an entity into the database.
* *
* @author Gavin King * @author Gavin King

2
hibernate-core/src/main/java/org/hibernate/event/spi/PreUpdateEvent.java
View File

@ -9,7 +9,7 @@ package org.hibernate.event.spi;
import org.hibernate.persister.entity.EntityPersister; import org.hibernate.persister.entity.EntityPersister;
/** /**
* Represents a <tt>pre-update</tt> event, which occurs just prior to * Represents a {@code pre-update} event, which occurs just prior to
* performing the update of an entity in the database. * performing the update of an entity in the database.
* *
* @author Gavin King * @author Gavin King

2
hibernate-core/src/main/java/org/hibernate/id/Assigned.java
View File

@ -18,7 +18,7 @@ import org.hibernate.type.Type;
/** /**
* <b>assigned</b> * <b>assigned</b>
* <p> * <p>
* An <tt>IdentifierGenerator</tt> that returns the current identifier assigned * An {@code IdentifierGenerator} that returns the current identifier assigned
* to an instance. * to an instance.
* *
* @author Gavin King * @author Gavin King

2
hibernate-core/src/main/java/org/hibernate/id/Configurable.java
View File

@ -26,7 +26,7 @@ import org.hibernate.type.Type;
public interface Configurable { public interface Configurable {
/** /**
* Configure this instance, given the value of parameters * Configure this instance, given the value of parameters
* specified by the user as <tt>&lt;param&gt;</tt> elements. * specified by the user as {@code &lt;param&gt;} elements.
* This method is called just once, following instantiation. * This method is called just once, following instantiation.
* *
* @param type The id property type descriptor * @param type The id property type descriptor

2
hibernate-core/src/main/java/org/hibernate/id/ForeignGenerator.java
View File

@ -27,7 +27,7 @@ import static org.hibernate.internal.CoreLogging.messageLogger;
/** /**
* <b>foreign</b> * <b>foreign</b>
* <p> * <p>
* An <tt>Identifier</tt> generator that uses the value of the id property of an * An {@code Identifier} generator that uses the value of the id property of an
* associated object * associated object
* <p> * <p>
* One mapping parameter is required: property. * One mapping parameter is required: property.

2
hibernate-core/src/main/java/org/hibernate/id/GUIDGenerator.java
View File

@ -17,7 +17,7 @@ import org.hibernate.internal.CoreLogging;
import org.hibernate.internal.CoreMessageLogger; import org.hibernate.internal.CoreMessageLogger;
/** /**
* Generates <tt>string</tt> values using the SQL Server NEWID() function. * Generates {@code string} values using the SQL Server NEWID() function.
* *
* @author Joseph Fifield * @author Joseph Fifield
* *

2
hibernate-core/src/main/java/org/hibernate/id/IdentifierGenerationException.java
View File

@ -8,7 +8,7 @@ package org.hibernate.id;
import org.hibernate.HibernateException; import org.hibernate.HibernateException;
/** /**
* Thrown by <tt>IdentifierGenerator</tt> implementation class when * Thrown by {@code IdentifierGenerator} implementation class when
* ID generation fails. * ID generation fails.
* *
* @see IdentifierGenerator * @see IdentifierGenerator

6
hibernate-core/src/main/java/org/hibernate/id/IdentifierGenerator.java
View File

@ -20,7 +20,7 @@ import org.hibernate.type.Type;
/** /**
* The general contract between a class that generates unique * The general contract between a class that generates unique
* identifiers and the <tt>Session</tt>. It is not intended that * identifiers and the {@code Session}. It is not intended that
* this interface ever be exposed to the application. It <b>is</b> * this interface ever be exposed to the application. It <b>is</b>
* intended that users implement this interface to provide * intended that users implement this interface to provide
* custom identifier generation strategies. * custom identifier generation strategies.
@ -28,7 +28,7 @@ import org.hibernate.type.Type;
* Implementors should provide a public default constructor. * Implementors should provide a public default constructor.
* <p> * <p>
* Implementations that accept configuration parameters should * Implementations that accept configuration parameters should
* also implement <tt>Configurable</tt>. * also implement {@code Configurable}.
* <p> * <p>
* Implementors <em>must</em> be thread-safe * Implementors <em>must</em> be thread-safe
* *
@ -60,7 +60,7 @@ public interface IdentifierGenerator extends Configurable, ExportableProducer {
/** /**
* Configure this instance, given the value of parameters * Configure this instance, given the value of parameters
* specified by the user as <tt>&lt;param&gt;</tt> elements. * specified by the user as {@code &lt;param&gt;} elements.
* <p> * <p>
* This method is called just once, following instantiation, and before {@link #registerExportables(Database)}. * This method is called just once, following instantiation, and before {@link #registerExportables(Database)}.
* *

2
hibernate-core/src/main/java/org/hibernate/id/IdentityGenerator.java
View File

@ -25,7 +25,7 @@ import org.hibernate.id.insert.InsertSelectIdentityInsert;
* A generator for use with ANSI-SQL IDENTITY columns used as the primary key. * A generator for use with ANSI-SQL IDENTITY columns used as the primary key.
* The IdentityGenerator for autoincrement/identity key generation. * The IdentityGenerator for autoincrement/identity key generation.
* <p> * <p>
* Indicates to the <tt>Session</tt> that identity (ie. identity/autoincrement * Indicates to the {@code Session} that identity (ie. identity/autoincrement
* column) key generation should be used. * column) key generation should be used.
* *
* @author Christoph Sturm * @author Christoph Sturm

2
hibernate-core/src/main/java/org/hibernate/id/IncrementGenerator.java
View File

@ -33,7 +33,7 @@ import org.hibernate.type.Type;
/** /**
* <b>increment</b> * <b>increment</b>
* <p> * <p>
* An <tt>IdentifierGenerator</tt> that returns a <tt>long</tt>, constructed by * An {@code IdentifierGenerator} that returns a {@code long}, constructed by
* counting from the maximum primary key value at startup. Not safe for use in a * counting from the maximum primary key value at startup. Not safe for use in a
* cluster! * cluster!
* <p> * <p>

16
hibernate-core/src/main/java/org/hibernate/id/IntegralDataTypeHolder.java
View File

@ -21,7 +21,7 @@ public interface IntegralDataTypeHolder extends Serializable {
* *
* @param value The primitive integral value. * @param value The primitive integral value.
* *
* @return <tt>this</tt>, for method chaining * @return {@code this}, for method chaining
*/ */
public IntegralDataTypeHolder initialize(long value); public IntegralDataTypeHolder initialize(long value);
@ -32,7 +32,7 @@ public interface IntegralDataTypeHolder extends Serializable {
* @param resultSet The JDBC result set * @param resultSet The JDBC result set
* @param defaultValue The default value to use if we did not get a result set value. * @param defaultValue The default value to use if we did not get a result set value.
* *
* @return <tt>this</tt>, for method chaining * @return {@code this}, for method chaining
* *
* @throws SQLException Any exception from accessing the result set * @throws SQLException Any exception from accessing the result set
*/ */
@ -51,7 +51,7 @@ public interface IntegralDataTypeHolder extends Serializable {
/** /**
* Equivalent to a ++ operation * Equivalent to a ++ operation
* *
* @return <tt>this</tt>, for method chaining * @return {@code this}, for method chaining
*/ */
public IntegralDataTypeHolder increment(); public IntegralDataTypeHolder increment();
@ -60,14 +60,14 @@ public interface IntegralDataTypeHolder extends Serializable {
* *
* @param addend The value to add to this integral. * @param addend The value to add to this integral.
* *
* @return <tt>this</tt>, for method chaining * @return {@code this}, for method chaining
*/ */
public IntegralDataTypeHolder add(long addend); public IntegralDataTypeHolder add(long addend);
/** /**
* Equivalent to a -- operation * Equivalent to a -- operation
* *
* @return <tt>this</tt>, for method chaining * @return {@code this}, for method chaining
*/ */
public IntegralDataTypeHolder decrement(); public IntegralDataTypeHolder decrement();
@ -76,7 +76,7 @@ public interface IntegralDataTypeHolder extends Serializable {
* *
* @param subtrahend The value to subtract from this integral. * @param subtrahend The value to subtract from this integral.
* *
* @return <tt>this</tt>, for method chaining * @return {@code this}, for method chaining
*/ */
public IntegralDataTypeHolder subtract(long subtrahend); public IntegralDataTypeHolder subtract(long subtrahend);
@ -85,7 +85,7 @@ public interface IntegralDataTypeHolder extends Serializable {
* *
* @param factor The factor by which to multiple this integral * @param factor The factor by which to multiple this integral
* *
* @return <tt>this</tt>, for method chaining * @return {@code this}, for method chaining
*/ */
public IntegralDataTypeHolder multiplyBy(IntegralDataTypeHolder factor); public IntegralDataTypeHolder multiplyBy(IntegralDataTypeHolder factor);
@ -94,7 +94,7 @@ public interface IntegralDataTypeHolder extends Serializable {
* *
* @param factor The factor by which to multiple this integral * @param factor The factor by which to multiple this integral
* *
* @return <tt>this</tt>, for method chaining * @return {@code this}, for method chaining
*/ */
public IntegralDataTypeHolder multiplyBy(long factor); public IntegralDataTypeHolder multiplyBy(long factor);

4
hibernate-core/src/main/java/org/hibernate/id/PersistentIdentifierGenerator.java
View File

@ -14,9 +14,9 @@ import org.hibernate.service.ServiceRegistry;
import org.hibernate.type.Type; import org.hibernate.type.Type;
/** /**
* An <tt>IdentifierGenerator</tt> that requires creation of database objects. * An {@code IdentifierGenerator} that requires creation of database objects.
* <p> * <p>
* All <tt>PersistentIdentifierGenerator</tt>s have access to a special mapping parameter * All {@code PersistentIdentifierGenerator}s have access to a special mapping parameter
* in their {@link #configure(Type, Properties, ServiceRegistry)} method: schema * in their {@link #configure(Type, Properties, ServiceRegistry)} method: schema
* *
* @author Gavin King * @author Gavin King

2
hibernate-core/src/main/java/org/hibernate/id/PostInsertIdentityPersister.java
View File

@ -9,7 +9,7 @@ import org.hibernate.persister.entity.EntityPersister;
/** /**
* A persister that may have an identity assigned by execution of * A persister that may have an identity assigned by execution of
* a SQL <tt>INSERT</tt>. * a SQL {@code INSERT}.
* *
* @author Gavin King * @author Gavin King
*/ */

2
hibernate-core/src/main/java/org/hibernate/id/UUIDHexGenerator.java
View File

@ -19,7 +19,7 @@ import org.hibernate.type.Type;
/** /**
* <b>uuid</b> * <b>uuid</b>
* <p> * <p>
* A <tt>UUIDGenerator</tt> that returns a string of length 32, * A {@code UUIDGenerator} that returns a string of length 32,
* This string will consist of only hex digits. Optionally, * This string will consist of only hex digits. Optionally,
* the string may be generated with separators between each * the string may be generated with separators between each
* component of the UUID. * component of the UUID.

4
hibernate-core/src/main/java/org/hibernate/id/enhanced/InitialValueAwareOptimizer.java
View File

@ -18,9 +18,9 @@ public interface InitialValueAwareOptimizer {
/** /**
* Reports the user specified initial value to the optimizer. * Reports the user specified initial value to the optimizer.
* <p/> * <p/>
* <tt>-1</tt> is used to indicate that the user did not specify. * {@code -1} is used to indicate that the user did not specify.
* *
* @param initialValue The initial value specified by the user, or <tt>-1</tt> to indicate that the * @param initialValue The initial value specified by the user, or {@code -1} to indicate that the
* user did not specify. * user did not specify.
*/ */
public void injectInitialValue(long initialValue); public void injectInitialValue(long initialValue);

2
hibernate-core/src/main/java/org/hibernate/id/factory/IdentifierGeneratorFactory.java
View File

@ -17,7 +17,7 @@ import org.hibernate.type.descriptor.java.JavaType;
import jakarta.persistence.GenerationType; import jakarta.persistence.GenerationType;
/** /**
* Contract for a <tt>factory</tt> of {@link IdentifierGenerator} instances. * Contract for a {@code factory} of {@link IdentifierGenerator} instances.
* *
* @author Steve Ebersole * @author Steve Ebersole
*/ */

2
hibernate-core/src/main/java/org/hibernate/id/factory/internal/StandardIdentifierGeneratorFactory.java
View File

@ -55,7 +55,7 @@ import jakarta.persistence.GenerationType;
import static org.hibernate.id.factory.IdGenFactoryLogging.ID_GEN_FAC_LOGGER; import static org.hibernate.id.factory.IdGenFactoryLogging.ID_GEN_FAC_LOGGER;
/** /**
* Basic <tt>templated</tt> support for {@link org.hibernate.id.factory.IdentifierGeneratorFactory} implementations. * Basic {@code templated} support for {@link org.hibernate.id.factory.IdentifierGeneratorFactory} implementations.
* *
* @author Steve Ebersole * @author Steve Ebersole
*/ */

12
hibernate-core/src/main/java/org/hibernate/internal/SessionFactoryImpl.java
View File

@ -138,16 +138,16 @@ import org.jboss.logging.Logger;
/** /**
* Concrete implementation of the <tt>SessionFactory</tt> interface. Has the following * Concrete implementation of the {@code SessionFactory} interface. Has the following
* responsibilities * responsibilities
* <ul> * <ul>
* <li>caches configuration settings (immutably) * <li>caches configuration settings (immutably)
* <li>caches "compiled" mappings ie. <tt>EntityPersister</tt>s and * <li>caches "compiled" mappings ie. {@code EntityPersister}s and
* <tt>CollectionPersister</tt>s (immutable) * {@code CollectionPersister}s (immutable)
* <li>caches "compiled" queries (memory sensitive cache) * <li>caches "compiled" queries (memory sensitive cache)
* <li>manages <tt>PreparedStatement</tt>s * <li>manages {@code PreparedStatement}s
* <li> delegates JDBC <tt>Connection</tt> management to the <tt>ConnectionProvider</tt> * <li> delegates JDBC {@code Connection} management to the {@code ConnectionProvider}
* <li>factory for instances of <tt>SessionImpl</tt> * <li>factory for instances of {@code SessionImpl}
* </ul> * </ul>
* This class must appear immutable to clients, even if it does all kinds of caching * This class must appear immutable to clients, even if it does all kinds of caching
* and pooling under the covers. It is crucial that the class is not only thread * and pooling under the covers. It is crucial that the class is not only thread

96
hibernate-core/src/main/java/org/hibernate/internal/util/collections/BoundedConcurrentHashMap.java
View File

@ -45,19 +45,19 @@ import static java.util.Collections.unmodifiableMap;
* adjustable expected concurrency for updates. This class obeys the * adjustable expected concurrency for updates. This class obeys the
* same functional specification as {@link java.util.Hashtable}, and * same functional specification as {@link java.util.Hashtable}, and
* includes versions of methods corresponding to each method of * includes versions of methods corresponding to each method of
* <tt>Hashtable</tt>. However, even though all operations are * {@code Hashtable}. However, even though all operations are
* thread-safe, retrieval operations do <em>not</em> entail locking, * thread-safe, retrieval operations do <em>not</em> entail locking,
* and there is <em>not</em> any support for locking the entire table * and there is <em>not</em> any support for locking the entire table
* in a way that prevents all access. This class is fully * in a way that prevents all access. This class is fully
* interoperable with <tt>Hashtable</tt> in programs that rely on its * interoperable with {@code Hashtable} in programs that rely on its
* thread safety but not on its synchronization details. * thread safety but not on its synchronization details.
* <p/> * <p/>
* <p> Retrieval operations (including <tt>get</tt>) generally do not * <p> Retrieval operations (including {@code get}) generally do not
* block, so may overlap with update operations (including * block, so may overlap with update operations (including
* <tt>put</tt> and <tt>remove</tt>). Retrievals reflect the results * {@code put} and {@code remove}). Retrievals reflect the results
* of the most recently <em>completed</em> update operations holding * of the most recently <em>completed</em> update operations holding
* upon their onset. For aggregate operations such as <tt>putAll</tt> * upon their onset. For aggregate operations such as {@code putAll}
* and <tt>clear</tt>, concurrent retrievals may reflect insertion or * and {@code clear}, concurrent retrievals may reflect insertion or
* removal of only some entries. Similarly, Iterators and * removal of only some entries. Similarly, Iterators and
* Enumerations return elements reflecting the state of the hash table * Enumerations return elements reflecting the state of the hash table
* at some point at or since the creation of the iterator/enumeration. * at some point at or since the creation of the iterator/enumeration.
@ -65,8 +65,8 @@ import static java.util.Collections.unmodifiableMap;
* However, iterators are designed to be used by only one thread at a time. * However, iterators are designed to be used by only one thread at a time.
* <p/> * <p/>
* <p> The allowed concurrency among update operations is guided by * <p> The allowed concurrency among update operations is guided by
* the optional <tt>concurrencyLevel</tt> constructor argument * the optional {@code concurrencyLevel} constructor argument
* (default <tt>16</tt>), which is used as a hint for internal sizing. The * (default {@code 16}), which is used as a hint for internal sizing. The
* table is internally partitioned to try to permit the indicated * table is internally partitioned to try to permit the indicated
* number of concurrent updates without contention. Because placement * number of concurrent updates without contention. Because placement
* in hash tables is essentially random, the actual concurrency will * in hash tables is essentially random, the actual concurrency will
@ -93,7 +93,7 @@ import static java.util.Collections.unmodifiableMap;
* <p/> * <p/>
* <p/> * <p/>
* <p> Like {@link java.util.Hashtable} but unlike {@link HashMap}, this class * <p> Like {@link java.util.Hashtable} but unlike {@link HashMap}, this class
* does <em>not</em> allow <tt>null</tt> to be used as a key or value. * does <em>not</em> allow {@code null} to be used as a key or value.
* *
* @param <K> the type of keys maintained by this map * @param <K> the type of keys maintained by this map
* @param <V> the type of mapped values * @param <V> the type of mapped values
@ -1195,8 +1195,8 @@ public class BoundedConcurrentHashMap<K, V> extends AbstractMap<K, V>
/** /**
* The table is rehashed when its size exceeds this threshold. * The table is rehashed when its size exceeds this threshold.
* (The value of this field is always <tt>(int)(capacity * * (The value of this field is always {@code (int)(capacity *
* loadFactor)</tt>.) * loadFactor)}.)
*/ */
transient int threshold; transient int threshold;
@ -1733,9 +1733,9 @@ public class BoundedConcurrentHashMap<K, V> extends AbstractMap<K, V>
} }
/** /**
* Returns <tt>true</tt> if this map contains no key-value mappings. * Returns {@code true} if this map contains no key-value mappings.
* *
* @return <tt>true</tt> if this map contains no key-value mappings * @return {@code true} if this map contains no key-value mappings
*/ */
@Override @Override
public boolean isEmpty() { public boolean isEmpty() {
@ -1774,8 +1774,8 @@ public class BoundedConcurrentHashMap<K, V> extends AbstractMap<K, V>
/** /**
* Returns the number of key-value mappings in this map. If the * Returns the number of key-value mappings in this map. If the
* map contains more than <tt>Integer.MAX_VALUE</tt> elements, returns * map contains more than {@code Integer.MAX_VALUE} elements, returns
* <tt>Integer.MAX_VALUE</tt>. * {@code Integer.MAX_VALUE}.
* *
* @return the number of key-value mappings in this map * @return the number of key-value mappings in this map
*/ */
@ -1854,9 +1854,9 @@ public class BoundedConcurrentHashMap<K, V> extends AbstractMap<K, V>
* *
* @param key possible key * @param key possible key
* *
* @return <tt>true</tt> if and only if the specified object * @return {@code true} if and only if the specified object
* is a key in this table, as determined by the * is a key in this table, as determined by the
* <tt>equals</tt> method; <tt>false</tt> otherwise. * {@code equals} method; {@code false} otherwise.
* *
* @throws NullPointerException if the specified key is null * @throws NullPointerException if the specified key is null
*/ */
@ -1867,14 +1867,14 @@ public class BoundedConcurrentHashMap<K, V> extends AbstractMap<K, V>
} }
/** /**
* Returns <tt>true</tt> if this map maps one or more keys to the * Returns {@code true} if this map maps one or more keys to the
* specified value. Note: This method requires a full internal * specified value. Note: This method requires a full internal
* traversal of the hash table, and so is much slower than * traversal of the hash table, and so is much slower than
* method <tt>containsKey</tt>. * method {@code containsKey}.
* *
* @param value value whose presence in this map is to be tested * @param value value whose presence in this map is to be tested
* *
* @return <tt>true</tt> if this map maps one or more keys to the * @return {@code true} if this map maps one or more keys to the
* specified value * specified value
* *
* @throws NullPointerException if the specified value is null * @throws NullPointerException if the specified value is null
@ -1947,10 +1947,10 @@ public class BoundedConcurrentHashMap<K, V> extends AbstractMap<K, V>
* *
* @param value a value to search for * @param value a value to search for
* *
* @return <tt>true</tt> if and only if some key maps to the * @return {@code true} if and only if some key maps to the
* <tt>value</tt> argument in this table as * {@code value} argument in this table as
* determined by the <tt>equals</tt> method; * determined by the {@code equals} method;
* <tt>false</tt> otherwise * {@code false} otherwise
* *
* @throws NullPointerException if the specified value is null * @throws NullPointerException if the specified value is null
*/ */
@ -1962,14 +1962,14 @@ public class BoundedConcurrentHashMap<K, V> extends AbstractMap<K, V>
* Maps the specified key to the specified value in this table. * Maps the specified key to the specified value in this table.
* Neither the key nor the value can be null. * Neither the key nor the value can be null.
* <p/> * <p/>
* <p> The value can be retrieved by calling the <tt>get</tt> method * <p> The value can be retrieved by calling the {@code get} method
* with a key that is equal to the original key. * with a key that is equal to the original key.
* *
* @param key key with which the specified value is to be associated * @param key key with which the specified value is to be associated
* @param value value to be associated with the specified key * @param value value to be associated with the specified key
* *
* @return the previous value associated with <tt>key</tt>, or * @return the previous value associated with {@code key}, or
* <tt>null</tt> if there was no mapping for <tt>key</tt> * {@code null} if there was no mapping for {@code key}
* *
* @throws NullPointerException if the specified key or value is null * @throws NullPointerException if the specified key or value is null
*/ */
@ -1986,7 +1986,7 @@ public class BoundedConcurrentHashMap<K, V> extends AbstractMap<K, V>
* {@inheritDoc} * {@inheritDoc}
* *
* @return the previous value associated with the specified key, * @return the previous value associated with the specified key,
* or <tt>null</tt> if there was no mapping for the key * or {@code null} if there was no mapping for the key
* *
* @throws NullPointerException if the specified key or value is null * @throws NullPointerException if the specified key or value is null
*/ */
@ -2019,8 +2019,8 @@ public class BoundedConcurrentHashMap<K, V> extends AbstractMap<K, V>
* *
* @param key the key that needs to be removed * @param key the key that needs to be removed
* *
* @return the previous value associated with <tt>key</tt>, or * @return the previous value associated with {@code key}, or
* <tt>null</tt> if there was no mapping for <tt>key</tt> * {@code null} if there was no mapping for {@code key}
* *
* @throws NullPointerException if the specified key is null * @throws NullPointerException if the specified key is null
*/ */
@ -2062,7 +2062,7 @@ public class BoundedConcurrentHashMap<K, V> extends AbstractMap<K, V>
* {@inheritDoc} * {@inheritDoc}
* *
* @return the previous value associated with the specified key, * @return the previous value associated with the specified key,
* or <tt>null</tt> if there was no mapping for the key * or {@code null} if there was no mapping for the key
* *
* @throws NullPointerException if the specified key or value is null * @throws NullPointerException if the specified key or value is null
*/ */
@ -2090,12 +2090,12 @@ public class BoundedConcurrentHashMap<K, V> extends AbstractMap<K, V>
* The set is backed by the map, so changes to the map are * The set is backed by the map, so changes to the map are
* reflected in the set, and vice-versa. The set supports element * reflected in the set, and vice-versa. The set supports element
* removal, which removes the corresponding mapping from this map, * removal, which removes the corresponding mapping from this map,
* via the <tt>Iterator.remove</tt>, <tt>Set.remove</tt>, * via the {@code Iterator.remove}, {@code Set.remove},
* <tt>removeAll</tt>, <tt>retainAll</tt>, and <tt>clear</tt> * {@code removeAll}, {@code retainAll}, and {@code clear}
* operations. It does not support the <tt>add</tt> or * operations. It does not support the {@code add} or
* <tt>addAll</tt> operations. * {@code addAll} operations.
* <p/> * <p/>
* <p>The view's <tt>iterator</tt> is a "weakly consistent" iterator * <p>The view's {@code iterator} is a "weakly consistent" iterator
* that will never throw {@link java.util.ConcurrentModificationException}, * that will never throw {@link java.util.ConcurrentModificationException},
* and guarantees to traverse elements as they existed upon * and guarantees to traverse elements as they existed upon
* construction of the iterator, and may (but is not guaranteed to) * construction of the iterator, and may (but is not guaranteed to)
@ -2112,12 +2112,12 @@ public class BoundedConcurrentHashMap<K, V> extends AbstractMap<K, V>
* The collection is backed by the map, so changes to the map are * The collection is backed by the map, so changes to the map are
* reflected in the collection, and vice-versa. The collection * reflected in the collection, and vice-versa. The collection
* supports element removal, which removes the corresponding * supports element removal, which removes the corresponding
* mapping from this map, via the <tt>Iterator.remove</tt>, * mapping from this map, via the {@code Iterator.remove},
* <tt>Collection.remove</tt>, <tt>removeAll</tt>, * {@code Collection.remove}, {@code removeAll},
* <tt>retainAll</tt>, and <tt>clear</tt> operations. It does not * {@code retainAll}, and {@code clear} operations. It does not
* support the <tt>add</tt> or <tt>addAll</tt> operations. * support the {@code add} or {@code addAll} operations.
* <p/> * <p/>
* <p>The view's <tt>iterator</tt> is a "weakly consistent" iterator * <p>The view's {@code iterator} is a "weakly consistent" iterator
* that will never throw {@link java.util.ConcurrentModificationException}, * that will never throw {@link java.util.ConcurrentModificationException},
* and guarantees to traverse elements as they existed upon * and guarantees to traverse elements as they existed upon
* construction of the iterator, and may (but is not guaranteed to) * construction of the iterator, and may (but is not guaranteed to)
@ -2134,12 +2134,12 @@ public class BoundedConcurrentHashMap<K, V> extends AbstractMap<K, V>
* The set is backed by the map, so changes to the map are * The set is backed by the map, so changes to the map are
* reflected in the set, and vice-versa. The set supports element * reflected in the set, and vice-versa. The set supports element
* removal, which removes the corresponding mapping from the map, * removal, which removes the corresponding mapping from the map,
* via the <tt>Iterator.remove</tt>, <tt>Set.remove</tt>, * via the {@code Iterator.remove}, {@code Set.remove},
* <tt>removeAll</tt>, <tt>retainAll</tt>, and <tt>clear</tt> * {@code removeAll}, {@code retainAll}, and {@code clear}
* operations. It does not support the <tt>add</tt> or * operations. It does not support the {@code add} or
* <tt>addAll</tt> operations. * {@code addAll} operations.
* <p/> * <p/>
* <p>The view's <tt>iterator</tt> is a "weakly consistent" iterator * <p>The view's {@code iterator} is a "weakly consistent" iterator
* that will never throw {@link java.util.ConcurrentModificationException}, * that will never throw {@link java.util.ConcurrentModificationException},
* and guarantees to traverse elements as they existed upon * and guarantees to traverse elements as they existed upon
* construction of the iterator, and may (but is not guaranteed to) * construction of the iterator, and may (but is not guaranteed to)
@ -2410,7 +2410,7 @@ public class BoundedConcurrentHashMap<K, V> extends AbstractMap<K, V>
/* ---------------- Serialization Support -------------- */ /* ---------------- Serialization Support -------------- */
/** /**
* Save the state of the <tt>ConcurrentHashMap</tt> instance to a * Save the state of the {@code ConcurrentHashMap} instance to a
* stream (i.e., serialize it). * stream (i.e., serialize it).
* *
* @param s the stream * @param s the stream
@ -2443,7 +2443,7 @@ public class BoundedConcurrentHashMap<K, V> extends AbstractMap<K, V>
} }
/** /**
* Reconstitute the <tt>ConcurrentHashMap</tt> instance from a * Reconstitute the {@code ConcurrentHashMap} instance from a
* stream (i.e., deserialize it). * stream (i.e., deserialize it).
* *
* @param s the stream * @param s the stream

98
hibernate-core/src/main/java/org/hibernate/internal/util/collections/ConcurrentReferenceHashMap.java
View File

@ -49,8 +49,8 @@ import java.util.concurrent.locks.ReentrantLock;
* discarded by the garbage collector. Once a key has been discarded by the * discarded by the garbage collector. Once a key has been discarded by the
* collector, the corresponding entry is no longer visible to this table; * collector, the corresponding entry is no longer visible to this table;
* however, the entry may occupy space until a future table operation decides to * however, the entry may occupy space until a future table operation decides to
* reclaim it. For this reason, summary functions such as <tt>size</tt> and * reclaim it. For this reason, summary functions such as {@code size} and
* <tt>isEmpty</tt> might return a value greater than the observed number of * {@code isEmpty} might return a value greater than the observed number of
* entries. In order to support a high level of concurrency, stale entries are * entries. In order to support a high level of concurrency, stale entries are
* only reclaimed during blocking (usually mutating) operations. * only reclaimed during blocking (usually mutating) operations.
* <p/> * <p/>
@ -75,19 +75,19 @@ import java.util.concurrent.locks.ReentrantLock;
* Just like {@link java.util.concurrent.ConcurrentHashMap}, this class obeys * Just like {@link java.util.concurrent.ConcurrentHashMap}, this class obeys
* the same functional specification as {@link java.util.Hashtable}, and * the same functional specification as {@link java.util.Hashtable}, and
* includes versions of methods corresponding to each method of * includes versions of methods corresponding to each method of
* <tt>Hashtable</tt>. However, even though all operations are thread-safe, * {@code Hashtable}. However, even though all operations are thread-safe,
* retrieval operations do <em>not</em> entail locking, and there is * retrieval operations do <em>not</em> entail locking, and there is
* <em>not</em> any support for locking the entire table in a way that * <em>not</em> any support for locking the entire table in a way that
* prevents all access. This class is fully interoperable with * prevents all access. This class is fully interoperable with
* <tt>Hashtable</tt> in programs that rely on its thread safety but not on * {@code Hashtable} in programs that rely on its thread safety but not on
* its synchronization details. * its synchronization details.
* <p/> * <p/>
* <p/> * <p/>
* Retrieval operations (including <tt>get</tt>) generally do not block, so * Retrieval operations (including {@code get}) generally do not block, so
* may overlap with update operations (including <tt>put</tt> and * may overlap with update operations (including {@code put} and
* <tt>remove</tt>). Retrievals reflect the results of the most recently * {@code remove}). Retrievals reflect the results of the most recently
* <em>completed</em> update operations holding upon their onset. For * <em>completed</em> update operations holding upon their onset. For
* aggregate operations such as <tt>putAll</tt> and <tt>clear</tt>, * aggregate operations such as {@code putAll} and {@code clear},
* concurrent retrievals may reflect insertion or removal of only some entries. * concurrent retrievals may reflect insertion or removal of only some entries.
* Similarly, Iterators and Enumerations return elements reflecting the state of * Similarly, Iterators and Enumerations return elements reflecting the state of
* the hash table at some point at or since the creation of the * the hash table at some point at or since the creation of the
@ -97,7 +97,7 @@ import java.util.concurrent.locks.ReentrantLock;
* <p/> * <p/>
* <p/> * <p/>
* The allowed concurrency among update operations is guided by the optional * The allowed concurrency among update operations is guided by the optional
* <tt>concurrencyLevel</tt> constructor argument (default <tt>16</tt>), * {@code concurrencyLevel} constructor argument (default {@code 16}),
* which is used as a hint for internal sizing. The table is internally * which is used as a hint for internal sizing. The table is internally
* partitioned to try to permit the indicated number of concurrent updates * partitioned to try to permit the indicated number of concurrent updates
* without contention. Because placement in hash tables is essentially random, * without contention. Because placement in hash tables is essentially random,
@ -118,7 +118,7 @@ import java.util.concurrent.locks.ReentrantLock;
* <p/> * <p/>
* <p/> * <p/>
* Like {@link java.util.Hashtable} but unlike {@link java.util.HashMap}, this class does * Like {@link java.util.Hashtable} but unlike {@link java.util.HashMap}, this class does
* <em>not</em> allow <tt>null</tt> to be used as a key or value. * <em>not</em> allow {@code null} to be used as a key or value.
* <p/> * <p/>
* <p/> * <p/>
* This class is a member of the <a href="{@docRoot}/../technotes/guides/collections/index.html"> * This class is a member of the <a href="{@docRoot}/../technotes/guides/collections/index.html">
@ -518,8 +518,8 @@ public class ConcurrentReferenceHashMap<K, V> extends AbstractMap<K, V>
/** /**
* The table is rehashed when its size exceeds this threshold. * The table is rehashed when its size exceeds this threshold.
* (The value of this field is always <tt>(int)(capacity * * (The value of this field is always {@code (int)(capacity *
* loadFactor)</tt>.) * loadFactor)}.)
*/ */
transient int threshold; transient int threshold;
@ -1078,9 +1078,9 @@ public class ConcurrentReferenceHashMap<K, V> extends AbstractMap<K, V>
} }
/** /**
* Returns <tt>true</tt> if this map contains no key-value mappings. * Returns {@code true} if this map contains no key-value mappings.
* *
* @return <tt>true</tt> if this map contains no key-value mappings * @return {@code true} if this map contains no key-value mappings
*/ */
@Override @Override
public boolean isEmpty() { public boolean isEmpty() {
@ -1120,8 +1120,8 @@ public class ConcurrentReferenceHashMap<K, V> extends AbstractMap<K, V>
/** /**
* Returns the number of key-value mappings in this map. If the * Returns the number of key-value mappings in this map. If the
* map contains more than <tt>Integer.MAX_VALUE</tt> elements, returns * map contains more than {@code Integer.MAX_VALUE} elements, returns
* <tt>Integer.MAX_VALUE</tt>. * {@code Integer.MAX_VALUE}.
* *
* @return the number of key-value mappings in this map * @return the number of key-value mappings in this map
*/ */
@ -1199,9 +1199,9 @@ public class ConcurrentReferenceHashMap<K, V> extends AbstractMap<K, V>
* *
* @param key possible key * @param key possible key
* *
* @return <tt>true</tt> if and only if the specified object * @return {@code true} if and only if the specified object
* is a key in this table, as determined by the * is a key in this table, as determined by the
* <tt>equals</tt> method; <tt>false</tt> otherwise. * {@code equals} method; {@code false} otherwise.
* *
* @throws NullPointerException if the specified key is null * @throws NullPointerException if the specified key is null
*/ */
@ -1215,14 +1215,14 @@ public class ConcurrentReferenceHashMap<K, V> extends AbstractMap<K, V>
} }
/** /**
* Returns <tt>true</tt> if this map maps one or more keys to the * Returns {@code true} if this map maps one or more keys to the
* specified value. Note: This method requires a full internal * specified value. Note: This method requires a full internal
* traversal of the hash table, and so is much slower than * traversal of the hash table, and so is much slower than
* method <tt>containsKey</tt>. * method {@code containsKey}.
* *
* @param value value whose presence in this map is to be tested * @param value value whose presence in this map is to be tested
* *
* @return <tt>true</tt> if this map maps one or more keys to the * @return {@code true} if this map maps one or more keys to the
* specified value * specified value
*/ */
@Override @Override
@ -1292,10 +1292,10 @@ public class ConcurrentReferenceHashMap<K, V> extends AbstractMap<K, V>
* *
* @param value a value to search for * @param value a value to search for
* *
* @return <tt>true</tt> if and only if some key maps to the * @return {@code true} if and only if some key maps to the
* <tt>value</tt> argument in this table as * {@code value} argument in this table as
* determined by the <tt>equals</tt> method; * determined by the {@code equals} method;
* <tt>false</tt> otherwise * {@code false} otherwise
* *
* @throws NullPointerException if the specified value is null * @throws NullPointerException if the specified value is null
*/ */
@ -1307,14 +1307,14 @@ public class ConcurrentReferenceHashMap<K, V> extends AbstractMap<K, V>
* Maps the specified key to the specified value in this table. * Maps the specified key to the specified value in this table.
* Neither the key nor the value can be null. * Neither the key nor the value can be null.
* <p/> * <p/>
* <p> The value can be retrieved by calling the <tt>get</tt> method * <p> The value can be retrieved by calling the {@code get} method
* with a key that is equal to the original key. * with a key that is equal to the original key.
* *
* @param key key with which the specified value is to be associated * @param key key with which the specified value is to be associated
* @param value value to be associated with the specified key * @param value value to be associated with the specified key
* *
* @return the previous value associated with <tt>key</tt>, or * @return the previous value associated with {@code key}, or
* <tt>null</tt> if there was no mapping for <tt>key</tt> * {@code null} if there was no mapping for {@code key}
* *
* @throws NullPointerException if the specified key or value is null * @throws NullPointerException if the specified key or value is null
*/ */
@ -1331,7 +1331,7 @@ public class ConcurrentReferenceHashMap<K, V> extends AbstractMap<K, V>
* {@inheritDoc} * {@inheritDoc}
* *
* @return the previous value associated with the specified key, * @return the previous value associated with the specified key,
* or <tt>null</tt> if there was no mapping for the key * or {@code null} if there was no mapping for the key
* *
* @throws NullPointerException if the specified key or value is null * @throws NullPointerException if the specified key or value is null
*/ */
@ -1364,8 +1364,8 @@ public class ConcurrentReferenceHashMap<K, V> extends AbstractMap<K, V>
* *
* @param key the key that needs to be removed * @param key the key that needs to be removed
* *
* @return the previous value associated with <tt>key</tt>, or * @return the previous value associated with {@code key}, or
* <tt>null</tt> if there was no mapping for <tt>key</tt> * {@code null} if there was no mapping for {@code key}
* *
* @throws NullPointerException if the specified key is null * @throws NullPointerException if the specified key is null
*/ */
@ -1410,7 +1410,7 @@ public class ConcurrentReferenceHashMap<K, V> extends AbstractMap<K, V>
* {@inheritDoc} * {@inheritDoc}
* *
* @return the previous value associated with the specified key, * @return the previous value associated with the specified key,
* or <tt>null</tt> if there was no mapping for the key * or {@code null} if there was no mapping for the key
* *
* @throws NullPointerException if the specified key or value is null * @throws NullPointerException if the specified key or value is null
*/ */
@ -1456,12 +1456,12 @@ public class ConcurrentReferenceHashMap<K, V> extends AbstractMap<K, V>
* The set is backed by the map, so changes to the map are * The set is backed by the map, so changes to the map are
* reflected in the set, and vice-versa. The set supports element * reflected in the set, and vice-versa. The set supports element
* removal, which removes the corresponding mapping from this map, * removal, which removes the corresponding mapping from this map,
* via the <tt>Iterator.remove</tt>, <tt>Set.remove</tt>, * via the {@code Iterator.remove}, {@code Set.remove},
* <tt>removeAll</tt>, <tt>retainAll</tt>, and <tt>clear</tt> * {@code removeAll}, {@code retainAll}, and {@code clear}
* operations. It does not support the <tt>add</tt> or * operations. It does not support the {@code add} or
* <tt>addAll</tt> operations. * {@code addAll} operations.
* <p/> * <p/>
* <p>The view's <tt>iterator</tt> is a "weakly consistent" iterator * <p>The view's {@code iterator} is a "weakly consistent" iterator
* that will never throw {@link java.util.ConcurrentModificationException}, * that will never throw {@link java.util.ConcurrentModificationException},
* and guarantees to traverse elements as they existed upon * and guarantees to traverse elements as they existed upon
* construction of the iterator, and may (but is not guaranteed to) * construction of the iterator, and may (but is not guaranteed to)
@ -1478,12 +1478,12 @@ public class ConcurrentReferenceHashMap<K, V> extends AbstractMap<K, V>
* The collection is backed by the map, so changes to the map are * The collection is backed by the map, so changes to the map are
* reflected in the collection, and vice-versa. The collection * reflected in the collection, and vice-versa. The collection
* supports element removal, which removes the corresponding * supports element removal, which removes the corresponding
* mapping from this map, via the <tt>Iterator.remove</tt>, * mapping from this map, via the {@code Iterator.remove},
* <tt>Collection.remove</tt>, <tt>removeAll</tt>, * {@code Collection.remove}, {@code removeAll},
* <tt>retainAll</tt>, and <tt>clear</tt> operations. It does not * {@code retainAll}, and {@code clear} operations. It does not
* support the <tt>add</tt> or <tt>addAll</tt> operations. * support the {@code add} or {@code addAll} operations.
* <p/> * <p/>
* <p>The view's <tt>iterator</tt> is a "weakly consistent" iterator * <p>The view's {@code iterator} is a "weakly consistent" iterator
* that will never throw {@link java.util.ConcurrentModificationException}, * that will never throw {@link java.util.ConcurrentModificationException},
* and guarantees to traverse elements as they existed upon * and guarantees to traverse elements as they existed upon
* construction of the iterator, and may (but is not guaranteed to) * construction of the iterator, and may (but is not guaranteed to)
@ -1500,12 +1500,12 @@ public class ConcurrentReferenceHashMap<K, V> extends AbstractMap<K, V>
* The set is backed by the map, so changes to the map are * The set is backed by the map, so changes to the map are
* reflected in the set, and vice-versa. The set supports element * reflected in the set, and vice-versa. The set supports element
* removal, which removes the corresponding mapping from the map, * removal, which removes the corresponding mapping from the map,
* via the <tt>Iterator.remove</tt>, <tt>Set.remove</tt>, * via the {@code Iterator.remove}, {@code Set.remove},
* <tt>removeAll</tt>, <tt>retainAll</tt>, and <tt>clear</tt> * {@code removeAll}, {@code retainAll}, and {@code clear}
* operations. It does not support the <tt>add</tt> or * operations. It does not support the {@code add} or
* <tt>addAll</tt> operations. * {@code addAll} operations.
* <p/> * <p/>
* <p>The view's <tt>iterator</tt> is a "weakly consistent" iterator * <p>The view's {@code iterator} is a "weakly consistent" iterator
* that will never throw {@link java.util.ConcurrentModificationException}, * that will never throw {@link java.util.ConcurrentModificationException},
* and guarantees to traverse elements as they existed upon * and guarantees to traverse elements as they existed upon
* construction of the iterator, and may (but is not guaranteed to) * construction of the iterator, and may (but is not guaranteed to)
@ -1853,7 +1853,7 @@ public class ConcurrentReferenceHashMap<K, V> extends AbstractMap<K, V>
/* ---------------- Serialization Support -------------- */ /* ---------------- Serialization Support -------------- */
/** /**
* Save the state of the <tt>ConcurrentReferenceHashMap</tt> instance to a * Save the state of the {@code ConcurrentReferenceHashMap} instance to a
* stream (i.e., serialize it). * stream (i.e., serialize it).
* *
* @param s the stream * @param s the stream
@ -1892,7 +1892,7 @@ public class ConcurrentReferenceHashMap<K, V> extends AbstractMap<K, V>
} }
/** /**
* Reconstitute the <tt>ConcurrentReferenceHashMap</tt> instance from a * Reconstitute the {@code ConcurrentReferenceHashMap} instance from a
* stream (i.e., deserialize it). * stream (i.e., deserialize it).
* *
* @param s the stream * @param s the stream

8
hibernate-core/src/main/java/org/hibernate/internal/util/collections/IdentityMap.java
View File

@ -17,8 +17,8 @@ import java.util.function.BiConsumer;
import java.util.function.Consumer; import java.util.function.Consumer;
/** /**
* A <tt>Map</tt> where keys are compared by object identity, * A {@code Map} where keys are compared by object identity,
* rather than <tt>equals()</tt>. * rather than {@code equals()}.
*/ */
public final class IdentityMap<K,V> implements Map<K,V> { public final class IdentityMap<K,V> implements Map<K,V> {
@ -47,9 +47,9 @@ public final class IdentityMap<K,V> implements Map<K,V> {
} }
/** /**
* Return the map entries (as instances of <tt>Map.Entry</tt> in a collection that * Return the map entries (as instances of {@code Map.Entry} in a collection that
* is safe from concurrent modification). ie. we may safely add new instances to * is safe from concurrent modification). ie. we may safely add new instances to
* the underlying <tt>Map</tt> during iteration of the <tt>entries()</tt>. * the underlying {@code Map} during iteration of the {@code entries()}.
* *
* @param map The map of entries * @param map The map of entries
* @return Collection * @return Collection

4
hibernate-core/src/main/java/org/hibernate/internal/util/config/ConfigurationHelper.java
View File

@ -303,7 +303,7 @@ public final class ConfigurationHelper {
/** /**
* Extract a property value by name from the given properties object. * Extract a property value by name from the given properties object.
* <p/> * <p/>
* Both <tt>null</tt> and <tt>empty string</tt> are viewed as the same, and return null. * Both {@code null} and {@code empty string} are viewed as the same, and return null.
* *
* @param propertyName The name of the property for which to extract value * @param propertyName The name of the property for which to extract value
* @param properties The properties object * @param properties The properties object
@ -323,7 +323,7 @@ public final class ConfigurationHelper {
/** /**
* Extract a property value by name from the given properties object. * Extract a property value by name from the given properties object.
* <p/> * <p/>
* Both <tt>null</tt> and <tt>empty string</tt> are viewed as the same, and return null. * Both {@code null} and {@code empty string} are viewed as the same, and return null.
* *
* @param propertyName The name of the property for which to extract value * @param propertyName The name of the property for which to extract value
* @param properties The properties object * @param properties The properties object

6
hibernate-core/src/main/java/org/hibernate/internal/util/xml/DTDEntityResolver.java
View File

@ -20,11 +20,11 @@ import org.xml.sax.InputSource;
/** /**
* An {@link EntityResolver} implementation which attempts to resolve * An {@link EntityResolver} implementation which attempts to resolve
* various systemId URLs to local classpath look ups<ol> * various systemId URLs to local classpath look ups<ol>
* <li>Any systemId URL beginning with <tt>http://www.hibernate.org/dtd/</tt> is * <li>Any systemId URL beginning with {@code http://www.hibernate.org/dtd/} is
* searched for as a classpath resource in the classloader which loaded the * searched for as a classpath resource in the classloader which loaded the
* Hibernate classes.</li> * Hibernate classes.</li>
* <li>Any systemId URL using <tt>classpath</tt> as the scheme (i.e. starting * <li>Any systemId URL using {@code classpath} as the scheme (i.e. starting
* with <tt>classpath://</tt> is searched for as a classpath resource using first * with {@code classpath://} is searched for as a classpath resource using first
* the current thread context classloader and then the classloader which loaded * the current thread context classloader and then the classloader which loaded
* the Hibernate classes. * the Hibernate classes.
* </ol> * </ol>

2
hibernate-core/src/main/java/org/hibernate/mapping/IdentifierBag.java
View File

@ -13,7 +13,7 @@ import org.hibernate.type.CollectionType;
import org.hibernate.type.IdentifierBagType; import org.hibernate.type.IdentifierBagType;
/** /**
* An <tt>IdentifierBag</tt> has a primary key consisting of * An {@code IdentifierBag} has a primary key consisting of
* just the identifier column * just the identifier column
*/ */
public class IdentifierBag extends IdentifierCollection { public class IdentifierBag extends IdentifierCollection {

2
hibernate-core/src/main/java/org/hibernate/metadata/ClassMetadata.java
View File

@ -257,7 +257,7 @@ public interface ClassMetadata {
/** /**
* Does the class implement the <tt>Lifecycle</tt> interface? * Does the class implement the {@code Lifecycle} interface?
*/ */
@SuppressWarnings( {"UnusedDeclaration"}) @SuppressWarnings( {"UnusedDeclaration"})
boolean implementsLifecycle(); boolean implementsLifecycle();

14
hibernate-core/src/main/java/org/hibernate/persister/collection/AbstractCollectionPersister.java
View File

@ -135,7 +135,7 @@ import org.hibernate.type.Type;
import org.jboss.logging.Logger; import org.jboss.logging.Logger;
/** /**
* Base implementation of the <tt>QueryableCollection</tt> interface. * Base implementation of the {@code QueryableCollection} interface.
* *
* @author Gavin King * @author Gavin King
* @see BasicCollectionPersister * @see BasicCollectionPersister
@ -1017,7 +1017,7 @@ public abstract class AbstractCollectionPersister
} }
/** /**
* Write the key to a JDBC <tt>PreparedStatement</tt> * Write the key to a JDBC {@code PreparedStatement}
*/ */
protected int writeKey(PreparedStatement st, Object key, int i, SharedSessionContractImplementor session) protected int writeKey(PreparedStatement st, Object key, int i, SharedSessionContractImplementor session)
throws HibernateException, SQLException { throws HibernateException, SQLException {
@ -1030,7 +1030,7 @@ public abstract class AbstractCollectionPersister
} }
/** /**
* Write the element to a JDBC <tt>PreparedStatement</tt> * Write the element to a JDBC {@code PreparedStatement}
*/ */
protected int writeElement(PreparedStatement st, Object elt, int i, SharedSessionContractImplementor session) protected int writeElement(PreparedStatement st, Object elt, int i, SharedSessionContractImplementor session)
throws HibernateException, SQLException { throws HibernateException, SQLException {
@ -1049,7 +1049,7 @@ public abstract class AbstractCollectionPersister
} }
/** /**
* Write the index to a JDBC <tt>PreparedStatement</tt> * Write the index to a JDBC {@code PreparedStatement}
*/ */
protected int writeIndex(PreparedStatement st, Object index, int i, SharedSessionContractImplementor session) protected int writeIndex(PreparedStatement st, Object index, int i, SharedSessionContractImplementor session)
throws HibernateException, SQLException { throws HibernateException, SQLException {
@ -1074,7 +1074,7 @@ public abstract class AbstractCollectionPersister
} }
/** /**
* Write the element to a JDBC <tt>PreparedStatement</tt> * Write the element to a JDBC {@code PreparedStatement}
*/ */
protected int writeElementToWhere(PreparedStatement st, Object elt, int i, SharedSessionContractImplementor session) protected int writeElementToWhere(PreparedStatement st, Object elt, int i, SharedSessionContractImplementor session)
throws HibernateException, SQLException { throws HibernateException, SQLException {
@ -1093,7 +1093,7 @@ public abstract class AbstractCollectionPersister
} }
/** /**
* Write the index to a JDBC <tt>PreparedStatement</tt> * Write the index to a JDBC {@code PreparedStatement}
*/ */
protected int writeIndexToWhere(PreparedStatement st, Object index, int i, SharedSessionContractImplementor session) protected int writeIndexToWhere(PreparedStatement st, Object index, int i, SharedSessionContractImplementor session)
throws HibernateException, SQLException { throws HibernateException, SQLException {
@ -1111,7 +1111,7 @@ public abstract class AbstractCollectionPersister
} }
/** /**
* Write the identifier to a JDBC <tt>PreparedStatement</tt> * Write the identifier to a JDBC {@code PreparedStatement}
*/ */
public int writeIdentifier(PreparedStatement st, Object id, int i, SharedSessionContractImplementor session) public int writeIdentifier(PreparedStatement st, Object id, int i, SharedSessionContractImplementor session)
throws HibernateException, SQLException { throws HibernateException, SQLException {

4
hibernate-core/src/main/java/org/hibernate/persister/collection/CollectionPersister.java
View File

@ -46,7 +46,7 @@ import org.hibernate.type.Type;
* Implements persistence of a collection instance while the instance is * Implements persistence of a collection instance while the instance is
* referenced in a particular role. * referenced in a particular role.
* <p> * <p>
* This class is highly coupled to the <tt>PersistentCollection</tt> * This class is highly coupled to the {@code PersistentCollection}
* hierarchy, since double dispatch is used to load and update collection * hierarchy, since double dispatch is used to load and update collection
* elements. * elements.
* <p> * <p>
@ -95,7 +95,7 @@ public interface CollectionPersister extends CollectionDefinition, Restrictable
*/ */
CacheEntryStructure getCacheEntryStructure(); CacheEntryStructure getCacheEntryStructure();
/** /**
* Get the associated <tt>Type</tt> * Get the associated {@code Type}
*/ */
CollectionType getCollectionType(); CollectionType getCollectionType();
/** /**

2
hibernate-core/src/main/java/org/hibernate/persister/collection/QueryableCollection.java
View File

@ -68,7 +68,7 @@ public interface QueryableCollection extends PropertyMapping, Joinable, Collecti
* Get the persister of the element class, if this is a * Get the persister of the element class, if this is a
* collection of entities (optional operation). Note that * collection of entities (optional operation). Note that
* for a one-to-many association, the returned persister * for a one-to-many association, the returned persister
* must be <tt>OuterJoinLoadable</tt>. * must be {@code OuterJoinLoadable}.
*/ */
public abstract EntityPersister getElementPersister(); public abstract EntityPersister getElementPersister();
/** /**

12
hibernate-core/src/main/java/org/hibernate/persister/entity/AbstractEntityPersister.java
View File

@ -4200,16 +4200,16 @@ public abstract class AbstractEntityPersister
} }
/** /**
* Load an instance using either the <tt>forUpdateLoader</tt> or the outer joining <tt>loader</tt>, * Load an instance using either the {@code forUpdateLoader} or the outer joining {@code loader},
* depending upon the value of the <tt>lock</tt> parameter * depending upon the value of the {@code lock} parameter
*/ */
public Object load(Object id, Object optionalObject, LockMode lockMode, SharedSessionContractImplementor session) { public Object load(Object id, Object optionalObject, LockMode lockMode, SharedSessionContractImplementor session) {
return load( id, optionalObject, new LockOptions().setLockMode( lockMode ), session ); return load( id, optionalObject, new LockOptions().setLockMode( lockMode ), session );
} }
/** /**
* Load an instance using either the <tt>forUpdateLoader</tt> or the outer joining <tt>loader</tt>, * Load an instance using either the {@code forUpdateLoader} or the outer joining {@code loader},
* depending upon the value of the <tt>lock</tt> parameter * depending upon the value of the {@code lock} parameter
*/ */
public Object load(Object id, Object optionalObject, LockOptions lockOptions, SharedSessionContractImplementor session) public Object load(Object id, Object optionalObject, LockOptions lockOptions, SharedSessionContractImplementor session)
throws HibernateException { throws HibernateException {
@ -4423,7 +4423,7 @@ public abstract class AbstractEntityPersister
* @param entity The entity for which we are checking state dirtiness. * @param entity The entity for which we are checking state dirtiness.
* @param session The session in which the check is occurring. * @param session The session in which the check is occurring.
* *
* @return <tt>null</tt> or the indices of the dirty properties * @return {@code null} or the indices of the dirty properties
* *
* @throws HibernateException * @throws HibernateException
*/ */
@ -4453,7 +4453,7 @@ public abstract class AbstractEntityPersister
* @param entity The entity for which we are checking state modification. * @param entity The entity for which we are checking state modification.
* @param session The session in which the check is occurring. * @param session The session in which the check is occurring.
* *
* @return <tt>null</tt> or the indices of the modified properties * @return {@code null} or the indices of the modified properties
* *
* @throws HibernateException * @throws HibernateException
*/ */

10
hibernate-core/src/main/java/org/hibernate/persister/entity/EntityPersister.java
View File

@ -893,12 +893,12 @@ public interface EntityPersister
* However, we still need to account for possible subclassing and potentially re-route to the more appropriate * However, we still need to account for possible subclassing and potentially re-route to the more appropriate
* persister. * persister.
* <p/> * <p/>
* For example, a request names <tt>Animal</tt> as the entity-name which gets resolved to this persister. But the * For example, a request names {@code Animal} as the entity-name which gets resolved to this persister. But the
* actual instance is really an instance of <tt>Cat</tt> which is a subclass of <tt>Animal</tt>. So, here the * actual instance is really an instance of {@code Cat} which is a subclass of {@code Animal}. So, here the
* <tt>Animal</tt> persister is being asked to return the persister specific to <tt>Cat</tt>. * {@code Animal} persister is being asked to return the persister specific to {@code Cat}.
* <p/> * <p/>
* It is also possible that the instance is actually an <tt>Animal</tt> instance in the above example in which * It is also possible that the instance is actually an {@code Animal} instance in the above example in which
* case we would return <tt>this</tt> from this method. * case we would return {@code this} from this method.
* *
* @param instance The entity instance * @param instance The entity instance
* @param factory Reference to the SessionFactory * @param factory Reference to the SessionFactory

2
hibernate-core/src/main/java/org/hibernate/persister/entity/JoinedSubclassEntityPersister.java
View File

@ -72,7 +72,7 @@ import org.jboss.logging.Logger;
import static java.util.Collections.emptyMap; import static java.util.Collections.emptyMap;
/** /**
* An <tt>EntityPersister</tt> implementing the normalized "table-per-subclass" * An {@code EntityPersister} implementing the normalized "table-per-subclass"
* mapping strategy * mapping strategy
* *
* @author Gavin King * @author Gavin King

4
hibernate-core/src/main/java/org/hibernate/persister/entity/Loadable.java
View File

@ -14,8 +14,8 @@ import org.hibernate.engine.spi.SharedSessionContractImplementor;
import org.hibernate.type.Type; import org.hibernate.type.Type;
/** /**
* Implemented by a <tt>EntityPersister</tt> that may be loaded * Implemented by a {@code EntityPersister} that may be loaded
* using <tt>Loader</tt>. * using {@code Loader}.
* *
* @author Gavin King * @author Gavin King
*/ */

4
hibernate-core/src/main/java/org/hibernate/persister/entity/OuterJoinLoadable.java
View File

@ -11,8 +11,8 @@ import org.hibernate.type.EntityType;
import org.hibernate.type.Type; import org.hibernate.type.Type;
/** /**
* A <tt>EntityPersister</tt> that may be loaded by outer join using * A {@code EntityPersister} that may be loaded by outer join using
* the <tt>OuterJoinLoader</tt> hierarchy and may be an element * the {@code OuterJoinLoader} hierarchy and may be an element
* of a one-to-many association. * of a one-to-many association.
* *
* @see org.hibernate.loader.OuterJoinLoader * @see org.hibernate.loader.OuterJoinLoader

2
hibernate-core/src/main/java/org/hibernate/persister/entity/Queryable.java
View File

@ -7,7 +7,7 @@
package org.hibernate.persister.entity; package org.hibernate.persister.entity;
/** /**
* Extends the generic <tt>EntityPersister</tt> contract to add * Extends the generic {@code EntityPersister} contract to add
* operations required by the Hibernate Query Language * operations required by the Hibernate Query Language
* *
* @author Gavin King * @author Gavin King

2
hibernate-core/src/main/java/org/hibernate/persister/entity/SingleTableEntityPersister.java
View File

@ -67,7 +67,7 @@ import org.hibernate.type.Type;
import org.hibernate.type.descriptor.java.JavaType; import org.hibernate.type.descriptor.java.JavaType;
/** /**
* The default implementation of the <tt>EntityPersister</tt> interface. * The default implementation of the {@code EntityPersister} interface.
* Implements the "table-per-class-hierarchy" or "roll-up" mapping strategy * Implements the "table-per-class-hierarchy" or "roll-up" mapping strategy
* for an entity class and its inheritance hierarchy. This is implemented * for an entity class and its inheritance hierarchy. This is implemented
* as a single table holding all classes in the hierarchy with a discriminator * as a single table holding all classes in the hierarchy with a discriminator

42
hibernate-core/src/main/java/org/hibernate/query/Query.java
View File

@ -120,9 +120,9 @@ public interface Query<R> extends TypedQuery<R>, CommonQueryContract {
ScrollableResults<R> scroll(ScrollMode scrollMode); ScrollableResults<R> scroll(ScrollMode scrollMode);
/** /**
* Return the query results as a <tt>List</tt>. If the query contains * Return the query results as a {@code List}. If the query contains
* multiple results per row, the results are returned in an instance * multiple results per row, the results are returned in an instance
* of <tt>Object[]</tt>. * of {@code Object[]}.
* *
* @return the result list * @return the result list
*/ */
@ -140,7 +140,7 @@ public interface Query<R> extends TypedQuery<R>, CommonQueryContract {
* Convenience method to return a single instance that matches * Convenience method to return a single instance that matches
* the query, or {@code null} if the query returns no results. * the query, or {@code null} if the query returns no results.
* *
* @return the single result or <tt>null</tt> * @return the single result or {@code null}
* *
* @throws NonUniqueResultException if there is more than one matching result * @throws NonUniqueResultException if there is more than one matching result
*/ */
@ -228,7 +228,7 @@ public interface Query<R> extends TypedQuery<R>, CommonQueryContract {
Query<R> setLockOptions(LockOptions lockOptions); Query<R> setLockOptions(LockOptions lockOptions);
/** /**
* Set the LockMode to use for specific alias (as defined in the query's <tt>FROM</tt> clause). * Set the LockMode to use for specific alias (as defined in the query's {@code FROM} clause).
* <p> * <p>
* The alias-specific lock modes specified here are added to the query's internal * The alias-specific lock modes specified here are added to the query's internal
* {@link #getLockOptions() LockOptions}. * {@link #getLockOptions() LockOptions}.
@ -298,7 +298,7 @@ public interface Query<R> extends TypedQuery<R>, CommonQueryContract {
* Bind a value to a JDBC-style query parameter. * Bind a value to a JDBC-style query parameter.
* *
* @param position the position of the parameter in the query * @param position the position of the parameter in the query
* string, numbered from <tt>0</tt>. * string, numbered from {@code 0}.
* @param val the possibly-null parameter value * @param val the possibly-null parameter value
* @param type the Hibernate allowable parameter type * @param type the Hibernate allowable parameter type
* *
@ -321,7 +321,7 @@ public interface Query<R> extends TypedQuery<R>, CommonQueryContract {
* Bind a value to a JDBC-style query parameter. * Bind a value to a JDBC-style query parameter.
* *
* @param position the position of the parameter in the query * @param position the position of the parameter in the query
* string, numbered from <tt>0</tt>. * string, numbered from {@code 0}.
* @param val the possibly-null parameter value * @param val the possibly-null parameter value
* @param type the Hibernate allowable parameter type * @param type the Hibernate allowable parameter type
* *
@ -346,7 +346,7 @@ public interface Query<R> extends TypedQuery<R>, CommonQueryContract {
* the indicated temporal-type. * the indicated temporal-type.
* *
* @param position the position of the parameter in the query * @param position the position of the parameter in the query
* string, numbered from <tt>0</tt>. * string, numbered from {@code 0}.
* @param val the possibly-null parameter value * @param val the possibly-null parameter value
* @param temporalType the temporal-type to use in binding the date/time * @param temporalType the temporal-type to use in binding the date/time
* *
@ -486,7 +486,7 @@ public interface Query<R> extends TypedQuery<R>, CommonQueryContract {
* should be used instead * should be used instead
* *
* @param position the position of the parameter in the query * @param position the position of the parameter in the query
* string, numbered from <tt>0</tt>. * string, numbered from {@code 0}.
* @param value the possibly-null parameter value * @param value the possibly-null parameter value
* *
* @return {@code this}, for method chaining * @return {@code this}, for method chaining
@ -521,7 +521,7 @@ public interface Query<R> extends TypedQuery<R>, CommonQueryContract {
* Bind multiple values to a query parameter using its inferred Type. The Hibernate type of the parameter values is * Bind multiple values to a query parameter using its inferred Type. The Hibernate type of the parameter values is
* first detected via the usage/position in the query and if not sufficient secondly * first detected via the usage/position in the query and if not sufficient secondly
* guessed from the class of the first object in the collection. This is useful for binding a list of values * guessed from the class of the first object in the collection. This is useful for binding a list of values
* to an expression such as <tt>foo.bar in (:value_list)</tt>. * to an expression such as {@code foo.bar in (:value_list)}.
* *
* @param parameter the parameter memento * @param parameter the parameter memento
* @param values a collection of values to list * @param values a collection of values to list
@ -534,7 +534,7 @@ public interface Query<R> extends TypedQuery<R>, CommonQueryContract {
* Bind multiple values to a named query parameter. The Hibernate type of the parameter is * Bind multiple values to a named query parameter. The Hibernate type of the parameter is
* first detected via the usage/position in the query and if not sufficient secondly * first detected via the usage/position in the query and if not sufficient secondly
* guessed from the class of the first object in the collection. This is useful for binding a list of values * guessed from the class of the first object in the collection. This is useful for binding a list of values
* to an expression such as <tt>foo.bar in (:value_list)</tt>. * to an expression such as {@code foo.bar in (:value_list)}.
* *
* @param name the name of the parameter * @param name the name of the parameter
* @param values a collection of values to list * @param values a collection of values to list
@ -547,7 +547,7 @@ public interface Query<R> extends TypedQuery<R>, CommonQueryContract {
* Bind multiple values to a positional query parameter. The Hibernate type of the parameter is * Bind multiple values to a positional query parameter. The Hibernate type of the parameter is
* first detected via the usage/position in the query and if not sufficient secondly * first detected via the usage/position in the query and if not sufficient secondly
* guessed from the class of the first object in the collection. This is useful for binding a list of values * guessed from the class of the first object in the collection. This is useful for binding a list of values
* to an expression such as <tt>foo.bar in (:value_list)</tt>. * to an expression such as {@code foo.bar in (:value_list)}.
* *
* @param position the parameter positional label * @param position the parameter positional label
* @param values a collection of values to list * @param values a collection of values to list
@ -560,7 +560,7 @@ public interface Query<R> extends TypedQuery<R>, CommonQueryContract {
* Bind multiple values to a named query parameter. The Hibernate type of the parameter is * Bind multiple values to a named query parameter. The Hibernate type of the parameter is
* first detected via the usage/position in the query and if not sufficient secondly * first detected via the usage/position in the query and if not sufficient secondly
* guessed from the class of the first object in the collection. This is useful for binding a list of values * guessed from the class of the first object in the collection. This is useful for binding a list of values
* to an expression such as <tt>foo.bar in (:value_list)</tt>. * to an expression such as {@code foo.bar in (:value_list)}.
* *
* @param name the name of the parameter * @param name the name of the parameter
* @param values a collection of values to list * @param values a collection of values to list
@ -573,7 +573,7 @@ public interface Query<R> extends TypedQuery<R>, CommonQueryContract {
* Bind multiple values to a positional query parameter. The Hibernate type of the parameter is * Bind multiple values to a positional query parameter. The Hibernate type of the parameter is
* first detected via the usage/position in the query and if not sufficient secondly * first detected via the usage/position in the query and if not sufficient secondly
* guessed from the class of the first object in the collection. This is useful for binding a list of values * guessed from the class of the first object in the collection. This is useful for binding a list of values
* to an expression such as <tt>foo.bar in (:value_list)</tt>. * to an expression such as {@code foo.bar in (:value_list)}.
* *
* @param position the parameter positional label * @param position the parameter positional label
* @param values a collection of values to list * @param values a collection of values to list
@ -584,7 +584,7 @@ public interface Query<R> extends TypedQuery<R>, CommonQueryContract {
// /** // /**
// * Bind multiple values to a named query parameter. This is useful for binding // * Bind multiple values to a named query parameter. This is useful for binding
// * a list of values to an expression such as <tt>foo.bar in (:value_list)</tt>. // * a list of values to an expression such as {@code foo.bar in (:value_list)}.
// * // *
// * @param name the name of the parameter // * @param name the name of the parameter
// * @param values a collection of values to list // * @param values a collection of values to list
@ -601,7 +601,7 @@ public interface Query<R> extends TypedQuery<R>, CommonQueryContract {
// /** // /**
// * Bind multiple values to a named query parameter. This is useful for binding // * Bind multiple values to a named query parameter. This is useful for binding
// * a list of values to an expression such as <tt>foo.bar in (:value_list)</tt>. // * a list of values to an expression such as {@code foo.bar in (:value_list)}.
// * // *
// * @param position the parameter positional label // * @param position the parameter positional label
// * @param values a collection of values to list // * @param values a collection of values to list
@ -618,7 +618,7 @@ public interface Query<R> extends TypedQuery<R>, CommonQueryContract {
/** /**
* Bind multiple values to a named query parameter. This is useful for binding * Bind multiple values to a named query parameter. This is useful for binding
* a list of values to an expression such as <tt>foo.bar in (:value_list)</tt>. * a list of values to an expression such as {@code foo.bar in (:value_list)}.
* *
* @param name the name of the parameter * @param name the name of the parameter
* @param values a collection of values to list * @param values a collection of values to list
@ -630,7 +630,7 @@ public interface Query<R> extends TypedQuery<R>, CommonQueryContract {
/** /**
* Bind multiple values to a positional query parameter. This is useful for binding * Bind multiple values to a positional query parameter. This is useful for binding
* a list of values to an expression such as <tt>foo.bar in (?1)</tt>. * a list of values to an expression such as {@code foo.bar in (?1)}.
* *
* @param position the parameter positional label * @param position the parameter positional label
* @param values a collection of values to list * @param values a collection of values to list
@ -642,7 +642,7 @@ public interface Query<R> extends TypedQuery<R>, CommonQueryContract {
/** /**
* Bind multiple values to a named query parameter. This is useful for binding * Bind multiple values to a named query parameter. This is useful for binding
* a list of values to an expression such as <tt>foo.bar in (:value_list)</tt>. * a list of values to an expression such as {@code foo.bar in (:value_list)}.
* *
* @param name the name of the parameter * @param name the name of the parameter
* @param values a collection of values to list * @param values a collection of values to list
@ -654,7 +654,7 @@ public interface Query<R> extends TypedQuery<R>, CommonQueryContract {
/** /**
* Bind multiple values to a named query parameter. This is useful for binding * Bind multiple values to a named query parameter. This is useful for binding
* a list of values to an expression such as <tt>foo.bar in (:value_list)</tt>. * a list of values to an expression such as {@code foo.bar in (:value_list)}.
* *
* @param position the parameter positional label * @param position the parameter positional label
* @param values a collection of values to list * @param values a collection of values to list
@ -668,7 +668,7 @@ public interface Query<R> extends TypedQuery<R>, CommonQueryContract {
* Bind multiple values to a named query parameter. The Hibernate type of the parameter is * Bind multiple values to a named query parameter. The Hibernate type of the parameter is
* first detected via the usage/position in the query and if not sufficient secondly * first detected via the usage/position in the query and if not sufficient secondly
* guessed from the class of the first object in the array. This is useful for binding a list of values * guessed from the class of the first object in the array. This is useful for binding a list of values
* to an expression such as <tt>foo.bar in (:value_list)</tt>. * to an expression such as {@code foo.bar in (:value_list)}.
* *
* @param name the name of the parameter * @param name the name of the parameter
* @param values a collection of values to list * @param values a collection of values to list
@ -681,7 +681,7 @@ public interface Query<R> extends TypedQuery<R>, CommonQueryContract {
* Bind multiple values to a named query parameter. The Hibernate type of the parameter is * Bind multiple values to a named query parameter. The Hibernate type of the parameter is
* first detected via the usage/position in the query and if not sufficient secondly * first detected via the usage/position in the query and if not sufficient secondly
* guessed from the class of the first object in the array. This is useful for binding a list of values * guessed from the class of the first object in the array. This is useful for binding a list of values
* to an expression such as <tt>foo.bar in (:value_list)</tt>. * to an expression such as {@code foo.bar in (:value_list)}.
* *
* @param position the parameter positional label * @param position the parameter positional label
* @param values a collection of values to list * @param values a collection of values to list

2
hibernate-core/src/main/java/org/hibernate/sql/Delete.java
View File

@ -12,7 +12,7 @@ import java.util.Map;
import org.hibernate.dialect.Dialect; import org.hibernate.dialect.Dialect;
/** /**
* An SQL <tt>DELETE</tt> statement * An SQL {@code DELETE} statement
* *
* @author Gavin King * @author Gavin King
*/ */

2
hibernate-core/src/main/java/org/hibernate/sql/Insert.java
View File

@ -13,7 +13,7 @@ import org.hibernate.MappingException;
import org.hibernate.dialect.Dialect; import org.hibernate.dialect.Dialect;
/** /**
* An SQL <tt>INSERT</tt> statement * An SQL {@code INSERT} statement
* *
* @author Gavin King * @author Gavin King
*/ */

2
hibernate-core/src/main/java/org/hibernate/sql/SimpleSelect.java
View File

@ -19,7 +19,7 @@ import org.hibernate.LockOptions;
import org.hibernate.dialect.Dialect; import org.hibernate.dialect.Dialect;
/** /**
* An SQL <tt>SELECT</tt> statement with no table joins * An SQL {@code SELECT} statement with no table joins
* *
* @author Gavin King * @author Gavin King
*/ */

2
hibernate-core/src/main/java/org/hibernate/sql/Update.java
View File

@ -12,7 +12,7 @@ import java.util.Map;
import org.hibernate.dialect.Dialect; import org.hibernate.dialect.Dialect;
/** /**
* An SQL <tt>UPDATE</tt> statement * An SQL {@code UPDATE} statement
* *
* @author Gavin King * @author Gavin King
*/ */

2
hibernate-core/src/main/java/org/hibernate/sql/results/graph/entity/AbstractEntityInitializer.java
View File

@ -453,7 +453,7 @@ public abstract class AbstractEntityInitializer extends AbstractFetchParentAcces
} }
/** /**
* Check the version of the object in the <tt>RowProcessingState</tt> against * Check the version of the object in the {@code RowProcessingState} against
* the object version in the session cache, throwing an exception * the object version in the session cache, throwing an exception
* if the version numbers are different * if the version numbers are different
*/ */

4
hibernate-core/src/main/java/org/hibernate/stat/SessionStatistics.java
View File

@ -24,12 +24,12 @@ public interface SessionStatistics {
int getCollectionCount(); int getCollectionCount();
/** /**
* Get the set of all <tt>EntityKey</tt>s * Get the set of all {@code EntityKey}s
* @see org.hibernate.engine.spi.EntityKey * @see org.hibernate.engine.spi.EntityKey
*/ */
Set getEntityKeys(); Set getEntityKeys();
/** /**
* Get the set of all <tt>CollectionKey</tt>s * Get the set of all {@code CollectionKey}s
* @see org.hibernate.engine.spi.CollectionKey * @see org.hibernate.engine.spi.CollectionKey
*/ */
Set getCollectionKeys(); Set getCollectionKeys();

2
hibernate-core/src/main/java/org/hibernate/stat/Statistics.java
View File

@ -339,7 +339,7 @@ public interface Statistics {
long getCloseStatementCount(); long getCloseStatementCount();
/** /**
* The number of Hibernate <tt>StaleObjectStateException</tt>s or JPA <tt>OptimisticLockException</tt>s * The number of Hibernate {@code StaleObjectStateException}s or JPA {@code OptimisticLockException}s
* that occurred. * that occurred.
*/ */
long getOptimisticFailureCount(); long getOptimisticFailureCount();

4
hibernate-core/src/main/java/org/hibernate/transform/Transformers.java
View File

@ -12,13 +12,13 @@ final public class Transformers {
private Transformers() {} private Transformers() {}
/** /**
* Each row of results is a <tt>Map</tt> from alias to values/entities * Each row of results is a {@code Map} from alias to values/entities
*/ */
public static final AliasToEntityMapResultTransformer ALIAS_TO_ENTITY_MAP = public static final AliasToEntityMapResultTransformer ALIAS_TO_ENTITY_MAP =
AliasToEntityMapResultTransformer.INSTANCE; AliasToEntityMapResultTransformer.INSTANCE;
/** /**
* Each row of results is a <tt>List</tt> * Each row of results is a {@code List}
*/ */
public static final ToListResultTransformer TO_LIST = ToListResultTransformer.INSTANCE; public static final ToListResultTransformer TO_LIST = ToListResultTransformer.INSTANCE;

10
hibernate-core/src/main/java/org/hibernate/tuple/entity/EntityTuplizer.java
View File

@ -69,13 +69,13 @@ public interface EntityTuplizer extends Tuplizer {
* asked to determine if there is a more appropriate entity-name to use, specifically within an inheritance * asked to determine if there is a more appropriate entity-name to use, specifically within an inheritance
* hierarchy. * hierarchy.
* <p/> * <p/>
* For example, consider a case where a user calls <tt>session.update( "Animal", cat );</tt>. Here, the * For example, consider a case where a user calls {@code session.update( "Animal", cat );}. Here, the
* user has explicitly provided <tt>Animal</tt> as the entity-name. However, they have passed in an instance * user has explicitly provided {@code Animal} as the entity-name. However, they have passed in an instance
* of <tt>Cat</tt> which is a subclass of <tt>Animal</tt>. In this case, we would return <tt>Cat</tt> as the * of {@code Cat} which is a subclass of {@code Animal}. In this case, we would return {@code Cat} as the
* entity-name. * entity-name.
* <p/> * <p/>
* <tt>null</tt> may be returned from calls to this method. The meaning of <tt>null</tt> in that case is assumed * {@code null} may be returned from calls to this method. The meaning of {@code null} in that case is assumed
* to be that we should use whatever explicit entity-name the user provided (<tt>Animal</tt> rather than <tt>Cat</tt> * to be that we should use whatever explicit entity-name the user provided ({@code Animal} rather than {@code Cat}
* in the example above). * in the example above).
* *
* @param entityInstance The entity instance. * @param entityInstance The entity instance.

4
hibernate-core/src/main/java/org/hibernate/type/CollectionType.java
View File

@ -50,7 +50,7 @@ import org.hibernate.type.spi.TypeConfiguration;
import org.jboss.logging.Logger; import org.jboss.logging.Logger;
/** /**
* A type that handles Hibernate <tt>PersistentCollection</tt>s (including arrays). * A type that handles Hibernate {@code PersistentCollection}s (including arrays).
* *
* @author Gavin King * @author Gavin King
*/ */
@ -365,7 +365,7 @@ public abstract class CollectionType extends AbstractType implements Association
public abstract PersistentCollection wrap(SharedSessionContractImplementor session, Object collection); public abstract PersistentCollection wrap(SharedSessionContractImplementor session, Object collection);
/** /**
* Note: return true because this type is castable to <tt>AssociationType</tt>. Not because * Note: return true because this type is castable to {@code AssociationType}. Not because
* all collections are associations. * all collections are associations.
*/ */
@Override @Override

2
hibernate-core/src/main/java/org/hibernate/type/CustomCollectionType.java
View File

@ -20,7 +20,7 @@ import org.hibernate.usertype.LoggableUserType;
import org.hibernate.usertype.UserCollectionType; import org.hibernate.usertype.UserCollectionType;
/** /**
* A custom type for mapping user-written classes that implement <tt>PersistentCollection</tt> * A custom type for mapping user-written classes that implement {@code PersistentCollection}
* *
* @see PersistentCollection * @see PersistentCollection
* @see UserCollectionType * @see UserCollectionType

2
hibernate-core/src/main/java/org/hibernate/type/DbTimestampType.java
View File

@ -20,7 +20,7 @@ import org.hibernate.type.descriptor.jdbc.TimestampJdbcType;
import org.jboss.logging.Logger; import org.jboss.logging.Logger;
/** /**
* <tt>dbtimestamp</tt>: A type that maps between {@link java.sql.Types#TIMESTAMP TIMESTAMP} and {@link Timestamp}. * {@code dbtimestamp}: A type that maps between {@link java.sql.Types#TIMESTAMP TIMESTAMP} and {@link Timestamp}.
* It maps to the database's current timestamp, rather than the jvm's * It maps to the database's current timestamp, rather than the jvm's
* current timestamp. * current timestamp.
* <p/> * <p/>

4
hibernate-core/src/main/java/org/hibernate/type/Type.java
View File

@ -286,7 +286,7 @@ public interface Type extends Serializable {
/** /**
* Bind a value represented by an instance of the {@link #getReturnedClass() mapped class} to the JDBC prepared * Bind a value represented by an instance of the {@link #getReturnedClass() mapped class} to the JDBC prepared
* statement, ignoring some columns as dictated by the 'settable' parameter. Implementors should handle the * statement, ignoring some columns as dictated by the 'settable' parameter. Implementors should handle the
* possibility of null values. A multi-column type should bind parameters starting from <tt>index</tt>. * possibility of null values. A multi-column type should bind parameters starting from {@code index}.
* *
* @param st The JDBC prepared statement to which to bind * @param st The JDBC prepared statement to which to bind
* @param value the object to write * @param value the object to write
@ -308,7 +308,7 @@ public interface Type extends Serializable {
/** /**
* Bind a value represented by an instance of the {@link #getReturnedClass() mapped class} to the JDBC prepared * Bind a value represented by an instance of the {@link #getReturnedClass() mapped class} to the JDBC prepared
* statement. Implementors should handle possibility of null values. A multi-column type should bind parameters * statement. Implementors should handle possibility of null values. A multi-column type should bind parameters
* starting from <tt>index</tt>. * starting from {@code index}.
* *
* @param st The JDBC prepared statement to which to bind * @param st The JDBC prepared statement to which to bind
* @param value the object to write * @param value the object to write

2
hibernate-core/src/main/java/org/hibernate/type/descriptor/java/MutabilityPlan.java
View File

@ -18,7 +18,7 @@ import org.hibernate.SharedSessionContract;
*/ */
public interface MutabilityPlan<T> extends Serializable { public interface MutabilityPlan<T> extends Serializable {
/** /**
* Can the internal state of instances of <tt>T</tt> be changed? * Can the internal state of instances of {@code T} be changed?
* *
* @return True if the internal state can be changed; false otherwise. * @return True if the internal state can be changed; false otherwise.
*/ */

Some files were not shown because too many files have changed in this diff Show More