replace use of <br> with <p> in all the javadoc

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

@@ -9,8 +9,8 @@ package org.hibernate;
 /**
  * Represents an association fetching strategy. This is used
  * together with the <tt>Criteria</tt> API to specify runtime
- * fetching strategies.<br>
+ * fetching strategies.
- * <br>
+ * <p>
  * For HQL queries, use the <tt>FETCH</tt> keyword instead.
  *
  * @see Criteria#setFetchMode(String, FetchMode)

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

@@ -23,8 +23,8 @@ public enum LockMode {
 	 * No lock required. If an object is requested with this lock
 	 * mode, a <tt>READ</tt> lock will be obtained if it is
 	 * necessary to actually read the state from the database,
-	 * rather than pull it from a cache.<br>
+	 * rather than pull it from a cache.
-	 * <br>
+	 * <p>
 	 * This is the "default" lock mode.
 	 */
 	NONE( 0, "none" ),

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

@@ -12,8 +12,8 @@ package org.hibernate;
  * be thrown when <tt>load()</tt> is called, even if there was no
  * row on the database, because <tt>load()</tt> returns a proxy if
  * possible. Applications should use <tt>Session.get()</tt> to test if
- * a row exists in the database.<br>
+ * a row exists in the database.
- * <br> 
+ * <p>
  * Like all Hibernate exceptions, this exception is considered 
  * unrecoverable.
  *

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

@@ -15,8 +15,8 @@ import org.hibernate.query.Query;
  * by arbitrary increments. The <tt>Query</tt> / <tt>ScrollableResults</tt>
  * pattern is very similar to the JDBC <tt>PreparedStatement</tt>/
  * <tt>ResultSet</tt> pattern and the semantics of methods of this interface
- * are similar to the similarly named methods on <tt>ResultSet</tt>.<br>
+ * are similar to the similarly named methods on <tt>ResultSet</tt>.
- * <br>
+ * <p>
  * Contrary to JDBC, columns of results are numbered from zero.
  *
  * @see Query#scroll()

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

