LEMON/LEMON-official Changeset - r156:e561aa7675de

Repositories » LEMON » LEMON-official

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

Changeset - r156:e561aa7675de

« 155:5c3604

157:2ccc1a »

r156:e561aa7675de

Sat, 17 May 2008 07:30:02

[Not Reviewed]

0 comments (0 inline)

alpar (Alpar Juttner)
alpar@cs.elte.hu

More flexible header names in .lgf + largely improved doc

0 4 1

default

5 files changed with 387 insertions and 100 deletions:

doc/lgf.dox

doc/Makefile.am

doc/groups.dox

lemon/lgf_reader.h

154

lemon/lgf_writer.h

136

↑ Collapse diff ↑

doc/lgf.dox

Show inline comments

 		/* -*- C++ -*-
+		 *
 		 * 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.
+		 *
 		 */
 		namespace lemon {
 		/*!
 		\page lgf-format Lemon Graph Format (LGF)
 		The \e LGF is a <em>column oriented</em>
 		file format for storing graphs and associated data like
 		node and edge maps.
 		Each line with \c '#' first non-whitespace
 		character is considered as a comment line.
 		Otherwise the file consists of sections starting with
 		a header line. The header lines starts with an \c '@' character followed by the
 		type of section. The standard section types are \c \@nodes, \c
 		\@arcs and \c \@edges
 		and \@attributes. Each header line may also have an optional
 		\e name, which can be use to distinguish the sections of the same
 		type.
 		The standard sections are column oriented, each line consists of
 		<em>token</em>s separated by whitespaces. A token can be \e plain or
 		\e quoted. A plain token is just a sequence of non-whitespace characters,
 		while a quoted token is a
 		character sequence surrounded by double quotes, and it can also
 		contain whitespaces and escape sequences.
 		The \c \@nodes section describes a set of nodes and associated
 		maps. The first is a header line, it columns are the names of the
 		maps appearing in the following lines.
 		One of the maps must be called \c
 		"label", which plays special role in the file.
 		The following
 		non-empty lines until the next section describes nodes of the
 		graph. Each line contains the values of the node maps
 		associated to the current node.
 		\code
 		 @nodes
 		 label   coordinates size    title
 (10,20)     10      "First node"
 (80,80)     8       "Second node"
 (40,10)     10      "Third node"
 		\endcode
 		The \c \@arcs section is very similar to the \c \@nodes section,
 		it again starts with a header line describing the names of the arc,
 		but the \c "label" map is not obligatory here. The following lines
 		describe the arcs. The first two tokens of each line are
 		the source and the target node of the arc, respectively, then come the map
 		values. The source and target tokens must be node labels.
 		\code
 		 @arcs
 		 	      capacity
 2   16
 3   12
 3   18
 		\endcode
 		The \c \@edges is just a synonym of \c \@arcs.
 		The \c \@attributes section contains key-value pairs, each line
 		consists of two tokens, an attribute name, and then an attribute value.
 		\code
 		 @attributes
 		 source 1
 		 target 3
 		 caption "LEMON test digraph"
 		\endcode
 		*/
+		}
 		//  LocalWords:  whitespace whitespaces

doc/Makefile.am

Show inline comments

 		EXTRA_DIST += \
 			doc/Doxyfile.in \
 			doc/coding_style.dox \
 			doc/dirs.dox \
 			doc/groups.dox \
 			doc/lgf.dox \
 			doc/license.dox \
 			doc/mainpage.dox \
 			doc/namespaces.dox \
 			doc/html
 		DOC_EPS_IMAGES18 = \
 			nodeshape_0.eps \
 			nodeshape_1.eps \
 			nodeshape_2.eps \
 			nodeshape_3.eps \
 			nodeshape_4.eps
 		DOC_EPS_IMAGES = \
 			$(DOC_EPS_IMAGES18)
 		DOC_PNG_IMAGES = \
 			$(DOC_EPS_IMAGES:%.eps=doc/gen-images/%.png)
 		EXTRA_DIST += $(DOC_EPS_IMAGES:%=doc/images/%)
 		doc/html:
 			$(MAKE) $(AM_MAKEFLAGS) html
 		GS_COMMAND=gs -dNOPAUSE -dBATCH -q -dEPSCrop -dTextAlphaBits=4 -dGraphicsAlphaBits=4

doc/groups.dox

Show inline comments

