Javadoc p fix ups

bbakerman · bbakerman · commit 97c6def77ba8 · 2018-08-26T15:34:17.000+10:00
diff --git a/src/main/java/org/dataloader/BatchLoader.java b/src/main/java/org/dataloader/BatchLoader.java
@@ -16,21 +16,19 @@
 
 package org.dataloader;
 
-import java.util.Collections;
 import java.util.List;
-import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionStage;
 
 /**
  * A function that is invoked for batch loading a list of data values indicated by the provided list of keys. The
  * function returns a promise of a list of results of individual load requests.
- *
+ * <p>
  * There are a few constraints that must be upheld:
  * <ul>
  * <li>The list of values must be the same size as the list of keys.</li>
  * <li>Each index in the list of values must correspond to the same index in the list of keys.</li>
  * </ul>
- *
+ * <p>
  * For example, if your batch function was provided the list of keys:
  *
  * <pre>
@@ -50,10 +48,10 @@
  * </pre>
  *
  * then the batch loader function contract has been broken.
- *
+ * <p>
  * The back-end service returned results in a different order than we requested, likely because it was more efficient for it to
  * do so. Also, it omitted a result for key 6, which we may interpret as no value existing for that key.
- *
+ * <p>
  * To uphold the constraints of the batch function, it must return an List of values the same length as
  * the List of keys, and re-order them to ensure each index aligns with the original keys [ 2, 9, 6, 1 ]:
  *
@@ -77,7 +75,7 @@ public interface BatchLoader<K, V> {
 
     /**
      * Called to batch load the provided keys and return a promise to a list of values.
-     *
+     * <p>
      * If you need calling context then implement {@link org.dataloader.BatchLoaderWithContext}
      *
      * @param keys the collection of keys to load
diff --git a/src/main/java/org/dataloader/DataLoader.java b/src/main/java/org/dataloader/DataLoader.java
@@ -95,10 +95,10 @@ public static <K, V> DataLoader<K, V> newDataLoader(BatchLoader<K, V> batchLoadF
      * Creates new DataLoader with the specified batch loader function and default options
      * (batching, caching and unlimited batch size) where the batch loader function returns a list of
      * {@link org.dataloader.Try} objects.
-     *
+     * <p>
      * If its important you to know the exact status of each item in a batch call and whether it threw exceptions then
      * you can use this form to create the data loader.
-     *
+     * <p>
      * Using Try objects allows you to capture a value returned or an exception that might
      * have occurred trying to get a value. .
      *
@@ -163,10 +163,10 @@ public static <K, V> DataLoader<K, V> newDataLoader(BatchLoaderWithContext<K, V>
      * Creates new DataLoader with the specified batch loader function and default options
      * (batching, caching and unlimited batch size) where the batch loader function returns a list of
      * {@link org.dataloader.Try} objects.
-     *
+     * <p>
      * If its important you to know the exact status of each item in a batch call and whether it threw exceptions then
      * you can use this form to create the data loader.
-     *
+     * <p>
      * Using Try objects allows you to capture a value returned or an exception that might
      * have occurred trying to get a value. .
      *
@@ -230,13 +230,13 @@ public static <K, V> DataLoader<K, V> newMappedDataLoader(MappedBatchLoader<K, V
      * Creates new DataLoader with the specified batch loader function and default options
      * (batching, caching and unlimited batch size) where the batch loader function returns a list of
      * {@link org.dataloader.Try} objects.
-     *
+     * <p>
      * If its important you to know the exact status of each item in a batch call and whether it threw exceptions then
      * you can use this form to create the data loader.
      *
      * Using Try objects allows you to capture a value returned or an exception that might
      * have occurred trying to get a value. .
-     *
+     * <p>
      * @param batchLoadFunction the batch load function to use that uses {@link org.dataloader.Try} objects
      * @param <K>               the key type
      * @param <V>               the value type
@@ -298,10 +298,10 @@ public static <K, V> DataLoader<K, V> newMappedDataLoader(MappedBatchLoaderWithC
      * Creates new DataLoader with the specified batch loader function and default options
      * (batching, caching and unlimited batch size) where the batch loader function returns a list of
      * {@link org.dataloader.Try} objects.
-     *
+     * <p>
      * If its important you to know the exact status of each item in a batch call and whether it threw exceptions then
      * you can use this form to create the data loader.
-     *
+     * <p>
      * Using Try objects allows you to capture a value returned or an exception that might
      * have occurred trying to get a value. .
      *
diff --git a/src/main/java/org/dataloader/MappedBatchLoader.java b/src/main/java/org/dataloader/MappedBatchLoader.java
@@ -23,7 +23,7 @@
 /**
  * A function that is invoked for batch loading a map of of data values indicated by the provided list of keys. The
  * function returns a promise of a map of results of individual load requests.
- *
+ * <p>
  * There are a few constraints that must be upheld:
  * <ul>
  * <li>The keys MUST be able to be first class keys in a Java map.  Get your equals() and hashCode() methods in order</li>
@@ -32,25 +32,25 @@
  * </li>
  * <li>The function MUST be resilient to the same key being presented twice.</li>
  * </ul>
- *
+ * <p>
  * This form is useful when you don't have a 1:1 mapping of keys to values or when null is an acceptable value for a missing value.
- *
+ * <p>
  * For example, let's assume you want to load users from a database, you could probably use a query that looks like this:
  *
  * <pre>
  *    SELECT * FROM User WHERE id IN (keys)
  * </pre>
- *
+ * <p>
  * Given say 10 user id keys you might only get 7 results back.  This can be more naturally represented in a map
  * than in an ordered list of values from the batch loader function.
- *
+ * <p>
  * When the map is processed by the {@link org.dataloader.DataLoader} code, any keys that are missing in the map
  * will be replaced with null values.  The semantic that the number of {@link org.dataloader.DataLoader#load(Object)} requests
  * are matched with and equal number of values is kept.
- *
+ * <p>
  * This means that if 10 keys are asked for then {@link DataLoader#dispatch()} will return a promise of 10 value results and each
  * of the {@link org.dataloader.DataLoader#load(Object)} will complete with a value, null or an exception.
- *
+ * <p>
  * When caching is disabled, its possible for the same key to be presented in the list of keys more than once.  Your map
  * batch loader function needs to be resilient to this situation.
  *
diff --git a/src/main/java/org/dataloader/MappedBatchLoaderWithContext.java b/src/main/java/org/dataloader/MappedBatchLoaderWithContext.java
@@ -24,7 +24,7 @@
  * This form of {@link MappedBatchLoader} is given a {@link org.dataloader.BatchLoaderEnvironment} object
  * that encapsulates the calling context.  A typical use case is passing in security credentials or database details
  * for example.
- *
+ * <p>
  * See {@link MappedBatchLoader} for more details on the design invariants that you must implement in order to
  * use this interface.
  */
