@Override public Set<Dependency<?>> getDependencies() { return singleton(Dependency.get(Key.get(Injector.class))); }
@Override public Set<Dependency<?>> getDependencies() { return singleton(Dependency.get(getSourceKey())); }
@Override public Set<Dependency<?>> getDependencies() { Set<Dependency<?>> dependencies = new HashSet<>(); for (AssistedConstructor<?> constructor : factoryMethodToConstructor.values()) { for (Parameter parameter : constructor.getAllParameters()) { if (!parameter.isProvidedByFactory()) { dependencies.add(Dependency.get(parameter.getPrimaryBindingKey())); } } } return unmodifiableSet(dependencies); }
final Dependency<T> dependency = Dependency.get(key); return new Provider<T>() { @Override
/** * Invoked by Guice at Injector-creation time to prepare providers for each * element in this set. At this time the set's size is known, but its * contents are only evaluated when get() is invoked. */ @Inject public void initialize(Injector injector) { providers = new ArrayList<>(); Set<Dependency<?>> dependencies = new HashSet<>(); for (Binding<?> entry : injector.findBindingsByType(elementType)) { if (keyMatches(entry.getKey())) { @SuppressWarnings("unchecked") // protected by findBindingsByType() Binding<T> binding = (Binding<T>) entry; providers.add(binding.getProvider()); dependencies.add(Dependency.get(binding.getKey())); } } this.dependencies = unmodifiableSet(dependencies); this.binder = null; }
<T> ProviderMethod<T> createProviderMethod(Binder binder, final Method method) { binder = binder.withSource(method); Errors errors = new Errors(method); // prepare the parameter providers Set<Dependency<?>> dependencies = new HashSet<>(); List<Provider<?>> parameterProviders = new ArrayList<>(); List<TypeLiteral<?>> parameterTypes = typeLiteral.getParameterTypes(method); Annotation[][] parameterAnnotations = method.getParameterAnnotations(); for (int i = 0; i < parameterTypes.size(); i++) { Key<?> key = getKey(errors, parameterTypes.get(i), method, parameterAnnotations[i]); dependencies.add(Dependency.get(key)); parameterProviders.add(binder.getProvider(key)); } @SuppressWarnings("unchecked") // Define T as the method's return type. TypeLiteral<T> returnType = (TypeLiteral<T>) typeLiteral.getReturnType(method); Key<T> key = getKey(errors, returnType, method, method.getAnnotations()); Class<? extends Annotation> scopeAnnotation = Annotations.findScopeAnnotation(errors, method.getAnnotations()); for (Message message : errors.getMessages()) { binder.addError(message); } return new ProviderMethod<>(key, method, delegate, unmodifiableSet(dependencies), parameterProviders, scopeAnnotation); }
private void loadEagerSingletons(InjectorImpl injector, Stage stage, final Errors errors, BindingImpl<?> binding) { if (binding.getScoping().isEagerSingleton(stage)) { try { injector.callInContext(new ContextualCallable<Void>() { Dependency<?> dependency = Dependency.get(binding.getKey()); @Override public Void call(InternalContext context) { context.setDependency(dependency); Errors errorsForBinding = errors.withSource(dependency); try { binding.getInternalFactory().get(errorsForBinding, context, dependency); } catch (ErrorsException e) { errorsForBinding.merge(e.getErrors()); } finally { context.setDependency(null); } return null; } }); } catch (ErrorsException e) { throw new AssertionError(); } } } }
@Override @SuppressWarnings({"rawtypes", "unchecked"}) // code is silly stupid with generics public void configure(Binder binder) { Multibinder.checkConfiguration(!isInitialized(), "MapBinder was already initialized"); final Set<Dependency<?>> dependencies = singleton(Dependency.get(entrySetBinder.getSetKey())); // binds a Map<K, Provider<V>> from a collection of Map<Entry<K, Provider<V>> final Provider<Set<Entry<K, Provider<V>>>> entrySetProvider = binder .getProvider(entrySetBinder.getSetKey()); binder.bind(providerMapKey) .toProvider(new MapBinderProviderWithDependencies(RealMapBinder.this, dependencies, entrySetProvider)); final Provider<Map<K, Provider<V>>> mapProvider = binder.getProvider(providerMapKey); binder.bind(mapKey).toProvider(new ProviderWithDependencies<Map<K, V>>() { @Override public Map<K, V> get() { Map<K, V> map = new LinkedHashMap<>(); for (Entry<K, Provider<V>> entry : mapProvider.get().entrySet()) { V value = entry.getValue().get(); K key = entry.getKey(); Multibinder.checkConfiguration(value != null, "Map injection failed due to null value for key \"%s\"", key); map.put(key, value); } return Collections.unmodifiableMap(map); } @Override public Set<Dependency<?>> getDependencies() { return dependencies; } }); }
@Override public Set<Dependency<?>> getDependencies() { return singleton(Dependency.get(getSourceKey())); }
@Override public Set<Dependency<?>> getDependencies() { return singleton(Dependency.get(Key.get(Injector.class))); }
@Override public Set<Dependency<?>> getDependencies() { return singleton(Dependency.get(Key.get(Injector.class))); }
@Override public Set<Dependency<?>> getDependencies() { return singleton(Dependency.get(Key.get(Injector.class))); }
@Override public Set<Dependency<?>> getDependencies() { return singleton(Dependency.get(getSourceKey())); }
@Override public Set<Dependency<?>> getDependencies() { return singleton(Dependency.get(getSourceKey())); }
@Override public Set<Dependency<?>> getDependencies() { Set<Dependency<?>> dependencies = new HashSet<>(); for (AssistedConstructor<?> constructor : factoryMethodToConstructor.values()) { for (Parameter parameter : constructor.getAllParameters()) { if (!parameter.isProvidedByFactory()) { dependencies.add(Dependency.get(parameter.getPrimaryBindingKey())); } } } return unmodifiableSet(dependencies); }
@Override public Set<Dependency<?>> getDependencies() { Set<Dependency<?>> dependencies = new HashSet<>(); for (AssistedConstructor<?> constructor : factoryMethodToConstructor.values()) { for (Parameter parameter : constructor.getAllParameters()) { if (!parameter.isProvidedByFactory()) { dependencies.add(Dependency.get(parameter.getPrimaryBindingKey())); } } } return unmodifiableSet(dependencies); }
@Override public Set<Dependency<?>> getDependencies() { Set<Dependency<?>> dependencies = new HashSet<>(); for (AssistedConstructor<?> constructor : factoryMethodToConstructor.values()) { for (Parameter parameter : constructor.getAllParameters()) { if (!parameter.isProvidedByFactory()) { dependencies.add(Dependency.get(parameter.getPrimaryBindingKey())); } } } return unmodifiableSet(dependencies); }
@Override public Set<Dependency<?>> getDependencies() { return ImmutableSet.<Dependency<?>>of(Dependency.get(Key.get(Injector.class))); }
@Override public Set<Dependency<?>> getDependencies() { List<Dependency<?>> dependencies = new ArrayList<>(); for (AssistedConstructor<?> constructor : factoryMethodToConstructor.values()) { for (Parameter parameter : constructor.getAllParameters()) { if (!parameter.isProvidedByFactory()) { dependencies.add(Dependency.get(parameter.getPrimaryBindingKey())); } } } return ImmutableSet.copyOf(dependencies); }
@Override public Set<Dependency<?>> getDependencies() { return ImmutableSet.<Dependency<?>>of(Dependency.get(getSourceKey())); }