Uses of Interface
org.neo4j.graphdb.Node

Packages that use Node

org.neo4j.graphalgo	Scalable graph algorithms like shortest path and others for Neo4j which can be easily accessed via GraphAlgoFactory.
org.neo4j.graphalgo.impl.centrality	Centrality graph algorithms which are allright to use, but doesn't scale to bigger graphs.
org.neo4j.graphalgo.impl.path
org.neo4j.graphalgo.impl.shortestpath	Package containing older implementations of Dijkstra and shortest path, where the ones in GraphAlgoFactory would be a better option.
org.neo4j.graphalgo.impl.util
org.neo4j.graphdb	The graph database API used by Neo4j.
org.neo4j.graphdb.event	Event framework.
org.neo4j.graphdb.index	Integrated API for node and relationship indexing.
org.neo4j.graphdb.traversal	Traversal framework.
org.neo4j.graphmatching	Facilities for finding occurrences of patterns in a Neo4j graph.
org.neo4j.index.impl.lucene	An indexing implementation using Apache Lucene as backend.
org.neo4j.kernel	Implementation for embedding a Neo4j graph database in an application.
org.neo4j.kernel.ha
org.neo4j.kernel.impl.core
org.neo4j.kernel.impl.traversal
org.neo4j.tooling.wrap

Uses of Node in org.neo4j.graphalgo

Methods in org.neo4j.graphalgo with parameters of type Node

Iterable<P>	PathFinder.findAllPaths(Node start, Node end) Tries to find all paths between start and end nodes.
P	PathFinder.findSinglePath(Node start, Node end) Tries to find a single path between start and end nodes.
T	EstimateEvaluator.getCost(Node node, Node goal) Estimate the weight of the remaining path from one node to another.

Uses of Node in org.neo4j.graphalgo.impl.centrality

Fields in org.neo4j.graphalgo.impl.centrality with type parameters of type Node

protected Map<Node,CentralityType>	ShortestPathBasedCentrality.centralities This map over centrality values is made available to the algorithms inheriting this class.
protected Set<Node>	EigenvectorCentralityArnoldi.nodeSet
protected Set<Node>	EigenvectorCentralityPower.nodeSet
protected Set<Node>	ShortestPathBasedCentrality.nodeSet
protected Set<Node>	ParallellCentralityCalculation.nodeSet
protected Map<Node,Double>	EigenvectorCentralityArnoldi.values
protected Map<Node,Double>	EigenvectorCentralityPower.values

Methods in org.neo4j.graphalgo.impl.centrality with parameters of type Node

protected void	ShortestPathBasedCentrality.addCentralityToNode(Node node, CentralityType value) This adds a value to a given node in the centralities Map.
protected Double	BetweennessCentrality.getAndUpdateNodeDependency(Node node, boolean skipFirstNode, Map<Node,List<Relationship>> successors, Util.PathCounter counter, Map<Node,Double> dependencies) This recursively updates the node dependencies
protected Double	StressCentrality.getAndUpdateNodeStress(Node node, boolean skipFirstNode, Map<Node,List<Relationship>> successors, Util.PathCounter counter, Map<Node,Double> stresses) This recursively updates the node stress (number of paths through a node).
Double	EigenvectorCentralityArnoldi.getCentrality(Node node) This can be used to retrieve the result for every node.
Double	EigenvectorCentralityPower.getCentrality(Node node) This can be used to retrieve the result for every node.
CentralityType	ShortestPathBasedCentrality.getCentrality(Node node) This can be used to retrieve the result for every node.
ShortestPathCostType	Eccentricity.getCentrality(Node node)
ShortestPathCostType	ClosenessCentrality.getCentrality(Node node)
ShortestPathCostType	NetworkDiameter.getCentrality(Node node)
Double	EigenvectorCentrality.getCentrality(Node node) This can be used to retrieve the result for every node.
ShortestPathCostType	NetworkRadius.getCentrality(Node node)
abstract void	ShortestPathBasedCentrality.processShortestPaths(Node node, SingleSourceShortestPath<ShortestPathCostType> singleSourceShortestPath) This is the abstract method all centrality algorithms based on this class need to implement.
void	BetweennessCentrality.processShortestPaths(Node node, SingleSourceShortestPath<ShortestPathCostType> singleSourceShortestPath)
void	Eccentricity.processShortestPaths(Node node, SingleSourceShortestPath<ShortestPathCostType> singleSourceShortestPath)
void	StressCentrality.processShortestPaths(Node node, SingleSourceShortestPath<ShortestPathCostType> singleSourceShortestPath)
void	ClosenessCentrality.processShortestPaths(Node node, SingleSourceShortestPath<ShortestPathCostType> singleSourceShortestPath)
void	NetworkDiameter.processShortestPaths(Node node, SingleSourceShortestPath<ShortestPathCostType> singleSourceShortestPath)
void	NetworkRadius.processShortestPaths(Node node, SingleSourceShortestPath<ShortestPathCostType> singleSourceShortestPath)
protected void	ShortestPathBasedCentrality.setCentralityForNode(Node node, CentralityType value) This sets a value for a given node in the centralities Map.

Method parameters in org.neo4j.graphalgo.impl.centrality with type arguments of type Node

