Java tutorial
/* * Created on June 16, 2008 * * Copyright (c) 2008, The JUNG Authors * * All rights reserved. * * This software is open-source under the BSD license; see either * "license.txt" or * https://github.com/jrtom/jung/blob/master/LICENSE for a description. */ package edu.uci.ics.jung.io; import java.io.BufferedWriter; import java.io.IOException; import java.io.Writer; import java.util.Collection; import java.util.Collections; import java.util.HashMap; import java.util.Map; import com.google.common.base.Function; import com.google.common.base.Functions; import edu.uci.ics.jung.graph.Graph; import edu.uci.ics.jung.graph.Hypergraph; import edu.uci.ics.jung.graph.UndirectedGraph; import edu.uci.ics.jung.graph.util.EdgeType; import edu.uci.ics.jung.graph.util.Pair; /** * Writes graphs out in GraphML format. * * Current known issues: * <ul> * <li>Only supports one graph per output file. * <li>Does not indent lines for text-format readability. * </ul> * */ public class GraphMLWriter<V, E> { protected Function<? super V, String> vertex_ids; protected Function<? super E, String> edge_ids; protected Map<String, GraphMLMetadata<Hypergraph<V, E>>> graph_data; protected Map<String, GraphMLMetadata<V>> vertex_data; protected Map<String, GraphMLMetadata<E>> edge_data; protected Function<? super V, String> vertex_desc; protected Function<? super E, String> edge_desc; protected Function<? super Hypergraph<V, E>, String> graph_desc; protected boolean directed; protected int nest_level; public GraphMLWriter() { vertex_ids = new Function<V, String>() { public String apply(V v) { return v.toString(); } }; edge_ids = Functions.constant(null); graph_data = Collections.emptyMap(); vertex_data = Collections.emptyMap(); edge_data = Collections.emptyMap(); vertex_desc = Functions.constant(null); edge_desc = Functions.constant(null); graph_desc = Functions.constant(null); nest_level = 0; } /** * Writes {@code graph} out using {@code w}. * @param graph the graph to write out * @param w the writer instance to which the graph data will be written out * @throws IOException if writing the graph fails */ public void save(Hypergraph<V, E> graph, Writer w) throws IOException { BufferedWriter bw = new BufferedWriter(w); // write out boilerplate header bw.write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"); bw.write("<graphml xmlns=\"http://graphml.graphdrawing.org/xmlns/graphml\"\n" + "xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" \n"); bw.write("xsi:schemaLocation=\"http://graphml.graphdrawing.org/xmlns/graphml\">\n"); // write out data specifiers, including defaults for (String key : graph_data.keySet()) writeKeySpecification(key, "graph", graph_data.get(key), bw); for (String key : vertex_data.keySet()) writeKeySpecification(key, "node", vertex_data.get(key), bw); for (String key : edge_data.keySet()) writeKeySpecification(key, "edge", edge_data.get(key), bw); // write out graph-level information // set edge default direction bw.write("<graph edgedefault=\""); directed = !(graph instanceof UndirectedGraph); if (directed) bw.write("directed\">\n"); else bw.write("undirected\">\n"); // write graph description, if any String desc = graph_desc.apply(graph); if (desc != null) bw.write("<desc>" + desc + "</desc>\n"); // write graph data out if any for (String key : graph_data.keySet()) { Function<Hypergraph<V, E>, ?> t = graph_data.get(key).transformer; Object value = t.apply(graph); if (value != null) bw.write(format("data", "key", key, value.toString()) + "\n"); } // write vertex information writeVertexData(graph, bw); // write edge information writeEdgeData(graph, bw); // close graph bw.write("</graph>\n"); bw.write("</graphml>\n"); bw.flush(); bw.close(); } // public boolean save(Collection<Hypergraph<V,E>> graphs, Writer w) // { // return true; // } protected void writeIndentedText(BufferedWriter w, String to_write) throws IOException { for (int i = 0; i < nest_level; i++) w.write(" "); w.write(to_write); } protected void writeVertexData(Hypergraph<V, E> graph, BufferedWriter w) throws IOException { for (V v : graph.getVertices()) { String v_string = String.format("<node id=\"%s\"", vertex_ids.apply(v)); boolean closed = false; // write description out if any String desc = vertex_desc.apply(v); if (desc != null) { w.write(v_string + ">\n"); closed = true; w.write("<desc>" + desc + "</desc>\n"); } // write data out if any for (String key : vertex_data.keySet()) { Function<V, ?> t = vertex_data.get(key).transformer; if (t != null) { Object value = t.apply(v); if (value != null) { if (!closed) { w.write(v_string + ">\n"); closed = true; } w.write(format("data", "key", key, value.toString()) + "\n"); } } } if (!closed) w.write(v_string + "/>\n"); // no contents; close the node with "/>" else w.write("</node>\n"); } } protected void writeEdgeData(Hypergraph<V, E> g, Writer w) throws IOException { for (E e : g.getEdges()) { Collection<V> vertices = g.getIncidentVertices(e); String id = edge_ids.apply(e); String e_string; boolean is_hyperedge = !(g instanceof Graph); if (is_hyperedge) { e_string = "<hyperedge "; // add ID if present if (id != null) e_string += "id=\"" + id + "\" "; } else { Pair<V> endpoints = new Pair<V>(vertices); V v1 = endpoints.getFirst(); V v2 = endpoints.getSecond(); e_string = "<edge "; // add ID if present if (id != null) e_string += "id=\"" + id + "\" "; // add edge type if doesn't match default EdgeType edge_type = g.getEdgeType(e); if (directed && edge_type == EdgeType.UNDIRECTED) e_string += "directed=\"false\" "; if (!directed && edge_type == EdgeType.DIRECTED) e_string += "directed=\"true\" "; e_string += "source=\"" + vertex_ids.apply(v1) + "\" target=\"" + vertex_ids.apply(v2) + "\""; } boolean closed = false; // write description out if any String desc = edge_desc.apply(e); if (desc != null) { w.write(e_string + ">\n"); closed = true; w.write("<desc>" + desc + "</desc>\n"); } // write data out if any for (String key : edge_data.keySet()) { Function<E, ?> t = edge_data.get(key).transformer; Object value = t.apply(e); if (value != null) { if (!closed) { w.write(e_string + ">\n"); closed = true; } w.write(format("data", "key", key, value.toString()) + "\n"); } } // if this is a hyperedge, write endpoints out if any if (is_hyperedge) { for (V v : vertices) { if (!closed) { w.write(e_string + ">\n"); closed = true; } w.write("<endpoint node=\"" + vertex_ids.apply(v) + "\"/>\n"); } } if (!closed) w.write(e_string + "/>\n"); // no contents; close the edge with "/>" else if (is_hyperedge) w.write("</hyperedge>\n"); else w.write("</edge>\n"); } } protected void writeKeySpecification(String key, String type, GraphMLMetadata<?> ds, BufferedWriter bw) throws IOException { bw.write("<key id=\"" + key + "\" for=\"" + type + "\""); boolean closed = false; // write out description if any String desc = ds.description; if (desc != null) { if (!closed) { bw.write(">\n"); closed = true; } bw.write("<desc>" + desc + "</desc>\n"); } // write out default if any Object def = ds.default_value; if (def != null) { if (!closed) { bw.write(">\n"); closed = true; } bw.write("<default>" + def.toString() + "</default>\n"); } if (!closed) bw.write("/>\n"); else bw.write("</key>\n"); } protected String format(String type, String attr, String value, String contents) { return String.format("<%s %s=\"%s\">%s</%s>", type, attr, value, contents, type); } /** * Provides an ID that will be used to identify a vertex in the output file. * If the vertex IDs are not set, the ID for each vertex will default to * the output of <code>toString</code> * (and thus not guaranteed to be unique). * * @param vertex_ids a mapping from vertex to ID */ public void setVertexIDs(Function<V, String> vertex_ids) { this.vertex_ids = vertex_ids; } /** * Provides an ID that will be used to identify an edge in the output file. * If any edge ID is missing, no ID will be written out for the * corresponding edge. * * @param edge_ids a mapping from edge to ID */ public void setEdgeIDs(Function<E, String> edge_ids) { this.edge_ids = edge_ids; } /** * Provides a map from data type name to graph data. * * @param graph_map map from data type name to graph data */ public void setGraphData(Map<String, GraphMLMetadata<Hypergraph<V, E>>> graph_map) { graph_data = graph_map; } /** * Provides a map from data type name to vertex data. * * @param vertex_map map from data type name to vertex data */ public void setVertexData(Map<String, GraphMLMetadata<V>> vertex_map) { vertex_data = vertex_map; } /** * Provides a map from data type name to edge data. * * @param edge_map map from data type name to edge data */ public void setEdgeData(Map<String, GraphMLMetadata<E>> edge_map) { edge_data = edge_map; } /** * Adds a new graph data specification. * * @param id the ID of the data to add * @param description a description of the data to add * @param default_value a default value for the data type * @param graph_transformer a mapping from graphs to their string representations */ public void addGraphData(String id, String description, String default_value, Function<Hypergraph<V, E>, String> graph_transformer) { if (graph_data.equals(Collections.EMPTY_MAP)) graph_data = new HashMap<String, GraphMLMetadata<Hypergraph<V, E>>>(); graph_data.put(id, new GraphMLMetadata<Hypergraph<V, E>>(description, default_value, graph_transformer)); } /** * Adds a new vertex data specification. * * @param id the ID of the data to add * @param description a description of the data to add * @param default_value a default value for the data type * @param vertex_transformer a mapping from vertices to their string representations */ public void addVertexData(String id, String description, String default_value, Function<V, String> vertex_transformer) { if (vertex_data.equals(Collections.EMPTY_MAP)) vertex_data = new HashMap<String, GraphMLMetadata<V>>(); vertex_data.put(id, new GraphMLMetadata<V>(description, default_value, vertex_transformer)); } /** * Adds a new edge data specification. * * @param id the ID of the data to add * @param description a description of the data to add * @param default_value a default value for the data type * @param edge_transformer a mapping from edges to their string representations */ public void addEdgeData(String id, String description, String default_value, Function<E, String> edge_transformer) { if (edge_data.equals(Collections.EMPTY_MAP)) edge_data = new HashMap<String, GraphMLMetadata<E>>(); edge_data.put(id, new GraphMLMetadata<E>(description, default_value, edge_transformer)); } /** * Provides vertex descriptions. * @param vertex_desc a mapping from vertices to their descriptions */ public void setVertexDescriptions(Function<V, String> vertex_desc) { this.vertex_desc = vertex_desc; } /** * Provides edge descriptions. * @param edge_desc a mapping from edges to their descriptions */ public void setEdgeDescriptions(Function<E, String> edge_desc) { this.edge_desc = edge_desc; } /** * Provides graph descriptions. * @param graph_desc a mapping from graphs to their descriptions */ public void setGraphDescriptions(Function<Hypergraph<V, E>, String> graph_desc) { this.graph_desc = graph_desc; } }