Node (The GraphStream 1.3 API)

All Superinterfaces:

Element, Iterable<Edge>

All Known Implementing Classes:

AbstractNode, AdjacencyListNode, GraphicNode, MultiNode, SingleNode
```
public interface Node
extends Element, Iterable<Edge>
```
An Interface that advises general purpose methods for handling nodes as elements of a graph.
Important

Implementing classes should indicate the complexity of their implementation for each method.

Since:

July 12 2007

Method Summary

Methods
Modifier and Type	Method and Description
`<T extends Node> Iterator<T>`	`getBreadthFirstIterator()` Iterator for breadth first exploration of the graph, starting at this node.
`<T extends Node> Iterator<T>`	`getBreadthFirstIterator(boolean directed)` Iterator for breadth first exploration of the graph, starting at this node.
`int`	`getDegree()` Total number of relations with other nodes or this node.
`<T extends Node> Iterator<T>`	`getDepthFirstIterator()` Iterator for depth first exploration of the graph, starting at this node.
`<T extends Node> Iterator<T>`	`getDepthFirstIterator(boolean directed)` Iterator for depth first exploration of the graph, starting at this node.
`<T extends Edge> Iterable<T>`	`getEachEdge()` Set of all entering and leaving edges.
`<T extends Edge> Iterable<T>`	`getEachEnteringEdge()` Set of all entering edges.
`<T extends Edge> Iterable<T>`	`getEachLeavingEdge()` Set of all leaving edges.
`<T extends Edge> T`	`getEdge(int i)` I-th edge.
`<T extends Edge> T`	`getEdgeBetween(int index)` Retrieves an edge between this node and the node with index i if one exists.
`<T extends Edge> T`	`getEdgeBetween(Node node)` Retrieves an edge between this node and and another node if one exists.
`<T extends Edge> T`	`getEdgeBetween(String id)` Retrieve an edge between this node and the node 'id', if it exits.
`<T extends Edge> T`	`getEdgeFrom(int index)` Retrieves an edge that leaves node with given index toward this node.
`<T extends Edge> T`	`getEdgeFrom(Node node)` Retrieves an edge that leaves given node toward this node.
`<T extends Edge> T`	`getEdgeFrom(String id)` Retrieve an edge that leaves node 'id' toward this node.
`<T extends Edge> Iterator<T>`	`getEdgeIterator()` Iterator on the set of connected edges.
`<T extends Edge> Collection<T>`	`getEdgeSet()` Set of all entering and leaving edges.
`<T extends Edge> T`	`getEdgeToward(int index)` Retrieves an edge that leaves this node toward the node with given index.
`<T extends Edge> T`	`getEdgeToward(Node node)` Retrieves an edge that leaves this node toward another node.
`<T extends Edge> T`	`getEdgeToward(String id)` Retrieve an edge that leaves this node toward 'id'.
`<T extends Edge> T`	`getEnteringEdge(int i)` I-th entering edge.
`<T extends Edge> Iterator<T>`	`getEnteringEdgeIterator()` Iterator only on leaving edges.
`<T extends Edge> Collection<T>`	`getEnteringEdgeSet()` Set of all entering edges.
`Graph`	`getGraph()` Parent graph.
`int`	`getInDegree()` Number of entering edges.
`<T extends Edge> T`	`getLeavingEdge(int i)` I-th leaving edge.
`<T extends Edge> Iterator<T>`	`getLeavingEdgeIterator()` Iterator only on entering edges.
`<T extends Edge> Collection<T>`	`getLeavingEdgeSet()` Set of all leaving edges.
`<T extends Node> Iterator<T>`	`getNeighborNodeIterator()` Iterator on the set of neighbor nodes connected to this node via one or more edges.
`int`	`getOutDegree()` Number of leaving edges.
`boolean`	`hasEdgeBetween(int index)` True if an edge exists between this node and a node with given index.
`boolean`	`hasEdgeBetween(Node node)` True if an edge exists between this node and another node.
`boolean`	`hasEdgeBetween(String id)` True if an edge exists between this node and node 'id'.
`boolean`	`hasEdgeFrom(int index)` True if an edge enters this node from a node with given index.
`boolean`	`hasEdgeFrom(Node node)` True if an edge enters this node from a given node.
`boolean`	`hasEdgeFrom(String id)` True if an edge enters this node from node 'id'.
`boolean`	`hasEdgeToward(int index)` True if an edge leaves this node toward a node with given index.
`boolean`	`hasEdgeToward(Node node)` True if an edge leaves this node toward a given node.
`boolean`	`hasEdgeToward(String id)` True if an edge leaves this node toward node 'id'.
`String`	`toString()` Override the Object.toString() method.

