private PathFinder<? extends Path> getAlgorithm(
        String algorithm, RelationshipExpander expander, int maxDepth) {
      if (algorithm.equals("shortestPath")) {
        return GraphAlgoFactory.shortestPath(expander, maxDepth);
      } else if (algorithm.equals("allSimplePaths")) {
        return GraphAlgoFactory.allSimplePaths(expander, maxDepth);
      } else if (algorithm.equals("allPaths")) {
        return GraphAlgoFactory.allPaths(expander, maxDepth);
      } else if (algorithm.equals("dijkstra")) {
        String costProperty = (String) map.get("cost_property");
        Number defaultCost = (Number) map.get("default_cost");
        CostEvaluator<Double> costEvaluator =
            defaultCost == null
                ? CommonEvaluators.doubleCostEvaluator(costProperty)
                : CommonEvaluators.doubleCostEvaluator(costProperty, defaultCost.doubleValue());
        representationCreator = WEIGHTED_PATH_REPRESENTATION_CREATOR;
        return GraphAlgoFactory.dijkstra(expander, costEvaluator);
      }

      throw new RuntimeException("Failed to find matching algorithm");
    }
  public List<?> getBaconPath(final Actor actor) {
    if (actor == null) throw new IllegalArgumentException("Null actor");

    Actor bacon = actorRepository.findByPropertyValue("name", "Bacon, Kevin");

    Path path =
        GraphAlgoFactory.shortestPath(
                (PathExpander) StandardExpander.DEFAULT.add(RelTypes.ACTS_IN), 10)
            .findSinglePath(bacon.getPersistentState(), actor.getPersistentState());
    if (path == null) return Collections.emptyList();
    return convertNodesToActorsAndMovies(path);
  }
 private static Iterator<Node> findPath(Node s, Node e) {
   Iterator<Node> it;
   try (Transaction tx = graphDb.beginTx()) {
     PathFinder<Path> finder =
         GraphAlgoFactory.shortestPath(
             PathExpanders.forTypeAndDirection(RelTypes.STD, Direction.OUTGOING), 15);
     Iterable<Path> paths = finder.findAllPaths(s, e);
     Path path = paths.iterator().next();
     it = path.nodes().iterator();
     if (it.hasNext()) {
       System.out.println(it.next().getProperty("name"));
     }
     if (it.hasNext()) {
       System.out.println(it.next().getProperty("name"));
     }
     if (it.hasNext()) {
       System.out.println(it.next().getProperty("name"));
     }
     tx.success();
   }
   return it;
 }
  public Double shortestPath() {

    s1nodes = Neo4jGraphUtils.getSourceNodes(graph, s1);
    s2nodes = Neo4jGraphUtils.getSourceNodes(graph, s2);

    log.info(
        "Compute pairwise cheapest path: S{} ({} nodes), S{} ({} nodes)",
        s1.getSnippetId(),
        s1nodes.size(),
        s2.getSnippetId(),
        s2nodes.size());

    int pathLenghtSum = 0;
    int pathCount = 0;
    int commonNodeCount = 0;

    int cacheCounter = 0;

    for (Vertex v1 : s1nodes) {
      for (Vertex v2 : s2nodes) {

        Long v1id = (Long) (v1.getId());
        Long v2id = (Long) (v2.getId());

        if (v1id.compareTo(v2id) == 0) {
          commonNodeCount++;
          // pathCount++;
          // pathLenghtSum += 0
          continue;
        }

        log.debug("Processing Node {} and Node {}", v1id, v2id);

        Node n1 = graph.getRawGraph().getNodeById(v1id);
        Node n2 = graph.getRawGraph().getNodeById(v2id);

        // Get shortest path

        Integer pathLen = null; // p.length();

        Tuple<Integer, Double> path = pathCache.getPath(v1id, v2id, log.isDebugEnabled());

        if (path != null) {

          pathLen = path.k;

          cacheCounter++;

          log.debug(
              "Path between Node{} and Node{} found, Length {}, Weight {} (from mysql cache)",
              v1id,
              v2id,
              pathLen);
        } else {

          log.debug("Start ShortestPath Node {} and Node {}", v1id, v2id);

          PathFinder<Path> shortestPathAlgo =
              GraphAlgoFactory.shortestPath(
                  (PathExpander<?>) Traversal.expanderForAllTypes(), maxPathLen.intValue());

          Path shortestPath = shortestPathAlgo.findSinglePath(n1, n2);
          StringBuffer shorestPathSteps = null;

          if (shortestPath != null) {

            pathLen = shortestPath.length();

            // Constructing path for debug logging
            if (log.isDebugEnabled()) {

              Iterator<PropertyContainer> iter = shortestPath.iterator();
              shorestPathSteps = new StringBuffer();

              while (iter.hasNext()) {
                Object e = iter.next();
                if (e instanceof NodeProxy) {
                  Node n = (Node) e;
                  shorestPathSteps.append("(" + n.getProperty("label") + ")");
                } else if (e instanceof RelationshipProxy) {
                  Relationship r = (Relationship) e;
                  shorestPathSteps.append("-[" + r.getType() + "]-");
                } else {
                  log.error("ERROR");
                }
              }

              log.debug(
                  "Path between Node{} and Node{} found, Length {}, Path {}",
                  v1id,
                  v2id,
                  pathLen,
                  shorestPathSteps);
            }
          } else {
            log.debug("Path between Node{} and Node{} not found.", v1id, v2id);
          }

          // Update mysql db cache
          if (log.isDebugEnabled()) {
            pathCache.setPath(v1id, v2id, pathLen, null, shorestPathSteps);
          } else {
            pathCache.setPath(v1id, v2id, pathLen, null);
          }
        }

        // Getting shortest path data
        if (pathLen != null) {

          if (pathLen <= maxPathLen) {
            pathLenghtSum += pathLen;

            pathCount++;
          }
        }
      }
    }

    log.info(
        "Similarity measures S{}, S{}: CommonNodes {}, PathCnt {}, MaxTheoPathCnt {}, SumPathLen {}, CacheCnt {}",
        s1.getSnippetId(),
        s2.getSnippetId(),
        commonNodeCount,
        pathCount,
        s1nodes.size() * s2nodes.size(),
        pathLenghtSum,
        cacheCounter);

    // log.info("Total path score S{}, S{}: {}", s1.getSnippetId(), s2.getSnippetId(), sim);
    return Double.valueOf(pathLenghtSum);
  }
 private void initFinder() {
   this.finder = GraphAlgoFactory.allSimplePaths(Traversal.expanderForAllTypes(), 7);
 }