AbstractGraph (The GraphStream 1.3 API)

java.lang.Object
- org.graphstream.graph.implementations.AbstractElement
- - org.graphstream.graph.implementations.AbstractGraph

All Implemented Interfaces:

Iterable<Node>, Element, Graph, Structure, AttributeSink, ElementSink, Pipe, Replayable, Sink, Source

Direct Known Subclasses:

AdjacencyListGraph
```
public abstract class AbstractGraph
extends AbstractElement
implements Graph, Replayable
```
This class provides a basic implementation of Graph interface, to minimize the effort required to implement this interface. It provides event management implementing all the methods of Pipe. It also manages strict checking and auto-creation policies, as well as other services as displaying, reading and writing.

Subclasses have to maintain data structures allowing to efficiently access graph elements by their id or index and iterating on them. They also have to maintain coherent indices of the graph elements. When AbstractGraph decides to add or remove elements, it calls one of the "callbacks" addNodeCallback(AbstractNode), addEdgeCallback(AbstractEdge), removeNodeCallback(AbstractNode), removeEdgeCallback(AbstractEdge), clearCallback(). The role of these callbacks is to update the data structures and to re-index elements if necessary.

Nested Class Summary
- Nested classes/interfaces inherited from class org.graphstream.graph.implementations.AbstractElement
  AbstractElement.AttributeChangeEvent
- Nested classes/interfaces inherited from interface org.graphstream.stream.Replayable
  Replayable.Controller

Constructor Summary

Constructors
Constructor and Description
`AbstractGraph(String id)` The same as `AbstractGraph(id, true, false)`
`AbstractGraph(String id, boolean strictChecking, boolean autoCreate)` Creates a new graph.

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`addAttributeSink(AttributeSink sink)` Add a sink for attribute events only.
`<T extends Edge> T`	`addEdge(String id, int index1, int index2)` Like `Graph.addEdge(String, String, String)` but the nodes are identified by their indices.
`<T extends Edge> T`	`addEdge(String id, int fromIndex, int toIndex, boolean directed)` Like `Graph.addEdge(String, String, String, boolean)` but the nodes are identified by their indices.
`<T extends Edge> T`	`addEdge(String id, Node node1, Node node2)` Like `Graph.addEdge(String, String, String)` but the node references are given instead of node identifiers.
`<T extends Edge> T`	`addEdge(String id, Node from, Node to, boolean directed)` Like `Graph.addEdge(String, String, String, boolean)` but the node references are given instead of node identifiers.
`<T extends Edge> T`	`addEdge(String id, String node1, String node2)` Adds an undirected edge between nodes.
`<T extends Edge> T`	`addEdge(String id, String from, String to, boolean directed)` Like `Graph.addEdge(String, String, String)`, but this edge can be directed between the two given nodes.
`void`	`addElementSink(ElementSink sink)` Add a sink for elements events only.
`<T extends Node> T`	`addNode(String id)` Add a node in the graph.
`void`	`addSink(Sink sink)` Add a sink for all graph events (attributes and graph elements) coming from this source.
`Iterable<AttributeSink>`	`attributeSinks()` Returns an "iterable" of `AttributeSink` objects registered to this graph.
`void`	`clear()` Empty the graph completely by removing any references to nodes or edges.
`void`	`clearAttributeSinks()` Remove all listener attribute sinks.
`void`	`clearElementSinks()` Remove all listener element sinks.
`void`	`clearSinks()` Remove all listener sinks.
`Viewer`	`display()` Utility method that creates a new graph viewer, and register the graph in it.
`Viewer`	`display(boolean autoLayout)` Utility method that creates a new graph viewer, and register the graph in it.
`void`	`edgeAdded(String sourceId, long timeId, String edgeId, String fromNodeId, String toNodeId, boolean directed)` An edge was inserted in graph.
`void`	`edgeAttributeAdded(String sourceId, long timeId, String edgeId, String attribute, Object value)` A edge attribute was added.
`void`	`edgeAttributeChanged(String sourceId, long timeId, String edgeId, String attribute, Object oldValue, Object newValue)` A edge attribute was changed.
`void`	`edgeAttributeRemoved(String sourceId, long timeId, String edgeId, String attribute)` A edge attribute was removed.
`EdgeFactory<? extends Edge>`	`edgeFactory()` The factory used to create edge instances.
`void`	`edgeRemoved(String sourceId, long timeId, String edgeId)` An edge of graph was removed.The nodes the edge connects may already have been removed from the graph.
`Iterable<ElementSink>`	`elementSinks()` Returns an "iterable" of `ElementSink` objects registered to this graph.
`<T extends Edge> Iterable<? extends T>`	`getEachEdge()` This implementation uses `getEdgeIterator()`
`<T extends Node> Iterable<? extends T>`	`getEachNode()` This implementation uses `getNodeIterator()`
`abstract <T extends Edge> T`	`getEdge(int index)` Get an edge by its index.
`abstract <T extends Edge> T`	`getEdge(String id)` Get an edge by its identifier.
`abstract int`	`getEdgeCount()` Number of edges in this graph.
`abstract <T extends Edge> Iterator<T>`	`getEdgeIterator()` Iterator on the set of edges, in an undefined order.
`<T extends Edge> Collection<T>`	`getEdgeSet()` This implementation uses `getEdgeIterator()` and `getEdgeCount()`
`abstract <T extends Node> T`	`getNode(int index)` Get a node by its index.
`abstract <T extends Node> T`	`getNode(String id)` Get a node by its identifier.
`abstract int`	`getNodeCount()` Number of nodes in this graph.
`abstract <T extends Node> Iterator<T>`	`getNodeIterator()` Iterator on the set of nodes, in an undefined order.
`<T extends Node> Collection<T>`	`getNodeSet()` This implementation uses `getNodeIterator()` and `getNodeCount()`
`Replayable.Controller`	`getReplayController()` Get a controller to replay the graph.
`double`	`getStep()` The current step.
`void`	`graphAttributeAdded(String sourceId, long timeId, String attribute, Object value)` A graph attribute was added.
`void`	`graphAttributeChanged(String sourceId, long timeId, String attribute, Object oldValue, Object newValue)` A graph attribute was changed.
`void`	`graphAttributeRemoved(String sourceId, long timeId, String attribute)` A graph attribute was removed.
`void`	`graphCleared(String sourceId, long timeId)` The whole graph was cleared.
`boolean`	`isAutoCreationEnabled()` Is the automatic creation of missing elements enabled?.
`boolean`	`isStrict()` Is strict checking enabled?
`Iterator<Node>`	`iterator()` This implementation returns `getNodeIterator()`
`void`	`nodeAdded(String sourceId, long timeId, String nodeId)` A node was inserted in the given graph.
`void`	`nodeAttributeAdded(String sourceId, long timeId, String nodeId, String attribute, Object value)` A node attribute was added.
`void`	`nodeAttributeChanged(String sourceId, long timeId, String nodeId, String attribute, Object oldValue, Object newValue)` A node attribute was changed.
`void`	`nodeAttributeRemoved(String sourceId, long timeId, String nodeId, String attribute)` A node attribute was removed.
`NodeFactory<? extends Node>`	`nodeFactory()` The factory used to create node instances.
`void`	`nodeRemoved(String sourceId, long timeId, String nodeId)` A node was removed from the graph.
`boolean`	`nullAttributesAreErrors()` If true, when accessing an attribute that does not exist (or is not of the expected type), a `NullAttributeException` is thrown.
`void`	`read(FileSource input, String filename)` Utility method to read a graph using the given reader.
`void`	`read(String filename)` Utility method to read a graph.
`void`	`removeAttributeSink(AttributeSink sink)` Remove an attribute sink.
`<T extends Edge> T`	`removeEdge(Edge edge)` Removes an edge.
`<T extends Edge> T`	`removeEdge(int index)` Removes an edge with a given index.
`<T extends Edge> T`	`removeEdge(int fromIndex, int toIndex)` Removes an edge between two nodes.
`<T extends Edge> T`	`removeEdge(Node node1, Node node2)` Removes an edge between two nodes.
`<T extends Edge> T`	`removeEdge(String id)` Removes an edge knowing its identifier.
`<T extends Edge> T`	`removeEdge(String from, String to)` Remove an edge given the identifiers of its two endpoints.
`void`	`removeElementSink(ElementSink sink)` Remove an element sink.
`<T extends Node> T`	`removeNode(int index)` Removes a node with a given index.
`<T extends Node> T`	`removeNode(Node node)` Removes a node.
`<T extends Node> T`	`removeNode(String id)` Remove a node using its identifier.
`void`	`removeSink(Sink sink)` Remove a sink.
`void`	`setAutoCreate(boolean on)` Enable or disable the automatic creation of missing elements.
`void`	`setEdgeFactory(EdgeFactory<? extends Edge> ef)` Set the edge factory used to create edges.
`void`	`setNodeFactory(NodeFactory<? extends Node> nf)` Set the node factory used to create nodes.
`void`	`setNullAttributesAreErrors(boolean on)` Should a `NullAttributeException` be thrown when one tries to access a non existing attribute, or an attribute whose type is not the expected one?.
`void`	`setStrict(boolean on)` Enable or disable strict checking.
`void`	`stepBegins(double time)` Since dynamic graphs are based on discrete event modifications, the notion of step is defined to simulate elapsed time between events.
`void`	`stepBegins(String sourceId, long timeId, double step)` Since dynamic graphs are based on discrete event modifications, the notion of step is defined to simulate elapsed time between events.
`void`	`write(FileSink output, String filename)` Utility method to write a graph in the chosen format to a file.
`void`	`write(String filename)` Utility method to write a graph in DGS format to a file.