Methods inherited from interface org.graphstream.graph.Element
addAttribute, addAttributes, changeAttribute, clearAttributes, getArray, getAttribute, getAttribute, getAttributeCount, getAttributeKeyIterator, getAttributeKeySet, getEachAttributeKey, getFirstAttributeOf, getFirstAttributeOf, getHash, getId, getIndex, getLabel, getNumber, getVector, hasArray, hasAttribute, hasAttribute, hasHash, hasLabel, hasNumber, hasVector, removeAttribute, setAttribute

Methods inherited from interface java.lang.Iterable
iterator

- Method Detail
  - getGraph
```
Graph getGraph()
```
    Parent graph. Some elements are not able to give their parent graph.
    
    Returns:
    The graph containing this node or null if unknown.
  - getDegree
```
int getDegree()
```
    Total number of relations with other nodes or this node.
    
    Returns:
    The number of edges/relations/links.
  - getOutDegree
```
int getOutDegree()
```
    Number of leaving edges.
    
    Returns:
    the count of edges that only leave this node plus all undirected edges.
  - getInDegree
```
int getInDegree()
```
    Number of entering edges.
    
    Returns:
    the count of edges that only enter this node plus all undirected edges.
  - hasEdgeToward
```
boolean hasEdgeToward(String id)
```
    True if an edge leaves this node toward node 'id'.
    
    Parameters:
    id - Identifier of the target node.
    
    Returns:
    True if a directed edge goes from this node to 'id' or if an undirected edge exists.
  - hasEdgeFrom
```
boolean hasEdgeFrom(String id)
```
    True if an edge enters this node from node 'id'.
    
    Parameters:
    id - Identifier of the source node.
    
    Returns:
    True if a directed edge goes from this node to 'id' or if an undirected edge exists.
  - hasEdgeBetween
```
boolean hasEdgeBetween(String id)
```
    True if an edge exists between this node and node 'id'.
    
    Parameters:
    id - Identifier of another node.
    
    Returns:
    True if a edge exists between this node and node 'id'.
  - getEdgeToward
```
<T extends Edge> T getEdgeToward(String id)
```
    Retrieve an edge that leaves this node toward 'id'.
    This method selects only edges leaving this node an pointing at node 'id' (this also selects undirected edges).
    
    This method is implicitly generic and return something which extends Edge. The return type is the one of the left part of the assignment. For example, in the following call :
```
 ExtendedEdge e = node.getEdgeToward("...");
 
```
    the method will return an ExtendedEdge. If no left part exists, method will just return an Edge.
    Parameters:
    id - Identifier of the target node.
    
    Returns:
    Directed edge going from this node to 'id', or undirected edge if it exists, else null.
  - getEdgeFrom
```
<T extends Edge> T getEdgeFrom(String id)
```
    Retrieve an edge that leaves node 'id' toward this node.
    This method selects only edges leaving node 'id' an pointing at this node (this also selects undirected edges).
    
    This method is implicitly generic and return something which extends Edge. The return type is the one of the left part of the assignment. For example, in the following call :
