Java Traversal类代码示例

import org.neo4j.kernel.Traversal; //导入依赖的package包/类
public List<Category> getAll() {
	List<Category> categories = new ArrayList<Category>();
	for(Category cat : catRepo.findAllByTraversal(getCategoryRoot(), Traversal.description()
			.breadthFirst()
			.evaluator(Evaluators.fromDepth(1))
			.expand(Traversal
				.expanderForTypes(DynamicRelationshipType
				.withName(RelTypes.PARENT_CATEGORY), 
						  Direction.INCOMING).addNodeFilter(new Predicate<Node>() {
								@Override
								public boolean accept(Node item) {
									return !StringUtils.isEmpty(item.getProperty("name"));
								}
						}
						)))) {
		if(cat != null && cat.getName() != null) { //TODO: Figure out why a null element appears in this traversal
			categories.add(cat);
		}
	}
	return categories;
}
 

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

    return Traversal.description().expand( expander ).depthFirst().filter( filter ).prune(
            Traversal.pruneAfterDepth( maxDepth ) ).uniqueness( uniqueness() ).traverse( start );
}
 

import org.neo4j.kernel.Traversal; //导入依赖的package包/类
public ExperimentalAStar( RelationshipExpander expander, CostEvaluator<Double> costEvaluator,
        EstimateEvaluator<Double> estimateEvaluator )
{
    this.traversalDescription = Traversal.description().uniqueness(
            Uniqueness.NONE ).expand( expander );
    this.costEvaluator = costEvaluator;
    this.estimateEvaluator = estimateEvaluator;
}
 

import org.neo4j.kernel.Traversal; //导入依赖的package包/类
public TraversalDescription expand(RelationshipExpander expander)
{
    if ( expander.equals( this.expander ) )
    {
        return this;
    }
    return new TraversalDescriptionImpl( Traversal.expander( expander ), uniqueness,
            uniquenessParameter, evaluator, branchSelector );
}
 

import org.neo4j.kernel.Traversal; //导入依赖的package包/类
@Override
public void shortestPath(Node n1, Integer i)
{
    PathFinder<Path> finder
        = GraphAlgoFactory.shortestPath(Traversal.expanderForTypes(Neo4jGraphDatabase.RelTypes.SIMILAR), 5);
    Node n2 = getVertex(i);
    Path path = finder.findSinglePath(n1, n2);

}
 

import org.neo4j.kernel.Traversal; //导入依赖的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);
}
 

import org.neo4j.kernel.Traversal; //导入依赖的package包/类
@Override
public String toString()
{
    return Traversal.defaultPathToString( this );
}
 

import org.neo4j.kernel.Traversal; //导入依赖的package包/类
public TraversalDescriptionImpl()
{
    this( StandardExpander.DEFAULT, Uniqueness.NODE_GLOBAL, null,
            Evaluators.all(), Traversal.preorderDepthFirst() );
}
 

import org.neo4j.kernel.Traversal; //导入依赖的package包/类
public TraversalDescription depthFirst()
{
    return order( Traversal.preorderDepthFirst() );
}
 

import org.neo4j.kernel.Traversal; //导入依赖的package包/类
public TraversalDescription breadthFirst()
{
    return order( Traversal.preorderBreadthFirst() );
}
 

import org.neo4j.kernel.Traversal; //导入依赖的package包/类
@Override
public INodeIterator traverse(ParcelableTraversalDescription desc, long startNodeId, ParcelableError err)
        throws RemoteException {
    try {
        resumeTrxIfExists();

        try {
            Node startNode = mDb.getNodeById(startNodeId);
            if (startNode == null) {
                throw new IllegalArgumentException("Illegal start node for traversal");
            }

            TraversalDescription traversalDesc = Traversal.description();

            // map order
            switch (desc.getOrder()) {
                case BREADTH_FIRST:
                    traversalDesc = traversalDesc.breadthFirst();
                    break;
                case DEPTH_FIRST:
                    traversalDesc = traversalDesc.depthFirst();
                    break;
            }

            // map uniqueness
            switch (desc.getUniqueness()) {
                case NONE:
                    traversalDesc = traversalDesc.uniqueness(Uniqueness.NONE);
                    break;
                case NODE_GLOBAL:
                    traversalDesc = traversalDesc.uniqueness(Uniqueness.NODE_GLOBAL);
                    break;
                case NODE_RECENT:
                    traversalDesc = traversalDesc.uniqueness(Uniqueness.NODE_RECENT);
                    break;
                case NODE_PATH:
                    traversalDesc = traversalDesc.uniqueness(Uniqueness.NODE_PATH);
                    break;
                case RELATIONSHIP_GLOBAL:
                    traversalDesc = traversalDesc.uniqueness(Uniqueness.RELATIONSHIP_GLOBAL);
                    break;
                case RELATIONSHIP_PATH:
                    traversalDesc = traversalDesc.uniqueness(Uniqueness.RELATIONSHIP_PATH);
                    break;
                case RELATIONSHIP_RECENT:
                    traversalDesc = traversalDesc.uniqueness(Uniqueness.RELATIONSHIP_RECENT);
                    break;
            }

            // map relationships
            for (String name : desc.getRelationships().keySet()) {
                RelationshipType type = new SimpleRelationshipType(name);
                Direction direction = Direction.valueOf(desc.getRelationships().get(name).name());
                traversalDesc = traversalDesc.relationships(type, direction);
            }

            // TODO: support paths
            Iterator<Node> nodeIterator = traversalDesc.traverse(startNode).nodes().iterator();

            return new NodeIteratorWrapper(nodeIterator);
        } finally {
            suspendCurrentTrx("traverse");
        }
    } catch (Exception e) {
        err.setError(Errors.TRANSACTION, e.getMessage());
        return null;
    }

}
 

