Java Path.length方法代码示例

import org.neo4j.graphdb.Path; //导入方法依赖的package包/类
public static int minDistance(String cui1, String cui2){
  int distance = -1;
  try ( Transaction tx = graphDb.beginTx() ){
    Node cui1Node = graphDb.findNode(RelReader.DictLabels.Concept, RelReader.CUI_PROPERTY, cui1);
    Node cui2Node = graphDb.findNode(RelReader.DictLabels.Concept, RelReader.CUI_PROPERTY, cui2);
    if(cui1Node == null || cui2Node == null) return distance;
    
    TraversalDescription td = graphDb.traversalDescription()
        .breadthFirst()
        .relationships(RelReader.RelTypes.ISA, Direction.OUTGOING)
        .evaluator(Evaluators.excludeStartPosition())
        .evaluator(Evaluators.includeWhereEndNodeIs(cui2Node));

    Traverser traverser = td.traverse(cui1Node);
    for(Path path : traverser){
      int len = path.length();
      if(distance == -1 || len < distance){
        distance = len;
      }
    }
    tx.success();
  }
  return distance;
}
 

import org.neo4j.graphdb.Path; //导入方法依赖的package包/类
public String printNeoFriends() {
	try (Transaction tx = graphDb.beginTx()) {
		Node neoNode = getNeoNode();
		// START SNIPPET: friends-usage
		int numberOfFriends = 0;
		String output = neoNode.getProperty("name") + "'s friends:\n";
		Traverser friendsTraverser = getFriends(neoNode);
		for (Path friendPath : friendsTraverser) {
			output += "At depth " + friendPath.length() + " => " + friendPath.endNode().getProperty("name") + "\n";
			numberOfFriends++;
		}
		output += "Number of friends found: " + numberOfFriends + "\n";
		// END SNIPPET: friends-usage
		return output;
	}
}
 

import org.neo4j.graphdb.Path; //导入方法依赖的package包/类
@Override
public final Iterable<Relationship> expand(final Path path, final BranchState state) {

    List<Relationship> result = new ArrayList<>();

    if (this.since == Long.MIN_VALUE && this.until == Long.MAX_VALUE) {
        return path.endNode().getRelationships();
    }

    if (path.length() >= this.depth) {
        return result;
    }

    for (Relationship rel : path.endNode().getRelationships()) {
        long current = Long.parseLong(rel.getProperty("timestamp").toString());
        if (until > current && current > since) {
            result.add(rel);
        }
    }

    return result;
}
 

import org.neo4j.graphdb.Path; //导入方法依赖的package包/类
@Override
public Iterable<Relationship> expand(Path path, BranchState branchState) {
    if (path.endNode().hasLabel(stopLabel)) {
        return Collections.emptyList();
    }
    if (path.length() % 2 == 0) {
        return path.endNode().getRelationships(Direction.INCOMING);
    } else {
        return path.endNode().getRelationships(Direction.OUTGOING);
    }
}
 

import org.neo4j.graphdb.Path; //导入方法依赖的package包/类
@Override
public Evaluation evaluate(Path path, BranchState<Double> branchState) {
    // Path with just the single node, ignore it and continue
    if (path.length() == 0 ) {
        return Evaluation.INCLUDE_AND_CONTINUE;
    }
    // Make sure last Equipment voltage is equal to or lower than previous voltage
    Double voltage = (Double) path.endNode().getProperty("voltage", 999.0);
    if (voltage <= branchState.getState()) {
        return Evaluation.INCLUDE_AND_CONTINUE;
    } else {
        return Evaluation.EXCLUDE_AND_PRUNE;
    }
}
 

import org.neo4j.graphdb.Path; //导入方法依赖的package包/类
public String printMatrixHackers() {
	try (Transaction tx = graphDb.beginTx()) {
		// START SNIPPET: find--hackers-usage
		String output = "Hackers:\n";
		int numberOfHackers = 0;
		Traverser traverser = findHackers(getNeoNode());
		for (Path hackerPath : traverser) {
			output += "At depth " + hackerPath.length() + " => " + hackerPath.endNode().getProperty("name") + "\n";
			numberOfHackers++;
		}
		output += "Number of hackers found: " + numberOfHackers + "\n";
		// END SNIPPET: find--hackers-usage
		return output;
	}
}
 

import org.neo4j.graphdb.Path; //导入方法依赖的package包/类
@Override
public Evaluation evaluate(Path path) {
    if (path.length() < length) {
        return Evaluation.EXCLUDE_AND_CONTINUE;
    }

    Node lastNode = path.endNode();
    if (!lastNode.hasLabel(Labels.AirportDay)){
        return Evaluation.EXCLUDE_AND_CONTINUE;
    } else if (destinations.contains( ((String)lastNode.getProperty("key")).substring(0,3) )) {
        return Evaluation.INCLUDE_AND_PRUNE;
    }
    return Evaluation.EXCLUDE_AND_PRUNE;
}
 