```
 ExtendedEdge e = node.getEdgeFrom("...");
 
```
    the method will return an ExtendedEdge. If no left part exists, method will just return an Edge.
    Parameters:
    id - Identifier of the source node.
    
    Returns:
    Directed edge going from node 'id' to this node, or undirected edge if it exists, else null.
  - getEdgeBetween
```
<T extends Edge> T getEdgeBetween(String id)
```
    Retrieve an edge between this node and the node 'id', if it exits.
    This method selects directed or undirected edges. If the edge is directed, its direction is not important and leaving or entering edges will be selected.
    
    This method is implicitly generic and return something which extends Edge. The return type is the one of the left part of the assignment. For example, in the following call :
```
 ExtendedEdge e = node.getEdgeBetween("...");
 
```
    the method will return an ExtendedEdge. If no left part exists, method will just return an Edge.
    Parameters:
    id - Identifier of the opposite node.
    
    Returns:
    Edge between node 'id' and this node if it exists, else null.
  - getEdgeIterator
```
<T extends Edge> Iterator<T> getEdgeIterator()
```
    Iterator on the set of connected edges.
    This iterator iterates on all edges leaving and entering (this includes any non-directed edge present, and a non-directed edge is only iterated once).
    
    This method is implicitly generic and return an Iterator over something which extends Edge. The return type is the one of the left part of the assignment. For example, in the following call :
```
 Iterator<ExtendedEdge> ite = node.getEdgeIterator();
 
```
    the method will return an Iterator<ExtendedEdge>. If no left part exists, method will just return an Iterator<Edge>.
    Returns:
    The iterator, edges are iterated in arbitrary order.
  - getEnteringEdgeIterator
```
<T extends Edge> Iterator<T> getEnteringEdgeIterator()
```
    Iterator only on leaving edges.
    This iterator iterates only on directed edges going from this node to others (non-directed edges are included in the iteration).
    
    This method is implicitly generic and return an Iterator over something which extends Edge. The return type is the one of the left part of the assignment. For example, in the following call :
```
 Iterator<ExtendedEdge> ite = node.getEnteringEdgeIterator();
 
```
    the method will return an Iterator<ExtendedEdge>. If no left part exists, method will just return an Iterator<Edge>.
    Returns:
    The iterator, edges are iterated in arbitrary order.
  - getLeavingEdgeIterator
```
<T extends Edge> Iterator<T> getLeavingEdgeIterator()
```
    Iterator only on entering edges.
    This iterator iterates only on directed edges going from other nodes toward this node (non-directed edges are included in the iteration).
    
    This method is implicitly generic and return an Iterator over something which extends Edge. The return type is the one of the left part of the assignment. For example, in the following call :
```
 Iterator<ExtendedEdge> ite = node.getLeavingEdgeIterator();
 
```
    the method will return an Iterator<ExtendedEdge>. If no left part exists, method will just return an Iterator<Edge>.
    Returns:
    The iterator, edges are iterated in arbitrary order.
  - getNeighborNodeIterator
```
<T extends Node> Iterator<T> getNeighborNodeIterator()
```
    Iterator on the set of neighbor nodes connected to this node via one or more edges. This iterator iterates across any leaving, entering and non directed edges (nodes are neighbors even if they only have a directed edge from them toward this node). If there are multiple edges connecting the same node, it might be iterated several times.
    
    Returns:
    The iterator, neighbors are iterated in arbitrary order.
  - getEdge
```
<T extends Edge> T getEdge(int i)
```
    I-th edge. Edges are stored in no given order.
    However this method allows to iterate very quickly on all edges, or to choose a given edge with direct access.
    
    This method is implicitly generic and return something which extends Edge. The return type is the one of the left part of the assignment. For example, in the following call :