protected Double	BetweennessCentrality.getAndUpdateNodeDependency(Node node, boolean skipFirstNode, Map<Node,List<Relationship>> successors, Util.PathCounter counter, Map<Node,Double> dependencies) This recursively updates the node dependencies
protected Double	BetweennessCentrality.getAndUpdateNodeDependency(Node node, boolean skipFirstNode, Map<Node,List<Relationship>> successors, Util.PathCounter counter, Map<Node,Double> dependencies) This recursively updates the node dependencies
protected Double	StressCentrality.getAndUpdateNodeStress(Node node, boolean skipFirstNode, Map<Node,List<Relationship>> successors, Util.PathCounter counter, Map<Node,Double> stresses) This recursively updates the node stress (number of paths through a node).
protected Double	StressCentrality.getAndUpdateNodeStress(Node node, boolean skipFirstNode, Map<Node,List<Relationship>> successors, Util.PathCounter counter, Map<Node,Double> stresses) This recursively updates the node stress (number of paths through a node).
protected double	EigenvectorCentralityArnoldi.normalize(Map<Node,Double> vector) Normalizes a vector represented as a Map.
protected void	EigenvectorCentralityPower.normalize(Map<Node,Double> vector) Normalizes a vector represented as a Map.
protected void	EigenvectorCentralityArnoldi.processRelationship(Map<Node,Double> newValues, Relationship relationship, boolean backwards) Internal method used in the "matrix multiplication" in each iteration.
protected void	EigenvectorCentralityPower.processRelationship(Map<Node,Double> newValues, Relationship relationship, boolean backwards) Internal method used in the "matrix multiplication" in each iteration.

Constructor parameters in org.neo4j.graphalgo.impl.centrality with type arguments of type Node

BetweennessCentrality(SingleSourceShortestPath<ShortestPathCostType> singleSourceShortestPath, Set<Node> nodeSet)
Default constructor.

ClosenessCentrality(SingleSourceShortestPath<ShortestPathCostType> singleSourceShortestPath, CostAccumulator<ShortestPathCostType> centralityAccumulator, ShortestPathCostType zeroValue, Set<Node> nodeSet, CostDivider<ShortestPathCostType> centralityDivider)
Default constructor.

Eccentricity(SingleSourceShortestPath<ShortestPathCostType> singleSourceShortestPath, ShortestPathCostType zeroValue, Set<Node> nodeSet, Comparator<ShortestPathCostType> distanceComparator)
Default constructor.

EigenvectorCentralityArnoldi(Direction relationDirection, CostEvaluator<Double> costEvaluator, Set<Node> nodeSet, Set<Relationship> relationshipSet, double precision)

EigenvectorCentralityPower(Direction relationDirection, CostEvaluator<Double> costEvaluator, Set<Node> nodeSet, Set<Relationship> relationshipSet, double precision)

NetworkDiameter(SingleSourceShortestPath<ShortestPathCostType> singleSourceShortestPath, ShortestPathCostType zeroValue, Set<Node> nodeSet, Comparator<ShortestPathCostType> distanceComparator)
Default constructor.

NetworkRadius(SingleSourceShortestPath<ShortestPathCostType> singleSourceShortestPath, ShortestPathCostType zeroValue, Set<Node> nodeSet, Comparator<ShortestPathCostType> distanceComparator)
Default constructor.

ParallellCentralityCalculation(SingleSourceShortestPath<ShortestPathCostType> singleSourceShortestPath, Set<Node> nodeSet)
Default constructor.

ShortestPathBasedCentrality(SingleSourceShortestPath<ShortestPathCostType> singleSourceShortestPath, CostAccumulator<CentralityType> centralityAccumulator, CentralityType zeroValue, Set<Node> nodeSet)
Default constructor.

StressCentrality(SingleSourceShortestPath<ShortestPathCostType> singleSourceShortestPath, Set<Node> nodeSet)
Default constructor.

Uses of Node in org.neo4j.graphalgo.impl.path

Methods in org.neo4j.graphalgo.impl.path that return Node

protected Node

ShortestPath.DirectionData.fetchNextOrNull()

Methods in org.neo4j.graphalgo.impl.path that return types with arguments of type Node

protected Collection<Node>

ShortestPath.filterNextLevelNodes(Collection<Node> nextNodes)

Methods in org.neo4j.graphalgo.impl.path with parameters of type Node

Iterable<Path>	AllPaths.findAllPaths(Node start, Node end)
Iterable<WeightedPath>	Dijkstra.findAllPaths(Node start, Node end)
Iterable<Path>	ShortestPath.findAllPaths(Node start, Node end)
Iterable<WeightedPath>	ExperimentalAStar.findAllPaths(Node start, Node end)
Iterable<WeightedPath>	AStar.findAllPaths(Node node, Node end)
Iterable<Path>	ExactDepthPathFinder.findAllPaths(Node start, Node end)
Path	AllPaths.findSinglePath(Node start, Node end)
WeightedPath	Dijkstra.findSinglePath(Node start, Node end)
Path	ShortestPath.findSinglePath(Node start, Node end)
WeightedPath	ExperimentalAStar.findSinglePath(Node start, Node end)
WeightedPath	AStar.findSinglePath(Node start, Node end)
Path	ExactDepthPathFinder.findSinglePath(Node start, Node end)

Method parameters in org.neo4j.graphalgo.impl.path with type arguments of type Node

protected Collection<Node>

ShortestPath.filterNextLevelNodes(Collection<Node> nextNodes)

Uses of Node in org.neo4j.graphalgo.impl.shortestpath

Fields in org.neo4j.graphalgo.impl.shortestpath declared as Node

