org.graphstream.ui.graphicGraph
Class GraphicGraph

java.lang.Object
  extended by org.graphstream.graph.implementations.AbstractElement
      extended by org.graphstream.ui.graphicGraph.GraphicGraph
All Implemented Interfaces:
Iterable<Node>, Element, Graph, Structure, AttributeSink, ElementSink, Pipe, Sink, Source, StyleGroupListener

public class GraphicGraph
extends AbstractElement
implements Graph, StyleGroupListener

Graph representation used in display classes.

Warning: This class is NOT a general graph class, and it should NOT be used as it. This class is particularly dedicated to fast drawing of the graph and is internally arranged to be fast for this task only. It implements graph solely to be easily susceptible to be used as a sink and source for graph events. Some of the common methods of the Graph interface are not functional and will throw an exception if used (as documented in their respective JavaDoc).

The purpose of the graphic graph is to represent a graph with some often used graphic attributes (like position, label, etc.) stored as fields in the nodes and edges and most of the style stored in styles pertaining to a style sheet that tries to imitate the way CSS works. For example, the GraphicNode class defines a label, a position (x,y,z) and a style that is taken from the style sheet.

The style sheet is uploaded on the graph using an attribute correspondingly named "ui.stylesheet" or "ui.stylesheet" (the second one is better). It can be a string that contains the whole style sheet, or an URL of the form :

 url(name)
 

The graphic graph does not completely duplicate a graph, it only store things that are useful for drawing it. Although it implements "Graph", some methods are not implemented and will throw a runtime exception. These methods are mostly utility methods like write(), read(), and naturally display().

The graphic graph has the ability to store attributes like any other graph element, however the attributes stored by the graphic graph are restricted. There is a filter on the attribute adding methods that let pass only:

All other attributes are filtered and not stored. The result is that if the graphic graph is used as an input (a source of graph events) some attributes will not pass through the filter.

The implementation of this graph relies on the StyleGroupSet class and this is indeed its way to store its elements (grouped by style and Z level).

In addition to this, it provides, as all graphs do, the relational information for edges.

TODO : this graph cannot handle modification inside event listener methods !!


Nested Class Summary
 
Nested classes/interfaces inherited from class org.graphstream.graph.implementations.AbstractElement
AbstractElement.AttributeChangeEvent
 
Field Summary
 boolean graphChanged
          Set to true each time the graph was modified internally and a redraw is needed.
 double step
          Memorize the step events.
 StyleGroup style
          The style of this graph.
 
Constructor Summary
GraphicGraph(String id)
          New empty graphic graph.
 
Method Summary
 void addAttribute(String attribute, Object... values)
          Add or replace the value of an attribute.
 void addAttributeSink(AttributeSink listener)
          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 from, String to)
          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 listener)
          Add a sink for elements events only.
<T extends Node>
T
addNode(String id)
          Add a node in the graph.
 void addSink(Sink listener)
          Add a sink for all graph events (attributes and graph elements) coming from this source.
 GraphicSprite addSprite(String id)
           
 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 clear(String sourceId, long timeId)
           
 void clearAttributeSinks()
          Remove all listener attribute sinks.
 void clearElementSinks()
          Remove all listener element sinks.
 void clearSinks()
          Remove all listener sinks.
 void computeBounds()
          Compute the overall bounds of the graphic graph according to the nodes and sprites positions.
 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.
 void elementStyleChanged(Element element, StyleGroup oldStyle, StyleGroup style)
          The style of the element changed.
 boolean feedbackXYZ()
          Does the graphic graph publish via attribute changes the XYZ changes on nodes and sprites when changed ?.
 void feedbackXYZ(boolean on)
          Should the graphic graph publish via attribute changes the XYZ changes on nodes and sprites when changed ?.
 Iterable<? extends Edge> getEachEdge()
          Set of edges usable in a for-each instruction.
 Iterable<? extends Node> getEachNode()
          Set of nodes usable in a for-each instruction.
<T extends Edge>
T
getEdge(int index)
          Get an edge by its index.
<T extends Edge>
T
getEdge(String id)
          Get an edge by its identifier.
 int getEdgeCount()
          Number of edges in this graph.
<T extends Edge>
Iterator<T>
getEdgeIterator()
          Iterator on the set of edges, in an undefined order.
<T extends Edge>
Collection<T>
getEdgeSet()
          Unmodifiable view of the set of edges.
 Point3 getMaxPos()
          The maximum position of a node or sprite.
 Point3 getMinPos()
          The minimum position of a node or sprite.
<T extends Node>
T
getNode(int index)
          Get a node by its index.
<T extends Node>
T
getNode(String id)
          Get a node by its identifier.
 int getNodeCount()
          Number of nodes in this graph.