```
 ExtendedEdge e = node.getEdge(i);
 
```
    the method will return an ExtendedEdge. If no left part exists, method will just return an Edge.
    Parameters:
    i - Index of the edge.
    
    Returns:
    The i-th edge.
    
    Throws:
    
    IndexOutOfBoundException - if i is negative or greater than or equal to the degree
  - getEnteringEdge
```
<T extends Edge> T getEnteringEdge(int i)
```
    I-th entering edge. Edges are stored in no given order.
    However this method allows to iterate very quickly on all entering edges, or to choose a given entering edge with direct access.
    
    This method is implicitly generic and return something which extends Edge. The return type is the one of the left part of the assignment. For example, in the following call :
```
 ExtendedEdge e = node.getEnteringEdge(i);
 
```
    the method will return an ExtendedEdge. If no left part exists, method will just return an Edge.
    Parameters:
    i - Index of the edge.
    
    Returns:
    The i-th entering edge.
    
    Throws:
    
    IndexOutOfBoundException - if i is negative or greater than or equal to the in-degree
  - getLeavingEdge
```
<T extends Edge> T getLeavingEdge(int i)
```
    I-th leaving edge. Edges are stored in no given order.
    However this method allows to iterate very quickly on all leaving edges, or to choose a given leaving edge with direct access.
    
    This method is implicitly generic and return something which extends Edge. The return type is the one of the left part of the assignment. For example, in the following call :
```
 ExtendedEdge e = node.getLeavingEdge(i);
 
```
    the method will return an ExtendedEdge. If no left part exists, method will just return an Edge.
    Parameters:
    i - Index of the edge.
    
    Returns:
    The i-th leaving edge.
    
    Throws:
    
    IndexOutOfBoundException - if i is negative or greater than or equal to the out-degree
  - getBreadthFirstIterator
```
<T extends Node> Iterator<T> getBreadthFirstIterator()
```
    Iterator for breadth first exploration of the graph, starting at this node.
    If the graph is not connected, only a part of it will be explored. By default, this iterator will respect edge orientation.
    
    This method is implicitly generic and return an Iterator over something which extends Node. The return type is the one of the left part of the assignment. For example, in the following call :
```
 Iterator<ExtendedNode> ite = node.getBreadthFirstIterator();
 
```
    the method will return an Iterator<ExtendedNode>. If no left part exists, method will just return an Iterator<Node>.
    Returns:
    An iterator able to explore the graph in a breadth first way starting at this node.
  - getBreadthFirstIterator
```
<T extends Node> Iterator<T> getBreadthFirstIterator(boolean directed)
```
    Iterator for breadth first exploration of the graph, starting at this node.
    If the graph is not connected, only a part of it will be explored.
    
    This method is implicitly generic and return an Iterator over something which extends Node. The return type is the one of the left part of the assignment. For example, in the following call :
```
 Iterator<ExtendedNode> ite = node.getBreadthFirstIterator(true);
 
```
    the method will return an Iterator<ExtendedNode>. If no left part exists, method will just return an Iterator<Node>.
    Parameters:
    directed - If false, the iterator will ignore edge orientation (the default is "True").
    
    Returns:
    An iterator able to explore the graph in a breadth first way starting at this node.
  - getDepthFirstIterator
```
<T extends Node> Iterator<T> getDepthFirstIterator()
```
    Iterator for depth first exploration of the graph, starting at this node.
    If the graph is not connected, only a part of it will be explored. By default, this iterator will respect edge orientation.
    
    This method is implicitly generic and return an Iterator over something which extends Node. The return type is the one of the left part of the assignment. For example, in the following call :
```
 Iterator<ExtendedNode> ite = node.getDepthFirstIterator();
 
```
    the method will return an Iterator<ExtendedNode>. If no left part exists, method will just return an Iterator<Node>.
    Returns:
    An iterator able to explore the graph in a depth first way starting at this node.
    Computational Complexity :
    
    of the depth first iterator O(n+m) with n the number of nodes and m the number of edges.
  - getDepthFirstIterator