protected Node	Dijkstra.endNode
protected Node	SingleSourceShortestPathBFS.startNode
protected Node	Dijkstra.startNode
protected Node	Dijkstra.DijstraIterator.startNode

Fields in org.neo4j.graphalgo.impl.shortestpath with type parameters of type Node

protected HashMap<Node,CostType>	SingleSourceShortestPathDijkstra.distances
protected HashMap<Node,Integer>	SingleSourceShortestPathBFS.distances
protected Set<Node>	Dijkstra.foundPathsMiddleNodes
protected HashMap<Node,CostType>	Dijkstra.DijstraIterator.myDistances
protected HashMap<Node,CostType>	Dijkstra.DijstraIterator.mySeen
protected Set<Node>	FloydWarshall.nodeSet
protected HashMap<Node,CostType>	Dijkstra.DijstraIterator.otherDistances
protected HashMap<Node,CostType>	Dijkstra.DijstraIterator.otherSeen
protected HashMap<Node,List<Relationship>>	SingleSourceShortestPathBFS.predecessors
protected HashMap<Node,List<Relationship>>	Dijkstra.DijstraIterator.predecessors
protected HashMap<Node,List<Relationship>>	Dijkstra.predecessors1
protected HashMap<Node,List<Relationship>>	Dijkstra.predecessors2

Methods in org.neo4j.graphalgo.impl.shortestpath that return Node

Node	DijkstraPriorityQueue.extractMin() Retrieve and remove the node with the most optimal value.
Node	DijkstraPriorityQueueFibonacciImpl.extractMin()
Node	DijkstraPriorityQueueImpl.extractMin() Retrieve and remove
Node	DijkstraPriorityQueueFibonacciImpl.HeapObject.getNode()
Node	DijkstraPriorityQueueImpl.pathObject.getNode()
Node	Dijkstra.DijstraIterator.next()
Node	DijkstraPriorityQueue.peek() Retrieve without removing the node with the most optimal value.
Node	DijkstraPriorityQueueFibonacciImpl.peek()
Node	DijkstraPriorityQueueImpl.peek() Retrieve without removing

Methods in org.neo4j.graphalgo.impl.shortestpath that return types with arguments of type Node

protected static List<LinkedList<Node>>	Util.constructAllPathsToNodeAsNodeLinkedLists(Node node, Map<Node,List<Relationship>> predecessors, boolean includeNode, boolean backwards) Same as constructAllPathsToNodeAsNodes, but different return type
static List<List<Node>>	Util.constructAllPathsToNodeAsNodes(Node node, Map<Node,List<Relationship>> predecessors, boolean includeNode, boolean backwards) Constructs all paths to a given node, for a given set of predecessors
static List<Node>	Util.constructSinglePathToNodeAsNodes(Node node, Map<Node,List<Relationship>> predecessors, boolean includeNode, boolean backwards) Constructs a path to a given node, for a given set of predecessors
List<Node>	FloydWarshall.getPath(Node startNode, Node targetNode) This returns the shortest path between two nodes as list of nodes.
List<Node>	SingleSourceSingleSinkShortestPath.getPathAsNodes() A call to this will run the algorithm to find a single shortest path, if not already done, and return it as a list of nodes.
List<Node>	SingleSourceShortestPathDijkstra.getPathAsNodes()
List<Node>	Dijkstra.getPathAsNodes()
List<Node>	SingleSourceShortestPathDijkstra.getPathAsNodes(Node targetNode)
List<Node>	SingleSourceShortestPathBFS.getPathAsNodes(Node targetNode)
List<Node>	SingleSourceShortestPath.getPathAsNodes(Node targetNode) A call to this will run the algorithm, if not already done, and return the found path to the target node if found as a list of nodes.
List<List<Node>>	SingleSourceSingleSinkShortestPath.getPathsAsNodes() A call to this will run the algorithm to find all shortest paths, if not already done, and return them as lists of nodes.
List<List<Node>>	SingleSourceShortestPathDijkstra.getPathsAsNodes()
List<List<Node>>	Dijkstra.getPathsAsNodes()
List<List<Node>>	SingleSourceShortestPathDijkstra.getPathsAsNodes(Node targetNode)
List<List<Node>>	SingleSourceShortestPathBFS.getPathsAsNodes(Node targetNode)
List<List<Node>>	SingleSourceShortestPath.getPathsAsNodes(Node targetNode) A call to this will run the algorithm to find all shortest paths, if not already done, and return them as lists of nodes.
List<Node>	SingleSourceShortestPathDijkstra.getPredecessorNodes(Node node)
List<Node>	SingleSourceShortestPathBFS.getPredecessorNodes(Node node)
List<Node>	SingleSourceShortestPath.getPredecessorNodes(Node node)
Map<Node,List<Relationship>>	SingleSourceShortestPathDijkstra.getPredecessors()
Map<Node,List<Relationship>>	SingleSourceShortestPathBFS.getPredecessors()
Map<Node,List<Relationship>>	SingleSourceShortestPath.getPredecessors() This can be used to retrieve the entire data structure representing the predecessors for every node.
static Map<Node,List<Relationship>>	Util.reversedPredecessors(Map<Node,List<Relationship>> predecessors) This can be used to generate the inverse of a structure with predecessors, i.e.

Methods in org.neo4j.graphalgo.impl.shortestpath with parameters of type Node