Methods inherited from class org.graphstream.graph.implementations.AbstractElement
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, toString

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, wait, wait, wait

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

- Constructor Detail
  - AbstractGraph
```
public AbstractGraph(String id)
```
    The same as AbstractGraph(id, true, false)
    
    Parameters:
    id - Identifier of the graph
    See Also:
    AbstractGraph(String, boolean, boolean)
  - AbstractGraph
```
public AbstractGraph(String id,
             boolean strictChecking,
             boolean autoCreate)
```
    Creates a new graph. Subclasses must create their node and edge factories and initialize their data structures in their constructors.
    
    Parameters:
    id -
    strictChecking -
    autoCreate -
- Method Detail
  - nullAttributesAreErrors
```
public boolean nullAttributesAreErrors()
```
    Description copied from interface: Graph
    
    If true, when accessing an attribute that does not exist (or is not of the expected type), a NullAttributeException is thrown. Else null is returned.
    
    Specified by:
    
    nullAttributesAreErrors in interface Graph
    
    Returns:
    True if exceptions must be thrown when accessing a null attribute.
  - getNode
```
public abstract <T extends Node> T getNode(String id)
```
    Description copied from interface: Graph
    Get a node by its identifier. This method is implicitly generic and returns something which extends Node. The return type is the one of the left part of the assignment. For example, in the following call :
```
 ExtendedNode node = graph.getNode("...");
 
```
    the method will return an ExtendedNode node. If no left part exists, method will just return a Node.
    Specified by:
    
    getNode in interface Graph
    
    Parameters:
    id - Identifier of the node to find.
    
    Returns:
    The searched node or null if not found.
  - getNode
```
public abstract <T extends Node> T getNode(int index)
```
    Description copied from interface: Graph
    Get a node by its index. This method is implicitly generic and returns something which extends Node. The return type is the one of the left part of the assignment. For example, in the following call :
