COIN-OR::LEMON - Graph Library

Changeset 192:7bf5f97d574f in lemon-1.2 for lemon


Ignore:
Timestamp:
07/05/08 00:14:27 (16 years ago)
Author:
Peter Kovacs <kpeter@…>
Branch:
default
Phase:
public
Message:

Doc improvements in LGF related files

Location:
lemon
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • lemon/lgf_reader.h

    r190 r192  
    1919///\ingroup lemon_io
    2020///\file
    21 ///\brief Lemon Graph Format reader.
     21///\brief \ref lgf-format "Lemon Graph Format" reader.
    2222
    2323
     
    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.
     
    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
     
    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  ///
     
    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.
     
    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,
     
    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,
     
    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");
     
    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() {
     
    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>
     
    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>
     
    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>
     
    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 {
     
    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)
     
    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)
     
    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)
     
    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;
     
    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;
     
    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;
     
    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,
     
    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,
     
    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");
     
    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() {
     
    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>
     
    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>
     
    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>
     
    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.
     
    21062129    ///\endcode
    21072130    ///
    2108     /// The functor is implemented as an struct:
     2131    /// The functor is implemented as a struct:
    21092132    ///\code
    21102133    ///  struct NumberSection {
     
    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.");
     
    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
     
    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.");
     
    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     
     
    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) {
     
    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) {
     
    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) {
     
    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
     
    23532386    }
    23542387
    2355     /// \brief Returns the section name at the given position.
    2356     ///
    2357     /// Returns the section name at the given position.
     2388    /// \brief Returns the node section name at the given position.
     2389    ///
     2390    /// Returns the node section name at the given position.
    23582391    const std::string& nodeSection(int i) const {
    23592392      return _node_sections[i];
     
    23802413    }
    23812414
    2382     /// \brief Returns the section name at the given position.
    2383     ///
    2384     /// Returns the section name at the given position.
     2415    /// \brief Returns the arc/edge section name at the given position.
     2416    ///
     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 {
     
    24372470    }
    24382471
    2439     /// \brief Returns the section name at the given position.
    2440     ///
    2441     /// Returns the section name at the given position.
     2472    /// \brief Returns the attribute section name at the given position.
     2473    ///
     2474    /// Returns the attribute section name at the given position.
    24422475    const std::string& attributeSectionNames(int i) const {
    24432476      return _attribute_sections[i];
     
    25302563    /// @{
    25312564
    2532     /// \brief Start the reading
    2533     ///
    2534     /// This function starts the reading
     2565    /// \brief Starts the reading
     2566    ///
     2567    /// This function starts the reading.
    25352568    void run() {
    25362569
  • lemon/lgf_writer.h

    r190 r192  
    1919///\ingroup lemon_io
    2020///\file
    21 ///\brief Lemon Graph Format writer.
     21///\brief \ref lgf-format "Lemon Graph Format" writer.
    2222
    2323
     
    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.
     
    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
     
    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  ///
     
    487487    /// @{
    488488   
    489     /// \brief Node map reading rule
    490     ///
    491     /// Add a node map reading rule to the writer.
     489    /// \brief Node map writing rule
     490    ///
     491    /// Add a node map writing rule to the writer.
    492492    template <typename Map>
    493493    DigraphWriter& nodeMap(const std::string& caption, const Map& map) {
     
    587587    }
    588588
    589     /// \name Select section by name
     589    /// \name Section captions
    590590    /// @{
    591591
    592     /// \brief Set \c \@nodes section to be read
    593     ///
    594     /// Set \c \@nodes section to be read
     592    /// \brief Add an additional caption to the \c \@nodes section
     593    ///
     594    /// Add an additional caption to the \c \@nodes section.
    595595    DigraphWriter& nodes(const std::string& caption) {
    596596      _nodes_caption = caption;
     
    598598    }
    599599
    600     /// \brief Set \c \@arcs section to be read
    601     ///
    602     /// Set \c \@arcs section to be read
     600    /// \brief Add an additional caption to the \c \@arcs section
     601    ///
     602    /// Add an additional caption to the \c \@arcs section.
    603603    DigraphWriter& arcs(const std::string& caption) {
    604604      _arcs_caption = caption;
     
    606606    }
    607607
    608     /// \brief Set \c \@attributes section to be read
    609     ///
    610     /// Set \c \@attributes section to be read
     608    /// \brief Add an additional caption to the \c \@attributes section
     609    ///
     610    /// Add an additional caption to the \c \@attributes section.
    611611    DigraphWriter& attributes(const std::string& caption) {
    612612      _attributes_caption = caption;
     
    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");
     
    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");
     
    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) {
     
    851851    }
    852852
    853     /// \brief Gives back the stream of the writer
    854     ///
    855     /// Gives back the stream of the writer
     853    /// \brief Give back the stream of the writer
     854    ///
     855    /// Give back the stream of the writer.
    856856    std::ostream& ostream() {
    857857      return *_os;
     
    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>
     
    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>
     
    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>
     
    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 {
     
    10241037    /// @{
    10251038   
    1026     /// \brief Node map reading rule
    1027     ///
    1028     /// Add a node map reading rule to the writer.
     1039    /// \brief Node map writing rule
     1040    ///
     1041    /// Add a node map writing rule to the writer.
    10291042    template <typename Map>
    10301043    GraphWriter& nodeMap(const std::string& caption, const Map& map) {
     
    11701183    }
    11711184
    1172     /// \name Select section by name
     1185    /// \name Section captions
    11731186    /// @{
    11741187
    1175     /// \brief Set \c \@nodes section to be read
    1176     ///
    1177     /// Set \c \@nodes section to be read
     1188    /// \brief Add an additional caption to the \c \@nodes section
     1189    ///
     1190    /// Add an additional caption to the \c \@nodes section.
    11781191    GraphWriter& nodes(const std::string& caption) {
    11791192      _nodes_caption = caption;
     
    11811194    }
    11821195
    1183     /// \brief Set \c \@edges section to be read
    1184     ///
    1185     /// Set \c \@edges section to be read
     1196    /// \brief Add an additional caption to the \c \@arcs section
     1197    ///
     1198    /// Add an additional caption to the \c \@arcs section.
    11861199    GraphWriter& edges(const std::string& caption) {
    11871200      _edges_caption = caption;
     
    11891202    }
    11901203
    1191     /// \brief Set \c \@attributes section to be read
    1192     ///
    1193     /// Set \c \@attributes section to be read
     1204    /// \brief Add an additional caption to the \c \@attributes section
     1205    ///
     1206    /// Add an additional caption to the \c \@attributes section.
    11941207    GraphWriter& attributes(const std::string& caption) {
    11951208      _attributes_caption = caption;
     
    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");
     
    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");
     
    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) {
     
    14341447    }
    14351448
    1436     /// \brief Gives back the stream of the writer
    1437     ///
    1438     /// Gives back the stream of the writer
     1449    /// \brief Give back the stream of the writer
     1450    ///
     1451    /// Give back the stream of the writer
    14391452    std::ostream& ostream() {
    14401453      return *_os;
     
    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>
     
    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>
     
    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>
Note: See TracChangeset for help on using the changeset viewer.