Java tutorial
/* * Created on Feb 4, 2007 * * Copyright (c) 2007, the JUNG Project and the Regents of the University * of California * All rights reserved. * * This software is open-source under the BSD license; see either * "license.txt" or * http://jung.sourceforge.net/license.txt for a description. */ package edu.uci.ics.jung.graph; import java.io.Serializable; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; import java.util.HashMap; import java.util.HashSet; import java.util.Map; import java.util.Set; import org.apache.commons.collections15.Factory; import edu.uci.ics.jung.graph.util.EdgeType; /** * An implementation of <code>Hypergraph</code> that is suitable for sparse graphs and * permits parallel edges. */ @SuppressWarnings("serial") public class SetHypergraph<V, H> implements Hypergraph<V, H>, MultiGraph<V, H>, Serializable { protected Map<V, Set<H>> vertices; // Map of vertices to incident hyperedge sets protected Map<H, Set<V>> edges; // Map of hyperedges to incident vertex sets /** * Returns a <code>Factory</code> which creates instances of this class. * @param <V> vertex type of the hypergraph to be created * @param <H> edge type of the hypergraph to be created * @return a <code>Factory</code> which creates instances of this class */ public static <V, H> Factory<Hypergraph<V, H>> getFactory() { return new Factory<Hypergraph<V, H>>() { public Hypergraph<V, H> create() { return new SetHypergraph<V, H>(); } }; } /** * Creates a <code>SetHypergraph</code> and initializes the internal data structures. */ public SetHypergraph() { vertices = new HashMap<V, Set<H>>(); edges = new HashMap<H, Set<V>>(); } /** * Adds <code>hyperedge</code> to this graph and connects them to the vertex collection <code>to_attach</code>. * Any vertices in <code>to_attach</code> that appear more than once will only appear once in the * incident vertex collection for <code>hyperedge</code>, that is, duplicates will be ignored. * * @see Hypergraph#addEdge(Object, Collection) */ public boolean addEdge(H hyperedge, Collection<? extends V> to_attach) { if (hyperedge == null) throw new IllegalArgumentException("input hyperedge may not be null"); if (to_attach == null) throw new IllegalArgumentException("endpoints may not be null"); if (to_attach.contains(null)) throw new IllegalArgumentException("cannot add an edge with a null endpoint"); Set<V> new_endpoints = new HashSet<V>(to_attach); if (edges.containsKey(hyperedge)) { Collection<V> attached = edges.get(hyperedge); if (!attached.equals(new_endpoints)) { throw new IllegalArgumentException( "Edge " + hyperedge + " exists in this graph with endpoints " + attached); } else return false; } edges.put(hyperedge, new_endpoints); for (V v : to_attach) { // add v if it's not already in the graph addVertex(v); // associate v with hyperedge vertices.get(v).add(hyperedge); } return true; } /** * @see Hypergraph#addEdge(Object, Collection, EdgeType) */ public boolean addEdge(H hyperedge, Collection<? extends V> to_attach, EdgeType edge_type) { if (edge_type != EdgeType.UNDIRECTED) throw new IllegalArgumentException( "Edge type for this " + "implementation must be EdgeType.HYPER, not " + edge_type); return addEdge(hyperedge, to_attach); } /** * @see Hypergraph#getEdgeType(Object) */ public EdgeType getEdgeType(H edge) { if (containsEdge(edge)) return EdgeType.UNDIRECTED; else return null; } public boolean containsVertex(V vertex) { return vertices.keySet().contains(vertex); } public boolean containsEdge(H edge) { return edges.keySet().contains(edge); } public Collection<H> getEdges() { return edges.keySet(); } public Collection<V> getVertices() { return vertices.keySet(); } public int getEdgeCount() { return edges.size(); } public int getVertexCount() { return vertices.size(); } public Collection<V> getNeighbors(V vertex) { if (!containsVertex(vertex)) return null; Set<V> neighbors = new HashSet<V>(); for (H hyperedge : vertices.get(vertex)) { neighbors.addAll(edges.get(hyperedge)); } return neighbors; } public Collection<H> getIncidentEdges(V vertex) { return vertices.get(vertex); } public Collection<V> getIncidentVertices(H edge) { return edges.get(edge); } public H findEdge(V v1, V v2) { if (!containsVertex(v1) || !containsVertex(v2)) return null; for (H h : getIncidentEdges(v1)) { if (isIncident(v2, h)) return h; } return null; } public Collection<H> findEdgeSet(V v1, V v2) { if (!containsVertex(v1) || !containsVertex(v2)) return null; Collection<H> edges = new ArrayList<H>(); for (H h : getIncidentEdges(v1)) { if (isIncident(v2, h)) edges.add(h); } return Collections.unmodifiableCollection(edges); } public boolean addVertex(V vertex) { if (vertex == null) throw new IllegalArgumentException("cannot add a null vertex"); if (containsVertex(vertex)) return false; vertices.put(vertex, new HashSet<H>()); return true; } public boolean removeVertex(V vertex) { if (!containsVertex(vertex)) return false; for (H hyperedge : vertices.get(vertex)) { edges.get(hyperedge).remove(vertex); } vertices.remove(vertex); return true; } public boolean removeEdge(H hyperedge) { if (!containsEdge(hyperedge)) return false; for (V vertex : edges.get(hyperedge)) { vertices.get(vertex).remove(hyperedge); } edges.remove(hyperedge); return true; } public boolean isNeighbor(V v1, V v2) { if (!containsVertex(v1) || !containsVertex(v2)) return false; if (vertices.get(v2).isEmpty()) return false; for (H hyperedge : vertices.get(v1)) { if (edges.get(hyperedge).contains(v2)) return true; } return false; } public boolean isIncident(V vertex, H edge) { if (!containsVertex(vertex) || !containsEdge(edge)) return false; return vertices.get(vertex).contains(edge); } public int degree(V vertex) { if (!containsVertex(vertex)) return 0; return vertices.get(vertex).size(); } public int getNeighborCount(V vertex) { if (!containsVertex(vertex)) return 0; return getNeighbors(vertex).size(); } public int getIncidentCount(H edge) { if (!containsEdge(edge)) return 0; return edges.get(edge).size(); } public int getEdgeCount(EdgeType edge_type) { if (edge_type == EdgeType.UNDIRECTED) return edges.size(); return 0; } public Collection<H> getEdges(EdgeType edge_type) { if (edge_type == EdgeType.UNDIRECTED) return edges.keySet(); return null; } public EdgeType getDefaultEdgeType() { return EdgeType.UNDIRECTED; } public Collection<H> getInEdges(V vertex) { return getIncidentEdges(vertex); } public Collection<H> getOutEdges(V vertex) { return getIncidentEdges(vertex); } public int inDegree(V vertex) { return degree(vertex); } public int outDegree(V vertex) { return degree(vertex); } public V getDest(H directed_edge) { return null; } public V getSource(H directed_edge) { return null; } public Collection<V> getPredecessors(V vertex) { return getNeighbors(vertex); } public Collection<V> getSuccessors(V vertex) { return getNeighbors(vertex); } }