lemon: comparison lemon/lgf

equal deleted inserted replaced

-:be8e24d99bf3
+:78f30c7c15f0
 }
 };
 }
-template <typename Digraph>
+template <typename DGR>
 class DigraphWriter;
-template <typename Digraph>
+template <typename TDGR>
-DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,
+DigraphWriter<TDGR> digraphWriter(const TDGR& digraph,
 std::ostream& os = std::cout);
-template <typename Digraph>
+template <typename TDGR>
-DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,
+DigraphWriter<TDGR> digraphWriter(const TDGR& digraph, const std::string& fn);
-const std::string& fn);
+template <typename TDGR>
-template <typename Digraph>
+DigraphWriter<TDGR> digraphWriter(const TDGR& digraph, const char* fn);
-DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,
-const char* fn);
 /// \ingroup lemon_io
 ///
 /// \brief \ref lgf-format "LGF" writer for directed graphs
 /// the output stream. If the functor is not set, then a default
 /// conversion will be used. The \c attribute(), \c node() and \c
 /// arc() functions are used to add attribute writing rules.
 ///
 ///\code
-/// DigraphWriter<Digraph>(digraph, std::cout).
+/// DigraphWriter<DGR>(digraph, std::cout).
 ///   nodeMap("coordinates", coord_map).
 ///   nodeMap("size", size).
 ///   nodeMap("title", title).
 ///   arcMap("capacity", cap_map).
 ///   node("source", src).
 /// writes the node section and the first arc section, then the
 /// second pass skips the node section and writes just the arc
 /// section to the stream. The output stream can be retrieved with
 /// the \c ostream() function, hence the second pass can append its
 /// output to the output of the first pass.
