LEMON/LEMON-official Changeset - r293:47fbc814aa31

Repositories » LEMON » LEMON-official

Summary
Changelog
Files
Switch To
- loading...
Options
- Lightweight changelog
- Search
Pull Requests

Changeset - r293:47fbc814aa31

« 289:d91884

294:cbe3ec »

r293:47fbc814aa31

Wed, 01 Oct 2008 12:44:16

[Not Reviewed]

0 comments (0 inline)

kpeter (Peter Kovacs)
kpeter@inf.elte.hu

Change the parameter order in LGF reader and writer tools

0 7 0

default

7 files changed with 92 insertions and 88 deletions:

demo/lgf_demo.cc

lemon/lgf_reader.h

lemon/lgf_writer.h

test/bfs_test.cc

test/dfs_test.cc

test/dijkstra_test.cc

test/heap_test.cc

↑ Collapse diff ↑

demo/lgf_demo.cc

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		///\ingroup demos
 		///\file
 		///\brief Demonstrating graph input and output
 		///
 		/// This program gives an example of how to read and write a digraph
 		/// and additional maps from/to a stream or a file using the
 		/// \ref lgf-format "LGF" format.
 		///
 		/// The \c "digraph.lgf" file:
 		/// \include digraph.lgf
 		///
 		/// And the program which reads it and prints the digraph to the
 		/// standard output:
 		/// \include lgf_demo.cc
 		#include <iostream>
 		#include <lemon/smart_graph.h>
 		#include <lemon/lgf_reader.h>
 		#include <lemon/lgf_writer.h>
 		using namespace lemon;
 		int main() {
 		  SmartDigraph g;
 		  SmartDigraph::ArcMap<int> cap(g);
 		  SmartDigraph::Node s, t;
 		  try {
-		    digraphReader("digraph.lgf", g). // read the directed graph into g
+		    digraphReader(g, "digraph.lgf"). // read the directed graph into g
 		      arcMap("capacity", cap).       // read the 'capacity' arc map into cap
 		      node("source", s).             // read 'source' node to s
 		      node("target", t).             // read 'target' node to t
 		      run();
 		  } catch (DataFormatError& error) { // check if there was any error
 		    std::cerr << "Error: " << error.what() << std::endl;
 		    return -1;
+		  }
 		  std::cout << "A digraph is read from 'digraph.lgf'." << std::endl;
 		  std::cout << "Number of nodes: " << countNodes(g) << std::endl;
 		  std::cout << "Number of arcs: " << countArcs(g) << std::endl;
 		  std::cout << "We can write it to the standard output:" << std::endl;
-		  digraphWriter(std::cout, g).     // write g to the standard output
+		  digraphWriter(g).                // write g to the standard output
 		    arcMap("capacity", cap).       // write cap into 'capacity'
 		    node("source", s).             // write s to 'source'
 		    node("target", t).             // write t to 'target'
 		    run();
 		  return 0;
+		}

lemon/lgf_reader.h

Show inline comments

@@ -329,291 +329,292 @@
 		    private:
 		      Functor _functor;
 		    public:
 		      LineSection(const Functor& functor) : _functor(functor) {}
 		      virtual ~LineSection() {}
 		      virtual void process(std::istream& is, int& line_num) {
 		        char c;
 		        std::string line;
 		        while (is.get(c) && c != '@') {
 		          if (c == '\n') {
 		            ++line_num;
 		          } else if (c == '#') {
 		            getline(is, line);
 		            ++line_num;
 		          } else if (!isWhiteSpace(c)) {
 		            is.putback(c);
 		            getline(is, line);
 		            _functor(line);
 		            ++line_num;
+		          }
+		        }
 		        if (is) is.putback(c);
 		        else if (is.eof()) is.clear();
+		      }
 		    };
 		    template <typename Functor>
 		    class StreamSection : public Section {
 		    private:
 		      Functor _functor;
 		    public:
 		      StreamSection(const Functor& functor) : _functor(functor) {}
 		      virtual ~StreamSection() {}
 		      virtual void process(std::istream& is, int& line_num) {
 		        _functor(is, line_num);
 		        char c;
 		        std::string line;
 		        while (is.get(c) && c != '@') {
 		          if (c == '\n') {
 		            ++line_num;
 		          } else if (!isWhiteSpace(c)) {
 		            getline(is, line);
 		            ++line_num;
+		          }
+		        }
 		        if (is) is.putback(c);
 		        else if (is.eof()) is.clear();
+		      }
 		    };
+		  }
 		  template <typename Digraph>
 		  class DigraphReader;
 		  template <typename Digraph>
-		  DigraphReader<Digraph> digraphReader(std::istream& is, Digraph& digraph);
+		  DigraphReader<Digraph> digraphReader(Digraph& digraph,
 		                                       std::istream& is = std::cin);
 		  template <typename Digraph>
-		  DigraphReader<Digraph> digraphReader(const std::string& fn, Digraph& digraph);
+		  DigraphReader<Digraph> digraphReader(Digraph& digraph, const std::string& fn);
 		  template <typename Digraph>
-		  DigraphReader<Digraph> digraphReader(const char *fn, Digraph& digraph);
+		  DigraphReader<Digraph> digraphReader(Digraph& digraph, const char *fn);
 		  /// \ingroup lemon_io
 		  ///
 		  /// \brief \ref lgf-format "LGF" reader for directed graphs
 		  ///
 		  /// This utility reads an \ref lgf-format "LGF" file.
 		  ///
 		  /// The reading method does a batch processing. The user creates a
 		  /// reader object, then various reading rules can be added to the
 		  /// reader, and eventually the reading is executed with the \c run()
 		  /// member function. A map reading rule can be added to the reader
 		  /// with the \c nodeMap() or \c arcMap() members. An optional
 		  /// converter parameter can also be added as a standard functor
 		  /// converting from \c std::string to the value type of the map. If it
 		  /// is set, it will determine how the tokens in the file should be
 		  /// converted to the value type of the map. If the functor is not set,
 		  /// then a default conversion will be used. One map can be read into
 		  /// multiple map objects at the same time. The \c attribute(), \c
 		  /// node() and \c arc() functions are used to add attribute reading
 		  /// rules.
 		  ///
 		  ///\code
