Fix JavaDoc warnings and remove obselete HTML tags

src/main/java/com/microsoft/sqlserver/jdbc/SQLServerSpatialDatatype.java

@@ -96,6 +96,8 @@ abstract class SQLServerSpatialDatatype {
      * 
      * @param noZM
      *        flag to indicate if Z and M coordinates should be included
+     * @param type
+     *        Type of Spatial Datatype (Geometry/Geography)
      */
     protected void serializeToWkb(boolean noZM, SQLServerSpatialDatatype type) {
         ByteBuffer buf = ByteBuffer.allocate(determineWkbCapacity());
@@ -172,6 +174,10 @@ protected void serializeToWkb(boolean noZM, SQLServerSpatialDatatype type) {
      * Deserializes the buffer (that contains WKB representation of Geometry/Geography data), and stores it into
      * multiple corresponding data structures.
      * 
+     * @param type
+     *          Type of Spatial Datatype (Geography/Geometry)
+     * @throws SQLServerException
+     *          if an Exception occurs
      */
     protected void parseWkb(SQLServerSpatialDatatype type) throws SQLServerException {
         srid = readInt();

src/main/java/mssql/googlecode/concurrentlinkedhashmap/ConcurrentLinkedHashMap.java

@@ -50,14 +50,14 @@
  * concurrency for updates, and a maximum capacity to bound the map by. This
  * implementation differs from {@link ConcurrentHashMap} in that it maintains a
  * page replacement algorithm that is used to evict an entry when the map has
- * exceeded its capacity. Unlike the <tt>Java Collections Framework</tt>, this
+ * exceeded its capacity. Unlike the <code>Java Collections Framework</code>, this
  * map does not have a publicly visible constructor and instances are created
  * through a {@link Builder}.
  * <p>
- * An entry is evicted from the map when the <tt>weighted capacity</tt> exceeds
- * its <tt>maximum weighted capacity</tt> threshold. A {@link EntryWeigher}
+ * An entry is evicted from the map when the <code>weighted capacity</code> exceeds
+ * its <code>maximum weighted capacity</code> threshold. A {@link EntryWeigher}
  * determines how many units of capacity that an entry consumes. The default
- * weigher assigns each value a weight of <tt>1</tt> to bound the map by the
+ * weigher assigns each value a weight of <code>1</code> to bound the map by the
  * total number of key-value pairs. A map that holds collections may choose to
  * weigh values by the number of elements in the collection and bound the map
  * by the total number of elements that it contains. A change to a value that
@@ -73,7 +73,7 @@
  * operation asynchronously, such as by submitting a task to an
  * {@link java.util.concurrent.ExecutorService}.
  * <p>
- * The <tt>concurrency level</tt> determines the number of threads that can
+ * The <code>concurrency level</code> determines the number of threads that can
  * concurrently modify the table. Using a significantly higher or lower value
  * than needed can waste space or lead to thread contention, but an estimate
  * within an order of magnitude of the ideal value does not usually have a
@@ -85,7 +85,7 @@
  * interfaces.
  * <p>
  * Like {@link java.util.Hashtable} but unlike {@link HashMap}, this class
- * does <em>not</em> allow <tt>null</tt> to be used as a key or value. Unlike
+ * does <em>not</em> allow <code>null</code> to be used as a key or value. Unlike
  * {@link java.util.LinkedHashMap}, this class does <em>not</em> provide
  * predictable iteration order. A snapshot of the keys and entries may be
  * obtained in ascending and descending order of retention.
@@ -466,8 +466,8 @@ void drainWriteBuffer() {
   }
 
   /**
-   * Attempts to transition the node from the <tt>alive</tt> state to the
-   * <tt>retired</tt> state.
+   * Attempts to transition the node from the <code>alive</code> state to the
+   * <code>retired</code> state.
    *
    * @param node the entry in the page replacement policy
    * @param expect the expected weighted value
@@ -482,8 +482,8 @@ boolean tryToRetire(Node<K, V> node, WeightedValue<V> expect) {
   }
 
   /**
-   * Atomically transitions the node from the <tt>alive</tt> state to the
-   * <tt>retired</tt> state, if a valid transition.
+   * Atomically transitions the node from the <code>alive</code> state to the
+   * <code>retired</code> state, if a valid transition.
    *
    * @param node the entry in the page replacement policy
    */
@@ -501,8 +501,8 @@ void makeRetired(Node<K, V> node) {
   }
 
   /**
-   * Atomically transitions the node to the <tt>dead</tt> state and decrements
-   * the <tt>weightedSize</tt>.
+   * Atomically transitions the node to the <code>dead</code> state and decrements
+   * the <code>weightedSize</code>.
    *
    * @param node the entry in the page replacement policy
    */
@@ -1147,7 +1147,7 @@ public void setNext(Node<K, V> next) {
       this.next = next;
     }
 
-    /** Retrieves the value held by the current <tt>WeightedValue</tt>. */
+    /** Retrieves the value held by the current <code>WeightedValue</code>. */
     V getValue() {
       return get().value;
     }
@@ -1473,7 +1473,7 @@ public Builder() {
     }
 
     /**
-     * Specifies the initial capacity of the hash table (default <tt>16</tt>).
+     * Specifies the initial capacity of the hash table (default <code>16</code>).
      * This is the number of key-value pairs that the hash table can hold
      * before a resize operation is required.
      *
@@ -1507,7 +1507,7 @@ public Builder<K, V> maximumWeightedCapacity(long capacity) {
     /**
      * Specifies the estimated number of concurrently updating threads. The
      * implementation performs internal sizing to try to accommodate this many
-     * threads (default <tt>16</tt>).
+     * threads (default <code>16</code>).
      *
      * @param concurrencyLevel the estimated number of concurrently updating
      *     threads
@@ -1538,7 +1538,7 @@ public Builder<K, V> listener(EvictionListener<K, V> listener) {
     /**
      * Specifies an algorithm to determine how many the units of capacity a
      * value consumes. The default algorithm bounds the map by the number of
-     * key-value pairs by giving each entry a weight of <tt>1</tt>.
+     * key-value pairs by giving each entry a weight of <code>1</code>.
      *
      * @param weigher the algorithm to determine a value's weight
      * @return Builder
@@ -1554,7 +1554,7 @@ public Builder<K, V> weigher(Weigher<? super V> weigher) {
     /**
      * Specifies an algorithm to determine how many the units of capacity an
      * entry consumes. The default algorithm bounds the map by the number of
-     * key-value pairs by giving each entry a weight of <tt>1</tt>.
+     * key-value pairs by giving each entry a weight of <code>1</code>.
      *
      * @param weigher the algorithm to determine a entry's weight
      * @return Builder

src/main/java/mssql/googlecode/concurrentlinkedhashmap/Weighers.java

@@ -54,7 +54,7 @@ public static <K, V> EntryWeigher<K, V> asEntryWeigher(
   }
 
   /**
-   * A weigher where an entry has a weight of <tt>1</tt>. A map bounded with
+   * A weigher where an entry has a weight of <code>1</code>. A map bounded with
    * this weigher will evict when the number of key-value pairs exceeds the
    * capacity.
    *
@@ -68,7 +68,7 @@ public static <K, V> EntryWeigher<K, V> entrySingleton() {
   }
 
   /**
-   * A weigher where a value has a weight of <tt>1</tt>. A map bounded with
+   * A weigher where a value has a weight of <code>1</code>. A map bounded with
    * this weigher will evict when the number of key-value pairs exceeds the
    * capacity.
    *
@@ -88,7 +88,7 @@ public static <V> Weigher<V> singleton() {
    * and is primarily for usage by dedicated caching servers that hold the
    * serialized data.
    * <p>
-   * A value with a weight of <tt>0</tt> will be rejected by the map. If a value
+   * A value with a weight of <code>0</code> will be rejected by the map. If a value
    * with this weight can occur then the caller should eagerly evaluate the
    * value and treat it as a removal operation. Alternatively, a custom weigher
    * may be specified on the map to assign an empty value a positive weight.
@@ -106,7 +106,7 @@ public static Weigher<byte[]> byteArray() {
    * map bounded with this weigher will evict when the total number of elements
    * exceeds the capacity rather than the number of key-value pairs in the map.
    * <p>
-   * A value with a weight of <tt>0</tt> will be rejected by the map. If a value
+   * A value with a weight of <code>0</code> will be rejected by the map. If a value
    * with this weight can occur then the caller should eagerly evaluate the
    * value and treat it as a removal operation. Alternatively, a custom weigher
    * may be specified on the map to assign an empty value a positive weight.
@@ -125,7 +125,7 @@ public static <E> Weigher<? super Iterable<E>> iterable() {
    * total number of elements exceeds the capacity rather than the number of
    * key-value pairs in the map.
    * <p>
-   * A value with a weight of <tt>0</tt> will be rejected by the map. If a value
+   * A value with a weight of <code>0</code> will be rejected by the map. If a value
    * with this weight can occur then the caller should eagerly evaluate the
    * value and treat it as a removal operation. Alternatively, a custom weigher
    * may be specified on the map to assign an empty value a positive weight.
@@ -144,7 +144,7 @@ public static <E> Weigher<? super Collection<E>> collection() {
    * number of elements exceeds the capacity rather than the number of
    * key-value pairs in the map.
    * <p>
-   * A value with a weight of <tt>0</tt> will be rejected by the map. If a value
+   * A value with a weight of <code>0</code> will be rejected by the map. If a value
    * with this weight can occur then the caller should eagerly evaluate the
    * value and treat it as a removal operation. Alternatively, a custom weigher
    * may be specified on the map to assign an empty value a positive weight.
@@ -163,7 +163,7 @@ public static <E> Weigher<? super List<E>> list() {
    * number of elements exceeds the capacity rather than the number of
    * key-value pairs in the map.
    * <p>
-   * A value with a weight of <tt>0</tt> will be rejected by the map. If a value
+   * A value with a weight of <code>0</code> will be rejected by the map. If a value
    * with this weight can occur then the caller should eagerly evaluate the
    * value and treat it as a removal operation. Alternatively, a custom weigher
    * may be specified on the map to assign an empty value a positive weight.
@@ -182,7 +182,7 @@ public static <E> Weigher<? super Set<E>> set() {
    * entries across all values exceeds the capacity rather than the number of
    * key-value pairs in the map.
    * <p>
-   * A value with a weight of <tt>0</tt> will be rejected by the map. If a value
+   * A value with a weight of <code>0</code> will be rejected by the map. If a value
    * with this weight can occur then the caller should eagerly evaluate the
    * value and treat it as a removal operation. Alternatively, a custom weigher
    * may be specified on the map to assign an empty value a positive weight.

src/main/java/mssql/googlecode/concurrentlinkedhashmap/package-info.java

@@ -22,7 +22,7 @@
  * automatically removed due to the map exceeding a capacity threshold. It is not called when an entry was explicitly removed.
  * <p>
  * The {@link ConcurrentLinkedHashMap} class supplies an efficient, scalable, thread-safe, bounded map. As with the
- * <tt>Java Collections Framework</tt> the "Concurrent" prefix is used to indicate that the map is not governed by a single exclusion lock.
+ * <code>Java Collections Framework</code> the "Concurrent" prefix is used to indicate that the map is not governed by a single exclusion lock.
  *
  * @see <a href="http://code.google.com/p/concurrentlinkedhashmap/"> http://code.google.com/p/concurrentlinkedhashmap/</a>
  */