[Lemon-commits] [lemon_svn] alpar: r2521 - in hugo/trunk/lemon: . bits concept
Lemon SVN
svn at lemon.cs.elte.hu
Mon Nov 6 20:53:15 CET 2006
Author: alpar
Date: Thu Feb 2 18:43:24 2006
New Revision: 2521
Modified:
hugo/trunk/lemon/bellman_ford.h
hugo/trunk/lemon/bits/alteration_notifier.h
hugo/trunk/lemon/bits/array_map.h
hugo/trunk/lemon/bits/default_map.h
hugo/trunk/lemon/bits/item_reader.h
hugo/trunk/lemon/bits/item_writer.h
hugo/trunk/lemon/bits/static_map.h
hugo/trunk/lemon/bits/vector_map.h
hugo/trunk/lemon/concept/bpugraph.h
hugo/trunk/lemon/concept/graph.h
hugo/trunk/lemon/concept/ugraph.h
hugo/trunk/lemon/dag_shortest_path.h
hugo/trunk/lemon/dfs.h
hugo/trunk/lemon/dimacs.h
hugo/trunk/lemon/floyd_warshall.h
hugo/trunk/lemon/fredman_tarjan.h
hugo/trunk/lemon/graph_adaptor.h
hugo/trunk/lemon/graph_reader.h
hugo/trunk/lemon/graph_utils.h
hugo/trunk/lemon/graph_writer.h
hugo/trunk/lemon/grid_graph.h
hugo/trunk/lemon/hypercube_graph.h
hugo/trunk/lemon/johnson.h
hugo/trunk/lemon/kruskal.h
hugo/trunk/lemon/lemon_reader.h
Log:
- workaround for a Doxygen 1.4.6 bug
- other doc fixes
Modified: hugo/trunk/lemon/bellman_ford.h
==============================================================================
--- hugo/trunk/lemon/bellman_ford.h (original)
+++ hugo/trunk/lemon/bellman_ford.h Thu Feb 2 18:43:24 2006
@@ -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
Modified: hugo/trunk/lemon/bits/alteration_notifier.h
==============================================================================
--- hugo/trunk/lemon/bits/alteration_notifier.h (original)
+++ hugo/trunk/lemon/bits/alteration_notifier.h Thu Feb 2 18:43:24 2006
@@ -20,7 +20,7 @@
#include <vector>
#include <algorithm>
-///\ingroin graphmapfactory
+///\ingroup graphmapfactory
///\file
///\brief Observer registry for graph alteration observers.
Modified: hugo/trunk/lemon/bits/array_map.h
==============================================================================
--- hugo/trunk/lemon/bits/array_map.h (original)
+++ hugo/trunk/lemon/bits/array_map.h Thu Feb 2 18:43:24 2006
@@ -23,14 +23,14 @@
#include <lemon/concept_check.h>
#include <lemon/concept/maps.h>
-/// \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.
///
Modified: hugo/trunk/lemon/bits/default_map.h
==============================================================================
--- hugo/trunk/lemon/bits/default_map.h (original)
+++ hugo/trunk/lemon/bits/default_map.h Thu Feb 2 18:43:24 2006
@@ -21,7 +21,7 @@
#include <lemon/bits/array_map.h>
#include <lemon/bits/vector_map.h>
-///\ingroin graphmapfactory
+///\ingroup graphmapfactory
///\file
///\brief Graph maps that construct and destruct
///their elements dynamically.
Modified: hugo/trunk/lemon/bits/item_reader.h
==============================================================================
--- hugo/trunk/lemon/bits/item_reader.h (original)
+++ hugo/trunk/lemon/bits/item_reader.h Thu Feb 2 18:43:24 2006
@@ -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 <typename Value>
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<std::pair<First, Second> >
: public PairReader<std::pair<First, Second> > {};
- /// \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<std::string> {};
- /// \ingroin item_io
+ /// \ingroup item_io
/// \brief Standard ReaderTraits for the GraphReader class.
///
/// Standard ReaderTraits for the GraphReader class.
Modified: hugo/trunk/lemon/bits/item_writer.h
==============================================================================
--- hugo/trunk/lemon/bits/item_writer.h (original)
+++ hugo/trunk/lemon/bits/item_writer.h Thu Feb 2 18:43:24 2006
@@ -14,7 +14,7 @@
*
*/
-/// \ingroin item_io
+/// \ingroup item_io
/// \file
/// \brief Item writer bits for lemon output.
@@ -34,7 +34,7 @@
template <typename Value>
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 <typename _Pair,
typename _FirstWriter =
@@ -234,7 +234,7 @@
};
- /// \ingroin item_io
+ /// \ingroup item_io
///
/// \brief The default item writer template class.
///
@@ -307,7 +307,7 @@
class DefaultWriter<std::pair<First, Second> >
: public PairWriter<std::pair<First, Second> > {};
- /// \ingroin item_io
+ /// \ingroup item_io
/// \brief Standard WriterTraits for the section writers.
///
/// Standard WriterTraits for the section writers.
Modified: hugo/trunk/lemon/bits/static_map.h
==============================================================================
--- hugo/trunk/lemon/bits/static_map.h (original)
+++ hugo/trunk/lemon/bits/static_map.h Thu Feb 2 18:43:24 2006
@@ -27,14 +27,14 @@
#include <lemon/concept_check.h>
#include <lemon/concept/maps.h>
-/// \ingroin graphmaps
+/// \ingroup graphmaps
///
///\file
///\brief Static sized graph maps.
namespace lemon {
- /// \ingroin graphmaps
+ /// \ingroup graphmaps
///
/// \brief Graph map with static sized storage.
///
Modified: hugo/trunk/lemon/bits/vector_map.h
==============================================================================
--- hugo/trunk/lemon/bits/vector_map.h (original)
+++ hugo/trunk/lemon/bits/vector_map.h Thu Feb 2 18:43:24 2006
@@ -26,14 +26,14 @@
#include <lemon/concept_check.h>
#include <lemon/concept/maps.h>
-/// \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.
///
Modified: hugo/trunk/lemon/concept/bpugraph.h
==============================================================================
--- hugo/trunk/lemon/concept/bpugraph.h (original)
+++ hugo/trunk/lemon/concept/bpugraph.h Thu Feb 2 18:43:24 2006
@@ -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:
Modified: hugo/trunk/lemon/concept/graph.h
==============================================================================
--- hugo/trunk/lemon/concept/graph.h (original)
+++ hugo/trunk/lemon/concept/graph.h Thu Feb 2 18:43:24 2006
@@ -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
Modified: hugo/trunk/lemon/concept/ugraph.h
==============================================================================
--- hugo/trunk/lemon/concept/ugraph.h (original)
+++ hugo/trunk/lemon/concept/ugraph.h Thu Feb 2 18:43:24 2006
@@ -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:
Modified: hugo/trunk/lemon/dag_shortest_path.h
==============================================================================
--- hugo/trunk/lemon/dag_shortest_path.h (original)
+++ hugo/trunk/lemon/dag_shortest_path.h Thu Feb 2 18:43:24 2006
@@ -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
Modified: hugo/trunk/lemon/dfs.h
==============================================================================
--- hugo/trunk/lemon/dfs.h (original)
+++ hugo/trunk/lemon/dfs.h Thu Feb 2 18:43:24 2006
@@ -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);
Modified: hugo/trunk/lemon/dimacs.h
==============================================================================
--- hugo/trunk/lemon/dimacs.h (original)
+++ hugo/trunk/lemon/dimacs.h Thu Feb 2 18:43:24 2006
@@ -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().
///
Modified: hugo/trunk/lemon/floyd_warshall.h
==============================================================================
--- hugo/trunk/lemon/floyd_warshall.h (original)
+++ hugo/trunk/lemon/floyd_warshall.h Thu Feb 2 18:43:24 2006
@@ -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();
Modified: hugo/trunk/lemon/fredman_tarjan.h
==============================================================================
--- hugo/trunk/lemon/fredman_tarjan.h (original)
+++ hugo/trunk/lemon/fredman_tarjan.h Thu Feb 2 18:43:24 2006
@@ -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);
Modified: hugo/trunk/lemon/graph_adaptor.h
==============================================================================
--- hugo/trunk/lemon/graph_adaptor.h (original)
+++ hugo/trunk/lemon/graph_adaptor.h Thu Feb 2 18:43:24 2006
@@ -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<ListGraph> gw(g);
- /// \endcode
+ ///\endcode
///\author Marton Makai
+
template<typename _Graph>
class RevGraphAdaptor :
public IterableGraphExtender<RevGraphAdaptorBase<_Graph> > {
@@ -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 <typename _Graph, typename FirstOutEdgesMap>
class ErasingFirstGraphAdaptor :
public IterableGraphExtender<
Modified: hugo/trunk/lemon/graph_reader.h
==============================================================================
--- hugo/trunk/lemon/graph_reader.h (original)
+++ hugo/trunk/lemon/graph_reader.h Thu Feb 2 18:43:24 2006
@@ -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<ListGraph> 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<ListUGraph> 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
Modified: hugo/trunk/lemon/graph_utils.h
==============================================================================
--- hugo/trunk/lemon/graph_utils.h (original)
+++ hugo/trunk/lemon/graph_utils.h Thu Feb 2 18:43:24 2006
@@ -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 <typename Graph>
@@ -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<Graph> it(g, src, trg); it != INVALID; ++it) {
/// ...
/// }
- /// \endcode
+ ///\endcode
///
/// \author Balazs Dezso
template <typename _Graph>
@@ -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 <typename Graph>
@@ -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<Graph> it(g, src, trg); it != INVALID; ++it) {
/// ...
/// }
- /// \endcode
+ ///\endcode
///
/// \author Balazs Dezso
template <typename _Graph>
@@ -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
Modified: hugo/trunk/lemon/graph_writer.h
==============================================================================
--- hugo/trunk/lemon/graph_writer.h (original)
+++ hugo/trunk/lemon/graph_writer.h Thu Feb 2 18:43:24 2006
@@ -47,9 +47,9 @@
/// write commands as \c NodeMap or \c EdgeMap writing and labeled Node and
/// Edge writing.
///
- /// \code
+ ///\code
/// GraphWriter<ListGraph> 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<ListGraph, Node> 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<ListGraph, Edge, ListGraph::EdgeMap<int> >
/// 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<ListUGraph> 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<ListUGraph, Node> 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<ListGraph, Edge, ListGraph::EdgeMap<int> >
/// 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
Modified: hugo/trunk/lemon/grid_graph.h
==============================================================================
--- hugo/trunk/lemon/grid_graph.h (original)
+++ hugo/trunk/lemon/grid_graph.h Thu Feb 2 18:43:24 2006
@@ -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<int> 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.
Modified: hugo/trunk/lemon/hypercube_graph.h
==============================================================================
--- hugo/trunk/lemon/hypercube_graph.h (original)
+++ hugo/trunk/lemon/hypercube_graph.h Thu Feb 2 18:43:24 2006
@@ -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<double> base[DIM];
@@ -286,7 +286,7 @@
/// }
/// HyperCubeGraph::HyperMap<xy<double> >
/// pos(graph, base, base + DIM, xy<double>(0.0, 0.0));
- /// \endcode
+ ///\endcode
///
/// \see HyperCubeGraph
template <typename T, typename BF = std::plus<T> >
Modified: hugo/trunk/lemon/johnson.h
==============================================================================
--- hugo/trunk/lemon/johnson.h (original)
+++ hugo/trunk/lemon/johnson.h Thu Feb 2 18:43:24 2006
@@ -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();
Modified: hugo/trunk/lemon/kruskal.h
==============================================================================
--- hugo/trunk/lemon/kruskal.h (original)
+++ hugo/trunk/lemon/kruskal.h Thu Feb 2 18:43:24 2006
@@ -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<Edge> 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<Edge> 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<Graph::Edge> 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<Edge> 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<Edge> tree;
// kruskal(g,cost,std::back_inserter(tree));
-// \endcode
+//\endcode
//
// \return The cost of the found tree.
//
Modified: hugo/trunk/lemon/lemon_reader.h
==============================================================================
--- hugo/trunk/lemon/lemon_reader.h (original)
+++ hugo/trunk/lemon/lemon_reader.h Thu Feb 2 18:43:24 2006
@@ -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:
More information about the Lemon-commits
mailing list