All Downloads are FREE. Search and download functionalities are using the official Maven repository.

shaded.com.google.inject.internal.RealMultibinder Maven / Gradle / Ivy

There is a newer version: 4.1.4
Show newest version
package shaded.shaded.com.google.inject.internal;

import static shaded.shaded.com.google.inject.internal.Element.Type.MULTIBINDER;
import static shaded.shaded.com.google.inject.internal.Errors.checkConfiguration;
import static shaded.shaded.com.google.inject.internal.Errors.checkNotNull;
import static shaded.shaded.com.google.inject.name.Names.named;

import shaded.shaded.com.google.common.base.Objects;
import shaded.shaded.com.google.common.collect.ImmutableList;
import shaded.shaded.com.google.common.collect.ImmutableSet;
import shaded.shaded.com.google.common.collect.Lists;
import shaded.shaded.com.google.common.collect.Sets;
import shaded.shaded.com.google.inject.AbstractModule;
import shaded.shaded.com.google.inject.Binder;
import shaded.shaded.com.google.inject.Binding;
import shaded.shaded.com.google.inject.Injector;
import shaded.shaded.com.google.inject.Key;
import shaded.shaded.com.google.inject.Module;
import shaded.shaded.com.google.inject.Provider;
import shaded.shaded.com.google.inject.TypeLiteral;
import shaded.shaded.com.google.inject.binder.LinkedBindingBuilder;
import shaded.shaded.com.google.inject.internal.InternalProviderInstanceBindingImpl.InitializationTiming;
import shaded.shaded.com.google.inject.multibindings.MultibinderBinding;
import shaded.shaded.com.google.inject.multibindings.MultibindingsTargetVisitor;
import shaded.shaded.com.google.inject.spi.BindingTargetVisitor;
import shaded.shaded.com.google.inject.spi.Dependency;
import shaded.shaded.com.google.inject.spi.ProviderInstanceBinding;
import shaded.shaded.com.google.inject.spi.ProviderWithExtensionVisitor;
import shaded.shaded.com.google.inject.util.Types;
import java.lang.reflect.Type;
import java.util.Collection;
import java.util.List;
import java.util.Set;