```
 ExtendedNode node = graph.getNode(index);
 
```
    the method will return an ExtendedNode node. If no left part exists, method will just return a Node.
    Specified by:
    
    getNode in interface Graph
    
    Parameters:
    index - Index of the node to find.
    
    Returns:
    The node with the given index
  - getEdge
```
public abstract <T extends Edge> T getEdge(String id)
```
    Description copied from interface: Graph
    Get an edge by its identifier. 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 edge = graph.getEdge("...");
 
```
    the method will return an ExtendedEdge edge. If no left part exists, method will just return an Edge.
    Specified by:
    
    getEdge in interface Graph
    
    Parameters:
    id - Identifier of the edge to find.
    
    Returns:
    The searched edge or null if not found.
  - getEdge
```
public abstract <T extends Edge> T getEdge(int index)
```
    Description copied from interface: Graph
    Get an edge by its index. 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 edge = graph.getEdge(index);
 
```
    the method will return an ExtendedEdge edge. If no left part exists, method will just return an Edge.
    Specified by:
    
    getEdge in interface Graph
    
    Parameters:
    index - The index of the edge to find.
    
    Returns:
    The edge with the given index
  - getNodeCount
```
public abstract int getNodeCount()
```
    Description copied from interface: Structure
    
    Number of nodes in this graph.
    
    Specified by:
    
    getNodeCount in interface Structure
    
    Returns:
    The number of nodes.
  - getEdgeCount
```
public abstract int getEdgeCount()
```
    Description copied from interface: Structure
    
    Number of edges in this graph.
    
    Specified by:
    
    getEdgeCount in interface Structure
    
    Returns:
    The number of edges.
  - getNodeIterator
```
public abstract <T extends Node> Iterator<T> getNodeIterator()
```
    Description copied from interface: Structure
    Iterator on the set of nodes, in an undefined order. This method is implicitly generic and returns 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 = graph.getNodeIterator();
 
```
    the method will return an Iterator<ExtendedNode>. If no left part exists, method will just return an Iterator<Node>.
    Specified by:
    
    getNodeIterator in interface Structure
    
    Returns:
    The iterator.
  - getEdgeIterator
```
public abstract <T extends Edge> Iterator<T> getEdgeIterator()
```
    Description copied from interface: Structure
    Iterator on the set of edges, in an undefined order. This method is implicitly generic and returns 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 = graph.getEdgeIterator();
 
```
    the method will return an Iterator<ExtendedEdge>. If no left part exists, method will just return an Iterator<Edge>.
    Specified by:
    
    getEdgeIterator in interface Structure
    
    Returns:
    The iterator.
  - getEachNode
```
public <T extends Node> Iterable<? extends T> getEachNode()
```
    This implementation uses getNodeIterator()
    
    Specified by:
    
    getEachNode in interface Structure
    
    Returns:
    An "iterable" view of the set of nodes.
    See Also:
    Structure.getEachNode()
  - getEachEdge
```
public <T extends Edge> Iterable<? extends T> getEachEdge()
```
    This implementation uses getEdgeIterator()
    
    Specified by:
    
    getEachEdge in interface Structure
    
    Returns:
    An "iterable" view of the set of edges.
    See Also:
    Structure.getEachEdge()
  - getNodeSet
```
public <T extends Node> Collection<T> getNodeSet()
```
    This implementation uses getNodeIterator() and getNodeCount()
    
    Specified by:
    
    getNodeSet in interface Structure
    
    Returns:
    A set of nodes that can only be read, not changed.
    See Also:
    Structure.getNodeSet()
  - getEdgeSet
```
public <T extends Edge> Collection<T> getEdgeSet()
```
    This implementation uses getEdgeIterator() and getEdgeCount()
    
    Specified by:
    
    getEdgeSet in interface Structure
    
    Returns:
    A set of edges that can only be read, not changed.
    See Also:
    Structure.getNodeSet()
  - iterator
```
public Iterator<Node> iterator()
```
    This implementation returns getNodeIterator()
    
    Specified by:
    
    iterator in interface Iterable<Node>
    
    See Also:
    Iterable.iterator()
  - nodeFactory
```
public NodeFactory<? extends Node> nodeFactory()
```
    Description copied from interface: Graph
    
    The factory used to create node instances. The factory can be changed to refine the node class generated for this graph.
    
    Specified by:
    
    nodeFactory in interface Graph
    
    See Also:
    Graph.setNodeFactory(NodeFactory), Graph.edgeFactory()
  - edgeFactory
```
public EdgeFactory<? extends Edge> edgeFactory()
```
    Description copied from interface: Graph
    
    The factory used to create edge instances. The factory can be changed to refine the edge class generated for this graph.
    
    Specified by:
    
    edgeFactory in interface Graph
    
    See Also:
    Graph.setEdgeFactory(EdgeFactory), Graph.nodeFactory()
  - setNodeFactory
```
public void setNodeFactory(NodeFactory<? extends Node> nf)
```
    Description copied from interface: Graph
    
    Set the node factory used to create nodes.
    
    Specified by:
    
    setNodeFactory in interface Graph
    
    Parameters:
    nf - the new NodeFactory
  - setEdgeFactory
```
public void setEdgeFactory(EdgeFactory<? extends Edge> ef)
```
    Description copied from interface: Graph
    
    Set the edge factory used to create edges.
    
    Specified by:
    
    setEdgeFactory in interface Graph
    
    Parameters:
    ef - the new EdgeFactory
  - isStrict
```
public boolean isStrict()
```
    Description copied from interface: Graph
    
    Is strict checking enabled? If strict checking is enabled the graph checks for name space conflicts (e.g. insertion of two nodes with the same name), removal of non-existing elements, use of non existing elements (create an edge between two non existing nodes). Graph implementations are free to respect strict checking or not.
    
    Specified by:
    
    isStrict in interface Graph
    
    Returns:
    True if enabled.
  - isAutoCreationEnabled