-		  /// DigraphReader<Digraph>(std::cin, digraph).
+		  /// DigraphReader<Digraph>(digraph, std::cin).
 		  ///   nodeMap("coordinates", coord_map).
 		  ///   arcMap("capacity", cap_map).
 		  ///   node("source", src).
 		  ///   node("target", trg).
 		  ///   attribute("caption", caption).
 		  ///   run();
 		  ///\endcode
 		  ///
 		  /// By default the reader uses the first section in the file of the
 		  /// proper type. If a section has an optional name, then it can be
 		  /// selected for reading by giving an optional name parameter to the
 		  /// \c nodes(), \c arcs() or \c attributes() functions.
 		  ///
 		  /// The \c useNodes() and \c useArcs() functions are used to tell the reader
 		  /// that the nodes or arcs should not be constructed (added to the
 		  /// graph) during the reading, but instead the label map of the items
 		  /// are given as a parameter of these functions. An
 		  /// application of these functions is multipass reading, which is
 		  /// important if two \c \@arcs sections must be read from the
 		  /// file. In this case the first phase would read the node set and one
 		  /// of the arc sets, while the second phase would read the second arc
 		  /// set into an \e ArcSet class (\c SmartArcSet or \c ListArcSet).
 		  /// The previously read label node map should be passed to the \c
 		  /// useNodes() functions. Another application of multipass reading when
 		  /// paths are given as a node map or an arc map.
 		  /// It is impossible to read this in
 		  /// a single pass, because the arcs are not constructed when the node
 		  /// maps are read.
 		  template <typename _Digraph>
 		  class DigraphReader {
 		  public:
 		    typedef _Digraph Digraph;
 		    TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
 		  private:
 		    std::istream* _is;
 		    bool local_is;
 		    Digraph& _digraph;
 		    std::string _nodes_caption;
 		    std::string _arcs_caption;
 		    std::string _attributes_caption;
 		    typedef std::map<std::string, Node> NodeIndex;
 		    NodeIndex _node_index;
 		    typedef std::map<std::string, Arc> ArcIndex;
 		    ArcIndex _arc_index;
 		    typedef std::vector<std::pair<std::string,
 		      _reader_bits::MapStorageBase<Node>*> > NodeMaps;
 		    NodeMaps _node_maps;
 		    typedef std::vector<std::pair<std::string,
 		      _reader_bits::MapStorageBase<Arc>*> >ArcMaps;
 		    ArcMaps _arc_maps;
 		    typedef std::multimap<std::string, _reader_bits::ValueStorageBase*>
 		      Attributes;
 		    Attributes _attributes;
 		    bool _use_nodes;
 		    bool _use_arcs;
 		    bool _skip_nodes;
 		    bool _skip_arcs;
 		    int line_num;
 		    std::istringstream line;
 		  public:
 		    /// \brief Constructor
 		    ///
 		    /// Construct a directed graph reader, which reads from the given
 		    /// input stream.
-		    DigraphReader(std::istream& is, Digraph& digraph)
+		    DigraphReader(Digraph& digraph, std::istream& is = std::cin)
 		      : _is(&is), local_is(false), _digraph(digraph),
 		        _use_nodes(false), _use_arcs(false),
 		        _skip_nodes(false), _skip_arcs(false) {}
 		    /// \brief Constructor
 		    ///
 		    /// Construct a directed graph reader, which reads from the given
 		    /// file.
-		    DigraphReader(const std::string& fn, Digraph& digraph)
+		    DigraphReader(Digraph& digraph, const std::string& fn)
 		      : _is(new std::ifstream(fn.c_str())), local_is(true), _digraph(digraph),
 		        _use_nodes(false), _use_arcs(false),
 		        _skip_nodes(false), _skip_arcs(false) {}
 		    /// \brief Constructor
 		    ///
 		    /// Construct a directed graph reader, which reads from the given
 		    /// file.
-		    DigraphReader(const char* fn, Digraph& digraph)
+		    DigraphReader(Digraph& digraph, const char* fn)
 		      : _is(new std::ifstream(fn)), local_is(true), _digraph(digraph),
 		        _use_nodes(false), _use_arcs(false),
 		        _skip_nodes(false), _skip_arcs(false) {}
 		    /// \brief Destructor
 		    ~DigraphReader() {
 		      for (typename NodeMaps::iterator it = _node_maps.begin();
 		           it != _node_maps.end(); ++it) {
 		        delete it->second;
+		      }
 		      for (typename ArcMaps::iterator it = _arc_maps.begin();
 		           it != _arc_maps.end(); ++it) {
 		        delete it->second;
+		      }
 		      for (typename Attributes::iterator it = _attributes.begin();
 		           it != _attributes.end(); ++it) {
 		        delete it->second;
+		      }
 		      if (local_is) {
 		        delete _is;
+		      }
+		    }
 		  private:
 		    friend DigraphReader<Digraph> digraphReader<>(std::istream& is,
 		                                                  Digraph& digraph);
 		    friend DigraphReader<Digraph> digraphReader<>(const std::string& fn,
 		                                                  Digraph& digraph);
 		    friend DigraphReader<Digraph> digraphReader<>(const char *fn,
 		                                                  Digraph& digraph);
 		    friend DigraphReader<Digraph> digraphReader<>(Digraph& digraph,
 		                                                  std::istream& is);
 		    friend DigraphReader<Digraph> digraphReader<>(Digraph& digraph,
 		                                                  const std::string& fn);
 		    friend DigraphReader<Digraph> digraphReader<>(Digraph& digraph,
 		                                                  const char *fn);
 		    DigraphReader(DigraphReader& other)
 		      : _is(other._is), local_is(other.local_is), _digraph(other._digraph),
 		        _use_nodes(other._use_nodes), _use_arcs(other._use_arcs),
 		        _skip_nodes(other._skip_nodes), _skip_arcs(other._skip_arcs) {
 		      other._is = 0;
 		      other.local_is = false;
 		      _node_index.swap(other._node_index);
 		      _arc_index.swap(other._arc_index);
 		      _node_maps.swap(other._node_maps);
 		      _arc_maps.swap(other._arc_maps);
 		      _attributes.swap(other._attributes);
 		      _nodes_caption = other._nodes_caption;
 		      _arcs_caption = other._arcs_caption;
 		      _attributes_caption = other._attributes_caption;
+		    }
 		    DigraphReader& operator=(const DigraphReader&);
 		  public:
 		    /// \name Reading rules
 		    /// @{
 		    /// \brief Node map reading rule
 		    ///
 		    /// Add a node map reading rule to the reader.
 		    template <typename Map>
 		    DigraphReader& nodeMap(const std::string& caption, Map& map) {
 		      checkConcept<concepts::WriteMap<Node, typename Map::Value>, Map>();
 		      _reader_bits::MapStorageBase<Node>* storage =
 		        new _reader_bits::MapStorage<Node, Map>(map);
 		      _node_maps.push_back(std::make_pair(caption, storage));
 		      return *this;
+		    }
 		    /// \brief Node map reading rule
 		    ///
 		    /// Add a node map reading rule with specialized converter to the
 		    /// reader.
 		    template <typename Map, typename Converter>
 		    DigraphReader& nodeMap(const std::string& caption, Map& map,
 		                           const Converter& converter = Converter()) {
 		      checkConcept<concepts::WriteMap<Node, typename Map::Value>, Map>();
 		      _reader_bits::MapStorageBase<Node>* storage =
 		        new _reader_bits::MapStorage<Node, Map, Converter>(map, converter);
 		      _node_maps.push_back(std::make_pair(caption, storage));
 		      return *this;
+		    }
 		    /// \brief Arc map reading rule
 		    ///
 		    /// Add an arc map reading rule to the reader.
 		    template <typename Map>
 		    DigraphReader& arcMap(const std::string& caption, Map& map) {
 		      checkConcept<concepts::WriteMap<Arc, typename Map::Value>, Map>();
 		      _reader_bits::MapStorageBase<Arc>* storage =
 		        new _reader_bits::MapStorage<Arc, Map>(map);
 		      _arc_maps.push_back(std::make_pair(caption, storage));
@@ -1119,282 +1120,284 @@
 		      line_num = 0;
 		      readLine();
 		      skipSection();
 		      while (readSuccess()) {
 		        try {
 		          char c;
 		          std::string section, caption;
 		          line >> c;
 		          _reader_bits::readToken(line, section);
 		          _reader_bits::readToken(line, caption);
 		          if (line >> c)
 		            throw DataFormatError("Extra character on the end of line");
 		          if (section == "nodes" && !nodes_done) {
 		            if (_nodes_caption.empty() || _nodes_caption == caption) {
 		              readNodes();
 		              nodes_done = true;
+		            }
 		          } else if ((section == "arcs" || section == "edges") &&
 		                     !arcs_done) {
 		            if (_arcs_caption.empty() || _arcs_caption == caption) {
 		              readArcs();
 		              arcs_done = true;
+		            }
 		          } else if (section == "attributes" && !attributes_done) {
 		            if (_attributes_caption.empty() || _attributes_caption == caption) {
 		              readAttributes();
 		              attributes_done = true;
+		            }
 		          } else {
 		            readLine();
 		            skipSection();
+		          }
 		        } catch (DataFormatError& error) {
 		          error.line(line_num);
 		          throw;
+		        }
+		      }
 		      if (!nodes_done) {
 		        throw DataFormatError("Section @nodes not found");
+		      }
 		      if (!arcs_done) {
 		        throw DataFormatError("Section @arcs not found");
+		      }
 		      if (!attributes_done && !_attributes.empty()) {
 		        throw DataFormatError("Section @attributes not found");
+		      }
+		    }
 		    /// @}
 		  };
 		  /// \brief Return a \ref DigraphReader class
 		  ///
 		  /// This function just returns a \ref DigraphReader class.
 		  /// \relates DigraphReader
 		  template <typename Digraph>
 		  DigraphReader<Digraph> digraphReader(std::istream& is, Digraph& digraph) {
 		    DigraphReader<Digraph> tmp(is, digraph);
 		  DigraphReader<Digraph> digraphReader(Digraph& digraph,
 		                                       std::istream& is = std::cin) {
 		    DigraphReader<Digraph> tmp(digraph, is);
 		    return tmp;
+		  }
 		  /// \brief Return a \ref DigraphReader class
 		  ///
 		  /// This function just returns a \ref DigraphReader class.
 		  /// \relates DigraphReader
 		  template <typename Digraph>
 		  DigraphReader<Digraph> digraphReader(const std::string& fn,
 		                                       Digraph& digraph) {
-		    DigraphReader<Digraph> tmp(fn, digraph);
+		  DigraphReader<Digraph> digraphReader(Digraph& digraph,
 		                                       const std::string& fn) {
 		    DigraphReader<Digraph> tmp(digraph, fn);
 		    return tmp;
+		  }
 		  /// \brief Return a \ref DigraphReader class
 		  ///
 		  /// This function just returns a \ref DigraphReader class.
 		  /// \relates DigraphReader
 		  template <typename Digraph>
 		  DigraphReader<Digraph> digraphReader(const char* fn, Digraph& digraph) {
 		    DigraphReader<Digraph> tmp(fn, digraph);
 		  DigraphReader<Digraph> digraphReader(Digraph& digraph, const char* fn) {
 		    DigraphReader<Digraph> tmp(digraph, fn);
 		    return tmp;
+		  }
 		  template <typename Graph>
 		  class GraphReader;
 		  template <typename Graph>
-		  GraphReader<Graph> graphReader(std::istream& is, Graph& graph);
+		  GraphReader<Graph> graphReader(Graph& graph,
 		                                 std::istream& is = std::cin);
 		  template <typename Graph>
-		  GraphReader<Graph> graphReader(const std::string& fn, Graph& graph);
+		  GraphReader<Graph> graphReader(Graph& graph, const std::string& fn);
 		  template <typename Graph>
-		  GraphReader<Graph> graphReader(const char *fn, Graph& graph);
+		  GraphReader<Graph> graphReader(Graph& graph, const char *fn);
 		  /// \ingroup lemon_io
 		  ///
 		  /// \brief \ref lgf-format "LGF" reader for undirected graphs
 		  ///
 		  /// This utility reads an \ref lgf-format "LGF" file.
 		  ///
 		  /// It can be used almost the same way as \c DigraphReader.
 		  /// The only difference is that this class can handle edges and
 		  /// edge maps as well as arcs and arc maps.
 		  ///
 		  /// The columns in the \c \@edges (or \c \@arcs) section are the
 		  /// edge maps. However, if there are two maps with the same name
 		  /// prefixed with \c '+' and \c '-', then these can be read into an
 		  /// arc map.  Similarly, an attribute can be read into an arc, if
 		  /// it's value is an edge label prefixed with \c '+' or \c '-'.
 		  template <typename _Graph>
 		  class GraphReader {
 		  public:
 		    typedef _Graph Graph;
 		    TEMPLATE_GRAPH_TYPEDEFS(Graph);
 		  private:
 		    std::istream* _is;
 		    bool local_is;
 		    Graph& _graph;
 		    std::string _nodes_caption;
 		    std::string _edges_caption;
 		    std::string _attributes_caption;
 		    typedef std::map<std::string, Node> NodeIndex;
 		    NodeIndex _node_index;
 		    typedef std::map<std::string, Edge> EdgeIndex;
 		    EdgeIndex _edge_index;
 		    typedef std::vector<std::pair<std::string,
 		      _reader_bits::MapStorageBase<Node>*> > NodeMaps;
 		    NodeMaps _node_maps;
 		    typedef std::vector<std::pair<std::string,
 		      _reader_bits::MapStorageBase<Edge>*> > EdgeMaps;
 		    EdgeMaps _edge_maps;
 		    typedef std::multimap<std::string, _reader_bits::ValueStorageBase*>
 		      Attributes;
 		    Attributes _attributes;
 		    bool _use_nodes;
 		    bool _use_edges;
 		    bool _skip_nodes;
 		    bool _skip_edges;
 		    int line_num;
 		    std::istringstream line;
 		  public:
 		    /// \brief Constructor
 		    ///
 		    /// Construct an undirected graph reader, which reads from the given
 		    /// input stream.
-		    GraphReader(std::istream& is, Graph& graph)
+		    GraphReader(Graph& graph, std::istream& is = std::cin)
 		      : _is(&is), local_is(false), _graph(graph),
 		        _use_nodes(false), _use_edges(false),
 		        _skip_nodes(false), _skip_edges(false) {}
 		    /// \brief Constructor
 		    ///
 		    /// Construct an undirected graph reader, which reads from the given
 		    /// file.
-		    GraphReader(const std::string& fn, Graph& graph)
+		    GraphReader(Graph& graph, const std::string& fn)
 		      : _is(new std::ifstream(fn.c_str())), local_is(true), _graph(graph),
 		        _use_nodes(false), _use_edges(false),
 		        _skip_nodes(false), _skip_edges(false) {}
 		    /// \brief Constructor
 		    ///
 		    /// Construct an undirected graph reader, which reads from the given
 		    /// file.
-		    GraphReader(const char* fn, Graph& graph)
+		    GraphReader(Graph& graph, const char* fn)
 		      : _is(new std::ifstream(fn)), local_is(true), _graph(graph),
 		        _use_nodes(false), _use_edges(false),
 		        _skip_nodes(false), _skip_edges(false) {}
 		    /// \brief Destructor
 		    ~GraphReader() {
 		      for (typename NodeMaps::iterator it = _node_maps.begin();
 		           it != _node_maps.end(); ++it) {
 		        delete it->second;
+		      }
 		      for (typename EdgeMaps::iterator it = _edge_maps.begin();
 		           it != _edge_maps.end(); ++it) {
 		        delete it->second;
+		      }
 		      for (typename Attributes::iterator it = _attributes.begin();
 		           it != _attributes.end(); ++it) {
 		        delete it->second;
+		      }
 		      if (local_is) {
 		        delete _is;
+		      }
+		    }
 		  private:
 		    friend GraphReader<Graph> graphReader<>(std::istream& is, Graph& graph);
 		    friend GraphReader<Graph> graphReader<>(const std::string& fn,
 		                                            Graph& graph);
 		    friend GraphReader<Graph> graphReader<>(const char *fn, Graph& graph);
 		    friend GraphReader<Graph> graphReader<>(Graph& graph, std::istream& is);
 		    friend GraphReader<Graph> graphReader<>(Graph& graph,
 		                                            const std::string& fn);
 		    friend GraphReader<Graph> graphReader<>(Graph& graph, const char *fn);
 		    GraphReader(GraphReader& other)
 		      : _is(other._is), local_is(other.local_is), _graph(other._graph),
 		        _use_nodes(other._use_nodes), _use_edges(other._use_edges),
 		        _skip_nodes(other._skip_nodes), _skip_edges(other._skip_edges) {
 		      other._is = 0;
 		      other.local_is = false;
 		      _node_index.swap(other._node_index);
 		      _edge_index.swap(other._edge_index);
 		      _node_maps.swap(other._node_maps);
 		      _edge_maps.swap(other._edge_maps);
 		      _attributes.swap(other._attributes);
 		      _nodes_caption = other._nodes_caption;
 		      _edges_caption = other._edges_caption;
 		      _attributes_caption = other._attributes_caption;
+		    }
 		    GraphReader& operator=(const GraphReader&);
 		  public:
 		    /// \name Reading rules
 		    /// @{
 		    /// \brief Node map reading rule
 		    ///
 		    /// Add a node map reading rule to the reader.
 		    template <typename Map>
 		    GraphReader& nodeMap(const std::string& caption, Map& map) {
 		      checkConcept<concepts::WriteMap<Node, typename Map::Value>, Map>();
 		      _reader_bits::MapStorageBase<Node>* storage =
 		        new _reader_bits::MapStorage<Node, Map>(map);
 		      _node_maps.push_back(std::make_pair(caption, storage));
 		      return *this;
+		    }
 		    /// \brief Node map reading rule
 		    ///
 		    /// Add a node map reading rule with specialized converter to the
 		    /// reader.
 		    template <typename Map, typename Converter>
 		    GraphReader& nodeMap(const std::string& caption, Map& map,
 		                           const Converter& converter = Converter()) {
 		      checkConcept<concepts::WriteMap<Node, typename Map::Value>, Map>();
 		      _reader_bits::MapStorageBase<Node>* storage =
 		        new _reader_bits::MapStorage<Node, Map, Converter>(map, converter);
 		      _node_maps.push_back(std::make_pair(caption, storage));
 		      return *this;
+		    }
 		    /// \brief Edge map reading rule
 		    ///
 		    /// Add an edge map reading rule to the reader.
 		    template <typename Map>
 		    GraphReader& edgeMap(const std::string& caption, Map& map) {
 		      checkConcept<concepts::WriteMap<Edge, typename Map::Value>, Map>();
 		      _reader_bits::MapStorageBase<Edge>* storage =
 		        new _reader_bits::MapStorage<Edge, Map>(map);
 		      _edge_maps.push_back(std::make_pair(caption, storage));
@@ -1945,151 +1948,150 @@
 		      line_num = 0;
 		      readLine();
 		      skipSection();
 		      while (readSuccess()) {
 		        try {
 		          char c;
 		          std::string section, caption;
 		          line >> c;
 		          _reader_bits::readToken(line, section);
 		          _reader_bits::readToken(line, caption);
 		          if (line >> c)
 		            throw DataFormatError("Extra character on the end of line");
 		          if (section == "nodes" && !nodes_done) {
 		            if (_nodes_caption.empty() || _nodes_caption == caption) {
 		              readNodes();
 		              nodes_done = true;
+		            }
 		          } else if ((section == "edges" || section == "arcs") &&
 		                     !edges_done) {
 		            if (_edges_caption.empty() || _edges_caption == caption) {
 		              readEdges();
 		              edges_done = true;
+		            }
 		          } else if (section == "attributes" && !attributes_done) {
 		            if (_attributes_caption.empty() || _attributes_caption == caption) {
 		              readAttributes();
 		              attributes_done = true;
+		            }
 		          } else {
 		            readLine();
 		            skipSection();
+		          }
 		        } catch (DataFormatError& error) {
 		          error.line(line_num);
 		          throw;
+		        }
+		      }
 		      if (!nodes_done) {
 		        throw DataFormatError("Section @nodes not found");
+		      }
 		      if (!edges_done) {
 		        throw DataFormatError("Section @edges not found");
+		      }
 		      if (!attributes_done && !_attributes.empty()) {
 		        throw DataFormatError("Section @attributes not found");
+		      }
+		    }
 		    /// @}
 		  };
 		  /// \brief Return a \ref GraphReader class
 		  ///
 		  /// This function just returns a \ref GraphReader class.
 		  /// \relates GraphReader
 		  template <typename Graph>
 		  GraphReader<Graph> graphReader(std::istream& is, Graph& graph) {
 		    GraphReader<Graph> tmp(is, graph);
 		  GraphReader<Graph> graphReader(Graph& graph, std::istream& is = std::cin) {
 		    GraphReader<Graph> tmp(graph, is);
 		    return tmp;
+		  }
 		  /// \brief Return a \ref GraphReader class
 		  ///
 		  /// This function just returns a \ref GraphReader class.
 		  /// \relates GraphReader
 		  template <typename Graph>
 		  GraphReader<Graph> graphReader(const std::string& fn,
 		                                       Graph& graph) {
-		    GraphReader<Graph> tmp(fn, graph);
+		  GraphReader<Graph> graphReader(Graph& graph, const std::string& fn) {
 		    GraphReader<Graph> tmp(graph, fn);
 		    return tmp;
+		  }
 		  /// \brief Return a \ref GraphReader class
 		  ///
 		  /// This function just returns a \ref GraphReader class.
 		  /// \relates GraphReader
 		  template <typename Graph>
 		  GraphReader<Graph> graphReader(const char* fn, Graph& graph) {
 		    GraphReader<Graph> tmp(fn, graph);
 		  GraphReader<Graph> graphReader(Graph& graph, const char* fn) {
 		    GraphReader<Graph> tmp(graph, fn);
 		    return tmp;
+		  }
 		  class SectionReader;
 		  SectionReader sectionReader(std::istream& is);
 		  SectionReader sectionReader(const std::string& fn);
 		  SectionReader sectionReader(const char* fn);
 		  /// \ingroup lemon_io
 		  ///
 		  /// \brief Section reader class
 		  ///
 		  /// In the \ref lgf-format "LGF" file extra sections can be placed,
 		  /// which contain any data in arbitrary format. Such sections can be
 		  /// read with this class. A reading rule can be added to the class
 		  /// with two different functions. With the \c sectionLines() function a
 		  /// functor can process the section line-by-line, while with the \c
 		  /// sectionStream() member the section can be read from an input
 		  /// stream.
 		  class SectionReader {
 		  private:
 		    std::istream* _is;
 		    bool local_is;
 		    typedef std::map<std::string, _reader_bits::Section*> Sections;
 		    Sections _sections;
 		    int line_num;
 		    std::istringstream line;
 		  public:
 		    /// \brief Constructor
 		    ///
 		    /// Construct a section reader, which reads from the given input
 		    /// stream.
 		    SectionReader(std::istream& is)
 		      : _is(&is), local_is(false) {}
 		    /// \brief Constructor
 		    ///
 		    /// Construct a section reader, which reads from the given file.
 		    SectionReader(const std::string& fn)
 		      : _is(new std::ifstream(fn.c_str())), local_is(true) {}
 		    /// \brief Constructor
 		    ///
 		    /// Construct a section reader, which reads from the given file.
 		    SectionReader(const char* fn)
 		      : _is(new std::ifstream(fn)), local_is(true) {}
 		    /// \brief Destructor
 		    ~SectionReader() {
 		      for (Sections::iterator it = _sections.begin();
 		           it != _sections.end(); ++it) {
 		        delete it->second;
+		      }
 		      if (local_is) {
 		        delete _is;
+		      }

lemon/lgf_writer.h

Show inline comments

@@ -291,278 +291,278 @@
+		      }
 		      return false;
+		    }
 		    inline std::ostream& writeToken(std::ostream& os, const std::string& str) {
 		      if (requireEscape(str)) {
 		        os << '\"';
 		        for (std::string::const_iterator it = str.begin();
 		             it != str.end(); ++it) {
 		          writeEscape(os, *it);
+		        }
 		        os << '\"';
 		      } else {
 		        os << str;
+		      }
 		      return os;
+		    }
 		    class Section {
 		    public:
 		      virtual ~Section() {}
 		      virtual void process(std::ostream& os) = 0;
 		    };
 		    template <typename Functor>
 		    class LineSection : public Section {
 		    private:
 		      Functor _functor;
 		    public:
 		      LineSection(const Functor& functor) : _functor(functor) {}
 		      virtual ~LineSection() {}
 		      virtual void process(std::ostream& os) {
 		        std::string line;
 		        while (!(line = _functor()).empty()) os << line << std::endl;
+		      }
 		    };
 		    template <typename Functor>
 		    class StreamSection : public Section {
 		    private:
 		      Functor _functor;
 		    public:
 		      StreamSection(const Functor& functor) : _functor(functor) {}
 		      virtual ~StreamSection() {}
 		      virtual void process(std::ostream& os) {
 		        _functor(os);
+		      }
 		    };
+		  }
 		  template <typename Digraph>
 		  class DigraphWriter;
 		  template <typename Digraph>
 		  DigraphWriter<Digraph> digraphWriter(std::ostream& os,
 		                                       const Digraph& digraph);
 		  DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,
 		                                       std::ostream& os = std::cout);
 		  template <typename Digraph>
 		  DigraphWriter<Digraph> digraphWriter(const std::string& fn,
 		                                       const Digraph& digraph);
 		  DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,
 		                                       const std::string& fn);
 		  template <typename Digraph>
 		  DigraphWriter<Digraph> digraphWriter(const char *fn,
 		                                       const Digraph& digraph);
 		  DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,
 		                                       const char *fn);
 		  /// \ingroup lemon_io
 		  ///
 		  /// \brief \ref lgf-format "LGF" writer for directed graphs
 		  ///
 		  /// This utility writes an \ref lgf-format "LGF" file.
 		  ///
 		  /// The writing method does a batch processing. The user creates a
 		  /// writer object, then various writing rules can be added to the
 		  /// writer, and eventually the writing is executed with the \c run()
 		  /// member function. A map writing rule can be added to the writer
 		  /// with the \c nodeMap() or \c arcMap() members. An optional
 		  /// converter parameter can also be added as a standard functor
 		  /// converting from the value type of the map to \c std::string. If it
 		  /// is set, it will determine how the value type of the map is written to
 		  /// 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>(std::cout, digraph).
+		  /// DigraphWriter<Digraph>(digraph, std::cout).
 		  ///   nodeMap("coordinates", coord_map).
 		  ///   nodeMap("size", size).
 		  ///   nodeMap("title", title).
 		  ///   arcMap("capacity", cap_map).
 		  ///   node("source", src).
 		  ///   node("target", trg).
 		  ///   attribute("caption", caption).
 		  ///   run();
 		  ///\endcode
 		  ///
 		  ///
 		  /// By default, the writer does not write additional captions to the
 		  /// sections, but they can be give as an optional parameter of
 		  /// the \c nodes(), \c arcs() or \c
 		  /// attributes() functions.
 		  ///
 		  /// The \c skipNodes() and \c skipArcs() functions forbid the
 		  /// writing of the sections. If two arc sections should be written
 		  /// to the output, it can be done in two passes, the first pass
 		  /// 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 _Digraph>
 		  class DigraphWriter {
 		  public:
 		    typedef _Digraph Digraph;
 		    TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
 		  private:
 		    std::ostream* _os;
 		    bool local_os;
 		    const Digraph& _digraph;
 		    std::string _nodes_caption;
 		    std::string _arcs_caption;
 		    std::string _attributes_caption;
 		    typedef std::map<Node, std::string> NodeIndex;
 		    NodeIndex _node_index;
 		    typedef std::map<Arc, std::string> ArcIndex;
 		    ArcIndex _arc_index;
 		    typedef std::vector<std::pair<std::string,
 		      _writer_bits::MapStorageBase<Node>* > > NodeMaps;
 		    NodeMaps _node_maps;
 		    typedef std::vector<std::pair<std::string,
 		      _writer_bits::MapStorageBase<Arc>* > >ArcMaps;
 		    ArcMaps _arc_maps;
 		    typedef std::vector<std::pair<std::string,
 		      _writer_bits::ValueStorageBase*> > Attributes;
 		    Attributes _attributes;
 		    bool _skip_nodes;
 		    bool _skip_arcs;
 		  public:
 		    /// \brief Constructor
 		    ///
 		    /// Construct a directed graph writer, which writes to the given
 		    /// output stream.
 		    DigraphWriter(std::ostream& is, const Digraph& digraph)
 		      : _os(&is), local_os(false), _digraph(digraph),
 		    DigraphWriter(const Digraph& 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 std::string& fn, const Digraph& digraph)
+		    DigraphWriter(const Digraph& digraph, const std::string& fn)
 		      : _os(new std::ofstream(fn.c_str())), local_os(true), _digraph(digraph),
 		        _skip_nodes(false), _skip_arcs(false) {}
 		    /// \brief Constructor
 		    ///
 		    /// Construct a directed graph writer, which writes to the given
 		    /// output file.
-		    DigraphWriter(const char* fn, const Digraph& digraph)
+		    DigraphWriter(const Digraph& digraph, const char* fn)
 		      : _os(new std::ofstream(fn)), local_os(true), _digraph(digraph),
 		        _skip_nodes(false), _skip_arcs(false) {}
 		    /// \brief Destructor
 		    ~DigraphWriter() {
 		      for (typename NodeMaps::iterator it = _node_maps.begin();
 		           it != _node_maps.end(); ++it) {
 		        delete it->second;
+		      }
 		      for (typename ArcMaps::iterator it = _arc_maps.begin();
 		           it != _arc_maps.end(); ++it) {
 		        delete it->second;
+		      }
 		      for (typename Attributes::iterator it = _attributes.begin();
 		           it != _attributes.end(); ++it) {
 		        delete it->second;
+		      }
 		      if (local_os) {
 		        delete _os;
+		      }
+		    }
 		  private:
 		    friend DigraphWriter<Digraph> digraphWriter<>(std::ostream& os,
 		                                                  const Digraph& digraph);
 		    friend DigraphWriter<Digraph> digraphWriter<>(const std::string& fn,
 		                                                  const Digraph& digraph);
 		    friend DigraphWriter<Digraph> digraphWriter<>(const char *fn,
 		                                                  const Digraph& digraph);
 		    friend DigraphWriter<Digraph> digraphWriter<>(const Digraph& digraph,
 		                                                  std::ostream& os);
 		    friend DigraphWriter<Digraph> digraphWriter<>(const Digraph& digraph,
 		                                                  const std::string& fn);
 		    friend DigraphWriter<Digraph> digraphWriter<>(const Digraph& 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) {
 		      other._os = 0;
 		      other.local_os = false;
 		      _node_index.swap(other._node_index);
 		      _arc_index.swap(other._arc_index);
 		      _node_maps.swap(other._node_maps);
 		      _arc_maps.swap(other._arc_maps);
 		      _attributes.swap(other._attributes);
 		      _nodes_caption = other._nodes_caption;
 		      _arcs_caption = other._arcs_caption;
 		      _attributes_caption = other._attributes_caption;
+		    }
 		    DigraphWriter& operator=(const DigraphWriter&);
 		  public:
 		    /// \name Writing rules
 		    /// @{
 		    /// \brief Node map writing rule
 		    ///
 		    /// Add a node map writing rule to the writer.
 		    template <typename Map>
 		    DigraphWriter& nodeMap(const std::string& caption, const Map& map) {
 		      checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
 		      _writer_bits::MapStorageBase<Node>* storage =
 		        new _writer_bits::MapStorage<Node, Map>(map);
 		      _node_maps.push_back(std::make_pair(caption, storage));
 		      return *this;
+		    }
 		    /// \brief Node map writing rule
 		    ///
 		    /// Add a node map writing rule with specialized converter to the
 		    /// writer.
 		    template <typename Map, typename Converter>
 		    DigraphWriter& nodeMap(const std::string& caption, const Map& map,
 		                           const Converter& converter = Converter()) {
 		      checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
 		      _writer_bits::MapStorageBase<Node>* storage =
 		        new _writer_bits::MapStorage<Node, Map, Converter>(map, converter);
 		      _node_maps.push_back(std::make_pair(caption, storage));
 		      return *this;
+		    }
 		    /// \brief Arc map writing rule
 		    ///
 		    /// Add an arc map writing rule to the writer.
 		    template <typename Map>
 		    DigraphWriter& arcMap(const std::string& caption, const Map& map) {
 		      checkConcept<concepts::ReadMap<Arc, typename Map::Value>, Map>();
 		      _writer_bits::MapStorageBase<Arc>* storage =
 		        new _writer_bits::MapStorage<Arc, Map>(map);
 		      _arc_maps.push_back(std::make_pair(caption, storage));
 		      return *this;
+		    }
@@ -847,278 +847,279 @@
 		          std::ostringstream os;
 		          os << _digraph.id(a);
 		          _arc_index.insert(std::make_pair(a, os.str()));
+		        }
 		      } else {
 		        for (ArcIt a(_digraph); a != INVALID; ++a) {
 		          std::string value = label->get(a);
 		          _arc_index.insert(std::make_pair(a, value));
+		        }
+		      }
+		    }
 		    void writeAttributes() {
 		      if (_attributes.empty()) return;
 		      *_os << "@attributes";
 		      if (!_attributes_caption.empty()) {
 		        _writer_bits::writeToken(*_os << ' ', _attributes_caption);
+		      }
 		      *_os << std::endl;
 		      for (typename Attributes::iterator it = _attributes.begin();
 		           it != _attributes.end(); ++it) {
 		        _writer_bits::writeToken(*_os, it->first) << ' ';
 		        _writer_bits::writeToken(*_os, it->second->get());
 		        *_os << std::endl;
+		      }
+		    }
 		  public:
 		    /// \name Execution of the writer
 		    /// @{
 		    /// \brief Start the batch processing
 		    ///
 		    /// This function starts the batch processing.
 		    void run() {
 		      if (!_skip_nodes) {
 		        writeNodes();
 		      } else {
 		        createNodeIndex();
+		      }
 		      if (!_skip_arcs) {
 		        writeArcs();
 		      } else {
 		        createArcIndex();
+		      }
 		      writeAttributes();
+		    }
 		    /// \brief Give back the stream of the writer
 		    ///
 		    /// Give back the stream of the writer.
 		    std::ostream& ostream() {
 		      return *_os;
+		    }
 		    /// @}
 		  };
 		  /// \brief Return a \ref DigraphWriter class
 		  ///
 		  /// This function just returns a \ref DigraphWriter class.
 		  /// \relates DigraphWriter
 		  template <typename Digraph>
 		  DigraphWriter<Digraph> digraphWriter(std::ostream& os,
 		                                       const Digraph& digraph) {
-		    DigraphWriter<Digraph> tmp(os, digraph);
+		  DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,
 		                                       std::ostream& os = std::cout) {
 		    DigraphWriter<Digraph> tmp(digraph, os);
 		    return tmp;
+		  }
 		  /// \brief Return a \ref DigraphWriter class
 		  ///
 		  /// This function just returns a \ref DigraphWriter class.
 		  /// \relates DigraphWriter
 		  template <typename Digraph>
 		  DigraphWriter<Digraph> digraphWriter(const std::string& fn,
 		                                       const Digraph& digraph) {
-		    DigraphWriter<Digraph> tmp(fn, digraph);
+		  DigraphWriter<Digraph> digraphWriter(const Digraph& digraph,
 		                                       const std::string& fn) {
 		    DigraphWriter<Digraph> tmp(digraph, fn);
 		    return tmp;
+		  }
 		  /// \brief Return a \ref DigraphWriter class
 		  ///
 		  /// This function just returns a \ref DigraphWriter class.
 		  /// \relates DigraphWriter
 		  template <typename Digraph>
 		  DigraphWriter<Digraph> digraphWriter(const char* fn,
 		                                       const Digraph& digraph) {
-		    DigraphWriter<Digraph> tmp(fn, 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>
-		  GraphWriter<Graph> graphWriter(std::ostream& os, const Graph& graph);
+		  GraphWriter<Graph> graphWriter(const Graph& graph,
 		                                 std::ostream& os = std::cout);
 		  template <typename Graph>
-		  GraphWriter<Graph> graphWriter(const std::string& fn, const Graph& graph);
+		  GraphWriter<Graph> graphWriter(const Graph& graph, const std::string& fn);
 		  template <typename Graph>
-		  GraphWriter<Graph> graphWriter(const char *fn, const Graph& graph);
+		  GraphWriter<Graph> graphWriter(const Graph& graph, const char *fn);
 		  /// \ingroup lemon_io
 		  ///
 		  /// \brief \ref lgf-format "LGF" writer for directed graphs
 		  ///
 		  /// This utility writes an \ref lgf-format "LGF" file.
 		  ///
 		  /// It can be used almost the same way as \c DigraphWriter.
 		  /// The only difference is that this class can handle edges and
 		  /// edge maps as well as arcs and arc maps.
 		  ///
 		  /// The arc maps are written into the file as two columns, the
 		  /// caption of the columns are the name of the map prefixed with \c
 		  /// '+' and \c '-'. The arcs are written into the \c \@attributes
 		  /// section as a \c '+' or a \c '-' prefix (depends on the direction
 		  /// of the arc) and the label of corresponding edge.
 		  template <typename _Graph>
 		  class GraphWriter {
 		  public:
 		    typedef _Graph Graph;
 		    TEMPLATE_GRAPH_TYPEDEFS(Graph);
 		  private:
 		    std::ostream* _os;
 		    bool local_os;
 		    const Graph& _graph;
 		    std::string _nodes_caption;
 		    std::string _edges_caption;
 		    std::string _attributes_caption;
 		    typedef std::map<Node, std::string> NodeIndex;
 		    NodeIndex _node_index;
 		    typedef std::map<Edge, std::string> EdgeIndex;
 		    EdgeIndex _edge_index;
 		    typedef std::vector<std::pair<std::string,
 		      _writer_bits::MapStorageBase<Node>* > > NodeMaps;
 		    NodeMaps _node_maps;
 		    typedef std::vector<std::pair<std::string,
 		      _writer_bits::MapStorageBase<Edge>* > >EdgeMaps;
 		    EdgeMaps _edge_maps;
 		    typedef std::vector<std::pair<std::string,
 		      _writer_bits::ValueStorageBase*> > Attributes;
 		    Attributes _attributes;
 		    bool _skip_nodes;
 		    bool _skip_edges;
 		  public:
 		    /// \brief Constructor
 		    ///
 		    /// Construct a directed graph writer, which writes to the given
 		    /// output stream.
 		    GraphWriter(std::ostream& is, const Graph& graph)
 		      : _os(&is), local_os(false), _graph(graph),
 		    GraphWriter(const Graph& 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 std::string& fn, const Graph& graph)
+		    GraphWriter(const Graph& graph, const std::string& fn)
 		      : _os(new std::ofstream(fn.c_str())), local_os(true), _graph(graph),
 		        _skip_nodes(false), _skip_edges(false) {}
 		    /// \brief Constructor
 		    ///
 		    /// Construct a directed graph writer, which writes to the given
 		    /// output file.
-		    GraphWriter(const char* fn, const Graph& graph)
+		    GraphWriter(const Graph& graph, const char* fn)
 		      : _os(new std::ofstream(fn)), local_os(true), _graph(graph),
 		        _skip_nodes(false), _skip_edges(false) {}
 		    /// \brief Destructor
 		    ~GraphWriter() {
 		      for (typename NodeMaps::iterator it = _node_maps.begin();
 		           it != _node_maps.end(); ++it) {
 		        delete it->second;
+		      }
 		      for (typename EdgeMaps::iterator it = _edge_maps.begin();
 		           it != _edge_maps.end(); ++it) {
 		        delete it->second;
+		      }
 		      for (typename Attributes::iterator it = _attributes.begin();
 		           it != _attributes.end(); ++it) {
 		        delete it->second;
+		      }
 		      if (local_os) {
 		        delete _os;
+		      }
+		    }
 		  private:
 		    friend GraphWriter<Graph> graphWriter<>(std::ostream& os,
 		                                            const Graph& graph);
 		    friend GraphWriter<Graph> graphWriter<>(const std::string& fn,
 		                                            const Graph& graph);
 		    friend GraphWriter<Graph> graphWriter<>(const char *fn,
 		                                            const Graph& graph);
 		    friend GraphWriter<Graph> graphWriter<>(const Graph& graph,
 		                                            std::ostream& os);
 		    friend GraphWriter<Graph> graphWriter<>(const Graph& graph,
 		                                            const std::string& 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) {
 		      other._os = 0;
 		      other.local_os = false;
 		      _node_index.swap(other._node_index);
 		      _edge_index.swap(other._edge_index);
 		      _node_maps.swap(other._node_maps);
 		      _edge_maps.swap(other._edge_maps);
 		      _attributes.swap(other._attributes);
 		      _nodes_caption = other._nodes_caption;
 		      _edges_caption = other._edges_caption;
 		      _attributes_caption = other._attributes_caption;
+		    }
 		    GraphWriter& operator=(const GraphWriter&);
 		  public:
 		    /// \name Writing rules
 		    /// @{
 		    /// \brief Node map writing rule
 		    ///
 		    /// Add a node map writing rule to the writer.
 		    template <typename Map>
 		    GraphWriter& nodeMap(const std::string& caption, const Map& map) {
 		      checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
 		      _writer_bits::MapStorageBase<Node>* storage =
 		        new _writer_bits::MapStorage<Node, Map>(map);
 		      _node_maps.push_back(std::make_pair(caption, storage));
 		      return *this;
+		    }
 		    /// \brief Node map writing rule
 		    ///
 		    /// Add a node map writing rule with specialized converter to the
 		    /// writer.
 		    template <typename Map, typename Converter>
 		    GraphWriter& nodeMap(const std::string& caption, const Map& map,
 		                           const Converter& converter = Converter()) {
 		      checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
 		      _writer_bits::MapStorageBase<Node>* storage =
 		        new _writer_bits::MapStorage<Node, Map, Converter>(map, converter);
 		      _node_maps.push_back(std::make_pair(caption, storage));
 		      return *this;
+		    }
 		    /// \brief Edge map writing rule
 		    ///
 		    /// Add an edge map writing rule to the writer.
 		    template <typename Map>
 		    GraphWriter& edgeMap(const std::string& caption, const Map& map) {
 		      checkConcept<concepts::ReadMap<Edge, typename Map::Value>, Map>();
 		      _writer_bits::MapStorageBase<Edge>* storage =
 		        new _writer_bits::MapStorage<Edge, Map>(map);
 		      _edge_maps.push_back(std::make_pair(caption, storage));
 		      return *this;
+		    }
@@ -1449,150 +1450,151 @@
 		          std::ostringstream os;
 		          os << _graph.id(e);
 		          _edge_index.insert(std::make_pair(e, os.str()));
+		        }
 		      } else {
 		        for (EdgeIt e(_graph); e != INVALID; ++e) {
 		          std::string value = label->get(e);
 		          _edge_index.insert(std::make_pair(e, value));
+		        }
+		      }
+		    }
 		    void writeAttributes() {
 		      if (_attributes.empty()) return;
 		      *_os << "@attributes";
 		      if (!_attributes_caption.empty()) {
 		        _writer_bits::writeToken(*_os << ' ', _attributes_caption);
+		      }
 		      *_os << std::endl;
 		      for (typename Attributes::iterator it = _attributes.begin();
 		           it != _attributes.end(); ++it) {
 		        _writer_bits::writeToken(*_os, it->first) << ' ';
 		        _writer_bits::writeToken(*_os, it->second->get());
 		        *_os << std::endl;
+		      }
+		    }
 		  public:
 		    /// \name Execution of the writer
 		    /// @{
 		    /// \brief Start the batch processing
 		    ///
 		    /// This function starts the batch processing.
 		    void run() {
 		      if (!_skip_nodes) {
 		        writeNodes();
 		      } else {
 		        createNodeIndex();
+		      }
 		      if (!_skip_edges) {
 		        writeEdges();
 		      } else {
 		        createEdgeIndex();
+		      }
 		      writeAttributes();
+		    }
 		    /// \brief Give back the stream of the writer
 		    ///
 		    /// Give back the stream of the writer
 		    std::ostream& ostream() {
 		      return *_os;
+		    }
 		    /// @}
 		  };
 		  /// \brief Return a \ref GraphWriter class
 		  ///
 		  /// This function just returns a \ref GraphWriter class.
 		  /// \relates GraphWriter
 		  template <typename Graph>
 		  GraphWriter<Graph> graphWriter(std::ostream& os, const Graph& graph) {
 		    GraphWriter<Graph> tmp(os, graph);
 		  GraphWriter<Graph> graphWriter(const Graph& graph,
 		                                 std::ostream& os = std::cout) {
 		    GraphWriter<Graph> tmp(graph, os);
 		    return tmp;
+		  }
 		  /// \brief Return a \ref GraphWriter class
 		  ///
 		  /// This function just returns a \ref GraphWriter class.
 		  /// \relates GraphWriter
 		  template <typename Graph>
 		  GraphWriter<Graph> graphWriter(const std::string& fn, const Graph& graph) {
 		    GraphWriter<Graph> tmp(fn, graph);
 		  GraphWriter<Graph> graphWriter(const Graph& graph, const std::string& fn) {
 		    GraphWriter<Graph> tmp(graph, fn);
 		    return tmp;
+		  }
 		  /// \brief Return a \ref GraphWriter class
 		  ///
 		  /// This function just returns a \ref GraphWriter class.
 		  /// \relates GraphWriter
 		  template <typename Graph>
 		  GraphWriter<Graph> graphWriter(const char* fn, const Graph& graph) {
 		    GraphWriter<Graph> tmp(fn, graph);
 		  GraphWriter<Graph> graphWriter(const Graph& graph, const char* fn) {
 		    GraphWriter<Graph> tmp(graph, fn);
 		    return tmp;
+		  }
 		  class SectionWriter;
 		  SectionWriter sectionWriter(std::istream& is);
 		  SectionWriter sectionWriter(const std::string& fn);
 		  SectionWriter sectionWriter(const char* fn);
 		  /// \ingroup lemon_io
 		  ///
 		  /// \brief Section writer class
 		  ///
 		  /// In the \ref lgf-format "LGF" file extra sections can be placed,
 		  /// which contain any data in arbitrary format. Such sections can be
 		  /// written with this class. A writing rule can be added to the
 		  /// class with two different functions. With the \c sectionLines()
 		  /// function a generator can write the section line-by-line, while
 		  /// with the \c sectionStream() member the section can be written to
 		  /// an output stream.
 		  class SectionWriter {
 		  private:
 		    std::ostream* _os;
 		    bool local_os;
 		    typedef std::vector<std::pair<std::string, _writer_bits::Section*> >
 		    Sections;
 		    Sections _sections;
 		  public:
 		    /// \brief Constructor
 		    ///
 		    /// Construct a section writer, which writes to the given output
 		    /// stream.
 		    SectionWriter(std::ostream& os)
 		      : _os(&os), local_os(false) {}
 		    /// \brief Constructor
 		    ///
 		    /// Construct a section writer, which writes into the given file.
 		    SectionWriter(const std::string& fn)
 		      : _os(new std::ofstream(fn.c_str())), local_os(true) {}
 		    /// \brief Constructor
 		    ///
 		    /// Construct a section writer, which writes into the given file.
 		    SectionWriter(const char* fn)
 		      : _os(new std::ofstream(fn)), local_os(true) {}
 		    /// \brief Destructor
 		    ~SectionWriter() {
 		      for (Sections::iterator it = _sections.begin();
 		           it != _sections.end(); ++it) {
 		        delete it->second;
+		      }
 		      if (local_os) {
 		        delete _os;
+		      }
+		    }

test/bfs_test.cc

Show inline comments

@@ -83,115 +83,115 @@
+		  }
+		  {
 		    BType
 		      ::SetPredMap<concepts::ReadWriteMap<Node,Arc> >
 		      ::SetDistMap<concepts::ReadWriteMap<Node,int> >
 		      ::SetReachedMap<concepts::ReadWriteMap<Node,bool> >
 		      ::SetProcessedMap<concepts::WriteMap<Node,bool> >
 		      ::SetStandardProcessedMap
 		      ::Create bfs_test(G);
 		    bfs_test.run(s);
 		    bfs_test.run(s,t);
 		    bfs_test.run();
 		    l  = bfs_test.dist(t);
 		    e  = bfs_test.predArc(t);
 		    s  = bfs_test.predNode(t);
 		    b  = bfs_test.reached(t);
 		    pp = bfs_test.path(t);
+		  }
+		}
 		void checkBfsFunctionCompile()
+		{
 		  typedef int VType;
 		  typedef concepts::Digraph Digraph;
 		  typedef Digraph::Arc Arc;
 		  typedef Digraph::Node Node;
 		  Digraph g;
 		  bool b;
 		  bfs(g).run(Node());
 		  b=bfs(g).run(Node(),Node());
 		  bfs(g).run();
 		  bfs(g)
 		    .predMap(concepts::ReadWriteMap<Node,Arc>())
 		    .distMap(concepts::ReadWriteMap<Node,VType>())
 		    .reachedMap(concepts::ReadWriteMap<Node,bool>())
 		    .processedMap(concepts::WriteMap<Node,bool>())
 		    .run(Node());
 		  b=bfs(g)
 		    .predMap(concepts::ReadWriteMap<Node,Arc>())
 		    .distMap(concepts::ReadWriteMap<Node,VType>())
 		    .reachedMap(concepts::ReadWriteMap<Node,bool>())
 		    .processedMap(concepts::WriteMap<Node,bool>())
 		    .path(concepts::Path<Digraph>())
 		    .dist(VType())
 		    .run(Node(),Node());
 		  bfs(g)
 		    .predMap(concepts::ReadWriteMap<Node,Arc>())
 		    .distMap(concepts::ReadWriteMap<Node,VType>())
 		    .reachedMap(concepts::ReadWriteMap<Node,bool>())
 		    .processedMap(concepts::WriteMap<Node,bool>())
 		    .run();
+		}
 		template <class Digraph>
 		void checkBfs() {
 		  TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
 		  Digraph G;
 		  Node s, t;
 		  std::istringstream input(test_lgf);
-		  digraphReader(input, G).
+		  digraphReader(G, input).
 		    node("source", s).
 		    node("target", t).
 		    run();
 		  Bfs<Digraph> bfs_test(G);
 		  bfs_test.run(s);
 		  check(bfs_test.dist(t)==2,"Bfs found a wrong path.");
 		  Path<Digraph> p = bfs_test.path(t);
 		  check(p.length()==2,"path() found a wrong path.");
 		  check(checkPath(G, p),"path() found a wrong path.");
 		  check(pathSource(G, p) == s,"path() found a wrong path.");
 		  check(pathTarget(G, p) == t,"path() found a wrong path.");
 		  for(ArcIt a(G); a!=INVALID; ++a) {
 		    Node u=G.source(a);
 		    Node v=G.target(a);
 		    check( !bfs_test.reached(u) ||
 		           (bfs_test.dist(v) <= bfs_test.dist(u)+1),
 		           "Wrong output. " << G.id(u) << "->" << G.id(v));
+		  }
 		  for(NodeIt v(G); v!=INVALID; ++v) {
 		    if (bfs_test.reached(v)) {
 		      check(v==s || bfs_test.predArc(v)!=INVALID, "Wrong tree.");
 		      if (bfs_test.predArc(v)!=INVALID ) {
 		        Arc a=bfs_test.predArc(v);
 		        Node u=G.source(a);
 		        check(u==bfs_test.predNode(v),"Wrong tree.");
 		        check(bfs_test.dist(v) - bfs_test.dist(u) == 1,
 		              "Wrong distance. Difference: "
 		              << std::abs(bfs_test.dist(v) - bfs_test.dist(u) - 1));
+		      }
+		    }
+		  }
+		  {
 		    NullMap<Node,Arc> myPredMap;
 		    bfs(G).predMap(myPredMap).run(s);
+		  }
+		}
 		int main()
+		{
 		  checkBfs<ListDigraph>();
 		  checkBfs<SmartDigraph>();
 		  return 0;
+		}

test/dfs_test.cc

Show inline comments

@@ -85,104 +85,104 @@
+		  }
+		  {
 		    DType
 		      ::SetPredMap<concepts::ReadWriteMap<Node,Arc> >
 		      ::SetDistMap<concepts::ReadWriteMap<Node,int> >
 		      ::SetReachedMap<concepts::ReadWriteMap<Node,bool> >
 		      ::SetProcessedMap<concepts::WriteMap<Node,bool> >
 		      ::SetStandardProcessedMap
 		      ::Create dfs_test(G);
 		    dfs_test.run(s);
 		    dfs_test.run(s,t);
 		    dfs_test.run();
 		    l  = dfs_test.dist(t);
 		    e  = dfs_test.predArc(t);
 		    s  = dfs_test.predNode(t);
 		    b  = dfs_test.reached(t);
 		    pp = dfs_test.path(t);
+		  }
+		}
 		void checkDfsFunctionCompile()
