Made the registry using a key pattern so they can be looked up by name in reverse

Author: bbakerman

README.md

@@ -265,7 +265,7 @@ Here is how you might put this in place:
         // in this case there is 1 but you can have many
         //
         DataLoaderRegistry registry = new DataLoaderRegistry();
-        registry.register(characterDataLoader);
+        registry.register("character", characterDataLoader);
 
         //
         // this instrumentation implementation will dispatched all the dataloaders

src/main/java/org/dataloader/DataLoaderRegistry.java

@@ -1,54 +1,92 @@
 package org.dataloader;
 
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
-import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 
 /**
  * This allows data loaders to be registered together into a single place so
- * they can be dispatched as one.
+ * they can be dispatched as one.  It also allows you to retrieve data loaders by
+ * name from a central place
  */
 public class DataLoaderRegistry {
-    private final List<DataLoader<?, ?>> dataLoaders = new CopyOnWriteArrayList<>();
+    private final Map<String, DataLoader<?, ?>> dataLoaders = new ConcurrentHashMap<>();
+
+    /**
+     * This will register a new dataloader
+     *
+     * @param key        the key to put the data loader under
+     * @param dataLoader the data loader to register
+     *
+     * @return this registry
+     */
+    public DataLoaderRegistry register(String key, DataLoader<?, ?> dataLoader) {
+        dataLoaders.put(key, dataLoader);
+        return this;
+    }
+
+    /**
+     * This will combine all the current data loaders in this registry and all the data loaders from the specified registry
+     * and return a new combined registry
+     *
+     * @param registry the registry to combine into this registry
+     *
+     * @return a new combined registry
+     */
+    public DataLoaderRegistry combine(DataLoaderRegistry registry) {
+        DataLoaderRegistry combined = new DataLoaderRegistry();
+
+        this.dataLoaders.forEach(combined::register);
+        registry.dataLoaders.forEach(combined::register);
+        return combined;
+    }
 
     /**
      * @return the currently registered data loaders
      */
     public List<DataLoader<?, ?>> getDataLoaders() {
-        return new ArrayList<>(dataLoaders);
+        return new ArrayList<>(dataLoaders.values());
     }
 
     /**
-     * This will register a new dataloader
+     * This will unregister a new dataloader
      *
-     * @param dataLoader the data loader to register
+     * @param key the key of the data loader to unregister
      *
      * @return this registry
      */
-    public DataLoaderRegistry register(DataLoader<?, ?> dataLoader) {
-        if (!dataLoaders.contains(dataLoader)) {
-            dataLoaders.add(dataLoader);
-        }
+    public DataLoaderRegistry unregister(String key) {
+        dataLoaders.remove(key);
         return this;
     }
 
     /**
-     * This will unregister a new dataloader
+     * Returns the dataloader that was registered under the specified key
      *
-     * @param dataLoader the data loader to unregister
+     * @param key the key of the data loader
      *
-     * @return this registry
+     * @return a data loader or null if its not present
      */
-    public DataLoaderRegistry unregister(DataLoader<?, ?> dataLoader) {
-        dataLoaders.remove(dataLoader);
-        return this;
+    public <K, V> DataLoader<K, V> getDataLoader(String key) {
+        //noinspection unchecked
+        return (DataLoader<K, V>) dataLoaders.get(key);
+    }
+
+    /**
+     * @return the keys of the data loaders in this registry
+     */
+    public Set<String> getKeys() {
+        return new HashSet<>(dataLoaders.keySet());
     }
 
     /**
      * This will called {@link org.dataloader.DataLoader#dispatch()} on each of the registered
      * {@link org.dataloader.DataLoader}s
      */
     public void dispatchAll() {
-        dataLoaders.forEach(DataLoader::dispatch);
+        getDataLoaders().forEach(DataLoader::dispatch);
     }
 }

src/test/java/ReadmeExamples.java

@@ -124,7 +124,7 @@ public Object get(DataFetchingEnvironment environment) {
         // in this case there is 1 but you can have many
         //
         DataLoaderRegistry registry = new DataLoaderRegistry();
-        registry.register(characterDataLoader);
+        registry.register("character", characterDataLoader);
 
         //
         // this instrumentation implementation will dispatched all the dataloaders

src/test/java/org/dataloader/DataLoaderRegistryTest.java

@@ -6,6 +6,8 @@
 
 import static java.util.Arrays.asList;
 import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.hasItems;
+import static org.hamcrest.Matchers.sameInstance;
 import static org.junit.Assert.assertThat;
 
 public class DataLoaderRegistryTest {
@@ -19,7 +21,7 @@ public void registration_works() throws Exception {
 
         DataLoaderRegistry registry = new DataLoaderRegistry();
 
-        registry.register(dlA).register(dlB).register(dlC);
+        registry.register("a", dlA).register("b", dlB).register("c", dlC);
 
         assertThat(registry.getDataLoaders(), equalTo(asList(dlA, dlB, dlC)));
 
@@ -28,14 +30,42 @@ public void registration_works() throws Exception {
 
         registry = new DataLoaderRegistry();
 
-        registry.register(dlA).register(dlB).register(dlC).register(dlA).register(dlB);
+        registry.register("a", dlA).register("b", dlB).register("c", dlC).register("b", dlB);
 
         assertThat(registry.getDataLoaders(), equalTo(asList(dlA, dlB, dlC)));
 
 
         // and unregister
-        registry.unregister(dlC);
+        registry.unregister("c");
 
         assertThat(registry.getDataLoaders(), equalTo(asList(dlA, dlB)));
+
+        // look up by name works
+        DataLoader<String, String> readDL = registry.getDataLoader("a");
+        assertThat(readDL, sameInstance(dlA));
+
+        assertThat(registry.getKeys(), hasItems("a", "b"));
+    }
+
+    @Test
+    public void registries_can_be_combined() throws Exception {
+
+        DataLoader<Object, Object> dlA = new DataLoader<>(identityBatchLoader);
+        DataLoader<Object, Object> dlB = new DataLoader<>(identityBatchLoader);
+        DataLoader<Object, Object> dlC = new DataLoader<>(identityBatchLoader);
+        DataLoader<Object, Object> dlD = new DataLoader<>(identityBatchLoader);
+
+        DataLoaderRegistry registry1 = new DataLoaderRegistry();
+
+        registry1.register("a", dlA).register("b", dlB);
+
+        DataLoaderRegistry registry2 = new DataLoaderRegistry();
+
+        registry2.register("c", dlC).register("d", dlD);
+
+        DataLoaderRegistry combinedRegistry = registry1.combine(registry2);
+
+        assertThat(combinedRegistry.getKeys(), hasItems("a", "b", "c", "d"));
+        assertThat(combinedRegistry.getDataLoaders(), hasItems(dlA, dlB, dlC, dlD));
     }
 }

src/test/java/org/dataloader/graphql/DataLoaderDispatcherInstrumentationTest.java

@@ -40,9 +40,9 @@ public void basic_invocation() throws Exception {
         DataLoader<Object, Object> dlB = new DataLoader<>(batchLoader);
         DataLoader<Object, Object> dlC = new DataLoader<>(batchLoader);
         DataLoaderRegistry registry = new DataLoaderRegistry()
-                .register(dlA)
-                .register(dlB)
-                .register(dlC);
+                .register("a", dlA)
+                .register("b", dlB)
+                .register("b", dlC);
 
         DataLoaderDispatcherInstrumentation dispatcher = new DataLoaderDispatcherInstrumentation(registry);
         InstrumentationContext<CompletableFuture<ExecutionResult>> context = dispatcher.beginExecutionStrategy(null);
@@ -66,7 +66,7 @@ public void exceptions_wont_cause_dispatches() throws Exception {
 
         DataLoader<Object, Object> dlA = new DataLoader<>(batchLoader);
         DataLoaderRegistry registry = new DataLoaderRegistry()
-                .register(dlA);
+                .register("a", dlA);
 
         DataLoaderDispatcherInstrumentation dispatcher = new DataLoaderDispatcherInstrumentation(registry);
         InstrumentationContext<CompletableFuture<ExecutionResult>> context = dispatcher.beginExecutionStrategy(null);