```
public boolean isAutoCreationEnabled()
```
    Description copied from interface: Graph
    
    Is the automatic creation of missing elements enabled?. If strict checking is disabled and auto-creation is enabled, when an edge is created and one or two of its nodes are not already present in the graph, the nodes are automatically created.
    
    Specified by:
    
    isAutoCreationEnabled in interface Graph
    
    Returns:
    True if enabled.
  - getStep
```
public double getStep()
```
    Description copied from interface: Graph
    
    The current step.
    
    Specified by:
    
    getStep in interface Graph
    
    Returns:
    The step.
  - setNullAttributesAreErrors
```
public void setNullAttributesAreErrors(boolean on)
```
    Description copied from interface: Graph
    
    Should a NullAttributeException be thrown when one tries to access a non existing attribute, or an attribute whose type is not the expected one?.
    
    Specified by:
    
    setNullAttributesAreErrors in interface Graph
    
    Parameters:
    on - if true, exceptions will be thrown when accessing a non existing attribute.
  - setStrict
```
public void setStrict(boolean on)
```
    Description copied from interface: Graph
    
    Enable or disable strict checking.
    
    Specified by:
    
    setStrict in interface Graph
    
    Parameters:
    on - True or false.
    See Also:
    Graph.isStrict()
  - setAutoCreate
```
public void setAutoCreate(boolean on)
```
    Description copied from interface: Graph
    
    Enable or disable the automatic creation of missing elements.
    
    Specified by:
    
    setAutoCreate in interface Graph
    
    Parameters:
    on - True or false.
    See Also:
    Graph.isAutoCreationEnabled()
  - stepBegins
```
public void stepBegins(double time)
```
    Description copied from interface: Graph
    
    Since dynamic graphs are based on discrete event modifications, the notion of step is defined to simulate elapsed time between events. So a step is a event that occurs in the graph, it does not modify it but it gives a kind of timestamp that allows the tracking of the progress of the graph over the time.
    
    This kind of event is useful for dynamic algorithms that listen to the dynamic graph and need to measure the time in the graph's evolution.
    
    Specified by:
    
    stepBegins in interface Graph
    
    Parameters:
    time - A numerical value that may give a timestamp to track the evolution of the graph over the time.
  - clear
```
public void clear()
```
    Description copied from interface: Graph
    
    Empty the graph completely by removing any references to nodes or edges. Every attribute is also removed. However, listeners are kept.
    
    Specified by:
    
    clear in interface Graph
    
    See Also:
    Source.clearSinks()
  - addNode
```
public <T extends Node> T addNode(String id)
```
    Description copied from interface: Graph
    Add a node in the graph.
    This acts as a factory, creating the node instance automatically (and eventually using the node factory provided). An event is generated toward the listeners. If strict checking is enabled, and a node already exists with this identifier, an IdAlreadyInUseException is raised. Else the error is silently ignored and the already existing node is returned.
    
    This method is implicitly generic and returns something which extends Node. The return type is the one of the left part of the assignment. For example, in the following call :
```
 ExtendedNode n = graph.addNode("...");
 
```
    the method will return an ExtendedNode. If no left part exists, method will just return a Node.
    Specified by:
    
    addNode in interface Graph
    
    Parameters:
    id - Arbitrary and unique string identifying the node.
    
    Returns:
    The created node (or the already existing node).
  - addEdge
```
public <T extends Edge> T addEdge(String id,
                         String node1,
                         String node2)
```
    Description copied from interface: Graph
    Adds an undirected edge between nodes.
    The behavior of this method depends on many conditions. It can be summarized as follows.
    
    First of all, the method checks if the graph already contains an edge with the same id. If this is the case and strict checking is enabled, IdAlreadyInUseException is thrown. If the strict checking is disabled the method returns a reference to the existing edge if it has endpoints node1 and node2 (in the same order if the edge is directed) or null otherwise.
    
    In the case when the graph does not contain an edge with the same id, the method checks if node1 and node2 exist. If one or both of them do not exist, and strict checking is enabled, ElementNotFoundException is thrown. Otherwise if auto-creation is disabled, the method returns null. If auto-creation is enabled, the method creates the missing endpoints.
    When the edge id is not already in use and the both endpoints exist (or created), the edge can still be rejected. It may happen for example when it connects two already connected nodes in a single graph. If the edge is rejected, the method throws EdgeRejectedException if strict checking is enabled or returns null otherwise. Finally, if the edge is accepted, it is created using the corresponding edge factory and a reference to it is returned.
    An edge creation event is sent toward the listeners. If new nodes are created, the corresponding events are also sent to the listeners.
    
    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 = graph.addEdge("...", "...", "...");
 
```
    the method will return an ExtendedEdge. If no left part exists, method will just return an Edge.
    Specified by:
    
    addEdge in interface Graph
    
    Parameters:
    id - Unique and arbitrary string identifying the edge.
    node1 - The first node identifier.
    node2 - The second node identifier.
    
    Returns:
    The newly created edge, an existing edge or null (see the detailed description above)
  - addEdge
```
public <T extends Edge> T addEdge(String id,
                         String from,
                         String to,
                         boolean directed)
```
    Description copied from interface: Graph
    
    Like Graph.addEdge(String, String, String), but this edge can be directed between the two given nodes. If directed, the edge goes in the 'from' -> 'to' direction. An event is sent toward the listeners.
    
    Specified by:
    
    addEdge in interface Graph
    
    Parameters:
    id - Unique and arbitrary string identifying the edge.
    directed - Is the edge directed?
    
    Returns:
    The newly created edge, an existing edge or null (see the detailed description above)
    See Also:
    Graph.addEdge(String, String, String)
  - addEdge
```
public <T extends Edge> T addEdge(String id,
                         int index1,
                         int index2)
