diff options
author | gjoranv <gv@oath.com> | 2018-11-20 14:46:37 +0100 |
---|---|---|
committer | gjoranv <gv@oath.com> | 2019-01-21 15:09:27 +0100 |
commit | 81182050f567673fc3180764b3645fb76ca85dc5 (patch) | |
tree | cae51ade6b09ccbe7d316efb7b3d5b93e8bd3f18 /yolean | |
parent | 0fb27af8c2d6b8e5ebb0255e21c220a89ce05eba (diff) |
Generate html5 javadoc
Diffstat (limited to 'yolean')
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) { |