congrats Icon
New! Announcing Tabnine Chat Beta
Learn More
Tabnine Logo
Dependency.getInitialDesire
Code IndexAdd Tabnine to your IDE (free)

How to use
getInitialDesire
method
in
org.grouplens.grapht.Dependency

Best Java code snippets using org.grouplens.grapht.Dependency.getInitialDesire (Showing top 11 results out of 315)

origin: lenskit/lenskit

public static boolean edgeIsTransient(DAGEdge<?, Dependency> input) {
  Desire desire = input.getLabel().getInitialDesire();
  return desireIsTransient(desire);
}
origin: lenskit/lenskit

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;
}
origin: lenskit/lenskit

  /**
   * 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);
  }
}
origin: lenskit/lenskit

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();
origin: org.grouplens.grapht/grapht

  @Override
  public boolean apply(@Nullable Dependency input) {
    return input != null && input.getInitialDesire().equals(d);
  }
};
origin: org.grouplens.grapht/grapht

  @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;
  }
}
origin: org.grouplens.grapht/grapht

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));
}
origin: org.lenskit/lenskit-core

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;
}
origin: org.lenskit/lenskit-core

public static boolean edgeIsTransient(DAGEdge<?, Dependency> input) {
  Desire desire = input.getLabel().getInitialDesire();
  return desireIsTransient(desire);
}
origin: org.lenskit/lenskit-core

  /**
   * 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);
  }
}
origin: org.grouplens.lenskit/lenskit-eval

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();
org.grouplens.graphtDependencygetInitialDesire

Javadoc

Convenience method to get the initial desire that prompted this dependency.

Popular methods of Dependency

  • hasInitialDesire
  • isFixed
    Query whether this dependency is immune to rewriting.
  • <init>
  • create
  • getDesireChain
    Get the desire chain associated with this dependency.

Popular in Java

  • Creating JSON documents from java classes using gson
  • setScale (BigDecimal)
  • orElseThrow (Optional)
    Return the contained value, if present, otherwise throw an exception to be created by the provided s
  • getSystemService (Context)
  • ByteBuffer (java.nio)
    A buffer for bytes. A byte buffer can be created in either one of the following ways: * #allocate
  • Collections (java.util)
    This class consists exclusively of static methods that operate on or return collections. It contains
  • Executor (java.util.concurrent)
    An object that executes submitted Runnable tasks. This interface provides a way of decoupling task s
  • Loader (org.hibernate.loader)
    Abstract superclass of object loading (and querying) strategies. This class implements useful common
  • Join (org.hibernate.mapping)
  • SAXParseException (org.xml.sax)
    Encapsulate an XML parse error or warning.> This module, both source code and documentation, is in t
  • Top plugins for Android Studio
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now