1 files changed, 12 insertions, 18 deletions
diff --git a/qpid/java/client/src/main/java/org/apache/qpid/client/failover/FailoverRetrySupport.java b/qpid/java/client/src/main/java/org/apache/qpid/client/failover/FailoverRetrySupport.java
index d3d33d3c75..ffe0baecd8 100644
--- a/qpid/java/client/src/main/java/org/apache/qpid/client/failover/FailoverRetrySupport.java
+++ b/qpid/java/client/src/main/java/org/apache/qpid/client/failover/FailoverRetrySupport.java
@@ -32,40 +32,34 @@ import org.apache.qpid.client.AMQConnection;
  * FailoverRetrySupport automatcally rechecks the condition and re-acquires the mutex and re-runs the continution. This
  * automatic retrying is continued until the continuation succeeds, or throws an exception (different to
  * FailoverException, which is used to signal the failure of the original condition).
- *
- * <p/>The blocking condition used is that the connection is not currently failing over, and the mutex used is the
+ * <p>
+ * The blocking condition used is that the connection is not currently failing over, and the mutex used is the
  * connection failover mutex, which guards against the fail-over process being run during fail-over vulnerable methods.
  * These are used like a lock and condition variable.
- *
- * <p/>The wrapped operation may throw a FailoverException, this is an exception that can be raised by a
+ * <p>
+ * The wrapped operation may throw a FailoverException, this is an exception that can be raised by a
  * {@link org.apache.qpid.client.protocol.BlockingMethodFrameListener}, in response to it being notified that a
  * fail-over wants to start whilst it was waiting. Methods that are vulnerable to fail-over are those that are
  * synchronous, where a failure will prevent them from getting the reply they are waiting for and asynchronous
  * methods that should not be attempted when a fail-over is in progress.
- *
- * <p/>Wrapping a synchronous method in a FailoverRetrySupport will have the effect that the operation will not be
+ * <p>
+ * Wrapping a synchronous method in a FailoverRetrySupport will have the effect that the operation will not be
  * started during fail-over, but be delayed until any current fail-over has completed. Should a fail-over process want
  * to start whilst waiting for the synchrnous reply, the FailoverRetrySupport will detect this and rety the operation
  * until it succeeds. Synchronous methods are usually coordinated with a
  * {@link org.apache.qpid.client.protocol.BlockingMethodFrameListener} which is notified when a fail-over process wants
  * to start and throws a FailoverException in response to this.
- *
- * <p/>Wrapping an asynchronous method in a FailoverRetrySupport will have the effect that the operation will not be
+ * <p>
+ * Wrapping an asynchronous method in a FailoverRetrySupport will have the effect that the operation will not be
  * started during fail-over, but be delayed until any current fail-over has completed.
- *
- * <p/><table id="crc"><caption>CRC Card</caption>
- * <tr><th> Responsibilities <th> Collaborations
- * <tr><td> Provide a continuation synchronized on a fail-over lock and condition.
- * <tr><td> Automatically retry the continuation accross fail-overs until it succeeds, or raises an exception.
- * </table>
- *
- * @todo Another continuation. Could use an interface Continuation (as described in other todos)
+ * <p>
+ * TODO  Another continuation. Could use an interface Continuation (as described in other todos)
  *      Then have a wrapping continuation (this), which blocks on an arbitrary
  *      Condition or Latch (specified in constructor call), that this blocks on before calling the wrapped Continuation.
  *      Must work on Java 1.4, so check retrotranslator works on Lock/Condition or latch first. Argument and return type
  *      to match wrapped condition as type parameters. Rename to AsyncConditionalContinuation or something like that.
- *
- * @todo InterruptedException not handled well.
+ * <p>
+ * TODO  InterruptedException not handled well.
  */
 public class FailoverRetrySupport<T, E extends Exception> implements FailoverSupport<T, E>
 {