@SuppressWarnings("unchecked") // At runtime we know it's a Binding<Lazy<T>>. @Override public void attach(Linker linker) { delegate = (Binding<T>) linker.requestBinding(lazyKey, requiredBy, loader); }
@Override public void attach(Linker linker) { delegate = linker.requestBinding(delegateKey, requiredBy, classLoader); }
/** * Returns the binding if it exists immediately. Otherwise this returns * null. If the returned binding didn't exist or was unlinked, it will be * enqueued to be linked. */ public Binding<?> requestBinding(String key, Object requiredBy, ClassLoader classLoader) { return requestBinding(key, requiredBy, classLoader, true, true); }
@SuppressWarnings("unchecked") // We're careful to make keys and bindings match up. @Override public void attach(Linker linker) { int k = 0; for (int i = 0; i < fields.length; i++) { if (fieldBindings[i] == null) { fieldBindings[i] = linker.requestBinding(keys[k], fields[i], loader); } k++; } if (constructor != null) { for (int i = 0; i < parameterBindings.length; i++) { if (parameterBindings[i] == null) { parameterBindings[i] = linker.requestBinding(keys[k], constructor, loader); } k++; } } if (supertype != null && supertypeBinding == null) { supertypeBinding = (Binding<? super T>) linker.requestBinding(keys[k], membersKey, loader, false, true); } }
/** @deprecated Older, generated code still using this should be re-generated. */ @Deprecated public Binding<?> requestBinding(String key, Object requiredBy) { return requestBinding( key, requiredBy, getClass().getClassLoader(), true, true); }
/** @deprecated Older, generated code still using this should be re-generated. */ @Deprecated public Binding<?> requestBinding(String key, Object requiredBy, boolean mustHaveInjections, boolean library) { return requestBinding(key, requiredBy, getClass().getClassLoader(), mustHaveInjections, library); }
private void linkInjectableTypes() { for (Map.Entry<String, Class<?>> entry : injectableTypes.entrySet()) { linker.requestBinding(entry.getKey(), entry.getValue(), entry.getValue().getClassLoader(), false, true); } }
@Override public void attach(Linker linker) { String requiredBy = type.getQualifiedName().toString(); for (int i = 0; i < keys.size(); i++) { bindings[i] = linker.requestBinding(keys.get(i), requiredBy, getClass().getClassLoader()); } if (supertypeKey != null) { // Force the binding lookup. linker.requestBinding(supertypeKey, requiredBy, getClass().getClassLoader(), false, true); } }
@Override public void attach(Linker linker) { for (int i = 0; i < method.getParameters().size(); i++) { VariableElement parameter = method.getParameters().get(i); String parameterKey = GeneratorKeys.get(parameter); parameters[i] = linker.requestBinding(parameterKey, method.toString(), getClass().getClassLoader()); } }
@Override public void attach(Linker linker) { bindings = new Binding<?>[fields.length]; for (int i = 0; i < fields.length; i++) { Field field = fields[i]; String key = Keys.get(field.getGenericType(), field.getAnnotations(), field); bindings[i] = linker.requestBinding(key, field, loader); } }
@Override public void attach(Linker linker) { for (Element enclosedElement : enclosingClass.getEnclosedElements()) { if (enclosedElement.getKind().isField() && isStatic(enclosedElement)) { Inject injectAnnotation = enclosedElement.getAnnotation(Inject.class); if (injectAnnotation != null) { String key = GeneratorKeys.get(enclosedElement.asType()); linker.requestBinding(key, enclosingClass.toString(), getClass().getClassLoader()); } } } }
/** * @param classLoader the {@code ClassLoader} used to load dependent bindings. * @param injectableKey the key used to store the injectable type. This * is a provides key for interfaces and a members injection key for * other types. That way keys can always be created, even if the type * has no injectable constructor. * @param key the key to use when retrieving the binding. This may be a * regular (provider) key or a members key. */ private Binding<?> getInjectableTypeBinding( ClassLoader classLoader, String injectableKey, String key) { Class<?> moduleClass = null; for (DaggerObjectGraph graph = this; graph != null; graph = graph.base) { moduleClass = graph.injectableTypes.get(injectableKey); if (moduleClass != null) break; } if (moduleClass == null) { throw new IllegalArgumentException("No inject registered for " + injectableKey + ". You must explicitly add it to the 'injects' option in one of your modules."); } synchronized (linker) { Binding<?> binding = linker.requestBinding(key, moduleClass, classLoader, false, true); if (binding == null || !binding.isLinked()) { linker.linkRequested(); binding = linker.requestBinding(key, moduleClass, classLoader, false, true); } return binding; } } }
@Override public void attach(Linker linker) { Type[] types = method.getGenericParameterTypes(); Annotation[][] annotations = method.getParameterAnnotations(); parameters = new Binding[types.length]; for (int i = 0; i < parameters.length; i++) { String key = Keys.get(types[i], annotations[i], method + " parameter " + i); parameters[i] = linker.requestBinding(key, method, instance.getClass().getClassLoader()); } }
? providerKey : GeneratorKeys.rawMembersKey(injectableType); linker.requestBinding(key, module.getQualifiedName().toString(), getClass().getClassLoader(), false, true);
@SuppressWarnings("unchecked") // At runtime we know it's a Binding<Lazy<T>>. @Override public void attach(Linker linker) { delegate = (Binding<T>) linker.requestBinding(lazyKey, requiredBy); }
@Override public void attach(Linker linker) { String requiredBy = type.getQualifiedName().toString(); for (int i = 0; i < keys.size(); i++) { bindings[i] = linker.requestBinding(keys.get(i), requiredBy); } if (supertypeKey != null) { supertypeBinding = linker.requestBinding(supertypeKey, requiredBy, false); } }
private void linkEntryPoints() { for (Map.Entry<String, Class<?>> entry : entryPoints.entrySet()) { linker.requestBinding(entry.getKey(), entry.getValue(), false); } }
@Override public void attach(Linker linker) { Type[] types = method.getGenericParameterTypes(); Annotation[][] annotations = method.getParameterAnnotations(); parameters = new Binding[types.length]; for (int i = 0; i < parameters.length; i++) { String key = Keys.get(types[i], annotations[i], method + " parameter " + i); parameters[i] = linker.requestBinding(key, method); } }
@Override public void attach(Linker linker) { bindings = new Binding<?>[fields.length]; for (int i = 0; i < fields.length; i++) { Field field = fields[i]; String key = Keys.get(field.getGenericType(), field.getAnnotations(), field); bindings[i] = linker.requestBinding(key, field); } }
@Override public void attach(Linker linker) { for (int i = 0; i < method.getParameters().size(); i++) { VariableElement parameter = method.getParameters().get(i); String parameterKey = GeneratorKeys.get(parameter); parameters[i] = linker.requestBinding(parameterKey, method.toString()); } }