boolean	SingleSourceShortestPathDijkstra.calculate(Node targetNode) Internal calculate method that will run the calculation until either the limit is reached or a result has been generated for a given node.
boolean	SingleSourceShortestPathBFS.calculate(Node targetNode) Internal calculate method that will run the calculation until either the limit is reached or a result has been generated for a given node.
boolean	SingleSourceShortestPathDijkstra.calculateMultiple(Node targetNode) Same as calculate(), but will set the flag to calculate all shortest paths.
protected void	Dijkstra.DijstraIterator.checkForPath(Node currentNode, CostType currentCost, HashMap<Node,CostType> otherSideDistances) This checks if a node has been seen by the other iterator/traverser as well.
static List<List<PropertyContainer>>	Util.constructAllPathsToNode(Node node, Map<Node,List<Relationship>> predecessors, boolean includeNode, boolean backwards) Constructs all paths to a given node, for a given set of predecessors
protected static List<LinkedList<PropertyContainer>>	Util.constructAllPathsToNodeAsLinkedLists(Node node, Map<Node,List<Relationship>> predecessors, boolean includeNode, boolean backwards) Same as constructAllPathsToNode, but different return type
protected static List<LinkedList<Node>>	Util.constructAllPathsToNodeAsNodeLinkedLists(Node node, Map<Node,List<Relationship>> predecessors, boolean includeNode, boolean backwards) Same as constructAllPathsToNodeAsNodes, but different return type
static List<List<Node>>	Util.constructAllPathsToNodeAsNodes(Node node, Map<Node,List<Relationship>> predecessors, boolean includeNode, boolean backwards) Constructs all paths to a given node, for a given set of predecessors
protected static List<LinkedList<Relationship>>	Util.constructAllPathsToNodeAsRelationshipLinkedLists(Node node, Map<Node,List<Relationship>> predecessors, boolean backwards) Same as constructAllPathsToNodeAsRelationships, but different return type
static List<List<Relationship>>	Util.constructAllPathsToNodeAsRelationships(Node node, Map<Node,List<Relationship>> predecessors, boolean backwards) Constructs all paths to a given node, for a given set of predecessors.
static List<PropertyContainer>	Util.constructSinglePathToNode(Node node, Map<Node,List<Relationship>> predecessors, boolean includeNode, boolean backwards) Constructs a path to a given node, for a given set of predecessors.
static List<Node>	Util.constructSinglePathToNodeAsNodes(Node node, Map<Node,List<Relationship>> predecessors, boolean includeNode, boolean backwards) Constructs a path to a given node, for a given set of predecessors
static List<Relationship>	Util.constructSinglePathToNodeAsRelationships(Node node, Map<Node,List<Relationship>> predecessors, boolean backwards) Constructs a path to a given node, for a given set of predecessors
void	DijkstraPriorityQueue.decreaseValue(Node node, CostType newValue) Used to update a value in the queue (or insert it).
void	DijkstraPriorityQueueFibonacciImpl.decreaseValue(Node node, CostType newValue)
void	DijkstraPriorityQueueImpl.decreaseValue(Node node, CostType newValue)
CostType	SingleSourceShortestPathDijkstra.getCost(Node targetNode)
Integer	SingleSourceShortestPathBFS.getCost(Node targetNode)
CostType	SingleSourceShortestPath.getCost(Node targetNode) A call to this will run the algorithm, if not already done, and return the cost for the shortest paths between the start node and the target node.
CostType	FloydWarshall.getCost(Node node1, Node node2) This returns the cost for the shortest path between two nodes.
int	Util.PathCounter.getNumberOfPathsToNode(Node node)
List<PropertyContainer>	SingleSourceShortestPathDijkstra.getPath(Node targetNode)
List<PropertyContainer>	SingleSourceShortestPathBFS.getPath(Node targetNode)
List<PropertyContainer>	SingleSourceShortestPath.getPath(Node targetNode) A call to this will run the algorithm to find a single shortest path, if not already done, and return it as an alternating list of Node/Relationship.
List<Node>	FloydWarshall.getPath(Node startNode, Node targetNode) This returns the shortest path between two nodes as list of nodes.
List<Node>	SingleSourceShortestPathDijkstra.getPathAsNodes(Node targetNode)
List<Node>	SingleSourceShortestPathBFS.getPathAsNodes(Node targetNode)
List<Node>	SingleSourceShortestPath.getPathAsNodes(Node targetNode) A call to this will run the algorithm, if not already done, and return the found path to the target node if found as a list of nodes.
List<Relationship>	SingleSourceShortestPathDijkstra.getPathAsRelationships(Node targetNode)
List<Relationship>	SingleSourceShortestPathBFS.getPathAsRelationships(Node targetNode)
List<Relationship>	SingleSourceShortestPath.getPathAsRelationships(Node targetNode) A call to this will run the algorithm to find a single shortest path, if not already done, and return it as a list of Relationships.
List<List<PropertyContainer>>	SingleSourceShortestPathDijkstra.getPaths(Node targetNode)
List<List<PropertyContainer>>	SingleSourceShortestPathBFS.getPaths(Node targetNode)
List<List<PropertyContainer>>	SingleSourceShortestPath.getPaths(Node targetNode) A call to this will run the algorithm to find all shortest paths, if not already done, and return them as alternating lists of Node/Relationship.
List<List<Node>>	SingleSourceShortestPathDijkstra.getPathsAsNodes(Node targetNode)
List<List<Node>>	SingleSourceShortestPathBFS.getPathsAsNodes(Node targetNode)
List<List<Node>>	SingleSourceShortestPath.getPathsAsNodes(Node targetNode) A call to this will run the algorithm to find all shortest paths, if not already done, and return them as lists of nodes.
List<List<Relationship>>	SingleSourceShortestPathDijkstra.getPathsAsRelationships(Node targetNode)
List<List<Relationship>>	SingleSourceShortestPathBFS.getPathsAsRelationships(Node targetNode)
List<List<Relationship>>	SingleSourceShortestPath.getPathsAsRelationships(Node targetNode) A call to this will run the algorithm to find all shortest paths, if not already done, and return them as lists of relationships.
List<Node>	SingleSourceShortestPathDijkstra.getPredecessorNodes(Node node)
List<Node>	SingleSourceShortestPathBFS.getPredecessorNodes(Node node)
List<Node>	SingleSourceShortestPath.getPredecessorNodes(Node node)
void	DijkstraPriorityQueue.insertValue(Node node, CostType value) Used to insert a new value into the queue.
void	DijkstraPriorityQueueFibonacciImpl.insertValue(Node node, CostType value)
void	DijkstraPriorityQueueImpl.insertValue(Node node, CostType value)
void	SingleSourceSingleSinkShortestPath.setEndNode(Node node) This sets the end node.
void	SingleSourceShortestPathDijkstra.setEndNode(Node endNode)
void	Dijkstra.setEndNode(Node endNode) Set the end node.
void	SingleSourceSingleSinkShortestPath.setStartNode(Node node) This sets the start node.
void	SingleSourceShortestPathBFS.setStartNode(Node node)
void	Dijkstra.setStartNode(Node startNode) Set the start node.
void	SingleSourceShortestPath.setStartNode(Node node) This sets the start node.

