/** Returns a name of the variable representing this dependency's future. */ private static String dependencyFutureName(DependencyRequest dependency) { return dependency.requestElement().get().getSimpleName() + "Future"; }
@Override String applyArgName() { String argName = asyncDependency.requestElement().get().getSimpleName().toString(); if (argName.equals("module")) { return "moduleArg"; } return argName; }
@Override public String format(DependencyRequest request) { return request .requestElement() .map(element -> element.accept(formatVisitor, request)) .orElse(""); }
/** * Returns a comparator that sorts edges in the order in which their request elements were * declared in their declaring type. * * <p>Only useful to compare edges whose request elements were declared in the same type. */ Comparator<DependencyEdge> requestElementDeclarationOrder() { return comparing( edge -> edge.dependencyRequest().requestElement().get(), DECLARATION_ORDER); } }
/** * Returns a comparator that sorts dependency edges lexicographically by the qualified name of * the type that contains them. Only appropriate for edges with request elements. */ Comparator<DependencyEdge> requestEnclosingTypeName() { return comparing( edge -> closestEnclosingTypeElement(edge.dependencyRequest().requestElement().get()) .getQualifiedName() .toString()); }
TypeElement typeDeclaringEntryPoint(DependencyEdge entryPoint) { return MoreElements.asType( entryPoint.dependencyRequest().requestElement().get().getEnclosingElement()); }
/** Returns all the nonsynthetic dependency requests for a binding. */ ImmutableSet<DependencyEdge> requests(MaybeBinding binding) { return graph.network().inEdges(binding).stream() .flatMap(instancesOf(DependencyEdge.class)) .filter(edge -> edge.dependencyRequest().requestElement().isPresent()) .sorted(requestEnclosingTypeName().thenComparing(requestElementDeclarationOrder())) .collect(toImmutableSet()); }
@Override public String toString() { String string = dependencyRequest .requestElement() .map(DaggerElements::elementToString) .orElseGet( () -> "synthetic request for " + dependencyRequest.kind().format(dependencyRequest.key())); return entryPoint ? string + " (entry point)" : string; } }
static String name(DependencyRequest dependency) { if (!dependency.requestElement().isPresent()) { return simpleVariableName(MoreTypes.asTypeElement(dependency.key().type())); String variableName = dependency.requestElement().get().getSimpleName().toString(); if (Ascii.isUpperCase(variableName.charAt(0))) { variableName = toLowerCamel(variableName);
/** * Returns the parameter type for {@code dependency}. If the raw type is not accessible, returns * {@link Object}. */ private static TypeName accessibleType(DependencyRequest dependency) { TypeName typeName = requestTypeName(dependency.kind(), accessibleType(dependency.key().type())); return dependency .requestElement() .map(element -> element.asType().getKind().isPrimitive()) .orElse(false) ? typeName.unbox() : typeName; }
!printingEntryPoints || (!request.isEntryPoint() && !isTracedRequest(request))) .map(request -> request.dependencyRequest().requestElement()) .flatMap(presentValues()) .collect(toImmutableSet()); entryPoint -> { message.append("\n "); Element requestElement = entryPoint.dependencyRequest().requestElement().get(); message.append(elementToString(requestElement));
private static CodeBlock injectionMethodArgument( DependencyRequest dependency, CodeBlock argument, ClassName generatedTypeName) { TypeMirror keyType = dependency.key().type(); CodeBlock.Builder codeBlock = CodeBlock.builder(); if (!isRawTypeAccessible(keyType, generatedTypeName.packageName()) && isTypeAccessibleFrom(keyType, generatedTypeName.packageName())) { if (!dependency.kind().equals(RequestKind.INSTANCE)) { TypeName usageTypeName = accessibleType(dependency); codeBlock.add("($T) ($T)", usageTypeName, rawTypeName(usageTypeName)); } else if (dependency.requestElement().get().asType().getKind().equals(TypeKind.TYPEVAR)) { codeBlock.add("($T)", keyType); } } return codeBlock.add(argument).build(); }