Context Navigation

Back to Ticket #35

Ticket #35: lgf_doc.patch

File lgf_doc.patch, 28.7 KB (added by Balazs Dezso, 16 years ago)

doc/groups.dox

# HG changeset patch
# User Balazs Dezso <deba@inf.elte.hu>
# Date 1210797907 -7200
# Node ID a765b4ecbcdbd5e8ac0fc55beecf585ebb481b15
# Parent  5c3604513ed0256e35e5fd50c54cd0e37362397e
Fixing token usage and documention is LGF IO

diff -r 5c3604513ed0 -r a765b4ecbcdb doc/groups.dox

-                      a
 */
 /**
-@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

lemon/lgf_reader.h

diff -r 5c3604513ed0 -r a765b4ecbcdb lemon/lgf_reader.h

-                      a
       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
+  ///
+  /// The \e LGF (LEMON graph file) format is the default file format
+  /// of the LEMON library. It is a text based, section oriented
+  /// format, which defines some standard sections for storing graphs
+  /// in text files. Each line with \c '#' first non-whitespace
+  /// character is considered as a comment line. Each section starts with
+  /// a header line, these lines starts with \c '@' character and the
+  /// name of section type.  The standard sections are \c \@nodes, \c
+  /// \@arcs and \c \@edges (these two names are completely equivalent)
+  /// and \@attributes. Each header line may also have an optional
+  /// name, which can be use to distinguish the sections of the same
+  /// type.
+  ///
+  /// The \@nodes section describes a set of nodes and associated
+  /// maps. The first is a header line consisting of the names of the
+  /// maps, each of them is a plain or quoted token. A plain token is
+  /// a sequence of non-whitespace characters, and a quoted token is a
+  /// character sequence surrounded by double quotes, and the sequence
+  /// may contain escape sequences. One of the maps must be called \c
+  /// "label", which plays special role in the file.  Each following
+  /// non-empty line until the next section describes a node in the
+  /// graph. These lines contain the values of the node maps
+  /// associated to the current node, each value is also plain or
+  /// quoted token.
+  ///
+  /// The \c \@arcs section is very similar to the \c \@nodes section,
+  /// it starts with a header line consists from the names of the arc
+  /// maps, the \c "label" map is also necessary. The following lines
+  /// contain the description of the arcs. The first two tokens are
+  /// the source and the target node of the edge, then comes the map
+  /// values. The source and target tokens must be node labels.
+  ///
+  /// The \c \@attributes section contains key-value pairs, each line
+  /// starts with an attribute nome, and then an attribute value. Both
+  /// of them are plain or quoted tokens, but the value could be also
+  /// a node or an arc label.
+  ///
+  ///\code
+  /// @nodes
+  /// label   coordinates size    title
+  /// 1       (10,20)     10      "First node"
+  /// 2       (80,80)     8       "Second node"
+  /// 3       (40,10)     10      "Third node"
+  /// @arcs
+  ///         capacity
+  /// 1   2   16
+  /// 1   3   12
+  /// 2   3   18
+  /// @attributes
+  /// source 1
+  /// target 3
+  /// caption "LEMON test digraph"
+  ///\endcode
+  ///
+  /// The writing method does a batch processing. The user creates a
+  /// writer object, then several 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. The optional
+  /// converter parameter can be a standard functor, which converts an
+  /// the value type of the map to std::string, if it is set, it
+  /// determines how the 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 uses the first section in the file of the
+  /// proper type. If a section has an optional name, then it can be
+  /// selected to write with the \c nodes(), \c arcs() or \c attributes()
+  /// functions.
+  ///
+  /// The \c useNodes() and \c useArcs() functions are used to specify
+  /// that the nodes or arcs should not be constructed(added to the
+  /// graph) during the reading, the argument of these functions is a
+  /// node map or arc map determining the label map for the items. An
+  /// application of these function is the multipass reading, which is
+  /// important if two \e \@arcs sections should be read from the
+  /// file. In this example the first phase reads the node set and one
+  /// of the arc set, while the second phase will read the second arc
+  /// set into an \e ArcSet class (\c SmartArcSet or \c ListArcSet),
+  /// the previously read label node map should be given to the \c
+  /// useNodes() functions. An other multipass application is reading
+  /// paths into a node map or an arc map. It is impossible in
+  /// single pass, because the arcs are not constructed when the node
+  /// maps are read.
   template <typename _Digraph>
   class DigraphReader {
   public:
 …
   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 useable 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) {
 …
       _attributes_caption = other._attributes_caption;
+    }
     /// \e
+    /// \brief Destructor
     ~DigraphReader() {
       for (typename NodeMaps::iterator it = _node_maps.begin();
            it != _node_maps.end(); ++it) {
 …
   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>();
 …
       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()) {
 …
       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>();
 …
       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()) {
 …
       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 =
 …
       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()) {
 …
       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);
 …
       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);
 …
       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>();
 …
       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()) {
 …
       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>();
 …
       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()) {
 …
+      }
       return *this;
+    }
+    /// @}
   private:
 …
         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;
 …
         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;
 …
         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");
 …
+    }
   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");
 …
           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");
 …
+      }
+    }
+    /// @}
   };
+  /// \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);

lemon/lgf_writer.h

diff -r 5c3604513ed0 -r a765b4ecbcdb lemon/lgf_writer.h

-                      a
+    }
     bool requireEscape(const std::string& str) {
+      if (str.empty() || str[0] == '@') return true;
       std::istringstream is(str);
       char c;
       while (is.get(c)) {
 …
+  }
+  /// \e
+  /// \ingroup lemon_io
+  ///
+  /// \brief LGF writer for directed graphs
+  ///
+  /// The \e LGF (LEMON graph file) format is the default file format
+  /// of the LEMON library. It is a text based, section oriented
+  /// format, which defines some standard sections for storing graphs
+  /// in text files. Each line with \c '#' first non-whitespace
+  /// character is considered as a comment line. Each section starts with
+  /// a header line, these lines starts with \c '@' character and the
+  /// name of section type.  The standard sections are \c \@nodes, \c
+  /// \@arcs and \c \@edges (these two names are completely equivalent)
+  /// and \@attributes. Each header line may also have an optional
+  /// name, which can be use to distinguish the sections of the same
+  /// type.
+  ///
+  /// The \@nodes section describes a set of nodes and associated
+  /// maps. The first is a header line consisting of the names of the
+  /// maps, each of them is a plain or quoted token. A plain token is
+  /// a sequence of non-whitespace characters, and a quoted token is a
+  /// character sequence surrounded by double quotes, and the sequence
+  /// may contain escape sequences. One of the maps must be called \c
+  /// "label", which plays special role in the file.  Each following
+  /// non-empty line until the next section describes a node in the
+  /// graph. These lines contain the values of the node maps
+  /// associated to the current node, each value is also plain or
+  /// quoted token.
+  ///
+  /// The \c \@arcs section is very similar to the \c \@nodes section,
+  /// it starts with a header line consists from the names of the arc
+  /// maps, the \c "label" map is also necessary. The following lines
+  /// contain the description of the arcs. The first two tokens are
+  /// the source and the target node of the edge, then comes the map
+  /// values. The source and target tokens must be node labels.
+  ///
+  /// The \c \@attributes section contains key-value pairs, each line
+  /// starts with an attribute nome, and then an attribute value. Both
+  /// of them are plain or quoted tokens, but the value could be also
+  /// a node or an arc label.
+  ///
+  ///\code
+  /// @nodes
+  /// label   coordinates size    title
+  /// 1       (10,20)     10      "First node"
+  /// 2       (80,80)     8       "Second node"
+  /// 3       (40,10)     10      "Third node"
+  /// @arcs
+  ///         capacity
+  /// 1   2   16
+  /// 1   3   12
+  /// 2   3   18
+  /// @attributes
+  /// source 1
+  /// target 3
+  /// caption "LEMON test digraph"
+  ///\endcode
+  ///
+  /// The reading method does a batch processing. The user creates a
+  /// writer object, then several reading rules can be added to the
+  /// writer, and eventually the reading is executed with the \c run()
+  /// member function. A map reading rule can be added to the writer
+  /// with the \c nodeMap() or \c arcMap() members. The optional
+  /// converter parameter can be a standard functor, which converts an
+  /// std::string to the value type of the map, if it is set, it
+  /// determines how the read string literal 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 in multiple map objects at the
+  /// same time. The \c attribute(), \c node() and \c arc() functions
+  /// are used to add attribute reading rules.
+  ///
+  ///\code
+  ///     DigraphWriter<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 writer does not write additional captions to the
+  /// section, but they can added with 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 write to the
+  /// output, it can be made 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 the output of the
+  /// first pass.
   template <typename _Digraph>
   class DigraphWriter {
   public:
 …
   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 useable 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) {
 …
       _attributes_caption = other._attributes_caption;
+    }
     /// \e
+    /// \brief Destructor
     ~DigraphWriter() {
       for (typename NodeMaps::iterator it = _node_maps.begin();
            it != _node_maps.end(); ++it) {
 …
   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>();
 …
       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()) {
 …
       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>();
 …
       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()) {
 …
       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 =
 …
       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()) {
 …
       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);
 …
       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);
 …
       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:
 …
       *_os << "@nodes";
       if (!_nodes_caption.empty()) {
         *_os << ' ' << _nodes_caption;
+        _writer_bits::writeToken(*_os << ' ', _nodes_caption);
+      }
       *_os << std::endl;
 …
+      }
       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;
 …
       *_os << "@arcs";
       if (!_arcs_caption.empty()) {
         *_os << ' ' << _arcs_caption;
+        _writer_bits::writeToken(*_os << ' ', _arcs_caption);
+      }
       *_os << std::endl;
 …
+      }
       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;
 …
       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();
 …
       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);

Download in other formats:

Original Format