Java Traverser类代码示例

import org.neo4j.graphdb.traversal.Traverser; //导入依赖的package包/类
private Traverser getPatternMatch(Node startNode, final List<String> patterns, final List<NodeLabel> nodeLabels, final List<LinkLabel> linkLabels) {
	TraversalDescription td = database.traversalDescription()
		.depthFirst()
		.evaluator( new Evaluator() {
			public Evaluation evaluate( final org.neo4j.graphdb.Path path ) {
                if ( path.length() == 0 ) {
                    return Evaluation.EXCLUDE_AND_CONTINUE;
                }
                boolean isToken = path.endNode().hasLabel(NodeLabel.WordToken);
                boolean included = isToken && (path.length() == 1 || nodeHasAnnotation(path.endNode(), linkLabels.get(path.length() - 1), patterns.get(path.length() - 1)));
                boolean continued = path.length() < patterns.size();
                return Evaluation.of( included, continued );
            }
        } )
		.relationships(LinkLabel.NEXT, Direction.OUTGOING)
		.relationships(LinkLabel.HAS_TYPE, Direction.INCOMING)
		.relationships(LinkLabel.HAS_LEMMA, Direction.INCOMING)
		.relationships(LinkLabel.HAS_POS_TAG, Direction.INCOMING)
		.relationships(LinkLabel.HAS_HEAD, Direction.INCOMING);
	return td.traverse(startNode);
}
 

import org.neo4j.graphdb.traversal.Traverser; //导入依赖的package包/类
public static List<String> getHypernyms(String cui){
  List<String> hypers = new ArrayList<>();
  
  try ( Transaction tx = graphDb.beginTx() ){
    TraversalDescription td = graphDb.traversalDescription()
        .breadthFirst()
        .relationships(RelReader.RelTypes.ISA, Direction.OUTGOING)
        .evaluator(Evaluators.excludeStartPosition());

    Node cuiNode = graphDb.findNode(RelReader.DictLabels.Concept, RelReader.CUI_PROPERTY, cui);
    if(cuiNode == null) return hypers;
    
    Traverser traverser = td.traverse(cuiNode);
    for(Path path : traverser){
      hypers.add(path.endNode().getProperty(RelReader.CUI_PROPERTY).toString());
    }
    tx.success();
  }
  return hypers;
}
 

import org.neo4j.graphdb.traversal.Traverser; //导入依赖的package包/类
public static List<String> getHyponyms(String cui){
  List<String> hypos = new ArrayList<>();
  
  try ( Transaction tx = graphDb.beginTx() ){
    TraversalDescription td = graphDb.traversalDescription()
        .breadthFirst()
        .relationships(RelReader.RelTypes.ISA, Direction.INCOMING)
        .evaluator(Evaluators.excludeStartPosition());

    Node cuiNode = graphDb.findNode(RelReader.DictLabels.Concept, RelReader.CUI_PROPERTY, cui);
    if(cuiNode == null) return hypos;
    
    Traverser traverser = td.traverse(cuiNode);
    for(Path path : traverser){
      hypos.add(path.endNode().getProperty(RelReader.CUI_PROPERTY).toString());
    }
    tx.success();
  }
  return hypos;    
}
 

import org.neo4j.graphdb.traversal.Traverser; //导入依赖的package包/类
public static boolean isa(String cui1, String cui2){
  boolean match=false;
  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 match;
    
    TraversalDescription td = graphDb.traversalDescription()
        .breadthFirst()
        .relationships(RelReader.RelTypes.ISA, Direction.OUTGOING)
        .evaluator(Evaluators.excludeStartPosition())
        .evaluator(Evaluators.includeWhereEndNodeIs(cui2Node));

    Traverser traverser = td.traverse(cui1Node);
    if(traverser.iterator().hasNext()){
      match = true;
    }
    tx.success();
  }
  return match;
}
 

import org.neo4j.graphdb.traversal.Traverser; //导入依赖的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.traversal.Traverser; //导入依赖的package包/类
@Test
public void testRelReader() throws IOException{
  
  RelReader reader = new RelReader(neo4jLocation);
  reader.batchBuildGraph(new File("my_test_umls/"), "CtakesAllTuis.txt", "SNOMEDCT_US");
  GraphDatabaseService db = new GraphDatabaseFactory().newEmbeddedDatabase(new File(neo4jLocation));
  
  try ( Transaction tx = db.beginTx() ){
    TraversalDescription td = db.traversalDescription()
        .breadthFirst()
        .relationships(RelReader.RelTypes.ISA, Direction.INCOMING)
        .evaluator(Evaluators.excludeStartPosition());

    Node cuiNode = db.findNode(RelReader.DictLabels.Concept, RelReader.CUI_PROPERTY, "C0007102");
    Assert.assertNotNull(cuiNode);
    Traverser traverser = td.traverse(cuiNode);
    for(Path path : traverser){
      System.out.println("At depth " + path.length() + " => " + path.endNode().getProperty("cui"));
    }
  }
  db.shutdown();
}
 