```
<T extends Node> Iterator<T> getDepthFirstIterator(boolean directed)
```
    Iterator for depth first exploration of the graph, starting at this node.
    If the graph is not connected, only a part of it will be explored.
    
    This method is implicitly generic and return an Iterator over something which extends Node. The return type is the one of the left part of the assignment. For example, in the following call :
```
 Iterator<ExtendedNode> ite = node.getDepthFirstIterator(true);
 
```
    the method will return an Iterator<ExtendedNode>. If no left part exists, method will just return an Iterator<Node>.
    Parameters:
    directed - If false, the iterator will ignore edge orientation (the default is "True").
    
    Returns:
    An iterator able to explore the graph in a depth first way starting at this node.
  - getEachEdge
```
<T extends Edge> Iterable<T> getEachEdge()
```
    Set of all entering and leaving edges.
    This method is implicitly generic and return an Iterable over something which extends Edge. The return type is the one of the left part of the assignment. For example, in the following call :
```
 Iterable<ExtendedEdge> ite = node.getEdgeSet();
 
```
    the method will return an Iterable<ExtendedEdge>. If no left part exists, method will just return an Iterable<Edge>.
    Returns:
    A collection containing all directed and undirected edges, leaving or entering.
  - getEachLeavingEdge
```
<T extends Edge> Iterable<T> getEachLeavingEdge()
```
    Set of all leaving edges.
    This method is implicitly generic and return an Iterable over something which extends Edge. The return type is the one of the left part of the assignment. For example, in the following call :
```
 Iterable<ExtendedEdge> ite = node.getLeavingEdgeSet();
 
```
    the method will return an Iterable<ExtendedEdge>. If no left part exists, method will just return an Iterable<Edge>.
    Returns:
    A collection of only edges that leave this node plus all undirected edges.
  - getEachEnteringEdge
```
<T extends Edge> Iterable<T> getEachEnteringEdge()
```
    Set of all entering edges.
    This method is implicitly generic and return an Iterable over something which extends Edge. The return type is the one of the left part of the assignment. For example, in the following call :
```
 Iterable<ExtendedEdge> ite = node.getEnteringEdgeSet();
 
```
    the method will return an Iterable<ExtendedEdge>. If no left part exists, method will just return an Iterable<Edge>.
    Returns:
    A collection of only edges that enter this node plus all undirected edges.
  - getEdgeSet
```
<T extends Edge> Collection<T> getEdgeSet()
```
    Set of all entering and leaving edges.
    This method is implicitly generic and return an Iterable over something which extends Edge. The return type is the one of the left part of the assignment. For example, in the following call :
```
 Iterable<ExtendedEdge> ite = node.getEdgeSet();
 
```
    the method will return an Iterable<ExtendedEdge>. If no left part exists, method will just return an Iterable<Edge>.
    Returns:
    A collection containing all directed and undirected edges, leaving or entering.
  - getLeavingEdgeSet
```
<T extends Edge> Collection<T> getLeavingEdgeSet()
```
    Set of all leaving edges.
    This method is implicitly generic and return an Iterable over something which extends Edge. The return type is the one of the left part of the assignment. For example, in the following call :
```
 Iterable<ExtendedEdge> ite = node.getLeavingEdgeSet();
 
```
    the method will return an Iterable<ExtendedEdge>. If no left part exists, method will just return an Iterable<Edge>.
    Returns:
    A collection of only edges that leave this node plus all undirected edges.
  - getEnteringEdgeSet
```
<T extends Edge> Collection<T> getEnteringEdgeSet()
```
    Set of all entering edges.
    This method is implicitly generic and return an Iterable over something which extends Edge. The return type is the one of the left part of the assignment. For example, in the following call :
```
 Iterable<ExtendedEdge> ite = node.getEnteringEdgeSet();
 
```
    the method will return an Iterable<ExtendedEdge>. If no left part exists, method will just return an Iterable<Edge>.
    Returns:
    A collection of only edges that enter this node plus all undirected edges.
  - toString