<T extends Node>
Iterator<T>
getNodeIterator()
          Iterator on the set of nodes, in an undefined order.
<T extends Node>
Collection<T>
getNodeSet()
          Unmodifiable view of the set of nodes.
 GraphicSprite getSprite(String id)
           
 int getSpriteCount()
           
 Iterator<? extends GraphicSprite> getSpriteIterator()
           
 double getStep()
          The current step.
 StyleGroup getStyle()
          The graph style group.
 StyleGroupSet getStyleGroups()
          The complete set of style groups.
 StyleSheet getStyleSheet()
          The style sheet.
 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.
 boolean graphChangedFlag()
          True if the graph was edited or changed in any way since the last reset of the "changed" flag.
 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()
           
 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 printConnectivity()
          Display the node/edge relations.
 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 listener)
          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.
 Edge removeEdge(String sourceId, long timeId, String id)
           
 Edge removeEdge(String sourceId, long timeId, String from, String to)
           
<T extends Edge>
T
removeEdge(String from, String to)
          Remove an edge given the identifiers of its two endpoints.
 void removeElementSink(ElementSink listener)
          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.
 Node removeNode(String sourceId, long timeId, String id)
           
 void removeSink(Sink listener)
          Remove a sink.
 void removeSprite(String id)
           
 void replay()
          Replay all the elements of the graph and all attributes as new events to all connected sinks.
 void resetGraphChangedFlag()
          Reset the "changed" flag.
 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.
 Iterable<? extends GraphicSprite> spriteSet()
           
 void stepBegins(double step)
           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 time)
           Since dynamic graphs are based on discrete event modifications, the notion of step is defined to simulate elapsed time between events.
 void styleChanged(StyleGroup style)
           
 String toString()
          Override the Object method
 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
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 class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, wait, wait, wait
 
Methods inherited from interface org.graphstream.graph.Element
addAttributes, changeAttribute, clearAttributes, getArray, getAttribute, getAttribute, getAttributeCount, getAttributeKeyIterator, getAttributeKeySet, getFirstAttributeOf, getFirstAttributeOf, getHash, getId, getIndex, getLabel, getNumber, getVector, hasArray, hasAttribute, hasAttribute, hasHash, hasLabel, hasNumber, hasVector, removeAttribute, setAttribute
 

Field Detail

style

public StyleGroup style
The style of this graph. This is a shortcut to avoid searching it in the style sheet.


step

public double step
Memorize the step events.


graphChanged

public boolean graphChanged
Set to true each time the graph was modified internally and a redraw is needed.

Constructor Detail

GraphicGraph

public GraphicGraph(String id)
New empty graphic graph. A default style sheet is created, it then can be "cascaded" with other style sheets.

Method Detail

graphChangedFlag

public boolean graphChangedFlag()
True if the graph was edited or changed in any way since the last reset of the "changed" flag.

Returns:
true if the graph was changed.

resetGraphChangedFlag

public void resetGraphChangedFlag()
Reset the "changed" flag.

See Also:
graphChangedFlag()

getStyleSheet

public StyleSheet getStyleSheet()
The style sheet. This style sheet is the result of the "cascade" or accumulation of styles added via attributes of the graph.

Returns:
A style sheet.

getStyle

public StyleGroup getStyle()
The graph style group.

Returns:
A style group.

getStyleGroups

public StyleGroupSet getStyleGroups()
The complete set of style groups.

Returns:
The style groups.

toString

public String toString()
Description copied from class: AbstractElement
Override the Object method

Overrides:
toString in class AbstractElement

getStep

public double getStep()
Description copied from interface: Graph
The current step.

Specified by:
getStep in interface Graph
Returns:
The step.

getMaxPos

public Point3 getMaxPos()
The maximum position of a node or sprite. Notice that this is updated only each time the computeBounds() method is called.

Returns:
The maximum node or sprite position.

getMinPos

public Point3 getMinPos()
The minimum position of a node or sprite. Notice that this is updated only each time the computeBounds() method is called.

Returns:
The minimum node or sprite position.

feedbackXYZ

public boolean feedbackXYZ()
Does the graphic graph publish via attribute changes the XYZ changes on nodes and sprites when changed ?. This is disabled by default, and enabled as soon as there is at least one listener.


feedbackXYZ

public void feedbackXYZ(boolean on)
Should the graphic graph publish via attribute changes the XYZ changes on nodes and sprites when changed ?.


computeBounds

public void computeBounds()
Compute the overall bounds of the graphic graph according to the nodes and sprites positions. We can only compute the graph bounds from the nodes and sprites centres since the node and graph bounds may in certain circumstances be computed according to the graph bounds. The bounds are stored in the graph metrics. This operation will process each node and sprite and is therefore costly. However it does this computation again only when a node or sprite moved. Therefore it can be called several times, if nothing moved in the graph, the computation will not be redone.