@@ -462,67 +462,48 @@
 		This group describes the exceptions defined in LEMON.
 		*/
 		/**
 		@defgroup io_group Input-Output
 		\brief Graph Input-Output methods
 		This group describes the tools for importing and exporting graphs
 		and graph related data. Now it supports the LEMON format, the
 		\c DIMACS format and the encapsulated postscript (EPS) format.
 		*/
 		/**
 		@defgroup lemon_io Lemon Input-Output
 		@ingroup io_group
 		\brief Reading and writing LEMON format
 		This group describes methods for reading and writing LEMON format.
 		You can find more about this format on the \ref graph-io-page "Graph Input-Output"
 		tutorial pages.
 		*/
 		/**
 		@defgroup section_io Section readers and writers
 		@ingroup lemon_io
 		\brief Section readers and writers for LEMON Input-Output.
 		This group describes section reader and writer classes that can be
 		attached to \ref LemonReader and \ref LemonWriter.
 		*/
 		/**
 		@defgroup item_io Item readers and writers
 		@ingroup lemon_io
 		\brief Item readers and writers for LEMON Input-Output.
 		This group describes reader and writer classes for various data types
 		(e.g. map or attribute values). These classes can be attached to
 		\ref LemonReader and \ref LemonWriter.
 		*/
 		/**
 		@defgroup eps_io Postscript exporting
 		@ingroup io_group
 		\brief General \c EPS drawer and graph exporter
 		This group describes general \c EPS drawing methods and special
 		graph exporting tools.
 		*/
 		/**
 		@defgroup concept Concepts
 		\brief Skeleton classes and concept checking classes
 		This group describes the data/algorithm skeletons and concept checking
 		classes implemented in LEMON.
 		The purpose of the classes in this group is fourfold.
 		- These classes contain the documentations of the concepts. In order
 		  to avoid document multiplications, an implementation of a concept
 		  simply refers to the corresponding concept class.
 		- These classes declare every functions, <tt>typedef</tt>s etc. an
 		  implementation of the concepts should provide, however completely

lemon/lgf_reader.h

Show inline comments

@@ -247,378 +247,466 @@
 		      if (c == '\"') {
 			while (is.get(c) && c != '\"') {
 			  if (c == '\\')
 			    c = readEscape(is);
 			  os << c;
+			}
 			if (!is)
 			  throw DataFormatError("Quoted format error");
 		      } else {
 			is.putback(c);
 			while (is.get(c) && !isWhiteSpace(c)) {
 			  if (c == '\\')
 			    c = readEscape(is);
 			  os << c;
+			}
 			if (!is) {
 			  is.clear();
 			} else {
 			  is.putback(c);
+			}
+		      }
 		      str = os.str();
 		      return is;
+		    }
 		    std::istream& readIdentifier(std::istream& is, std::string& str) {
 		      std::ostringstream os;
 		      char c;
 		      is >> std::ws;
 		      if (!is.get(c))
 			return is;
 		      if (!isIdentifierFirstChar(c))
 			throw DataFormatError("Wrong char in identifier");
 		      os << c;
 		      while (is.get(c) && !isWhiteSpace(c)) {
 			if (!isIdentifierChar(c))
 			  throw DataFormatError("Wrong char in identifier");
 			os << c;
+		      }
 		      if (!is) is.clear();
 		      str = os.str();
 		      return is;
+		    }
+		  }
 		  /// \e
 		  /// \ingroup lemon_io
 		  ///
 		  /// \brief 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
 		  /// std::string to the value type of the map. If it is set, it will
 		  /// determine how the tokens in the file should be is converted to the map's
 		  /// value type. 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).
 		  ///       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 function is multipass reading, which is
 		  /// important if two \e \@arcs sections must be read from the
 		  /// file. In this example 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 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;
 		    int line_num;
 		    std::istringstream line;
 		  public:
-		    /// \e
+		    /// \brief Constructor
 		    ///
 		    /// Construct a directed graph reader, which reads from the given
 		    /// input stream.
 		    DigraphReader(std::istream& is, Digraph& digraph)
 		      : _is(&is), local_is(false), _digraph(digraph),
 			_use_nodes(false), _use_arcs(false) {}
-		    /// \e
+		    /// \brief Constructor
 		    ///
 		    /// Construct a directed graph reader, which reads from the given
 		    /// file.
 		    DigraphReader(const std::string& fn, Digraph& digraph)
 		      : _is(new std::ifstream(fn.c_str())), local_is(true), _digraph(digraph),
 		    	_use_nodes(false), _use_arcs(false) {}
-		    /// \e
 		    /// \brief Constructor
 		    ///
 		    /// Construct a directed graph reader, which reads from the given
 		    /// file.
 		    DigraphReader(const char* fn, Digraph& digraph)
 		      : _is(new std::ifstream(fn)), local_is(true), _digraph(digraph),
 		    	_use_nodes(false), _use_arcs(false) {}
-		    /// \e
+		    /// \brief Copy constructor
 		    ///
 		    /// The copy constructor transfers all data from the other reader,
 		    /// therefore the copied reader will not be usable more.
 		    DigraphReader(DigraphReader& other)
 		      : _is(other._is), local_is(other.local_is), _digraph(other._digraph),
 			_use_nodes(other._use_nodes), _use_arcs(other._use_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;
+		    }
-		    /// \e
+		    /// \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:
 		    DigraphReader& operator=(const DigraphReader&);
 		  public:
-		    /// \e
+		    /// \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;
+		    }
-		    /// \e
+		    /// \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;
+		    }
-		    /// \e
+		    /// \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));
 		      return *this;
+		    }
-		    /// \e
+		    /// \brief Arc map reading rule
 		    ///
 		    /// Add an arc map reading rule with specialized converter to the
 		    /// reader.
 		    template <typename Map, typename Converter>
 		    DigraphReader& arcMap(const std::string& caption, Map& map,
 					  const Converter& converter = Converter()) {
 		      checkConcept<concepts::WriteMap<Arc, typename Map::Value>, Map>();
 		      _reader_bits::MapStorageBase<Arc>* storage =
 			new _reader_bits::MapStorage<Arc, Map, Converter>(map, converter);
 		      _arc_maps.push_back(std::make_pair(caption, storage));
 		      return *this;
+		    }
-		    /// \e
+		    /// \brief Attribute reading rule
 		    ///
 		    /// Add an attribute reading rule to the reader.
 		    template <typename Value>
 		    DigraphReader& attribute(const std::string& caption, Value& value) {
 		      _reader_bits::ValueStorageBase* storage =
 			new _reader_bits::ValueStorage<Value>(value);
 		      _attributes.insert(std::make_pair(caption, storage));
 		      return *this;
+		    }
-		    /// \e
+		    /// \brief Attribute reading rule
 		    ///
 		    /// Add an attribute reading rule with specialized converter to the
 		    /// reader.
 		    template <typename Value, typename Converter>
 		    DigraphReader& attribute(const std::string& caption, Value& value,
 					     const Converter& converter = Converter()) {
 		      _reader_bits::ValueStorageBase* storage =
 			new _reader_bits::ValueStorage<Value, Converter>(value, converter);
 		      _attributes.insert(std::make_pair(caption, storage));
 		      return *this;
+		    }
-		    /// \e
+		    /// \brief Node reading rule
 		    ///
 		    /// Add a node reading rule to reader.
 		    DigraphReader& node(const std::string& caption, Node& node) {
 		      typedef _reader_bits::MapLookUpConverter<Node> Converter;
 		      Converter converter(_node_index);
 		      _reader_bits::ValueStorageBase* storage =
 			new _reader_bits::ValueStorage<Node, Converter>(node, converter);
 		      _attributes.insert(std::make_pair(caption, storage));
 		      return *this;
+		    }
-		    /// \e
+		    /// \brief Arc reading rule
 		    ///
 		    /// Add an arc reading rule to reader.
 		    DigraphReader& arc(const std::string& caption, Arc& arc) {
 		      typedef _reader_bits::MapLookUpConverter<Arc> Converter;
 		      Converter converter(_arc_index);
 		      _reader_bits::ValueStorageBase* storage =
 			new _reader_bits::ValueStorage<Arc, Converter>(arc, converter);
 		      _attributes.insert(std::make_pair(caption, storage));
 		      return *this;
+		    }
-		    /// \e
+		    /// @}
 		    /// \name Select section by name
 		    /// @{
 		    /// \brief Set \c \@nodes section to be read
 		    ///
 		    /// Set \c \@nodes section to be read
 		    DigraphReader& nodes(const std::string& caption) {
 		      _nodes_caption = caption;
 		      return *this;
+		    }
-		    /// \e
+		    /// \brief Set \c \@arcs section to be read
 		    ///
 		    /// Set \c \@arcs section to be read
 		    DigraphReader& arcs(const std::string& caption) {
 		      _arcs_caption = caption;
 		      return *this;
+		    }
-		    /// \e
+		    /// \brief Set \c \@attributes section to be read
 		    ///
 		    /// Set \c \@attributes section to be read
 		    DigraphReader& attributes(const std::string& caption) {
 		      _attributes_caption = caption;
 		      return *this;
+		    }
-		    /// \e
+		    /// @}
 		    /// \name Using previously constructed node or arc set
 		    /// @{
 		    /// \brief Use previously constructed node set
 		    ///
 		    /// Use previously constructed node set, and specify the node
 		    /// label map.
 		    template <typename Map>
 		    DigraphReader& useNodes(const Map& map) {
 		      checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
 		      LEMON_ASSERT(!_use_nodes, "Multiple usage of useNodes() member");
 		      _use_nodes = true;
 		      _writer_bits::DefaultConverter<typename Map::Value> converter;
 		      for (NodeIt n(_digraph); n != INVALID; ++n) {
 			_node_index.insert(std::make_pair(converter(map[n]), n));
+		      }
 		      return *this;
+		    }
-		    /// \e
+		    /// \brief Use previously constructed node set
 		    ///
 		    /// Use previously constructed node set, and specify the node
 		    /// label map and a functor which converts the label map values to
 		    /// std::string.
 		    template <typename Map, typename Converter>
 		    DigraphReader& useNodes(const Map& map,
 					    const Converter& converter = Converter()) {
 		      checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
 		      LEMON_ASSERT(!_use_nodes, "Multiple usage of useNodes() member");
 		      _use_nodes = true;
 		      for (NodeIt n(_digraph); n != INVALID; ++n) {
 			_node_index.insert(std::make_pair(converter(map[n]), n));
+		      }
 		      return *this;
+		    }
-		    /// \e
+		    /// \brief Use previously constructed arc set
 		    ///
 		    /// Use previously constructed arc set, and specify the arc
 		    /// label map.
 		    template <typename Map>
 		    DigraphReader& useArcs(const Map& map) {
 		      checkConcept<concepts::ReadMap<Arc, typename Map::Value>, Map>();
 		      LEMON_ASSERT(!_use_arcs, "Multiple usage of useArcs() member");
 		      _use_arcs = true;
 		      _writer_bits::DefaultConverter<typename Map::Value> converter;
 		      for (ArcIt a(_digraph); a != INVALID; ++a) {
 			_arc_index.insert(std::make_pair(converter(map[a]), a));
+		      }
 		      return *this;
+		    }
-		    /// \e
+		    /// \brief Use previously constructed arc set
 		    ///
 		    /// Use previously constructed arc set, and specify the arc
 		    /// label map and a functor which converts the label map values to
 		    /// std::string.
 		    template <typename Map, typename Converter>
 		    DigraphReader& useArcs(const Map& map,
 					    const Converter& converter = Converter()) {
 		      checkConcept<concepts::ReadMap<Arc, typename Map::Value>, Map>();
 		      LEMON_ASSERT(!_use_arcs, "Multiple usage of useArcs() member");
 		      _use_arcs = true;
 		      for (ArcIt a(_digraph); a != INVALID; ++a) {
 			_arc_index.insert(std::make_pair(converter(map[a]), a));
+		      }
 		      return *this;
+		    }
 		    /// @}
 		  private:
 		    bool readLine() {
 		      std::string str;
 		      while(++line_num, std::getline(*_is, str)) {
 			line.clear(); line.str(str);
 			char c;
 			if (line >> std::ws >> c && c != '#') {
 			  line.putback(c);
 			  return true;
+			}
+		      }
 		      return false;
+		    }
 		    bool readSuccess() {
 		      return static_cast<bool>(*_is);
+		    }
 		    void skipSection() {
 		      char c;
 		      while (readSuccess() && line >> c && c != '@') {
 			readLine();
+		      }
 		      line.putback(c);
+		    }
 		    void readNodes() {
 		      std::vector<int> map_index(_node_maps.size());
 		      int map_num, label_index;
 		      if (!readLine())
 			throw DataFormatError("Cannot find map captions");
+		      {
 			std::map<std::string, int> maps;
 			std::string map;
 			int index = 0;
-			while (_reader_bits::readIdentifier(line, map)) {
+			while (_reader_bits::readToken(line, map)) {
 			  if (maps.find(map) != maps.end()) {
 			    std::ostringstream msg;
 			    msg << "Multiple occurence of node map: " << map;
 			    throw DataFormatError(msg.str().c_str());
+			  }
 			  maps.insert(std::make_pair(map, index));
 			  ++index;
+			}
 			for (int i = 0; i < static_cast<int>(_node_maps.size()); ++i) {
 			  std::map<std::string, int>::iterator jt =
 			    maps.find(_node_maps[i].first);
 			  if (jt == maps.end()) {
 			    std::ostringstream msg;
 			    msg << "Map not found in file: " << _node_maps[i].first;
 			    throw DataFormatError(msg.str().c_str());
+			  }
 			  map_index[i] = jt->second;
+			}
+			{
 			  std::map<std::string, int>::iterator jt = maps.find("label");
 			  if (jt == maps.end())
 			    throw DataFormatError("Label map not found in file");
@@ -659,49 +747,49 @@
 			for (int i = 0; i < static_cast<int>(_node_maps.size()); ++i) {
 			  _node_maps[i].second->set(n, tokens[map_index[i]]);
+			}
+		      }
 		      if (readSuccess()) {
 			line.putback(c);
+		      }
+		    }
 		    void readArcs() {
 		      std::vector<int> map_index(_arc_maps.size());
 		      int map_num, label_index;
 		      if (!readLine())
 			throw DataFormatError("Cannot find map captions");
+		      {
 			std::map<std::string, int> maps;
 			std::string map;
 			int index = 0;
-			while (_reader_bits::readIdentifier(line, map)) {
+			while (_reader_bits::readToken(line, map)) {
 			  if (maps.find(map) != maps.end()) {
 			    std::ostringstream msg;
 			    msg << "Multiple occurence of arc map: " << map;
 			    throw DataFormatError(msg.str().c_str());
+			  }
 			  maps.insert(std::make_pair(map, index));
 			  ++index;
+			}
 			for (int i = 0; i < static_cast<int>(_arc_maps.size()); ++i) {
 			  std::map<std::string, int>::iterator jt =
 			    maps.find(_arc_maps[i].first);
 			  if (jt == maps.end()) {
 			    std::ostringstream msg;
 			    msg << "Map not found in file: " << _arc_maps[i].first;
 			    throw DataFormatError(msg.str().c_str());
+			  }
 			  map_index[i] = jt->second;
+			}
+			{
 			  std::map<std::string, int>::iterator jt = maps.find("label");
 			  if (jt == maps.end())
 			    throw DataFormatError("Label map not found in file");
@@ -766,149 +854,159 @@
 			    throw DataFormatError(msg.str().c_str());
+			  }
 			  a = it->second;
+			}
 			for (int i = 0; i < static_cast<int>(_arc_maps.size()); ++i) {
 			  _arc_maps[i].second->set(a, tokens[map_index[i]]);
+			}
+		      }
 		      if (readSuccess()) {
 			line.putback(c);
+		      }
+		    }
 		    void readAttributes() {
 		      std::set<std::string> read_attr;
 		      char c;
 		      while (readLine() && line >> c && c != '@') {
 			line.putback(c);
 			std::string attr, token;
-			if (!_reader_bits::readIdentifier(line, attr))
+			if (!_reader_bits::readToken(line, attr))
 			  throw DataFormatError("Attribute name not found");
 			if (!_reader_bits::readToken(line, token))
 			  throw DataFormatError("Attribute value not found");
 			if (line >> c)
 			  throw DataFormatError("Extra character on the end of line");
+			{
 			  std::set<std::string>::iterator it = read_attr.find(attr);
 			  if (it != read_attr.end()) {
 			    std::ostringstream msg;
 			    msg << "Multiple occurence of attribute " << attr;
 			    throw DataFormatError(msg.str().c_str());
+			  }
 			  read_attr.insert(attr);
+			}
+			{
 			  typename Attributes::iterator it = _attributes.lower_bound(attr);
 			  while (it != _attributes.end() && it->first == attr) {
 			    it->second->set(token);
 			    ++it;
+			  }
+			}
+		      }
 		      if (readSuccess()) {
 			line.putback(c);
+		      }
 		      for (typename Attributes::iterator it = _attributes.begin();
 			   it != _attributes.end(); ++it) {
 			if (read_attr.find(it->first) == read_attr.end()) {
 			  std::ostringstream msg;
 			  msg << "Attribute not found in file: " << it->first;
 			  throw DataFormatError(msg.str().c_str());
+			}
+		      }
+		    }
 		  public:
 		    /// \e
 		    /// \name Execution of the reader
 		    /// @{
 		    /// \brief Start the batch processing
 		    ///
 		    /// This function starts the batch processing
 		    void run() {
 		      LEMON_ASSERT(_is != 0, "This reader assigned to an other reader");
 		      bool nodes_done = false;
 		      bool arcs_done = false;
 		      bool attributes_done = false;
 		      line_num = 0;
 		      readLine();
 		      while (readSuccess()) {
 			skipSection();
 			try {
 			  char c;
 			  std::string section, caption;
 			  line >> c;
 			  _reader_bits::readIdentifier(line, section);
 			  _reader_bits::readIdentifier(line, caption);
 			  _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");
+		      }
+		    }
 		    /// @}
 		  };
 		  /// \relates DigraphReader
 		  template <typename Digraph>
 		  DigraphReader<Digraph> digraphReader(std::istream& is, Digraph& digraph) {
 		    return DigraphReader<Digraph>(is, digraph);
+		  }
 		  /// \relates DigraphReader
 		  template <typename Digraph>
 		  DigraphReader<Digraph> digraphReader(const std::string& fn,
 						       Digraph& digraph) {
 		    return DigraphReader<Digraph>(fn, digraph);
+		  }
 		  /// \relates DigraphReader
 		  template <typename Digraph>
 		  DigraphReader<Digraph> digraphReader(const char* fn, Digraph& digraph) {
 		    return DigraphReader<Digraph>(fn, digraph);
+		  }
+		}
 		#endif

lemon/lgf_writer.h

Show inline comments

@@ -183,312 +183,411 @@
 			return;
 		      case '\r':
 			os << "\\r";
 			return;
 		      case '\n':
 			os << "\\n";
 			return;
 		      case '\t':
 			os << "\\t";
 			return;
 		      case '\v':
 			os << "\\v";
 			return;
 		      default:
 			if (c < 0x20) {
 			  os << '\\' << std::oct << static_cast<int>(c);
 			} else {
 			  os << c;
+			}
 			return;
+		      }
+		    }
 		    bool requireEscape(const std::string& str) {
 		      if (str.empty() || str[0] == '@') return true;
 		      std::istringstream is(str);
 		      char c;
 		      while (is.get(c)) {
 			if (isWhiteSpace(c) || isEscaped(c)) {
 			  return true;
+			}
+		      }
 		      return false;
+		    }
 		    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;
+		    }
+		  }
-		  /// \e
+		  /// \ingroup lemon_io
 		  ///
 		  /// \brief 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 std::string. If it is set, it will
 		  /// determine how the map's value type 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).
 		  ///       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;
 		    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:
-		    /// \e
+		    /// \brief Constructor
 		    ///
 		    /// Construct a directed graph writer, which writes to the given
 		    /// output stream.
 		    DigraphWriter(std::ostream& is, Digraph& digraph)
 		      : _os(&is), local_os(false), _digraph(digraph),
 			_skip_nodes(false), _skip_arcs(false) {}
-		    /// \e
+		    /// \brief Constructor
 		    ///
 		    /// Construct a directed graph writer, which writes to the given
 		    /// output file.
 		    DigraphWriter(const std::string& fn, Digraph& digraph)
 		      : _os(new std::ofstream(fn.c_str())), local_os(true), _digraph(digraph),
 			_skip_nodes(false), _skip_arcs(false) {}
-		    /// \e
+		    /// \brief Constructor
 		    ///
 		    /// Construct a directed graph writer, which writes to the given
 		    /// output file.
 		    DigraphWriter(const char* fn, Digraph& digraph)
 		      : _os(new std::ofstream(fn)), local_os(true), _digraph(digraph),
 			_skip_nodes(false), _skip_arcs(false) {}
 		    /// \brief Copy constructor
 		    ///
 		    /// The copy constructor transfers all data from the other writer,
 		    /// therefore the copied writer will not be usable more.
 		    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.is = 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;
+		    }
-		    /// \e
+		    /// \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:
 		    DigraphWriter& operator=(const DigraphWriter&);
 		  public:
-		    /// \e
+		    /// \name Writing rules
 		    /// @{
 		    /// \brief Node map reading rule
 		    ///
 		    /// Add a node map reading 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;
+		    }
-		    /// \e
+		    /// \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;
+		    }
-		    /// \e
+		    /// \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;
+		    }
-		    /// \e
+		    /// \brief Arc map writing rule
 		    ///
 		    /// Add an arc map writing rule with specialized converter to the
 		    /// writer.
 		    template <typename Map, typename Converter>
 		    DigraphWriter& arcMap(const std::string& caption, const Map& map,
 					  const Converter& converter = Converter()) {
 		      checkConcept<concepts::ReadMap<Arc, typename Map::Value>, Map>();
 		      _writer_bits::MapStorageBase<Arc>* storage =
 			new _writer_bits::MapStorage<Arc, Map, Converter>(map, converter);
 		      _arc_maps.push_back(std::make_pair(caption, storage));
 		      return *this;
+		    }
-		    /// \e
+		    /// \brief Attribute writing rule
 		    ///
 		    /// Add an attribute writing rule to the writer.
 		    template <typename Value>
 		    DigraphWriter& attribute(const std::string& caption, const Value& value) {
 		      _writer_bits::ValueStorageBase* storage =
 			new _writer_bits::ValueStorage<Value>(value);
 		      _attributes.push_back(std::make_pair(caption, storage));
 		      return *this;
+		    }
-		    /// \e
+		    /// \brief Attribute writing rule
 		    ///
 		    /// Add an attribute writing rule with specialized converter to the
 		    /// writer.
 		    template <typename Value, typename Converter>
 		    DigraphWriter& attribute(const std::string& caption, const Value& value,
 					     const Converter& converter = Converter()) {
 		      _writer_bits::ValueStorageBase* storage =
 			new _writer_bits::ValueStorage<Value, Converter>(value, converter);
 		      _attributes.push_back(std::make_pair(caption, storage));
 		      return *this;
+		    }
-		    /// \e
+		    /// \brief Node writing rule
 		    ///
 		    /// Add a node writing rule to the writer.
 		    DigraphWriter& node(const std::string& caption, const Node& node) {
 		      typedef _writer_bits::MapLookUpConverter<Node> Converter;
 		      Converter converter(_node_index);
 		      _writer_bits::ValueStorageBase* storage =
 			new _writer_bits::ValueStorage<Node, Converter>(node, converter);
 		      _attributes.push_back(std::make_pair(caption, storage));
 		      return *this;
+		    }
-		    /// \e
+		    /// \brief Arc writing rule
 		    ///
 		    /// Add an arc writing rule to writer.
 		    DigraphWriter& arc(const std::string& caption, const Arc& arc) {
 		      typedef _writer_bits::MapLookUpConverter<Arc> Converter;
 		      Converter converter(_arc_index);
 		      _writer_bits::ValueStorageBase* storage =
 			new _writer_bits::ValueStorage<Arc, Converter>(arc, converter);
 		      _attributes.push_back(std::make_pair(caption, storage));
 		      return *this;
+		    }
-		    /// \e
+		    /// \name Select section by name
 		    /// @{
 		    /// \brief Set \c \@nodes section to be read
 		    ///
 		    /// Set \c \@nodes section to be read
 		    DigraphWriter& nodes(const std::string& caption) {
 		      _nodes_caption = caption;
 		      return *this;
+		    }
-		    /// \e
+		    /// \brief Set \c \@arcs section to be read
 		    ///
 		    /// Set \c \@arcs section to be read
 		    DigraphWriter& arcs(const std::string& caption) {
 		      _arcs_caption = caption;
 		      return *this;
+		    }
-		    /// \e
+		    /// \brief Set \c \@attributes section to be read
 		    ///
 		    /// Set \c \@attributes section to be read
 		    DigraphWriter& attributes(const std::string& caption) {
 		      _attributes_caption = caption;
 		      return *this;
+		    }
 		    /// \name Skipping section
 		    /// @{
 		    /// \brief Skip writing the node set
 		    ///
 		    /// The \c \@nodes section will be not written to the stream.
 		    DigraphWriter& skipNodes() {
 		      LEMON_ASSERT(!_skip_nodes, "Multiple usage of skipNodes() member");
 		      return *this;
+		    }
 		    /// \brief Skip writing arc set
 		    ///
 		    /// The \c \@arcs section will be not written to the stream.
 		    DigraphWriter& skipArcs() {
 		      LEMON_ASSERT(!_skip_arcs, "Multiple usage of skipArcs() member");
 		      return *this;
+		    }
 		    /// @}
 		  private:
 		    void writeNodes() {
 		      _writer_bits::MapStorageBase<Node>* label = 0;
 		      for (typename NodeMaps::iterator it = _node_maps.begin();
 			   it != _node_maps.end(); ++it) {
 		        if (it->first == "label") {
 			  label = it->second;
 			  break;
+			}
+		      }
 		      *_os << "@nodes";
 		      if (!_nodes_caption.empty()) {
-			*_os << ' ' << _nodes_caption;
+			_writer_bits::writeToken(*_os << ' ', _nodes_caption);
+		      }
 		      *_os << std::endl;
 		      if (label == 0) {
 			*_os << "label" << '\t';
+		      }
 		      for (typename NodeMaps::iterator it = _node_maps.begin();
 			   it != _node_maps.end(); ++it) {
-			*_os << it->first << '\t';
+			_writer_bits::writeToken(*_os, it->first) << '\t';
+		      }
 		      *_os << std::endl;
 		      std::vector<Node> nodes;
 		      for (NodeIt n(_digraph); n != INVALID; ++n) {
 			nodes.push_back(n);
+		      }
 		      if (label == 0) {
 			IdMap<Digraph, Node> id_map(_digraph);
 			_writer_bits::MapLess<IdMap<Digraph, Node> > id_less(id_map);
 			std::sort(nodes.begin(), nodes.end(), id_less);
 		      } else {
 			label->sort(nodes);
+		      }
 		      for (int i = 0; i < static_cast<int>(nodes.size()); ++i) {
 			Node n = nodes[i];
 			if (label == 0) {
 			  std::ostringstream os;
 			  os << _digraph.id(n);
 			  _writer_bits::writeToken(*_os, os.str());
 			  *_os << '\t';
 			  _node_index.insert(std::make_pair(n, os.str()));
@@ -497,131 +596,143 @@
 			     it != _node_maps.end(); ++it) {
 			  std::string value = it->second->get(n);
 			  _writer_bits::writeToken(*_os, value);
 			  if (it->first == "label") {
 			    _node_index.insert(std::make_pair(n, value));
+			  }
 			  *_os << '\t';
+			}
 			*_os << std::endl;
+		      }
+		    }
 		    void writeArcs() {
 		      _writer_bits::MapStorageBase<Arc>* label = 0;
 		      for (typename ArcMaps::iterator it = _arc_maps.begin();
 			   it != _arc_maps.end(); ++it) {
 		        if (it->first == "label") {
 			  label = it->second;
 			  break;
+			}
+		      }
 		      *_os << "@arcs";
 		      if (!_arcs_caption.empty()) {
-			*_os << ' ' << _arcs_caption;
+			_writer_bits::writeToken(*_os << ' ', _arcs_caption);
+		      }
 		      *_os << std::endl;
 		      *_os << '\t' << '\t';
 		      if (label == 0) {
 			*_os << "label" << '\t';
+		      }
 		      for (typename ArcMaps::iterator it = _arc_maps.begin();
 			   it != _arc_maps.end(); ++it) {
-			*_os << it->first << '\t';
+			_writer_bits::writeToken(*_os, it->first) << '\t';
+		      }
 		      *_os << std::endl;
 		      std::vector<Arc> arcs;
 		      for (ArcIt n(_digraph); n != INVALID; ++n) {
 			arcs.push_back(n);
+		      }
 		      if (label == 0) {
 			IdMap<Digraph, Arc> id_map(_digraph);
 			_writer_bits::MapLess<IdMap<Digraph, Arc> > id_less(id_map);
 			std::sort(arcs.begin(), arcs.end(), id_less);
 		      } else {
 			label->sort(arcs);
+		      }
 		      for (int i = 0; i < static_cast<int>(arcs.size()); ++i) {
 			Arc a = arcs[i];
 			_writer_bits::writeToken(*_os, _node_index.
 						 find(_digraph.source(a))->second);
 			*_os << '\t';
 			_writer_bits::writeToken(*_os, _node_index.
 						 find(_digraph.target(a))->second);
 			*_os << '\t';
 			if (label == 0) {
 			  std::ostringstream os;
 			  os << _digraph.id(a);
 			  _writer_bits::writeToken(*_os, os.str());
 			  *_os << '\t';
 			  _arc_index.insert(std::make_pair(a, os.str()));
+			}
 			for (typename ArcMaps::iterator it = _arc_maps.begin();
 			     it != _arc_maps.end(); ++it) {
 			  std::string value = it->second->get(a);
 			  _writer_bits::writeToken(*_os, value);
 			  if (it->first == "label") {
 			    _arc_index.insert(std::make_pair(a, value));
+			  }
 			  *_os << '\t';
+			}
 			*_os << std::endl;
+		      }
+		    }
 		    void writeAttributes() {
 		      if (_attributes.empty()) return;
 		      *_os << "@attributes";
 		      if (!_attributes_caption.empty()) {
-			*_os << ' ' << _attributes_caption;
+			_writer_bits::writeToken(*_os << ' ', _attributes_caption);
+		      }
 		      *_os << std::endl;
 		      for (typename Attributes::iterator it = _attributes.begin();
 			   it != _attributes.end(); ++it) {
-			*_os << it->first << ' ';
+			_writer_bits::writeToken(*_os, it->first) << ' ';
 			_writer_bits::writeToken(*_os, it->second->get());
 			*_os << std::endl;
+		      }
+		    }
 		  public:
-		    /// \e
+		    /// \name Execution of the writer
 		    /// @{
 		    /// \brief Start the batch processing
 		    ///
 		    /// This function starts the batch processing
 		    void run() {
 		      if (!_skip_nodes) {
 			writeNodes();
+		      }
 		      if (!_skip_arcs) {
 			writeArcs();
+		      }
 		      writeAttributes();
+		    }
 		    /// \e
 		    std::ostream& stream() {
 		    /// \brief Gives back the stream of the writer
 		    ///
 		    /// Gives back the stream of the writer
 		    std::ostream& ostream() {
 		      return *_os;
+		    }
 		    /// @}
 		  };
 		  /// \relates DigraphWriter
 		  template <typename Digraph>
 		  DigraphWriter<Digraph> digraphWriter(std::istream& is, Digraph& digraph) {
 		    return DigraphWriter<Digraph>(is, digraph);
+		  }
 		  /// \relates DigraphWriter
 		  template <typename Digraph>
 		  DigraphWriter<Digraph> digraphWriter(const std::string& fn,
 						       Digraph& digraph) {
 		    return DigraphWriter<Digraph>(fn, digraph);
+		  }
 		  /// \relates DigraphWriter
 		  template <typename Digraph>
 		  DigraphWriter<Digraph> digraphWriter(const char* fn, Digraph& digraph) {
 		    return DigraphWriter<Digraph>(fn, digraph);
+		  }
+		}
 		#endif

0 comments (0 inline)

RhodeCode

Login to your account