```
    Description copied from interface: Graph
    
    Like Graph.addEdge(String, String, String) but the nodes are identified by their indices.
    
    Specified by:
    
    addEdge in interface Graph
    
    Parameters:
    id - Unique and arbitrary string identifying the edge.
    index1 - The first node index
    index2 - The second node index
    
    Returns:
    The newly created edge, an existing edge or null
    See Also:
    Graph.addEdge(String, String, String)
  - addEdge
```
public <T extends Edge> T addEdge(String id,
                         int fromIndex,
                         int toIndex,
                         boolean directed)
```
    Description copied from interface: Graph
    
    Like Graph.addEdge(String, String, String, boolean) but the nodes are identified by their indices.
    
    Specified by:
    
    addEdge in interface Graph
    
    Parameters:
    id - Unique and arbitrary string identifying the edge.
    fromIndex - The second node index
    toIndex - The first node index
    directed - Is the edge directed?
    
    Returns:
    The newly created edge, an existing edge or null
    See Also:
    Graph.addEdge(String, String, String)
  - addEdge
```
public <T extends Edge> T addEdge(String id,
                         Node node1,
                         Node node2)
```
    Description copied from interface: Graph
    
    Like Graph.addEdge(String, String, String) but the node references are given instead of node identifiers.
    
    Specified by:
    
    addEdge in interface Graph
    
    Parameters:
    id - Unique and arbitrary string identifying the edge.
    node1 - The first node
    node2 - The second node
    
    Returns:
    The newly created edge, an existing edge or null
    See Also:
    Graph.addEdge(String, String, String)
  - addEdge
```
public <T extends Edge> T addEdge(String id,
                         Node from,
                         Node to,
                         boolean directed)
```
    Description copied from interface: Graph
    
    Like Graph.addEdge(String, String, String, boolean) but the node references are given instead of node identifiers.
    
    Specified by:
    
    addEdge in interface Graph
    
    Parameters:
    id - Unique and arbitrary string identifying the edge.
    from - The first node
    to - The second node
    directed - Is the edge directed?
    
    Returns:
    The newly created edge, an existing edge or null
    See Also:
    Graph.addEdge(String, String, String)
  - removeNode
```
public <T extends Node> T removeNode(String id)
```
    Description copied from interface: Graph
    Remove a node using its identifier.
    An event is generated toward the listeners. Note that removing a node may remove all edges it is connected to. In this case corresponding events will also be generated toward the listeners.
    
    This method is implicitly generic and return something which extends Node. The return type is the one of the left part of the assignment. For example, in the following call :
```
 ExtendedNode n = graph.removeNode("...");
 
```
    the method will return an ExtendedNode. If no left part exists, method will just return a Node.
    Specified by:
    
    removeNode in interface Graph
    
    Parameters:
    id - The unique identifier of the node to remove.
    
    Returns:
    The removed node. If strict checking is disabled, it can return null if the node to remove does not exist.
  - removeNode
```
public <T extends Node> T removeNode(int index)
```
    Description copied from interface: Graph
    Removes a node with a given index.
    An event is generated toward the listeners. Note that removing a node may remove all edges it is connected to. In this case corresponding events will also be generated toward the listeners.
    
    This method is implicitly generic and return something which extends Node. The return type is the one of the left part of the assignment. For example, in the following call :
```
 ExtendedNode n = graph.removeNode(index);
 
```
    the method will return an ExtendedNode. If no left part exists, method will just return a Node.
    Specified by:
    
    removeNode in interface Graph
    
    Parameters:
    index - The index of the node to be removed
    
    Returns:
    The removed node
  - removeNode
```
public <T extends Node> T removeNode(Node node)
```
    Description copied from interface: Graph
    Removes a node.
    An event is generated toward the listeners. Note that removing a node may remove all edges it is connected to. In this case corresponding events will also be generated toward the listeners.
    
    This method is implicitly generic and return something which extends Node. The return type is the one of the left part of the assignment. For example, in the following call :
```
 ExtendedNode n = graph.removeNode(...);
 
```
    the method will return an ExtendedNode. If no left part exists, method will just return a Node.
    Specified by:
    
    removeNode in interface Graph
    
    Parameters:
    node - The node to be removed
    
    Returns:
    The removed node
  - removeEdge
```
public <T extends Edge> T removeEdge(String id)
```
    Description copied from interface: Graph
    Removes an edge knowing its identifier. An event is sent toward the listeners. If strict checking is enabled and the edge does not exist, ElementNotFoundException is raised. Otherwise the error is silently ignored and null is returned.
    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 = graph.removeEdge("...");
 
```
    the method will return an ExtendedEdge. If no left part exists, method will just return an Edge.
    Specified by:
    
    removeEdge in interface Graph
    
    Parameters:
    id - Identifier of the edge to remove.
    
    Returns:
    The removed edge, or null if strict checking is disabled and the edge does not exist.
  - removeEdge
```
public <T extends Edge> T removeEdge(int index)
```
    Description copied from interface: Graph
    Removes an edge with a given index. An event is sent toward the listeners.
    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 edge = graph.removeEdge(i);
 
```
    the method will return an ExtendedEdge edge. If no left part exists, method will just return an Edge.
    Specified by:
    
    removeEdge in interface Graph
    
    Parameters:
    index - The index of the edge to be removed.
    
    Returns:
    The removed edge
  - removeEdge
```
public <T extends Edge> T removeEdge(Edge edge)
```
    Description copied from interface: Graph
    Removes an edge. An event is sent toward the listeners.
    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 = graph.removeEdge(...);
 
```
    the method will return an ExtendedEdge. If no left part exists, method will just return an Edge.
    Specified by:
    
    removeEdge in interface Graph
    
    Parameters:
    edge - The edge to be removed
    
    Returns:
    The removed edge
  - removeEdge