See Also:
getMaxPos(), getMinPos()

removeEdge

public Edge removeEdge(String sourceId,
                       long timeId,
                       String id)
                throws ElementNotFoundException
Throws:
ElementNotFoundException

removeEdge

public Edge removeEdge(String sourceId,
                       long timeId,
                       String from,
                       String to)
                throws ElementNotFoundException
Throws:
ElementNotFoundException

removeNode

public Node removeNode(String sourceId,
                       long timeId,
                       String id)

getNode

public <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.

getEdge

public <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.

getSprite

public GraphicSprite getSprite(String id)

clear

public void clear(String sourceId,
                  long timeId)

printConnectivity

public void printConnectivity()
Display the node/edge relations.


elementStyleChanged

public void elementStyleChanged(Element element,
                                StyleGroup oldStyle,
                                StyleGroup style)
Description copied from interface: StyleGroupListener
The style of the element changed.

Specified by:
elementStyleChanged in interface StyleGroupListener
Parameters:
element - The element.
oldStyle - The old style.
style - The changed style or the new style of the element.

styleChanged

public void styleChanged(StyleGroup style)

getEachEdge

public Iterable<? extends Edge> getEachEdge()
Description copied from interface: Structure
Set of edges usable in a for-each instruction. This method is implicitly generic and returns 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<ExtendedNEdge> ite = struct.getEachEdge();
 
the method will return an Iterable<ExtendedEdge>. If no left part exists, method will just return an Iterable<Edge>. It is possible to use it in a for-each loop by giving the parameter :
 for (ExtendedEdge e : struct.<ExtendedEdge> getEachEdge()) {
        // ...
 }
 

Specified by:
getEachEdge in interface Structure
Returns:
An "iterable" view of the set of edges.
See Also:
Structure.getEdgeIterator(), Structure.getEdgeSet()

getEachNode

public Iterable<? extends Node> getEachNode()
Description copied from interface: Structure
Set of nodes usable in a for-each instruction. This method is implicitly generic and returns an Iterable over something which extends Node. The return type is the one of the left part of the assignment. For example, in the following call :
 Iterable<ExtendedNode> ite = struct.getEachNode();
 
the method will return an Iterable<ExtendedNode>. If no left part exists, method will just return an Iterable<Node>. It is possible to use it in a for-each loop by giving the parameter :
 for (ExtendedNode n : struct.<ExtendedNode> getEachNode()) {
        // ...
 }
 

Specified by:
getEachNode in interface Structure
Returns:
An "iterable" view of the set of nodes.
See Also:
Structure.getNodeIterator(), Structure.getEachNode()

getNodeSet

public <T extends Node> Collection<T> getNodeSet()
Description copied from interface: Structure
Unmodifiable view of the set of nodes. This method is implicitly generic and returns a Collection of something which extends Node. The return type is the one of the left part of the assignment. For example, in the following call :
 Collection<ExtendedNode> c = struct.getNodeSet();
 
the method will return a Collection<ExtendedNode>. If no left part exists, method will just return a Collection<Node>.

Specified by:
getNodeSet in interface Structure
Returns:
A set of nodes that can only be read, not changed.
See Also:
Structure.getNodeIterator(), Structure.getEachNode()

getEdgeSet

public <T extends Edge> Collection<T> getEdgeSet()
Description copied from interface: Structure
Unmodifiable view of the set of edges. This method is implicitly generic and returns a Collection of something which extends Edge. The return type is the one of the left part of the assignment. For example, in the following call :
 Collection<ExtendedEdge> c = struct.getEdgeSet();
 
the method will return a Collection<ExtendedEdge>. If no left part exists, method will just return a Collection<Edge>.

Specified by:
getEdgeSet in interface Structure
Returns:
A set of edges that can only be read, not changed.
See Also:
Structure.getEdgeIterator(), Structure.getEachEdge()

iterator

public Iterator<Node> iterator()
Specified by:
iterator in interface Iterable<Node>

addSink

public void addSink(Sink listener)
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:
listener - The sink to register.

removeSink

public void removeSink(Sink listener)
Description copied from interface: Source
Remove a sink.

Specified by:
removeSink in interface Source
Parameters:
listener - The sink to remove, if it does not exist, this is ignored silently.

addAttributeSink

public void addAttributeSink(AttributeSink listener)
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:
listener - The sink to register.

removeAttributeSink

public void removeAttributeSink(AttributeSink listener)
Description copied from interface: Source
Remove an attribute sink.

