How to use

Dependency

in

org.grouplens.grapht

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);
  }
}