Merge pull request #28 from sghill/self-closing-tags

Fix jdk8 javadoc errors

src/main/java/com/netflix/nfgraph/NFGraph.java

@@ -25,28 +25,28 @@
 /**
  * <code>NFGraph</code> represents a directed graph and is the base class for the two flavors of NetflixGraph 
  * ({@link NFBuildGraph} and {@link NFCompressedGraph}).  It defines the operations for retrieving connections 
- * in the graph, given some node and property.<p/>
+ * in the graph, given some node and property.<p>
  * 
  * In the NetflixGraph library, each node in your graph is expected to be uniquely represented as a "type" and "ordinal".  
  * Each "type" will be referred to by some String.  An "ordinal", in this sense, is a number that uniquely defines the node 
  * given its type.  If a type of node has "n" instances, then each instance should be representable by some unique value 
  * from 0 through (n-1).  If nodes in the graph are represented as Objects externally to the NetflixGraph library, then 
  * developers may find it helpful to use an {@link OrdinalMap} for each type to create and maintain a mapping between objects 
- * and their ordinals.  The {@link OrdinalMap} has been optimized with this use case in mind.  <p/>
+ * and their ordinals.  The {@link OrdinalMap} has been optimized with this use case in mind.  <p>
  * 
- * Use of the NFGraph is expected to generally follow some lifecycle:<p/>
+ * Use of the NFGraph is expected to generally follow some lifecycle:<p>
  * <ol>
  * <li>Define an {@link NFGraphSpec}, which serves as the schema for the graph data.</li>
  * <li>Instantiate an {@link NFBuildGraph}, then populate it with connections.</li>
  * <li>Compress the {@link NFBuildGraph}, which will return a representation of the data as an {@link NFCompressedGraph}.</li>
  * <li>Serialize the {@link NFCompressedGraph} to a stream.  Netflix, for example, has a use case which streams this graph to Amazon Web Service's S3.</li>
  * <li>Deserialize the stream where the compact in-memory representation of the graph data is necessary.</li>
- * </ol><p/>
+ * </ol><p>
  * 
  * In some cases, the location where the compact in-memory representation is necessary is the same as the location where this
- * representation will be built.  In these cases, steps (4) and (5) above will be omitted.<p/>
+ * representation will be built.  In these cases, steps (4) and (5) above will be omitted.<p>
  * 
- * If there will be a producer of this graph and one or more consumers, then your producer code will resemble:<p/>
+ * If there will be a producer of this graph and one or more consumers, then your producer code will resemble:<p>
  * 
  * <pre>
  * {@code
@@ -66,7 +66,7 @@
  * }
  * </pre>
  * 
- * And your consumer code will resemble:<p/>
+ * And your consumer code will resemble:<p>
  * 
  * <pre>
  * {@code

src/main/java/com/netflix/nfgraph/NFGraphModelHolder.java

@@ -22,14 +22,14 @@
 import com.netflix.nfgraph.util.OrdinalMap;
 
 /**
- * <code>NFGraphModelHolder</code> maintains an ordering over the models in a given NFGraph.<p/>
+ * <code>NFGraphModelHolder</code> maintains an ordering over the models in a given NFGraph.<p>
  * 
  * An {@link NFGraph} may contain one or more "connection models".  A "connection model" is a grouping of the set of connections
- * between nodes in the graph.<p/>
+ * between nodes in the graph.<p>
  * 
  * Connections added for a connection model will be visible only for that model.  Use of multiple connection models will 
  * add a minimum of one byte per model-specific connection set per node.  As a result, this feature should be used only 
- * when the number of connection models is and will remain low.<p/>
+ * when the number of connection models is and will remain low.<p>
  * 
  * It is unlikely that this class will need to be used externally.
  */

src/main/java/com/netflix/nfgraph/OrdinalIterator.java

@@ -22,7 +22,7 @@
 import com.netflix.nfgraph.compressed.HashSetOrdinalIterator;
 
 /**
- * <code>OrdinalIterator</code> is the interface used to iterate over a set of connections.<p/>
+ * <code>OrdinalIterator</code> is the interface used to iterate over a set of connections.<p>
  * 
  * An <code>OrdinalIterator</code> may be obtained for a set of connections directly from an {@link NFGraph} or via an {@link OrdinalSet}
  * obtained from an {@link NFGraph}.
@@ -50,7 +50,7 @@ public interface OrdinalIterator {
     public void reset();
 
     /**
-     * Obtain a copy of this <copy>OrdinalIterator</code>.  The returned <code>OrdinalIterator</code> will be reset to the beginning of the set.
+     * Obtain a copy of this <code>OrdinalIterator</code>.  The returned <code>OrdinalIterator</code> will be reset to the beginning of the set.
      */
     public OrdinalIterator copy();
 