diff --git a/src/main/java/org/dataloader/impl/PromisedValues.java b/src/main/java/org/dataloader/impl/PromisedValues.java
@@ -13,10 +13,10 @@
  * This allows multiple {@link CompletionStage}s to be combined together and completed
  * as one and should something go wrong, instead of throwing {@link CompletionException}s it captures the cause and returns null for that
  * data value, other wise it allows you to access them as a list of values.
- *
+ * <p>
  * This class really encapsulate a list of promised values.  It is considered finished when all of the underlying futures
  * are finished.
- *
+ * <p>
  * You can get that list of values via {@link #toList()}.  You can also compose a {@link CompletableFuture} of that
  * list of values via {@link #toCompletableFuture()} ()}
  *
diff --git a/src/main/java/org/dataloader/stats/ThreadLocalStatisticsCollector.java b/src/main/java/org/dataloader/stats/ThreadLocalStatisticsCollector.java
@@ -3,9 +3,9 @@
 /**
  * This can collect statistics per thread as well as in an overall sense.  This allows you to snapshot stats for a web request say
  * as well as all requests.
- *
+ * <p>
  * You will want to call {@link #resetThread()} to clean up the thread local aspects of this object per request thread.
- *
+ * <p>
  * ThreadLocals have their place in the Java world but be careful on how you use them.  If you don't clean them up on "request boundaries"
  * then you WILL have misleading statistics.
  *