import org.neo4j.graphdb.Path; //导入方法依赖的package包/类
Optional<Node> getTaxon(Node source) {
  for (Path path : taxonDescription.traverse(source)) {
    if (path.length() > 0 && path.lastRelationship().isType(inTaxon)) {
      return Optional.of(path.endNode());
    }
  }
  return Optional.empty();
}
 

import org.neo4j.graphdb.Path; //导入方法依赖的package包/类
Optional<Node> getChromosome(Node source) {
  for (Path path : chromosomeDescription.traverse(source)) {
    if (path.length() > 0 && path.lastRelationship().isType(OwlRelationships.RDF_TYPE)) {
      if (chromsomeEntailment.contains(path.endNode())) {
        return Optional.of(path.lastRelationship().getOtherNode(path.endNode()));
      }
    }
  }
  return Optional.empty();
}
 

import org.neo4j.graphdb.Path; //导入方法依赖的package包/类
@Override
public Evaluation evaluate(Path path) {
    if (!path.endNode().hasRelationship(Direction.OUTGOING)) {
        leaves++;
        depthSum += path.length();
    }

    return Evaluation.EXCLUDE_AND_CONTINUE;
}
 

import org.neo4j.graphdb.Path; //导入方法依赖的package包/类
@Override
public Evaluation evaluate(Path path) {
  long currentId = path.endNode().getId();
  if (!nodePredicate.apply(path.endNode())) {
    inMemoryIndex.get(currentId);
    return Evaluation.EXCLUDE_AND_PRUNE;
  }

  long startId = path.startNode().getId(); // Vi
  InOutList listPair = inMemoryIndex.get(currentId);

  if (0 == path.length()) {
    // first node in the traverse - add itself to the in-out list
    listPair.getInList().add(currentId);
    listPair.getOutList().add(currentId);
    return Evaluation.INCLUDE_AND_CONTINUE;
  }
  else if (direction == Direction.INCOMING ) {
    // doing reverse BFS
    if (nodesAreConnected(currentId, startId)) {
      return Evaluation.EXCLUDE_AND_PRUNE;
    } else {
      listPair.getOutList().add(startId);
      return Evaluation.INCLUDE_AND_CONTINUE;
    }
  } else {
    //doing BFS
    if (nodesAreConnected(startId, currentId)) { // cur is w
      return Evaluation.EXCLUDE_AND_PRUNE;
    } else {
      listPair.getInList().add(startId);
      return Evaluation.INCLUDE_AND_CONTINUE;
    }
  }
}
 

import org.neo4j.graphdb.Path; //导入方法依赖的package包/类
/**
 * A {@link PruneEvaluator} which prunes everything beyond {@code depth}.
 * @param depth the depth to prune beyond (after).
 * @return a {@link PruneEvaluator} which prunes everything after
 * {@code depth}.
 * @deprecated because of the introduction of {@link Evaluator}. The equivalent
 * is {@link Evaluators#toDepth(int)}.
 */
public static PruneEvaluator pruneAfterDepth( final int depth )
{
    return new PruneEvaluator()
    {
        public boolean pruneAfter( Path position )
        {
            return position.length() >= depth;
        }
    };
}
 

import org.neo4j.graphdb.Path; //导入方法依赖的package包/类
public Evaluation evaluate( Path path )
{
    // Before the Evaluator, when PruneEvaluator was used individually a PruneEvaluator
    // was never called with the start node as argument. This condition mimics that behaviour.
    if ( path.length() == 0 )
    {
        return Evaluation.INCLUDE_AND_CONTINUE;
    }
    return pruning.pruneAfter( path ) ? Evaluation.INCLUDE_AND_PRUNE : Evaluation.INCLUDE_AND_CONTINUE;
}
 

import org.neo4j.graphdb.Path; //导入方法依赖的package包/类
/**
 * Returns an {@link Evaluator} which includes positions down to {@code depth}
 * and prunes everything deeper than that.
 * 
 * @param depth the max depth to traverse to.
 * @return Returns an {@link Evaluator} which includes positions down to
 * {@code depth} and prunes everything deeper than that.
 */
public static Evaluator toDepth( final int depth )
{
    return new Evaluator()
    {
        public Evaluation evaluate( Path path )
        {
            return path.length() < depth ? Evaluation.INCLUDE_AND_CONTINUE : Evaluation.INCLUDE_AND_PRUNE;
        }
    };
}
 

import org.neo4j.graphdb.Path; //导入方法依赖的package包/类
/**
 * Returns an {@link Evaluator} which only includes positions from {@code depth}
 * and deeper and never prunes anything.
 * 
 * @param depth the depth to start include positions from.
 * @return Returns an {@link Evaluator} which only includes positions from
 * {@code depth} and deeper and never prunes anything.
 */
public static Evaluator fromDepth( final int depth )
{
    return new Evaluator()
    {
        public Evaluation evaluate( Path path )
        {
            return path.length() < depth ? Evaluation.EXCLUDE_AND_CONTINUE : Evaluation.INCLUDE_AND_CONTINUE;
        }
    };
}