lemon-0.x: src/lemon/graph_writer.h@d8491fce6751

     1 /* -*- C++ -*-

     2  * src/lemon/graph_writer.h - Part of LEMON, a generic C++ optimization library

     3  *

     4  * Copyright (C) 2005 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

     5  * (Egervary Combinatorial Optimization Research Group, EGRES).

     6  *

     7  * Permission to use, modify and distribute this software is granted

     8  * provided that this copyright notice appears in all copies. For

     9  * precise terms see the accompanying LICENSE file.

    10  *

    11  * This software is provided "AS IS" with no warranty of any kind,

    12  * express or implied, and with no claim as to its suitability for any

    13  * purpose.

    14  *

    15  */

    17 ///\ingroup gio

    18 ///\file

    19 ///\brief Graph writer.

    21 #ifndef LEMON_GRAPH_WRITER_H

    22 #define LEMON_GRAPH_WRITER_H

    24 #include <iostream>

    25 #include <sstream>

    27 #include <map>

    28 #include <vector>

    30 #include <memory>

    32 #include <lemon/map_utils.h>

    34 #include <lemon/invalid.h>

    35 #include <lemon/error.h>

    38 namespace lemon {

    40   /// \brief Standard WriterTraits for the GraphWriter class.

    41   ///

    42   /// Standard WriterTraits for the GraphWriter class.

    43   /// It defines standard writing method for all type of value.

    44   struct DefaultWriterTraits {

    46     /// \brief Template class for writing an value.

    47     ///

    48     /// Template class for writing an value.

    49     template <typename _Value>

    50     struct Writer {

    51       /// The value type.

    52       typedef _Value Value;

    54       /// \brief Writes a value to the given stream.

    55       ///

    56       /// Writes a value to the given stream.

    57       void write(std::ostream& os, const Value& value) {

    58 	os << value << '\t';

    59       }

    60     };

    62   };

    65   /// \brief Writer class for quoted strings.

    66   ///

    67   /// Writer class for quoted strings. It can process the escape

    68   /// sequences in the string.

    69   class QuotedStringWriter {

    70   public:

    71     typedef std::string Value;

    73     /// \brief Constructor for the writer.

    74     ///

    75     /// Constructor for the writer. If the given parameter is true

    76     /// the writer creates escape sequences from special characters.

    77     QuotedStringWriter(bool _escaped = true) : escaped(_escaped) {}

    79     /// \brief Writes a quoted string to the given stream.

    80     ///

    81     /// Writes a quoted string to the given stream.

    82     void write(std::ostream& os, const std::string& value) {

    83       os << "\"";

    84       if (escaped) {

    85 	ostringstream ls;

    86 	for (int i = 0; i < (int)value.size(); ++i) {

    87 	  writeEscape(ls, value[i]);

    88 	}

    89 	os << ls.str();

    90       } else {

    91 	os << value;

    92       }

    93       os << "\"";

    94     }

    96   private:

    98     static void writeEscape(std::ostream& os, char c) {

    99       switch (c) {

   100       case '\\':

   101 	os << "\\\\";

   102 	return;

   103       case '\"':

   104 	os << "\\\"";

   105 	return;

   106       case '\'':

   107 	os << "\\\'";

   108 	return;

   109       case '\?':

   110 	os << "\\\?";

   111 	return;

   112       case '\a':

   113 	os << "\\a";

   114 	return;

   115       case '\b':

   116 	os << "\\b";

   117 	return;

   118       case '\f':

   119 	os << "\\f";

   120 	return;

   121       case '\r':

   122 	os << "\\r";

   123 	return;

   124       case '\n':

   125 	os << "\\n";

   126 	return;

   127       case '\t':

   128 	os << "\\t";

   129 	return;

   130       case '\v':

   131 	os << "\\v";

   132 	return;

   133       default:

   134 	if (c < 0x20) {

   135 	  os << '\\' << oct << (int)c;

   136 	} else {

   137 	  os << c;

   138 	}

   139 	return;

   140       }

   141     }

   142   private:

   143     bool escaped;

   144   };

   147   /// \brief The graph writer class.

   148   ///

   149   /// The writer class for the graph output.

   150   /// \see \ref GraphReader

   151   /// \see \ref graph-io-page

   152   template <typename _Graph, typename _WriterTraits = DefaultWriterTraits>

   153   class GraphWriter {

   154   public:

   156     typedef _Graph Graph;

   157     typedef typename Graph::Node Node;

   158     typedef typename Graph::NodeIt NodeIt;

   159     typedef typename Graph::Edge Edge;

   160     typedef typename Graph::EdgeIt EdgeIt;

   162     typedef _WriterTraits WriterTraits;

   164     /// \brief Construct a new GraphWriter.

   165     ///

   166     /// Construct a new GraphWriter. It writes from the given map,

   167     /// it constructs the given map and it use the given writer as the

   168     /// default skipper.

   169     GraphWriter(std::ostream& _os, const Graph& _graph)

   170       : os(_os), graph(_graph) {}

   173     /// \brief Destruct the graph writer.

   174     ///

   175     /// Destruct the graph writer.

   176     ~GraphWriter() {

   177       for (typename NodeMapWriters::iterator it = node_map_writers.begin();

   178 	   it != node_map_writers.end(); ++it) {

   179 	delete it->second;

   180       }

   182       for (typename EdgeMapWriters::iterator it = edge_map_writers.begin();

   183 	   it != edge_map_writers.end(); ++it) {

   184 	delete it->second;

   185       }

   187     }

   189     // Node map rules

   191     /// \brief Add a new node map writer command for the writer.

   192     ///

   193     /// Add a new node map writer command for the writer.

   194     template <typename Map>

   195     GraphWriter& addNodeMap(std::string name, const Map& map) {

   196       return addNodeMap<typename WriterTraits::template Writer<

   197 	typename Map::Value>, Map>(name, map);

   198     }

   200     /// \brief Add a new node map writer command for the writer.

   201     ///

   202     /// Add a new node map writer command for the writer.

   203     template <typename Writer, typename Map>

   204     GraphWriter& addNodeMap(std::string name, const Map& map,

   205 			      const Writer& writer = Writer()) {

   206       node_map_writers.push_back(

   207         make_pair(name, new MapWriter<Node, Map, Writer>(map, writer)));

   208       return *this;

   209     }

   211     // Edge map rules

   213     /// \brief Add a new edge map writer command for the writer.

   214     ///

   215     /// Add a new edge map writer command for the writer.

   216     template <typename Map>

   217     GraphWriter& addEdgeMap(std::string name, const Map& map) {

   218       return addEdgeMap<typename WriterTraits::template Writer<

   219         typename Map::Value>, Map>(name, map);

   220     }

   223     /// \brief Add a new edge map writer command for the writer.

   224     ///

   225     /// Add a new edge map writer command for the writer.

   226     template <typename Writer, typename Map>

   227     GraphWriter& addEdgeMap(std::string name,

   228 			    const Map& map, const Writer& writer = Writer()) {

   229       edge_map_writers.push_back(make_pair(name,

   230 	new MapWriter<Edge, Map, Writer>(map, writer)));

   231       return *this;

   232     }

   234     /// \brief Add a new labeled node writer for the writer.

   235     ///

   236     /// Add a new labeled node writer for the writer.

   237     GraphWriter& addNode(std::string name, const Node& node) {

   238       node_writers.push_back(make_pair(name, node));

   239       return *this;

   240     }

   242     /// \brief Add a new labeled edge writer for the writer.

   243     ///

   244     /// Add a new labeled edge writer for the writer.

   245     GraphWriter& addEdge(std::string name, const Edge& edge) {

   246       edge_writers.push_back(make_pair(name, edge));

   247       return *this;

   248     }

   250     /// \brief Executes the writer commands.

   251     ///

   252     /// Executes the writer commands.

   253     void run() {

   254       writeNodeSet();

   255       writeEdgeSet();

   256       writeNodes();

   257       writeEdges();

   258       os << "@end" << std::endl;

   259     }

   261   private:

   263     void writeNodeSet() {

   264       if (node_map_writers.size() == 0) return;

   265       os << "@nodeset" << std::endl;

   266       for (int i = 0; i < (int)node_map_writers.size(); ++i) {

   267 	os << node_map_writers[i].first << '\t';

   268       }

   269       os << std::endl;

   270       for (NodeIt it(graph); it != INVALID; ++it) {

   271 	for (int i = 0; i < (int)node_map_writers.size(); ++i) {

   272 	  node_map_writers[i].second->write(os, it);

   273 	}

   274 	os << std::endl;

   275       }

   277     }

   279     void writeEdgeSet() {

   280       if (edge_map_writers.size() == 0) return;

   281       if (node_map_writers.size() == 0) {

   282 	//	ErrorMessage message;

   283 	//	message << "Missing node id map";

   284 	//	throw IOLogicError(message);

   285       }

   286       os << "@edgeset" << std::endl;

   287       os << "\t\t";

   288       for (int i = 0; i < (int)edge_map_writers.size(); ++i) {

   289 	os << edge_map_writers[i].first << '\t';

   290       }

   291       os << std::endl;

   292       for (EdgeIt it(graph); it != INVALID; ++it) {

   293 	node_map_writers[0].second->write(os, graph.source(it));

   294 	node_map_writers[0].second->write(os, graph.target(it));

   295 	for (int i = 0; i < (int)edge_map_writers.size(); ++i) {

   296 	  edge_map_writers[i].second->write(os, it);

   297 	}

   298 	os << std::endl;

   299       }

   300     }

   302     void writeNodes() {

   303       if (node_writers.size() == 0) return;

   304       if (node_map_writers.size() == 0) {

   305 	//	throw Exception() << "Missing node id map";

   306       }

   307       os << "@nodes" << std::endl;

   308       for (int i = 0; i < (int)node_writers.size(); ++i) {

   309 	os << node_writers[i].first << '\t';

   310 	node_map_writers[0].second->write(os, node_writers[i].second);

   311 	os << std::endl;

   312       }

   313     }

   315     void writeEdges() {

   316       if (edge_writers.size() == 0) return;

   317       if (edge_map_writers.size() == 0) {

   318 	//	throw Exception() << "Missing edge id map";

   319       }

   320       os << "@edges" << std::endl;

   321       for (int i = 0; i < (int)edge_writers.size(); ++i) {

   322 	os << edge_writers[i].first << '\t';

   323 	edge_map_writers[0].second->write(os, edge_writers[i].second);

   324 	os << std::endl;

   325       }

   326     }

   328     // Writers

   330     template <class _Item>

   331     class WriterBase {

   332     public:

   333       typedef _Item Item;

   334       virtual void write(std::ostream&, const Item&) = 0;

   335     };

   337     template <class _Item, typename _Map, typename _Writer>

   338     class MapWriter : public WriterBase<_Item> {

   339     public:

   340       typedef _Map Map;

   341       typedef _Writer Writer;

   342       typedef typename Writer::Value Value;

   343       typedef _Item Item;

   345       const Map& map;

   346       Writer writer;

   348       MapWriter(const Map& _map, const Writer& _writer)

   349 	: map(_map), writer(_writer) {}

   352       virtual void write(std::ostream& os, const Item& item) {

   353 	writer.write(os, map[item]);

   354       }

   356     };

   360     typedef std::vector< std::pair<std::string, WriterBase<Node>*> >

   361       NodeMapWriters;

   362     NodeMapWriters node_map_writers;

   364     typedef std::vector< std::pair<std::string, WriterBase<Edge>*> >

   365       EdgeMapWriters;

   366     EdgeMapWriters edge_map_writers;

   368     typedef std::vector<std::pair<std::string, Node> > NodeWriters;

   369     NodeWriters node_writers;

   371     typedef std::vector<std::pair<std::string, Edge> > EdgeWriters;

   372     EdgeWriters edge_writers;

   374     std::ostream& os;

   375     const Graph& graph;

   377   };

   379   /// Ready to use writer function.

   380   template<typename Graph, typename CapacityMap, typename CostMap>

   381   void writeGraph(std::ostream& os, const Graph &g,

   382 		  const CapacityMap& capacity, const typename Graph::Node &s,

   383 		  const typename Graph::Node &t, const CostMap& cost) {

   384     GraphWriter<Graph> reader(os, g);

   385     IdMap<Graph, typename Graph::Node> nodeIdMap(g);

   386     reader.addNodeMap("id", nodeIdMap);

   387     IdMap<Graph, typename Graph::Edge> edgeIdMap(g);

   388     reader.addEdgeMap("id", edgeIdMap);

   389     reader.addEdgeMap("capacity", capacity);

   390     reader.addEdgeMap("cost", cost);

   391     reader.addNode("source", s);

   392     reader.addNode("target", t);

   393     reader.run();

   394   }

   396   /// Ready to use writer function.

   397   template<typename Graph, typename CapacityMap, typename CostMap>

   398   void writeGraph(std::ostream& os, const Graph &g,

   399 		  const CapacityMap& capacity, const typename Graph::Node &s,

   400 		  const typename Graph::Node &t) {

   401     GraphWriter<Graph> reader(os, g);

   402     IdMap<Graph, typename Graph::Node> nodeIdMap(g);

   403     reader.addNodeMap("id", nodeIdMap);

   404     IdMap<Graph, typename Graph::Edge> edgeIdMap(g);

   405     reader.addEdgeMap("id", edgeIdMap);

   406     reader.addEdgeMap("capacity", capacity);

   407     reader.addNode("source", s);

   408     reader.addNode("target", t);

   409     reader.run();

   410   }

   412   /// Ready to use writer function.

   413   template<typename Graph, typename CapacityMap>

   414   void writeGraph(std::ostream& os, const Graph &g,

   415 		  const CapacityMap& capacity, const typename Graph::Node &s) {

   416     GraphWriter<Graph> reader(os, g);

   417     IdMap<Graph, typename Graph::Node> nodeIdMap(g);

   418     reader.addNodeMap("id", nodeIdMap);

   419     IdMap<Graph, typename Graph::Edge> edgeIdMap(g);

   420     reader.addEdgeMap("id", edgeIdMap);

   421     reader.addEdgeMap("capacity", capacity);

   422     reader.addNode("source", s);

   423     reader.run();

   424   }

   425   /// Ready to use writer function.

   426   template<typename Graph, typename CapacityMap>

   427   void writeGraph(std::ostream& os, const Graph &g,

   428 		  const CapacityMap& capacity) {

   429     GraphWriter<Graph> reader(os, g);

   430     IdMap<Graph, typename Graph::Node> nodeIdMap(g);

   431     reader.addNodeMap("id", nodeIdMap);

   432     IdMap<Graph, typename Graph::Edge> edgeIdMap(g);

   433     reader.addEdgeMap("id", edgeIdMap);

   434     reader.addEdgeMap("capacity", capacity);

   435     reader.run();

   436   }

   437   /// Ready to use writer function.

   438   template<typename Graph>

   439   void writeGraph(std::ostream& os, const Graph &g) {

   440     GraphWriter<Graph> reader(os, g);

   441     IdMap<Graph, typename Graph::Node> nodeIdMap(g);

   442     reader.addNodeMap("id", nodeIdMap);

   443     IdMap<Graph, typename Graph::Edge> edgeIdMap(g);

   444     reader.addEdgeMap("id", edgeIdMap);

   445     reader.run();

   446   }

   449 }

   451 #endif

author	athos
	Fri, 25 Mar 2005 15:23:00 +0000
changeset 1260	d8491fce6751
parent 1208	f486d30e4e7b
child 1287	984723507b86
permissions	-rw-r--r--