+		{
 		  typedef int VType;
 		  typedef concepts::Digraph Digraph;
 		  typedef Digraph::Arc Arc;
 		  typedef Digraph::Node Node;
 		  Digraph g;
 		  bool b;
 		  dfs(g).run(Node());
 		  b=dfs(g).run(Node(),Node());
 		  dfs(g).run();
 		  dfs(g)
 		    .predMap(concepts::ReadWriteMap<Node,Arc>())
 		    .distMap(concepts::ReadWriteMap<Node,VType>())
 		    .reachedMap(concepts::ReadWriteMap<Node,bool>())
 		    .processedMap(concepts::WriteMap<Node,bool>())
 		    .run(Node());
 		  b=dfs(g)
 		    .predMap(concepts::ReadWriteMap<Node,Arc>())
 		    .distMap(concepts::ReadWriteMap<Node,VType>())
 		    .reachedMap(concepts::ReadWriteMap<Node,bool>())
 		    .processedMap(concepts::WriteMap<Node,bool>())
 		    .path(concepts::Path<Digraph>())
 		    .dist(VType())
 		    .run(Node(),Node());
 		  dfs(g)
 		    .predMap(concepts::ReadWriteMap<Node,Arc>())
 		    .distMap(concepts::ReadWriteMap<Node,VType>())
 		    .reachedMap(concepts::ReadWriteMap<Node,bool>())
 		    .processedMap(concepts::WriteMap<Node,bool>())
 		    .run();
+		}
 		template <class Digraph>
 		void checkDfs() {
 		  TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
 		  Digraph G;
 		  Node s, t;
 		  std::istringstream input(test_lgf);
-		  digraphReader(input, G).
+		  digraphReader(G, input).
 		    node("source", s).
 		    node("target", t).
 		    run();
 		  Dfs<Digraph> dfs_test(G);
 		  dfs_test.run(s);
 		  Path<Digraph> p = dfs_test.path(t);
 		  check(p.length() == dfs_test.dist(t),"path() found a wrong path.");
 		  check(checkPath(G, p),"path() found a wrong path.");
 		  check(pathSource(G, p) == s,"path() found a wrong path.");
 		  check(pathTarget(G, p) == t,"path() found a wrong path.");
 		  for(NodeIt v(G); v!=INVALID; ++v) {
 		    if (dfs_test.reached(v)) {
 		      check(v==s || dfs_test.predArc(v)!=INVALID, "Wrong tree.");
 		      if (dfs_test.predArc(v)!=INVALID ) {
 		        Arc e=dfs_test.predArc(v);
 		        Node u=G.source(e);
 		        check(u==dfs_test.predNode(v),"Wrong tree.");
 		        check(dfs_test.dist(v) - dfs_test.dist(u) == 1,
 		              "Wrong distance. (" << dfs_test.dist(u) << "->"
 		              << dfs_test.dist(v) << ")");
+		      }
+		    }
+		  }
+		  {
 		    NullMap<Node,Arc> myPredMap;
 		    dfs(G).predMap(myPredMap).run(s);
+		  }
+		}
 		int main()
+		{
 		  checkDfs<ListDigraph>();
 		  checkDfs<SmartDigraph>();
 		  return 0;
+		}

test/dijkstra_test.cc

Show inline comments

@@ -81,116 +81,116 @@
 		    b  = dijkstra_test.reached(t);
 		    d  = dijkstra_test.distMap();
 		    p  = dijkstra_test.predMap();
 		    pp = dijkstra_test.path(t);
+		  }
+		  {
 		    DType
 		      ::SetPredMap<concepts::ReadWriteMap<Node,Arc> >
 		      ::SetDistMap<concepts::ReadWriteMap<Node,VType> >
 		      ::SetProcessedMap<concepts::WriteMap<Node,bool> >
 		      ::SetStandardProcessedMap
 		      ::SetOperationTraits<DijkstraWidestPathOperationTraits<VType> >
 		      ::SetHeap<BinHeap<VType, concepts::ReadWriteMap<Node,int> > >
 		      ::SetStandardHeap<BinHeap<VType, concepts::ReadWriteMap<Node,int> > >
 		      ::Create dijkstra_test(G,length);
 		    dijkstra_test.run(s);
 		    dijkstra_test.run(s,t);
 		    l  = dijkstra_test.dist(t);
 		    e  = dijkstra_test.predArc(t);
 		    s  = dijkstra_test.predNode(t);
 		    b  = dijkstra_test.reached(t);
 		    pp = dijkstra_test.path(t);
+		  }
+		}
 		void checkDijkstraFunctionCompile()