@@ -21,37 +21,37 @@ import org.hibernate.stat.SessionStatistics;
 
 /**
  * The main runtime interface between a Java application and Hibernate. This is the
- * central API class abstracting the notion of a persistence service.<br>
+ * central API class abstracting the notion of a persistence service.
- * <br>
+ * <p>
  * The lifecycle of a <tt>Session</tt> is bounded by the beginning and end of a logical
- * transaction. (Long transactions might span several database transactions.)<br>
+ * transaction. (Long transactions might span several database transactions.)
- * <br>
+ * <p>
  * The main function of the <tt>Session</tt> is to offer create, read and delete operations
- * for instances of mapped entity classes. Instances may exist in one of three states:<br>
+ * for instances of mapped entity classes. Instances may exist in one of three states:
- * <br>
+ * <ul>
- * <i>transient:</i> never persistent, not associated with any <tt>Session</tt><br>
+ * <li><i>transient:</i> never persistent, not associated with any <tt>Session</tt>
- * <i>persistent:</i> associated with a unique <tt>Session</tt><br>
+ * <li><i>persistent:</i> associated with a unique <tt>Session</tt>
- * <i>detached:</i> previously persistent, not associated with any <tt>Session</tt><br>
+ * <li><i>detached:</i> previously persistent, not associated with any <tt>Session</tt>
- * <br>
+ * </ul>
  * Transient instances may be made persistent by calling <tt>save()</tt>,
  * <tt>persist()</tt> or <tt>saveOrUpdate()</tt>. Persistent instances may be made transient
  * by calling<tt> delete()</tt>. Any instance returned by a <tt>get()</tt> or
  * <tt>load()</tt> method is persistent. Detached instances may be made persistent
  * by calling <tt>update()</tt>, <tt>saveOrUpdate()</tt>, <tt>lock()</tt> or <tt>replicate()</tt>. 
  * The state of a transient or detached instance may also be made persistent as a new
- * persistent instance by calling <tt>merge()</tt>.<br>
+ * persistent instance by calling <tt>merge()</tt>.
- * <br>
+ * <p>
  * <tt>save()</tt> and <tt>persist()</tt> result in an SQL <tt>INSERT</tt>, <tt>delete()</tt>
  * in an SQL <tt>DELETE</tt> and <tt>update()</tt> or <tt>merge()</tt> in an SQL <tt>UPDATE</tt>. 
  * 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
- * <tt>INSERT</tt> or an <tt>UPDATE</tt>.<br>
+ * <tt>INSERT</tt> or an <tt>UPDATE</tt>.
- * <br>
+ * <p>
  * It is not intended that implementors be threadsafe. Instead each thread/transaction
- * should obtain its own instance from a <tt>SessionFactory</tt>.<br>
+ * should obtain its own instance from a <tt>SessionFactory</tt>.
- * <br>
+ * <p>
- * A <tt>Session</tt> instance is serializable if its persistent classes are serializable.<br>
+ * A <tt>Session</tt> instance is serializable if its persistent classes are serializable.
- * <br>
+ * <p>
  * A typical transaction should use the following idiom:
  * <pre>
  * Session sess = factory.openSession();
@@ -70,7 +70,7 @@ import org.hibernate.stat.SessionStatistics;
  *     sess.close();
  * }
  * </pre>
- * <br>
+ * <p>
  * If the <tt>Session</tt> throws an exception, the transaction must be rolled back
  * and the session discarded. The internal state of the <tt>Session</tt> might not
  * be consistent with the database after the exception occurs.
@@ -332,7 +332,7 @@ public interface Session extends SharedSessionContract, EntityManager, AutoClose
 	 * Return the persistent instance of the given entity class with the given identifier,
 	 * assuming that the instance exists. This method might return a proxied instance that
 	 * is initialized on-demand, when a non-identifier method is accessed.
-	 * <br><br>
+	 * <p>
 	 * You should not use this method to determine if an instance exists (use <tt>get()</tt>
 	 * instead). Use this only to retrieve an instance that you assume exists, where non-existence
 	 * would be an actual error.
@@ -348,7 +348,7 @@ public interface Session extends SharedSessionContract, EntityManager, AutoClose
 	 * Return the persistent instance of the given entity class with the given identifier,
 	 * assuming that the instance exists. This method might return a proxied instance that
 	 * is initialized on-demand, when a non-identifier method is accessed.
-	 * <br><br>
+	 * <p>
 	 * You should not use this method to determine if an instance exists (use <tt>get()</tt>
 	 * instead). Use this only to retrieve an instance that you assume exists, where non-existence
 	 * would be an actual error.

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

@@ -159,8 +159,8 @@ public interface StatelessSession extends SharedSessionContract, AutoCloseable,
 
 	/**
 	 * Returns the current JDBC connection associated with this
-	 * instance.<br>
+	 * instance.
-	 * <br>
+	 * <p>
 	 * If the session is using aggressive connection release (as in a
 	 * CMT environment), it is the application's responsibility to
 	 * close the connection returned by this call. Otherwise, the

hibernate-core/src/main/java/org/hibernate/cfg/Environment.java

@@ -25,7 +25,7 @@ import org.jboss.logging.Logger;
 
 /**
  * Provides access to configuration info passed in <tt>Properties</tt> objects.
- * <br><br>
+ * <p>
  * Hibernate has two property scopes:
  * <ul>
  * <li><b>Factory-level</b> properties may be passed to the <tt>SessionFactory</tt> when it
@@ -41,14 +41,14 @@ import org.jboss.logging.Logger;
  * </ul>
  * <tt>Environment</tt> properties are populated by calling <tt>System.getProperties()</tt>
  * and then from a resource named <tt>/hibernate.properties</tt> if it exists. System
- * properties override properties specified in <tt>hibernate.properties</tt>.<br>
+ * properties override properties specified in <tt>hibernate.properties</tt>.
- * <br>
+ * <p>
  * The <tt>SessionFactory</tt> is controlled by the following properties.
  * Properties may be either be <tt>System</tt> properties, properties
  * defined in a resource named <tt>/hibernate.properties</tt> or an instance of
  * <tt>java.util.Properties</tt> passed to
- * <tt>Configuration.build()</tt><br>
+ * <tt>Configuration.build()</tt>
- * <br>
+ * <p>
  * <table>
  * <tr><td><b>property</b></td><td><b>meaning</b></td></tr>
  * <tr>

hibernate-core/src/main/java/org/hibernate/classic/Lifecycle.java

@@ -14,28 +14,29 @@ import java.io.Serializable;
 /**
  * Provides callbacks from the <tt>Session</tt> to the persistent object.
  * Persistent classes <b>may</b> implement this interface but they are not
- * required to.<br>
+ * required to.
- * <br>
+ * <ul>
- * <b>onSave:</b> called just before the object is saved<br>
+ * <li><b>onSave:</b> called just before the object is saved
- * <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<br>
+ * ie. when <tt>Session.update()</tt> is called
- * <b>onDelete:</b> called just before an object is deleted<br>
+ * <li><b>onDelete:</b> called just before an object is deleted
- * <b>onLoad:</b> called just after an object is loaded<br>
+ * <b>onLoad:</b> called just after an object is loaded
- * <br>
+ * </ul>
+ * <p>
  * <tt>onLoad()</tt> may be used to initialize transient properties of the
  * 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
- * invoked from inside this method.<br>
+ * invoked from inside this method.
- * <br>
+ * <p>
  * A further intended usage of <tt>onLoad()</tt>, <tt>onSave()</tt> and
  * <tt>onUpdate()</tt> is to store a reference to the <tt>Session</tt>
- * for later use.<br>
+ * for later use.
- * <br>
+ * <p>
  * If <tt>onSave()</tt>, <tt>onUpdate()</tt> or <tt>onDelete()</tt> return
  * <tt>VETO</tt>, the operation is silently vetoed. If a
  * <tt>CallbackException</tt> is thrown, the operation is vetoed and the
- * exception is passed back to the application.<br>
+ * exception is passed back to the application.
- * <br>
+ * <p>
  * Note that <tt>onSave()</tt> is called after an identifier is assigned
  * to the object, except when identity column key generation is used.
  *

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

@@ -28,8 +28,8 @@ import org.hibernate.type.Type;
  * a regular <tt>Bag</tt> by adding a synthetic identifier column to the
  * 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
- * to the application.<br>
+ * to the application.
- * <br>
+ * <p>
  * <tt>IdentifierBag</tt>s may not be used for a many-to-one association.
  * Furthermore, there is no reason to use <tt>inverse="true"</tt>.
  *

hibernate-core/src/main/java/org/hibernate/collection/spi/PersistentCollection.java

@@ -24,18 +24,18 @@ import org.hibernate.type.Type;
  * automatically deleted when unreferenced and automatically become
  * persistent when held by a persistent object. Collections can be
  * passed between different objects (change "roles") and this might
- * cause their elements to move from one database table to another.<br>
+ * cause their elements to move from one database table to another.
- * <br>
+ * <p>
  * Hibernate "wraps" a java collection in an instance of
  * PersistentCollection. This mechanism is designed to support
  * tracking of changes to the collection's persistent state and
  * lazy instantiation of collection elements. The downside is that
  * only certain abstract collection types are supported and any
- * extra semantics are lost<br>
+ * extra semantics are lost
- * <br>
+ * <p>
  * Applications should <em>never</em> use classes in this package
- * directly, unless extending the "framework" here.<br>
+ * directly, unless extending the "framework" here.
- * <br>
+ * <p>
  * Changes to <em>structure</em> of the collection are recorded by the
  * collection calling back to the session. Changes to mutable
  * elements (ie. composite elements) are discovered by cloning their

hibernate-core/src/main/java/org/hibernate/id/Assigned.java

@@ -16,8 +16,8 @@ import org.hibernate.service.ServiceRegistry;
 import org.hibernate.type.Type;
 
 /**
- * <b>assigned</b><br>
+ * <b>assigned</b>
- * <br>
+ * <p>
  * An <tt>IdentifierGenerator</tt> that returns the current identifier assigned
  * to an instance.
  *

hibernate-core/src/main/java/org/hibernate/id/ForeignGenerator.java

@@ -25,11 +25,11 @@ import org.hibernate.type.Type;
 import static org.hibernate.internal.CoreLogging.messageLogger;
 
 /**
- * <b>foreign</b><br>
+ * <b>foreign</b>
- * <br>
+ * <p>
  * An <tt>Identifier</tt> generator that uses the value of the id property of an
- * associated object<br>
+ * associated object
- * <br>
+ * <p>
  * One mapping parameter is required: property.
  *
  * @author Gavin King

hibernate-core/src/main/java/org/hibernate/id/IdentifierGenerator.java

@@ -23,13 +23,13 @@ import org.hibernate.type.Type;
  * identifiers and the <tt>Session</tt>. It is not intended that
  * this interface ever be exposed to the application. It <b>is</b>
  * intended that users implement this interface to provide
- * custom identifier generation strategies.<br>
+ * custom identifier generation strategies.
- * <br>
+ * <p>
- * Implementors should provide a public default constructor.<br>
+ * Implementors should provide a public default constructor.
- * <br>
+ * <p>
  * Implementations that accept configuration parameters should
  * also implement <tt>Configurable</tt>.
- * <br>
+ * <p>
  * Implementors <em>must</em> be thread-safe
  *
  * @author Gavin King

hibernate-core/src/main/java/org/hibernate/id/IdentityGenerator.java

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

hibernate-core/src/main/java/org/hibernate/id/IncrementGenerator.java

@@ -31,12 +31,12 @@ import org.hibernate.service.ServiceRegistry;
 import org.hibernate.type.Type;
 
 /**
- * <b>increment</b><br>
+ * <b>increment</b>
- * <br>
+ * <p>
  * An <tt>IdentifierGenerator</tt> that returns a <tt>long</tt>, constructed by
  * counting from the maximum primary key value at startup. Not safe for use in a
- * cluster!<br>
+ * cluster!
- * <br>
+ * <p>
  * Mapping parameters supported, but not usually needed: tables, column.
  * (The tables parameter specified a comma-separated list of table names.)
  *

hibernate-core/src/main/java/org/hibernate/id/PersistentIdentifierGenerator.java

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

hibernate-core/src/main/java/org/hibernate/id/UUIDHexGenerator.java

@@ -17,13 +17,13 @@ import org.hibernate.service.ServiceRegistry;
 import org.hibernate.type.Type;
 
 /**
- * <b>uuid</b><br>
+ * <b>uuid</b>
- * <br>
+ * <p>
  * A <tt>UUIDGenerator</tt> that returns a string of length 32,
  * This string will consist of only hex digits. Optionally,
  * the string may be generated with separators between each
  * component of the UUID.
- * <p/>
+ * <p>
  * Mapping parameters supported: separator.
  *
  * @author Gavin King

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

@@ -39,19 +39,20 @@ import org.hibernate.type.Type;
  * A strategy for persisting a collection role. Defines a contract between
  * the persistence strategy and the actual persistent collection framework
  * and session. Does not define operations that are required for querying
- * collections, or loading by outer join.<br>
+ * collections, or loading by outer join.
- * <br>
+ * <p>
  * Implements persistence of a collection instance while the instance is
- * referenced in a particular role.<br>
+ * referenced in a particular role.
- * <br>
+ * <p>
  * This class is highly coupled to the <tt>PersistentCollection</tt>
  * hierarchy, since double dispatch is used to load and update collection
- * elements.<br>
+ * elements.
- * <br>
+ * <p>
  * May be considered an immutable view of the mapping object
- * <p/>
+ * <p>
  * Unless a customer {@link org.hibernate.persister.spi.PersisterFactory} is used, it is expected
- * that implementations of CollectionDefinition define a constructor accepting the following arguments:<ol>
+ * that implementations of CollectionDefinition define a constructor accepting the following arguments:
+ * <ol>
  *     <li>
  *         {@link org.hibernate.mapping.Collection} - The metadata about the collection to be handled
  *         by the persister

hibernate-core/src/main/java/org/hibernate/sql/InFragment.java

@@ -14,9 +14,8 @@ import org.hibernate.internal.util.StringHelper;
 
 /**
  * An SQL IN expression.
- * <br>
+ * <p>
  * <code>... in(...)</code>
- * <br>
  *
  * @author Gavin King
  */