/**
 * The actual multibinder plays several roles:
 *
 * 

As a Multibinder, it acts as a factory for LinkedBindingBuilders for each of the set's * elements. Each binding is given an annotation that identifies it as a part of this set. * *

As a Module, it installs the binding to the set itself. As a module, this implements equals() * and hashcode() in order to trick Guice into executing its configure() method only once. That * makes it so that multiple multibinders can be created for the same target collection, but only * one is bound. Since the list of bindings is retrieved from the injector itself (and not the * multibinder), each multibinder has access to all contributions from all multibinders. * *

As a Provider, this constructs the set instances. * *

We use a subclass to hide 'implements Module, Provider' from the public API. */ public final class RealMultibinder implements Module { /** Implementation of newSetBinder. */ public static RealMultibinder newRealSetBinder(Binder binder, Key key) { binder = binder.skipSources(RealMultibinder.class); RealMultibinder result = new RealMultibinder<>(binder, key); binder.install(result); return result; } @SuppressWarnings("unchecked") // wrapping a T in a Set safely returns a Set static TypeLiteral> setOf(TypeLiteral elementType) { Type type = Types.setOf(elementType.getType()); return (TypeLiteral>) TypeLiteral.get(type); } @SuppressWarnings("unchecked") static TypeLiteral>> collectionOfProvidersOf( TypeLiteral elementType) { Type providerType = Types.providerOf(elementType.getType()); Type type = Types.collectionOf(providerType); return (TypeLiteral>>) TypeLiteral.get(type); } @SuppressWarnings("unchecked") static TypeLiteral>> collectionOfJavaxProvidersOf( TypeLiteral elementType) { Type providerType = Types.newParameterizedType(javax.inject.Provider.class, elementType.getType()); Type type = Types.collectionOf(providerType); return (TypeLiteral>>) TypeLiteral.get(type); } private final BindingSelection bindingSelection; private final Binder binder; RealMultibinder(Binder binder, Key key) { this.binder = checkNotNull(binder, "binder"); this.bindingSelection = new BindingSelection<>(key); } @Override public void configure(Binder binder) { checkConfiguration(!bindingSelection.isInitialized(), "Multibinder was already initialized"); binder .bind(bindingSelection.getSetKey()) .toProvider(new RealMultibinderProvider(bindingSelection)); Provider>> collectionOfProvidersProvider = new RealMultibinderCollectionOfProvidersProvider(bindingSelection); binder .bind(bindingSelection.getCollectionOfProvidersKey()) .toProvider(collectionOfProvidersProvider); // The collection this exposes is internally an ImmutableList, so it's OK to massage // the guice Provider to javax Provider in the value (since the guice Provider implements // javax Provider). @SuppressWarnings("unchecked") Provider>> javaxProvider = (Provider) collectionOfProvidersProvider; binder.bind(bindingSelection.getCollectionOfJavaxProvidersKey()).toProvider(javaxProvider); } public void permitDuplicates() { binder.install(new PermitDuplicatesModule(bindingSelection.getPermitDuplicatesKey())); } /** Adds a new entry to the set and returns the key for it. */ Key getKeyForNewItem() { checkConfiguration(!bindingSelection.isInitialized(), "Multibinder was already initialized"); return Key.get( bindingSelection.getElementTypeLiteral(), new RealElement(bindingSelection.getSetName(), MULTIBINDER, "")); } public LinkedBindingBuilder addBinding() { return binder.bind(getKeyForNewItem()); } // These methods are used by RealMapBinder Key> getSetKey() { return bindingSelection.getSetKey(); } TypeLiteral getElementTypeLiteral() { return bindingSelection.getElementTypeLiteral(); } String getSetName() { return bindingSelection.getSetName(); } boolean permitsDuplicates(Injector injector) { return bindingSelection.permitsDuplicates(injector); } boolean containsElement(shaded.shaded.com.google.inject.spi.Element element) { return bindingSelection.containsElement(element); } private static final class RealMultibinderProvider extends InternalProviderInstanceBindingImpl.Factory> implements ProviderWithExtensionVisitor>, MultibinderBinding> { private final BindingSelection bindingSelection; private List> bindings; private SingleParameterInjector[] injectors; private boolean permitDuplicates; RealMultibinderProvider(BindingSelection bindingSelection) { // While Multibinders only depend on bindings created in modules so we could theoretically // initialize eagerly, they also depend on // 1. findBindingsByType returning results // 2. being able to call BindingImpl.acceptTargetVisitor // neither of those is available during eager initialization, so we use DELAYED super(InitializationTiming.DELAYED); this.bindingSelection = bindingSelection; } @Override public Set> getDependencies() { return bindingSelection.getDependencies(); } @Override void initialize(InjectorImpl injector, Errors errors) throws ErrorsException { bindingSelection.initialize(injector, errors); this.bindings = bindingSelection.getBindings(); this.injectors = bindingSelection.getParameterInjectors(); this.permitDuplicates = bindingSelection.permitsDuplicates(); } @Override protected Set doProvision(InternalContext context, Dependency dependency) throws InternalProvisionException { SingleParameterInjector[] localInjectors = injectors; if (localInjectors == null) { // if localInjectors == null, then we have no bindings so return the empty set. return ImmutableSet.of(); } // Ideally we would just add to an ImmutableSet.Builder, but if we did that and there were // duplicates we wouldn't be able to tell which one was the duplicate. So to manage this we // first put everything into an array and then construct the set. This way if something gets // dropped we can figure out what it is. @SuppressWarnings("unchecked") T[] values = (T[]) new Object[localInjectors.length]; for (int i = 0; i < localInjectors.length; i++) { SingleParameterInjector parameterInjector = localInjectors[i]; T newValue = parameterInjector.inject(context); if (newValue == null) { throw newNullEntryException(i); } values[i] = newValue; } ImmutableSet set = ImmutableSet.copyOf(values); // There are fewer items in the set than the array. Figure out which one got dropped. if (!permitDuplicates && set.size() < values.length) { throw newDuplicateValuesException(set, values); } return set; } private InternalProvisionException newNullEntryException(int i) { return InternalProvisionException.create( "Set injection failed due to null element bound at: %s", bindings.get(i).getSource()); } @SuppressWarnings("unchecked") @Override public V acceptExtensionVisitor( BindingTargetVisitor visitor, ProviderInstanceBinding binding) { if (visitor instanceof MultibindingsTargetVisitor) { return ((MultibindingsTargetVisitor, V>) visitor).visit(this); } else { return visitor.visit(binding); } } private InternalProvisionException newDuplicateValuesException( ImmutableSet set, T[] values) { // TODO(lukes): consider reporting all duplicate values, the easiest way would be to rebuild // a new set and detect dupes as we go // Find the duplicate binding // To do this we take advantage of the fact that set, values and bindings all have the same // ordering for a non-empty prefix of the set. // First we scan for the first item dropped from the set. int newBindingIndex = 0; for (T item : set) { if (item != values[newBindingIndex]) { break; } newBindingIndex++; } // once we exit the loop newBindingIndex will point at the first item in values that was // dropped. Binding newBinding = bindings.get(newBindingIndex); T newValue = values[newBindingIndex]; // Now we scan again to find the index of the value, we are guaranteed to find it. int oldBindingIndex = set.asList().indexOf(newValue); T oldValue = values[oldBindingIndex]; Binding duplicateBinding = bindings.get(oldBindingIndex); String oldString = oldValue.toString(); String newString = newValue.toString(); if (Objects.equal(oldString, newString)) { // When the value strings match, just show the source of the bindings return InternalProvisionException.create( "Set injection failed due to duplicated element \"%s\"" + "\n Bound at %s\n Bound at %s", newValue, duplicateBinding.getSource(), newBinding.getSource()); } else { // When the value strings don't match, include them both as they may be useful for debugging return InternalProvisionException.create( "Set injection failed due to multiple elements comparing equal:" + "\n \"%s\"\n bound at %s" + "\n \"%s\"\n bound at %s", oldValue, duplicateBinding.getSource(), newValue, newBinding.getSource()); } } @Override public boolean equals(Object obj) { return obj instanceof RealMultibinderProvider && bindingSelection.equals(((RealMultibinderProvider) obj).bindingSelection); } @Override public int hashCode() { return bindingSelection.hashCode(); } @Override public Key> getSetKey() { return bindingSelection.getSetKey(); } @Override public TypeLiteral getElementTypeLiteral() { return bindingSelection.getElementTypeLiteral(); } @Override public List> getElements() { return bindingSelection.getElements(); } @Override public boolean permitsDuplicates() { return bindingSelection.permitsDuplicates(); } @Override public boolean containsElement(shaded.shaded.com.google.inject.spi.Element element) { return bindingSelection.containsElement(element); } } private static final class BindingSelection { // prior to initialization we declare just a dependency on the injector, but as soon as we are // initialized we swap to dependencies on the elements. private static final ImmutableSet> MODULE_DEPENDENCIES = ImmutableSet.>of(Dependency.get(Key.get(Injector.class))); private final TypeLiteral elementType; private final Key> setKey; // these are all lazily allocated private String setName; private Key>> collectionOfProvidersKey; private Key>> collectionOfJavaxProvidersKey; private Key permitDuplicatesKey; private boolean isInitialized; /* a binding for each element in the set. null until initialization, non-null afterwards */ private ImmutableList> bindings; // Starts out as Injector and gets set up properly after initialization private ImmutableSet> dependencies = MODULE_DEPENDENCIES; private ImmutableSet> providerDependencies = MODULE_DEPENDENCIES; /** whether duplicates are allowed. Possibly configured by a different instance */ private boolean permitDuplicates; private SingleParameterInjector[] parameterinjectors; BindingSelection(Key key) { this.setKey = key.ofType(setOf(key.getTypeLiteral())); this.elementType = key.getTypeLiteral(); } void initialize(InjectorImpl injector, Errors errors) throws ErrorsException { // This will be called multiple times, once by each Factory. We only want // to do the work to initialize everything once, so guard this code with // isInitialized. if (isInitialized) { return; } List> bindings = Lists.newArrayList(); Set index = Sets.newHashSet(); Indexer indexer = new Indexer(injector); List> dependencies = Lists.newArrayList(); List> providerDependencies = Lists.newArrayList(); for (Binding entry : injector.findBindingsByType(elementType)) { if (keyMatches(entry.getKey())) { @SuppressWarnings("unchecked") // protected by findBindingsByType() Binding binding = (Binding) entry; if (index.add(binding.acceptTargetVisitor(indexer))) { // TODO(lukes): most of these are linked bindings since user bindings are linked to // a user binding through the @Element annotation. Since this is an implementation // detail we could 'dereference' the @Element if it is a LinkedBinding and avoid // provisioning through the FactoryProxy at runtime. // Ditto for OptionalBinder/MapBinder bindings.add(binding); Key key = binding.getKey(); // TODO(lukes): we should mark this as a non-nullable dependency since we don't accept // null. // Add a dependency on Key dependencies.add(Dependency.get(key)); // and add a dependency on Key> providerDependencies.add( Dependency.get(key.ofType(Types.providerOf(key.getTypeLiteral().getType())))); } } } this.bindings = ImmutableList.copyOf(bindings); this.dependencies = ImmutableSet.copyOf(dependencies); this.providerDependencies = ImmutableSet.copyOf(providerDependencies); this.permitDuplicates = permitsDuplicates(injector); // This is safe because all our dependencies are assignable to T and we never assign to // elements of this array. @SuppressWarnings("unchecked") SingleParameterInjector[] typed = (SingleParameterInjector[]) injector.getParametersInjectors(dependencies, errors); this.parameterinjectors = typed; isInitialized = true; } boolean permitsDuplicates(Injector injector) { return injector.getBindings().containsKey(getPermitDuplicatesKey()); } ImmutableList> getBindings() { checkConfiguration(isInitialized, "not initialized"); return bindings; } SingleParameterInjector[] getParameterInjectors() { checkConfiguration(isInitialized, "not initialized"); return parameterinjectors; } ImmutableSet> getDependencies() { return dependencies; } ImmutableSet> getProviderDependencies() { return providerDependencies; } String getSetName() { // lazily initialized since most selectors don't survive module installation. if (setName == null) { setName = Annotations.nameOf(setKey); } return setName; } Key getPermitDuplicatesKey() { Key local = permitDuplicatesKey; if (local == null) { local = permitDuplicatesKey = Key.get(Boolean.class, named(toString() + " permits duplicates")); } return local; } Key>> getCollectionOfProvidersKey() { Key>> local = collectionOfProvidersKey; if (local == null) { local = collectionOfProvidersKey = setKey.ofType(collectionOfProvidersOf(elementType)); } return local; } Key>> getCollectionOfJavaxProvidersKey() { Key>> local = collectionOfJavaxProvidersKey; if (local == null) { local = collectionOfJavaxProvidersKey = setKey.ofType(collectionOfJavaxProvidersOf(elementType)); } return local; } boolean isInitialized() { return isInitialized; } // MultibinderBinding API methods TypeLiteral getElementTypeLiteral() { return elementType; } Key> getSetKey() { return setKey; } @SuppressWarnings("unchecked") List> getElements() { if (isInitialized()) { return (List>) (List) bindings; // safe because bindings is immutable. } else { throw new UnsupportedOperationException("getElements() not supported for module bindings"); } } boolean permitsDuplicates() { if (isInitialized()) { return permitDuplicates; } else { throw new UnsupportedOperationException( "permitsDuplicates() not supported for module bindings"); } } boolean containsElement(shaded.shaded.com.google.inject.spi.Element element) { if (element instanceof Binding) { Binding binding = (Binding) element; return keyMatches(binding.getKey()) || binding.getKey().equals(getPermitDuplicatesKey()) || binding.getKey().equals(setKey) || binding.getKey().equals(collectionOfProvidersKey) || binding.getKey().equals(collectionOfJavaxProvidersKey); } else { return false; } } private boolean keyMatches(Key key) { return key.getTypeLiteral().equals(elementType) && key.getAnnotation() instanceof Element && ((Element) key.getAnnotation()).setName().equals(getSetName()) && ((Element) key.getAnnotation()).type() == MULTIBINDER; } @Override public boolean equals(Object obj) { if (obj instanceof BindingSelection) { return setKey.equals(((BindingSelection) obj).setKey); } return false; } @Override public int hashCode() { return setKey.hashCode(); } @Override public String toString() { return (getSetName().isEmpty() ? "" : getSetName() + " ") + "Multibinder<" + elementType + ">"; } } @Override public boolean equals(Object o) { return o instanceof RealMultibinder && ((RealMultibinder) o).bindingSelection.equals(bindingSelection); } @Override public int hashCode() { return bindingSelection.hashCode(); } private static final class RealMultibinderCollectionOfProvidersProvider extends InternalProviderInstanceBindingImpl.Factory>> { private final BindingSelection bindingSelection; private ImmutableList> collectionOfProviders; RealMultibinderCollectionOfProvidersProvider(BindingSelection bindingSelection) { super(InitializationTiming.DELAYED); // See comment in RealMultibinderProvider this.bindingSelection = bindingSelection; } @Override void initialize(InjectorImpl injector, Errors errors) throws ErrorsException { bindingSelection.initialize(injector, errors); ImmutableList.Builder> providers = ImmutableList.builder(); for (Binding binding : bindingSelection.getBindings()) { providers.add(binding.getProvider()); } this.collectionOfProviders = providers.build(); } @Override protected Collection> doProvision( InternalContext context, Dependency dependency) { return collectionOfProviders; } @Override public Set> getDependencies() { return bindingSelection.getProviderDependencies(); } @Override public boolean equals(Object obj) { return obj instanceof RealMultibinderCollectionOfProvidersProvider && bindingSelection.equals( ((RealMultibinderCollectionOfProvidersProvider) obj).bindingSelection); } @Override public int hashCode() { return bindingSelection.hashCode(); } } /** * We install the permit duplicates configuration as its own binding, all by itself. This way, if * only one of a multibinder's users remember to call permitDuplicates(), they're still permitted. * *

This is like setting a global variable in the injector so that each instance of the * multibinder will have the same value for permitDuplicates, even if it is only set on one of * them. */ private static class PermitDuplicatesModule extends AbstractModule { private final Key key; PermitDuplicatesModule(Key key) { this.key = key; } @Override protected void configure() { bind(key).toInstance(true); } @Override public boolean equals(Object o) { return o instanceof PermitDuplicatesModule && ((PermitDuplicatesModule) o).key.equals(key); } @Override public int hashCode() { return getClass().hashCode() ^ key.hashCode(); } } }





© 2015 - 2024 Weber Informatics LLC | Privacy Policy