import org.neo4j.graphdb.traversal.Traverser; //导入依赖的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.traversal.Traverser; //导入依赖的package包/类
public Iterable<WeightedPath> findAllPaths( Node start, final Node end )
{
    Predicate<Path> filter = new Predicate<Path>()
    {
        public boolean accept( Path position )
        {
            return position.endNode().equals( end );
        }
    };

    final Traverser traverser = TRAVERSAL.expand( expander ).order(
            new SelectorFactory( costEvaluator ) ).filter( filter ).traverse( start );
    return new Iterable<WeightedPath>()
    {
        public Iterator<WeightedPath> iterator()
        {
            return new StopAfterWeightIterator( traverser.iterator(),
                    costEvaluator );
        }
    };
}
 

import org.neo4j.graphdb.traversal.Traverser; //导入依赖的package包/类
public Iterable<WeightedPath> findAllPaths( Node start, final Node end )
{
    Predicate<Path> filter = new Predicate<Path>()
    {
        public boolean accept( Path position )
        {
            return position.endNode().equals( end );
        }
    };

    final Traverser traverser = traversalDescription.order(
            new SelectorFactory( end ) ).filter( filter ).traverse( start );
    return new Iterable<WeightedPath>()
    {
        public Iterator<WeightedPath> iterator()
        {
            return new StopAfterWeightIterator( traverser.iterator(),
                    costEvaluator );
        }
    };
}
 

import org.neo4j.graphdb.traversal.Traverser; //导入依赖的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.traversal.Traverser; //导入依赖的package包/类
private void fillNodesFromBeginning(Node currentNode, ViralShortUrl url) {
    // nodes from beginning, counted via a simple depth-first traversal
    // in the opposite direction
    Traverser t = Traversal.description().depthFirst()
        .evaluator(Evaluators.excludeStartPosition())
        .relationships(LinkRelationship.SPAWNS, Direction.INCOMING)
        .traverse(currentNode);
    int nodesFromBeginning = IteratorUtil.count(t);
    url.setNodesFromBeginning(nodesFromBeginning);
}
 

import org.neo4j.graphdb.traversal.Traverser; //导入依赖的package包/类
public void getAncestors(String task){
    final Traverser traverser = getTraverser(task, Direction.OUTGOING);
    for (Path path : traverser) {
        System.out.println(pathToString(path, TASK_PATH_PRINTER));
    }
    System.out.println("----------------------------------------------");
}
 

import org.neo4j.graphdb.traversal.Traverser; //导入依赖的package包/类
public void getDescendants(String task){
    final Traverser traverser = getTraverser(task, Direction.INCOMING);
    for (Path path : traverser) {
        System.out.println(pathToString(path, TASK_PATH_PRINTER));
    }
    System.out.println("----------------------------------------------");
}
 

import org.neo4j.graphdb.traversal.Traverser; //导入依赖的package包/类
public Traverser getTraverser(String task, Direction direction){
    TraversalDescription td = Traversal.description()
            .breadthFirst()
            .relationships( TaskRelations.DEPENDS_ON, direction )
            .evaluator(Evaluators.excludeStartPosition());
    return td.traverse(getNode(task));
}
 

import org.neo4j.graphdb.traversal.Traverser; //导入依赖的package包/类
@GET
@Path("/cc/{name}")
public String getConnectedComponentsCount(@PathParam("name") String name, @Context GraphDatabaseService db) throws IOException {
    int CCid = 0;
    for ( Node n : GlobalGraphOperations.at( db ).getAllNodes() ) {
        if(!n.hasProperty("CCId")) {
            Transaction tx = db.beginTx();
            try {
                Traverser traverser = Traversal.description()
                        .breadthFirst()
                        .relationships(DynamicRelationshipType.withName(name), Direction.BOTH)
                        .evaluator(Evaluators.excludeStartPosition())
                        .uniqueness(Uniqueness.NODE_GLOBAL)
                        .traverse(n);
                int currentCCid = CCid;
                CCid++;
                n.setProperty("CCId", currentCCid);
                for ( org.neo4j.graphdb.Path p : traverser )
                {
                    p.endNode().setProperty("CCId", currentCCid);
                }
                tx.success();
            }
            catch ( Exception e )
            {
                tx.failure();
            }
            finally
            {
                tx.finish();
            }
        }
    }
    return String.valueOf(CCid);
}