Method parameters in org.neo4j.graphalgo.impl.shortestpath with type arguments of type Node

protected void	Dijkstra.DijstraIterator.checkForPath(Node currentNode, CostType currentCost, HashMap<Node,CostType> otherSideDistances) This checks if a node has been seen by the other iterator/traverser as well.
static List<List<PropertyContainer>>	Util.constructAllPathsToNode(Node node, Map<Node,List<Relationship>> predecessors, boolean includeNode, boolean backwards) Constructs all paths to a given node, for a given set of predecessors
protected static List<LinkedList<PropertyContainer>>	Util.constructAllPathsToNodeAsLinkedLists(Node node, Map<Node,List<Relationship>> predecessors, boolean includeNode, boolean backwards) Same as constructAllPathsToNode, but different return type
protected static List<LinkedList<Node>>	Util.constructAllPathsToNodeAsNodeLinkedLists(Node node, Map<Node,List<Relationship>> predecessors, boolean includeNode, boolean backwards) Same as constructAllPathsToNodeAsNodes, but different return type
static List<List<Node>>	Util.constructAllPathsToNodeAsNodes(Node node, Map<Node,List<Relationship>> predecessors, boolean includeNode, boolean backwards) Constructs all paths to a given node, for a given set of predecessors
protected static List<LinkedList<Relationship>>	Util.constructAllPathsToNodeAsRelationshipLinkedLists(Node node, Map<Node,List<Relationship>> predecessors, boolean backwards) Same as constructAllPathsToNodeAsRelationships, but different return type
static List<List<Relationship>>	Util.constructAllPathsToNodeAsRelationships(Node node, Map<Node,List<Relationship>> predecessors, boolean backwards) Constructs all paths to a given node, for a given set of predecessors.
static List<PropertyContainer>	Util.constructSinglePathToNode(Node node, Map<Node,List<Relationship>> predecessors, boolean includeNode, boolean backwards) Constructs a path to a given node, for a given set of predecessors.
static List<Node>	Util.constructSinglePathToNodeAsNodes(Node node, Map<Node,List<Relationship>> predecessors, boolean includeNode, boolean backwards) Constructs a path to a given node, for a given set of predecessors
static List<Relationship>	Util.constructSinglePathToNodeAsRelationships(Node node, Map<Node,List<Relationship>> predecessors, boolean backwards) Constructs a path to a given node, for a given set of predecessors
static Map<Node,List<Relationship>>	Util.reversedPredecessors(Map<Node,List<Relationship>> predecessors) This can be used to generate the inverse of a structure with predecessors, i.e.

Constructors in org.neo4j.graphalgo.impl.shortestpath with parameters of type Node

Dijkstra.DijstraIterator(Node startNode, HashMap<Node,List<Relationship>> predecessors, HashMap<Node,CostType> mySeen, HashMap<Node,CostType> otherSeen, HashMap<Node,CostType> myDistances, HashMap<Node,CostType> otherDistances, boolean backwards)

Dijkstra(CostType startCost, Node startNode, Node endNode, CostEvaluator<CostType> costEvaluator, CostAccumulator<CostType> costAccumulator, Comparator<CostType> costComparator, Direction relationDirection, RelationshipType... costRelationTypes)

DijkstraPriorityQueueFibonacciImpl.HeapObject(Node node, CostType cost)

DijkstraPriorityQueueImpl.pathObject(Node node, CostType cost)

SingleSourceShortestPathBFS(Node startNode, Direction relationShipDirection, RelationshipType... relationShipTypes)

