COIN-OR::LEMON - Graph Library

Ticket #93: lgf_doc_7bf5f97d574f.patch

File lgf_doc_7bf5f97d574f.patch, 30.1 KB (added by Peter Kovacs, 12 years ago)

Doc improvements

  • demo/lgf_demo.cc

    # HG changeset patch
    # User Peter Kovacs <kpeter@inf.elte.hu>
    # Date 1215209667 -7200
    # Node ID 7bf5f97d574f0c8fa09366a59c7c588dd2820c03
    # Parent  1e6af6f0843c373a0579fc699ac4a83bb4f5948a
    Doc improvements in LGF related files
    
    diff -r 1e6af6f0843c -r 7bf5f97d574f demo/lgf_demo.cc
    a b  
    3434#include <lemon/smart_graph.h>
    3535#include <lemon/lgf_reader.h>
    3636#include <lemon/lgf_writer.h>
    37 #include <lemon/random.h>
    38 
    3937
    4038using namespace lemon;
    4139
     
    4442  SmartDigraph::ArcMap<int> cap(g);
    4543  SmartDigraph::Node s, t;
    4644
    47   digraphReader("digraph.lgf", g). // read the directeg graph into g
     45  digraphReader("digraph.lgf", g). // read the directed graph into g
    4846    arcMap("capacity", cap).       // read the 'capacity' arc map into cap
    4947    node("source", s).             // read 'source' node to s
    5048    node("target", t).             // read 'target' node to t
    5149    run();
    5250
    53   std::cout << "Digraph read from 'digraph.lgf'" << std::endl;
     51  std::cout << "A digraph is read from 'digraph.lgf'." << std::endl;
    5452  std::cout << "Number of nodes: " << countNodes(g) << std::endl;
    5553  std::cout << "Number of arcs: " << countArcs(g) << std::endl;
    5654
  • doc/groups.dox

    diff -r 1e6af6f0843c -r 7bf5f97d574f doc/groups.dox
    a b  
    475475/**
    476476@defgroup lemon_io Lemon Input-Output
    477477@ingroup io_group
    478 \brief Reading and writing LEMON format
     478\brief Reading and writing \ref lgf-format "Lemon Graph Format".
    479479
    480 This group describes methods for reading and writing LEMON format.
    481 You can find more about this format on the \ref graph-io-page "Graph Input-Output"
    482 tutorial pages.
     480This group describes methods for reading and writing \ref lgf-format "Lemon Graph Format".
    483481*/
    484482
    485483/**
  • doc/lgf.dox

    diff -r 1e6af6f0843c -r 7bf5f97d574f doc/lgf.dox
    a b  
    4646contain whitespaces and escape sequences.
    4747
    4848The \c \@nodes section describes a set of nodes and associated
    49 maps. The first is a header line, it columns are the names of the
     49maps. The first is a header line, its columns are the names of the
    5050maps appearing in the following lines.
    5151One of the maps must be called \c
    5252"label", which plays special role in the file.
     
    6464\endcode
    6565
    6666The \c \@arcs section is very similar to the \c \@nodes section,
    67 it again starts with a header line describing the names of the arc,
     67it again starts with a header line describing the names of the maps,
    6868but the \c "label" map is not obligatory here. The following lines
    6969describe the arcs. The first two tokens of each line are
    7070the source and the target node of the arc, respectively, then come the map
  • lemon/lgf_reader.h

    diff -r 1e6af6f0843c -r 7bf5f97d574f lemon/lgf_reader.h
    a b  
    1818
    1919///\ingroup lemon_io
    2020///\file
    21 ///\brief Lemon Graph Format reader.
     21///\brief \ref lgf-format "Lemon Graph Format" reader.
    2222
    2323
    2424#ifndef LEMON_LGF_READER_H
     
    400400
    401401  /// \ingroup lemon_io
    402402  /// 
    403   /// \brief LGF reader for directed graphs
     403  /// \brief \ref lgf-format "LGF" reader for directed graphs
    404404  ///
    405405  /// This utility reads an \ref lgf-format "LGF" file.
    406406  ///
     
    410410  /// member function. A map reading rule can be added to the reader
    411411  /// with the \c nodeMap() or \c arcMap() members. An optional
    412412  /// converter parameter can also be added as a standard functor
    413   /// converting from std::string to the value type of the map. If it
     413  /// converting from \c std::string to the value type of the map. If it
    414414  /// is set, it will determine how the tokens in the file should be
    415   /// is converted to the map's value type. If the functor is not set,
     415  /// converted to the value type of the map. If the functor is not set,
    416416  /// then a default conversion will be used. One map can be read into
    417417  /// multiple map objects at the same time. The \c attribute(), \c
    418418  /// node() and \c arc() functions are used to add attribute reading
    419419  /// rules.
    420420  ///
    421421  ///\code
    422   ///     DigraphReader<Digraph>(std::cin, digraph).
    423   ///       nodeMap("coordinates", coord_map).
    424   ///       arcMap("capacity", cap_map).
    425   ///       node("source", src).
    426   ///       node("target", trg).
    427   ///       attribute("caption", caption).
    428   ///       run();
     422  /// DigraphReader<Digraph>(std::cin, digraph).
     423  ///   nodeMap("coordinates", coord_map).
     424  ///   arcMap("capacity", cap_map).
     425  ///   node("source", src).
     426  ///   node("target", trg).
     427  ///   attribute("caption", caption).
     428  ///   run();
    429429  ///\endcode
    430430  ///
    431431  /// By default the reader uses the first section in the file of the
     
    437437  /// that the nodes or arcs should not be constructed (added to the
    438438  /// graph) during the reading, but instead the label map of the items
    439439  /// are given as a parameter of these functions. An
    440   /// application of these function is multipass reading, which is
    441   /// important if two \e \@arcs sections must be read from the
    442   /// file. In this example the first phase would read the node set and one
     440  /// application of these functions is multipass reading, which is
     441  /// important if two \c \@arcs sections must be read from the
     442  /// file. In this case the first phase would read the node set and one
    443443  /// of the arc sets, while the second phase would read the second arc
    444444  /// set into an \e ArcSet class (\c SmartArcSet or \c ListArcSet).
    445445  /// The previously read label node map should be passed to the \c
    446446  /// useNodes() functions. Another application of multipass reading when
    447   /// paths are given as a node map or an arc map. It is impossible read this in
     447  /// paths are given as a node map or an arc map. It is impossible to read this in
    448448  /// a single pass, because the arcs are not constructed when the node
    449449  /// maps are read.
    450450  template <typename _Digraph>
     
    735735    ///
    736736    /// Use previously constructed node set, and specify the node
    737737    /// label map and a functor which converts the label map values to
    738     /// std::string.
     738    /// \c std::string.
    739739    template <typename Map, typename Converter>
    740740    DigraphReader& useNodes(const Map& map,
    741741                            const Converter& converter = Converter()) {
     
    768768    ///
    769769    /// Use previously constructed arc set, and specify the arc
    770770    /// label map and a functor which converts the label map values to
    771     /// std::string.
     771    /// \c std::string.
    772772    template <typename Map, typename Converter>
    773773    DigraphReader& useArcs(const Map& map,
    774774                           const Converter& converter = Converter()) {
     
    784784    /// \brief Skips the reading of node section
    785785    ///
    786786    /// Omit the reading of the node section. This implies that each node
    787     /// map reading rule will be abanoned, and the nodes of the graph
     787    /// map reading rule will be abandoned, and the nodes of the graph
    788788    /// will not be constructed, which usually cause that the arc set
    789     /// could not be read due to lack of node name
    790     /// resolving. Therefore, the \c skipArcs() should be used too, or
    791     /// the useNodes() member function should be used to specify the
    792     /// label of the nodes.
     789    /// could not be read due to lack of node name resolving.
     790    /// Therefore \c skipArcs() function should also be used, or
     791    /// \c useNodes() should be used to specify the label of the nodes.
    793792    DigraphReader& skipNodes() {
    794793      LEMON_ASSERT(!_skip_nodes, "Skip nodes already set");
    795794      _skip_nodes = true;
     
    799798    /// \brief Skips the reading of arc section
    800799    ///
    801800    /// Omit the reading of the arc section. This implies that each arc
    802     /// map reading rule will be abanoned, and the arcs of the graph
     801    /// map reading rule will be abandoned, and the arcs of the graph
    803802    /// will not be constructed.
    804803    DigraphReader& skipArcs() {
    805804      LEMON_ASSERT(!_skip_arcs, "Skip arcs already set");
     
    11751174   
    11761175  };
    11771176
     1177  /// \brief Return a \ref DigraphReader class
     1178  ///
     1179  /// This function just returns a \ref DigraphReader class.
    11781180  /// \relates DigraphReader
    11791181  template <typename Digraph>
    11801182  DigraphReader<Digraph> digraphReader(std::istream& is, Digraph& digraph) {
     
    11821184    return tmp;
    11831185  }
    11841186
     1187  /// \brief Return a \ref DigraphReader class
     1188  ///
     1189  /// This function just returns a \ref DigraphReader class.
    11851190  /// \relates DigraphReader
    11861191  template <typename Digraph>
    11871192  DigraphReader<Digraph> digraphReader(const std::string& fn,
     
    11901195    return tmp;
    11911196  }
    11921197
     1198  /// \brief Return a \ref DigraphReader class
     1199  ///
     1200  /// This function just returns a \ref DigraphReader class.
    11931201  /// \relates DigraphReader
    11941202  template <typename Digraph>
    11951203  DigraphReader<Digraph> digraphReader(const char* fn, Digraph& digraph) {
     
    12111219
    12121220  /// \ingroup lemon_io
    12131221  /// 
    1214   /// \brief LGF reader for undirected graphs
     1222  /// \brief \ref lgf-format "LGF" reader for undirected graphs
    12151223  ///
    12161224  /// This utility reads an \ref lgf-format "LGF" file.
     1225  ///
     1226  /// It can be used almost the same way as \c DigraphReader.
     1227  /// The only difference is that this class can handle edges and
     1228  /// edge maps as well as arcs and arc maps.
    12171229  template <typename _Graph>
    12181230  class GraphReader {
    12191231  public:
     
    12621274
    12631275    /// \brief Constructor
    12641276    ///
    1265     /// Construct a undirected graph reader, which reads from the given
     1277    /// Construct an undirected graph reader, which reads from the given
    12661278    /// input stream.
    12671279    GraphReader(std::istream& is, Graph& graph)
    12681280      : _is(&is), local_is(false), _graph(graph),
     
    12711283
    12721284    /// \brief Constructor
    12731285    ///
    1274     /// Construct a undirected graph reader, which reads from the given
     1286    /// Construct an undirected graph reader, which reads from the given
    12751287    /// file.
    12761288    GraphReader(const std::string& fn, Graph& graph)
    12771289      : _is(new std::ifstream(fn.c_str())), local_is(true), _graph(graph),
     
    12801292   
    12811293    /// \brief Constructor
    12821294    ///
    1283     /// Construct a undirected graph reader, which reads from the given
     1295    /// Construct an undirected graph reader, which reads from the given
    12841296    /// file.
    12851297    GraphReader(const char* fn, Graph& graph)
    12861298      : _is(new std::ifstream(fn)), local_is(true), _graph(graph),
     
    14971509
    14981510    /// \brief Set \c \@nodes section to be read
    14991511    ///
    1500     /// Set \c \@nodes section to be read
     1512    /// Set \c \@nodes section to be read.
    15011513    GraphReader& nodes(const std::string& caption) {
    15021514      _nodes_caption = caption;
    15031515      return *this;
     
    15051517
    15061518    /// \brief Set \c \@edges section to be read
    15071519    ///
    1508     /// Set \c \@edges section to be read
     1520    /// Set \c \@edges section to be read.
    15091521    GraphReader& edges(const std::string& caption) {
    15101522      _edges_caption = caption;
    15111523      return *this;
     
    15131525
    15141526    /// \brief Set \c \@attributes section to be read
    15151527    ///
    1516     /// Set \c \@attributes section to be read
     1528    /// Set \c \@attributes section to be read.
    15171529    GraphReader& attributes(const std::string& caption) {
    15181530      _attributes_caption = caption;
    15191531      return *this;
     
    15441556    ///
    15451557    /// Use previously constructed node set, and specify the node
    15461558    /// label map and a functor which converts the label map values to
    1547     /// std::string.
     1559    /// \c std::string.
    15481560    template <typename Map, typename Converter>
    15491561    GraphReader& useNodes(const Map& map,
    15501562                            const Converter& converter = Converter()) {
     
    15771589    ///
    15781590    /// Use previously constructed edge set, and specify the edge
    15791591    /// label map and a functor which converts the label map values to
    1580     /// std::string.
     1592    /// \c std::string.
    15811593    template <typename Map, typename Converter>
    15821594    GraphReader& useEdges(const Map& map,
    15831595                            const Converter& converter = Converter()) {
     
    15901602      return *this;
    15911603    }
    15921604
    1593     /// \brief Skips the reading of node section
     1605    /// \brief Skip the reading of node section
    15941606    ///
    15951607    /// Omit the reading of the node section. This implies that each node
    1596     /// map reading rule will be abanoned, and the nodes of the graph
     1608    /// map reading rule will be abandoned, and the nodes of the graph
    15971609    /// will not be constructed, which usually cause that the edge set
    15981610    /// could not be read due to lack of node name
    1599     /// resolving. Therefore, the \c skipEdges() should be used too, or
    1600     /// the useNodes() member function should be used to specify the
    1601     /// label of the nodes.
     1611    /// could not be read due to lack of node name resolving.
     1612    /// Therefore \c skipEdges() function should also be used, or
     1613    /// \c useNodes() should be used to specify the label of the nodes.
    16021614    GraphReader& skipNodes() {
    16031615      LEMON_ASSERT(!_skip_nodes, "Skip nodes already set");
    16041616      _skip_nodes = true;
    16051617      return *this;
    16061618    }
    16071619
    1608     /// \brief Skips the reading of edge section
     1620    /// \brief Skip the reading of edge section
    16091621    ///
    16101622    /// Omit the reading of the edge section. This implies that each edge
    1611     /// map reading rule will be abanoned, and the edges of the graph
     1623    /// map reading rule will be abandoned, and the edges of the graph
    16121624    /// will not be constructed.
    16131625    GraphReader& skipEdges() {
    16141626      LEMON_ASSERT(!_skip_edges, "Skip edges already set");
     
    19821994   
    19831995  };
    19841996
     1997  /// \brief Return a \ref GraphReader class
     1998  ///
     1999  /// This function just returns a \ref GraphReader class.
    19852000  /// \relates GraphReader
    19862001  template <typename Graph>
    19872002  GraphReader<Graph> graphReader(std::istream& is, Graph& graph) {
     
    19892004    return tmp;
    19902005  }
    19912006
     2007  /// \brief Return a \ref GraphReader class
     2008  ///
     2009  /// This function just returns a \ref GraphReader class.
    19922010  /// \relates GraphReader
    19932011  template <typename Graph>
    19942012  GraphReader<Graph> graphReader(const std::string& fn,
     
    19972015    return tmp;
    19982016  }
    19992017
     2018  /// \brief Return a \ref GraphReader class
     2019  ///
     2020  /// This function just returns a \ref GraphReader class.
    20002021  /// \relates GraphReader
    20012022  template <typename Graph>
    20022023  GraphReader<Graph> graphReader(const char* fn, Graph& graph) {
     
    20102031  SectionReader sectionReader(const std::string& fn);
    20112032  SectionReader sectionReader(const char* fn);
    20122033 
     2034  /// \ingroup lemon_io
     2035  ///
    20132036  /// \brief Section reader class
    20142037  ///
    2015   /// In the \e LGF file extra sections can be placed, which contain
    2016   /// any data in arbitrary format. Such sections can be read with
    2017   /// this class. A reading rule can be added with two different
    2018   /// functions, with the \c sectionLines() function a functor can
    2019   /// process the section line-by-line. While with the \c
     2038  /// In the \ref lgf-format "LGF" file extra sections can be placed,
     2039  /// which contain any data in arbitrary format. Such sections can be
     2040  /// read with this class. A reading rule can be added to the class
     2041  /// with two different functions. With the \c sectionLines() function a
     2042  /// functor can process the section line-by-line, while with the \c
    20202043  /// sectionStream() member the section can be read from an input
    20212044  /// stream.
    20222045  class SectionReader {
     
    21052128    ///  23 6
    21062129    ///\endcode
    21072130    ///
    2108     /// The functor is implemented as an struct:
     2131    /// The functor is implemented as a struct:
    21092132    ///\code
    21102133    ///  struct NumberSection {
    21112134    ///    std::vector<int>& _data;
     
    21232146    ///\endcode
    21242147    template <typename Functor>
    21252148    SectionReader& sectionLines(const std::string& type, Functor functor) {
    2126       LEMON_ASSERT(!type.empty(), "Type is not empty.");
     2149      LEMON_ASSERT(!type.empty(), "Type is empty.");
    21272150      LEMON_ASSERT(_sections.find(type) == _sections.end(),
    21282151                   "Multiple reading of section.");
    21292152      _sections.insert(std::make_pair(type,
     
    21352158    /// \brief Add a section processor with stream oriented reading
    21362159    ///
    21372160    /// The first parameter is the type of the section, the second is
    2138     /// a functor, which takes an \c std::istream& and an int&
     2161    /// a functor, which takes an \c std::istream& and an \c int&
    21392162    /// parameter, the latter regard to the line number of stream. The
    21402163    /// functor can read the input while the section go on, and the
    21412164    /// line number should be modified accordingly.
    21422165    template <typename Functor>
    21432166    SectionReader& sectionStream(const std::string& type, Functor functor) {
    2144       LEMON_ASSERT(!type.empty(), "Type is not empty.");
     2167      LEMON_ASSERT(!type.empty(), "Type is empty.");
    21452168      LEMON_ASSERT(_sections.find(type) == _sections.end(),
    21462169                   "Multiple reading of section.");
    21472170      _sections.insert(std::make_pair(type,
     
    21862209
    21872210    /// \brief Start the batch processing
    21882211    ///
    2189     /// This function starts the batch processing
     2212    /// This function starts the batch processing.
    21902213    void run() {
    21912214     
    21922215      LEMON_ASSERT(_is != 0, "This reader assigned to an other reader");
     
    22392262       
    22402263  };
    22412264
     2265  /// \brief Return a \ref SectionReader class
     2266  ///
     2267  /// This function just returns a \ref SectionReader class.
    22422268  /// \relates SectionReader
    22432269  inline SectionReader sectionReader(std::istream& is) {
    22442270    SectionReader tmp(is);
    22452271    return tmp;
    22462272  }
    22472273
     2274  /// \brief Return a \ref SectionReader class
     2275  ///
     2276  /// This function just returns a \ref SectionReader class.
    22482277  /// \relates SectionReader
    22492278  inline SectionReader sectionReader(const std::string& fn) {
    22502279    SectionReader tmp(fn);
    22512280    return tmp;
    22522281  }
    22532282
     2283  /// \brief Return a \ref SectionReader class
     2284  ///
     2285  /// This function just returns a \ref SectionReader class.
    22542286  /// \relates SectionReader
    22552287  inline SectionReader sectionReader(const char* fn) {
    22562288    SectionReader tmp(fn);
     
    22692301  /// reads the graph and stores the appropriate information for
    22702302  /// reading the graph.
    22712303  ///
    2272   ///\code LgfContents contents("graph.lgf");
     2304  ///\code
     2305  /// LgfContents contents("graph.lgf");
    22732306  /// contents.run();
    22742307  ///
    2275   /// // does it contain any node section and arc section
     2308  /// // Does it contain any node section and arc section?
    22762309  /// if (contents.nodeSectionNum() == 0 || contents.arcSectionNum()) {
    2277   ///   std::cerr << "Failure, cannot find graph" << std::endl;
     2310  ///   std::cerr << "Failure, cannot find graph." << std::endl;
    22782311  ///   return -1;
    22792312  /// }
    2280   /// std::cout << "The name of the default node section : "
     2313  /// std::cout << "The name of the default node section: "
    22812314  ///           << contents.nodeSection(0) << std::endl;
    2282   /// std::cout << "The number of the arc maps : "
     2315  /// std::cout << "The number of the arc maps: "
    22832316  ///           << contents.arcMaps(0).size() << std::endl;
    2284   /// std::cout << "The name of second arc map : "
     2317  /// std::cout << "The name of second arc map: "
    22852318  ///           << contents.arcMaps(0)[1] << std::endl;
    22862319  ///\endcode
    22872320  class LgfContents {   
     
    23522385      return _node_sections.size();
    23532386    }
    23542387
    2355     /// \brief Returns the section name at the given position.
     2388    /// \brief Returns the node section name at the given position.
    23562389    ///
    2357     /// Returns the section name at the given position.
     2390    /// Returns the node section name at the given position.
    23582391    const std::string& nodeSection(int i) const {
    23592392      return _node_sections[i];
    23602393    }
     
    23792412      return _edge_sections.size();
    23802413    }
    23812414
    2382     /// \brief Returns the section name at the given position.
     2415    /// \brief Returns the arc/edge section name at the given position.
    23832416    ///
    2384     /// Returns the section name at the given position.
     2417    /// Returns the arc/edge section name at the given position.
    23852418    /// \note It is synonym of \c edgeSection().
    23862419    const std::string& arcSection(int i) const {
    23872420      return _edge_sections[i];
     
    24362469      return _attribute_sections.size();
    24372470    }
    24382471
    2439     /// \brief Returns the section name at the given position.
     2472    /// \brief Returns the attribute section name at the given position.
    24402473    ///
    2441     /// Returns the section name at the given position.
     2474    /// Returns the attribute section name at the given position.
    24422475    const std::string& attributeSectionNames(int i) const {
    24432476      return _attribute_sections[i];
    24442477    }
     
    25292562    /// \name Execution of the contents reader   
    25302563    /// @{
    25312564
    2532     /// \brief Start the reading
     2565    /// \brief Starts the reading
    25332566    ///
    2534     /// This function starts the reading
     2567    /// This function starts the reading.
    25352568    void run() {
    25362569
    25372570      readLine();
  • lemon/lgf_writer.h

    diff -r 1e6af6f0843c -r 7bf5f97d574f lemon/lgf_writer.h
    a b  
    1818
    1919///\ingroup lemon_io
    2020///\file
    21 ///\brief Lemon Graph Format writer.
     21///\brief \ref lgf-format "Lemon Graph Format" writer.
    2222
    2323
    2424#ifndef LEMON_LGF_WRITER_H
     
    322322 
    323323  /// \ingroup lemon_io
    324324  /// 
    325   /// \brief LGF writer for directed graphs
     325  /// \brief \ref lgf-format "LGF" writer for directed graphs
    326326  ///
    327327  /// This utility writes an \ref lgf-format "LGF" file.
    328328  ///
     
    332332  /// member function. A map writing rule can be added to the writer
    333333  /// with the \c nodeMap() or \c arcMap() members. An optional
    334334  /// converter parameter can also be added as a standard functor
    335   /// converting from the value type of the map to std::string. If it
    336   /// is set, it will determine how the map's value type is written to
     335  /// converting from the value type of the map to \c std::string. If it
     336  /// is set, it will determine how the value type of the map is written to
    337337  /// the output stream. If the functor is not set, then a default
    338338  /// conversion will be used. The \c attribute(), \c node() and \c
    339339  /// arc() functions are used to add attribute writing rules.
    340340  ///
    341341  ///\code
    342   ///     DigraphWriter<Digraph>(std::cout, digraph).
    343   ///       nodeMap("coordinates", coord_map).
    344   ///       nodeMap("size", size).
    345   ///       nodeMap("title", title).
    346   ///       arcMap("capacity", cap_map).
    347   ///       node("source", src).
    348   ///       node("target", trg).
    349   ///       attribute("caption", caption).
    350   ///       run();
     342  /// DigraphWriter<Digraph>(std::cout, digraph).
     343  ///   nodeMap("coordinates", coord_map).
     344  ///   nodeMap("size", size).
     345  ///   nodeMap("title", title).
     346  ///   arcMap("capacity", cap_map).
     347  ///   node("source", src).
     348  ///   node("target", trg).
     349  ///   attribute("caption", caption).
     350  ///   run();
    351351  ///\endcode
    352352  ///
    353353  ///
     
    486486    /// \name Writing rules
    487487    /// @{
    488488   
    489     /// \brief Node map reading rule
     489    /// \brief Node map writing rule
    490490    ///
    491     /// Add a node map reading rule to the writer.
     491    /// Add a node map writing rule to the writer.
    492492    template <typename Map>
    493493    DigraphWriter& nodeMap(const std::string& caption, const Map& map) {
    494494      checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
     
    586586      return *this;
    587587    }
    588588
    589     /// \name Select section by name
     589    /// \name Section captions
    590590    /// @{
    591591
    592     /// \brief Set \c \@nodes section to be read
     592    /// \brief Add an additional caption to the \c \@nodes section
    593593    ///
    594     /// Set \c \@nodes section to be read
     594    /// Add an additional caption to the \c \@nodes section.
    595595    DigraphWriter& nodes(const std::string& caption) {
    596596      _nodes_caption = caption;
    597597      return *this;
    598598    }
    599599
    600     /// \brief Set \c \@arcs section to be read
     600    /// \brief Add an additional caption to the \c \@arcs section
    601601    ///
    602     /// Set \c \@arcs section to be read
     602    /// Add an additional caption to the \c \@arcs section.
    603603    DigraphWriter& arcs(const std::string& caption) {
    604604      _arcs_caption = caption;
    605605      return *this;
    606606    }
    607607
    608     /// \brief Set \c \@attributes section to be read
     608    /// \brief Add an additional caption to the \c \@attributes section
    609609    ///
    610     /// Set \c \@attributes section to be read
     610    /// Add an additional caption to the \c \@attributes section.
    611611    DigraphWriter& attributes(const std::string& caption) {
    612612      _attributes_caption = caption;
    613613      return *this;
     
    618618
    619619    /// \brief Skip writing the node set
    620620    ///
    621     /// The \c \@nodes section will be not written to the stream.
     621    /// The \c \@nodes section will not be written to the stream.
    622622    DigraphWriter& skipNodes() {
    623623      LEMON_ASSERT(!_skip_nodes, "Multiple usage of skipNodes() member");
    624624      _skip_nodes = true;
     
    627627
    628628    /// \brief Skip writing arc set
    629629    ///
    630     /// The \c \@arcs section will be not written to the stream.
     630    /// The \c \@arcs section will not be written to the stream.
    631631    DigraphWriter& skipArcs() {
    632632      LEMON_ASSERT(!_skip_arcs, "Multiple usage of skipArcs() member");
    633633      _skip_arcs = true;
     
    835835
    836836    /// \brief Start the batch processing
    837837    ///
    838     /// This function starts the batch processing
     838    /// This function starts the batch processing.
    839839    void run() {
    840840      if (!_skip_nodes) {
    841841        writeNodes();
     
    850850      writeAttributes();
    851851    }
    852852
    853     /// \brief Gives back the stream of the writer
     853    /// \brief Give back the stream of the writer
    854854    ///
    855     /// Gives back the stream of the writer
     855    /// Give back the stream of the writer.
    856856    std::ostream& ostream() {
    857857      return *_os;
    858858    }
     
    860860    /// @}
    861861  };
    862862
     863  /// \brief Return a \ref DigraphWriter class
     864  ///
     865  /// This function just returns a \ref DigraphWriter class.
    863866  /// \relates DigraphWriter
    864867  template <typename Digraph>
    865868  DigraphWriter<Digraph> digraphWriter(std::ostream& os,
     
    868871    return tmp;
    869872  }
    870873
     874  /// \brief Return a \ref DigraphWriter class
     875  ///
     876  /// This function just returns a \ref DigraphWriter class.
    871877  /// \relates DigraphWriter
    872878  template <typename Digraph>
    873879  DigraphWriter<Digraph> digraphWriter(const std::string& fn,
     
    876882    return tmp;
    877883  }
    878884
     885  /// \brief Return a \ref DigraphWriter class
     886  ///
     887  /// This function just returns a \ref DigraphWriter class.
    879888  /// \relates DigraphWriter
    880889  template <typename Digraph>
    881890  DigraphWriter<Digraph> digraphWriter(const char* fn,
     
    898907
    899908  /// \ingroup lemon_io
    900909  /// 
    901   /// \brief LGF writer for directed graphs
     910  /// \brief \ref lgf-format "LGF" writer for directed graphs
    902911  ///
    903912  /// This utility writes an \ref lgf-format "LGF" file.
     913  ///
     914  /// It can be used almost the same way as \c DigraphWriter.
     915  /// The only difference is that this class can handle edges and
     916  /// edge maps as well as arcs and arc maps.
    904917  template <typename _Graph>
    905918  class GraphWriter {
    906919  public:
     
    10231036    /// \name Writing rules
    10241037    /// @{
    10251038   
    1026     /// \brief Node map reading rule
     1039    /// \brief Node map writing rule
    10271040    ///
    1028     /// Add a node map reading rule to the writer.
     1041    /// Add a node map writing rule to the writer.
    10291042    template <typename Map>
    10301043    GraphWriter& nodeMap(const std::string& caption, const Map& map) {
    10311044      checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
     
    11691182      return *this;
    11701183    }
    11711184
    1172     /// \name Select section by name
     1185    /// \name Section captions
    11731186    /// @{
    11741187
    1175     /// \brief Set \c \@nodes section to be read
     1188    /// \brief Add an additional caption to the \c \@nodes section
    11761189    ///
    1177     /// Set \c \@nodes section to be read
     1190    /// Add an additional caption to the \c \@nodes section.
    11781191    GraphWriter& nodes(const std::string& caption) {
    11791192      _nodes_caption = caption;
    11801193      return *this;
    11811194    }
    11821195
    1183     /// \brief Set \c \@edges section to be read
     1196    /// \brief Add an additional caption to the \c \@arcs section
    11841197    ///
    1185     /// Set \c \@edges section to be read
     1198    /// Add an additional caption to the \c \@arcs section.
    11861199    GraphWriter& edges(const std::string& caption) {
    11871200      _edges_caption = caption;
    11881201      return *this;
    11891202    }
    11901203
    1191     /// \brief Set \c \@attributes section to be read
     1204    /// \brief Add an additional caption to the \c \@attributes section
    11921205    ///
    1193     /// Set \c \@attributes section to be read
     1206    /// Add an additional caption to the \c \@attributes section.
    11941207    GraphWriter& attributes(const std::string& caption) {
    11951208      _attributes_caption = caption;
    11961209      return *this;
     
    12011214
    12021215    /// \brief Skip writing the node set
    12031216    ///
    1204     /// The \c \@nodes section will be not written to the stream.
     1217    /// The \c \@nodes section will not be written to the stream.
    12051218    GraphWriter& skipNodes() {
    12061219      LEMON_ASSERT(!_skip_nodes, "Multiple usage of skipNodes() member");
    12071220      _skip_nodes = true;
     
    12101223
    12111224    /// \brief Skip writing edge set
    12121225    ///
    1213     /// The \c \@edges section will be not written to the stream.
     1226    /// The \c \@edges section will not be written to the stream.
    12141227    GraphWriter& skipEdges() {
    12151228      LEMON_ASSERT(!_skip_edges, "Multiple usage of skipEdges() member");
    12161229      _skip_edges = true;
     
    14181431
    14191432    /// \brief Start the batch processing
    14201433    ///
    1421     /// This function starts the batch processing
     1434    /// This function starts the batch processing.
    14221435    void run() {
    14231436      if (!_skip_nodes) {
    14241437        writeNodes();
     
    14331446      writeAttributes();
    14341447    }
    14351448
    1436     /// \brief Gives back the stream of the writer
     1449    /// \brief Give back the stream of the writer
    14371450    ///
    1438     /// Gives back the stream of the writer
     1451    /// Give back the stream of the writer
    14391452    std::ostream& ostream() {
    14401453      return *_os;
    14411454    }
     
    14431456    /// @}
    14441457  };
    14451458
     1459  /// \brief Return a \ref GraphWriter class
     1460  ///
     1461  /// This function just returns a \ref GraphWriter class.
    14461462  /// \relates GraphWriter
    14471463  template <typename Graph>
    14481464  GraphWriter<Graph> graphWriter(std::ostream& os, const Graph& graph) {
     
    14501466    return tmp;
    14511467  }
    14521468
     1469  /// \brief Return a \ref GraphWriter class
     1470  ///
     1471  /// This function just returns a \ref GraphWriter class.
    14531472  /// \relates GraphWriter
    14541473  template <typename Graph>
    14551474  GraphWriter<Graph> graphWriter(const std::string& fn, const Graph& graph) {
     
    14571476    return tmp;
    14581477  }
    14591478
     1479  /// \brief Return a \ref GraphWriter class
     1480  ///
     1481  /// This function just returns a \ref GraphWriter class.
    14601482  /// \relates GraphWriter
    14611483  template <typename Graph>
    14621484  GraphWriter<Graph> graphWriter(const char* fn, const Graph& graph) {