public static boolean edgeIsTransient(DAGEdge<?, Dependency> input) { Desire desire = input.getLabel().getInitialDesire(); return desireIsTransient(desire); }
@Nullable public <T> T tryGetInstance(Class<T> type) throws InjectionException { Desire d = Desires.create(null, type, true); DAGEdge<Component, Dependency> e = graph.getOutgoingEdgeWithLabel(l -> l.hasInitialDesire(d)); if (e != null) { return type.cast(instantiator.instantiate(e.getTail())); } else { DAGNode<Component, Dependency> node = GraphtUtils.findSatisfyingNode(graph, Qualifiers.matchDefault(), type); if (node != null) { return type.cast(instantiator.instantiate(node)); } else { return null; } } }
Collections.sort(edges, GraphtUtils.DEP_EDGE_ORDER); for (DAGEdge<Component, Dependency> e: edges) { Desire dep = e.getLabel().getInitialDesire(); Annotation q = dep.getInjectionPoint().getQualifier(); DAGNode<Component, Dependency> targetNode = e.getTail(); EdgeBuilder eb = EdgeBuilder.create(port, tid) .set("arrowhead", "vee"); if (e.getLabel().isFixed()) { eb.set("arrowtail", "crow");
for (DAGEdge<Component, Dependency> edge: root.getOutgoingEdges()) { logger.debug("considering {} for replacement", edge.getTail().getLabel()); Desire desire = edge.getLabel().getDesireChain().getInitialDesire(); DesireChain chain = DesireChain.singleton(desire); Pair<DAGNode<Component, Dependency>, Dependency> repl = null; if (!edge.getLabel().isFixed()) { for (BindingFunction bf: triggerFunctions) { BindingResult result = bf.bind(context, chain); .getSatisfaction(), edge.getLabel() .getDesireChain() .getInitialDesire() .getInjectionPoint());
public static Dependency create(DesireChain desires, EnumSet<Flag> flags) { return new Dependency(desires, flags); }
public Dependency makeDependency() { EnumSet<Dependency.Flag> flags = Dependency.Flag.emptySet(); if (fixed) { flags.add(Dependency.Flag.FIXED); } return Dependency.create(desires, flags); }
private static List<String> extractOrderKey(DAGEdge<Component,Dependency> node) { Desire desire = node.getLabel().getInitialDesire(); InjectionPoint ip = desire.getInjectionPoint(); List<String> key = new ArrayList<>(4); Member member = ip.getMember(); if (member instanceof Constructor) { key.add("0: constructor"); key.add(Integer.toString(ip.getParameterIndex())); } else if (member instanceof Method) { key.add("1: setter"); key.add(member.getName()); key.add(Integer.toString(ip.getParameterIndex())); } else if (member instanceof Field) { key.add("2: field"); key.add(member.getName()); } else if (ip instanceof SimpleInjectionPoint) { key.add("5: simple"); } else { key.add("9: unknown"); key.add(ip.getClass().getName()); } return key; }
Collections.sort(edges, GraphtUtils.DEP_EDGE_ORDER); for (DAGEdge<Component, Dependency> e: edges) { Desire dep = e.getLabel().getInitialDesire(); Annotation q = dep.getInjectionPoint().getQualifier(); DAGNode<Component, Dependency> targetNode = e.getTail(); EdgeBuilder eb = EdgeBuilder.create(port, tid) .set("arrowhead", "vee"); if (e.getLabel().isFixed()) { eb.set("arrowtail", "crow");
/** * Get the back edge for a particular node and desire, if one exists. * @return The back edge, or {@code null} if no edge exists. * @see #getBackEdges() */ public synchronized DAGNode<Component, Dependency> getBackEdge(DAGNode<Component, Dependency> parent, Desire desire) { Predicate<DAGEdge<?, Dependency>> pred = DAGEdge.labelMatches(Dependency.hasInitialDesire(desire)); return FluentIterable.from(backEdges.get(parent)) .filter(pred) .first() .transform(DAGEdge.<Component, Dependency>extractTail()) .orNull(); }
/** * Find a node with a satisfaction for a specified type. Does a breadth-first * search to find the closest matching one. * * @param type The type to look for. * @return A node whose satisfaction is compatible with {@code type}. */ @Nullable public static DAGNode<Component,Dependency> findSatisfyingNode(DAGNode<Component,Dependency> graph, final QualifierMatcher qmatch, final Class<?> type) { Optional<DAGEdge<Component, Dependency>> edge = graph.breadthFirstEdges() .filter(e -> type.isAssignableFrom(e.getTail() .getLabel() .getSatisfaction() .getErasedType())) .filter(e -> qmatch.apply(e.getLabel() .getInitialDesire() .getInjectionPoint() .getQualifier())) .findFirst(); return edge.map(DAGEdge::getTail) .orElse(null); } }
@Nullable public <T> T tryGetInstance(Class<T> type) throws InjectionException { Desire d = Desires.create(null, type, true); DAGEdge<Component, Dependency> e = graph.getOutgoingEdgeWithLabel(l -> l.hasInitialDesire(d)); if (e != null) { return type.cast(instantiator.instantiate(e.getTail())); } else { DAGNode<Component, Dependency> node = GraphtUtils.findSatisfyingNode(graph, Qualifiers.matchDefault(), type); if (node != null) { return type.cast(instantiator.instantiate(node)); } else { return null; } } }
@Override public boolean apply(@Nullable Dependency input) { return input != null && input.getInitialDesire().equals(d); } };
@Override @SuppressWarnings("unchecked") public <T> T getInstance(Annotation qualifier, Class<T> type) throws InjectionException { // All Provider cache access, graph resolution, etc. occur // within this exclusive lock so we know everything is thread safe // albeit in a non-optimal way. synchronized(this) { Desire desire = Desires.create(qualifier, type, false); Predicate<Dependency> pred = Dependency.hasInitialDesire(desire); // check if the desire is already in the graph DAGEdge<Component, Dependency> resolved = solver.getGraph().getOutgoingEdgeWithLabel(pred); // The edge is only non-null if instantiate() has been called before, // it may be present in the graph at a deeper node. If that's the case // it will be properly merged after regenerating the graph at the root context. if (resolved == null) { logger.info("Must resolve desire: {}", desire); solver.resolve(desire); resolved = solver.getGraph().getOutgoingEdgeWithLabel(pred); } // Check if the provider for the resolved node is in our cache DAGNode<Component, Dependency> resolvedNode = resolved.getTail(); return type.cast(instantiator.makeInstantiator(resolvedNode, solver.getBackEdges()).instantiate()); } } }
@Nullable @Override public Instantiator apply(@Nullable Desire input) { for (DAGEdge<Component,Dependency> edge: edges) { if (edge.getLabel().getInitialDesire().equals(input)) { return makeInstantiator(edge.getTail(), backEdges); } } return null; } }
private Map<Desire, Instantiator> makeDependencyMap(DAGNode<Component, Dependency> node, SetMultimap<DAGNode<Component, Dependency>, DAGEdge<Component, Dependency>> backEdges) { Set<DAGEdge<Component,Dependency>> edges = node.getOutgoingEdges(); if (backEdges.containsKey(node)) { ImmutableSet.Builder<DAGEdge<Component,Dependency>> bld = ImmutableSet.builder(); edges = bld.addAll(edges) .addAll(backEdges.get(node)) .build(); } ImmutableSet.Builder<Desire> desires = ImmutableSet.builder(); for (DAGEdge<Component,Dependency> edge: edges) { desires.add(edge.getLabel().getInitialDesire()); } return Maps.asMap(desires.build(), new DepLookup(edges, backEdges)); }
private static List<String> extractOrderKey(DAGEdge<Component,Dependency> node) { Desire desire = node.getLabel().getInitialDesire(); InjectionPoint ip = desire.getInjectionPoint(); List<String> key = new ArrayList<>(4); Member member = ip.getMember(); if (member instanceof Constructor) { key.add("0: constructor"); key.add(Integer.toString(ip.getParameterIndex())); } else if (member instanceof Method) { key.add("1: setter"); key.add(member.getName()); key.add(Integer.toString(ip.getParameterIndex())); } else if (member instanceof Field) { key.add("2: field"); key.add(member.getName()); } else if (ip instanceof SimpleInjectionPoint) { key.add("5: simple"); } else { key.add("9: unknown"); key.add(ip.getClass().getName()); } return key; }
public static boolean edgeIsTransient(DAGEdge<?, Dependency> input) { Desire desire = input.getLabel().getInitialDesire(); return desireIsTransient(desire); }
/** * Find a node with a satisfaction for a specified type. Does a breadth-first * search to find the closest matching one. * * @param type The type to look for. * @return A node whose satisfaction is compatible with {@code type}. */ @Nullable public static DAGNode<Component,Dependency> findSatisfyingNode(DAGNode<Component,Dependency> graph, final QualifierMatcher qmatch, final Class<?> type) { Optional<DAGEdge<Component, Dependency>> edge = graph.breadthFirstEdges() .filter(e -> type.isAssignableFrom(e.getTail() .getLabel() .getSatisfaction() .getErasedType())) .filter(e -> qmatch.apply(e.getLabel() .getInitialDesire() .getInjectionPoint() .getQualifier())) .findFirst(); return edge.map(DAGEdge::getTail) .orElse(null); } }