```
String toString()
```
    Override the Object.toString() method.
    
    Overrides:
    
    toString in class Object
  - hasEdgeToward
```
boolean hasEdgeToward(Node node)
```
    True if an edge leaves this node toward a given node.
    
    Parameters:
    node - The target node.
    
    Returns:
    True if a directed edge goes from this node to the other node or if an undirected edge exists.
  - hasEdgeToward
```
boolean hasEdgeToward(int index)
                      throws IndexOutOfBoundsException
```
    True if an edge leaves this node toward a node with given index.
    
    Parameters:
    index - Index of the target node.
    
    Returns:
    True if a directed edge goes from this node to the other node or if an undirected edge exists.
    
    Throws:
    
    IndexOutOfBoundsException - if the index is negative or greater than getNodeCount() - 1.
  - hasEdgeFrom
```
boolean hasEdgeFrom(Node node)
```
    True if an edge enters this node from a given node.
    
    Parameters:
    node - The source node.
    
    Returns:
    True if a directed edge goes from the other node to this node or if an undirected edge exists.
  - hasEdgeFrom
```
boolean hasEdgeFrom(int index)
                    throws IndexOutOfBoundsException
```
    True if an edge enters this node from a node with given index.
    
    Parameters:
    index - Index of the source node.
    
    Returns:
    True if a directed edge goes from the other node to this node or if an undirected edge exists.
    
    Throws:
    
    IndexOutOfBoundsException - if the index is negative or greater than getNodeCount() - 1.
  - hasEdgeBetween
```
boolean hasEdgeBetween(Node node)
```
    True if an edge exists between this node and another node.
    
    Parameters:
    node - Another node.
    
    Returns:
    True if an edge exists between this node and the other node.
  - hasEdgeBetween
```
boolean hasEdgeBetween(int index)
                       throws IndexOutOfBoundsException
```
    True if an edge exists between this node and a node with given index.
    
    Parameters:
    index - Index of another node.
    
    Returns:
    True if an edge exists between this node and the other node.
    
    Throws:
    
    IndexOutOfBoundsException - if the index is negative or greater than getNodeCount() - 1.
  - getEdgeToward
```
<T extends Edge> T getEdgeToward(Node node)
```
    Retrieves an edge that leaves this node toward another node.
    This method selects only edges leaving this node an pointing at the parameter node (this also selects undirected edges).
    
    This method is implicitly generic and returns something which extends Edge. The return type is the one of the left part of the assignment. For example, in the following call :
```
 ExtendedEdge e = node.getEdgeToward(...);
 
```
    the method will return an ExtendedEdge. If no left part exists, method will just return an Edge.
    Parameters:
    node - The target node.
    
    Returns:
    Directed edge going from this node to the parameter node, or undirected edge if it exists, else null.
  - getEdgeToward
```
<T extends Edge> T getEdgeToward(int index)
                             throws IndexOutOfBoundsException
```
    Retrieves an edge that leaves this node toward the node with given index.
    This method selects only edges leaving this node an pointing at the parameter node (this also selects undirected edges).
    
    This method is implicitly generic and returns something which extends Edge. The return type is the one of the left part of the assignment. For example, in the following call :
```
 ExtendedEdge e = node.getEdgeToward(...);
 
```
    the method will return an ExtendedEdge. If no left part exists, method will just return an Edge.
    Parameters:
    index - Index of the target node.
    
    Returns:
    Directed edge going from this node to the parameter node, or undirected edge if it exists, else null.
    
    Throws:
    
    IndexOutOfBoundsException - if the index is negative or greater than getNodeCount() - 1.
  - getEdgeFrom