```
public <T extends Edge> T removeEdge(String from,
                            String to)
```
    Description copied from interface: Graph
    Remove an edge given the identifiers of its two endpoints.
    If the edge is directed it is removed only if its source and destination nodes are identified by 'from' and 'to' respectively. If the graph is a multi-graph and there are several edges between the two nodes, one of the edges at random is removed. An event is sent toward the listeners. If strict checking is enabled and at least one of the two given nodes does not exist or if they are not connected, a not found exception is raised. Else the error is silently ignored, and null is returned.
    
    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 = graph.removeEdge("...", "...");
 
```
    the method will return an ExtendedEdge. If no left part exists, method will just return an Edge.
    Specified by:
    
    removeEdge in interface Graph
    
    Parameters:
    from - The origin node identifier to select the edge.
    to - The destination node identifier to select the edge.
    
    Returns:
    The removed edge, or null if strict checking is disabled and at least one of the two given nodes does not exist or there is no edge between them
  - removeEdge
```
public <T extends Edge> T removeEdge(int fromIndex,
                            int toIndex)
```
    Description copied from interface: Graph
    
    Removes an edge between two nodes. Like Graph.removeEdge(String, String) but the nodes are identified by their indices.
    
    Specified by:
    
    removeEdge in interface Graph
    
    Parameters:
    fromIndex - the index of the source node
    toIndex - the index of the target node
    
    Returns:
    the removed edge or null if no edge is removed
    See Also:
    Graph.removeEdge(String, String)
  - removeEdge
```
public <T extends Edge> T removeEdge(Node node1,
                            Node node2)
```
    Description copied from interface: Graph
    
    Removes an edge between two nodes. Like Graph.removeEdge(String, String) but node references are given instead of node identifiers.
    
    Specified by:
    
    removeEdge in interface Graph
    
    Parameters:
    node1 - the first node
    node2 - the second node
    
    Returns:
    the removed edge or null if no edge is removed
    See Also:
    Graph.removeEdge(String, String)
  - attributeSinks
```
public Iterable<AttributeSink> attributeSinks()
```
    Description copied from interface: Graph
    
    Returns an "iterable" of AttributeSink objects registered to this graph.
    
    Specified by:
    
    attributeSinks in interface Graph
    
    Returns:
    the set of AttributeSink under the form of an iterable object.
  - elementSinks
```
public Iterable<ElementSink> elementSinks()
```
    Description copied from interface: Graph
    
    Returns an "iterable" of ElementSink objects registered to this graph.
    
    Specified by:
    
    elementSinks in interface Graph
    
    Returns:
    the list of ElementSink under the form of an iterable object.
  - addAttributeSink
```
public void addAttributeSink(AttributeSink sink)
```
    Description copied from interface: Source
    
    Add a sink for attribute events only. Attribute events include attribute addition change and removal.
    
    Specified by:
    
    addAttributeSink in interface Source
    
    Parameters:
    sink - The sink to register.
  - addElementSink
```
public void addElementSink(ElementSink sink)
```
    Description copied from interface: Source
    
    Add a sink for elements events only. Elements events include, addition and removal of nodes and edges, as well as step events.
    
    Specified by:
    
    addElementSink in interface Source
    
    Parameters:
    sink - The sink to register.
  - addSink
```
public void addSink(Sink sink)
```
    Description copied from interface: Source
    
    Add a sink for all graph events (attributes and graph elements) coming from this source. This is similar to registering a sink for attributes an another for elements.
    
    Specified by:
    
    addSink in interface Source
    
    Parameters:
    sink - The sink to register.
  - clearAttributeSinks
```
public void clearAttributeSinks()
```
    Description copied from interface: Source
    
    Remove all listener attribute sinks.
    
    Specified by:
    
    clearAttributeSinks in interface Source
  - clearElementSinks
```
public void clearElementSinks()
```
    Description copied from interface: Source
    
    Remove all listener element sinks.
    
    Specified by:
    
    clearElementSinks in interface Source
  - clearSinks
```
public void clearSinks()
```
    Description copied from interface: Source
    
    Remove all listener sinks.
    
    Specified by:
    
    clearSinks in interface Source
  - removeAttributeSink
```
public void removeAttributeSink(AttributeSink sink)
```
    Description copied from interface: Source
    
    Remove an attribute sink.
    
    Specified by:
    
    removeAttributeSink in interface Source
    
    Parameters:
    sink - The sink to remove, if it does not exist, this is ignored silently.
  - removeElementSink
```
public void removeElementSink(ElementSink sink)
```
    Description copied from interface: Source
    
    Remove an element sink.
    
    Specified by:
    
    removeElementSink in interface Source
    
    Parameters:
    sink - The sink to remove, if it does not exist, this is ignored silently.
  - removeSink
```
public void removeSink(Sink sink)
```
    Description copied from interface: Source
    
    Remove a sink.
    
    Specified by:
    
    removeSink in interface Source
    
    Parameters:
    sink - The sink to remove, if it does not exist, this is ignored silently.
  - edgeAttributeAdded
```
public void edgeAttributeAdded(String sourceId,
                      long timeId,
                      String edgeId,
                      String attribute,
                      Object value)
```
    Description copied from interface: AttributeSink
    
    A edge attribute was added.
    
    Specified by:
    
    edgeAttributeAdded in interface AttributeSink
    
    Parameters:
    sourceId - Identifier of the graph where the change occurred.
    edgeId - Identifier of the edge whose attribute changed.
    attribute - The attribute name.
    value - The attribute new value.
  - edgeAttributeChanged
```
public void edgeAttributeChanged(String sourceId,
                        long timeId,
                        String edgeId,
                        String attribute,
                        Object oldValue,
                        Object newValue)