src/main/java/com/netflix/nfgraph/OrdinalSet.java

@@ -26,7 +26,7 @@
 import com.netflix.nfgraph.compressed.HashSetOrdinalSet;
 
 /**
- * <code>OrdinalSet</code> is the interface used to represent a set of connections.<p/>
+ * <code>OrdinalSet</code> is the interface used to represent a set of connections.<p>
  * 
  * An <code>OrdinalSet</code> is obtained directly from an {@link NFGraph}.
  * 
@@ -37,19 +37,19 @@ public abstract class OrdinalSet {
 
     /**
      * Returns <code>true</code> when the specified value is contained in this set.  Depending on the implementation,
-     * this operation will have one of two performance characteristics:<p/>
+     * this operation will have one of two performance characteristics:<p>
      * 
-     * <code>O(1)</code> for {@link HashSetOrdinalSet} and {@link BitSetOrdinalSet}<br/>
+     * <code>O(1)</code> for {@link HashSetOrdinalSet} and {@link BitSetOrdinalSet}<br>
      * <code>O(n)</code> for {@link CompactOrdinalSet} and {@link NFBuildGraphOrdinalSet}
      */
     public abstract boolean contains(int value);
 
     /**
      * Returns <code>true</code> when all specified values are contained in this set.  Depending on the implementation,
-     * this operation will have one of two performance characteristics:<p/>
+     * this operation will have one of two performance characteristics:<p>
      * 
-     * <code>O(m)</code> for {@link HashSetOrdinalSet} and {@link BitSetOrdinalSet}, where <code>m</code> is the number of specified elements.<br/>
-     * <code>O(n)</code> for {@link CompactOrdinalSet}, where <code>n</code> is the number of elements in the set.<br/>
+     * <code>O(m)</code> for {@link HashSetOrdinalSet} and {@link BitSetOrdinalSet}, where <code>m</code> is the number of specified elements.<br>
+     * <code>O(n)</code> for {@link CompactOrdinalSet}, where <code>n</code> is the number of elements in the set.<br>
      * <code>O(n * m)</code> for {@link NFBuildGraphOrdinalSet}.
      */
 	public boolean containsAll(int... values) {

src/main/java/com/netflix/nfgraph/build/NFBuildGraph.java

@@ -30,11 +30,11 @@
 
 
 /**
- * An </code>NFBuildGraph</code> is used to create a new graph.  This representation of the graph data is not especially memory-efficient,
- * and is intended to exist only for a short time while the {@link NFGraph} is being populated.<p/>
+ * An <code>NFBuildGraph</code> is used to create a new graph.  This representation of the graph data is not especially memory-efficient,
+ * and is intended to exist only for a short time while the {@link NFGraph} is being populated.<p>
  * 
  * Once the graph is completely populated, it is expected that this <code>NFBuildGraph</code> will be exchanged for a memory-efficient, 
- * read-only {@link NFCompressedGraph} via the <code>compress()</code> method.<p/>
+ * read-only {@link NFCompressedGraph} via the <code>compress()</code> method.<p>
  * 
  * See {@link NFGraph} for an example of code which creates and populates an <code>NFBuildGraph</code>
  * 
@@ -122,10 +122,10 @@ public void addConnection(NFBuildGraphNode fromNode, NFPropertySpec propertySpec
     }
 
     /**
-     * Add a connection model, identified by the parameter <code>connectionModel</code> to this graph.<p/>
+     * Add a connection model, identified by the parameter <code>connectionModel</code> to this graph.<p>
      * 
      * Building the graph may be much more efficient if each connection model is added to the graph with this method 
-     * prior to adding any connections.<p/>
+     * prior to adding any connections.<p>
      * 
      * This operation is not necessary, but may make building the graph more efficient.
      *

src/main/java/com/netflix/nfgraph/compressed/BitSetOrdinalSet.java

@@ -24,13 +24,13 @@
 import com.netflix.nfgraph.util.ByteArrayReader;
 
 /**
- * An implementation of {@link OrdinalSet}, returned for connections represented as a bit set in an {@link NFCompressedGraph}.<p/>
+ * An implementation of {@link OrdinalSet}, returned for connections represented as a bit set in an {@link NFCompressedGraph}.<p>
  *
  * A bit set representation contains a single bit per ordinal in the type to which the connections point.  If the bit at the
- * position for a given ordinal is set, then there is a connection to that ordinal in this set.<p/>
+ * position for a given ordinal is set, then there is a connection to that ordinal in this set.<p>
  *
  * Because determining membership in a set requires only checking whether the bit at a given position is set, <code>contains()</code>
- * is an <code>O(1)</code> operation.<p/>
+ * is an <code>O(1)</code> operation.<p>
  *
  * This representation will automatically be chosen for a set by the {@link NFCompressedGraphBuilder} when it requires fewer bytes than
  * the configured representation (either {@link NFPropertySpec#COMPACT} or {@link NFPropertySpec#HASH}).

src/main/java/com/netflix/nfgraph/compressed/CompactOrdinalSet.java

@@ -25,16 +25,16 @@
 import com.netflix.nfgraph.util.ByteArrayReader;
 
 /**
- * An implementation of {@link OrdinalSet}, returned for connections represented as variable-byte deltas in an {@link NFCompressedGraph}.<p/>
+ * An implementation of {@link OrdinalSet}, returned for connections represented as variable-byte deltas in an {@link NFCompressedGraph}.<p>
  * 
  * A variable-byte delta representation contains between one and five bytes per connection.  
- * The ordinals in the set are sorted ascending, then encoded as the difference between each ordinal and the last ordinal.<p/>
+ * The ordinals in the set are sorted ascending, then encoded as the difference between each ordinal and the last ordinal.<p>
  * 
- * For example, the values [ 7, 11, 13, 21 ] will be encoded as [ 7, 4, 2, 8 ].<p/>
+ * For example, the values [ 7, 11, 13, 21 ] will be encoded as [ 7, 4, 2, 8 ].<p>
  * 
- * This is done because smaller values can be represented in fewer bytes.<p/>
+ * This is done because smaller values can be represented in fewer bytes.<p>
  *
- * Because each value can only be derived using the previous value, <code>contains()</code> is an <code>O(n)</code> operation.<p/>
+ * Because each value can only be derived using the previous value, <code>contains()</code> is an <code>O(n)</code> operation.<p>
  * 
  * This representation for a connection set can be configured for an {@link NFPropertySpec} using {@link NFPropertySpec#COMPACT}.
  * 

src/main/java/com/netflix/nfgraph/compressed/HashSetOrdinalSet.java

@@ -24,17 +24,17 @@
 import com.netflix.nfgraph.util.Mixer;
 
 /**
- * An implementation of {@link OrdinalSet}, returned for connections represented as variable-byte hashed integer arrays in an {@link NFCompressedGraph}.<p/>
+ * An implementation of {@link OrdinalSet}, returned for connections represented as variable-byte hashed integer arrays in an {@link NFCompressedGraph}.<p>
  *
  * A variable-byte hashed integer array representation contains between one and five bytes per connection.  The ordinal for each
- * connection is hashed into a byte array, then represented as a variant on the variable-byte integers used in the {@link CompactOrdinalSet}.<p/>
+ * connection is hashed into a byte array, then represented as a variant on the variable-byte integers used in the {@link CompactOrdinalSet}.<p>
  *
  * The byte array can be thought of as a open-addressed hash table, with each byte representing a single bucket.  Because
  * values may be represented in more than one byte, single values may spill over into multiple buckets.  The beginning of the
  * value is indicated by an unset sign bit, and will be located at or after the bucket to which it is hashed.  If the value's
- * first bit is not located at the hashed position, it will be located in a position after the bucket with no empty buckets in between.<p/>
+ * first bit is not located at the hashed position, it will be located in a position after the bucket with no empty buckets in between.<p>
  *
- * This implementation provides <code>O(1)</code> time for <code>contains()</code>, but is not as memory-efficient as a {@link CompactOrdinalSet}.<p/>
+ * This implementation provides <code>O(1)</code> time for <code>contains()</code>, but is not as memory-efficient as a {@link CompactOrdinalSet}.<p>
  *
  * This representation for a connection set can be configured for an {@link NFPropertySpec} using {@link NFPropertySpec#HASH}.
  *

src/main/java/com/netflix/nfgraph/compressed/NFCompressedGraph.java

@@ -42,7 +42,7 @@
 /**
  * A read-only, memory-efficient implementation of an {@link NFGraph}.  The connections for all nodes in the graph
  * are encoded into a single byte array.  The encoding for each set will be specified as either a {@link CompactOrdinalSet} or
- * {@link HashSetOrdinalSet}.  If it is more efficient, the actual encoding will be a {@link BitSetOrdinalSet}.<p/>
+ * {@link HashSetOrdinalSet}.  If it is more efficient, the actual encoding will be a {@link BitSetOrdinalSet}.<p>
  *
  * The offsets into the byte array where connections for each node are encoded are held in the {@link NFCompressedGraphPointers}.
  */

src/main/java/com/netflix/nfgraph/compressed/NFCompressedGraphIntPointers.java

@@ -23,10 +23,10 @@
 import com.netflix.nfgraph.exception.NFGraphException;
 
 /**
- * This class holds all of the offsets into the {@link NFCompressedGraph}'s byte array.<p/>
+ * This class holds all of the offsets into the {@link NFCompressedGraph}'s byte array.<p>
  *
  * This class maintains a mapping of type name to int array.  For a given type, the offset in the {@link NFCompressedGraph}'s byte array
- * where the connections for a given node are encoded is equal to the value of the int array for the node's type at the index for the node's ordinal.<p/>
+ * where the connections for a given node are encoded is equal to the value of the int array for the node's type at the index for the node's ordinal.<p>
  *
  * It is unlikely that this class will need to be used externally.
  */

src/main/java/com/netflix/nfgraph/compressed/NFCompressedGraphLongPointers.java

@@ -23,10 +23,10 @@
 import com.netflix.nfgraph.exception.NFGraphException;
 
 /**
- * This class holds all of the offsets into the {@link NFCompressedGraph}'s byte array.<p/>
+ * This class holds all of the offsets into the {@link NFCompressedGraph}'s byte array.<p>
  *
  * This class maintains a mapping of type name to int array.  For a given type, the offset in the {@link NFCompressedGraph}'s byte array
- * where the connections for a given node are encoded is equal to the value of the int array for the node's type at the index for the node's ordinal.<p/>
+ * where the connections for a given node are encoded is equal to the value of the int array for the node's type at the index for the node's ordinal.<p>
  *
  * It is unlikely that this class will need to be used externally.
  */

src/main/java/com/netflix/nfgraph/compressor/BitSetPropertyBuilder.java

@@ -25,7 +25,7 @@
 import com.netflix.nfgraph.util.ByteArrayBuffer;
 
 /**
- * This class is used by {@link NFCompressedGraphBuilder} to write sets of ordinals represented with bit sets.<p/>
+ * This class is used by {@link NFCompressedGraphBuilder} to write sets of ordinals represented with bit sets.<p>
  * 
  * It is unlikely that this class will need to be used externally.
  * 

src/main/java/com/netflix/nfgraph/compressor/CompactPropertyBuilder.java

@@ -24,7 +24,7 @@
 import com.netflix.nfgraph.util.ByteArrayBuffer;
 
 /**
- * This class is used by {@link NFCompressedGraphBuilder} to write sets of ordinals represented as variable-byte deltas.<p/>
+ * This class is used by {@link NFCompressedGraphBuilder} to write sets of ordinals represented as variable-byte deltas.<p>
  * 
  * It is unlikely that this class will need to be used externally.
  * 

src/main/java/com/netflix/nfgraph/compressor/HashedPropertyBuilder.java

@@ -26,7 +26,7 @@
 import com.netflix.nfgraph.util.Mixer;
 
 /**
- * This class is used by {@link NFCompressedGraphBuilder} to write sets of ordinals represented as as variable-byte hashed integer arrays.<p/>
+ * This class is used by {@link NFCompressedGraphBuilder} to write sets of ordinals represented as as variable-byte hashed integer arrays.<p>
  * 
  * It is unlikely that this class will need to be used externally.
  * 

src/main/java/com/netflix/nfgraph/compressor/NFCompressedGraphBuilder.java

@@ -32,7 +32,7 @@
 
 
 /**
- * <code>NFCompressedGraphBuilder</code> is used by {@link NFBuildGraph#compress()} to create an {@link NFCompressedGraph}.<p/>
+ * <code>NFCompressedGraphBuilder</code> is used by {@link NFBuildGraph#compress()} to create an {@link NFCompressedGraph}.<p>
  *
  * It is unlikely that this class will need to be used externally.
  */

src/main/java/com/netflix/nfgraph/serializer/NFCompressedGraphDeserializer.java

@@ -33,7 +33,7 @@
 import java.io.InputStream;
 
 /**
- * This class is used by {@link NFCompressedGraph#readFrom(InputStream)}.<p/>
+ * This class is used by {@link NFCompressedGraph#readFrom(InputStream)}.<p>
  *
  * It is unlikely that this class will need to be used externally.
  */

src/main/java/com/netflix/nfgraph/serializer/NFCompressedGraphSerializer.java

@@ -30,7 +30,7 @@
 import java.io.OutputStream;
 
 /**
- * This class is used by {@link NFCompressedGraph#writeTo(OutputStream)}.<p/>
+ * This class is used by {@link NFCompressedGraph#writeTo(OutputStream)}.<p>
  *
  * It is unlikely that this class will need to be used externally.
  */

src/main/java/com/netflix/nfgraph/spec/NFGraphSpec.java

@@ -27,11 +27,11 @@
 
 /**
  * An <code>NFGraphSpec</code> defines the schema for a graph.  It contains a mapping of node type 
- * name to {@link NFNodeSpec}s.<p/>
+ * name to {@link NFNodeSpec}s.<p>
  *
  * The example code below will create two node types "a" and "b".  An "a" node can be connected to "b" nodes 
  * via the properties "a-to-one-b" and/or "a-to-many-b".  A "b" node can be connected to "a" nodes via the property
- * "b-to-many-a".<p/>
+ * "b-to-many-a".<p>
  * 
  * <pre>
  * {@code

src/main/java/com/netflix/nfgraph/spec/NFPropertySpec.java

@@ -23,11 +23,11 @@
 import com.netflix.nfgraph.compressed.NFCompressedGraph;
 
 /**
- * This class defines a specification for a single property.<p/>
+ * This class defines a specification for a single property.<p>
  * 
- * The recommended interface for creating a property is to instantiate with the flag method below.<p/>
+ * The recommended interface for creating a property is to instantiate with the flag method below.<p>
  * 
- * By default, an <code>NFPropertySpec</code> is {@link #GLOBAL}, {@link #MULTIPLE}, and {@link #COMPACT}.<p/>
+ * By default, an <code>NFPropertySpec</code> is {@link #GLOBAL}, {@link #MULTIPLE}, and {@link #COMPACT}.<p>
  * 
  * <pre>
  * {@code
@@ -92,7 +92,7 @@ public class NFPropertySpec {
      * 
      * @param name the name of the property.
      * @param toNodeType the node type to which this property connects
-     * @param flags a bitwise-or of the various flags defined as constants in {@link NFPropertySpec}.<br/>For example, a global, multiple, compact property would take the value <code>NFPropertySpec.GLOBAL | NFPropertySpec.MULTIPLE | NFPropertySpec.COMPACT</code> 
+     * @param flags a bitwise-or of the various flags defined as constants in {@link NFPropertySpec}.<br>For example, a global, multiple, compact property would take the value <code>NFPropertySpec.GLOBAL | NFPropertySpec.MULTIPLE | NFPropertySpec.COMPACT</code>
      * 
      */
     public NFPropertySpec(String name, String toNodeType, int flags) {

src/main/java/com/netflix/nfgraph/util/ByteArrayBuffer.java

@@ -23,7 +23,7 @@
 import java.io.OutputStream;
 
 /**
- * A <code>ByteArrayBuffer</code> is used by the {@link NFCompressedGraphBuilder} to write data to a byte array.<p/>
+ * A <code>ByteArrayBuffer</code> is used by the {@link NFCompressedGraphBuilder} to write data to a byte array.<p>
  *
  * It is unlikely that this class will need to be used externally.
  */

src/main/java/com/netflix/nfgraph/util/ByteArrayReader.java

@@ -22,7 +22,7 @@
 import com.netflix.nfgraph.compressed.NFCompressedGraph;
 
 /**
- * Used by the {@link NFCompressedGraph}, and various {@link OrdinalSet} and {@link OrdinalIterator} implementations to read the encoded graph data.<p/>
+ * Used by the {@link NFCompressedGraph}, and various {@link OrdinalSet} and {@link OrdinalIterator} implementations to read the encoded graph data.<p>
  *
  * It is unlikely that this class will be required externally.
  */