```
<T extends Edge> T getEdgeFrom(Node node)
```
    Retrieves an edge that leaves given node toward this node.
    This method selects only edges leaving the other node an pointing at this node (this also selects undirected edges).
    
    This method is implicitly generic and returns something which extends Edge. The return type is the one of the left part of the assignment. For example, in the following call :
```
 ExtendedEdge e = node.getEdgeFrom(...);
 
```
    the method will return an ExtendedEdge. If no left part exists, method will just return an Edge.
    Parameters:
    node - The source node.
    
    Returns:
    Directed edge going from the parameter node to this node, or undirected edge if it exists, else null.
  - getEdgeFrom
```
<T extends Edge> T getEdgeFrom(int index)
                           throws IndexOutOfBoundsException
```
    Retrieves an edge that leaves node with given index toward this node.
    This method selects only edges leaving the other node an pointing at this node (this also selects undirected edges).
    
    This method is implicitly generic and returns something which extends Edge. The return type is the one of the left part of the assignment. For example, in the following call :
```
 ExtendedEdge e = node.getEdgeFrom("...");
 
```
    the method will return an ExtendedEdge. If no left part exists, method will just return an Edge.
    Parameters:
    index - Index of the source node.
    
    Returns:
    Directed edge going from the parameter node to this node, or undirected edge if it exists, else null.
    
    Throws:
    
    IndexOutOfBoundsException - if the index is negative or greater than getNodeCount() - 1.
  - getEdgeBetween
```
<T extends Edge> T getEdgeBetween(Node node)
```
    Retrieves an edge between this node and and another node if one exists.
    This method selects directed or undirected edges. If the edge is directed, its direction is not important and leaving or entering edges will be selected.
    
    This method is implicitly generic and return something which extends Edge. The return type is the one of the left part of the assignment. For example, in the following call :
```
 ExtendedEdge e = node.getEdgeBetween(...);
 
```
    the method will return an ExtendedEdge. If no left part exists, method will just return an Edge.
    Parameters:
    node - The opposite node.
    
    Returns:
    Edge between this node and the parameter node if it exists, else null.
  - getEdgeBetween
```
<T extends Edge> T getEdgeBetween(int index)
                              throws IndexOutOfBoundsException
```
    Retrieves an edge between this node and the node with index i if one exists.
    This method selects directed or undirected edges. If the edge is directed, its direction is not important and leaving or entering edges will be selected.
    
    This method is implicitly generic and return something which extends Edge. The return type is the one of the left part of the assignment. For example, in the following call :
```
 ExtendedEdge e = node.getEdgeBetween(...);
 
```
    the method will return an ExtendedEdge. If no left part exists, method will just return an Edge.
    Parameters:
    index - The index of the opposite node.
    
    Returns:
    Edge between node with index i and this node if it exists, else null.
    
    Throws:
    
    IndexOutOfBoundsException - if the index is negative or greater than getNodeCount() - 1.

Interface Node

Important

Method Summary

Methods inherited from interface org.graphstream.graph.Element

Methods inherited from interface java.lang.Iterable

Method Detail

getGraph

getDegree

getOutDegree

getInDegree

hasEdgeToward

hasEdgeFrom

hasEdgeBetween

getEdgeToward

getEdgeFrom

getEdgeBetween

getEdgeIterator

getEnteringEdgeIterator

getLeavingEdgeIterator

getNeighborNodeIterator

getEdge

getEnteringEdge

getLeavingEdge

getBreadthFirstIterator

getBreadthFirstIterator

getDepthFirstIterator

getDepthFirstIterator

getEachEdge

getEachLeavingEdge

getEachEnteringEdge

getEdgeSet

getLeavingEdgeSet

getEnteringEdgeSet

toString

hasEdgeToward

hasEdgeToward

hasEdgeFrom

hasEdgeFrom

hasEdgeBetween

hasEdgeBetween

getEdgeToward

getEdgeToward

getEdgeFrom

getEdgeFrom

getEdgeBetween

getEdgeBetween