```
    Description copied from interface: AttributeSink
    
    A edge attribute was changed.
    
    Specified by:
    
    edgeAttributeChanged in interface AttributeSink
    
    Parameters:
    sourceId - Identifier of the graph where the change occurred.
    edgeId - Identifier of the edge whose attribute changed.
    attribute - The attribute name.
    oldValue - The attribute old value.
    newValue - The attribute new value.
  - edgeAttributeRemoved
```
public void edgeAttributeRemoved(String sourceId,
                        long timeId,
                        String edgeId,
                        String attribute)
```
    Description copied from interface: AttributeSink
    
    A edge attribute was removed.
    
    Specified by:
    
    edgeAttributeRemoved in interface AttributeSink
    
    Parameters:
    sourceId - Identifier of the graph where the attribute was removed.
    edgeId - Identifier of the edge whose attribute was removed.
    attribute - The removed attribute name.
  - graphAttributeAdded
```
public void graphAttributeAdded(String sourceId,
                       long timeId,
                       String attribute,
                       Object value)
```
    Description copied from interface: AttributeSink
    
    A graph attribute was added.
    
    Specified by:
    
    graphAttributeAdded in interface AttributeSink
    
    Parameters:
    sourceId - Identifier of the graph where the attribute changed.
    attribute - The attribute name.
    value - The attribute new value.
  - graphAttributeChanged
```
public void graphAttributeChanged(String sourceId,
                         long timeId,
                         String attribute,
                         Object oldValue,
                         Object newValue)
```
    Description copied from interface: AttributeSink
    
    A graph attribute was changed.
    
    Specified by:
    
    graphAttributeChanged in interface AttributeSink
    
    Parameters:
    sourceId - Identifier of the graph where the attribute changed.
    attribute - The attribute name.
    oldValue - The attribute old value.
    newValue - The attribute new value.
  - graphAttributeRemoved
```
public void graphAttributeRemoved(String sourceId,
                         long timeId,
                         String attribute)
```
    Description copied from interface: AttributeSink
    
    A graph attribute was removed.
    
    Specified by:
    
    graphAttributeRemoved in interface AttributeSink
    
    Parameters:
    sourceId - Identifier of the graph where the attribute was removed.
    attribute - The removed attribute name.
  - nodeAttributeAdded
```
public void nodeAttributeAdded(String sourceId,
                      long timeId,
                      String nodeId,
                      String attribute,
                      Object value)
```
    Description copied from interface: AttributeSink
    
    A node attribute was added.
    
    Specified by:
    
    nodeAttributeAdded in interface AttributeSink
    
    Parameters:
    sourceId - Identifier of the graph where the change occurred.
    nodeId - Identifier of the node whose attribute changed.
    attribute - The attribute name.
    value - The attribute new value.
  - nodeAttributeChanged
```
public void nodeAttributeChanged(String sourceId,
                        long timeId,
                        String nodeId,
                        String attribute,
                        Object oldValue,
                        Object newValue)
```
    Description copied from interface: AttributeSink
    
    A node attribute was changed.
    
    Specified by:
    
    nodeAttributeChanged in interface AttributeSink
    
    Parameters:
    sourceId - Identifier of the graph where the change occurred.
    nodeId - Identifier of the node whose attribute changed.
    attribute - The attribute name.
    oldValue - The attribute old value.
    newValue - The attribute new value.
  - nodeAttributeRemoved
```
public void nodeAttributeRemoved(String sourceId,
                        long timeId,
                        String nodeId,
                        String attribute)
```
    Description copied from interface: AttributeSink
    
    A node attribute was removed.
    
    Specified by:
    
    nodeAttributeRemoved in interface AttributeSink
    
    Parameters:
    sourceId - Identifier of the graph where the attribute was removed.
    nodeId - Identifier of the node whose attribute was removed.
    attribute - The removed attribute name.
  - edgeAdded
```
public void edgeAdded(String sourceId,
             long timeId,
             String edgeId,
             String fromNodeId,
             String toNodeId,
             boolean directed)
```
    Description copied from interface: ElementSink
    
    An edge was inserted in graph.
    
    Specified by:
    
    edgeAdded in interface ElementSink
    
    Parameters:
    sourceId - Identifier of the graph where the edge was added.
    edgeId - Identifier of the added edge.
    fromNodeId - Identifier of the first node of the edge.
    toNodeId - Identifier of the second node of the edge.
    directed - If true, the edge is directed.
  - edgeRemoved
```
public void edgeRemoved(String sourceId,
               long timeId,
               String edgeId)
```
    Description copied from interface: ElementSink
    
    An edge of graph was removed.The nodes the edge connects may already have been removed from the graph.
    
    Specified by:
    
    edgeRemoved in interface ElementSink
    
    Parameters:
    sourceId - The graph where the edge will be removed.
    edgeId - The edge that will be removed.
  - graphCleared
```
public void graphCleared(String sourceId,
                long timeId)
```
    Description copied from interface: ElementSink
    
    The whole graph was cleared. All the nodes, edges and attributes of the graph are removed.
    
    Specified by:
    
    graphCleared in interface ElementSink
    
    Parameters:
    sourceId - The graph cleared.
  - nodeAdded
```
public void nodeAdded(String sourceId,
             long timeId,
             String nodeId)
```
    Description copied from interface: ElementSink
    
    A node was inserted in the given graph.
    
    Specified by:
    
    nodeAdded in interface ElementSink
    
    Parameters:
    sourceId - Identifier of the graph where the node was added.
    nodeId - Identifier of the added node.
  - nodeRemoved
```
public void nodeRemoved(String sourceId,
               long timeId,
               String nodeId)