SingleSourceShortestPathDijkstra(CostType startCost, Node startNode, CostEvaluator<CostType> costEvaluator, CostAccumulator<CostType> costAccumulator, Comparator<CostType> costComparator, Direction relationDirection, RelationshipType... costRelationTypes)

Constructor parameters in org.neo4j.graphalgo.impl.shortestpath with type arguments of type Node

Dijkstra.DijstraIterator(Node startNode, HashMap<Node,List<Relationship>> predecessors, HashMap<Node,CostType> mySeen, HashMap<Node,CostType> otherSeen, HashMap<Node,CostType> myDistances, HashMap<Node,CostType> otherDistances, boolean backwards)

Dijkstra.DijstraIterator(Node startNode, HashMap<Node,List<Relationship>> predecessors, HashMap<Node,CostType> mySeen, HashMap<Node,CostType> otherSeen, HashMap<Node,CostType> myDistances, HashMap<Node,CostType> otherDistances, boolean backwards)

Dijkstra.DijstraIterator(Node startNode, HashMap<Node,List<Relationship>> predecessors, HashMap<Node,CostType> mySeen, HashMap<Node,CostType> otherSeen, HashMap<Node,CostType> myDistances, HashMap<Node,CostType> otherDistances, boolean backwards)

Dijkstra.DijstraIterator(Node startNode, HashMap<Node,List<Relationship>> predecessors, HashMap<Node,CostType> mySeen, HashMap<Node,CostType> otherSeen, HashMap<Node,CostType> myDistances, HashMap<Node,CostType> otherDistances, boolean backwards)

Dijkstra.DijstraIterator(Node startNode, HashMap<Node,List<Relationship>> predecessors, HashMap<Node,CostType> mySeen, HashMap<Node,CostType> otherSeen, HashMap<Node,CostType> myDistances, HashMap<Node,CostType> otherDistances, boolean backwards)

FloydWarshall(CostType startCost, CostType infinitelyBad, Direction relationDirection, CostEvaluator<CostType> costEvaluator, CostAccumulator<CostType> costAccumulator, Comparator<CostType> costComparator, Set<Node> nodeSet, Set<Relationship> relationshipSet)

Util.PathCounter(Map<Node,List<Relationship>> predecessors)

Uses of Node in org.neo4j.graphalgo.impl.util

Fields in org.neo4j.graphalgo.impl.util with type parameters of type Node

static org.neo4j.graphalgo.impl.util.PriorityMap.Converter<Node,TraversalBranch>

BestFirstSelectorFactory.CONVERTER

Methods in org.neo4j.graphalgo.impl.util that return Node

Node	PathImpl.endNode()
Node	WeightedPathImpl.endNode()
Node	PathImpl.Builder.getStartNode()
Node	PathImpl.startNode()
Node	WeightedPathImpl.startNode()

Methods in org.neo4j.graphalgo.impl.util that return types with arguments of type Node

Iterable<Node>	PathImpl.nodes()
Iterable<Node>	WeightedPathImpl.nodes()

Methods in org.neo4j.graphalgo.impl.util with parameters of type Node

Double	GeoEstimateEvaluator.getCost(Node node, Node goal)
static Path	PathImpl.singular(Node start)

Constructors in org.neo4j.graphalgo.impl.util with parameters of type Node

PathImpl.Builder(Node start)

Uses of Node in org.neo4j.graphdb

Methods in org.neo4j.graphdb that return Node

Node	GraphDatabaseService.createNode() Creates a new node.
Node	TraversalPosition.currentNode() Returns the current node.
Node	Path.endNode() Returns the end node of this path.
Node	Relationship.getEndNode() Returns the end node of this relationship.
Node	GraphDatabaseService.getNodeById(long id) Looks up a node by id.
Node[]	Relationship.getNodes() Returns the two nodes that are attached to this relationship.
Node	Relationship.getOtherNode(Node node) A convenience operation that, given a node that is attached to this relationship, returns the other node.
Node	GraphDatabaseService.getReferenceNode() Returns the reference node, which is a "starting point" in the node space.
Node	Relationship.getStartNode() Returns the start node of this relationship.
Node	TraversalPosition.previousNode() Returns the previous node.
Node	Path.startNode() Returns the start node of this path.

Methods in org.neo4j.graphdb that return types with arguments of type Node

Iterable<Node>	GraphDatabaseService.getAllNodes() Returns all nodes in the node space.
Collection<Node>	Traverser.getAllNodes() Returns a collection of all nodes for this traversal.
Iterator<Node>	Traverser.iterator() Returns an Iterator representing the traversal of the graph.
Iterable<Node>	Path.nodes() Returns all the nodes in this path.

Methods in org.neo4j.graphdb with parameters of type Node

Relationship	Node.createRelationshipTo(Node otherNode, RelationshipType type) Creates a relationship between this node and another node.
Iterable<Relationship>	RelationshipExpander.expand(Node node) Returns relationships for a node in whatever way the implementation likes.
Node	Relationship.getOtherNode(Node node) A convenience operation that, given a node that is attached to this relationship, returns the other node.

Method parameters in org.neo4j.graphdb with type arguments of type Node

Expander

Expander.addNodeFilter(Predicate<? super Node> filter) Add a Node filter.

Uses of Node in org.neo4j.graphdb.event

Methods in org.neo4j.graphdb.event that return types with arguments of type Node

