*/
public class Graph {
- private List<Node> _nodes;
- private List<Edge> _edges;
+ private List<Node> nodes;
+ private List<Edge> edges;
/**
* Constructs the graph.
*/
public Graph() {
- _nodes = new ArrayList<Node>();
- _edges = new ArrayList<Edge>();
+ nodes = new ArrayList<Node>();
+ edges = new ArrayList<Edge>();
}
/**
* using <code>equals</code>.
*/
public void addNode(Node aNode) {
- if (_nodes.contains(aNode)) {
+ if (nodes.contains(aNode)) {
throw new IllegalArgumentException("Node '" + aNode.getName()
+ "' already exists");
}
- _nodes.add(aNode);
+ nodes.add(aNode);
}
/**
* @return Node or null if not found.
*/
public Node findNode(String aName) {
- for (Node node : _nodes) {
+ for (Node node : nodes) {
if (node.getName().equals(aName)) {
return node;
}
+ aNode.getName()
+ "' because it is connected to one or more edges");
}
- return _nodes.remove(aNode);
+ return nodes.remove(aNode);
}
/**
* {@link #equals(Object)} is already a part of the graph.
*/
public void addEdge(Edge aEdge) {
- if (_edges.contains(aEdge)) {
+ if (edges.contains(aEdge)) {
throw new IllegalArgumentException("Edge '" + aEdge
+ "' already exists");
}
- if (!_nodes.contains(aEdge.getFrom())) {
+ if (!nodes.contains(aEdge.getFrom())) {
throw new IllegalArgumentException("From node '" + aEdge.getFrom()
+ "' from edge '" + aEdge + "' is not part of the graph");
}
- if (!_nodes.contains(aEdge.getTo())) {
+ if (!nodes.contains(aEdge.getTo())) {
throw new IllegalArgumentException("To node '" + aEdge.getTo()
+ "' from edge '" + aEdge + "' is not part of the graph");
}
- _edges.add(aEdge);
+ edges.add(aEdge);
}
/**
* @return True if the edge was removed.
*/
public boolean removeEdge(Edge aEdge) {
- return _edges.remove(aEdge);
+ return edges.remove(aEdge);
}
/**
* @return Copy of the list of nodes of the graph.
*/
public List<Node> getNodes() {
- return new ArrayList<Node>(_nodes);
+ return new ArrayList<Node>(nodes);
}
/**
* @return Copy of the list of edges of the graph.
*/
public List<Edge> getEdges() {
- return new ArrayList<Edge>(_edges);
+ return new ArrayList<Edge>(edges);
}
/**
* @param aFactory Edge factory.
*/
public void extend(EdgeFactory aFactory) {
- for (Node from : _nodes) {
- for (Node to : _nodes) {
- _edges.addAll(aFactory.create(from, to));
+ for (Node from : nodes) {
+ for (Node to : nodes) {
+ edges.addAll(aFactory.create(from, to));
}
}
}
* @param aFilter Filter to apply.
*/
public void applyFilter(EdgeFilter aFilter) {
- for (Iterator<Edge> edge = _edges.iterator(); edge.hasNext(); ) {
+ for (Iterator<Edge> edge = edges.iterator(); edge.hasNext(); ) {
if (aFilter.isViolated(edge.next())) {
edge.remove();
}
*/
public List<Edge> findOutgoing(Node aNode) {
List<Edge> result = new ArrayList<Edge>();
- for (Edge edge : _edges) {
+ for (Edge edge : edges) {
if (edge.getFrom().getName().equals(aNode.getName())) {
result.add(edge);
}
*/
public List<Edge> findIncoming(Node aNode) {
List<Edge> result = new ArrayList<Edge>();
- for (Edge edge : _edges) {
+ for (Edge edge : edges) {
if (edge.getTo().getName().equals(aNode.getName())) {
result.add(edge);
}