1.1 --- a/lemon/bellman_ford.h Thu Feb 02 17:09:09 2006 +0000
1.2 +++ b/lemon/bellman_ford.h Thu Feb 02 17:43:24 2006 +0000
1.3 @@ -544,11 +544,11 @@
1.4 /// - The distance of each node from the root.
1.5 ///
1.6 /// \note d.run(s) is just a shortcut of the following code.
1.7 - /// \code
1.8 + ///\code
1.9 /// d.init();
1.10 /// d.addSource(s);
1.11 /// d.start();
1.12 - /// \endcode
1.13 + ///\endcode
1.14 void run(Node s) {
1.15 init();
1.16 addSource(s);
1.17 @@ -565,11 +565,11 @@
1.18 /// - The distance of each node from the root.
1.19 ///
1.20 /// \note d.run(s, len) is just a shortcut of the following code.
1.21 - /// \code
1.22 + ///\code
1.23 /// d.init();
1.24 /// d.addSource(s);
1.25 /// d.limitedStart(len);
1.26 - /// \endcode
1.27 + ///\endcode
1.28 void run(Node s, int len) {
1.29 init();
1.30 addSource(s);
1.31 @@ -928,9 +928,9 @@
1.32 /// \ref BellmanFordWizard.
1.33 /// The following
1.34 /// example shows how to use these parameters.
1.35 - /// \code
1.36 + ///\code
1.37 /// bellmanford(g,length,source).predMap(preds).run();
1.38 - /// \endcode
1.39 + ///\endcode
1.40 /// \warning Don't forget to put the \ref BellmanFordWizard::run() "run()"
1.41 /// to the end of the parameter list.
1.42 /// \sa BellmanFordWizard
2.1 --- a/lemon/bits/alteration_notifier.h Thu Feb 02 17:09:09 2006 +0000
2.2 +++ b/lemon/bits/alteration_notifier.h Thu Feb 02 17:43:24 2006 +0000
2.3 @@ -20,7 +20,7 @@
2.4 #include <vector>
2.5 #include <algorithm>
2.6
2.7 -///\ingroin graphmapfactory
2.8 +///\ingroup graphmapfactory
2.9 ///\file
2.10 ///\brief Observer registry for graph alteration observers.
2.11
3.1 --- a/lemon/bits/array_map.h Thu Feb 02 17:09:09 2006 +0000
3.2 +++ b/lemon/bits/array_map.h Thu Feb 02 17:43:24 2006 +0000
3.3 @@ -23,14 +23,14 @@
3.4 #include <lemon/concept_check.h>
3.5 #include <lemon/concept/maps.h>
3.6
3.7 -/// \ingroin graphmapfactory
3.8 +/// \ingroup graphmapfactory
3.9 /// \file
3.10 /// \brief Graph maps that construct and destruct
3.11 /// their elements dynamically.
3.12
3.13 namespace lemon {
3.14
3.15 - /// \ingroin graphmapfactory
3.16 + /// \ingroup graphmapfactory
3.17 ///
3.18 /// \brief Graph map based on the array storage.
3.19 ///
4.1 --- a/lemon/bits/default_map.h Thu Feb 02 17:09:09 2006 +0000
4.2 +++ b/lemon/bits/default_map.h Thu Feb 02 17:43:24 2006 +0000
4.3 @@ -21,7 +21,7 @@
4.4 #include <lemon/bits/array_map.h>
4.5 #include <lemon/bits/vector_map.h>
4.6
4.7 -///\ingroin graphmapfactory
4.8 +///\ingroup graphmapfactory
4.9 ///\file
4.10 ///\brief Graph maps that construct and destruct
4.11 ///their elements dynamically.
5.1 --- a/lemon/bits/item_reader.h Thu Feb 02 17:09:09 2006 +0000
5.2 +++ b/lemon/bits/item_reader.h Thu Feb 02 17:43:24 2006 +0000
5.3 @@ -15,14 +15,14 @@
5.4 */
5.5
5.6 /// @defgroin item_io Item Readers and Writers
5.7 -/// @ingroin io_groin
5.8 +/// @ingroup io_groin
5.9 /// \brief Item Readers and Writers
5.10 ///
5.11 /// The Input-Output classes can handle more data type by example
5.12 /// as map or attribute value. Each of these should be written and
5.13 /// read some way. The module make possible to do this.
5.14
5.15 -/// \ingroin item_io
5.16 +/// \ingroup item_io
5.17 /// \file
5.18 /// \brief Item reader bits for lemon input.
5.19
5.20 @@ -42,7 +42,7 @@
5.21 template <typename Value>
5.22 class DefaultReader;
5.23
5.24 - /// \ingroin item_io
5.25 + /// \ingroup item_io
5.26 ///
5.27 /// \brief Reader class for quoted strings.
5.28 ///
5.29 @@ -157,7 +157,7 @@
5.30 bool escaped;
5.31 };
5.32
5.33 - /// \ingroin item_io
5.34 + /// \ingroup item_io
5.35 /// \brief Reader for standard containers.
5.36 ///
5.37 /// Reader for back insertable standard containers. The representation
5.38 @@ -204,7 +204,7 @@
5.39
5.40 };
5.41
5.42 - /// \ingroin item_io
5.43 + /// \ingroup item_io
5.44 ///
5.45 /// \brief Reader for standard containers.
5.46 ///
5.47 @@ -252,7 +252,7 @@
5.48
5.49 };
5.50
5.51 - /// \ingroin item_io
5.52 + /// \ingroup item_io
5.53 /// \brief Reader for parsed string.
5.54 ///
5.55 /// Reader for parsed strings. You can define the open and close
5.56 @@ -300,7 +300,7 @@
5.57
5.58 };
5.59
5.60 - /// \ingroin item_io
5.61 + /// \ingroup item_io
5.62 /// \brief Reader for read the whole line.
5.63 ///
5.64 /// Reader for read the whole line.
5.65 @@ -330,7 +330,7 @@
5.66 bool skipSpaces;
5.67 };
5.68
5.69 - /// \ingroin item_io
5.70 + /// \ingroup item_io
5.71 /// \brief Reader for std::pair.
5.72 ///
5.73 /// Reader for std::pair.
5.74 @@ -384,7 +384,7 @@
5.75 }
5.76 };
5.77
5.78 - /// \ingroin item_io
5.79 + /// \ingroup item_io
5.80 ///
5.81 /// \brief The default item reader template class.
5.82 ///
5.83 @@ -471,7 +471,7 @@
5.84 class DefaultReader<std::pair<First, Second> >
5.85 : public PairReader<std::pair<First, Second> > {};
5.86
5.87 - /// \ingroin item_io
5.88 + /// \ingroup item_io
5.89 ///
5.90 /// \brief The default item reader for skipping a value in the stream.
5.91 ///
5.92 @@ -480,7 +480,7 @@
5.93 /// \author Balazs Dezso
5.94 class DefaultSkipper : public DefaultReader<std::string> {};
5.95
5.96 - /// \ingroin item_io
5.97 + /// \ingroup item_io
5.98 /// \brief Standard ReaderTraits for the GraphReader class.
5.99 ///
5.100 /// Standard ReaderTraits for the GraphReader class.
6.1 --- a/lemon/bits/item_writer.h Thu Feb 02 17:09:09 2006 +0000
6.2 +++ b/lemon/bits/item_writer.h Thu Feb 02 17:43:24 2006 +0000
6.3 @@ -14,7 +14,7 @@
6.4 *
6.5 */
6.6
6.7 -/// \ingroin item_io
6.8 +/// \ingroup item_io
6.9 /// \file
6.10 /// \brief Item writer bits for lemon output.
6.11
6.12 @@ -34,7 +34,7 @@
6.13 template <typename Value>
6.14 class DefaultWriter;
6.15
6.16 - /// \ingroin item_io
6.17 + /// \ingroup item_io
6.18 /// \brief Writer class for quoted strings.
6.19 ///
6.20 /// Writer class for quoted strings. It can process the escape
6.21 @@ -117,7 +117,7 @@
6.22 bool escaped;
6.23 };
6.24
6.25 - /// \ingroin item_io
6.26 + /// \ingroup item_io
6.27 /// \brief Writer class for quoted char array.
6.28 ///
6.29 /// Writer class for quoted char array. It can process the escape
6.30 @@ -145,7 +145,7 @@
6.31 };
6.32
6.33
6.34 - /// \ingroin item_io
6.35 + /// \ingroup item_io
6.36 ///
6.37 /// \brief Writer for standard containers.
6.38 ///
6.39 @@ -187,12 +187,12 @@
6.40
6.41 };
6.42
6.43 - /// \ingroin item_io
6.44 + /// \ingroup item_io
6.45 ///
6.46 /// \brief Writer for standard pairs.
6.47 ///
6.48 /// Writer for standard pairs. The representation of a pair is
6.49 - /// \code ( first_value => second_value ) \endcode.
6.50 + ///\code ( first_value => second_value ) \endcode.
6.51 /// \author Balazs Dezso
6.52 template <typename _Pair,
6.53 typename _FirstWriter =
6.54 @@ -234,7 +234,7 @@
6.55
6.56 };
6.57
6.58 - /// \ingroin item_io
6.59 + /// \ingroup item_io
6.60 ///
6.61 /// \brief The default item writer template class.
6.62 ///
6.63 @@ -307,7 +307,7 @@
6.64 class DefaultWriter<std::pair<First, Second> >
6.65 : public PairWriter<std::pair<First, Second> > {};
6.66
6.67 - /// \ingroin item_io
6.68 + /// \ingroup item_io
6.69 /// \brief Standard WriterTraits for the section writers.
6.70 ///
6.71 /// Standard WriterTraits for the section writers.
7.1 --- a/lemon/bits/static_map.h Thu Feb 02 17:09:09 2006 +0000
7.2 +++ b/lemon/bits/static_map.h Thu Feb 02 17:43:24 2006 +0000
7.3 @@ -27,14 +27,14 @@
7.4 #include <lemon/concept_check.h>
7.5 #include <lemon/concept/maps.h>
7.6
7.7 -/// \ingroin graphmaps
7.8 +/// \ingroup graphmaps
7.9 ///
7.10 ///\file
7.11 ///\brief Static sized graph maps.
7.12
7.13 namespace lemon {
7.14
7.15 - /// \ingroin graphmaps
7.16 + /// \ingroup graphmaps
7.17 ///
7.18 /// \brief Graph map with static sized storage.
7.19 ///
8.1 --- a/lemon/bits/vector_map.h Thu Feb 02 17:09:09 2006 +0000
8.2 +++ b/lemon/bits/vector_map.h Thu Feb 02 17:43:24 2006 +0000
8.3 @@ -26,14 +26,14 @@
8.4 #include <lemon/concept_check.h>
8.5 #include <lemon/concept/maps.h>
8.6
8.7 -/// \ingroin graphmapfactory
8.8 +/// \ingroup graphmapfactory
8.9 ///
8.10 ///\file
8.11 ///\brief Vector based graph maps.
8.12
8.13 namespace lemon {
8.14
8.15 - /// \ingroin graphmapfactory
8.16 + /// \ingroup graphmapfactory
8.17 ///
8.18 /// \brief Graph map based on the std::vector storage.
8.19 ///
9.1 --- a/lemon/concept/bpugraph.h Thu Feb 02 17:09:09 2006 +0000
9.2 +++ b/lemon/concept/bpugraph.h Thu Feb 02 17:43:24 2006 +0000
9.3 @@ -244,10 +244,10 @@
9.4 /// This iterator goes through each node.
9.5 /// Its usage is quite simple, for example you can count the number
9.6 /// of nodes in graph \c g of type \c Graph like this:
9.7 - /// \code
9.8 + ///\code
9.9 /// int count=0;
9.10 /// for (Graph::NodeIt n(g); n!=INVALID; ++n) ++count;
9.11 - /// \endcode
9.12 + ///\endcode
9.13 class NodeIt : public Node {
9.14 public:
9.15 /// Default constructor
9.16 @@ -289,10 +289,10 @@
9.17 /// This iterator goes through each ANode.
9.18 /// Its usage is quite simple, for example you can count the number
9.19 /// of nodes in graph \c g of type \c Graph like this:
9.20 - /// \code
9.21 + ///\code
9.22 /// int count=0;
9.23 /// for (Graph::ANodeIt n(g); n!=INVALID; ++n) ++count;
9.24 - /// \endcode
9.25 + ///\endcode
9.26 class ANodeIt : public ANode {
9.27 public:
9.28 /// Default constructor
9.29 @@ -334,10 +334,10 @@
9.30 /// This iterator goes through each BNode.
9.31 /// Its usage is quite simple, for example you can count the number
9.32 /// of nodes in graph \c g of type \c Graph like this:
9.33 - /// \code
9.34 + ///\code
9.35 /// int count=0;
9.36 /// for (Graph::BNodeIt n(g); n!=INVALID; ++n) ++count;
9.37 - /// \endcode
9.38 + ///\endcode
9.39 class BNodeIt : public BNode {
9.40 public:
9.41 /// Default constructor
9.42 @@ -425,10 +425,10 @@
9.43 /// This iterator goes through each undirected edge of a graph.
9.44 /// Its usage is quite simple, for example you can count the number
9.45 /// of undirected edges in a graph \c g of type \c Graph as follows:
9.46 - /// \code
9.47 + ///\code
9.48 /// int count=0;
9.49 /// for(Graph::UEdgeIt e(g); e!=INVALID; ++e) ++count;
9.50 - /// \endcode
9.51 + ///\endcode
9.52 class UEdgeIt : public UEdge {
9.53 public:
9.54 /// Default constructor
9.55 @@ -473,10 +473,10 @@
9.56 /// degree (i.e. count the number
9.57 /// of incident edges of a node \c n
9.58 /// in graph \c g of type \c Graph as follows.
9.59 - /// \code
9.60 + ///\code
9.61 /// int count=0;
9.62 /// for(Graph::IncEdgeIt e(g, n); e!=INVALID; ++e) ++count;
9.63 - /// \endcode
9.64 + ///\endcode
9.65 class IncEdgeIt : public UEdge {
9.66 public:
9.67 /// Default constructor
9.68 @@ -562,10 +562,10 @@
9.69 /// This iterator goes through each edge of a graph.
9.70 /// Its usage is quite simple, for example you can count the number
9.71 /// of edges in a graph \c g of type \c Graph as follows:
9.72 - /// \code
9.73 + ///\code
9.74 /// int count=0;
9.75 /// for(Graph::EdgeIt e(g); e!=INVALID; ++e) ++count;
9.76 - /// \endcode
9.77 + ///\endcode
9.78 class EdgeIt : public Edge {
9.79 public:
9.80 /// Default constructor
9.81 @@ -607,10 +607,10 @@
9.82 /// Its usage is quite simple, for example you can count the number
9.83 /// of outgoing edges of a node \c n
9.84 /// in graph \c g of type \c Graph as follows.
9.85 - /// \code
9.86 + ///\code
9.87 /// int count=0;
9.88 /// for (Graph::OutEdgeIt e(g, n); e!=INVALID; ++e) ++count;
9.89 - /// \endcode
9.90 + ///\endcode
9.91
9.92 class OutEdgeIt : public Edge {
9.93 public:
9.94 @@ -659,10 +659,10 @@
9.95 /// Its usage is quite simple, for example you can count the number
9.96 /// of outgoing edges of a node \c n
9.97 /// in graph \c g of type \c Graph as follows.
9.98 - /// \code
9.99 + ///\code
9.100 /// int count=0;
9.101 /// for(Graph::InEdgeIt e(g, n); e!=INVALID; ++e) ++count;
9.102 - /// \endcode
9.103 + ///\endcode
9.104
9.105 class InEdgeIt : public Edge {
9.106 public:
10.1 --- a/lemon/concept/graph.h Thu Feb 02 17:09:09 2006 +0000
10.2 +++ b/lemon/concept/graph.h Thu Feb 02 17:43:24 2006 +0000
10.3 @@ -192,10 +192,10 @@
10.4 /// This iterator goes through each node.
10.5 /// Its usage is quite simple, for example you can count the number
10.6 /// of nodes in graph \c g of type \c Graph like this:
10.7 - /// \code
10.8 + ///\code
10.9 /// int count=0;
10.10 /// for (Graph::NodeIt n(g); n!=INVALID; ++n) ++count;
10.11 - /// \endcode
10.12 + ///\endcode
10.13 class NodeIt : public Node {
10.14 public:
10.15 /// Default constructor
10.16 @@ -285,10 +285,10 @@
10.17 /// Its usage is quite simple, for example you can count the number
10.18 /// of outgoing edges of a node \c n
10.19 /// in graph \c g of type \c Graph as follows.
10.20 - /// \code
10.21 + ///\code
10.22 /// int count=0;
10.23 /// for (Graph::OutEdgeIt e(g, n); e!=INVALID; ++e) ++count;
10.24 - /// \endcode
10.25 + ///\endcode
10.26
10.27 class OutEdgeIt : public Edge {
10.28 public:
10.29 @@ -332,10 +332,10 @@
10.30 /// Its usage is quite simple, for example you can count the number
10.31 /// of outgoing edges of a node \c n
10.32 /// in graph \c g of type \c Graph as follows.
10.33 - /// \code
10.34 + ///\code
10.35 /// int count=0;
10.36 /// for(Graph::InEdgeIt e(g, n); e!=INVALID; ++e) ++count;
10.37 - /// \endcode
10.38 + ///\endcode
10.39
10.40 class InEdgeIt : public Edge {
10.41 public:
10.42 @@ -376,10 +376,10 @@
10.43 /// This iterator goes through each edge of a graph.
10.44 /// Its usage is quite simple, for example you can count the number
10.45 /// of edges in a graph \c g of type \c Graph as follows:
10.46 - /// \code
10.47 + ///\code
10.48 /// int count=0;
10.49 /// for(Graph::EdgeIt e(g); e!=INVALID; ++e) ++count;
10.50 - /// \endcode
10.51 + ///\endcode
10.52 class EdgeIt : public Edge {
10.53 public:
10.54 /// Default constructor
11.1 --- a/lemon/concept/ugraph.h Thu Feb 02 17:09:09 2006 +0000
11.2 +++ b/lemon/concept/ugraph.h Thu Feb 02 17:43:24 2006 +0000
11.3 @@ -304,10 +304,10 @@
11.4 /// This iterator goes through each node.
11.5 /// Its usage is quite simple, for example you can count the number
11.6 /// of nodes in graph \c g of type \c Graph like this:
11.7 - /// \code
11.8 + ///\code
11.9 /// int count=0;
11.10 /// for (Graph::NodeIt n(g); n!=INVALID; ++n) ++count;
11.11 - /// \endcode
11.12 + ///\endcode
11.13 class NodeIt : public Node {
11.14 public:
11.15 /// Default constructor
11.16 @@ -395,10 +395,10 @@
11.17 /// This iterator goes through each undirected edge of a graph.
11.18 /// Its usage is quite simple, for example you can count the number
11.19 /// of undirected edges in a graph \c g of type \c Graph as follows:
11.20 - /// \code
11.21 + ///\code
11.22 /// int count=0;
11.23 /// for(Graph::UEdgeIt e(g); e!=INVALID; ++e) ++count;
11.24 - /// \endcode
11.25 + ///\endcode
11.26 class UEdgeIt : public UEdge {
11.27 public:
11.28 /// Default constructor
11.29 @@ -443,10 +443,10 @@
11.30 /// degree (i.e. count the number
11.31 /// of incident edges of a node \c n
11.32 /// in graph \c g of type \c Graph as follows.
11.33 - /// \code
11.34 + ///\code
11.35 /// int count=0;
11.36 /// for(Graph::IncEdgeIt e(g, n); e!=INVALID; ++e) ++count;
11.37 - /// \endcode
11.38 + ///\endcode
11.39 class IncEdgeIt : public UEdge {
11.40 public:
11.41 /// Default constructor
11.42 @@ -532,10 +532,10 @@
11.43 /// This iterator goes through each edge of a graph.
11.44 /// Its usage is quite simple, for example you can count the number
11.45 /// of edges in a graph \c g of type \c Graph as follows:
11.46 - /// \code
11.47 + ///\code
11.48 /// int count=0;
11.49 /// for(Graph::EdgeIt e(g); e!=INVALID; ++e) ++count;
11.50 - /// \endcode
11.51 + ///\endcode
11.52 class EdgeIt : public Edge {
11.53 public:
11.54 /// Default constructor
11.55 @@ -577,10 +577,10 @@
11.56 /// Its usage is quite simple, for example you can count the number
11.57 /// of outgoing edges of a node \c n
11.58 /// in graph \c g of type \c Graph as follows.
11.59 - /// \code
11.60 + ///\code
11.61 /// int count=0;
11.62 /// for (Graph::OutEdgeIt e(g, n); e!=INVALID; ++e) ++count;
11.63 - /// \endcode
11.64 + ///\endcode
11.65
11.66 class OutEdgeIt : public Edge {
11.67 public:
11.68 @@ -629,10 +629,10 @@
11.69 /// Its usage is quite simple, for example you can count the number
11.70 /// of outgoing edges of a node \c n
11.71 /// in graph \c g of type \c Graph as follows.
11.72 - /// \code
11.73 + ///\code
11.74 /// int count=0;
11.75 /// for(Graph::InEdgeIt e(g, n); e!=INVALID; ++e) ++count;
11.76 - /// \endcode
11.77 + ///\endcode
11.78
11.79 class InEdgeIt : public Edge {
11.80 public:
12.1 --- a/lemon/dag_shortest_path.h Thu Feb 02 17:09:09 2006 +0000
12.2 +++ b/lemon/dag_shortest_path.h Thu Feb 02 17:43:24 2006 +0000
12.3 @@ -116,7 +116,8 @@
12.4 /// \brief Instantiates a PredMap.
12.5 ///
12.6 /// This function instantiates a \ref PredMap.
12.7 - /// \param G is the graph, to which we would like to define the PredMap.
12.8 + /// \param graph is the graph, to which we would
12.9 + /// like to define the PredMap.
12.10 /// \todo The graph alone may be insufficient for the initialization
12.11 static PredMap *createPredMap(const _Graph& graph) {
12.12 return new PredMap(graph);
12.13 @@ -133,7 +134,7 @@
12.14 /// \brief Instantiates a DistMap.
12.15 ///
12.16 /// This function instantiates a \ref DistMap.
12.17 - /// \param G is the graph, to which we would like to define the
12.18 + /// \param graph is the graph, to which we would like to define the
12.19 /// \ref DistMap
12.20 static DistMap *createDistMap(const _Graph& graph) {
12.21 return new DistMap(graph);
12.22 @@ -227,7 +228,8 @@
12.23 /// \brief Instantiates a PredMap.
12.24 ///
12.25 /// This function instantiates a \ref PredMap.
12.26 - /// \param G is the graph, to which we would like to define the PredMap.
12.27 + /// \param graph is the graph,
12.28 + /// to which we would like to define the PredMap.
12.29 /// \todo The graph alone may be insufficient for the initialization
12.30 static PredMap *createPredMap(const _Graph& graph) {
12.31 return new PredMap(graph);
12.32 @@ -244,7 +246,7 @@
12.33 /// \brief Instantiates a DistMap.
12.34 ///
12.35 /// This function instantiates a \ref DistMap.
12.36 - /// \param G is the graph, to which we would like to define the
12.37 + /// \param graph is the graph, to which we would like to define the
12.38 /// \ref DistMap
12.39 static DistMap *createDistMap(const _Graph& graph) {
12.40 return new DistMap(graph);
12.41 @@ -681,11 +683,11 @@
12.42 /// - The distance of each node from the root.
12.43 ///
12.44 /// \note d.run(s) is just a shortcut of the following code.
12.45 - /// \code
12.46 + ///\code
12.47 /// d.init();
12.48 /// d.addSource(s);
12.49 /// d.start();
12.50 - /// \endcode
12.51 + ///\endcode
12.52 void run(Node s) {
12.53 init();
12.54 addSource(s);
12.55 @@ -977,7 +979,7 @@
12.56 /// \brief Runs DagShortestPath algorithm from the given node.
12.57 ///
12.58 /// Runs DagShortestPath algorithm from the given node.
12.59 - /// \param s is the given source.
12.60 + /// \param source is the given source.
12.61 void run(Node source) {
12.62 Base::_source = source;
12.63 run();
12.64 @@ -1042,7 +1044,7 @@
12.65 /// \brief Sets the source node, from which the DagShortestPath algorithm runs.
12.66 ///
12.67 /// Sets the source node, from which the DagShortestPath algorithm runs.
12.68 - /// \param s is the source node.
12.69 + /// \param source is the source node.
12.70 DagShortestPathWizard<_Traits>& source(Node source) {
12.71 Base::_source = source;
12.72 return *this;
12.73 @@ -1060,9 +1062,9 @@
12.74 /// \ref DagShortestPathWizard.
12.75 /// The following
12.76 /// example shows how to use these parameters.
12.77 - /// \code
12.78 + ///\code
12.79 /// dagShortestPath(g,length,source).predMap(preds).run();
12.80 - /// \endcode
12.81 + ///\endcode
12.82 /// \warning Don't forget to put the \ref DagShortestPathWizard::run() "run()"
12.83 /// to the end of the parameter list.
12.84 /// \sa DagShortestPathWizard
13.1 --- a/lemon/dfs.h Thu Feb 02 17:09:09 2006 +0000
13.2 +++ b/lemon/dfs.h Thu Feb 02 17:43:24 2006 +0000
13.3 @@ -1442,11 +1442,11 @@
13.4 ///
13.5 /// This method runs the %DFS algorithm from a root node \c s.
13.6 /// \note d.run(s) is just a shortcut of the following code.
13.7 - /// \code
13.8 + ///\code
13.9 /// d.init();
13.10 /// d.addSource(s);
13.11 /// d.start();
13.12 - /// \endcode
13.13 + ///\endcode
13.14 void run(Node s) {
13.15 init();
13.16 addSource(s);
14.1 --- a/lemon/dimacs.h Thu Feb 02 17:09:09 2006 +0000
14.2 +++ b/lemon/dimacs.h Thu Feb 02 17:43:24 2006 +0000
14.3 @@ -44,9 +44,9 @@
14.4
14.5 /// This function reads a min cost flow instance from dimacs format,
14.6 /// i.e. from dimacs files having a line starting with
14.7 - /// \code
14.8 + ///\code
14.9 /// p "min"
14.10 - /// \endcode
14.11 + ///\endcode
14.12 /// At the beginning \c g is cleared by \c g.clear(). The edge
14.13 /// capacities are written to \c capacity, \c s and \c t are set to
14.14 /// the source and the target nodes resp. and the cost of the edges
14.15 @@ -124,9 +124,9 @@
14.16
14.17 /// This function reads a max flow instance from dimacs format,
14.18 /// i.e. from dimacs files having a line starting with
14.19 - /// \code
14.20 + ///\code
14.21 /// p "max"
14.22 - /// \endcode
14.23 + ///\endcode
14.24 ///At the beginning \c g is cleared by \c g.clear(). The
14.25 /// edge capacities are written to \c capacity and \c s and \c t are
14.26 /// set to the source and the target nodes.
14.27 @@ -144,9 +144,9 @@
14.28
14.29 /// This function reads a shortest path instance from dimacs format,
14.30 /// i.e. from dimacs files having a line starting with
14.31 - /// \code
14.32 + ///\code
14.33 /// p "sp"
14.34 - /// \endcode
14.35 + ///\endcode
14.36 /// At the beginning \c g is cleared by \c g.clear(). The edge
14.37 /// capacities are written to \c capacity and \c s is set to the
14.38 /// source node.
14.39 @@ -180,9 +180,9 @@
14.40 /// This function reads a graph without any designated nodes and
14.41 /// maps from dimacs format, i.e. from dimacs files having a line
14.42 /// starting with
14.43 - /// \code
14.44 + ///\code
14.45 /// p "mat"
14.46 - /// \endcode
14.47 + ///\endcode
14.48 /// At the beginning \c g is cleared
14.49 /// by \c g.clear().
14.50 ///
15.1 --- a/lemon/floyd_warshall.h Thu Feb 02 17:09:09 2006 +0000
15.2 +++ b/lemon/floyd_warshall.h Thu Feb 02 17:43:24 2006 +0000
15.3 @@ -117,7 +117,8 @@
15.4 /// \brief Instantiates a PredMap.
15.5 ///
15.6 /// This function instantiates a \ref PredMap.
15.7 - /// \param G is the graph, to which we would like to define the PredMap.
15.8 + /// \param graph is the graph,
15.9 + /// to which we would like to define the PredMap.
15.10 /// \todo The graph alone may be insufficient for the initialization
15.11 static PredMap *createPredMap(const _Graph& graph) {
15.12 return new PredMap(graph);
15.13 @@ -133,7 +134,7 @@
15.14 /// \brief Instantiates a DistMap.
15.15 ///
15.16 /// This function instantiates a \ref DistMap.
15.17 - /// \param G is the graph, to which we would like to define the
15.18 + /// \param graph is the graph, to which we would like to define the
15.19 /// \ref DistMap
15.20 static DistMap *createDistMap(const _Graph& graph) {
15.21 return new DistMap(graph);
15.22 @@ -454,10 +455,10 @@
15.23 /// - The distance between each node pairs.
15.24 ///
15.25 /// \note d.run(s) is just a shortcut of the following code.
15.26 - /// \code
15.27 + ///\code
15.28 /// d.init();
15.29 /// d.start();
15.30 - /// \endcode
15.31 + ///\endcode
15.32 void run() {
15.33 init();
15.34 start();
16.1 --- a/lemon/fredman_tarjan.h Thu Feb 02 17:09:09 2006 +0000
16.2 +++ b/lemon/fredman_tarjan.h Thu Feb 02 17:43:24 2006 +0000
16.3 @@ -65,7 +65,7 @@
16.4 ///Instantiates a TreeMap.
16.5
16.6 ///This function instantiates a \ref TreeMap.
16.7 - ///\param g is the graph, to which
16.8 + ///\param _graph is the graph, to which
16.9 ///we would like to define the \ref TreeMap
16.10 static TreeMap *createTreeMap(const GR &_graph){
16.11 return new TreeMap(_graph);
17.1 --- a/lemon/graph_adaptor.h Thu Feb 02 17:09:09 2006 +0000
17.2 +++ b/lemon/graph_adaptor.h Thu Feb 02 17:43:24 2006 +0000
17.3 @@ -188,9 +188,9 @@
17.4 /// Let \f$G=(V, A)\f$ be a directed graph and
17.5 /// suppose that a graph instange \c g of type
17.6 /// \c ListGraph implements \f$G\f$.
17.7 - /// \code
17.8 + ///\code
17.9 /// ListGraph g;
17.10 - /// \endcode
17.11 + ///\endcode
17.12 /// For each directed edge
17.13 /// \f$e\in A\f$, let \f$\bar e\f$ denote the edge obtained by
17.14 /// reversing its orientation.
17.15 @@ -199,10 +199,11 @@
17.16 /// \f$\{\bar e : e\in A \}\f$, i.e. the graph obtained from \f$G\f$ be
17.17 /// reversing the orientation of its edges. The following code shows how
17.18 /// such an instance can be constructed.
17.19 - /// \code
17.20 + ///\code
17.21 /// RevGraphAdaptor<ListGraph> gw(g);
17.22 - /// \endcode
17.23 + ///\endcode
17.24 ///\author Marton Makai
17.25 +
17.26 template<typename _Graph>
17.27 class RevGraphAdaptor :
17.28 public IterableGraphExtender<RevGraphAdaptorBase<_Graph> > {
17.29 @@ -1278,18 +1279,18 @@
17.30
17.31 /// For blocking flows.
17.32
17.33 - ///\warning Graph adaptors are in even more experimental state than the other
17.34 + ///\warning Graph adaptors are in even more
17.35 + ///experimental state than the other
17.36 ///parts of the lib. Use them at you own risk.
17.37 ///
17.38 - /// This graph adaptor is used for on-the-fly
17.39 - /// Dinits blocking flow computations.
17.40 - /// For each node, an out-edge is stored which is used when the
17.41 - /// \code
17.42 - /// OutEdgeIt& first(OutEdgeIt&, const Node&)
17.43 - /// \endcode
17.44 - /// is called.
17.45 + ///This graph adaptor is used for on-the-fly
17.46 + ///Dinits blocking flow computations.
17.47 + ///For each node, an out-edge is stored which is used when the
17.48 + ///\code OutEdgeIt& first(OutEdgeIt&, const Node&)\endcode
17.49 + ///is called.
17.50 ///
17.51 - /// \author Marton Makai
17.52 + ///\author Marton Makai
17.53 + ///
17.54 template <typename _Graph, typename FirstOutEdgesMap>
17.55 class ErasingFirstGraphAdaptor :
17.56 public IterableGraphExtender<
18.1 --- a/lemon/graph_reader.h Thu Feb 02 17:09:09 2006 +0000
18.2 +++ b/lemon/graph_reader.h Thu Feb 02 17:43:24 2006 +0000
18.3 @@ -54,9 +54,9 @@
18.4 /// whitespaces, therefore it has some extra possibilities to control how
18.5 /// it should skip the values when the string representation contains spaces.
18.6 ///
18.7 - /// \code
18.8 + ///\code
18.9 /// GraphReader<ListGraph> reader(std::cin, graph);
18.10 - /// \endcode
18.11 + ///\endcode
18.12 ///
18.13 /// The \c readNodeMap() function reads a map from the \c \@nodeset section.
18.14 /// If there is a map that you do not want to read from the file and there is
18.15 @@ -64,31 +64,31 @@
18.16 /// call the \c skipNodeMap() template member function with proper
18.17 /// parameters.
18.18 ///
18.19 - /// \code
18.20 + ///\code
18.21 /// reader.readNodeMap("coords", coords);
18.22 ///
18.23 /// reader.skipNodeMap("description", desc);
18.24 ///
18.25 /// reader.readNodeMap("color", colorMap);
18.26 - /// \endcode
18.27 + ///\endcode
18.28 ///
18.29 /// With the \c readEdgeMap() member function you can give an edge map
18.30 /// reading command similar to the NodeMaps.
18.31 ///
18.32 - /// \code
18.33 + ///\code
18.34 /// reader.readEdgeMap("weight", weightMap);
18.35 /// reader.readEdgeMap("label", labelMap);
18.36 - /// \endcode
18.37 + ///\endcode
18.38 ///
18.39 /// With \c readNode() and \c readEdge() functions you can read
18.40 /// labeled Nodes and Edges.
18.41 ///
18.42 - /// \code
18.43 + ///\code
18.44 /// reader.readNode("source", sourceNode);
18.45 /// reader.readNode("target", targetNode);
18.46 ///
18.47 /// reader.readEdge("observed", edge);
18.48 - /// \endcode
18.49 + ///\endcode
18.50 ///
18.51 /// With the \c readAttribute() functions you can read an attribute
18.52 /// into a variable. You can specify the reader for the attribute as
18.53 @@ -97,9 +97,9 @@
18.54 /// After you give all read commands you must call the \c run() member
18.55 /// function, which executes all the commands.
18.56 ///
18.57 - /// \code
18.58 + ///\code
18.59 /// reader.run();
18.60 - /// \endcode
18.61 + ///\endcode
18.62 ///
18.63 /// \see DefaultReaderTraits
18.64 /// \see QuotedStringReader
18.65 @@ -398,9 +398,9 @@
18.66 /// whitespaces, therefore it has some extra possibilities to control how
18.67 /// it should skip the values when the string representation contains spaces.
18.68 ///
18.69 - /// \code
18.70 + ///\code
18.71 /// UGraphReader<ListUGraph> reader(std::cin, graph);
18.72 - /// \endcode
18.73 + ///\endcode
18.74 ///
18.75 /// The \c readNodeMap() function reads a map from the \c \@nodeset section.
18.76 /// If there is a map that you do not want to read from the file and there is
18.77 @@ -408,39 +408,39 @@
18.78 /// call the \c skipNodeMap() template member function with proper
18.79 /// parameters.
18.80 ///
18.81 - /// \code
18.82 + ///\code
18.83 /// reader.readNodeMap("coords", coords);
18.84 ///
18.85 /// reader.skipNodeMap("description", desc);
18.86 ///
18.87 /// reader.readNodeMap("color", colorMap);
18.88 - /// \endcode
18.89 + ///\endcode
18.90 ///
18.91 /// With the \c readUEdgeMap() member function you can give an
18.92 /// uedge map reading command similar to the NodeMaps.
18.93 ///
18.94 - /// \code
18.95 + ///\code
18.96 /// reader.readUEdgeMap("capacity", capacityMap);
18.97 - /// \endcode
18.98 + ///\endcode
18.99 ///
18.100 /// The reading of the directed edge maps is just a syntactical sugar.
18.101 /// It reads two undirected edgemaps into a directed edge map. The
18.102 /// undirected edge maps' name should be start with the \c '+' and the
18.103 /// \c '-' character and the same.
18.104 ///
18.105 - /// \code
18.106 + ///\code
18.107 /// reader.readEdgeMap("flow", flowMap);
18.108 - /// \endcode
18.109 + ///\endcode
18.110 ///
18.111 /// With \c readNode() and \c readUEdge() functions you can read
18.112 /// labeled Nodes and UEdges.
18.113 ///
18.114 - /// \code
18.115 + ///\code
18.116 /// reader.readNode("source", sourceNode);
18.117 /// reader.readNode("target", targetNode);
18.118 ///
18.119 /// reader.readUEdge("observed", uEdge);
18.120 - /// \endcode
18.121 + ///\endcode
18.122 ///
18.123 /// With the \c readAttribute() functions you can read an attribute
18.124 /// in a variable. You can specify the reader for the attribute as
18.125 @@ -449,9 +449,9 @@
18.126 /// After you give all read commands you must call the \c run() member
18.127 /// function, which execute all the commands.
18.128 ///
18.129 - /// \code
18.130 + ///\code
18.131 /// reader.run();
18.132 - /// \endcode
18.133 + ///\endcode
18.134 ///
18.135 /// \see GraphReader
18.136 /// \see DefaultReaderTraits
19.1 --- a/lemon/graph_utils.h Thu Feb 02 17:09:09 2006 +0000
19.2 +++ b/lemon/graph_utils.h Thu Feb 02 17:43:24 2006 +0000
19.3 @@ -258,11 +258,11 @@
19.4 /// \return The found edge or \ref INVALID if there is no such an edge.
19.5 ///
19.6 /// Thus you can iterate through each edge from \c u to \c v as it follows.
19.7 - /// \code
19.8 + ///\code
19.9 /// for(Edge e=findEdge(g,u,v);e!=INVALID;e=findEdge(g,u,v,e)) {
19.10 /// ...
19.11 /// }
19.12 - /// \endcode
19.13 + ///\endcode
19.14 // /// \todo We may want to use the "GraphBase"
19.15 // /// interface here...
19.16 template <typename Graph>
19.17 @@ -278,11 +278,11 @@
19.18 /// Iterator for iterating on edges connected the same nodes. It is
19.19 /// higher level interface for the findEdge() function. You can
19.20 /// use it the following way:
19.21 - /// \code
19.22 + ///\code
19.23 /// for (ConEdgeIt<Graph> it(g, src, trg); it != INVALID; ++it) {
19.24 /// ...
19.25 /// }
19.26 - /// \endcode
19.27 + ///\endcode
19.28 ///
19.29 /// \author Balazs Dezso
19.30 template <typename _Graph>
19.31 @@ -360,12 +360,12 @@
19.32 /// \return The found edge or \ref INVALID if there is no such an edge.
19.33 ///
19.34 /// Thus you can iterate through each edge from \c u to \c v as it follows.
19.35 - /// \code
19.36 + ///\code
19.37 /// for(UEdge e = findUEdge(g,u,v); e != INVALID;
19.38 /// e = findUEdge(g,u,v,e)) {
19.39 /// ...
19.40 /// }
19.41 - /// \endcode
19.42 + ///\endcode
19.43 // /// \todo We may want to use the "GraphBase"
19.44 // /// interface here...
19.45 template <typename Graph>
19.46 @@ -382,11 +382,11 @@
19.47 /// Iterator for iterating on uedges connected the same nodes. It is
19.48 /// higher level interface for the findUEdge() function. You can
19.49 /// use it the following way:
19.50 - /// \code
19.51 + ///\code
19.52 /// for (ConUEdgeIt<Graph> it(g, src, trg); it != INVALID; ++it) {
19.53 /// ...
19.54 /// }
19.55 - /// \endcode
19.56 + ///\endcode
19.57 ///
19.58 /// \author Balazs Dezso
19.59 template <typename _Graph>
19.60 @@ -580,9 +580,9 @@
19.61 /// Copy a graph to an other graph.
19.62 /// The usage of the function:
19.63 ///
19.64 - /// \code
19.65 + ///\code
19.66 /// copyGraph(trg, src).nodeRef(nr).edgeCrossRef(ecr);
19.67 - /// \endcode
19.68 + ///\endcode
19.69 ///
19.70 /// After the copy the \c nr map will contain the mapping from the
19.71 /// source graph's nodes to the target graph's nodes and the \c ecr will
19.72 @@ -792,9 +792,9 @@
19.73 /// Copy a graph to an other graph.
19.74 /// The usage of the function:
19.75 ///
19.76 - /// \code
19.77 + ///\code
19.78 /// copyGraph(trg, src).nodeRef(nr).edgeCrossRef(ecr);
19.79 - /// \endcode
19.80 + ///\endcode
19.81 ///
19.82 /// After the copy the \c nr map will contain the mapping from the
19.83 /// source graph's nodes to the target graph's nodes and the \c ecr will
20.1 --- a/lemon/graph_writer.h Thu Feb 02 17:09:09 2006 +0000
20.2 +++ b/lemon/graph_writer.h Thu Feb 02 17:43:24 2006 +0000
20.3 @@ -47,9 +47,9 @@
20.4 /// write commands as \c NodeMap or \c EdgeMap writing and labeled Node and
20.5 /// Edge writing.
20.6 ///
20.7 - /// \code
20.8 + ///\code
20.9 /// GraphWriter<ListGraph> writer(std::cout, graph);
20.10 - /// \endcode
20.11 + ///\endcode
20.12 ///
20.13 /// The \c writeNodeMap() function declares a \c NodeMap writing
20.14 /// command in the \c GraphWriter. You should give as parameter
20.15 @@ -57,43 +57,43 @@
20.16 /// command with name "label" should write a unique map because it
20.17 /// is regarded as label map (such a map is essential if the graph has edges).
20.18 ///
20.19 - /// \code
20.20 + ///\code
20.21 /// IdMap<ListGraph, Node> nodeLabelMap;
20.22 /// writer.writeNodeMap("label", nodeLabelMap);
20.23 ///
20.24 /// writer.writeNodeMap("coords", coords);
20.25 /// writer.writeNodeMap("color", colorMap);
20.26 - /// \endcode
20.27 + ///\endcode
20.28 ///
20.29 /// With the \c writeEdgeMap() member function you can give an edge map
20.30 /// writing command similar to the NodeMaps.
20.31 ///
20.32 - /// \code
20.33 + ///\code
20.34 /// DescriptorMap<ListGraph, Edge, ListGraph::EdgeMap<int> >
20.35 /// edgeDescMap(graph);
20.36 /// writer.writeEdgeMap("descriptor", edgeDescMap);
20.37 ///
20.38 /// writer.writeEdgeMap("weight", weightMap);
20.39 /// writer.writeEdgeMap("label", labelMap);
20.40 - /// \endcode
20.41 + ///\endcode
20.42 ///
20.43 /// With \c writeNode() and \c writeEdge() functions you can
20.44 /// point out Nodes and Edges in the graph. For example, you can
20.45 /// write out the source and target of a maximum flow instance.
20.46 ///
20.47 - /// \code
20.48 + ///\code
20.49 /// writer.writeNode("source", sourceNode);
20.50 /// writer.writeNode("target", targetNode);
20.51 ///
20.52 /// writer.writeEdge("observed", edge);
20.53 - /// \endcode
20.54 + ///\endcode
20.55 ///
20.56 /// After you give all write commands you must call the \c run() member
20.57 /// function, which executes all the writing commands.
20.58 ///
20.59 - /// \code
20.60 + ///\code
20.61 /// writer.run();
20.62 - /// \endcode
20.63 + ///\endcode
20.64 ///
20.65 /// \see DefaultWriterTraits
20.66 /// \see QuotedStringWriter
20.67 @@ -320,9 +320,9 @@
20.68 /// declare write command as \c NodeMap, \c EdgeMap or \c UEdgeMap
20.69 /// writing and labeled Node, Edge or UEdge writing.
20.70 ///
20.71 - /// \code
20.72 + ///\code
20.73 /// UGraphWriter<ListUGraph> writer(std::cout, graph);
20.74 - /// \endcode
20.75 + ///\endcode
20.76 ///
20.77 /// The \c writeNodeMap() function declares a \c NodeMap writing
20.78 /// command in the \c UGraphWriter. You should give as parameter
20.79 @@ -330,51 +330,51 @@
20.80 /// command with name "label" should write a unique map because it
20.81 /// is regarded as label map.
20.82 ///
20.83 - /// \code
20.84 + ///\code
20.85 /// IdMap<ListUGraph, Node> nodeLabelMap;
20.86 /// writer.writeNodeMap("label", nodeLabelMap);
20.87 ///
20.88 /// writer.writeNodeMap("coords", coords);
20.89 /// writer.writeNodeMap("color", colorMap);
20.90 - /// \endcode
20.91 + ///\endcode
20.92 ///
20.93 /// With the \c writeUEdgeMap() member function you can give an
20.94 /// undirected edge map writing command similar to the NodeMaps.
20.95 ///
20.96 - /// \code
20.97 + ///\code
20.98 /// DescriptorMap<ListGraph, Edge, ListGraph::EdgeMap<int> >
20.99 /// edgeDescMap(graph);
20.100 /// writer.writeUEdgeMap("descriptor", edgeDescMap);
20.101 ///
20.102 /// writer.writeUEdgeMap("weight", weightMap);
20.103 /// writer.writeUEdgeMap("label", labelMap);
20.104 - /// \endcode
20.105 + ///\endcode
20.106 ///
20.107 /// The EdgeMap handling is just a syntactical sugar. It writes
20.108 /// two undirected edge map with '+' and '-' prefix in the name.
20.109 ///
20.110 - /// \code
20.111 + ///\code
20.112 /// writer.writeEdgeMap("capacity", capacityMap);
20.113 - /// \endcode
20.114 + ///\endcode
20.115 ///
20.116 ///
20.117 /// With \c writeNode() and \c writeUEdge() functions you can
20.118 /// designate nodes and undirected edges in the graph. For example, you can
20.119 /// write out the source and target of the graph.
20.120 ///
20.121 - /// \code
20.122 + ///\code
20.123 /// writer.writeNode("source", sourceNode);
20.124 /// writer.writeNode("target", targetNode);
20.125 ///
20.126 /// writer.writeUEdge("observed", uEdge);
20.127 - /// \endcode
20.128 + ///\endcode
20.129 ///
20.130 /// After you give all write commands you must call the \c run() member
20.131 /// function, which executes all the writing commands.
20.132 ///
20.133 - /// \code
20.134 + ///\code
20.135 /// writer.run();
20.136 - /// \endcode
20.137 + ///\endcode
20.138 ///
20.139 /// \see DefaultWriterTraits
20.140 /// \see QuotedStringWriter
21.1 --- a/lemon/grid_graph.h Thu Feb 02 17:09:09 2006 +0000
21.2 +++ b/lemon/grid_graph.h Thu Feb 02 17:43:24 2006 +0000
21.3 @@ -354,7 +354,7 @@
21.4 /// on one position and only one is the difference.
21.5 ///
21.6 /// The graph can be indiced in the following way:
21.7 - /// \code
21.8 + ///\code
21.9 /// GridGraph graph(w, h);
21.10 /// GridGraph::NodeMap<int> val(graph);
21.11 /// for (int i = 0; i < graph.width(); ++i) {
21.12 @@ -362,7 +362,7 @@
21.13 /// val[graph(i, j)] = i + j;
21.14 /// }
21.15 /// }
21.16 - /// \endcode
21.17 + ///\endcode
21.18 ///
21.19 /// The graph type is fully conform to the \ref concept::UGraph
21.20 /// "Undirected Graph" concept.
22.1 --- a/lemon/hypercube_graph.h Thu Feb 02 17:09:09 2006 +0000
22.2 +++ b/lemon/hypercube_graph.h Thu Feb 02 17:43:24 2006 +0000
22.3 @@ -276,7 +276,7 @@
22.4 /// given by the \c begin and \c end iterators and this range's length
22.5 /// should be the dimension number of the graph.
22.6 ///
22.7 - /// \code
22.8 + ///\code
22.9 /// const int DIM = 3;
22.10 /// HyperCubeGraph graph(DIM);
22.11 /// xy<double> base[DIM];
22.12 @@ -286,7 +286,7 @@
22.13 /// }
22.14 /// HyperCubeGraph::HyperMap<xy<double> >
22.15 /// pos(graph, base, base + DIM, xy<double>(0.0, 0.0));
22.16 - /// \endcode
22.17 + ///\endcode
22.18 ///
22.19 /// \see HyperCubeGraph
22.20 template <typename T, typename BF = std::plus<T> >
23.1 --- a/lemon/johnson.h Thu Feb 02 17:09:09 2006 +0000
23.2 +++ b/lemon/johnson.h Thu Feb 02 17:43:24 2006 +0000
23.3 @@ -608,10 +608,10 @@
23.4 /// - The distance between each node pairs.
23.5 ///
23.6 /// \note d.run(s) is just a shortcut of the following code.
23.7 - /// \code
23.8 + ///\code
23.9 /// d.init();
23.10 /// d.start();
23.11 - /// \endcode
23.12 + ///\endcode
23.13 void run() {
23.14 init();
23.15 start();
24.1 --- a/lemon/kruskal.h Thu Feb 02 17:09:09 2006 +0000
24.2 +++ b/lemon/kruskal.h Thu Feb 02 17:43:24 2006 +0000
24.3 @@ -77,15 +77,15 @@
24.4 /// For example, if we know that the spanning tree of the graph \c g has
24.5 /// say 53 edges, then
24.6 /// we can put its edges into a STL vector \c tree with a code like this.
24.7 - /// \code
24.8 + ///\code
24.9 /// std::vector<Edge> tree(53);
24.10 /// kruskal(g,cost,tree.begin());
24.11 - /// \endcode
24.12 + ///\endcode
24.13 /// Or if we don't know in advance the size of the tree, we can write this.
24.14 - /// \code
24.15 + ///\code
24.16 /// std::vector<Edge> tree;
24.17 /// kruskal(g,cost,std::back_inserter(tree));
24.18 - /// \endcode
24.19 + ///\endcode
24.20 ///
24.21 /// \return The cost of the found tree.
24.22 ///
24.23 @@ -300,10 +300,10 @@
24.24 /// is added to sequence pointed by the iterator.
24.25 ///
24.26 /// A typical usage:
24.27 - /// \code
24.28 + ///\code
24.29 /// std::vector<Graph::Edge> v;
24.30 /// kruskal(g, input, makeKruskalSequenceOutput(back_inserter(v)));
24.31 - /// \endcode
24.32 + ///\endcode
24.33 ///
24.34 /// For the most common case, when the input is given by a simple edge
24.35 /// map and the output is a sequence of the tree edges, a special
24.36 @@ -396,15 +396,15 @@
24.37 // For example, if we know that the spanning tree of the graph \c g has
24.38 // say 53 edges, then
24.39 // we can put its edges into a STL vector \c tree with a code like this.
24.40 -// \code
24.41 +//\code
24.42 // std::vector<Edge> tree(53);
24.43 // kruskal(g,cost,tree.begin());
24.44 -// \endcode
24.45 +//\endcode
24.46 // Or if we don't know in advance the size of the tree, we can write this.
24.47 -// \code
24.48 +//\code
24.49 // std::vector<Edge> tree;
24.50 // kruskal(g,cost,std::back_inserter(tree));
24.51 -// \endcode
24.52 +//\endcode
24.53 //
24.54 // \return The cost of the found tree.
24.55 //
25.1 --- a/lemon/lemon_reader.h Thu Feb 02 17:09:09 2006 +0000
25.2 +++ b/lemon/lemon_reader.h Thu Feb 02 17:43:24 2006 +0000
25.3 @@ -1962,11 +1962,11 @@
25.4 /// SectionReader for retrieve what is in the file. If you want
25.5 /// to know which sections, maps and items are in the file
25.6 /// use the next code:
25.7 - /// \code
25.8 + ///\code
25.9 /// LemonReader reader("input.lgf");
25.10 /// ContentReader content(reader);
25.11 /// reader.run();
25.12 - /// \endcode
25.13 + ///\endcode
25.14 class ContentReader : public LemonReader::SectionReader {
25.15 typedef LemonReader::SectionReader Parent;
25.16 public: