/*
* GeoTools - The Open Source Java GIS Toolkit
* http://geotools.org
*
* (C) 2002-2008, Open Source Geospatial Foundation (OSGeo)
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation;
* version 2.1 of the License.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*/
package org.geotools.graph.io.standard;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.EOFException;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Iterator;
import org.geotools.graph.build.GraphBuilder;
import org.geotools.graph.io.GraphReaderWriter;
import org.geotools.graph.structure.Edge;
import org.geotools.graph.structure.Graph;
import org.geotools.graph.structure.Node;
/**
* An implementation of GraphReaderWriter that uses java serialization to
* read and write graph objects. During the graph serialization process
* edges are written to the object output stream. Along with the edges,
* the two nodes incident to the edge are also written. However, edge adjacency
* lists of nodes are <B>not</B> written to the output stream in order to
* prevent deep recursive calls that often result in a stack overflow. Therefore
* it is important that any implementation of the Node interface declare its
* edge adjacecny list (if any) as transient in order to support graph
* serializability. <BR>
* Because edge adjacency lists are not serialized, they must be reconstructed
* upon deserialization in order to preserve the original graph structure.<BR>
*
* @author Justin Deoliveira, Refractions Research Inc, jdeolive@refractions.net
*
*
*
* @source $URL$
*/
public class SerializedReaderWriter extends AbstractReaderWriter
implements FileReaderWriter {
/**
* Deserializes the graph and reconstructs the original structure.
*
* @see GraphReaderWriter#read()
*/
public Graph read() throws Exception {
//read builder property
GraphBuilder builder = (GraphBuilder)getProperty(BUILDER);
//create file input stream
ObjectInputStream objin = new ObjectInputStream(
new BufferedInputStream(
new FileInputStream((String)getProperty(FILENAME))
)
);
//read header
int nnodes = objin.readInt();
int nedges = objin.readInt();
//rebuild edge collection, upon reading an edge, at the edge to the
// adjacency list of each of its nodes
int count = 0;
while(count++ < nedges) {
Edge e = (Edge)objin.readObject();
e.getNodeA().setVisited(false);
e.getNodeB().setVisited(false);
builder.addEdge(e);
}
//rebuild node collection
for (
Iterator itr = builder.getGraph().getEdges().iterator(); itr.hasNext();
) {
Edge e = (Edge)itr.next();
if (!e.getNodeA().isVisited()) {
e.getNodeA().setVisited(true);
builder.addNode(e.getNodeA());
}
if (!e.getNodeB().isVisited()) {
e.getNodeB().setVisited(true);
builder.addNode(e.getNodeB());
}
}
//check if object stream is empty, if not, there are nodes of degree 0
// in the graph
try {
Node n;
while((n = (Node)objin.readObject()) != null) {
builder.addNode(n);
}
}
catch(EOFException ignore) {}
return(builder.getGraph());
}
/**
* Serializes the graph by writing each edge in the graph to an object
* output stream. If there any nodes of degree 0 in the graph, then they are
* appended to the end of the object output stream.
*
* @see GraphReaderWriter#write()
*/
public void write(Graph graph) throws Exception {
//create file output stream
ObjectOutputStream objout = new ObjectOutputStream(
new BufferedOutputStream(
new FileOutputStream((String)getProperty(FILENAME))
)
);
//create header
// 1. number of nodes
// 2. number of edges
objout.writeInt(graph.getNodes().size());
objout.writeInt(graph.getEdges().size());
//write out edges (note: nodes do not write out adjacent edges)
for (Iterator itr = graph.getEdges().iterator(); itr.hasNext();) {
Edge e = (Edge)itr.next();
objout.writeObject(e);
}
//write out any nodes that have no adjacent edges
for (Iterator itr = graph.getNodesOfDegree(0).iterator(); itr.hasNext();) {
Node n = (Node)itr.next();
objout.writeObject(n);
}
objout.flush();
objout.close();
}
}