hibernate-core/src/main/java/org/hibernate/usertype/UserType.java

@@ -18,8 +18,8 @@ import org.hibernate.engine.spi.SharedSessionContractImplementor;
  * This interface should be implemented by user-defined "types".
  * A "type" class is <em>not</em> the actual property type - it
  * is a class that knows how to serialize instances of another
- * class to and from JDBC.<br>
+ * class to and from JDBC.
- * <br>
+ * <p>
  * This interface
  * <ul>
  * <li>abstracts user code from future changes to the <tt>Type</tt>
@@ -27,16 +27,16 @@ import org.hibernate.engine.spi.SharedSessionContractImplementor;
  * <li>simplifies the implementation of custom types and</li>
  * <li>hides certain "internal" interfaces from user code.</li>
  * </ul>
- * <br>
+ * <p>
  * Implementors must be immutable and must declare a public
- * default constructor.<br>
+ * default constructor.
- * <br>
+ * <p>
  * The actual class mapped by a <tt>UserType</tt> may be just
- * about anything.<br>
+ * about anything.
- * <br>
+ * <p>
  * <tt>CompositeUserType</tt> provides an extended version of
- * this interface that is useful for more complex cases.<br>
+ * this interface that is useful for more complex cases.
- * <br>
+ * <p>
  * Alternatively, custom types could implement <tt>Type</tt>
  * directly or extend one of the abstract classes in
  * <tt>org.hibernate.type</tt>. This approach risks future