@Override public Set<Dependency<?>> getDependencies() { // The dependencies are Key<Provider<V>> return ImmutableSet.<Dependency<?>>of(Dependency.get(getKeyOfProvider(valueKey))); }
@Override public Set<Dependency<?>> getDependencies() { return ImmutableSet.<Dependency<?>>of(Dependency.get(targetKey)); }
@Override public Set<Dependency<?>> getDependencies() { return ImmutableSet.<Dependency<?>>of(Dependency.get(providerKey)); }
public ProviderLookup(Object source, Key<T> key) { this(source, Dependency.get(checkNotNull(key, "key"))); }
@Override public Set<Dependency<?>> getDependencies() { return ImmutableSet.<Dependency<?>>of(Dependency.get(Key.get(Injector.class))); }
public FilterChainResolverProvider(Map<String, Key<? extends Filter>[]> chains) { this.chains = chains; Set<Dependency<?>> dependenciesBuilder = new HashSet<Dependency<?>>(); for (String chain : chains.keySet()) { for (Key<? extends Filter> filterKey : chains.get(chain)) { dependenciesBuilder.add(Dependency.get(filterKey)); } } this.dependencies = Collections.unmodifiableSet(dependenciesBuilder); }
@Override // from |com.google.inject.spi.HasDependencies| public Set<Dependency<?>> getDependencies() { // get() depends on other modules final HashSet<Dependency<?>> built = new HashSet<>(); built.add(Dependency.get(Key.get(ModelManager.class))); built.add(Dependency.get(Key.get(BufferAllocator.class))); return Collections.unmodifiableSet(built); }
@Override // from |com.google.inject.spi.HasDependencies| public Set<Dependency<?>> getDependencies() { // get() depends on other modules final HashSet<Dependency<?>> built = new HashSet<>(); built.add(Dependency.get(Key.get(ScriptingContainerDelegate.class))); return Collections.unmodifiableSet(built); }
@Override public Set<Dependency<?>> getDependencies() { return ImmutableSet.<Dependency<?>>of(Dependency.get(getProvidedKey())); }
@Override public <T> Provider<T> getProvider(final Key<T> key) { return getProvider(Dependency.get(key)); }
@Override public Set<Dependency<?>> getDependencies() { return ImmutableSet.<Dependency<?>>of(Dependency.get(getSourceKey())); }
@Override protected void doInitialize(InjectorImpl injector, Errors errors) { ImmutableMap.Builder<K, Provider<V>> mapOfProvidersBuilder = ImmutableMap.builder(); ImmutableSet.Builder<Dependency<?>> dependenciesBuilder = ImmutableSet.builder(); for (Map.Entry<K, Binding<V>> entry : bindingSelection.getMapBindings().entrySet()) { mapOfProvidersBuilder.put(entry.getKey(), entry.getValue().getProvider()); dependenciesBuilder.add(Dependency.get(getKeyOfProvider(entry.getValue().getKey()))); } mapOfProviders = mapOfProvidersBuilder.build(); dependencies = dependenciesBuilder.build(); }
/** Returns the current dependency chain (all the state stored in the dependencyStack). */ java.util.List<com.google.inject.spi.DependencyAndSource> getDependencyChain() { com.google.common.collect.ImmutableList.Builder<com.google.inject.spi.DependencyAndSource> builder = com.google.common.collect.ImmutableList.builder(); for (int i = 0; i < dependencyStackSize; i += 2) { Object evenEntry = dependencyStack[i]; Dependency<?> dependency; if (evenEntry instanceof com.google.inject.Key) { dependency = Dependency.get((com.google.inject.Key<?>) evenEntry); } else { dependency = (Dependency<?>) evenEntry; } builder.add(new com.google.inject.spi.DependencyAndSource(dependency, dependencyStack[i + 1])); } return builder.build(); }
@Override protected void doInitialize(InjectorImpl injector, Errors errors) { ImmutableMap.Builder<K, Set<Provider<V>>> multimapOfProvidersBuilder = ImmutableMap.builder(); ImmutableSet.Builder<Dependency<?>> dependenciesBuilder = ImmutableSet.builder(); for (Map.Entry<K, Set<Binding<V>>> entry : bindingSelection.getMultimapBindings().entrySet()) { ImmutableSet.Builder<Provider<V>> providersBuilder = ImmutableSet.builder(); for (Binding<V> binding : entry.getValue()) { providersBuilder.add(binding.getProvider()); dependenciesBuilder.add(Dependency.get(getKeyOfProvider(binding.getKey()))); } multimapOfProvidersBuilder.put(entry.getKey(), providersBuilder.build()); } multimapOfProviders = multimapOfProvidersBuilder.build(); dependencies = dependenciesBuilder.build(); }
@Override protected void doInitialize(InjectorImpl injector, Errors errors) throws ErrorsException { @SuppressWarnings("unchecked") K[] keysArray = (K[]) new Object[bindingSelection.getMapBindings().size()]; keys = keysArray; ImmutableSet.Builder<Dependency<?>> dependenciesBuilder = ImmutableSet.builder(); int i = 0; for (Map.Entry<K, Binding<V>> entry : bindingSelection.getMapBindings().entrySet()) { dependenciesBuilder.add(Dependency.get(entry.getValue().getKey())); keys[i] = entry.getKey(); i++; } ImmutableSet<Dependency<?>> localDependencies = dependenciesBuilder.build(); dependencies = localDependencies; List<Dependency<?>> dependenciesList = localDependencies.asList(); // We know the type because we built up our own sets of dependencies, it's just // that the interface uses a "?" generic @SuppressWarnings("unchecked") SingleParameterInjector<V>[] typedInjectors = (SingleParameterInjector<V>[]) injector.getParametersInjectors(dependenciesList, errors); injectors = typedInjectors; }
int j = 0; for (Binding<V> binding : bindings) { Dependency<V> dependency = Dependency.get(binding.getKey()); dependenciesBuilder.add(dependency); dependenciesForKey.add(dependency);
@Test public void testGetDependencies() throws Exception { Set<Dependency<?>> dependencySet = underTest.getDependencies(); assertEquals(4, dependencySet.size()); assertTrue("Dependency set doesn't contain key1a.", dependencySet.contains(Dependency.get(key1a))); assertTrue("Dependency set doesn't contain key1b.", dependencySet.contains(Dependency.get(key1b))); assertTrue("Dependency set doesn't contain key1c.", dependencySet.contains(Dependency.get(key1c))); assertTrue("Dependency set doesn't contain key2a.", dependencySet.contains(Dependency.get(key2a))); }
@Override public Set<Dependency<?>> getDependencies() { // We depend on Provider<T>, not T directly. This is an important distinction // for dependency analysis tools that short-circuit on providers. Key<?> providerKey = getKey().ofType(Types.providerOf(getKey().getTypeLiteral().getType())); return ImmutableSet.<Dependency<?>>of(Dependency.get(providerKey)); }
@Override public <T> Provider<T> getProvider(final Key<T> key) { Errors errors = new Errors(key); try { Provider<T> result = getProviderOrThrow(Dependency.get(key), errors); errors.throwIfNewErrors(0); return result; } catch (ErrorsException e) { throw new ConfigurationException(errors.merge(e.getErrors()).getMessages()); } }
for (BindingImpl<?> binding : candidateBindings) { if (isEagerSingleton(injector, binding, stage)) { Dependency<?> dependency = Dependency.get(binding.getKey()); Dependency previous = context.pushDependency(dependency, binding.getSource());