+		{
 		  typedef int VType;
 		  typedef concepts::Digraph Digraph;
 		  typedef Digraph::Arc Arc;
 		  typedef Digraph::Node Node;
 		  typedef concepts::ReadMap<Digraph::Arc,VType> LengthMap;
 		  Digraph g;
 		  bool b;
 		  dijkstra(g,LengthMap()).run(Node());
 		  b=dijkstra(g,LengthMap()).run(Node(),Node());
 		  dijkstra(g,LengthMap())
 		    .predMap(concepts::ReadWriteMap<Node,Arc>())
 		    .distMap(concepts::ReadWriteMap<Node,VType>())
 		    .processedMap(concepts::WriteMap<Node,bool>())
 		    .run(Node());
 		  b=dijkstra(g,LengthMap())
 		    .predMap(concepts::ReadWriteMap<Node,Arc>())
 		    .distMap(concepts::ReadWriteMap<Node,VType>())
 		    .processedMap(concepts::WriteMap<Node,bool>())
 		    .path(concepts::Path<Digraph>())
 		    .dist(VType())
 		    .run(Node(),Node());
+		}
 		template <class Digraph>
 		void checkDijkstra() {
 		  TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
 		  typedef typename Digraph::template ArcMap<int> LengthMap;
 		  Digraph G;
 		  Node s, t;
 		  LengthMap length(G);
 		  std::istringstream input(test_lgf);
-		  digraphReader(input, G).
+		  digraphReader(G, input).
 		    arcMap("length", length).
 		    node("source", s).
 		    node("target", t).
 		    run();
 		  Dijkstra<Digraph, LengthMap>
 		        dijkstra_test(G, length);
 		  dijkstra_test.run(s);
 		  check(dijkstra_test.dist(t)==3,"Dijkstra found a wrong path.");
 		  Path<Digraph> p = dijkstra_test.path(t);
 		  check(p.length()==3,"path() found a wrong path.");
 		  check(checkPath(G, p),"path() found a wrong path.");
 		  check(pathSource(G, p) == s,"path() found a wrong path.");
 		  check(pathTarget(G, p) == t,"path() found a wrong path.");
 		  for(ArcIt e(G); e!=INVALID; ++e) {
 		    Node u=G.source(e);
 		    Node v=G.target(e);
 		    check( !dijkstra_test.reached(u) ||
 		           (dijkstra_test.dist(v) - dijkstra_test.dist(u) <= length[e]),
 		           "Wrong output. dist(target)-dist(source)-arc_length=" <<
 		           dijkstra_test.dist(v) - dijkstra_test.dist(u) - length[e]);
+		  }
 		  for(NodeIt v(G); v!=INVALID; ++v) {
 		    if (dijkstra_test.reached(v)) {
 		      check(v==s || dijkstra_test.predArc(v)!=INVALID, "Wrong tree.");
 		      if (dijkstra_test.predArc(v)!=INVALID ) {
 		        Arc e=dijkstra_test.predArc(v);
 		        Node u=G.source(e);
 		        check(u==dijkstra_test.predNode(v),"Wrong tree.");
 		        check(dijkstra_test.dist(v) - dijkstra_test.dist(u) == length[e],
 		              "Wrong distance! Difference: " <<
 		              std::abs(dijkstra_test.dist(v)-dijkstra_test.dist(u)-length[e]));
+		      }
+		    }
+		  }
+		  {
 		    NullMap<Node,Arc> myPredMap;
 		    dijkstra(G,length).predMap(myPredMap).run(s);
+		  }
+		}
 		int main() {
 		  checkDijkstra<ListDigraph>();
 		  checkDijkstra<SmartDigraph>();
 		  return 0;
+		}