Specified by:
removeAttributeSink in interface Source
Parameters:
listener - The sink to remove, if it does not exist, this is ignored silently.

addElementSink

public void addElementSink(ElementSink listener)
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:
listener - The sink to register.

removeElementSink

public void removeElementSink(ElementSink listener)
Description copied from interface: Source
Remove an element sink.

Specified by:
removeElementSink in interface Source
Parameters:
listener - The sink to remove, if it does not exist, this is ignored silently.

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.

addEdge

public <T extends Edge> T addEdge(String id,
                                  String from,
                                  String to)
                       throws IdAlreadyInUseException,
                              ElementNotFoundException
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.
from - The first node identifier.
to - The second node identifier.
Returns:
The newly created edge, an existing edge or null (see the detailed description above)
Throws:
IdAlreadyInUseException - If an edge with the same id already exists and strict checking is enabled.
ElementNotFoundException - If strict checking is enabled, and 'node1' or 'node2' are not registered in the graph.

addEdge

public <T extends Edge> T addEdge(String id,
                                  String from,
                                  String to,
                                  boolean directed)
                       throws IdAlreadyInUseException,
                              ElementNotFoundException
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)
Throws:
IdAlreadyInUseException - If an edge with the same id already exists and strict checking is enabled.
ElementNotFoundException - If strict checking is enabled, and 'node1' or 'node2' are not registered in the graph.
See Also:
Graph.addEdge(String, String, String)

addNode

public <T extends Node> T addNode(String id)
                       throws IdAlreadyInUseException
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).
Throws:
IdAlreadyInUseException - If strict checking is enabled the identifier is already used.

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()

removeEdge

public <T extends Edge> T removeEdge(String id)
                          throws ElementNotFoundException
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.
Throws:
ElementNotFoundException - If no edge matches the identifier and strict checking is enabled.

removeEdge

public <T extends Edge> T removeEdge(String from,
                                     String to)
                          throws ElementNotFoundException
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
Throws:
ElementNotFoundException - If the 'from' or 'to' node is not registered in the graph or not connected and strict checking is enabled.

removeNode

public <T extends Node> T removeNode(String id)
                          throws ElementNotFoundException
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.
Throws:
ElementNotFoundException - If no node matches the given identifier and strict checking is enabled.

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()

stepBegins

public void stepBegins(double step)
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:
step - A numerical value that may give a timestamp to track the evolution of the graph over the time.

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()

getEdgeCount

public int getEdgeCount()
Description copied from interface: Structure
Number of edges in this graph.

Specified by:
getEdgeCount in interface Structure
Returns:
The number of edges.

getEdgeIterator

public <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.

getNodeCount

public int getNodeCount()
Description copied from interface: Structure
Number of nodes in this graph.

Specified by:
getNodeCount in interface Structure
Returns:
The number of nodes.

getSpriteCount

public int getSpriteCount()

getNodeIterator

public <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.

getSpriteIterator

public Iterator<? extends GraphicSprite> getSpriteIterator()

spriteSet

public Iterable<? extends GraphicSprite> spriteSet()

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.

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()

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()

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.

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()

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.

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.

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

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

read

public void read(String filename)
          throws IOException
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.

read

public void read(FileSource input,
                 String filename)
          throws IOException
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.

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.

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 time)
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.

addSprite

public GraphicSprite addSprite(String id)

removeSprite

public void removeSprite(String id)

addAttribute

public void addAttribute(String attribute,
                         Object... values)
Description copied from interface: Element
Add or replace the value of an attribute. Existing attributes are overwritten silently. All classes inheriting from Number can be considered as numbers. All classes inheriting from CharSequence can be considered as labels. You can pass zero, one or more arguments for the attribute values. If no value is given, a boolean with value "true" is added. If there is more than one value, an array is stored. If there is only one value, the value is stored (but not in an array).

Specified by:
addAttribute in interface Element
Overrides:
addAttribute in class AbstractElement
Parameters:
attribute - The attribute name.
values - The attribute value or set of values.

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

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)

getEdge

public <T extends Edge> T getEdge(int index)
                       throws IndexOutOfBoundsException
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
Throws:
IndexOutOfBoundsException - if the index is less than 0 or greater than getNodeCount() - 1.

getNode

public <T extends Node> T getNode(int index)
                       throws IndexOutOfBoundsException
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
Throws:
IndexOutOfBoundsException - If the index is negative or greater than getNodeCount() - 1.

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(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)

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

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

replay

public void replay()
Replay all the elements of the graph and all attributes as new events to all connected sinks. Be very careful with this method, it introduces new events in the event stream and some sinks may therefore receive them twice !! Graph replay is always dangerous !



Copyright © 2012. All Rights Reserved.