Iterable<PropertyEntry<Node>>	TransactionData.assignedNodeProperties() Get the properties that had a value assigned or overwritten on a node during the transaction.
Iterable<Node>	TransactionData.createdNodes() Get the nodes that were created during the transaction.
Iterable<Node>	TransactionData.deletedNodes() Get the nodes that were deleted during the transaction.
Iterable<PropertyEntry<Node>>	TransactionData.removedNodeProperties() Get the properties that had a value removed from a node during the transaction.

Methods in org.neo4j.graphdb.event with parameters of type Node

boolean

TransactionData.isDeleted(Node node) Returns whether or not node is deleted in this transaction.

Uses of Node in org.neo4j.graphdb.index

Methods in org.neo4j.graphdb.index that return Node

protected Node

UniqueFactory.UniqueNodeFactory.create(Map<String,Object> properties) Default implementation of UniqueFactory.create(Map), creates a plain node.

Methods in org.neo4j.graphdb.index that return types with arguments of type Node

Index<Node>	IndexManager.forNodes(String indexName) Returns an Index for Nodes with the name indexName.
Index<Node>	IndexManager.forNodes(String indexName, Map<String,String> customConfiguration) Returns an Index for Nodes with the name indexName.
AutoIndexer<Node>	IndexManager.getNodeAutoIndexer()
abstract Index<Node>	IndexImplementation.nodeIndex(String indexName, Map<String,String> config) Returns an Index for Nodes for the name indexName with the given config.

Methods in org.neo4j.graphdb.index with parameters of type Node

protected void	UniqueFactory.UniqueNodeFactory.delete(Node node) Default implementation of UniqueFactory.delete(PropertyContainer).
IndexHits<Relationship>	ReadableRelationshipIndex.get(String key, Object valueOrNull, Node startNodeOrNull, Node endNodeOrNull) Returns exact matches from this index, given the key/value pair.
IndexHits<Relationship>	ReadableRelationshipIndex.query(Object queryOrQueryObjectOrNull, Node startNodeOrNull, Node endNodeOrNull) Returns matches from this index based on the supplied query object, which can be a query string or an implementation-specific query object.
IndexHits<Relationship>	ReadableRelationshipIndex.query(String key, Object queryOrQueryObjectOrNull, Node startNodeOrNull, Node endNodeOrNull) Returns matches from this index based on the supplied key and query object, which can be a query string or an implementation-specific query object.

Constructor parameters in org.neo4j.graphdb.index with type arguments of type Node

UniqueFactory.UniqueNodeFactory(Index<Node> index)
Create a new UniqueFactory for nodes.

Uses of Node in org.neo4j.graphdb.traversal

Methods in org.neo4j.graphdb.traversal that return Node

Node	TraversalBranch.node() The node for this expansion source.

Methods in org.neo4j.graphdb.traversal that return types with arguments of type Node

Iterable<Node>

Traverser.nodes() Represents the traversal in the form of Nodes.

Methods in org.neo4j.graphdb.traversal with parameters of type Node

Traverser

TraversalDescription.traverse(Node startNode) Traverse from startNode based on all the rules and behavior in this description.

Uses of Node in org.neo4j.graphmatching

Methods in org.neo4j.graphmatching that return Node

Node	PatternElement.getNode() Returns the matching Node which is just one part of the whole match.
Node	PatternMatch.getNodeFor(PatternNode node)

Methods in org.neo4j.graphmatching with parameters of type Node

Iterable<PatternMatch>	PatternMatcher.match(PatternNode start, Node startNode) Find occurrences of the pattern defined by the given PatternNode where the given PatternNode starts matching at the given Node.
Iterable<PatternMatch>	PatternMatcher.match(PatternNode start, Node startNode, Map<String,PatternNode> objectVariables) Find occurrences of the pattern defined by the given PatternNode where the given PatternNode starts matching at the given Node.
Iterable<PatternMatch>	PatternMatcher.match(PatternNode start, Node startNode, Map<String,PatternNode> objectVariables, Collection<PatternNode> optional) Find occurrences of the pattern defined by the given PatternNode where the given PatternNode starts matching at the given Node.
Iterable<PatternMatch>	PatternMatcher.match(PatternNode start, Node startNode, Map<String,PatternNode> objectVariables, PatternNode... optional) Find occurrences of the pattern defined by the given PatternNode where the given PatternNode starts matching at the given Node.

Uses of Node in org.neo4j.index.impl.lucene

Methods in org.neo4j.index.impl.lucene that return types with arguments of type Node

Index<Node>

LuceneIndexImplementation.nodeIndex(String indexName, Map<String,String> config)

Uses of Node in org.neo4j.kernel

Methods in org.neo4j.kernel that return Node

Node	EmbeddedGraphDatabase.createNode()
Node	EmbeddedReadOnlyGraphDatabase.createNode()
Node	HAGraphDb.createNode()
Node	EmbeddedGraphDatabase.getNodeById(long id)
Node	EmbeddedReadOnlyGraphDatabase.getNodeById(long id)
Node	HAGraphDb.getNodeById(long id)
Node	EmbeddedGraphDatabase.getReferenceNode()
Node	EmbeddedReadOnlyGraphDatabase.getReferenceNode()
Node	HAGraphDb.getReferenceNode()

Methods in org.neo4j.kernel that return types with arguments of type Node

Iterable<Node>	EmbeddedGraphDatabase.getAllNodes()
Iterable<Node>	EmbeddedReadOnlyGraphDatabase.getAllNodes()
Iterable<Node>	HAGraphDb.getAllNodes()

Methods in org.neo4j.kernel with parameters of type Node