test/heap_test.cc

Show inline comments

@@ -106,82 +106,82 @@
 		void heapIncreaseTest() {
 		  RangeMap<int> map(test_len, -1);
 		  Heap heap(map);
 		  std::vector<int> v(test_len);
 		  for (int i = 0; i < test_len; ++i) {
 		    v[i] = test_seq[i];
 		    heap.push(i, v[i]);
+		  }
 		  for (int i = 0; i < test_len; ++i) {
 		    v[i] += test_inc[i];
 		    heap.increase(i, v[i]);
+		  }
 		  std::sort(v.begin(), v.end());
 		  for (int i = 0; i < test_len; ++i) {
 		    check(v[i] == heap.prio() ,"Wrong order in heap increase test.");
 		    heap.pop();
+		  }
+		}
 		template <typename Heap>
 		void dijkstraHeapTest(const Digraph& digraph, const IntArcMap& length,
 		                      Node source) {
 		  typename Dijkstra<Digraph, IntArcMap>::template SetStandardHeap<Heap>::
 		    Create dijkstra(digraph, length);
 		  dijkstra.run(source);
 		  for(ArcIt a(digraph); a != INVALID; ++a) {
 		    Node s = digraph.source(a);
 		    Node t = digraph.target(a);
 		    if (dijkstra.reached(s)) {
 		      check( dijkstra.dist(t) - dijkstra.dist(s) <= length[a],
 		             "Error in a shortest path tree!");
+		    }
+		  }
 		  for(NodeIt n(digraph); n != INVALID; ++n) {
 		    if ( dijkstra.reached(n) && dijkstra.predArc(n) != INVALID ) {
 		      Arc a = dijkstra.predArc(n);
 		      Node s = digraph.source(a);
 		      check( dijkstra.dist(n) - dijkstra.dist(s) == length[a],
 		             "Error in a shortest path tree!");
+		    }
+		  }
+		}
 		int main() {
 		  typedef int Item;
 		  typedef int Prio;
 		  typedef RangeMap<int> ItemIntMap;
 		  Digraph digraph;
 		  IntArcMap length(digraph);
 		  Node source;
 		  std::istringstream input(test_lgf);
-		  digraphReader(input, digraph).
+		  digraphReader(digraph, input).
 		    arcMap("capacity", length).
 		    node("source", source).
 		    run();
+		  {
 		    typedef BinHeap<Prio, ItemIntMap> IntHeap;
 		    checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
 		    heapSortTest<IntHeap>();
 		    heapIncreaseTest<IntHeap>();
 		    typedef BinHeap<Prio, IntNodeMap > NodeHeap;
 		    checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();
 		    dijkstraHeapTest<NodeHeap>(digraph, length, source);
+		  }
 		  return 0;
+		}

0 comments (0 inline)

RhodeCode

Login to your account