Generate html5 javadoc

3 files changed, 38 insertions, 38 deletions

diff --git a/yolean/src/main/java/com/yahoo/yolean/concurrent/ThreadRobustList.java b/yolean/src/main/java/com/yahoo/yolean/concurrent/ThreadRobustList.java
index 3f57319cdce..72020bbaf88 100644
--- a/yolean/src/main/java/com/yahoo/yolean/concurrent/ThreadRobustList.java
+++ b/yolean/src/main/java/com/yahoo/yolean/concurrent/ThreadRobustList.java
@@ -8,15 +8,15 @@ import java.util.NoSuchElementException;
 /**
  * <p>This class implements a thread-safe, lock-free list of Objects that supports multiple readers and a single writer.
  * Because there are no locks or other memory barriers involved, there exists no <i>happens-before</i> relationship
- * among calls to either methods of the <tt>ThreadRobustList</tt>. This means that there are no guarantees as to when
+ * among calls to either methods of the <code>ThreadRobustList</code>. This means that there are no guarantees as to when
  * (or even if) an item {@link #add(Object)}ed becomes visible through {@link #iterator()}. If visibility is required,
  * either use explicit synchronization between reader and writer thread, or move to a different concurrent collection
- * (e.g. <tt>CopyOnWriteArrayList</tt>).</p>
- * <p>Because it is lock-free, the <tt>ThreadRobustList</tt> has minimal overhead to both reading and writing. The
+ * (e.g. <code>CopyOnWriteArrayList</code>).</p>
+ * <p>Because it is lock-free, the <code>ThreadRobustList</code> has minimal overhead to both reading and writing. The
  * iterator offered by this class always observes the list in a consistent state, and it never throws a
- * <tt>ConcurrentModificationException</tt>.</p>
- * <p>The <tt>ThreadRobustList</tt> does not permit adding <tt>null</tt> items.</p>
- * <p>The usage of <tt>ThreadRobustList</tt> has no memory consistency effects. </p>
+ * <code>ConcurrentModificationException</code>.</p>
+ * <p>The <code>ThreadRobustList</code> does not permit adding <code>null</code> items.</p>
+ * <p>The usage of <code>ThreadRobustList</code> has no memory consistency effects. </p>
  *
  * @author <a href="mailto:steinar@yahoo-inc.com">Steinar Knutsen</a>
  * @author bratseth
@@ -28,7 +28,7 @@ public class ThreadRobustList<T> implements Iterable<T> {
     private int next = 0;
 
     /**
-     * <p>Constructs a new instance of this class with an initial capacity of <tt>10</tt>.</p>
+     * <p>Constructs a new instance of this class with an initial capacity of <code>10</code>.</p>
      */
     public ThreadRobustList() {
         this(10);
@@ -46,18 +46,18 @@ public class ThreadRobustList<T> implements Iterable<T> {
     /**
      * <p>Returns whether or not this list is empty.</p>
      *
-     * @return <tt>true</tt> if this list has zero items
+     * @return <code>true</code> if this list has zero items
      */
     public boolean isEmpty() {
         return next == 0;
     }
 
     /**
-     * <p>Adds an item to this list. As opposed to <tt>CopyOnWriteArrayList</tt>, items added to this list may become
+     * <p>Adds an item to this list. As opposed to <code>CopyOnWriteArrayList</code>, items added to this list may become
      * visible to iterators created <em>before</em> a call to this method.</p>
      *
      * @param item the item to add
-     * @throws NullPointerException if <tt>item</tt> is <tt>null</tt>
+     * @throws NullPointerException if <code>item</code> is <code>null</code>
      */
     public void add(T item) {
         if (item == null) {
@@ -74,9 +74,9 @@ public class ThreadRobustList<T> implements Iterable<T> {
     }
 
     /**
-     * <p>Returns an iterator over the items in this list. As opposed to <tt>CopyOnWriteArrayList</tt>, this iterator
-     * may see items added to the <tt>ThreadRobustList</tt> even if they occur <em>after</em> a call to this method.</p>
-     * <p>The returned iterator does not support <tt>remove()</tt>.</p>
+     * <p>Returns an iterator over the items in this list. As opposed to <code>CopyOnWriteArrayList</code>, this iterator
+     * may see items added to the <code>ThreadRobustList</code> even if they occur <em>after</em> a call to this method.</p>
+     * <p>The returned iterator does not support <code>remove()</code>.</p>
      *
      * @return an iterator over this list
      */
diff --git a/yolean/src/main/java/com/yahoo/yolean/trace/TraceNode.java b/yolean/src/main/java/com/yahoo/yolean/trace/TraceNode.java
index 92e083c9998..b3c4d67db47 100644
--- a/yolean/src/main/java/com/yahoo/yolean/trace/TraceNode.java
+++ b/yolean/src/main/java/com/yahoo/yolean/trace/TraceNode.java
@@ -10,16 +10,16 @@ import java.util.List;
 import java.util.NoSuchElementException;
 
 /**
- * <p>This class represents a single node in a tree of <tt>TraceNodes</tt>. The trace forms a tree where there is a
- * branch for each parallel execution, and a node within such a branch for each traced event. As each <tt>TraceNode</tt>
+ * <p>This class represents a single node in a tree of <code>TraceNodes</code>. The trace forms a tree where there is a
+ * branch for each parallel execution, and a node within such a branch for each traced event. As each <code>TraceNode</code>
  * may contain a payload of any type, the trace tree can be used to exchange any thread-safe state between producers and
  * consumers in different threads, whether or not the shape of the trace tree is relevant to the particular
  * information.</p>
  * <p>This class uses a {@link ThreadRobustList} for its children. That list allows multiple threads to inspect the
- * hierarchy of a <tt>TraceNode</tt> tree while there are other threads concurrently modifying it, without incurring the
- * cost of memory synchronization. The only caveat being that for each <tt>TraceNode</tt> there can never be more than
- * exactly one writer thread. If multiple threads need to mutate a single <tt>TraceNode</tt>, then the writer threads
- * need to synchronize their access on the <tt>TraceNode</tt>.</p>
+ * hierarchy of a <code>TraceNode</code> tree while there are other threads concurrently modifying it, without incurring the
+ * cost of memory synchronization. The only caveat being that for each <code>TraceNode</code> there can never be more than
+ * exactly one writer thread. If multiple threads need to mutate a single <code>TraceNode</code>, then the writer threads
+ * need to synchronize their access on the <code>TraceNode</code>.</p>
  *
  * @author <a href="mailto:steinar@yahoo-inc.com">Steinar Knutsen</a>
  * @author bratseth
@@ -35,7 +35,7 @@ public class TraceNode {
     /**
      * <p>Creates a new instance of this class.</p>
      *
-     * @param payload   the payload to assign to this, may be <tt>null</tt>
+     * @param payload   the payload to assign to this, may be <code>null</code>
      * @param timestamp the timestamp to assign to this
      */
     public TraceNode(Object payload, long timestamp) {
@@ -44,11 +44,11 @@ public class TraceNode {
     }
 
     /**
-     * <p>Adds another <tt>TraceNode</tt> as a child to this.</p>
+     * <p>Adds another <code>TraceNode</code> as a child to this.</p>
      *
      * @param child the TraceNode to add
      * @return this, to allow chaining
-     * @throws IllegalArgumentException if <tt>child</tt> is not a root TraceNode
+     * @throws IllegalArgumentException if <code>child</code> is not a root TraceNode
      * @see #isRoot()
      */
     public TraceNode add(TraceNode child) {
@@ -64,12 +64,12 @@ public class TraceNode {
     }
 
     /**
-     * <p>Returns a read-only iterable of all {@link #payload() payloads} that are instances of <tt>payloadType</tt>,
-     * in all its decendants. The payload of <em>this</em> <tt>TraceNode</tt> is ignored.</p>
+     * <p>Returns a read-only iterable of all {@link #payload() payloads} that are instances of <code>payloadType</code>,
+     * in all its decendants. The payload of <em>this</em> <code>TraceNode</code> is ignored.</p>
      * <p>The payloads are retrieved in depth-first, prefix order.</p>
      *
      * @param payloadType the type of payloads to retrieve
-     * @return the payloads, never <tt>null</tt>
+     * @return the payloads, never <code>null</code>
      */
     public <PAYLOADTYPE> Iterable<PAYLOADTYPE> descendants(final Class<PAYLOADTYPE> payloadType) {
         if (children == null) {
@@ -85,7 +85,7 @@ public class TraceNode {
     }
 
     /**
-     * <p>Returns the payload of this <tt>TraceNode</tt>, or null if none.</p>
+     * <p>Returns the payload of this <code>TraceNode</code>, or null if none.</p>
      *
      * @return the payload
      */
@@ -94,7 +94,7 @@ public class TraceNode {
     }
 
     /**
-     * <p>Returns the timestamp of this <tt>TraceNode</tt>.</p>
+     * <p>Returns the timestamp of this <code>TraceNode</code>.</p>
      *
      * @return the timestamp
      */
@@ -103,7 +103,7 @@ public class TraceNode {
     }
 
     /**
-     * <p>Returns the parent <tt>TraceNode</tt> of this.</p>
+     * <p>Returns the parent <code>TraceNode</code> of this.</p>
      *
      * @return the parent
      */
@@ -112,7 +112,7 @@ public class TraceNode {
     }
 
     /**
-     * <p>Returns the child <tt>TraceNodes</tt> of this.</p>
+     * <p>Returns the child <code>TraceNodes</code> of this.</p>
      *
      * @return the children
      */
@@ -124,16 +124,16 @@ public class TraceNode {
     }
 
     /**
-     * <p>Returns whether or not this <tt>TraceNode</tt> is a root node (i.e. it has no parent).</p>
+     * <p>Returns whether or not this <code>TraceNode</code> is a root node (i.e. it has no parent).</p>
      *
-     * @return <tt>true</tt> if {@link #parent()} returns <tt>null</tt>
+     * @return <code>true</code> if {@link #parent()} returns <code>null</code>
      */
     public boolean isRoot() {
         return parent == null;
     }
 
     /**
-     * <p>Returns the root <tt>TraceNode</tt> of the tree that this <tt>TraceNode</tt> belongs to.</p>
+     * <p>Returns the root <code>TraceNode</code> of the tree that this <code>TraceNode</code> belongs to.</p>
      *
      * @return the root
      */
@@ -146,7 +146,7 @@ public class TraceNode {
     }
 
     /**
-     * <p>Visits this <tt>TraceNode</tt> and all of its descendants in depth-first, prefix order.</p>
+     * <p>Visits this <code>TraceNode</code> and all of its descendants in depth-first, prefix order.</p>
      *
      * @param visitor The visitor to accept.
      * @return The <code>visitor</code> parameter.
diff --git a/yolean/src/main/java/com/yahoo/yolean/trace/TraceVisitor.java b/yolean/src/main/java/com/yahoo/yolean/trace/TraceVisitor.java
index c45823da19a..23525b65571 100644
--- a/yolean/src/main/java/com/yahoo/yolean/trace/TraceVisitor.java
+++ b/yolean/src/main/java/com/yahoo/yolean/trace/TraceVisitor.java
@@ -13,17 +13,17 @@ public abstract class TraceVisitor {
      * <p>Visits a {@link TraceNode}. Called by {@link TraceNode#accept(TraceVisitor)}, before visiting its
      * children.</p>
      *
-     * @param node the <tt>TraceNode</tt> being visited
+     * @param node the <code>TraceNode</code> being visited
      * @see TraceNode#accept(TraceVisitor)
      */
     public abstract void visit(TraceNode node);
 
     /**
      * <p>Enters a {@link TraceNode}. This method is called after {@link #visit(TraceNode)}, but before visiting its
-     * children. Note that this method is NOT called if a <tt>TraceNode</tt> has zero children.</p>
+     * children. Note that this method is NOT called if a <code>TraceNode</code> has zero children.</p>
      * <p>The default implementation of this method does nothing.</p>
      *
-     * @param node the <tt>TraceNode</tt> being entered
+     * @param node the <code>TraceNode</code> being entered
      * @see #leaving(TraceNode)
      */
     @SuppressWarnings("UnusedParameters")
@@ -33,10 +33,10 @@ public abstract class TraceVisitor {
 
     /**
      * <p>Leaves a {@link TraceNode}. This method is called after {@link #entering(TraceNode)}, and after visiting its
-     * children. Note that this method is NOT called if a <tt>TraceNode</tt> has zero children.</p>
+     * children. Note that this method is NOT called if a <code>TraceNode</code> has zero children.</p>
      * <p>The default implementation of this method does nothing.</p>
      *
-     * @param node the <tt>TraceNode</tt> being left
+     * @param node the <code>TraceNode</code> being left
      */
     @SuppressWarnings("UnusedParameters")
     public void leaving(TraceNode node) {