org.neo4j.kernel.Expansion<Relationship>	StandardExpander.expand(Node start)
protected WrappedNode<? extends WrappedGraphDatabase>	HighlyAvailableGraphDatabase.node(Node node, boolean created)
String	Traversal.DefaultPathDescriptor.nodeRepresentation(Path path, Node node)
String	Traversal.PathDescriptor.nodeRepresentation(T path, Node node) Returns a string representation of a Node.
String	Traversal.DefaultPathDescriptor.relationshipRepresentation(Path path, Node from, Relationship relationship)
String	Traversal.PathDescriptor.relationshipRepresentation(T path, Node from, Relationship relationship) Returns a string representation of a Relationship.

Method parameters in org.neo4j.kernel with type arguments of type Node

StandardExpander	StandardExpander.addNodeFilter(Predicate<? super Node> filter)
protected WrappedIndex.WrappedNodeIndex	HighlyAvailableGraphDatabase.automaticNodeIndex(ReadableIndex<Node> index)
protected WrappedIndex.WrappedNodeIndex	HighlyAvailableGraphDatabase.nodeIndex(Index<Node> index, String indexName)

Uses of Node in org.neo4j.kernel.ha

Classes in org.neo4j.kernel.ha that implement Node

class

LockableNode

Methods in org.neo4j.kernel.ha that return Node

Node	LockableRelationship.getEndNode()
Node[]	LockableRelationship.getNodes()
Node	LockableRelationship.getOtherNode(Node node)
Node	LockableRelationship.getStartNode()

Methods in org.neo4j.kernel.ha with parameters of type Node

Relationship	LockableNode.createRelationshipTo(Node otherNode, RelationshipType type)
Node	LockableRelationship.getOtherNode(Node node)

Uses of Node in org.neo4j.kernel.impl.core

Methods in org.neo4j.kernel.impl.core that return Node

Node	NodeManager.createNode()
Node	NodeManager.getNodeById(long nodeId)
Node	NodeManager.getReferenceNode()

Methods in org.neo4j.kernel.impl.core with parameters of type Node

Relationship

NodeManager.createRelationship(org.neo4j.kernel.impl.core.NodeImpl startNode, Node endNode, RelationshipType type)

Method parameters in org.neo4j.kernel.impl.core with type arguments of type Node

void	NodeManager.addNodePropertyTracker(PropertyTracker<Node> nodePropertyTracker)
void	NodeManager.removeNodePropertyTracker(PropertyTracker<Node> nodePropertyTracker)

Uses of Node in org.neo4j.kernel.impl.traversal

Methods in org.neo4j.kernel.impl.traversal that return Node

Node	TraversalPath.endNode()
Node	FinalTraversalBranch.node()
Node	TraversalPath.startNode()

Methods in org.neo4j.kernel.impl.traversal that return types with arguments of type Node

Iterable<Node>

TraversalPath.nodes()

Methods in org.neo4j.kernel.impl.traversal with parameters of type Node

Traverser	TraversalDescriptionImpl.traverse(Node startNode)
static Traverser	OldTraverserWrapper.traverse(Node node, Traverser.Order traversalOrder, StopEvaluator stopEvaluator, ReturnableEvaluator returnableEvaluator, Object... relationshipTypesAndDirections)

Constructors in org.neo4j.kernel.impl.traversal with parameters of type Node

FinalTraversalBranch(Node head, Relationship... path)

Uses of Node in org.neo4j.tooling.wrap

Classes in org.neo4j.tooling.wrap that implement Node

class

WrappedNode<G extends WrappedGraphDatabase>

Methods in org.neo4j.tooling.wrap that return Node

Node	WrappedGraphDatabase.createNode()
Node	WrappedRelationship.getEndNode()
Node	WrappedGraphDatabase.getNodeById(long id)
Node[]	WrappedRelationship.getNodes()
Node	WrappedRelationship.getOtherNode(Node node)
Node	WrappedGraphDatabase.getReferenceNode()
Node	WrappedRelationship.getStartNode()

Methods in org.neo4j.tooling.wrap that return types with arguments of type Node

Iterable<Node>

WrappedGraphDatabase.getAllNodes()

Methods in org.neo4j.tooling.wrap with parameters of type Node

Relationship	WrappedNode.createRelationshipTo(Node otherNode, RelationshipType type)
IndexHits<Relationship>	WrappedIndex.WrappedRelationshipIndex.get(String key, Object valueOrNull, Node startNodeOrNull, Node endNodeOrNull)
Node	WrappedRelationship.getOtherNode(Node node)
protected abstract WrappedNode<? extends WrappedGraphDatabase>	WrappedGraphDatabase.node(Node node, boolean created)
IndexHits<Relationship>	WrappedIndex.WrappedRelationshipIndex.query(Object queryOrQueryObjectOrNull, Node startNodeOrNull, Node endNodeOrNull)
IndexHits<Relationship>	WrappedIndex.WrappedRelationshipIndex.query(String key, Object queryOrQueryObjectOrNull, Node startNodeOrNull, Node endNodeOrNull)

Method parameters in org.neo4j.tooling.wrap with type arguments of type Node

protected WrappedIndex.WrappedNodeIndex	WrappedGraphDatabase.automaticNodeIndex(ReadableIndex<Node> index)
protected WrappedIndex.WrappedNodeIndex	WrappedGraphDatabase.nodeIndex(Index<Node> index, String indexName)