# HG changeset patch # User alpar # Date 1138902204 0 # Node ID 17eb3eaad9f87903f3d661b363e3cca9c1126501 # Parent e5c0c5cc477fc44c0d6765e388e16162396bc6a1 - workaround for a Doxygen 1.4.6 bug - other doc fixes diff -r e5c0c5cc477f -r 17eb3eaad9f8 lemon/bellman_ford.h --- a/lemon/bellman_ford.h Thu Feb 02 17:09:09 2006 +0000 +++ b/lemon/bellman_ford.h Thu Feb 02 17:43:24 2006 +0000 @@ -544,11 +544,11 @@ /// - The distance of each node from the root. /// /// \note d.run(s) is just a shortcut of the following code. - /// \code + ///\code /// d.init(); /// d.addSource(s); /// d.start(); - /// \endcode + ///\endcode void run(Node s) { init(); addSource(s); @@ -565,11 +565,11 @@ /// - The distance of each node from the root. /// /// \note d.run(s, len) is just a shortcut of the following code. - /// \code + ///\code /// d.init(); /// d.addSource(s); /// d.limitedStart(len); - /// \endcode + ///\endcode void run(Node s, int len) { init(); addSource(s); @@ -928,9 +928,9 @@ /// \ref BellmanFordWizard. /// The following /// example shows how to use these parameters. - /// \code + ///\code /// bellmanford(g,length,source).predMap(preds).run(); - /// \endcode + ///\endcode /// \warning Don't forget to put the \ref BellmanFordWizard::run() "run()" /// to the end of the parameter list. /// \sa BellmanFordWizard diff -r e5c0c5cc477f -r 17eb3eaad9f8 lemon/bits/alteration_notifier.h --- a/lemon/bits/alteration_notifier.h Thu Feb 02 17:09:09 2006 +0000 +++ b/lemon/bits/alteration_notifier.h Thu Feb 02 17:43:24 2006 +0000 @@ -20,7 +20,7 @@ #include #include -///\ingroin graphmapfactory +///\ingroup graphmapfactory ///\file ///\brief Observer registry for graph alteration observers. diff -r e5c0c5cc477f -r 17eb3eaad9f8 lemon/bits/array_map.h --- a/lemon/bits/array_map.h Thu Feb 02 17:09:09 2006 +0000 +++ b/lemon/bits/array_map.h Thu Feb 02 17:43:24 2006 +0000 @@ -23,14 +23,14 @@ #include #include -/// \ingroin graphmapfactory +/// \ingroup graphmapfactory /// \file /// \brief Graph maps that construct and destruct /// their elements dynamically. namespace lemon { - /// \ingroin graphmapfactory + /// \ingroup graphmapfactory /// /// \brief Graph map based on the array storage. /// diff -r e5c0c5cc477f -r 17eb3eaad9f8 lemon/bits/default_map.h --- a/lemon/bits/default_map.h Thu Feb 02 17:09:09 2006 +0000 +++ b/lemon/bits/default_map.h Thu Feb 02 17:43:24 2006 +0000 @@ -21,7 +21,7 @@ #include #include -///\ingroin graphmapfactory +///\ingroup graphmapfactory ///\file ///\brief Graph maps that construct and destruct ///their elements dynamically. diff -r e5c0c5cc477f -r 17eb3eaad9f8 lemon/bits/item_reader.h --- a/lemon/bits/item_reader.h Thu Feb 02 17:09:09 2006 +0000 +++ b/lemon/bits/item_reader.h Thu Feb 02 17:43:24 2006 +0000 @@ -15,14 +15,14 @@ */ /// @defgroin item_io Item Readers and Writers -/// @ingroin io_groin +/// @ingroup io_groin /// \brief Item Readers and Writers /// /// The Input-Output classes can handle more data type by example /// as map or attribute value. Each of these should be written and /// read some way. The module make possible to do this. -/// \ingroin item_io +/// \ingroup item_io /// \file /// \brief Item reader bits for lemon input. @@ -42,7 +42,7 @@ template class DefaultReader; - /// \ingroin item_io + /// \ingroup item_io /// /// \brief Reader class for quoted strings. /// @@ -157,7 +157,7 @@ bool escaped; }; - /// \ingroin item_io + /// \ingroup item_io /// \brief Reader for standard containers. /// /// Reader for back insertable standard containers. The representation @@ -204,7 +204,7 @@ }; - /// \ingroin item_io + /// \ingroup item_io /// /// \brief Reader for standard containers. /// @@ -252,7 +252,7 @@ }; - /// \ingroin item_io + /// \ingroup item_io /// \brief Reader for parsed string. /// /// Reader for parsed strings. You can define the open and close @@ -300,7 +300,7 @@ }; - /// \ingroin item_io + /// \ingroup item_io /// \brief Reader for read the whole line. /// /// Reader for read the whole line. @@ -330,7 +330,7 @@ bool skipSpaces; }; - /// \ingroin item_io + /// \ingroup item_io /// \brief Reader for std::pair. /// /// Reader for std::pair. @@ -384,7 +384,7 @@ } }; - /// \ingroin item_io + /// \ingroup item_io /// /// \brief The default item reader template class. /// @@ -471,7 +471,7 @@ class DefaultReader > : public PairReader > {}; - /// \ingroin item_io + /// \ingroup item_io /// /// \brief The default item reader for skipping a value in the stream. /// @@ -480,7 +480,7 @@ /// \author Balazs Dezso class DefaultSkipper : public DefaultReader {}; - /// \ingroin item_io + /// \ingroup item_io /// \brief Standard ReaderTraits for the GraphReader class. /// /// Standard ReaderTraits for the GraphReader class. diff -r e5c0c5cc477f -r 17eb3eaad9f8 lemon/bits/item_writer.h --- a/lemon/bits/item_writer.h Thu Feb 02 17:09:09 2006 +0000 +++ b/lemon/bits/item_writer.h Thu Feb 02 17:43:24 2006 +0000 @@ -14,7 +14,7 @@ * */ -/// \ingroin item_io +/// \ingroup item_io /// \file /// \brief Item writer bits for lemon output. @@ -34,7 +34,7 @@ template class DefaultWriter; - /// \ingroin item_io + /// \ingroup item_io /// \brief Writer class for quoted strings. /// /// Writer class for quoted strings. It can process the escape @@ -117,7 +117,7 @@ bool escaped; }; - /// \ingroin item_io + /// \ingroup item_io /// \brief Writer class for quoted char array. /// /// Writer class for quoted char array. It can process the escape @@ -145,7 +145,7 @@ }; - /// \ingroin item_io + /// \ingroup item_io /// /// \brief Writer for standard containers. /// @@ -187,12 +187,12 @@ }; - /// \ingroin item_io + /// \ingroup item_io /// /// \brief Writer for standard pairs. /// /// Writer for standard pairs. The representation of a pair is - /// \code ( first_value => second_value ) \endcode. + ///\code ( first_value => second_value ) \endcode. /// \author Balazs Dezso template > : public PairWriter > {}; - /// \ingroin item_io + /// \ingroup item_io /// \brief Standard WriterTraits for the section writers. /// /// Standard WriterTraits for the section writers. diff -r e5c0c5cc477f -r 17eb3eaad9f8 lemon/bits/static_map.h --- a/lemon/bits/static_map.h Thu Feb 02 17:09:09 2006 +0000 +++ b/lemon/bits/static_map.h Thu Feb 02 17:43:24 2006 +0000 @@ -27,14 +27,14 @@ #include #include -/// \ingroin graphmaps +/// \ingroup graphmaps /// ///\file ///\brief Static sized graph maps. namespace lemon { - /// \ingroin graphmaps + /// \ingroup graphmaps /// /// \brief Graph map with static sized storage. /// diff -r e5c0c5cc477f -r 17eb3eaad9f8 lemon/bits/vector_map.h --- a/lemon/bits/vector_map.h Thu Feb 02 17:09:09 2006 +0000 +++ b/lemon/bits/vector_map.h Thu Feb 02 17:43:24 2006 +0000 @@ -26,14 +26,14 @@ #include #include -/// \ingroin graphmapfactory +/// \ingroup graphmapfactory /// ///\file ///\brief Vector based graph maps. namespace lemon { - /// \ingroin graphmapfactory + /// \ingroup graphmapfactory /// /// \brief Graph map based on the std::vector storage. /// diff -r e5c0c5cc477f -r 17eb3eaad9f8 lemon/concept/bpugraph.h --- a/lemon/concept/bpugraph.h Thu Feb 02 17:09:09 2006 +0000 +++ b/lemon/concept/bpugraph.h Thu Feb 02 17:43:24 2006 +0000 @@ -244,10 +244,10 @@ /// This iterator goes through each node. /// Its usage is quite simple, for example you can count the number /// of nodes in graph \c g of type \c Graph like this: - /// \code + ///\code /// int count=0; /// for (Graph::NodeIt n(g); n!=INVALID; ++n) ++count; - /// \endcode + ///\endcode class NodeIt : public Node { public: /// Default constructor @@ -289,10 +289,10 @@ /// This iterator goes through each ANode. /// Its usage is quite simple, for example you can count the number /// of nodes in graph \c g of type \c Graph like this: - /// \code + ///\code /// int count=0; /// for (Graph::ANodeIt n(g); n!=INVALID; ++n) ++count; - /// \endcode + ///\endcode class ANodeIt : public ANode { public: /// Default constructor @@ -334,10 +334,10 @@ /// This iterator goes through each BNode. /// Its usage is quite simple, for example you can count the number /// of nodes in graph \c g of type \c Graph like this: - /// \code + ///\code /// int count=0; /// for (Graph::BNodeIt n(g); n!=INVALID; ++n) ++count; - /// \endcode + ///\endcode class BNodeIt : public BNode { public: /// Default constructor @@ -425,10 +425,10 @@ /// This iterator goes through each undirected edge of a graph. /// Its usage is quite simple, for example you can count the number /// of undirected edges in a graph \c g of type \c Graph as follows: - /// \code + ///\code /// int count=0; /// for(Graph::UEdgeIt e(g); e!=INVALID; ++e) ++count; - /// \endcode + ///\endcode class UEdgeIt : public UEdge { public: /// Default constructor @@ -473,10 +473,10 @@ /// degree (i.e. count the number /// of incident edges of a node \c n /// in graph \c g of type \c Graph as follows. - /// \code + ///\code /// int count=0; /// for(Graph::IncEdgeIt e(g, n); e!=INVALID; ++e) ++count; - /// \endcode + ///\endcode class IncEdgeIt : public UEdge { public: /// Default constructor @@ -562,10 +562,10 @@ /// This iterator goes through each edge of a graph. /// Its usage is quite simple, for example you can count the number /// of edges in a graph \c g of type \c Graph as follows: - /// \code + ///\code /// int count=0; /// for(Graph::EdgeIt e(g); e!=INVALID; ++e) ++count; - /// \endcode + ///\endcode class EdgeIt : public Edge { public: /// Default constructor @@ -607,10 +607,10 @@ /// Its usage is quite simple, for example you can count the number /// of outgoing edges of a node \c n /// in graph \c g of type \c Graph as follows. - /// \code + ///\code /// int count=0; /// for (Graph::OutEdgeIt e(g, n); e!=INVALID; ++e) ++count; - /// \endcode + ///\endcode class OutEdgeIt : public Edge { public: @@ -659,10 +659,10 @@ /// Its usage is quite simple, for example you can count the number /// of outgoing edges of a node \c n /// in graph \c g of type \c Graph as follows. - /// \code + ///\code /// int count=0; /// for(Graph::InEdgeIt e(g, n); e!=INVALID; ++e) ++count; - /// \endcode + ///\endcode class InEdgeIt : public Edge { public: diff -r e5c0c5cc477f -r 17eb3eaad9f8 lemon/concept/graph.h --- a/lemon/concept/graph.h Thu Feb 02 17:09:09 2006 +0000 +++ b/lemon/concept/graph.h Thu Feb 02 17:43:24 2006 +0000 @@ -192,10 +192,10 @@ /// This iterator goes through each node. /// Its usage is quite simple, for example you can count the number /// of nodes in graph \c g of type \c Graph like this: - /// \code + ///\code /// int count=0; /// for (Graph::NodeIt n(g); n!=INVALID; ++n) ++count; - /// \endcode + ///\endcode class NodeIt : public Node { public: /// Default constructor @@ -285,10 +285,10 @@ /// Its usage is quite simple, for example you can count the number /// of outgoing edges of a node \c n /// in graph \c g of type \c Graph as follows. - /// \code + ///\code /// int count=0; /// for (Graph::OutEdgeIt e(g, n); e!=INVALID; ++e) ++count; - /// \endcode + ///\endcode class OutEdgeIt : public Edge { public: @@ -332,10 +332,10 @@ /// Its usage is quite simple, for example you can count the number /// of outgoing edges of a node \c n /// in graph \c g of type \c Graph as follows. - /// \code + ///\code /// int count=0; /// for(Graph::InEdgeIt e(g, n); e!=INVALID; ++e) ++count; - /// \endcode + ///\endcode class InEdgeIt : public Edge { public: @@ -376,10 +376,10 @@ /// This iterator goes through each edge of a graph. /// Its usage is quite simple, for example you can count the number /// of edges in a graph \c g of type \c Graph as follows: - /// \code + ///\code /// int count=0; /// for(Graph::EdgeIt e(g); e!=INVALID; ++e) ++count; - /// \endcode + ///\endcode class EdgeIt : public Edge { public: /// Default constructor diff -r e5c0c5cc477f -r 17eb3eaad9f8 lemon/concept/ugraph.h --- a/lemon/concept/ugraph.h Thu Feb 02 17:09:09 2006 +0000 +++ b/lemon/concept/ugraph.h Thu Feb 02 17:43:24 2006 +0000 @@ -304,10 +304,10 @@ /// This iterator goes through each node. /// Its usage is quite simple, for example you can count the number /// of nodes in graph \c g of type \c Graph like this: - /// \code + ///\code /// int count=0; /// for (Graph::NodeIt n(g); n!=INVALID; ++n) ++count; - /// \endcode + ///\endcode class NodeIt : public Node { public: /// Default constructor @@ -395,10 +395,10 @@ /// This iterator goes through each undirected edge of a graph. /// Its usage is quite simple, for example you can count the number /// of undirected edges in a graph \c g of type \c Graph as follows: - /// \code + ///\code /// int count=0; /// for(Graph::UEdgeIt e(g); e!=INVALID; ++e) ++count; - /// \endcode + ///\endcode class UEdgeIt : public UEdge { public: /// Default constructor @@ -443,10 +443,10 @@ /// degree (i.e. count the number /// of incident edges of a node \c n /// in graph \c g of type \c Graph as follows. - /// \code + ///\code /// int count=0; /// for(Graph::IncEdgeIt e(g, n); e!=INVALID; ++e) ++count; - /// \endcode + ///\endcode class IncEdgeIt : public UEdge { public: /// Default constructor @@ -532,10 +532,10 @@ /// This iterator goes through each edge of a graph. /// Its usage is quite simple, for example you can count the number /// of edges in a graph \c g of type \c Graph as follows: - /// \code + ///\code /// int count=0; /// for(Graph::EdgeIt e(g); e!=INVALID; ++e) ++count; - /// \endcode + ///\endcode class EdgeIt : public Edge { public: /// Default constructor @@ -577,10 +577,10 @@ /// Its usage is quite simple, for example you can count the number /// of outgoing edges of a node \c n /// in graph \c g of type \c Graph as follows. - /// \code + ///\code /// int count=0; /// for (Graph::OutEdgeIt e(g, n); e!=INVALID; ++e) ++count; - /// \endcode + ///\endcode class OutEdgeIt : public Edge { public: @@ -629,10 +629,10 @@ /// Its usage is quite simple, for example you can count the number /// of outgoing edges of a node \c n /// in graph \c g of type \c Graph as follows. - /// \code + ///\code /// int count=0; /// for(Graph::InEdgeIt e(g, n); e!=INVALID; ++e) ++count; - /// \endcode + ///\endcode class InEdgeIt : public Edge { public: diff -r e5c0c5cc477f -r 17eb3eaad9f8 lemon/dag_shortest_path.h --- a/lemon/dag_shortest_path.h Thu Feb 02 17:09:09 2006 +0000 +++ b/lemon/dag_shortest_path.h Thu Feb 02 17:43:24 2006 +0000 @@ -116,7 +116,8 @@ /// \brief Instantiates a PredMap. /// /// This function instantiates a \ref PredMap. - /// \param G is the graph, to which we would like to define the PredMap. + /// \param graph is the graph, to which we would + /// like to define the PredMap. /// \todo The graph alone may be insufficient for the initialization static PredMap *createPredMap(const _Graph& graph) { return new PredMap(graph); @@ -133,7 +134,7 @@ /// \brief Instantiates a DistMap. /// /// This function instantiates a \ref DistMap. - /// \param G is the graph, to which we would like to define the + /// \param graph is the graph, to which we would like to define the /// \ref DistMap static DistMap *createDistMap(const _Graph& graph) { return new DistMap(graph); @@ -227,7 +228,8 @@ /// \brief Instantiates a PredMap. /// /// This function instantiates a \ref PredMap. - /// \param G is the graph, to which we would like to define the PredMap. + /// \param graph is the graph, + /// to which we would like to define the PredMap. /// \todo The graph alone may be insufficient for the initialization static PredMap *createPredMap(const _Graph& graph) { return new PredMap(graph); @@ -244,7 +246,7 @@ /// \brief Instantiates a DistMap. /// /// This function instantiates a \ref DistMap. - /// \param G is the graph, to which we would like to define the + /// \param graph is the graph, to which we would like to define the /// \ref DistMap static DistMap *createDistMap(const _Graph& graph) { return new DistMap(graph); @@ -681,11 +683,11 @@ /// - The distance of each node from the root. /// /// \note d.run(s) is just a shortcut of the following code. - /// \code + ///\code /// d.init(); /// d.addSource(s); /// d.start(); - /// \endcode + ///\endcode void run(Node s) { init(); addSource(s); @@ -977,7 +979,7 @@ /// \brief Runs DagShortestPath algorithm from the given node. /// /// Runs DagShortestPath algorithm from the given node. - /// \param s is the given source. + /// \param source is the given source. void run(Node source) { Base::_source = source; run(); @@ -1042,7 +1044,7 @@ /// \brief Sets the source node, from which the DagShortestPath algorithm runs. /// /// Sets the source node, from which the DagShortestPath algorithm runs. - /// \param s is the source node. + /// \param source is the source node. DagShortestPathWizard<_Traits>& source(Node source) { Base::_source = source; return *this; @@ -1060,9 +1062,9 @@ /// \ref DagShortestPathWizard. /// The following /// example shows how to use these parameters. - /// \code + ///\code /// dagShortestPath(g,length,source).predMap(preds).run(); - /// \endcode + ///\endcode /// \warning Don't forget to put the \ref DagShortestPathWizard::run() "run()" /// to the end of the parameter list. /// \sa DagShortestPathWizard diff -r e5c0c5cc477f -r 17eb3eaad9f8 lemon/dfs.h --- a/lemon/dfs.h Thu Feb 02 17:09:09 2006 +0000 +++ b/lemon/dfs.h Thu Feb 02 17:43:24 2006 +0000 @@ -1442,11 +1442,11 @@ /// /// This method runs the %DFS algorithm from a root node \c s. /// \note d.run(s) is just a shortcut of the following code. - /// \code + ///\code /// d.init(); /// d.addSource(s); /// d.start(); - /// \endcode + ///\endcode void run(Node s) { init(); addSource(s); diff -r e5c0c5cc477f -r 17eb3eaad9f8 lemon/dimacs.h --- a/lemon/dimacs.h Thu Feb 02 17:09:09 2006 +0000 +++ b/lemon/dimacs.h Thu Feb 02 17:43:24 2006 +0000 @@ -44,9 +44,9 @@ /// This function reads a min cost flow instance from dimacs format, /// i.e. from dimacs files having a line starting with - /// \code + ///\code /// p "min" - /// \endcode + ///\endcode /// At the beginning \c g is cleared by \c g.clear(). The edge /// capacities are written to \c capacity, \c s and \c t are set to /// the source and the target nodes resp. and the cost of the edges @@ -124,9 +124,9 @@ /// This function reads a max flow instance from dimacs format, /// i.e. from dimacs files having a line starting with - /// \code + ///\code /// p "max" - /// \endcode + ///\endcode ///At the beginning \c g is cleared by \c g.clear(). The /// edge capacities are written to \c capacity and \c s and \c t are /// set to the source and the target nodes. @@ -144,9 +144,9 @@ /// This function reads a shortest path instance from dimacs format, /// i.e. from dimacs files having a line starting with - /// \code + ///\code /// p "sp" - /// \endcode + ///\endcode /// At the beginning \c g is cleared by \c g.clear(). The edge /// capacities are written to \c capacity and \c s is set to the /// source node. @@ -180,9 +180,9 @@ /// This function reads a graph without any designated nodes and /// maps from dimacs format, i.e. from dimacs files having a line /// starting with - /// \code + ///\code /// p "mat" - /// \endcode + ///\endcode /// At the beginning \c g is cleared /// by \c g.clear(). /// diff -r e5c0c5cc477f -r 17eb3eaad9f8 lemon/floyd_warshall.h --- a/lemon/floyd_warshall.h Thu Feb 02 17:09:09 2006 +0000 +++ b/lemon/floyd_warshall.h Thu Feb 02 17:43:24 2006 +0000 @@ -117,7 +117,8 @@ /// \brief Instantiates a PredMap. /// /// This function instantiates a \ref PredMap. - /// \param G is the graph, to which we would like to define the PredMap. + /// \param graph is the graph, + /// to which we would like to define the PredMap. /// \todo The graph alone may be insufficient for the initialization static PredMap *createPredMap(const _Graph& graph) { return new PredMap(graph); @@ -133,7 +134,7 @@ /// \brief Instantiates a DistMap. /// /// This function instantiates a \ref DistMap. - /// \param G is the graph, to which we would like to define the + /// \param graph is the graph, to which we would like to define the /// \ref DistMap static DistMap *createDistMap(const _Graph& graph) { return new DistMap(graph); @@ -454,10 +455,10 @@ /// - The distance between each node pairs. /// /// \note d.run(s) is just a shortcut of the following code. - /// \code + ///\code /// d.init(); /// d.start(); - /// \endcode + ///\endcode void run() { init(); start(); diff -r e5c0c5cc477f -r 17eb3eaad9f8 lemon/fredman_tarjan.h --- a/lemon/fredman_tarjan.h Thu Feb 02 17:09:09 2006 +0000 +++ b/lemon/fredman_tarjan.h Thu Feb 02 17:43:24 2006 +0000 @@ -65,7 +65,7 @@ ///Instantiates a TreeMap. ///This function instantiates a \ref TreeMap. - ///\param g is the graph, to which + ///\param _graph is the graph, to which ///we would like to define the \ref TreeMap static TreeMap *createTreeMap(const GR &_graph){ return new TreeMap(_graph); diff -r e5c0c5cc477f -r 17eb3eaad9f8 lemon/graph_adaptor.h --- a/lemon/graph_adaptor.h Thu Feb 02 17:09:09 2006 +0000 +++ b/lemon/graph_adaptor.h Thu Feb 02 17:43:24 2006 +0000 @@ -188,9 +188,9 @@ /// Let \f$G=(V, A)\f$ be a directed graph and /// suppose that a graph instange \c g of type /// \c ListGraph implements \f$G\f$. - /// \code + ///\code /// ListGraph g; - /// \endcode + ///\endcode /// For each directed edge /// \f$e\in A\f$, let \f$\bar e\f$ denote the edge obtained by /// reversing its orientation. @@ -199,10 +199,11 @@ /// \f$\{\bar e : e\in A \}\f$, i.e. the graph obtained from \f$G\f$ be /// reversing the orientation of its edges. The following code shows how /// such an instance can be constructed. - /// \code + ///\code /// RevGraphAdaptor gw(g); - /// \endcode + ///\endcode ///\author Marton Makai + template class RevGraphAdaptor : public IterableGraphExtender > { @@ -1278,18 +1279,18 @@ /// For blocking flows. - ///\warning Graph adaptors are in even more experimental state than the other + ///\warning Graph adaptors are in even more + ///experimental state than the other ///parts of the lib. Use them at you own risk. /// - /// This graph adaptor is used for on-the-fly - /// Dinits blocking flow computations. - /// For each node, an out-edge is stored which is used when the - /// \code - /// OutEdgeIt& first(OutEdgeIt&, const Node&) - /// \endcode - /// is called. + ///This graph adaptor is used for on-the-fly + ///Dinits blocking flow computations. + ///For each node, an out-edge is stored which is used when the + ///\code OutEdgeIt& first(OutEdgeIt&, const Node&)\endcode + ///is called. /// - /// \author Marton Makai + ///\author Marton Makai + /// template class ErasingFirstGraphAdaptor : public IterableGraphExtender< diff -r e5c0c5cc477f -r 17eb3eaad9f8 lemon/graph_reader.h --- a/lemon/graph_reader.h Thu Feb 02 17:09:09 2006 +0000 +++ b/lemon/graph_reader.h Thu Feb 02 17:43:24 2006 +0000 @@ -54,9 +54,9 @@ /// whitespaces, therefore it has some extra possibilities to control how /// it should skip the values when the string representation contains spaces. /// - /// \code + ///\code /// GraphReader reader(std::cin, graph); - /// \endcode + ///\endcode /// /// The \c readNodeMap() function reads a map from the \c \@nodeset section. /// If there is a map that you do not want to read from the file and there is @@ -64,31 +64,31 @@ /// call the \c skipNodeMap() template member function with proper /// parameters. /// - /// \code + ///\code /// reader.readNodeMap("coords", coords); /// /// reader.skipNodeMap("description", desc); /// /// reader.readNodeMap("color", colorMap); - /// \endcode + ///\endcode /// /// With the \c readEdgeMap() member function you can give an edge map /// reading command similar to the NodeMaps. /// - /// \code + ///\code /// reader.readEdgeMap("weight", weightMap); /// reader.readEdgeMap("label", labelMap); - /// \endcode + ///\endcode /// /// With \c readNode() and \c readEdge() functions you can read /// labeled Nodes and Edges. /// - /// \code + ///\code /// reader.readNode("source", sourceNode); /// reader.readNode("target", targetNode); /// /// reader.readEdge("observed", edge); - /// \endcode + ///\endcode /// /// With the \c readAttribute() functions you can read an attribute /// into a variable. You can specify the reader for the attribute as @@ -97,9 +97,9 @@ /// After you give all read commands you must call the \c run() member /// function, which executes all the commands. /// - /// \code + ///\code /// reader.run(); - /// \endcode + ///\endcode /// /// \see DefaultReaderTraits /// \see QuotedStringReader @@ -398,9 +398,9 @@ /// whitespaces, therefore it has some extra possibilities to control how /// it should skip the values when the string representation contains spaces. /// - /// \code + ///\code /// UGraphReader reader(std::cin, graph); - /// \endcode + ///\endcode /// /// The \c readNodeMap() function reads a map from the \c \@nodeset section. /// If there is a map that you do not want to read from the file and there is @@ -408,39 +408,39 @@ /// call the \c skipNodeMap() template member function with proper /// parameters. /// - /// \code + ///\code /// reader.readNodeMap("coords", coords); /// /// reader.skipNodeMap("description", desc); /// /// reader.readNodeMap("color", colorMap); - /// \endcode + ///\endcode /// /// With the \c readUEdgeMap() member function you can give an /// uedge map reading command similar to the NodeMaps. /// - /// \code + ///\code /// reader.readUEdgeMap("capacity", capacityMap); - /// \endcode + ///\endcode /// /// The reading of the directed edge maps is just a syntactical sugar. /// It reads two undirected edgemaps into a directed edge map. The /// undirected edge maps' name should be start with the \c '+' and the /// \c '-' character and the same. /// - /// \code + ///\code /// reader.readEdgeMap("flow", flowMap); - /// \endcode + ///\endcode /// /// With \c readNode() and \c readUEdge() functions you can read /// labeled Nodes and UEdges. /// - /// \code + ///\code /// reader.readNode("source", sourceNode); /// reader.readNode("target", targetNode); /// /// reader.readUEdge("observed", uEdge); - /// \endcode + ///\endcode /// /// With the \c readAttribute() functions you can read an attribute /// in a variable. You can specify the reader for the attribute as @@ -449,9 +449,9 @@ /// After you give all read commands you must call the \c run() member /// function, which execute all the commands. /// - /// \code + ///\code /// reader.run(); - /// \endcode + ///\endcode /// /// \see GraphReader /// \see DefaultReaderTraits diff -r e5c0c5cc477f -r 17eb3eaad9f8 lemon/graph_utils.h --- a/lemon/graph_utils.h Thu Feb 02 17:09:09 2006 +0000 +++ b/lemon/graph_utils.h Thu Feb 02 17:43:24 2006 +0000 @@ -258,11 +258,11 @@ /// \return The found edge or \ref INVALID if there is no such an edge. /// /// Thus you can iterate through each edge from \c u to \c v as it follows. - /// \code + ///\code /// for(Edge e=findEdge(g,u,v);e!=INVALID;e=findEdge(g,u,v,e)) { /// ... /// } - /// \endcode + ///\endcode // /// \todo We may want to use the "GraphBase" // /// interface here... template @@ -278,11 +278,11 @@ /// Iterator for iterating on edges connected the same nodes. It is /// higher level interface for the findEdge() function. You can /// use it the following way: - /// \code + ///\code /// for (ConEdgeIt it(g, src, trg); it != INVALID; ++it) { /// ... /// } - /// \endcode + ///\endcode /// /// \author Balazs Dezso template @@ -360,12 +360,12 @@ /// \return The found edge or \ref INVALID if there is no such an edge. /// /// Thus you can iterate through each edge from \c u to \c v as it follows. - /// \code + ///\code /// for(UEdge e = findUEdge(g,u,v); e != INVALID; /// e = findUEdge(g,u,v,e)) { /// ... /// } - /// \endcode + ///\endcode // /// \todo We may want to use the "GraphBase" // /// interface here... template @@ -382,11 +382,11 @@ /// Iterator for iterating on uedges connected the same nodes. It is /// higher level interface for the findUEdge() function. You can /// use it the following way: - /// \code + ///\code /// for (ConUEdgeIt it(g, src, trg); it != INVALID; ++it) { /// ... /// } - /// \endcode + ///\endcode /// /// \author Balazs Dezso template @@ -580,9 +580,9 @@ /// Copy a graph to an other graph. /// The usage of the function: /// - /// \code + ///\code /// copyGraph(trg, src).nodeRef(nr).edgeCrossRef(ecr); - /// \endcode + ///\endcode /// /// After the copy the \c nr map will contain the mapping from the /// source graph's nodes to the target graph's nodes and the \c ecr will @@ -792,9 +792,9 @@ /// Copy a graph to an other graph. /// The usage of the function: /// - /// \code + ///\code /// copyGraph(trg, src).nodeRef(nr).edgeCrossRef(ecr); - /// \endcode + ///\endcode /// /// After the copy the \c nr map will contain the mapping from the /// source graph's nodes to the target graph's nodes and the \c ecr will diff -r e5c0c5cc477f -r 17eb3eaad9f8 lemon/graph_writer.h --- a/lemon/graph_writer.h Thu Feb 02 17:09:09 2006 +0000 +++ b/lemon/graph_writer.h Thu Feb 02 17:43:24 2006 +0000 @@ -47,9 +47,9 @@ /// write commands as \c NodeMap or \c EdgeMap writing and labeled Node and /// Edge writing. /// - /// \code + ///\code /// GraphWriter writer(std::cout, graph); - /// \endcode + ///\endcode /// /// The \c writeNodeMap() function declares a \c NodeMap writing /// command in the \c GraphWriter. You should give as parameter @@ -57,43 +57,43 @@ /// command with name "label" should write a unique map because it /// is regarded as label map (such a map is essential if the graph has edges). /// - /// \code + ///\code /// IdMap nodeLabelMap; /// writer.writeNodeMap("label", nodeLabelMap); /// /// writer.writeNodeMap("coords", coords); /// writer.writeNodeMap("color", colorMap); - /// \endcode + ///\endcode /// /// With the \c writeEdgeMap() member function you can give an edge map /// writing command similar to the NodeMaps. /// - /// \code + ///\code /// DescriptorMap > /// edgeDescMap(graph); /// writer.writeEdgeMap("descriptor", edgeDescMap); /// /// writer.writeEdgeMap("weight", weightMap); /// writer.writeEdgeMap("label", labelMap); - /// \endcode + ///\endcode /// /// With \c writeNode() and \c writeEdge() functions you can /// point out Nodes and Edges in the graph. For example, you can /// write out the source and target of a maximum flow instance. /// - /// \code + ///\code /// writer.writeNode("source", sourceNode); /// writer.writeNode("target", targetNode); /// /// writer.writeEdge("observed", edge); - /// \endcode + ///\endcode /// /// After you give all write commands you must call the \c run() member /// function, which executes all the writing commands. /// - /// \code + ///\code /// writer.run(); - /// \endcode + ///\endcode /// /// \see DefaultWriterTraits /// \see QuotedStringWriter @@ -320,9 +320,9 @@ /// declare write command as \c NodeMap, \c EdgeMap or \c UEdgeMap /// writing and labeled Node, Edge or UEdge writing. /// - /// \code + ///\code /// UGraphWriter writer(std::cout, graph); - /// \endcode + ///\endcode /// /// The \c writeNodeMap() function declares a \c NodeMap writing /// command in the \c UGraphWriter. You should give as parameter @@ -330,51 +330,51 @@ /// command with name "label" should write a unique map because it /// is regarded as label map. /// - /// \code + ///\code /// IdMap nodeLabelMap; /// writer.writeNodeMap("label", nodeLabelMap); /// /// writer.writeNodeMap("coords", coords); /// writer.writeNodeMap("color", colorMap); - /// \endcode + ///\endcode /// /// With the \c writeUEdgeMap() member function you can give an /// undirected edge map writing command similar to the NodeMaps. /// - /// \code + ///\code /// DescriptorMap > /// edgeDescMap(graph); /// writer.writeUEdgeMap("descriptor", edgeDescMap); /// /// writer.writeUEdgeMap("weight", weightMap); /// writer.writeUEdgeMap("label", labelMap); - /// \endcode + ///\endcode /// /// The EdgeMap handling is just a syntactical sugar. It writes /// two undirected edge map with '+' and '-' prefix in the name. /// - /// \code + ///\code /// writer.writeEdgeMap("capacity", capacityMap); - /// \endcode + ///\endcode /// /// /// With \c writeNode() and \c writeUEdge() functions you can /// designate nodes and undirected edges in the graph. For example, you can /// write out the source and target of the graph. /// - /// \code + ///\code /// writer.writeNode("source", sourceNode); /// writer.writeNode("target", targetNode); /// /// writer.writeUEdge("observed", uEdge); - /// \endcode + ///\endcode /// /// After you give all write commands you must call the \c run() member /// function, which executes all the writing commands. /// - /// \code + ///\code /// writer.run(); - /// \endcode + ///\endcode /// /// \see DefaultWriterTraits /// \see QuotedStringWriter diff -r e5c0c5cc477f -r 17eb3eaad9f8 lemon/grid_graph.h --- a/lemon/grid_graph.h Thu Feb 02 17:09:09 2006 +0000 +++ b/lemon/grid_graph.h Thu Feb 02 17:43:24 2006 +0000 @@ -354,7 +354,7 @@ /// on one position and only one is the difference. /// /// The graph can be indiced in the following way: - /// \code + ///\code /// GridGraph graph(w, h); /// GridGraph::NodeMap val(graph); /// for (int i = 0; i < graph.width(); ++i) { @@ -362,7 +362,7 @@ /// val[graph(i, j)] = i + j; /// } /// } - /// \endcode + ///\endcode /// /// The graph type is fully conform to the \ref concept::UGraph /// "Undirected Graph" concept. diff -r e5c0c5cc477f -r 17eb3eaad9f8 lemon/hypercube_graph.h --- a/lemon/hypercube_graph.h Thu Feb 02 17:09:09 2006 +0000 +++ b/lemon/hypercube_graph.h Thu Feb 02 17:43:24 2006 +0000 @@ -276,7 +276,7 @@ /// given by the \c begin and \c end iterators and this range's length /// should be the dimension number of the graph. /// - /// \code + ///\code /// const int DIM = 3; /// HyperCubeGraph graph(DIM); /// xy base[DIM]; @@ -286,7 +286,7 @@ /// } /// HyperCubeGraph::HyperMap > /// pos(graph, base, base + DIM, xy(0.0, 0.0)); - /// \endcode + ///\endcode /// /// \see HyperCubeGraph template > diff -r e5c0c5cc477f -r 17eb3eaad9f8 lemon/johnson.h --- a/lemon/johnson.h Thu Feb 02 17:09:09 2006 +0000 +++ b/lemon/johnson.h Thu Feb 02 17:43:24 2006 +0000 @@ -608,10 +608,10 @@ /// - The distance between each node pairs. /// /// \note d.run(s) is just a shortcut of the following code. - /// \code + ///\code /// d.init(); /// d.start(); - /// \endcode + ///\endcode void run() { init(); start(); diff -r e5c0c5cc477f -r 17eb3eaad9f8 lemon/kruskal.h --- a/lemon/kruskal.h Thu Feb 02 17:09:09 2006 +0000 +++ b/lemon/kruskal.h Thu Feb 02 17:43:24 2006 +0000 @@ -77,15 +77,15 @@ /// For example, if we know that the spanning tree of the graph \c g has /// say 53 edges, then /// we can put its edges into a STL vector \c tree with a code like this. - /// \code + ///\code /// std::vector tree(53); /// kruskal(g,cost,tree.begin()); - /// \endcode + ///\endcode /// Or if we don't know in advance the size of the tree, we can write this. - /// \code + ///\code /// std::vector tree; /// kruskal(g,cost,std::back_inserter(tree)); - /// \endcode + ///\endcode /// /// \return The cost of the found tree. /// @@ -300,10 +300,10 @@ /// is added to sequence pointed by the iterator. /// /// A typical usage: - /// \code + ///\code /// std::vector v; /// kruskal(g, input, makeKruskalSequenceOutput(back_inserter(v))); - /// \endcode + ///\endcode /// /// For the most common case, when the input is given by a simple edge /// map and the output is a sequence of the tree edges, a special @@ -396,15 +396,15 @@ // For example, if we know that the spanning tree of the graph \c g has // say 53 edges, then // we can put its edges into a STL vector \c tree with a code like this. -// \code +//\code // std::vector tree(53); // kruskal(g,cost,tree.begin()); -// \endcode +//\endcode // Or if we don't know in advance the size of the tree, we can write this. -// \code +//\code // std::vector tree; // kruskal(g,cost,std::back_inserter(tree)); -// \endcode +//\endcode // // \return The cost of the found tree. // diff -r e5c0c5cc477f -r 17eb3eaad9f8 lemon/lemon_reader.h --- a/lemon/lemon_reader.h Thu Feb 02 17:09:09 2006 +0000 +++ b/lemon/lemon_reader.h Thu Feb 02 17:43:24 2006 +0000 @@ -1962,11 +1962,11 @@ /// SectionReader for retrieve what is in the file. If you want /// to know which sections, maps and items are in the file /// use the next code: - /// \code + ///\code /// LemonReader reader("input.lgf"); /// ContentReader content(reader); /// reader.run(); - /// \endcode + ///\endcode class ContentReader : public LemonReader::SectionReader { typedef LemonReader::SectionReader Parent; public: