Add runtime support for set-components.

vkryachko · vkryachko · commit 96acdf2648fa · 2018-12-19T17:34:10.000-05:00
diff --git a/firebase-common/src/main/java/com/google/firebase/components/AbstractComponentContainer.java b/firebase-common/src/main/java/com/google/firebase/components/AbstractComponentContainer.java
@@ -15,6 +15,7 @@
 package com.google.firebase.components;
 
 import com.google.firebase.inject.Provider;
+import java.util.Set;
 
 abstract class AbstractComponentContainer implements ComponentContainer {
   @Override
@@ -25,4 +26,9 @@ public <T> T get(Class<T> anInterface) {
     }
     return provider.get();
   }
+
+  @Override
+  public <T> Set<T> setOf(Class<T> anInterface) {
+    return setOfProvider(anInterface).get();
+  }
 }
diff --git a/firebase-common/src/main/java/com/google/firebase/components/ComponentContainer.java b/firebase-common/src/main/java/com/google/firebase/components/ComponentContainer.java
@@ -16,6 +16,7 @@
 
 import com.google.android.gms.common.annotation.KeepForSdk;
 import com.google.firebase.inject.Provider;
+import java.util.Set;
 
 /** Provides a means to retrieve instances of requested classes/interfaces. */
 @KeepForSdk
@@ -25,4 +26,10 @@ public interface ComponentContainer {
 
   @KeepForSdk
   <T> Provider<T> getProvider(Class<T> anInterface);
+
+  @KeepForSdk
+  <T> Set<T> setOf(Class<T> anInterface);
+
+  @KeepForSdk
+  <T> Provider<Set<T>> setOfProvider(Class<T> anInterface);
 }
diff --git a/firebase-common/src/main/java/com/google/firebase/components/ComponentRuntime.java b/firebase-common/src/main/java/com/google/firebase/components/ComponentRuntime.java
@@ -21,8 +21,10 @@
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import java.util.concurrent.Executor;
 
 /**
@@ -32,8 +34,10 @@
  * Component}s via {@link #get(Class)} method.
  */
 public class ComponentRuntime extends AbstractComponentContainer {
-  private final List<Component<?>> components;
+  private static final Provider<Set<Object>> EMPTY_PROVIDER = Collections::emptySet;
+  private final Map<Component<?>, Lazy<?>> components = new HashMap<>();
   private final Map<Class<?>, Lazy<?>> lazyInstanceMap = new HashMap<>();
+  private final Map<Class<?>, Lazy<Set<?>>> lazySetMap = new HashMap<>();
   private final EventBus eventBus;
 
   /**
@@ -54,12 +58,49 @@ public ComponentRuntime(
     Collections.addAll(componentsToAdd, additionalComponents);
 
     CycleDetector.detect(componentsToAdd);
-    components = Collections.unmodifiableList(componentsToAdd);
 
-    for (Component<?> component : components) {
+    for (Component<?> component : componentsToAdd) {
       register(component);
     }
     validateDependencies();
+
+    processSetComponents();
+  }
+
+  /** Populates lazySetMap to make set components available for consumption via set dependencies. */
+  private void processSetComponents() {
+    Map<Class<?>, Set<Lazy<?>>> setIndex = new HashMap<>();
+    for (Map.Entry<Component<?>, Lazy<?>> entry : components.entrySet()) {
+      Component<?> component = entry.getKey();
+
+      // only process set components.
+      if (component.isValue()) {
+        continue;
+      }
+
+      Lazy<?> lazy = entry.getValue();
+
+      for (Class<?> anInterface : component.getProvidedInterfaces()) {
+        if (!setIndex.containsKey(anInterface)) {
+          setIndex.put(anInterface, new HashSet<>());
+        }
+        setIndex.get(anInterface).add(lazy);
+      }
+    }
+
+    for (Map.Entry<Class<?>, Set<Lazy<?>>> entry : setIndex.entrySet()) {
+      Set<Lazy<?>> lazies = entry.getValue();
+      lazySetMap.put(
+          entry.getKey(),
+          new Lazy<>(
+              () -> {
+                Set<Object> set = new HashSet<>();
+                for (Lazy<?> lazy : lazies) {
+                  set.add(lazy.get());
+                }
+                return Collections.unmodifiableSet(set);
+              }));
+    }
   }
 
   @Override
@@ -69,6 +110,16 @@ public <T> Provider<T> getProvider(Class<T> anInterface) {
     return (Provider<T>) lazyInstanceMap.get(anInterface);
   }
 
+  @Override
+  @SuppressWarnings("unchecked")
+  public <T> Provider<Set<T>> setOfProvider(Class<T> anInterface) {
+    Lazy<Set<?>> lazy = lazySetMap.get(anInterface);
+    if (lazy != null) {
+      return (Provider<Set<T>>) (Provider<?>) lazy;
+    }
+    return (Provider<Set<T>>) (Provider<?>) EMPTY_PROVIDER;
+  }
+
   /**
    * Initializes all eager components.
    *
@@ -77,10 +128,12 @@ public <T> Provider<T> getProvider(Class<T> anInterface) {
    * <p>Note: the method is idempotent.
    */
   public void initializeEagerComponents(boolean isDefaultApp) {
-    for (Component<?> component : components) {
+    for (Map.Entry<Component<?>, Lazy<?>> entry : components.entrySet()) {
+      Component<?> component = entry.getKey();
+      Lazy<?> lazy = entry.getValue();
+
       if (component.isAlwaysEager() || (component.isEagerInDefaultApp() && isDefaultApp)) {
-        // at least one interface is guarenteed to be provided by a component.
-        get(component.getProvidedInterfaces().iterator().next());
+        lazy.get();
       }
     }
 
@@ -89,15 +142,20 @@ public void initializeEagerComponents(boolean isDefaultApp) {
 
   private <T> void register(Component<T> component) {
     Lazy<T> lazy =
-        new Lazy<>(component.getFactory(), new RestrictedComponentContainer(component, this));
+        new Lazy<>(
+            () -> component.getFactory().create(new RestrictedComponentContainer(component, this)));
 
+    components.put(component, lazy);
+    if (!component.isValue()) {
+      return;
+    }
     for (Class<? super T> anInterface : component.getProvidedInterfaces()) {
       lazyInstanceMap.put(anInterface, lazy);
     }
   }
 
   private void validateDependencies() {
-    for (Component<?> component : components) {
+    for (Component<?> component : components.keySet()) {
       for (Dependency dependency : component.getDependencies()) {
         if (dependency.isRequired() && !lazyInstanceMap.containsKey(dependency.getInterface())) {
           throw new MissingDependencyException(
diff --git a/firebase-common/src/main/java/com/google/firebase/components/Lazy.java b/firebase-common/src/main/java/com/google/firebase/components/Lazy.java
@@ -38,9 +38,8 @@ class Lazy<T> implements Provider<T> {
     this.instance = instance;
   }
 
-  /** Creates a lazy backed by a {@link ComponentFactory} and {@link ComponentContainer}. */
-  Lazy(ComponentFactory<T> factory, ComponentContainer container) {
-    provider = () -> factory.create(container);
+  Lazy(Provider<T> provider) {
+    this.provider = provider;
   }
 
   /** Returns the initialized value. */
@@ -59,7 +58,10 @@ public T get() {
         }
       }
     }
-    return (T) result;
+
+    @SuppressWarnings("unchecked")
+    T tResult = (T) result;
+    return tResult;
   }
 
   @VisibleForTesting
diff --git a/firebase-common/src/main/java/com/google/firebase/components/RestrictedComponentContainer.java b/firebase-common/src/main/java/com/google/firebase/components/RestrictedComponentContainer.java
@@ -28,24 +28,38 @@
 final class RestrictedComponentContainer extends AbstractComponentContainer {
   private final Set<Class<?>> allowedDirectInterfaces;
   private final Set<Class<?>> allowedProviderInterfaces;
+  private final Set<Class<?>> allowedSetDirectInterfaces;
+  private final Set<Class<?>> allowedSetProviderInterfaces;
   private final Set<Class<?>> allowedPublishedEvents;
   private final ComponentContainer delegateContainer;
 
   RestrictedComponentContainer(Component<?> component, ComponentContainer container) {
     Set<Class<?>> directInterfaces = new HashSet<>();
     Set<Class<?>> providerInterfaces = new HashSet<>();
+    Set<Class<?>> setDirectInterfaces = new HashSet<>();
+    Set<Class<?>> setProviderInterfaces = new HashSet<>();
     for (Dependency dependency : component.getDependencies()) {
       if (dependency.isDirectInjection()) {
-        directInterfaces.add(dependency.getInterface());
+        if (dependency.isSet()) {
+          setDirectInterfaces.add(dependency.getInterface());
+        } else {
+          directInterfaces.add(dependency.getInterface());
+        }
       } else {
-        providerInterfaces.add(dependency.getInterface());
+        if (dependency.isSet()) {
+          setProviderInterfaces.add(dependency.getInterface());
+        } else {
+          providerInterfaces.add(dependency.getInterface());
+        }
       }
     }
     if (!component.getPublishedEvents().isEmpty()) {
       directInterfaces.add(Publisher.class);
     }
     allowedDirectInterfaces = Collections.unmodifiableSet(directInterfaces);
     allowedProviderInterfaces = Collections.unmodifiableSet(providerInterfaces);
+    allowedSetDirectInterfaces = Collections.unmodifiableSet(setDirectInterfaces);
+    allowedSetProviderInterfaces = Collections.unmodifiableSet(setProviderInterfaces);
     allowedPublishedEvents = component.getPublishedEvents();
     delegateContainer = container;
   }
@@ -54,7 +68,7 @@ final class RestrictedComponentContainer extends AbstractComponentContainer {
   public <T> T get(Class<T> anInterface) {
     if (!allowedDirectInterfaces.contains(anInterface)) {
       throw new IllegalArgumentException(
-          String.format("Requesting %s is not allowed.", anInterface));
+          String.format("Attempting to request an undeclared dependency %s.", anInterface));
     }
 
     // The container is guaranteed to contain a class keyed with Publisher.class. This is what we
@@ -75,11 +89,31 @@ public <T> T get(Class<T> anInterface) {
   public <T> Provider<T> getProvider(Class<T> anInterface) {
     if (!allowedProviderInterfaces.contains(anInterface)) {
       throw new IllegalArgumentException(
-          String.format("Requesting Provider<%s> is not allowed.", anInterface));
+          String.format(
+              "Attempting to request an undeclared dependency Provider<%s>.", anInterface));
     }
     return delegateContainer.getProvider(anInterface);
   }
 
+  @Override
+  public <T> Provider<Set<T>> setOfProvider(Class<T> anInterface) {
+    if (!allowedSetProviderInterfaces.contains(anInterface)) {
+      throw new IllegalArgumentException(
+          String.format(
+              "Attempting to request an undeclared dependency Provider<Set<%s>>.", anInterface));
+    }
+    return delegateContainer.setOfProvider(anInterface);
+  }
+
+  @Override
+  public <T> Set<T> setOf(Class<T> anInterface) {
+    if (!allowedSetDirectInterfaces.contains(anInterface)) {
+      throw new IllegalArgumentException(
+          String.format("Attempting to request an undeclared dependency Set<%s>.", anInterface));
+    }
+    return delegateContainer.setOf(anInterface);
+  }
+
   /**
    * An implementation of {@link Publisher} that is backed by another delegate {@link Publisher} and
    * restricts publishing to only a set of allowed event types.
diff --git a/firebase-common/src/test/java/com/google/firebase/components/ComponentRuntimeTest.java b/firebase-common/src/test/java/com/google/firebase/components/ComponentRuntimeTest.java
@@ -233,4 +233,37 @@ public void container_shouldExposeAllProvidedInterfacesOfAComponent() {
     assertThat(child).isSameAs(parent);
     assertThat(child.get()).isSameAs(parent.get());
   }
+
+  @Test
+  public void container_shouldExposeAllRegisteredSetValues() {
+    ComponentRuntime runtime =
+        new ComponentRuntime(
+            EXECUTOR,
+            Collections.emptyList(),
+            Component.intoSet(1, Integer.class),
+            Component.intoSet(2, Integer.class));
+
+    assertThat(runtime.setOf(Integer.class)).containsExactly(1, 2);
+  }
+
+  @Test
+  public void setComponents_shouldParticipateInCycleDetection() {
+    try {
+      new ComponentRuntime(
+          EXECUTOR,
+          Collections.emptyList(),
+          Component.builder(ComponentOne.class)
+              .add(Dependency.setOf(Integer.class))
+              .factory(c -> null)
+              .build(),
+          Component.intoSet(1, Integer.class),
+          Component.intoSetBuilder(Integer.class)
+              .add(Dependency.required(ComponentOne.class))
+              .factory(c -> 2)
+              .build());
+      fail("Expected exception not thrown.");
+    } catch (DependencyCycleException ex) {
+      // success.
+    }
+  }
 }
diff --git a/firebase-common/src/test/java/com/google/firebase/components/LazyTest.java b/firebase-common/src/test/java/com/google/firebase/components/LazyTest.java
diff --git a/firebase-common/src/test/java/com/google/firebase/components/RestrictedComponentContainerTest.java b/firebase-common/src/test/java/com/google/firebase/components/RestrictedComponentContainerTest.java

Original file line number	Diff line number	Diff line change
`@@ -15,6 +15,7 @@`
`15`	`15`	`package com.google.firebase.components;`
`16`	`16`
`17`	`17`	`import com.google.firebase.inject.Provider;`
	`18`	`+import java.util.Set;`
`18`	`19`
`19`	`20`	`abstract class AbstractComponentContainer implements ComponentContainer {`
`20`	`21`	`@Override`
`@@ -25,4 +26,9 @@ public <T> T get(Class<T> anInterface) {`
`25`	`26`	`}`
`26`	`27`	`return provider.get();`
`27`	`28`	`}`
	`29`	`+`
	`30`	`+ @Override`
	`31`	`+ public <T> Set<T> setOf(Class<T> anInterface) {`
	`32`	`+ return setOfProvider(anInterface).get();`
	`33`	`+ }`
`28`	`34`	`}`
Original file line number	Diff line number	Diff line change
`@@ -38,9 +38,8 @@ class Lazy<T> implements Provider<T> {`
`38`	`38`	`this.instance = instance;`
`39`	`39`	`}`
`40`	`40`
`41`		`- /** Creates a lazy backed by a {@link ComponentFactory} and {@link ComponentContainer}. */`
`42`		`- Lazy(ComponentFactory<T> factory, ComponentContainer container) {`
`43`		`- provider = () -> factory.create(container);`
	`41`	`+ Lazy(Provider<T> provider) {`
	`42`	`+ this.provider = provider;`
`44`	`43`	`}`
`45`	`44`
`46`	`45`	`/** Returns the initialized value. */`
`@@ -59,7 +58,10 @@ public T get() {`
`59`	`58`	`}`
`60`	`59`	`}`
`61`	`60`	`}`
`62`		`- return (T) result;`
	`61`	`+`
	`62`	`+ @SuppressWarnings("unchecked")`
	`63`	`+ T tResult = (T) result;`
	`64`	`+ return tResult;`
`63`	`65`	`}`
`64`	`66`
`65`	`67`	`@VisibleForTesting`