Improved the generics

Author: aschrijver

src/main/java/io/engagingspaces/vertx/dataloader/CacheMap.java

@@ -17,6 +17,7 @@
 package io.engagingspaces.vertx.dataloader;
 
 import io.engagingspaces.vertx.dataloader.impl.DefaultCacheMap;
+import io.vertx.core.Future;
 
 /**
  * Cache map interface for data loaders that use caching.
@@ -41,7 +42,7 @@ public interface CacheMap<U, V> {
      * @param <V> type parameter indicating the type of the data that is cached
      * @return the cache map
      */
-    static <U, V> CacheMap<U, V> simpleMap() {
+    static <U, V> CacheMap<U, Future<V>> simpleMap() {
         return new DefaultCacheMap<>();
     }
 
@@ -71,20 +72,20 @@ static <U, V> CacheMap<U, V> simpleMap() {
      * @param value the value to cache
      * @return the cache map for fluent coding
      */
-    CacheMap set(U key, V value);
+    CacheMap<U, V> set(U key, V value);
 
     /**
      * Deletes the entry with the specified key from the cache map, if it exists.
      *
      * @param key the key to delete
      * @return the cache map for fluent coding
      */
-    CacheMap delete(U key);
+    CacheMap<U, V> delete(U key);
 
     /**
      * Clears all entries of the cache map
      *
      * @return the cache map for fluent coding
      */
-    CacheMap clear();
+    CacheMap<U, V> clear();
 }

src/main/java/io/engagingspaces/vertx/dataloader/DataLoader.java

@@ -49,7 +49,7 @@
 public class DataLoader<K, V> {
 
     private final BatchLoader<K> batchLoadFunction;
-    private final DataLoaderOptions loaderOptions;
+    private final DataLoaderOptions<K, V> loaderOptions;
     private final CacheMap<Object, Future<V>> futureCache;
     private final LinkedHashMap<K, Future<V>> loaderQueue;
 
@@ -68,11 +68,12 @@ public DataLoader(BatchLoader<K> batchLoadFunction) {
      * @param batchLoadFunction the batch load function to use
      * @param options           the batch load options
      */
-    public DataLoader(BatchLoader<K> batchLoadFunction, DataLoaderOptions options) {
+    @SuppressWarnings("unchecked")
+    public DataLoader(BatchLoader<K> batchLoadFunction, DataLoaderOptions<K, V> options) {
         Objects.requireNonNull(batchLoadFunction, "Batch load function cannot be null");
         this.batchLoadFunction = batchLoadFunction;
-        this.loaderOptions = options == null ? new DataLoaderOptions() : options;
-        this.futureCache = loaderOptions.cacheMap().isPresent() ? loaderOptions.cacheMap().get() : CacheMap.simpleMap();
+        this.loaderOptions = options == null ? new DataLoaderOptions<>() : options;
+        this.futureCache = loaderOptions.cacheMap().isPresent() ? (CacheMap<Object, Future<V>>) loaderOptions.cacheMap().get() : CacheMap.simpleMap();
         this.loaderQueue = new LinkedHashMap<>();
     }
 

src/main/java/io/engagingspaces/vertx/dataloader/DataLoaderOptions.java

@@ -16,6 +16,7 @@
 
 package io.engagingspaces.vertx.dataloader;
 
+import io.vertx.core.Future;
 import io.vertx.core.json.JsonObject;
 
 import java.util.Objects;
@@ -26,12 +27,12 @@
  *
  * @author <a href="https://github.com/aschrijver/">Arnold Schrijver</a>
  */
-public class DataLoaderOptions {
+public class DataLoaderOptions<K, V> {
 
     private boolean batchingEnabled;
     private boolean cachingEnabled;
     private CacheKey cacheKeyFunction;
-    private CacheMap cacheMap;
+    private CacheMap<K, Future<V>> cacheMap;
 
     /**
      * Creates a new data loader options with default settings.
@@ -41,12 +42,16 @@ public DataLoaderOptions() {
         cachingEnabled = true;
     }
 
+    public static <K, V> DataLoaderOptions<K, V> create() {
+        return new DataLoaderOptions<>();
+    }
+
     /**
      * Clones the provided data loader options.
      *
      * @param other the other options instance
      */
-    public DataLoaderOptions(DataLoaderOptions other) {
+    public DataLoaderOptions(DataLoaderOptions<K, V> other) {
         Objects.requireNonNull(other, "Other data loader options cannot be null");
         this.batchingEnabled = other.batchingEnabled;
         this.cachingEnabled = other.cachingEnabled;
@@ -139,7 +144,7 @@ public DataLoaderOptions setCacheKeyFunction(CacheKey cacheKeyFunction) {
      *
      * @return an optional with the cache map instance, or empty
      */
-    public Optional<CacheMap> cacheMap() {
+    public Optional<CacheMap<K, Future<V>>> cacheMap() {
         return Optional.ofNullable(cacheMap);
     }
 
@@ -149,7 +154,7 @@ public Optional<CacheMap> cacheMap() {
      * @param cacheMap the cache map instance
      * @return the data loader options for fluent coding
      */
-    public DataLoaderOptions setCacheMap(CacheMap cacheMap) {
+    public DataLoaderOptions setCacheMap(CacheMap<K, Future<V>> cacheMap) {
         this.cacheMap = cacheMap;
         return this;
     }

src/main/java/io/engagingspaces/vertx/dataloader/impl/DefaultCacheMap.java

@@ -22,15 +22,16 @@
 import java.util.Map;
 
 /**
+ * Default implementation of {@link CacheMap} that is based on a regular {@link java.util.LinkedHashMap}.
  *
- * @param <K>
- * @param <V>
+ * @param <U> type parameter indicating the type of the cache keys
+ * @param <V> type parameter indicating the type of the data that is cached
  *
  * @author <a href="https://github.com/aschrijver/">Arnold Schrijver</a>
  */
-public class DefaultCacheMap<K, V> implements CacheMap<K, V> {
+public class DefaultCacheMap<U, V> implements CacheMap<U, V> {
 
-    private Map<K, V> cache;
+    private Map<U, V> cache;
 
     /**
      * Default constructor
@@ -43,23 +44,23 @@ public DefaultCacheMap() {
      * {@inheritDoc}
      */
     @Override
-    public boolean containsKey(K key) {
+    public boolean containsKey(U key) {
         return cache.containsKey(key);
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
-    public V get(K key) {
+    public V get(U key) {
         return cache.get(key);
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
-    public CacheMap set(K key, V value) {
+    public CacheMap<U, V> set(U key, V value) {
         cache.put(key, value);
         return this;
     }
@@ -68,7 +69,7 @@ public CacheMap set(K key, V value) {
      * {@inheritDoc}
      */
     @Override
-    public CacheMap delete(K key) {
+    public CacheMap<U, V> delete(U key) {
         cache.remove(key);
         return this;
     }
@@ -77,7 +78,7 @@ public CacheMap delete(K key) {
      * {@inheritDoc}
      */
     @Override
-    public CacheMap clear() {
+    public CacheMap<U, V> clear() {
         cache.clear();
         return this;
     }

src/test/java/io/engagingspaces/vertx/dataloader/DataLoaderTest.java

@@ -54,7 +54,7 @@ public class DataLoaderTest {
 
     @Before
     public void setUp() {
-        identityLoader = idLoader(new DataLoaderOptions(), new ArrayList<>());
+        identityLoader = idLoader(new DataLoaderOptions<>(), new ArrayList<>());
     }
 
     @Test
@@ -108,7 +108,7 @@ public void should_Resolve_to_empty_list_when_no_keys_supplied() {
     @Test
     public void should_Batch_multiple_requests() {
         ArrayList<Collection> loadCalls = new ArrayList<>();
-        DataLoader<Integer, Integer> identityLoader = idLoader(new DataLoaderOptions(), loadCalls);
+        DataLoader<Integer, Integer> identityLoader = idLoader(new DataLoaderOptions<>(), loadCalls);
 
         Future<Integer> future1 = identityLoader.load(1);
         Future<Integer> future2 = identityLoader.load(2);
@@ -123,7 +123,7 @@ public void should_Batch_multiple_requests() {
     @Test
     public void should_Coalesce_identical_requests() {
         ArrayList<Collection> loadCalls = new ArrayList<>();
-        DataLoader<Integer, Integer> identityLoader = idLoader(new DataLoaderOptions(), loadCalls);
+        DataLoader<Integer, Integer> identityLoader = idLoader(new DataLoaderOptions<>(), loadCalls);
 
         Future<Integer> future1a = identityLoader.load(1);
         Future<Integer> future1b = identityLoader.load(1);
@@ -139,7 +139,7 @@ public void should_Coalesce_identical_requests() {
     @Test
     public void should_Cache_repeated_requests() {
         ArrayList<Collection> loadCalls = new ArrayList<>();
-        DataLoader<String, String> identityLoader = idLoader(new DataLoaderOptions(), loadCalls);
+        DataLoader<String, String> identityLoader = idLoader(new DataLoaderOptions<>(), loadCalls);
 
         Future<String> future1 = identityLoader.load("A");
         Future<String> future2 = identityLoader.load("B");
@@ -174,7 +174,7 @@ public void should_Cache_repeated_requests() {
     @Test
     public void should_Clear_single_value_in_loader() {
         ArrayList<Collection> loadCalls = new ArrayList<>();
-        DataLoader<String, String> identityLoader = idLoader(new DataLoaderOptions(), loadCalls);
+        DataLoader<String, String> identityLoader = idLoader(new DataLoaderOptions<>(), loadCalls);
 
         Future<String> future1 = identityLoader.load("A");
         Future<String> future2 = identityLoader.load("B");
@@ -200,7 +200,7 @@ public void should_Clear_single_value_in_loader() {
     @Test
     public void should_Clear_all_values_in_loader() {
         ArrayList<Collection> loadCalls = new ArrayList<>();
-        DataLoader<String, String> identityLoader = idLoader(new DataLoaderOptions(), loadCalls);
+        DataLoader<String, String> identityLoader = idLoader(new DataLoaderOptions<>(), loadCalls);
 
         Future<String> future1 = identityLoader.load("A");
         Future<String> future2 = identityLoader.load("B");
@@ -226,7 +226,7 @@ public void should_Clear_all_values_in_loader() {
     @Test
     public void should_Allow_priming_the_cache() {
         ArrayList<Collection> loadCalls = new ArrayList<>();
-        DataLoader<String, String> identityLoader = idLoader(new DataLoaderOptions(), loadCalls);
+        DataLoader<String, String> identityLoader = idLoader(new DataLoaderOptions<>(), loadCalls);
 
         identityLoader.prime("A", "A");
 
@@ -243,7 +243,7 @@ public void should_Allow_priming_the_cache() {
     @Test
     public void should_Not_prime_keys_that_already_exist() {
         ArrayList<Collection> loadCalls = new ArrayList<>();
-        DataLoader<String, String> identityLoader = idLoader(new DataLoaderOptions(), loadCalls);
+        DataLoader<String, String> identityLoader = idLoader(new DataLoaderOptions<>(), loadCalls);
 
         identityLoader.prime("A", "X");
 
@@ -271,7 +271,7 @@ public void should_Not_prime_keys_that_already_exist() {
     @Test
     public void should_Allow_to_forcefully_prime_the_cache() {
         ArrayList<Collection> loadCalls = new ArrayList<>();
-        DataLoader<String, String> identityLoader = idLoader(new DataLoaderOptions(), loadCalls);
+        DataLoader<String, String> identityLoader = idLoader(new DataLoaderOptions<>(), loadCalls);
 
         identityLoader.prime("A", "X");
 
@@ -299,7 +299,7 @@ public void should_Allow_to_forcefully_prime_the_cache() {
     @Test
     public void should_Resolve_to_error_to_indicate_failure() {
         ArrayList<Collection> loadCalls = new ArrayList<>();
-        DataLoader<Integer, Integer> evenLoader = idLoaderWithErrors(new DataLoaderOptions(), loadCalls);
+        DataLoader<Integer, Integer> evenLoader = idLoaderWithErrors(new DataLoaderOptions<>(), loadCalls);
 
         Future<Integer> future1 = evenLoader.load(1);
         evenLoader.dispatch();
@@ -319,7 +319,7 @@ public void should_Resolve_to_error_to_indicate_failure() {
     @Test
     public void should_Represent_failures_and_successes_simultaneously() {
         ArrayList<Collection> loadCalls = new ArrayList<>();
-        DataLoader<Integer, Integer> evenLoader = idLoaderWithErrors(new DataLoaderOptions(), loadCalls);
+        DataLoader<Integer, Integer> evenLoader = idLoaderWithErrors(new DataLoaderOptions<>(), loadCalls);
 
         Future<Integer> future1 = evenLoader.load(1);
         Future<Integer> future2 = evenLoader.load(2);
@@ -337,7 +337,7 @@ public void should_Represent_failures_and_successes_simultaneously() {
     @Test
     public void should_Cache_failed_fetches() {
         ArrayList<Collection> loadCalls = new ArrayList<>();
-        DataLoader<Integer, Integer> errorLoader = idLoaderAllErrors(new DataLoaderOptions(), loadCalls);
+        DataLoader<Integer, Integer> errorLoader = idLoaderAllErrors(new DataLoaderOptions<>(), loadCalls);
 
         Future<Integer> future1 = errorLoader.load(1);
         errorLoader.dispatch();
@@ -358,7 +358,7 @@ public void should_Cache_failed_fetches() {
     @Test
     public void should_Handle_priming_the_cache_with_an_error() {
         ArrayList<Collection> loadCalls = new ArrayList<>();
-        DataLoader<Integer, Integer> identityLoader = idLoader(new DataLoaderOptions(), loadCalls);
+        DataLoader<Integer, Integer> identityLoader = idLoader(new DataLoaderOptions<>(), loadCalls);
 
         identityLoader.prime(1, new IllegalStateException("Error"));
 
@@ -374,7 +374,7 @@ public void should_Handle_priming_the_cache_with_an_error() {
     @Test
     public void should_Clear_values_from_cache_after_errors() {
         ArrayList<Collection> loadCalls = new ArrayList<>();
-        DataLoader<Integer, Integer> errorLoader = idLoaderAllErrors(new DataLoaderOptions(), loadCalls);
+        DataLoader<Integer, Integer> errorLoader = idLoaderAllErrors(new DataLoaderOptions<>(), loadCalls);
 
         Future<Integer> future1 = errorLoader.load(1);
         future1.setHandler(rh -> {
@@ -405,7 +405,7 @@ public void should_Clear_values_from_cache_after_errors() {
     }
 
     @SuppressWarnings("unchecked")
-    private static <K, V> DataLoader<K, V> idLoader(DataLoaderOptions options, List<Collection> loadCalls) {
+    private static <K, V> DataLoader<K, V> idLoader(DataLoaderOptions<K, V> options, List<Collection> loadCalls) {
         return new DataLoader<>(keys -> {
             loadCalls.add(new ArrayList(keys));
             List<Future> futures = keys.stream().map(Future::succeededFuture).collect(Collectors.toList());
@@ -414,7 +414,8 @@ private static <K, V> DataLoader<K, V> idLoader(DataLoaderOptions options, List<
     }
 
     @SuppressWarnings("unchecked")
-    private static <K, V> DataLoader<K, V> idLoaderAllErrors(DataLoaderOptions options, List<Collection> loadCalls) {
+    private static <K, V> DataLoader<K, V> idLoaderAllErrors(
+            DataLoaderOptions<K, V> options, List<Collection> loadCalls) {
         return new DataLoader<>(keys -> {
             loadCalls.add(new ArrayList(keys));
             List<Future> futures = keys.stream()
@@ -426,7 +427,7 @@ private static <K, V> DataLoader<K, V> idLoaderAllErrors(DataLoaderOptions optio
 
     @SuppressWarnings("unchecked")
     private static DataLoader<Integer, Integer> idLoaderWithErrors(
-            DataLoaderOptions options, List<Collection> loadCalls) {
+            DataLoaderOptions<Integer, Integer> options, List<Collection> loadCalls) {
         return new DataLoader<>(keys -> {
             loadCalls.add(new ArrayList(keys));
             List<Future> futures = keys.stream()