import org.neo4j.kernel.Traversal; //导入依赖的package包/类
public static List<CostFunction> getCostFunctionsForNode(Long id, EmbeddedGraphDatabase database) {

        List<CostFunction> costFunctions = new ArrayList<CostFunction>();
        boolean transactionAllreadyRunning = false;
        try {
            transactionAllreadyRunning = (database.getTxManager().getStatus() == Status.STATUS_ACTIVE);
        } catch (SystemException ex) {
            log.error(ex.getMessage(), ex);
        }
        Transaction tx = (transactionAllreadyRunning) ? null : database.beginTx();

        try {

            Node parentNode = database.getNodeById(id);

            if (parentNode == null) {
                return costFunctions;
            }

            //search from this node with ID=id the target nodes for which it has a HAS_COST_FUNCTION relationship
            TraversalDescription description = Traversal.traversal()
                    .evaluator(Evaluators.excludeStartPosition())
                    .relationships(ServiceUnitRelationship.hasCostFunction, Direction.OUTGOING)
                    .uniqueness(Uniqueness.NODE_PATH);
            Traverser traverser = description.traverse(parentNode);
            for (Path path : traverser) {

                Node node = path.endNode();
                CostFunction costFunction = new CostFunction();
                costFunction.setId(node.getId());

                if (node.hasProperty(KEY)) {
                    costFunction.setName(node.getProperty(KEY).toString());
                } else {
                    log.warn("Retrieved CostFunction " + node + " has no " + KEY);
                }

                if (node.hasProperty(UUID)) {
                    costFunction.setUuid(java.util.UUID.fromString(node.getProperty(UUID).toString()));
                } else {
                    log.warn("Retrieved CloudProvider " + costFunction + " has no " + UUID);
                }

                //carefull. this can lead to infinite recursion (is still a graph. maybe improve later)
                costFunction.getAppliedIfServiceInstanceUses().addAll(getAppliedInConjunctionWithEntities(node.getId(), database));
                //need to also retrieve Resurce and Quality

                costFunction.getCostElements().addAll(CostElementDAO.getCostElementPropertiesForNode(node.getId(), database));

                if (costFunction != null) {
                    //hack. if the costFunction has allready been added (equals is done on the DB Node),
                    //this means ServiceUnit has elasticity capability on it, and the old is also removed
                    if (costFunctions.contains(costFunction)) {
                        costFunctions.remove(costFunction);
                    } else {
                        costFunctions.add(costFunction);
                    }
                }
            }
            if (!transactionAllreadyRunning) {
                tx.success();
            }
        } catch (Exception e) {
            log.error(e.getMessage(), e);
            e.printStackTrace();
        } finally {
            if (!transactionAllreadyRunning) {
                tx.finish();
            }
        }

        return costFunctions;
    }
 

import org.neo4j.kernel.Traversal; //导入依赖的package包/类
/**
 * Counts how many elasticity characteristic nodes point to it with a
 * "elasticityCapabilityFor" relationship
 *
 * @param id
 * @param database
 * @return sum of incoming MANDATORY_ASSOCIATION and OPTIONAL_ASSOCIATION
 * elasticity capabilities if returns -1, means error encountered. otherwise
 * the result is always >= 0
 */
public static int getElasticityDependency(long id, EmbeddedGraphDatabase database) {

    CloudOfferedService elTarget = null;
    int incomingPaths = 0;
    boolean transactionAllreadyRunning = false;
    try {
        transactionAllreadyRunning = (database.getTxManager().getStatus() == Status.STATUS_ACTIVE);
    } catch (SystemException ex) {
        log.error(ex.getMessage(), ex);
    }
    Transaction tx = (transactionAllreadyRunning) ? null : database.beginTx();

    try {
        Node parentNode = database.getNodeById(id);

        if (parentNode == null) {
            log.error("Node with id " + id + " was not found");
            return 0;
        }

        TraversalDescription description = Traversal.traversal()
                .evaluator(Evaluators.excludeStartPosition())
                .relationships(ServiceUnitRelationship.hasElasticityCapability, Direction.OUTGOING)
                .uniqueness(Uniqueness.NODE_PATH);
        Traverser traverser = description.traverse(parentNode);

        //for each incoming path, if is MANDATORY_ASSOCIATION decrease the in
        for (Path path : traverser) {
            incomingPaths++;
        }
        if (!transactionAllreadyRunning) {
            if (!transactionAllreadyRunning) {
                tx.success();
            }
        }
    } catch (Exception e) {
        log.error(e.getMessage(), e);

        e.printStackTrace();
    } finally {
        if (!transactionAllreadyRunning) {
            tx.finish();
        }
    }
    return incomingPaths;
}