Line | Hits | Source |
---|---|---|
1 | /* | |
2 | * Copyright (c) 2003, the JUNG Project and the Regents of the University of | |
3 | * California All rights reserved. | |
4 | * | |
5 | * This software is open-source under the BSD license; see either "license.txt" | |
6 | * or http://jung.sourceforge.net/license.txt for a description. | |
7 | */ | |
8 | /* | |
9 | * Created on Jun 25, 2003 | |
10 | */ | |
11 | package edu.uci.ics.jung.utils; | |
12 | ||
13 | import java.util.Collection; | |
14 | import java.util.HashSet; | |
15 | import java.util.Iterator; | |
16 | import java.util.LinkedList; | |
17 | import java.util.Map; | |
18 | import java.util.Set; | |
19 | ||
20 | import org.apache.commons.collections.CollectionUtils; | |
21 | ||
22 | import cern.colt.list.DoubleArrayList; | |
23 | import edu.uci.ics.jung.algorithms.transformation.DirectionTransformer; | |
24 | import edu.uci.ics.jung.graph.ArchetypeEdge; | |
25 | import edu.uci.ics.jung.graph.ArchetypeGraph; | |
26 | import edu.uci.ics.jung.graph.ArchetypeVertex; | |
27 | import edu.uci.ics.jung.graph.DirectedGraph; | |
28 | import edu.uci.ics.jung.graph.Edge; | |
29 | import edu.uci.ics.jung.graph.Graph; | |
30 | import edu.uci.ics.jung.graph.Hyperedge; | |
31 | import edu.uci.ics.jung.graph.Hypergraph; | |
32 | import edu.uci.ics.jung.graph.Hypervertex; | |
33 | import edu.uci.ics.jung.graph.UndirectedGraph; | |
34 | import edu.uci.ics.jung.graph.Vertex; | |
35 | import edu.uci.ics.jung.graph.decorators.Indexer; | |
36 | import edu.uci.ics.jung.graph.decorators.NumberVertexValue; | |
37 | import edu.uci.ics.jung.graph.decorators.StringLabeller; | |
38 | import edu.uci.ics.jung.graph.decorators.StringLabeller.UniqueLabelException; | |
39 | import edu.uci.ics.jung.graph.filters.UnassembledGraph; | |
40 | import edu.uci.ics.jung.graph.filters.impl.DropSoloNodesFilter; | |
41 | import edu.uci.ics.jung.graph.impl.AbstractSparseEdge; | |
42 | import edu.uci.ics.jung.graph.impl.DirectedSparseEdge; | |
43 | import edu.uci.ics.jung.graph.impl.DirectedSparseVertex; | |
44 | import edu.uci.ics.jung.graph.impl.SparseVertex; | |
45 | import edu.uci.ics.jung.graph.impl.UndirectedSparseEdge; | |
46 | import edu.uci.ics.jung.graph.impl.UndirectedSparseVertex; | |
47 | ||
48 | /** | |
49 | * | |
50 | * A series of helpful utility methods. All methods in GraphUtils can be | |
51 | * accomplished with public members of other code; these are simply | |
52 | * combinations that we found useful. | |
53 | * | |
54 | * @author Danyel Fisher, Scott White, Joshua O'Madadhain | |
55 | */ | |
56 | 0 | public class GraphUtils |
57 | { | |
58 | ||
59 | /** | |
60 | * Adds an appropriate edge between two vertices. Specifically, this method | |
61 | * confirms that both vertices are from the same graph, and then checks | |
62 | * whether the Graph is directed or not. If | |
63 | * so, it creates a new | |
64 | * {@link edu.uci.ics.jung.graph.impl.DirectedSparseEdge DirectedSparseEdge}, | |
65 | * otherwise a new | |
66 | * {@link edu.uci.ics.jung.graph.impl.UndirectedSparseEdge UndirectedSparseEdge}. | |
67 | * This is a convenience method; one might instead just call <code> g.addEdge( new XXSparseEdge(v1, v2))) </code>. | |
68 | * <p> | |
69 | * The input vertices must be of type {@link edu.uci.ics.jung.graph.Vertex}, | |
70 | * or the method will throw a <code>ClassCastException</code>. | |
71 | * | |
72 | * @throws ClassCastException | |
73 | * if the input aren't Vertices | |
74 | * @throws IllegalArgumentException | |
75 | * if the vertices don't belong to the same graph | |
76 | * | |
77 | * @return the edge that was added | |
78 | * | |
79 | * @see edu.uci.ics.jung.graph.Graph#addEdge | |
80 | * @see edu.uci.ics.jung.graph.impl.AbstractSparseGraph#addEdge | |
81 | */ | |
82 | public static Edge addEdge(Graph g, Vertex v1, Vertex v2) | |
83 | { | |
84 | 135547 | if (v1.getGraph() != g || v2.getGraph() != g) |
85 | 1 | throw new IllegalArgumentException("Vertices not in this graph!"); |
86 | 135546 | if (PredicateUtils.enforcesEdgeConstraint(g, Graph.DIRECTED_EDGE)) |
87 | { | |
88 | 2734 | return (AbstractSparseEdge) g.addEdge( |
89 | new DirectedSparseEdge(v1, v2)); | |
90 | } | |
91 | 132812 | else if (PredicateUtils.enforcesEdgeConstraint(g, Graph.UNDIRECTED_EDGE)) |
92 | { | |
93 | 132812 | return (AbstractSparseEdge) g.addEdge( |
94 | new UndirectedSparseEdge(v1, v2)); | |
95 | } | |
96 | else | |
97 | 0 | throw new IllegalArgumentException("Behavior not specified " + |
98 | "for mixed (directed/undirected) graphs"); | |
99 | } | |
100 | ||
101 | /** | |
102 | * Adds <code>count</code> vertices into a graph. This is a convenience | |
103 | * method; one might instead just call <code> g.addVertex( new SparseVertex())) </code> | |
104 | * <code>count</code> | |
105 | * times. | |
106 | * <p> | |
107 | * The input graph must be one that can accept a series of | |
108 | * {@link edu.uci.ics.jung.graph.impl.SparseVertex directed vertices}. | |
109 | * | |
110 | * @param g | |
111 | * A graph to add the vertices to | |
112 | * @param count | |
113 | * how many vertices to add | |
114 | * | |
115 | * @see edu.uci.ics.jung.graph.impl.AbstractSparseGraph#addVertex | |
116 | */ | |
117 | public static void addVertices(Graph g, int count) | |
118 | { | |
119 | 30907 | for (int i = 0; i < count; i++) |
120 | 30609 | g.addVertex(new SparseVertex()); |
121 | 298 | } |
122 | ||
123 | /** | |
124 | * Adds <code>count</code> directed vertices into a graph. This is a | |
125 | * convenience method; one might instead just call <code> g.addVertex( new DirectedSparseVertex())) </code> | |
126 | * <code>count</code> | |
127 | * times. | |
128 | * <p> | |
129 | * The input graph must be one that can accept a series of | |
130 | * {@link edu.uci.ics.jung.graph.impl.DirectedSparseVertex directed vertices}. | |
131 | * | |
132 | * @param g | |
133 | * A graph to add the vertices to | |
134 | * @param count | |
135 | * how many vertices to add | |
136 | * | |
137 | * @see edu.uci.ics.jung.graph.impl.AbstractSparseGraph#addVertex | |
138 | * @deprecated As of version 1.2, replaced by {@link #addVertices}. | |
139 | */ | |
140 | public static void addDirectedVertices(Graph g, int count) | |
141 | { | |
142 | 0 | for (int i = 0; i < count; i++) |
143 | { | |
144 | 0 | g.addVertex(new DirectedSparseVertex()); |
145 | } | |
146 | 0 | } |
147 | ||
148 | /** | |
149 | * Adds <code>count</code> undirected vertices into a graph. This is a | |
150 | * convenience method; one might instead just call <code> g.addVertex( new UndirectedSparseVertex())) </code> | |
151 | * <code>count</code> | |
152 | * times. | |
153 | * <p> | |
154 | * The input graph must be one that can accept a series of | |
155 | * {@link edu.uci.ics.jung.graph.impl.UndirectedSparseVertex undirected vertices}. | |
156 | * | |
157 | * @param g | |
158 | * A graph to add the vertices to | |
159 | * @param count | |
160 | * how many vertices to add | |
161 | * | |
162 | * @see edu.uci.ics.jung.graph.impl.AbstractSparseGraph#addVertex | |
163 | * @deprecated As of version 1.2, replaced by {@link #addVertices}. | |
164 | */ | |
165 | public static void addUndirectedVertices(Graph g, int count) | |
166 | { | |
167 | 0 | for (int i = 0; i < count; i++) |
168 | { | |
169 | 0 | g.addVertex(new UndirectedSparseVertex()); |
170 | } | |
171 | 0 | } |
172 | ||
173 | /** | |
174 | * Translates every vertex from the input <code>set</code> into the graph | |
175 | * given. For each vertex, then, it gets the equivalent vertex in <code>g</code>, | |
176 | * and returns the collated set. | |
177 | * | |
178 | * @param s | |
179 | * The set of input vertices, not from g | |
180 | * @param g | |
181 | * The graph which has the corresponding vertices | |
182 | * | |
183 | * @return a resulting set | |
184 | * | |
185 | * @see edu.uci.ics.jung.graph.ArchetypeVertex#getEqualVertex | |
186 | * @deprecated As of version 1.4, replaced by {@link GraphUtils#getEqualVertices(Set, ArchetypeGraph)} | |
187 | */ | |
188 | public static Set translateAll(Set s, Graph g) | |
189 | { | |
190 | 0 | return getEqualVertices(s, g); |
191 | } | |
192 | ||
193 | /** | |
194 | * Returns the set of vertices in <code>g</code> which are equal | |
195 | * to the vertices in <code>g</code>. | |
196 | * @since 1.4 | |
197 | */ | |
198 | public static Set getEqualVertices(Set s, ArchetypeGraph g) | |
199 | { | |
200 | 6 | Set rv = new HashSet(); |
201 | 6 | for (Iterator iter = s.iterator(); iter.hasNext();) |
202 | { | |
203 | 58 | ArchetypeVertex v = (ArchetypeVertex) iter.next(); |
204 | 58 | ArchetypeVertex v_g = v.getEqualVertex(g); |
205 | 58 | if (v_g != null) |
206 | 54 | rv.add(v_g); |
207 | } | |
208 | 6 | return rv; |
209 | } | |
210 | ||
211 | /** | |
212 | * Translates every edge from the input <code>set</code> into the graph | |
213 | * given. For each edge, then, it gets the equivalent edge in <code>g</code>, | |
214 | * and returns the collated set. | |
215 | * | |
216 | * @param s | |
217 | * The set of input edges, not from g | |
218 | * @param g | |
219 | * The graph which has the corresponding edges | |
220 | * | |
221 | * @return a resulting set | |
222 | * | |
223 | * @see edu.uci.ics.jung.graph.ArchetypeEdge#getEqualEdge | |
224 | * @deprecated As of version 1.4, replaced by {@link GraphUtils#getEqualEdges(Set, ArchetypeGraph)} | |
225 | */ | |
226 | public static Set translateAllEdges(Set s, Graph g) | |
227 | { | |
228 | 0 | return getEqualEdges(s, g); |
229 | } | |
230 | ||
231 | /** | |
232 | * Returns the set of edges in <code>g</code> which are equal | |
233 | * to the edges in <code>g</code>. | |
234 | * @since 1.4 | |
235 | */ | |
236 | public static Set getEqualEdges(Set s, ArchetypeGraph g) | |
237 | { | |
238 | 6 | Set rv = new HashSet(); |
239 | 6 | for (Iterator iter = s.iterator(); iter.hasNext();) |
240 | { | |
241 | 266 | ArchetypeEdge e = (ArchetypeEdge) iter.next(); |
242 | 266 | ArchetypeEdge e_g = e.getEqualEdge(g); |
243 | 266 | if (e_g != null) |
244 | 262 | rv.add(e_g); |
245 | } | |
246 | 6 | return rv; |
247 | } | |
248 | ||
249 | /** | |
250 | * Given a set of vertices, creates a new <tt>Graph</tt> that contains | |
251 | * all of those vertices, and all the edges that connect them. Uses the | |
252 | * <tt>{@link edu.uci.ics.jung.graph.filters.UnassembledGraph UnassembledGraph}</tt> | |
253 | * mechanism to create the graph. | |
254 | * | |
255 | * @param s | |
256 | * A set of <tt>Vertex</tt> s that want to be a part of a new | |
257 | * Graph | |
258 | * @return A graph, created with <tt>{@link edu.uci.ics.jung.graph.Graph#newInstance Graph.newInstance}</tt>, | |
259 | * containing vertices equivalent to (and that are copies of!) all | |
260 | * the vertices in the input set. Note that if the input is an | |
261 | * empty set, <tt>null</tt> is returned. | |
262 | */ | |
263 | public static Graph vertexSetToGraph(Set s) | |
264 | { | |
265 | 0 | if (s.isEmpty()) |
266 | 0 | return null; |
267 | 0 | Vertex v = (Vertex) s.iterator().next(); |
268 | 0 | Graph g = (Graph) v.getGraph(); |
269 | 0 | return new UnassembledGraph("vertexSetToGraph", s, g.getEdges(), g) |
270 | .assemble(); | |
271 | } | |
272 | ||
273 | /** | |
274 | * Given a set of edges, creates a new <tt>Graph</tt> that contains all | |
275 | * of those edges, and at least all the vertices that are attached to them. | |
276 | * Uses <tt>{@link edu.uci.ics.jung.graph.filters.UnassembledGraph UnassembledGraph}</tt> | |
277 | * mechanism to create the graph. The parameter decides what to do with | |
278 | * disconnected vertices: <tt>true</tt> says that they should be | |
279 | * retained, <tt>false</tt> says that they should be discarded (with a | |
280 | * {@link edu.uci.ics.jung.graph.filters.impl.DropSoloNodesFilter DropSoloNodesFilter}). | |
281 | * | |
282 | * @param edges | |
283 | * A set of <tt>Edge</tt> s that want to be a part of a new | |
284 | * <tt>Graph</tt> | |
285 | * @param retain | |
286 | * Is true if all isolated vertices should be retained; is false if they | |
287 | * should be discarded. | |
288 | * @return A graph, created with <tt>{@link edu.uci.ics.jung.graph.Graph#newInstance Graph.newInstance}</tt>, | |
289 | * containing edges equivalent to (and that are copies of!) all the | |
290 | * edges in the input set. Note that if the input is an empty set, | |
291 | * <tt>null</tt> is returned. | |
292 | */ | |
293 | public static Graph edgeSetToGraph(Set edges, boolean retain) | |
294 | { | |
295 | 0 | if (edges.isEmpty()) |
296 | 0 | return null; |
297 | 0 | Edge e = (Edge) edges.iterator().next(); |
298 | 0 | Graph g = (Graph) e.getGraph(); |
299 | 0 | Graph retval = |
300 | new UnassembledGraph("edgeSetToGraph", g.getVertices(), edges, g) | |
301 | .assemble(); | |
302 | 0 | if (retain) |
303 | 0 | return retval; |
304 | else | |
305 | { | |
306 | 0 | return DropSoloNodesFilter.getInstance().filter(retval).assemble(); |
307 | } | |
308 | } | |
309 | ||
310 | /** | |
311 | * Returns a graph which consists of the union of the two input graphs. | |
312 | * Assumes that both graphs are of a type that can accept the vertices | |
313 | * and edges found in both graphs. | |
314 | * The resultant graph contains all constraints that are common to both graphs. | |
315 | */ | |
316 | public static ArchetypeGraph union(ArchetypeGraph g1, ArchetypeGraph g2) | |
317 | { | |
318 | 0 | ArchetypeGraph g = g1.newInstance(); |
319 | // g.getEdgeConstraints().clear(); | |
320 | 0 | g.getEdgeConstraints().addAll(CollectionUtils.intersection( |
321 | g1.getEdgeConstraints(), g2.getEdgeConstraints())); | |
322 | ||
323 | 0 | Collection vertices = CollectionUtils.union(g1.getVertices(), g2.getVertices()); |
324 | 0 | Collection edges = CollectionUtils.union(g1.getEdges(), g2.getEdges()); |
325 | ||
326 | 0 | for (Iterator v_iter = vertices.iterator(); v_iter.hasNext(); ) |
327 | { | |
328 | 0 | ArchetypeVertex v = (ArchetypeVertex)v_iter.next(); |
329 | 0 | v.copy(g); |
330 | } | |
331 | ||
332 | 0 | for (Iterator e_iter = edges.iterator(); e_iter.hasNext(); ) |
333 | { | |
334 | 0 | ArchetypeEdge e = (ArchetypeEdge)e_iter.next(); |
335 | 0 | e.copy(g); |
336 | } | |
337 | 0 | return g; |
338 | } | |
339 | ||
340 | /** | |
341 | * Transforms an (possibly undirected) graph into a directed graph. All user data on | |
342 | * the graph,edges & vertices are copied to their corresponding | |
343 | * counterparts. Returns a new graph with a directed edge from a to b iff a | |
344 | * was a predecessor of b in the original. For an undirected edge, this will create | |
345 | * two new edges. | |
346 | * | |
347 | * @param uGraph | |
348 | * the undirected graph to transform | |
349 | * @return the resultant directed graph | |
350 | * @deprecated As of version 1.4, replaced by | |
351 | * {@link edu.uci.ics.jung.algorithms.transformation.DirectionTransformer#toDirected(Graph)} | |
352 | */ | |
353 | public static DirectedGraph transform(Graph uGraph) | |
354 | { | |
355 | 0 | return DirectionTransformer.toDirected(uGraph); |
356 | } | |
357 | ||
358 | /** | |
359 | * Transforms a directed graph into a undirected graph. All user data on | |
360 | * the graph,edges & vertices are copied to their corresponding | |
361 | * counterparts. | |
362 | * | |
363 | * @param dGraph | |
364 | * the directed graph to transform | |
365 | * @return the resultant undirected graph | |
366 | * @deprecated As of version 1.4, replaced by | |
367 | * {@link edu.uci.ics.jung.algorithms.transformation.DirectionTransformer#toUndirected(Graph)} | |
368 | */ | |
369 | public static UndirectedGraph transform(DirectedGraph dGraph) | |
370 | { | |
371 | 0 | return DirectionTransformer.toUndirected(dGraph); |
372 | } | |
373 | ||
374 | /** | |
375 | * Copies the labels of vertices from one StringLabeller to another. Only | |
376 | * the labels of vertices that are equivalent are copied. | |
377 | * | |
378 | * @param source | |
379 | * the source StringLabeller | |
380 | * @param target | |
381 | * the target StringLabeller | |
382 | */ | |
383 | public static void copyLabels(StringLabeller source, StringLabeller target) | |
384 | throws UniqueLabelException | |
385 | { | |
386 | 1 | Graph g1 = source.getGraph(); |
387 | 1 | Graph g2 = target.getGraph(); |
388 | 1 | Set s1 = g1.getVertices(); |
389 | 1 | Set s2 = g2.getVertices(); |
390 | ||
391 | 1 | for (Iterator iter = s1.iterator(); iter.hasNext();) |
392 | { | |
393 | 5 | Vertex v = (Vertex) iter.next(); |
394 | 5 | if (s2.contains(v)) |
395 | { | |
396 | 4 | target.setLabel( |
397 | (Vertex) v.getEqualVertex(g2), | |
398 | source.getLabel(v)); | |
399 | } | |
400 | } | |
401 | 1 | } |
402 | ||
403 | /** | |
404 | * Returns true if <code>g1</code> and <code>g2</code> have equivalent | |
405 | * vertex and edge sets (that is, if each vertex and edge in <code>g1</code> | |
406 | * has an equivalent in <code>g2</code>, and vice versa), and false | |
407 | * otherwise. | |
408 | */ | |
409 | public static boolean areEquivalent(ArchetypeGraph g1, ArchetypeGraph g2) | |
410 | { | |
411 | 4 | return ( |
412 | (g1 == g2) | |
413 | || (g1.getVertices().equals(g2.getVertices()) | |
414 | && g1.getEdges().equals(g2.getEdges()))); | |
415 | } | |
416 | ||
417 | /** | |
418 | * For every vertex in s, prints sl.get(s). S must be made up of only | |
419 | * vertices. | |
420 | * | |
421 | * @param s | |
422 | * @param sl | |
423 | */ | |
424 | public static String printVertices(Collection s, StringLabeller sl) | |
425 | { | |
426 | 0 | StringBuffer sb = new StringBuffer(); |
427 | 0 | boolean first = true; |
428 | 0 | sb.append("["); |
429 | 0 | for (Iterator iter = s.iterator(); iter.hasNext();) |
430 | { | |
431 | 0 | Vertex v = (Vertex) iter.next(); |
432 | 0 | if (!first) |
433 | 0 | sb.append(", "); |
434 | else | |
435 | 0 | first = false; |
436 | 0 | sb.append( sl.getLabel(v) ); |
437 | ||
438 | } | |
439 | 0 | sb.append("]"); |
440 | 0 | return sb.toString(); |
441 | } | |
442 | ||
443 | ||
444 | /** | |
445 | * Copies, for each vertex <code>v</code> in <code>g</code>, | |
446 | * <code>source</code>'s value to <code>dest</code>. | |
447 | * @param g the graph from which the vertices are taken | |
448 | * @param source the <code>NumberVertexValue</code> from which values are to be copied | |
449 | * @param dest the <code>NumberVertexValue</code> into which values are to be copied | |
450 | */ | |
451 | public static void copyValues(ArchetypeGraph g, NumberVertexValue source, NumberVertexValue dest) | |
452 | { | |
453 | 0 | for (Iterator iter = g.getVertices().iterator(); iter.hasNext(); ) |
454 | { | |
455 | 0 | ArchetypeVertex v = (ArchetypeVertex)iter.next(); |
456 | 0 | dest.setNumber(v, source.getNumber(v)); |
457 | } | |
458 | 0 | } |
459 | ||
460 | /** | |
461 | * Returns the <code>VertexGenerator</code>, if any, stored in <code>g</code>'s | |
462 | * user data at the standardized location specified by the VG interface: <code>VertexGenerator.TAG</code>. | |
463 | */ | |
464 | public static VertexGenerator getVertexGenerator(ArchetypeGraph g) | |
465 | { | |
466 | 0 | return (VertexGenerator)g.getUserDatum(VertexGenerator.TAG); |
467 | } | |
468 | ||
469 | /** | |
470 | * Converts <code>vertex_values</code> (a Map of vertex to Number values) | |
471 | * to a DoubleArrayList, using <code>indexer</code> to determine the location | |
472 | * of each vertex's value in the DAL. | |
473 | * @param vertex_values | |
474 | * @param indexer | |
475 | * @return | |
476 | */ | |
477 | public static DoubleArrayList vertexMapToDAL(Map vertex_values, Indexer indexer) | |
478 | { | |
479 | 0 | DoubleArrayList dal = new DoubleArrayList(vertex_values.size()); |
480 | ||
481 | 0 | for (Iterator iter = vertex_values.keySet().iterator(); iter.hasNext(); ) |
482 | { | |
483 | 0 | ArchetypeVertex av = (ArchetypeVertex)iter.next(); |
484 | 0 | double value = ((Number)vertex_values.get(av)).doubleValue(); |
485 | 0 | dal.set(indexer.getIndex(av), value); |
486 | } | |
487 | ||
488 | 0 | return dal; |
489 | } | |
490 | ||
491 | /** | |
492 | * Adds all vertices in the specified set to <code>g</code>. Syntactic | |
493 | * sugar for a loop that calls <code>g.addVertex</code> on all elements | |
494 | * of the set. | |
495 | * If any element of <code>vertices</code> may not be legally added | |
496 | * to this graph, throws an exception: <code>ClassCastException</code> if | |
497 | * the type is inappropriate, and <code>IllegalArgumentException</code> | |
498 | * otherwise. If an exception is thrown, any vertices that may | |
499 | * already have been added are not guaranteed to be retained. | |
500 | */ | |
501 | public static void addVertices(Graph g, Set vertices) | |
502 | { | |
503 | 0 | for (Iterator iter = vertices.iterator(); iter.hasNext(); ) |
504 | 0 | g.addVertex((Vertex)iter.next()); |
505 | 0 | } |
506 | ||
507 | /** | |
508 | * Adds all vertices in the specified set to <code>g</code>. Syntactic | |
509 | * sugar for a loop that calls <code>g.addVertex</code> on all elements | |
510 | * of the set. | |
511 | * If any element of <code>vertices</code> may not be legally added | |
512 | * to this graph, throws an exception: <code>ClassCastException</code> if | |
513 | * the type is inappropriate, and <code>IllegalArgumentException</code> | |
514 | * otherwise. If an exception is thrown, any vertices that may | |
515 | * already have been added are not guaranteed to be retained. | |
516 | */ | |
517 | public static void addVertices(Hypergraph g, Set vertices) | |
518 | { | |
519 | 0 | for (Iterator iter = vertices.iterator(); iter.hasNext(); ) |
520 | 0 | g.addVertex((Hypervertex)iter.next()); |
521 | 0 | } |
522 | ||
523 | /** | |
524 | * Adds all edges in the specified set to <code>g</code>. Syntactic | |
525 | * sugar for a loop that calls <code>g.addEdge</code> on all elements | |
526 | * of the set. | |
527 | * If any element of <code>edges</code> may not be legally added | |
528 | * to this graph, throws an exception: <code>ClassCastException</code> if | |
529 | * the type is inappropriate, and <code>IllegalArgumentException</code> | |
530 | * otherwise. If an exception is thrown, any edges that may | |
531 | * already have been added are not guaranteed to be retained. | |
532 | */ | |
533 | public static void addEdges(Graph g, Set edges) | |
534 | { | |
535 | 0 | for (Iterator iter = edges.iterator(); iter.hasNext(); ) |
536 | 0 | g.addEdge((Edge)iter.next()); |
537 | 0 | } |
538 | ||
539 | /** | |
540 | * Adds all edges in the specified set to <code>g</code>. Syntactic | |
541 | * sugar for a loop that calls <code>g.addEdge</code> on all elements | |
542 | * of the set. | |
543 | * If any element of <code>edges</code> may not be legally added | |
544 | * to this graph, throws an exception: <code>ClassCastException</code> if | |
545 | * the type is inappropriate, and <code>IllegalArgumentException</code> | |
546 | * otherwise. If an exception is thrown, any edges that may | |
547 | * already have been added are not guaranteed to be retained. | |
548 | */ | |
549 | public static void addEdges(Hypergraph g, Set edges) | |
550 | { | |
551 | 0 | for (Iterator iter = edges.iterator(); iter.hasNext(); ) |
552 | 0 | g.addEdge((Hyperedge)iter.next()); |
553 | 0 | } |
554 | ||
555 | /** | |
556 | * Removes all vertices in the specified set from <code>g</code>. Syntactic | |
557 | * sugar for a loop that calls <code>g.removeVertex</code> on all elements | |
558 | * of the set. | |
559 | * If any element of <code>vertices</code> is not part of this graph, | |
560 | * then throws <code>IllegalArgumentException</code>. If this | |
561 | * exception is thrown, any vertices that may have been removed already | |
562 | * are not guaranteed to be restored to the graph. | |
563 | */ | |
564 | public static void removeVertices(Graph g, Set vertices) | |
565 | { | |
566 | 21 | for (Iterator iter = new LinkedList(vertices).iterator(); iter.hasNext(); ) |
567 | 64 | g.removeVertex((Vertex)iter.next()); |
568 | 21 | } |
569 | ||
570 | /** | |
571 | * Removes all vertices in the specified set from <code>g</code>. Syntactic | |
572 | * sugar for a loop that calls <code>g.removeVertex</code> on all elements | |
573 | * of the set. | |
574 | * If any element of <code>vertices</code> is not part of this graph, | |
575 | * then throws <code>IllegalArgumentException</code>. If this | |
576 | * exception is thrown, any vertices that may have been removed already | |
577 | * are not guaranteed to be restored to the graph. | |
578 | */ | |
579 | public static void removeVertices(Hypergraph g, Set vertices) | |
580 | { | |
581 | 0 | for (Iterator iter = new LinkedList(vertices).iterator(); iter.hasNext(); ) |
582 | 0 | g.removeVertex((Hypervertex)iter.next()); |
583 | 0 | } |
584 | ||
585 | /** | |
586 | * Removes all vertices in the specified set from <code>g</code>. Syntactic | |
587 | * sugar for a loop that calls <code>g.removeVertex</code> on all elements | |
588 | * of the set. | |
589 | * If any element of <code>edges</code> is not part of this graph, | |
590 | * then throws <code>IllegalArgumentException</code>. If this | |
591 | * exception is thrown, any edges that may have been removed already | |
592 | * are not guaranteed to be restored to the graph. | |
593 | */ | |
594 | public static void removeEdges(Graph g, Set edges) | |
595 | { | |
596 | 118 | for (Iterator iter = new LinkedList(edges).iterator(); iter.hasNext(); ) |
597 | 228 | g.removeEdge((Edge)iter.next()); |
598 | 118 | } |
599 | ||
600 | /** | |
601 | * Removes all vertices in the specified set from <code>g</code>. Syntactic | |
602 | * sugar for a loop that calls <code>g.removeVertex</code> on all elements | |
603 | * of the set. | |
604 | * If any element of <code>edges</code> is not part of this graph, | |
605 | * then throws <code>IllegalArgumentException</code>. If this | |
606 | * exception is thrown, any edges that may have been removed already | |
607 | * are not guaranteed to be restored to the graph. | |
608 | */ | |
609 | public static void removeEdges(Hypergraph g, Set edges) | |
610 | { | |
611 | 0 | for (Iterator iter = new LinkedList(edges).iterator(); iter.hasNext(); ) |
612 | 0 | g.removeEdge((Hyperedge)iter.next()); |
613 | 0 | } |
614 | ||
615 | } |
this report was generated by version 1.0.5 of jcoverage. |
copyright © 2003, jcoverage ltd. all rights reserved. |