-template <typename GR>
+template <typename DGR>
 class DigraphWriter {
 public:
-typedef GR Digraph;
+typedef DGR Digraph;
-TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
+TEMPLATE_DIGRAPH_TYPEDEFS(DGR);
 private:
 std::ostream* _os;
 bool local_os;
-const Digraph& _digraph;
+const DGR& _digraph;
 std::string _nodes_caption;
 std::string _arcs_caption;
 std::string _attributes_caption;
 /// \brief Constructor
 ///
 /// Construct a directed graph writer, which writes to the given
 /// output stream.
-DigraphWriter(const Digraph& digraph, std::ostream& os = std::cout)
+DigraphWriter(const DGR& digraph, std::ostream& os = std::cout)
 : _os(&os), local_os(false), _digraph(digraph),
 _skip_nodes(false), _skip_arcs(false) {}
 /// \brief Constructor
 ///
 /// Construct a directed graph writer, which writes to the given
 /// output file.
-DigraphWriter(const Digraph& digraph, const std::string& fn)
+DigraphWriter(const DGR& digraph, const std::string& fn)
 : _os(new std::ofstream(fn.c_str())), local_os(true), _digraph(digraph),
 _skip_nodes(false), _skip_arcs(false) {
 if (!(*_os)) {
 delete _os;
 throw IoError("Cannot write file", fn);
 /// \brief Constructor
 ///
 /// Construct a directed graph writer, which writes to the given
 /// output file.
-DigraphWriter(const Digraph& digraph, const char* fn)
+DigraphWriter(const DGR& digraph, const char* fn)
 : _os(new std::ofstream(fn)), local_os(true), _digraph(digraph),
 _skip_nodes(false), _skip_arcs(false) {
 if (!(*_os)) {
 delete _os;
 throw IoError("Cannot write file", fn);
 }
 }
 private:
-template <typename DGR>
+template <typename TDGR>
-friend DigraphWriter<DGR> digraphWriter(const DGR& digraph,
+friend DigraphWriter<TDGR> digraphWriter(const TDGR& digraph,
 std::ostream& os);
-template <typename DGR>
+template <typename TDGR>
-friend DigraphWriter<DGR> digraphWriter(const DGR& digraph,
+friend DigraphWriter<TDGR> digraphWriter(const TDGR& digraph,
 const std::string& fn);
-template <typename DGR>
+template <typename TDGR>
-friend DigraphWriter<DGR> digraphWriter(const DGR& digraph,
+friend DigraphWriter<TDGR> digraphWriter(const TDGR& digraph,
 const char *fn);
 DigraphWriter(DigraphWriter& other)
 : _os(other._os), local_os(other.local_os), _digraph(other._digraph),
 _skip_nodes(other._skip_nodes), _skip_arcs(other._skip_arcs) {
 for (NodeIt n(_digraph); n != INVALID; ++n) {
 nodes.push_back(n);
 }
 if (label == 0) {
-IdMap<Digraph, Node> id_map(_digraph);
+IdMap<DGR, Node> id_map(_digraph);
-_writer_bits::MapLess<IdMap<Digraph, Node> > id_less(id_map);
+_writer_bits::MapLess<IdMap<DGR, Node> > id_less(id_map);
 std::sort(nodes.begin(), nodes.end(), id_less);
 } else {
 label->sort(nodes);
 }
 for (ArcIt n(_digraph); n != INVALID; ++n) {
 arcs.push_back(n);
 }
 if (label == 0) {
-IdMap<Digraph, Arc> id_map(_digraph);
+IdMap<DGR, Arc> id_map(_digraph);
-_writer_bits::MapLess<IdMap<Digraph, Arc> > id_less(id_map);
+_writer_bits::MapLess<IdMap<DGR, Arc> > id_less(id_map);
 std::sort(arcs.begin(), arcs.end(), id_less);
 } else {
 label->sort(arcs);
 }
 }
 /// @}
 };
+/// \ingroup lemon_io
+///
+/// \brief Return a \ref DigraphWriter class
+///
+/// This function just returns a \ref DigraphWriter class.
+///
+/// With this function a digraph can be write to a file or output
+/// stream in \ref lgf-format "LGF" format with several maps and
+/// attributes. For example, with the following code a network flow
+/// problem can be written to the standard output, i.e. a digraph
+/// with a \e capacity map on the arcs and \e source and \e target
+/// nodes:
+///
+///\code
+///ListDigraph digraph;
+///ListDigraph::ArcMap<int> cap(digraph);
+///ListDigraph::Node src, trg;
+///  // Setting the capacity map and source and target nodes
+///digraphWriter(digraph, std::cout).
+///  arcMap("capacity", cap).
+///  node("source", src).
+///  node("target", trg).
+///  run();
+///\endcode
+///
+/// For a complete documentation, please see the \ref DigraphWriter
+/// class documentation.
+/// \warning Don't forget to put the \ref DigraphWriter::run() "run()"
+/// to the end of the parameter list.
+/// \relates DigraphWriter
+/// \sa digraphWriter(const TDGR& digraph, const std::string& fn)
+/// \sa digraphWriter(const TDGR& digraph, const char* fn)
+template <typename TDGR>
+DigraphWriter<TDGR> digraphWriter(const TDGR& digraph, std::ostream& os) {
+DigraphWriter<TDGR> tmp(digraph, os);
+return tmp;
+}
 /// \brief Return a \ref DigraphWriter class
 ///
 /// This function just returns a \ref DigraphWriter class.
 /// \relates DigraphWriter
-template <typename Digraph>
+/// \sa digraphWriter(const TDGR& digraph, std::ostream& os)
-DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,
+template <typename TDGR>
-std::ostream& os) {
+DigraphWriter<TDGR> digraphWriter(const TDGR& digraph,
-DigraphWriter<Digraph> tmp(digraph, os);
+const std::string& fn) {
+DigraphWriter<TDGR> tmp(digraph, fn);
 return tmp;
 }
 /// \brief Return a \ref DigraphWriter class
 ///
 /// This function just returns a \ref DigraphWriter class.
 /// \relates DigraphWriter
-template <typename Digraph>
+/// \sa digraphWriter(const TDGR& digraph, std::ostream& os)
-DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,
+template <typename TDGR>
-const std::string& fn) {
+DigraphWriter<TDGR> digraphWriter(const TDGR& digraph, const char* fn) {
-DigraphWriter<Digraph> tmp(digraph, fn);
+DigraphWriter<TDGR> tmp(digraph, fn);
 return tmp;
 }
-/// \brief Return a \ref DigraphWriter class
+template <typename GR>
-///
-/// This function just returns a \ref DigraphWriter class.
-/// \relates DigraphWriter
-template <typename Digraph>
-DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,
-const char* fn) {
-DigraphWriter<Digraph> tmp(digraph, fn);
-return tmp;
-}
-template <typename Graph>
 class GraphWriter;
-template <typename Graph>
+template <typename TGR>
-GraphWriter<Graph> graphWriter(const Graph& graph,
+GraphWriter<TGR> graphWriter(const TGR& graph, std::ostream& os = std::cout);
-std::ostream& os = std::cout);
+template <typename TGR>
-template <typename Graph>
+GraphWriter<TGR> graphWriter(const TGR& graph, const std::string& fn);
-GraphWriter<Graph> graphWriter(const Graph& graph, const std::string& fn);
+template <typename TGR>
-template <typename Graph>
+GraphWriter<TGR> graphWriter(const TGR& graph, const char* fn);
-GraphWriter<Graph> graphWriter(const Graph& graph, const char* fn);
 /// \ingroup lemon_io
 ///
 /// \brief \ref lgf-format "LGF" writer for directed graphs
 ///
 template <typename GR>
 class GraphWriter {
 public:
 typedef GR Graph;
-TEMPLATE_GRAPH_TYPEDEFS(Graph);
+TEMPLATE_GRAPH_TYPEDEFS(GR);
 private:
 std::ostream* _os;
 bool local_os;
-const Graph& _graph;
+const GR& _graph;
 std::string _nodes_caption;
 std::string _edges_caption;
 std::string _attributes_caption;
 /// \brief Constructor
 ///
 /// Construct a directed graph writer, which writes to the given
 /// output stream.
-GraphWriter(const Graph& graph, std::ostream& os = std::cout)
+GraphWriter(const GR& graph, std::ostream& os = std::cout)
 : _os(&os), local_os(false), _graph(graph),
 _skip_nodes(false), _skip_edges(false) {}
 /// \brief Constructor
 ///
 /// Construct a directed graph writer, which writes to the given
 /// output file.
-GraphWriter(const Graph& graph, const std::string& fn)
+GraphWriter(const GR& graph, const std::string& fn)
 : _os(new std::ofstream(fn.c_str())), local_os(true), _graph(graph),
 _skip_nodes(false), _skip_edges(false) {
 if (!(*_os)) {
 delete _os;
 throw IoError("Cannot write file", fn);
 /// \brief Constructor
 ///
 /// Construct a directed graph writer, which writes to the given
 /// output file.
-GraphWriter(const Graph& graph, const char* fn)
+GraphWriter(const GR& graph, const char* fn)
 : _os(new std::ofstream(fn)), local_os(true), _graph(graph),
 _skip_nodes(false), _skip_edges(false) {
 if (!(*_os)) {
 delete _os;
 throw IoError("Cannot write file", fn);
 }
 }
 private:
-template <typename Graph>
+template <typename TGR>
-friend GraphWriter<Graph> graphWriter(const Graph& graph,
+friend GraphWriter<TGR> graphWriter(const TGR& graph, std::ostream& os);
-std::ostream& os);
+template <typename TGR>
-template <typename Graph>
+friend GraphWriter<TGR> graphWriter(const TGR& graph,
-friend GraphWriter<Graph> graphWriter(const Graph& graph,
+const std::string& fn);
-const std::string& fn);
+template <typename TGR>
-template <typename Graph>
+friend GraphWriter<TGR> graphWriter(const TGR& graph, const char *fn);
-friend GraphWriter<Graph> graphWriter(const Graph& graph,
-const char *fn);
 GraphWriter(GraphWriter& other)
 : _os(other._os), local_os(other.local_os), _graph(other._graph),
 _skip_nodes(other._skip_nodes), _skip_edges(other._skip_edges) {
 /// Add an arc map writing rule to the writer.
 template <typename Map>
 GraphWriter& arcMap(const std::string& caption, const Map& map) {
 checkConcept<concepts::ReadMap<Arc, typename Map::Value>, Map>();
 _writer_bits::MapStorageBase<Edge>* forward_storage =
-new _writer_bits::GraphArcMapStorage<Graph, true, Map>(_graph, map);
+new _writer_bits::GraphArcMapStorage<GR, true, Map>(_graph, map);
 _edge_maps.push_back(std::make_pair('+' + caption, forward_storage));
 _writer_bits::MapStorageBase<Edge>* backward_storage =
-new _writer_bits::GraphArcMapStorage<Graph, false, Map>(_graph, map);
+new _writer_bits::GraphArcMapStorage<GR, false, Map>(_graph, map);
 _edge_maps.push_back(std::make_pair('-' + caption, backward_storage));
 return *this;
 }
 /// \brief Arc map writing rule
 template <typename Map, typename Converter>
 GraphWriter& arcMap(const std::string& caption, const Map& map,
 const Converter& converter = Converter()) {
 checkConcept<concepts::ReadMap<Arc, typename Map::Value>, Map>();
 _writer_bits::MapStorageBase<Edge>* forward_storage =
-new _writer_bits::GraphArcMapStorage<Graph, true, Map, Converter>
+new _writer_bits::GraphArcMapStorage<GR, true, Map, Converter>
 (_graph, map, converter);
 _edge_maps.push_back(std::make_pair('+' + caption, forward_storage));
 _writer_bits::MapStorageBase<Edge>* backward_storage =
-new _writer_bits::GraphArcMapStorage<Graph, false, Map, Converter>
+new _writer_bits::GraphArcMapStorage<GR, false, Map, Converter>
 (_graph, map, converter);
 _edge_maps.push_back(std::make_pair('-' + caption, backward_storage));
 return *this;
 }
 /// \brief Arc writing rule
 ///
 /// Add an arc writing rule to writer.
 GraphWriter& arc(const std::string& caption, const Arc& arc) {
-typedef _writer_bits::GraphArcLookUpConverter<Graph> Converter;
+typedef _writer_bits::GraphArcLookUpConverter<GR> Converter;
 Converter converter(_graph, _edge_index);
 _writer_bits::ValueStorageBase* storage =
 new _writer_bits::ValueStorage<Arc, Converter>(arc, converter);
 _attributes.push_back(std::make_pair(caption, storage));
 return *this;
 for (NodeIt n(_graph); n != INVALID; ++n) {
 nodes.push_back(n);
 }
 if (label == 0) {
-IdMap<Graph, Node> id_map(_graph);
+IdMap<GR, Node> id_map(_graph);
-_writer_bits::MapLess<IdMap<Graph, Node> > id_less(id_map);
+_writer_bits::MapLess<IdMap<GR, Node> > id_less(id_map);
 std::sort(nodes.begin(), nodes.end(), id_less);
 } else {
 label->sort(nodes);
 }
 for (EdgeIt n(_graph); n != INVALID; ++n) {
 edges.push_back(n);
 }
 if (label == 0) {
-IdMap<Graph, Edge> id_map(_graph);
+IdMap<GR, Edge> id_map(_graph);
-_writer_bits::MapLess<IdMap<Graph, Edge> > id_less(id_map);
+_writer_bits::MapLess<IdMap<GR, Edge> > id_less(id_map);
 std::sort(edges.begin(), edges.end(), id_less);
 } else {
 label->sort(edges);
 }
 }
 /// @}
 };
+/// \ingroup lemon_io
+///
+/// \brief Return a \ref GraphWriter class
+///
+/// This function just returns a \ref GraphWriter class.
+///
+/// With this function a graph can be write to a file or output
+/// stream in \ref lgf-format "LGF" format with several maps and
+/// attributes. For example, with the following code a weighted
+/// matching problem can be written to the standard output, i.e. a
+/// graph with a \e weight map on the edges:
+///
+///\code
+///ListGraph graph;
+///ListGraph::EdgeMap<int> weight(graph);
+///  // Setting the weight map
+///graphWriter(graph, std::cout).
+///  edgeMap("weight", weight).
+///  run();
+///\endcode
+///
+/// For a complete documentation, please see the \ref GraphWriter
+/// class documentation.
+/// \warning Don't forget to put the \ref GraphWriter::run() "run()"
+/// to the end of the parameter list.
+/// \relates GraphWriter
+/// \sa graphWriter(const TGR& graph, const std::string& fn)
+/// \sa graphWriter(const TGR& graph, const char* fn)
+template <typename TGR>
+GraphWriter<TGR> graphWriter(const TGR& graph, std::ostream& os) {
+GraphWriter<TGR> tmp(graph, os);
+return tmp;
+}
 /// \brief Return a \ref GraphWriter class
 ///
 /// This function just returns a \ref GraphWriter class.
 /// \relates GraphWriter
-template <typename Graph>
+/// \sa graphWriter(const TGR& graph, std::ostream& os)
-GraphWriter<Graph> graphWriter(const Graph& graph,
+template <typename TGR>
-std::ostream& os) {
+GraphWriter<TGR> graphWriter(const TGR& graph, const std::string& fn) {
-GraphWriter<Graph> tmp(graph, os);
+GraphWriter<TGR> tmp(graph, fn);
 return tmp;
 }
 /// \brief Return a \ref GraphWriter class
 ///
 /// This function just returns a \ref GraphWriter class.
 /// \relates GraphWriter
-template <typename Graph>
+/// \sa graphWriter(const TGR& graph, std::ostream& os)
-GraphWriter<Graph> graphWriter(const Graph& graph, const std::string& fn) {
+template <typename TGR>
-GraphWriter<Graph> tmp(graph, fn);
+GraphWriter<TGR> graphWriter(const TGR& graph, const char* fn) {
-return tmp;
+GraphWriter<TGR> tmp(graph, fn);
-}
-/// \brief Return a \ref GraphWriter class
-///
-/// This function just returns a \ref GraphWriter class.
-/// \relates GraphWriter
-template <typename Graph>
-GraphWriter<Graph> graphWriter(const Graph& graph, const char* fn) {
-GraphWriter<Graph> tmp(graph, fn);
 return tmp;
 }
 class SectionWriter;
 /// @}
 };
+/// \ingroup lemon_io
+///
 /// \brief Return a \ref SectionWriter class
 ///
 /// This function just returns a \ref SectionWriter class.
+///
+/// Please see SectionWriter documentation about the custom section
+/// output.
+///
 /// \relates SectionWriter
+/// \sa sectionWriter(const std::string& fn)
+/// \sa sectionWriter(const char *fn)
 inline SectionWriter sectionWriter(std::ostream& os) {
 SectionWriter tmp(os);
 return tmp;
 }
 /// \brief Return a \ref SectionWriter class
 ///
 /// This function just returns a \ref SectionWriter class.
 /// \relates SectionWriter
+/// \sa sectionWriter(std::ostream& os)
 inline SectionWriter sectionWriter(const std::string& fn) {
 SectionWriter tmp(fn);
 return tmp;
 }
 /// \brief Return a \ref SectionWriter class
 ///
 /// This function just returns a \ref SectionWriter class.
 /// \relates SectionWriter
+/// \sa sectionWriter(std::ostream& os)
 inline SectionWriter sectionWriter(const char* fn) {
 SectionWriter tmp(fn);
 return tmp;
 }
 }

changeset 645	a3402913cffe
parent 606	c5fd2d996909
child 646	f63e87b9748e