diff -r 892c29484414 -r d2d1f8fa187b src/lemon/graph_writer.h
--- a/src/lemon/graph_writer.h	Mon May 09 11:24:26 2005 +0000
+++ b/src/lemon/graph_writer.h	Wed May 11 11:50:13 2005 +0000
@@ -22,146 +22,15 @@
 #define LEMON_GRAPH_WRITER_H
 
 #include <iostream>
-#include <sstream>
 
-#include <map>
-#include <vector>
-
-#include <memory>
-
-#include <lemon/graph_utils.h>
-
-#include <lemon/invalid.h>
 #include <lemon/error.h>
-
+#include <lemon/lemon_writer.h>
 
 namespace lemon {
 
   /// \addtogroup io_group
   /// @{
 
-  /// \brief Standard WriterTraits for the GraphWriter class.
-  ///
-  /// Standard WriterTraits for the GraphWriter class.
-  /// It defines standard writing method for all type of value. 
-  /// \author Balazs Dezso
-  struct DefaultWriterTraits {
-
-    /// \brief Template class for writing an value.
-    ///
-    /// Template class for writing an value.
-    /// \author Balazs Dezso
-    template <typename _Value>
-    struct Writer {
-      /// The value type.
-      typedef _Value Value;
-
-      /// \brief Writes a value to the given stream.
-      ///
-      /// Writes a value to the given stream.
-      void write(std::ostream& os, const Value& value) {
-	os << value << '\t';
-      }
-    };
-
-    /// \brief Returns wheter this name is an ID map name.
-    ///
-    /// Returns wheter this name is an ID map name.
-    static bool idMapName(const std::string& name) {
-      return name == "id";
-    }
-
-  };
-
-
-  /// \brief Writer class for quoted strings.
-  ///
-  /// Writer class for quoted strings. It can process the escape
-  /// sequences in the string.
-  /// \author Balazs Dezso
-  class QuotedStringWriter {
-  public:
-    typedef std::string Value;
-
-    /// \brief Constructor for the writer.
-    ///
-    /// Constructor for the writer. If the given parameter is true
-    /// the writer creates escape sequences from special characters.
-    QuotedStringWriter(bool _escaped = true) : escaped(_escaped) {}
-
-    /// \brief Writes a quoted string to the given stream.
-    ///
-    /// Writes a quoted string to the given stream.
-    void write(std::ostream& os, const std::string& value) {
-      os << "\"";
-      if (escaped) {
-	std::ostringstream ls;
-	for (int i = 0; i < (int)value.size(); ++i) {
-	  writeEscape(ls, value[i]);
-	}
-	os << ls.str();
-      } else {
-	os << value;
-      }
-      os << "\"";
-    }
-
-  private:
-    
-    static void writeEscape(std::ostream& os, char c) {
-      switch (c) {
-      case '\\':
-	os << "\\\\";
-	return;
-      case '\"':
-	os << "\\\"";
-	return;
-      case '\'':
-	os << "\\\'";
-	return;
-      case '\?':
-	os << "\\\?";
-	return;
-      case '\a':
-	os << "\\a";
-	return;
-      case '\b':
-	os << "\\b";
-	return;
-      case '\f':
-	os << "\\f";
-	return;
-      case '\r':
-	os << "\\r";
-	return;
-      case '\n':
-	os << "\\n";
-	return;
-      case '\t':
-	os << "\\t";
-	return;
-      case '\v':
-	os << "\\v";
-	return;
-      default:
-	if (c < 0x20) {
-	  os << '\\' << std::oct << (int)c;
-	} else {
-	  os << c;
-	}
-	return;
-      }     
-    }
-  private:
-    bool escaped;
-  };
-
-  class GUIWriter {
-  public:
-    virtual void write(std::ostream& os) = 0;
-  };
-
-  
   /// \brief The graph writer class.
   ///
   /// The \c GraphWriter class provides the graph output. To write a graph
@@ -231,46 +100,64 @@
     
     typedef _Graph Graph;
     typedef typename Graph::Node Node;
-    typedef typename Graph::NodeIt NodeIt;
     typedef typename Graph::Edge Edge;
-    typedef typename Graph::EdgeIt EdgeIt;
 
     typedef _WriterTraits WriterTraits;
- 
+
     /// \brief Construct a new GraphWriter.
     ///
-    /// Construct a new GraphWriter. It writes from the given map,
-    /// it constructs the given map and it use the given writer as the
-    /// default skipper.
+    /// Construct a new GraphWriter. It writes the given graph
+    /// to the given stream.
     GraphWriter(std::ostream& _os, const Graph& _graph) 
-      : gui_writer(0), os(_os), graph(_graph){}
+      : writer(new LemonWriter(_os)), own_writer(true), 
+	graph(_graph), 
+	nodeset_writer(*writer, graph, std::string()),
+	edgeset_writer(*writer, graph, nodeset_writer, std::string()),
+	node_writer(*writer, nodeset_writer, std::string()),
+	edge_writer(*writer, edgeset_writer, std::string()),
+	attribute_writer(*writer, std::string()) {}
 
+    /// \brief Construct a new GraphWriter.
+    ///
+    /// Construct a new GraphWriter. It writes into the given graph
+    /// to the given file.
+    GraphWriter(const std::string& _filename, const Graph& _graph) 
+      : writer(new LemonWriter(_filename)), own_writer(true), 
+	graph(_graph),
+	nodeset_writer(*writer, graph, std::string(), skipper),
+	edgeset_writer(*writer, graph, nodeset_writer, std::string(), skipper),
+	node_writer(*writer, nodeset_writer, std::string()),
+	edge_writer(*writer, edgeset_writer, std::string()),
+	attribute_writer(*writer, std::string()) {}
+
+    /// \brief Construct a new GraphWriter.
+    ///
+    /// Construct a new GraphWriter. It writes into the given graph
+    /// to given LemonReader.
+    GraphWriter(LemonWriter& _writer, const Graph& _graph)
+      : writer(_writer), own_writer(false), 
+	graph(_graph),
+	nodeset_writer(*writer, graph, std::string()),
+	edgeset_writer(*writer, graph, nodeset_writer, std::string()),
+	node_writer(*writer, nodeset_writer, std::string()),
+	edge_writer(*writer, edgeset_writer, std::string()),
+	attribute_writer(*writer, std::string()) {}
 
     /// \brief Destruct the graph writer.
     ///
     /// Destruct the graph writer.
     ~GraphWriter() {
-      for (typename NodeMapWriters::iterator it = node_map_writers.begin(); 
-	   it != node_map_writers.end(); ++it) {
-	delete it->second;
-      }
-
-      for (typename EdgeMapWriters::iterator it = edge_map_writers.begin();
-	   it != edge_map_writers.end(); ++it) {
-	delete it->second;
-      }
-
+      if (own_writer) 
+	delete writer;
     }
 
-    // Node map rules
-
     /// \brief Add a new node map writer command for the writer.
     ///
     /// Add a new node map writer command for the writer.
     template <typename Map>
     GraphWriter& writeNodeMap(std::string name, const Map& map) {
-      return writeNodeMap<typename WriterTraits::template Writer<
-	typename Map::Value>, Map>(name, map);
+      nodeset_writer.writeMap(name, map);
+      return *this;
     }
 
     /// \brief Add a new node map writer command for the writer.
@@ -278,21 +165,19 @@
     /// Add a new node map writer command for the writer.
     template <typename Writer, typename Map>
     GraphWriter& writeNodeMap(std::string name, const Map& map, 
-			      const Writer& writer = Writer()) {
-      node_map_writers.push_back(
-        make_pair(name, new MapWriter<Node, Map, Writer>(map, writer)));
+			     const Writer& writer = Writer()) {
+      nodeset_writer.writeMap(name, map, writer);
       return *this;
     }
 
-    // Edge map rules
 
     /// \brief Add a new edge map writer command for the writer.
     ///
     /// Add a new edge map writer command for the writer.
     template <typename Map>
     GraphWriter& writeEdgeMap(std::string name, const Map& map) { 
-      return writeEdgeMap<typename WriterTraits::template Writer<
-        typename Map::Value>, Map>(name, map);
+      edgeset_writer.writeMap(name, map);
+      return *this;
     }
 
 
@@ -300,10 +185,9 @@
     ///
     /// Add a new edge map writer command for the writer.
     template <typename Writer, typename Map>
-    GraphWriter& writeEdgeMap(std::string name, 
-			    const Map& map, const Writer& writer = Writer()) {
-      edge_map_writers.push_back(make_pair(name, 
-	new MapWriter<Edge, Map, Writer>(map, writer)));
+    GraphWriter& writeEdgeMap(std::string name, const Map& map,
+			     const Writer& writer = Writer()) {
+      edgeset_writer.writeMap(name, map, writer);
       return *this;
     }
 
@@ -311,7 +195,7 @@
     ///
     /// Add a new labeled node writer for the writer.
     GraphWriter& writeNode(std::string name, const Node& node) {
-      node_writers.push_back(make_pair(name, node));
+      node_writer.writeNode(name, node);
       return *this;
     }
 
@@ -319,160 +203,62 @@
     ///
     /// Add a new labeled edge writer for the writer.
     GraphWriter& writeEdge(std::string name, const Edge& edge) {
-      edge_writers.push_back(make_pair(name, edge));
+      edge_writer.writeEdge(name, edge);
+    }
+
+    /// \brief Add a new attribute writer command.
+    ///
+    ///  Add a new attribute writer command.
+    template <typename Value>
+    GraphWriter& writeAttribute(std::string name, const Value& value) {
+      attribute_writer.writeAttribute(name, value);
+      return *this;
+    }
+    
+    /// \brief Add a new attribute writer command.
+    ///
+    ///  Add a new attribute writer command.
+    template <typename Writer, typename Value>
+    GraphWriter& writeAttribute(std::string name, const Value& value, 
+			       const Writer& writer) {
+      attribute_writer.writeAttribute<Writer>(name, value, writer);
       return *this;
     }
 
-    GraphWriter& writeGUI(const GUIWriter& writer) {
-      gui_writer = &writer;
+    /// \brief Conversion operator to LemonWriter.
+    ///
+    /// Conversion operator to LemonWriter. It make possible
+    /// to access the encapsulated \e LemonWriter, this way
+    /// you can attach to this writer new instances of 
+    /// \e LemonWriter::SectionWriter.
+    operator LemonWriter&() {
+      return *writer;
     }
 
     /// \brief Executes the writer commands.
     ///
     /// Executes the writer commands.
-    void run() {   
-      WriterBase<Node>* nodeWriter = 0;
-      WriterBase<Edge>* edgeWriter = 0;
-      writeNodeSet(nodeWriter);
-      writeEdgeSet(nodeWriter, edgeWriter);
-      writeNodes(nodeWriter);
-      writeEdges(edgeWriter);
-      writeGUI();
-      os << "@end" << std::endl;
+    void run() {
+      writer->run();
     }
 
   private:
 
-    template <class _Item>
-    class WriterBase {
-    public:
-      typedef _Item Item;
-      virtual void write(std::ostream&, const Item&) = 0;
-    };
+    LemonWriter* writer;
+    bool own_writer;
 
-    template <class _Item, typename _Map, typename _Writer>
-    class MapWriter : public WriterBase<_Item> {
-    public:
-      typedef _Map Map;
-      typedef _Writer Writer;
-      typedef typename Writer::Value Value;
-      typedef _Item Item;
-      
-      const Map& map;
-      Writer writer;
-
-      MapWriter(const Map& _map, const Writer& _writer) 
-	: map(_map), writer(_writer) {}
-
-
-      virtual void write(std::ostream& os, const Item& item) {
-	writer.write(os, map[item]);
-      }
-
-    };
-
-    void writeNodeSet(WriterBase<Node>* & nodeWriter) {
-      if (node_map_writers.size() == 0) return;
-      os << "@nodeset" << std::endl;
-      for (int i = 0; i < (int)node_map_writers.size(); ++i) {
-	const std::string& id = node_map_writers[i].first;
-	os << id << '\t';
-	if (WriterTraits::idMapName(id) && nodeWriter == 0) {
-	  nodeWriter = node_map_writers[i].second;
-	}
-      } 
-      os << std::endl;
-      for (NodeIt it(graph); it != INVALID; ++it) {
-	for (int i = 0; i < (int)node_map_writers.size(); ++i) {
-	  node_map_writers[i].second->write(os, it);
-	}
-	os << std::endl;
-      }
-
-    }
-
-    void writeEdgeSet(WriterBase<Node>* nodeWriter, 
-		      WriterBase<Edge>* & edgeWriter) {
-      if (edge_map_writers.size() == 0) return;
-      if (nodeWriter == 0) {
-	throw DataFormatError("Cannot find node id map");
-      }
-      os << "@edgeset" << std::endl;
-      os << "\t\t";
-      for (int i = 0; i < (int)edge_map_writers.size(); ++i) {
-	const std::string& id = edge_map_writers[i].first;
-	os << id << '\t';
-	if (WriterTraits::idMapName(id) && edgeWriter == 0) {
-	  edgeWriter = edge_map_writers[i].second;
-	}
-      } 
-      os << std::endl;
-      for (EdgeIt it(graph); it != INVALID; ++it) {
-	nodeWriter->write(os, graph.source(it));
-	nodeWriter->write(os, graph.target(it));
-	for (int i = 0; i < (int)edge_map_writers.size(); ++i) {
-	  edge_map_writers[i].second->write(os, it);
-	}
-	os << std::endl;
-      }
-    }
-
-    void writeNodes(WriterBase<Node>* nodeWriter) {
-      if (node_writers.size() == 0) return;
-      if (nodeWriter == 0) {
-	throw DataFormatError("Cannot find node id map");
-      }
-      os << "@nodes" << std::endl;
-      for (int i = 0; i < (int)node_writers.size(); ++i) {
-	os << node_writers[i].first << '\t';
-	nodeWriter->write(os, node_writers[i].second);
-	os << std::endl;
-      } 
-    }
-
-    void writeEdges(WriterBase<Edge>* edgeWriter) {
-      if (edge_writers.size() == 0) return;
-      if (edgeWriter == 0) {
-	throw DataFormatError("Cannot find node id map");
-      }
-      os << "@edges" << std::endl;
-      for (int i = 0; i < (int)edge_writers.size(); ++i) {
-	os << edge_writers[i].first << '\t';
-        edgeWriter->write(os, edge_writers[i].second);
-	os << std::endl;
-      } 
-    }
-    
-    void writeGUI() {      
-      if (gui_writer) {
-	os << "@gui" << std::endl;
-	gui_writer->write(os);
-      }
-    }
-
-
-
-    typedef std::vector< std::pair<std::string, WriterBase<Node>*> > 
-      NodeMapWriters;
-    NodeMapWriters node_map_writers;
-
-    typedef std::vector< std::pair<std::string, WriterBase<Edge>*> > 
-      EdgeMapWriters;
-    EdgeMapWriters edge_map_writers;
-
-    typedef std::vector<std::pair<std::string, Node> > NodeWriters;
-    NodeWriters node_writers;
-
-    typedef std::vector<std::pair<std::string, Edge> > EdgeWriters;
-    EdgeWriters edge_writers;
-
-    GUIWriter* gui_writer;
-
-    std::ostream& os;
     const Graph& graph;
 
+    NodeSetWriter<Graph, WriterTraits> nodeset_writer;
+    EdgeSetWriter<Graph, WriterTraits> edgeset_writer;
+
+    NodeWriter<Graph> node_writer;
+    EdgeWriter<Graph> edge_writer;
+    
+    AttributeWriter<WriterTraits> attribute_writer;
   };
 
+
   /// \brief Write a graph to the output.
   ///
   /// Write a graph to the output.