```
    Description copied from interface: ElementSink
    
    A node was removed from the graph.
    
    Specified by:
    
    nodeRemoved in interface ElementSink
    
    Parameters:
    sourceId - Identifier of the graph where the node will be removed.
    nodeId - Identifier of the removed node.
  - stepBegins
```
public void stepBegins(String sourceId,
              long timeId,
              double step)
```
    Description copied from interface: ElementSink
    
    Since dynamic graphs are based on discrete event modifications, the notion of step is defined to simulate elapsed time between events. So a step is a event that occurs in the graph, it does not modify it but it gives a kind of timestamp that allow the tracking of the progress of the graph over the time.
    
    This kind of event is useful for dynamic algorithms that listen to the dynamic graph and need to measure the time in the graph's evolution.
    
    Specified by:
    
    stepBegins in interface ElementSink
    
    Parameters:
    sourceId - Identifier of the graph where the step starts.
    timeId - A numerical value that may give a timestamp to track the evolution of the graph over the time.
  - display
```
public Viewer display()
```
    Description copied from interface: Graph
    
    Utility method that creates a new graph viewer, and register the graph in it. Notice that this method is a quick way to see a graph, and only this. It can be used to prototype a program, but may be limited. This method automatically launch a graph layout algorithm in its own thread to compute best node positions.
    
    Specified by:
    
    display in interface Graph
    
    Returns:
    a graph viewer that allows to command the viewer (it often run in another thread).
    See Also:
    Viewer, Graph.display(boolean )
  - display
```
public Viewer display(boolean autoLayout)
```
    Description copied from interface: Graph
    
    Utility method that creates a new graph viewer, and register the graph in it. Notice that this method is a quick way to see a graph, and only this. It can be used to prototype a program, but is very limited.
    
    Specified by:
    
    display in interface Graph
    
    Parameters:
    autoLayout - If true a layout algorithm is launched in its own thread to compute best node positions.
    
    Returns:
    a graph viewer that allows to command the viewer (it often run in another thread).
    See Also:
    Viewer, Graph.display()
  - read
```
public void read(FileSource input,
        String filename)
          throws IOException,
                 GraphParseException
```
    Description copied from interface: Graph
    
    Utility method to read a graph using the given reader.
    
    Specified by:
    
    read in interface Graph
    
    Parameters:
    input - An appropriate reader for the filename.
    filename - The graph filename (or URL).
    
    Throws:
    
    IOException - If an input/output error occurs during the graph reading.
    
    GraphParseException - If there is a parsing error while reading the file.
  - read
```
public void read(String filename)
          throws IOException,
                 GraphParseException,
                 ElementNotFoundException
```
    Description copied from interface: Graph
    
    Utility method to read a graph. This method tries to identify the graph format by itself and instantiates the corresponding reader automatically. If this process fails, a NotFoundException is raised.
    
    Specified by:
    
    read in interface Graph
    
    Parameters:
    filename - The graph filename (or URL).
    
    Throws:
    
    IOException - If an input output error occurs during the graph reading.
    
    GraphParseException - If there is a parsing error while reading the file.
    
    ElementNotFoundException - If the file cannot be found or if the format is not recognized.
  - write
```
public void write(FileSink output,
         String filename)
           throws IOException
```
    Description copied from interface: Graph
    
    Utility method to write a graph in the chosen format to a file.
    
    Specified by:
    
    write in interface Graph
    
    Parameters:
    output - The output format to use.
    filename - The file that will contain the saved graph (or URL).
    
    Throws:
    
    IOException - If an input/output error occurs during the graph writing.
  - write
```
public void write(String filename)
           throws IOException
```
    Description copied from interface: Graph
    
    Utility method to write a graph in DGS format to a file.
    
    Specified by:
    
    write in interface Graph
    
    Parameters:
    filename - The file that will contain the saved graph (or URL).
    
    Throws:
    
    IOException - If an input/output error occurs during the graph writing.
  - getReplayController
```
public Replayable.Controller getReplayController()
```
    Description copied from interface: Replayable
    
    Get a controller to replay the graph.
    
    Specified by:
    
    getReplayController in interface Replayable
    
    Returns:
    a new replay controller

Class AbstractGraph

Nested Class Summary

Nested classes/interfaces inherited from class org.graphstream.graph.implementations.AbstractElement

Nested classes/interfaces inherited from interface org.graphstream.stream.Replayable

Constructor Summary

Method Summary

Methods inherited from class org.graphstream.graph.implementations.AbstractElement

Methods inherited from class java.lang.Object

Methods inherited from interface org.graphstream.graph.Element

Constructor Detail

AbstractGraph

AbstractGraph

Method Detail

nullAttributesAreErrors

getNode

getNode

getEdge

getEdge

getNodeCount

getEdgeCount

getNodeIterator

getEdgeIterator

getEachNode

getEachEdge

getNodeSet

getEdgeSet

iterator

nodeFactory

edgeFactory

setNodeFactory

setEdgeFactory

isStrict

isAutoCreationEnabled

getStep

setNullAttributesAreErrors

setStrict

setAutoCreate

stepBegins

clear

addNode

addEdge

addEdge

addEdge

addEdge

addEdge

addEdge

removeNode

removeNode

removeNode

removeEdge

removeEdge

removeEdge

removeEdge

removeEdge

removeEdge

attributeSinks

elementSinks

addAttributeSink

addElementSink

addSink

clearAttributeSinks

clearElementSinks

clearSinks

removeAttributeSink

removeElementSink

removeSink

edgeAttributeAdded

edgeAttributeChanged

edgeAttributeRemoved

graphAttributeAdded

graphAttributeChanged

graphAttributeRemoved

nodeAttributeAdded

nodeAttributeChanged

nodeAttributeRemoved

edgeAdded

edgeRemoved

graphCleared

nodeAdded

nodeRemoved