[Lemon-commits] [lemon_svn] deba: r2817 - in hugo/trunk: doc lemon lemon/concept test
Lemon SVN
svn at lemon.cs.elte.hu
Mon Nov 6 21:50:34 CET 2006
Author: deba
Date: Wed Jun 28 17:06:24 2006
New Revision: 2817
Modified:
hugo/trunk/doc/graphs.dox
hugo/trunk/lemon/bellman_ford.h
hugo/trunk/lemon/concept/bpugraph.h
hugo/trunk/lemon/concept/graph.h
hugo/trunk/lemon/concept/graph_component.h
hugo/trunk/lemon/concept/ugraph.h
hugo/trunk/lemon/dag_shortest_path.h
hugo/trunk/lemon/dijkstra.h
hugo/trunk/lemon/edge_set.h
hugo/trunk/lemon/floyd_warshall.h
hugo/trunk/lemon/full_graph.h
hugo/trunk/lemon/graph_adaptor.h
hugo/trunk/lemon/hypercube_graph.h
hugo/trunk/lemon/johnson.h
hugo/trunk/lemon/kruskal.h
hugo/trunk/lemon/list_graph.h
hugo/trunk/lemon/min_cost_arborescence.h
hugo/trunk/lemon/min_cut.h
hugo/trunk/lemon/smart_graph.h
hugo/trunk/lemon/topology.h
hugo/trunk/test/bfs_test.cc
hugo/trunk/test/dfs_test.cc
hugo/trunk/test/dijkstra_test.cc
hugo/trunk/test/edge_set_test.cc
hugo/trunk/test/graph_adaptor_test.cc
hugo/trunk/test/graph_factory_test.cc
hugo/trunk/test/graph_test.cc
hugo/trunk/test/kruskal_test.cc
hugo/trunk/test/preflow_test.cc
hugo/trunk/test/ugraph_test.cc
Log:
Removing concepts for extendable and erasable graphs
Renaming StaticGraph to Graph
Modified: hugo/trunk/doc/graphs.dox
==============================================================================
--- hugo/trunk/doc/graphs.dox (original)
+++ hugo/trunk/doc/graphs.dox Wed Jun 28 17:06:24 2006
@@ -2,23 +2,20 @@
\page graphs Graphs
+\todo Write a new Graphs page. I think it should be contain the Graph,
+UGraph and BpUGraph concept. It should be describe the iterators and
+the basic functions and the differences of the implementations.
+
The primary data structures of LEMON are the graph classes. They all
provide a node list - edge list interface, i.e. they have
functionalities to list the nodes and the edges of the graph as well
as incoming and outgoing edges of a given node.
+Each graph should meet the \ref lemon::concept::Graph "Graph" concept.
+This concept does not make it possible to change the graph (i.e. it is
+not possible to add or delete edges or nodes). Most of the graph
+algorithms will run on these graphs.
-Each graph should meet the
-\ref lemon::concept::StaticGraph "StaticGraph" concept.
-This concept does not
-make it possible to change the graph (i.e. it is not possible to add
-or delete edges or nodes). Most of the graph algorithms will run on
-these graphs.
-
-The graphs meeting the
-\ref lemon::concept::ExtendableGraph "ExtendableGraph"
-concept allow node and
-edge addition. You can also "clear" such a graph (i.e. erase all edges and nodes ).
In case of graphs meeting the full feature
\ref lemon::concept::ErasableGraph "ErasableGraph"
@@ -36,7 +33,7 @@
so you cannot delete individual edges or nodes.
\li \ref lemon::FullGraph "FullGraph"
implements a complete graph. It is a
-\ref lemon::concept::StaticGraph "StaticGraph", so you cannot
+\ref lemon::concept::Graph "Graph", so you cannot
change the number of nodes once it is constructed. It is extremely memory
efficient: it uses constant amount of memory independently from the number of
the nodes of the graph. Of course, the size of the \ref maps-page "NodeMap"'s and
Modified: hugo/trunk/lemon/bellman_ford.h
==============================================================================
--- hugo/trunk/lemon/bellman_ford.h (original)
+++ hugo/trunk/lemon/bellman_ford.h Wed Jun 28 17:06:24 2006
@@ -164,7 +164,7 @@
/// is \ref ListGraph. The value of _Graph is not used directly by
/// BellmanFord, it is only passed to \ref BellmanFordDefaultTraits.
/// \param _LengthMap This read-only EdgeMap determines the lengths of the
- /// edges. The default map type is \ref concept::StaticGraph::EdgeMap
+ /// edges. The default map type is \ref concept::Graph::EdgeMap
/// "Graph::EdgeMap<int>". The value of _LengthMap is not used directly
/// by BellmanFord, it is only passed to \ref BellmanFordDefaultTraits.
/// \param _Traits Traits class to set various data types used by the
Modified: hugo/trunk/lemon/concept/bpugraph.h
==============================================================================
--- hugo/trunk/lemon/concept/bpugraph.h (original)
+++ hugo/trunk/lemon/concept/bpugraph.h Wed Jun 28 17:06:24 2006
@@ -947,70 +947,6 @@
};
- /// \brief An empty non-static undirected graph class.
- ///
- /// This class provides everything that \ref BpUGraph does.
- /// Additionally it enables building graphs from scratch.
- class ExtendableBpUGraph : public BpUGraph {
- public:
-
- /// \brief Add a new ANode to the graph.
- ///
- /// Add a new ANode to the graph.
- /// \return the new node.
- Node addANode();
-
- /// \brief Add a new ANode to the graph.
- ///
- /// Add a new ANode to the graph.
- /// \return the new node.
- Node addBNode();
-
- /// \brief Add a new undirected edge to the graph.
- ///
- /// Add a new undirected edge to the graph. One of the nodes
- /// should be ANode and the other should be BNode.
- /// \pre The nodes are not in the same nodeset.
- /// \return the new edge.
- UEdge addEdge(const Node& from, const Node& to);
-
- /// \brief Resets the graph.
- ///
- /// This function deletes all undirected edges and nodes of the graph.
- /// It also frees the memory allocated to store them.
- void clear() { }
-
- template <typename Graph>
- struct Constraints {
- void constraints() {}
- };
-
- };
-
- /// \brief An empty erasable undirected graph class.
- ///
- /// This class is an extension of \ref ExtendableBpUGraph. It makes it
- /// possible to erase undirected edges or nodes.
- class ErasableBpUGraph : public ExtendableBpUGraph {
- public:
-
- /// \brief Deletes a node.
- ///
- /// Deletes a node.
- ///
- void erase(Node) { }
- /// \brief Deletes an undirected edge.
- ///
- /// Deletes an undirected edge.
- ///
- void erase(UEdge) { }
-
- template <typename Graph>
- struct Constraints {
- void constraints() {}
- };
-
- };
/// @}
Modified: hugo/trunk/lemon/concept/graph.h
==============================================================================
--- hugo/trunk/lemon/concept/graph.h (original)
+++ hugo/trunk/lemon/concept/graph.h Wed Jun 28 17:06:24 2006
@@ -38,8 +38,8 @@
// \brief Modular static graph class.
//
- // It should be the same as the \c StaticGraph class.
- class _StaticGraph
+ // It should be the same as the \c Graph class.
+ class _Graph
: virtual public BaseGraphComponent,
public IterableGraphComponent, public MappableGraphComponent {
public:
@@ -56,49 +56,10 @@
};
};
- // \brief Modular extendable graph class.
- //
- // It should be the same as the \c ExtendableGraph class.
- class _ExtendableGraph
- : virtual public BaseGraphComponent, public _StaticGraph,
- public ExtendableGraphComponent, public ClearableGraphComponent {
- public:
- typedef BaseGraphComponent::Node Node;
- typedef BaseGraphComponent::Edge Edge;
-
- template <typename _Graph>
- struct Constraints {
- void constraints() {
- checkConcept<_StaticGraph, _Graph >();
- checkConcept<ExtendableGraphComponent, _Graph >();
- checkConcept<ClearableGraphComponent, _Graph >();
- }
- };
- };
-
- // \brief Modular erasable graph class.
- //
- // It should be the same as the \c ErasableGraph class.
- class _ErasableGraph
- : virtual public BaseGraphComponent, public _ExtendableGraph,
- public ErasableGraphComponent {
- public:
- typedef BaseGraphComponent::Node Node;
- typedef BaseGraphComponent::Edge Edge;
-
- template <typename _Graph>
- struct Constraints {
- void constraints() {
- checkConcept<_ExtendableGraph, _Graph >();
- checkConcept<ErasableGraphComponent, _Graph >();
- }
- };
- };
-
/// \addtogroup graph_concepts
/// @{
- /// An empty static graph class.
+ /// An empty graph class.
/// This class provides all the common features of a graph structure,
/// however completely without implementations and real data structures
@@ -116,13 +77,7 @@
///
/// \todo A pages describing the concept of concept description would
/// be nice.
- class StaticGraph
- {
-// ///Copy consructor.
-
-// ///\todo It is not clear, what we expect from a copy constructor.
-// ///E.g. How to assign the nodes/edges to each other? What about maps?
-// StaticGraph(const StaticGraph& g) { }
+ class Graph {
public:
///\e
@@ -130,7 +85,7 @@
/// Defalult constructor.
///
- StaticGraph() { }
+ Graph() { }
/// The base type of node iterators,
/// or in other words, the trivial node iterator.
@@ -213,14 +168,14 @@
/// Sets the iterator to the first node of \c g.
///
- NodeIt(const StaticGraph&) { }
+ NodeIt(const Graph&) { }
/// Node -> NodeIt conversion.
/// Sets the iterator to the node of \c the graph pointed by
/// the trivial iterator.
/// This feature necessitates that each time we
/// iterate the edge-set, the iteration order is the same.
- NodeIt(const StaticGraph&, const Node&) { }
+ NodeIt(const Graph&, const Node&) { }
/// Next node.
/// Assign the iterator to the next node.
@@ -307,13 +262,13 @@
/// This constructor sets the iterator to the first outgoing edge of
/// the node.
- OutEdgeIt(const StaticGraph&, const Node&) { }
+ OutEdgeIt(const Graph&, const Node&) { }
/// Edge -> OutEdgeIt conversion
/// Sets the iterator to the value of the trivial iterator.
/// This feature necessitates that each time we
/// iterate the edge-set, the iteration order is the same.
- OutEdgeIt(const StaticGraph&, const Edge&) { }
+ OutEdgeIt(const Graph&, const Edge&) { }
///Next outgoing edge
/// Assign the iterator to the next
@@ -354,13 +309,13 @@
/// This constructor set the iterator to the first incoming edge of
/// the node.
- InEdgeIt(const StaticGraph&, const Node&) { }
+ InEdgeIt(const Graph&, const Node&) { }
/// Edge -> InEdgeIt conversion
/// Sets the iterator to the value of the trivial iterator \c e.
/// This feature necessitates that each time we
/// iterate the edge-set, the iteration order is the same.
- InEdgeIt(const StaticGraph&, const Edge&) { }
+ InEdgeIt(const Graph&, const Edge&) { }
/// Next incoming edge
/// Assign the iterator to the next inedge of the corresponding node.
@@ -397,13 +352,13 @@
/// This constructor sets the iterator to the first edge of \c g.
///@param g the graph
- EdgeIt(const StaticGraph& g) { ignore_unused_variable_warning(g); }
+ EdgeIt(const Graph& g) { ignore_unused_variable_warning(g); }
/// Edge -> EdgeIt conversion
/// Sets the iterator to the value of the trivial iterator \c e.
/// This feature necessitates that each time we
/// iterate the edge-set, the iteration order is the same.
- EdgeIt(const StaticGraph&, const Edge&) { }
+ EdgeIt(const Graph&, const Edge&) { }
///Next edge
/// Assign the iterator to the next edge.
@@ -420,53 +375,17 @@
///
Node source(Edge) const { return INVALID; }
-// /// Gives back the first Node in the iterating order.
-
-// /// Gives back the first Node in the iterating order.
-// ///
void first(Node&) const {}
-
-// /// Gives back the next Node in the iterating order.
-
-// /// Gives back the next Node in the iterating order.
-// ///
void next(Node&) const {}
-// /// Gives back the first Edge in the iterating order.
-
-// /// Gives back the first Edge in the iterating order.
-// ///
void first(Edge&) const {}
-// /// Gives back the next Edge in the iterating order.
-
-// /// Gives back the next Edge in the iterating order.
-// ///
void next(Edge&) const {}
-// /// Gives back the first of the Edges point to the given Node.
-
-// /// Gives back the first of the Edges point to the given Node.
-// ///
void firstIn(Edge&, const Node&) const {}
-
-// /// Gives back the next of the Edges points to the given Node.
-
-
-// /// Gives back the next of the Edges points to the given Node.
-// ///
void nextIn(Edge&) const {}
-// /// Gives back the first of the Edges start from the given Node.
-
-// /// Gives back the first of the Edges start from the given Node.
-// ///
void firstOut(Edge&, const Node&) const {}
-
-// /// Gives back the next of the Edges start from the given Node.
-
-// /// Gives back the next of the Edges start from the given Node.
-// ///
void nextOut(Edge&) const {}
/// \brief The base node of the iterator.
@@ -511,9 +430,9 @@
public:
///\e
- NodeMap(const StaticGraph&) { }
+ NodeMap(const Graph&) { }
///\e
- NodeMap(const StaticGraph&, T) { }
+ NodeMap(const Graph&, T) { }
///Copy constructor
NodeMap(const NodeMap& nm) : ReadWriteMap< Node, T >(nm) { }
@@ -535,9 +454,9 @@
public:
///\e
- EdgeMap(const StaticGraph&) { }
+ EdgeMap(const Graph&) { }
///\e
- EdgeMap(const StaticGraph&, T) { }
+ EdgeMap(const Graph&, T) { }
///Copy constructor
EdgeMap(const EdgeMap& em) : ReadWriteMap<Edge,T>(em) { }
///Assignment operator
@@ -545,72 +464,8 @@
// \todo fix this concept
};
- template <typename _Graph>
- struct Constraints : public _StaticGraph::Constraints<_Graph> {};
-
- };
-
- /// An empty non-static graph class.
-
- /// This class provides everything that \ref StaticGraph does.
- /// Additionally it enables building graphs from scratch.
- class ExtendableGraph : public StaticGraph
- {
- public:
- /// Defalult constructor.
-
- /// Defalult constructor.
- ///
- ExtendableGraph() { }
- ///Add a new node to the graph.
-
- /// \return the new node.
- ///
- Node addNode() { return INVALID; }
- ///Add a new edge to the graph.
-
- ///Add a new edge to the graph with source node \c s
- ///and target node \c t.
- ///\return the new edge.
- Edge addEdge(Node, Node) { return INVALID; }
-
- /// Resets the graph.
-
- /// This function deletes all edges and nodes of the graph.
- /// It also frees the memory allocated to store them.
- /// \todo It might belong to \ref ErasableGraph.
- void clear() { }
-
- template <typename _Graph>
- struct Constraints : public _ExtendableGraph::Constraints<_Graph> {};
-
- };
-
- /// An empty erasable graph class.
-
- /// This class is an extension of \ref ExtendableGraph. It makes it
- /// possible to erase edges or nodes.
- class ErasableGraph : public ExtendableGraph
- {
- public:
- /// Defalult constructor.
-
- /// Defalult constructor.
- ///
- ErasableGraph() { }
- /// Deletes a node.
-
- /// Deletes node \c n node.
- ///
- void erase(Node) { }
- /// Deletes an edge.
-
- /// Deletes edge \c e edge.
- ///
- void erase(Edge) { }
-
- template <typename _Graph>
- struct Constraints : public _ErasableGraph::Constraints<_Graph> {};
+ template <typename RGraph>
+ struct Constraints : public _Graph::Constraints<RGraph> {};
};
Modified: hugo/trunk/lemon/concept/graph_component.h
==============================================================================
--- hugo/trunk/lemon/concept/graph_component.h (original)
+++ hugo/trunk/lemon/concept/graph_component.h Wed Jun 28 17:06:24 2006
@@ -458,7 +458,7 @@
/// This class provides beside the core graph features
/// core clear functions for the graph structure.
/// The most of the base graphs should be conform to this concept.
- class ClearableGraphComponent : virtual public BaseGraphComponent {
+ class BaseClearableGraphComponent : virtual public BaseGraphComponent {
public:
/// Erase all the Nodes and Edges from the graph.
@@ -646,7 +646,7 @@
/// This class provides beside the core graph features
/// iterator based iterable interface for the graph structure.
- /// This concept is part of the StaticGraphConcept.
+ /// This concept is part of the GraphConcept.
class IterableGraphComponent : virtual public BaseGraphComponent {
public:
@@ -817,7 +817,7 @@
/// This class provides beside the core graph features
/// map interface for the graph structure.
- /// This concept is part of the StaticGraphConcept.
+ /// This concept is part of the GraphConcept.
class MappableGraphComponent : virtual public BaseGraphComponent {
public:
@@ -930,86 +930,160 @@
};
};
- /// \brief An empty extendable extended graph class.
- ///
- /// This class provides beside the core graph features
- /// item addition interface for the graph structure.
- /// The difference between this class and the
- /// \c BaseExtendableGraphComponent is that it should
- /// notify the item alteration observers.
- class ExtendableGraphComponent : virtual public BaseGraphComponent {
+
+// /// Skeleton class which describes an edge with direction in \ref
+// /// UGraph "undirected graph".
+ template <typename UGraph>
+ class UGraphEdge : public UGraph::UEdge {
+ typedef typename UGraph::UEdge UEdge;
+ typedef typename UGraph::Node Node;
public:
- typedef ExtendableGraphComponent Graph;
+ /// \e
+ UGraphEdge() {}
- typedef BaseGraphComponent::Node Node;
- typedef BaseGraphComponent::Edge Edge;
+ /// \e
+ UGraphEdge(const UGraphEdge& e) : UGraph::UEdge(e) {}
+
+ /// \e
+ UGraphEdge(Invalid) {}
- /// \brief Add a node to the graph.
+ /// \brief Directed edge from undirected edge and a source node.
///
- /// Add a node to the graph and notify the observers.
- Node addNode() {
- return INVALID;
- }
-
- /// \brief Add an edge to the graph.
+ /// Constructs a directed edge from undirected edge and a source node.
///
- /// Add an edge to the graph and notify the observers.
- Edge addEdge(const Node&, const Node&) {
- return INVALID;
+ /// \note You have to specify the graph for this constructor.
+ UGraphEdge(const UGraph &g,
+ UEdge u_edge, Node n) {
+ ignore_unused_variable_warning(u_edge);
+ ignore_unused_variable_warning(g);
+ ignore_unused_variable_warning(n);
}
- template <typename _Graph>
+ /// \e
+ UGraphEdge& operator=(UGraphEdge) { return *this; }
+
+ /// \e
+ bool operator==(UGraphEdge) const { return true; }
+ /// \e
+ bool operator!=(UGraphEdge) const { return false; }
+
+ /// \e
+ bool operator<(UGraphEdge) const { return false; }
+
+ template <typename Edge>
struct Constraints {
void constraints() {
- checkConcept<BaseGraphComponent, _Graph >();
- typename _Graph::Node node_a, node_b;
- node_a = graph.addNode();
- node_b = graph.addNode();
- typename _Graph::Edge edge;
- edge = graph.addEdge(node_a, node_b);
+ const_constraints();
}
- _Graph& graph;
+ void const_constraints() const {
+ /// \bug This should be is_base_and_derived ...
+ UEdge ue = e;
+ ue = e;
+
+ Edge e_with_source(graph,ue,n);
+ ignore_unused_variable_warning(e_with_source);
+ }
+ Edge e;
+ UEdge ue;
+ UGraph graph;
+ Node n;
};
};
+
- /// \brief An empty erasable extended graph class.
- ///
- /// This class provides beside the core graph features
- /// item erase interface for the graph structure.
- /// The difference between this class and the
- /// \c BaseErasableGraphComponent is that it should
- /// notify the item alteration observers.
- class ErasableGraphComponent : virtual public BaseGraphComponent {
- public:
+ struct BaseIterableUGraphConcept {
- typedef ErasableGraphComponent Graph;
+ template <typename Graph>
+ struct Constraints {
- typedef BaseGraphComponent::Node Node;
- typedef BaseGraphComponent::Edge Edge;
+ typedef typename Graph::UEdge UEdge;
+ typedef typename Graph::Edge Edge;
+ typedef typename Graph::Node Node;
- /// \brief Erase the Node and notify the node alteration observers.
- ///
- /// Erase the Node and notify the node alteration observers.
- void erase(const Node&) {}
+ void constraints() {
+ checkConcept<BaseIterableGraphComponent, Graph>();
+ checkConcept<GraphItem<>, UEdge>();
+ //checkConcept<UGraphEdge<Graph>, Edge>();
- /// \brief Erase the Edge and notify the edge alteration observers.
- ///
- /// Erase the Edge and notify the edge alteration observers.
- void erase(const Edge&) {}
+ graph.first(ue);
+ graph.next(ue);
- template <typename _Graph>
+ const_constraints();
+ }
+ void const_constraints() {
+ Node n;
+ n = graph.target(ue);
+ n = graph.source(ue);
+ n = graph.oppositeNode(n0, ue);
+
+ bool b;
+ b = graph.direction(e);
+ Edge e = graph.direct(UEdge(), true);
+ e = graph.direct(UEdge(), n);
+
+ ignore_unused_variable_warning(b);
+ }
+
+ Graph graph;
+ Edge e;
+ Node n0;
+ UEdge ue;
+ };
+
+ };
+
+
+ struct IterableUGraphConcept {
+
+ template <typename Graph>
struct Constraints {
void constraints() {
- checkConcept<BaseGraphComponent, _Graph >();
- typename _Graph::Node node;
- graph.erase(node);
- typename _Graph::Edge edge;
- graph.erase(edge);
+ /// \todo we don't need the iterable component to be base iterable
+ /// Don't we really???
+ //checkConcept< BaseIterableUGraphConcept, Graph > ();
+
+ checkConcept<IterableGraphComponent, Graph> ();
+
+ typedef typename Graph::UEdge UEdge;
+ typedef typename Graph::UEdgeIt UEdgeIt;
+ typedef typename Graph::IncEdgeIt IncEdgeIt;
+
+ checkConcept<GraphIterator<Graph, UEdge>, UEdgeIt>();
+ checkConcept<GraphIncIterator<Graph, UEdge>, IncEdgeIt>();
}
+ };
- _Graph& graph;
+ };
+
+ struct MappableUGraphConcept {
+
+ template <typename Graph>
+ struct Constraints {
+
+ struct Dummy {
+ int value;
+ Dummy() : value(0) {}
+ Dummy(int _v) : value(_v) {}
+ };
+
+ void constraints() {
+ checkConcept<MappableGraphComponent, Graph>();
+
+ typedef typename Graph::template UEdgeMap<int> IntMap;
+ checkConcept<GraphMap<Graph, typename Graph::UEdge, int>,
+ IntMap >();
+
+ typedef typename Graph::template UEdgeMap<bool> BoolMap;
+ checkConcept<GraphMap<Graph, typename Graph::UEdge, bool>,
+ BoolMap >();
+
+ typedef typename Graph::template UEdgeMap<Dummy> DummyMap;
+ checkConcept<GraphMap<Graph, typename Graph::UEdge, Dummy>,
+ DummyMap >();
+ }
};
+
};
}
Modified: hugo/trunk/lemon/concept/ugraph.h
==============================================================================
--- hugo/trunk/lemon/concept/ugraph.h (original)
+++ hugo/trunk/lemon/concept/ugraph.h Wed Jun 28 17:06:24 2006
@@ -18,7 +18,7 @@
///\ingroup graph_concepts
///\file
-///\brief Undirected graphs and components of.
+///\brief The concept of the undirected graphs.
#ifndef LEMON_CONCEPT_UGRAPH_H
@@ -31,191 +31,6 @@
namespace lemon {
namespace concept {
-// /// Skeleton class which describes an edge with direction in \ref
-// /// UGraph "undirected graph".
- template <typename UGraph>
- class UGraphEdge : public UGraph::UEdge {
- typedef typename UGraph::UEdge UEdge;
- typedef typename UGraph::Node Node;
- public:
-
- /// \e
- UGraphEdge() {}
-
- /// \e
- UGraphEdge(const UGraphEdge& e) : UGraph::UEdge(e) {}
-
- /// \e
- UGraphEdge(Invalid) {}
-
- /// \brief Directed edge from undirected edge and a source node.
- ///
- /// Constructs a directed edge from undirected edge and a source node.
- ///
- /// \note You have to specify the graph for this constructor.
- UGraphEdge(const UGraph &g,
- UEdge u_edge, Node n) {
- ignore_unused_variable_warning(u_edge);
- ignore_unused_variable_warning(g);
- ignore_unused_variable_warning(n);
- }
-
- /// \e
- UGraphEdge& operator=(UGraphEdge) { return *this; }
-
- /// \e
- bool operator==(UGraphEdge) const { return true; }
- /// \e
- bool operator!=(UGraphEdge) const { return false; }
-
- /// \e
- bool operator<(UGraphEdge) const { return false; }
-
- template <typename Edge>
- struct Constraints {
- void constraints() {
- const_constraints();
- }
- void const_constraints() const {
- /// \bug This should be is_base_and_derived ...
- UEdge ue = e;
- ue = e;
-
- Edge e_with_source(graph,ue,n);
- ignore_unused_variable_warning(e_with_source);
- }
- Edge e;
- UEdge ue;
- UGraph graph;
- Node n;
- };
- };
-
-
- struct BaseIterableUGraphConcept {
-
- template <typename Graph>
- struct Constraints {
-
- typedef typename Graph::UEdge UEdge;
- typedef typename Graph::Edge Edge;
- typedef typename Graph::Node Node;
-
- void constraints() {
- checkConcept<BaseIterableGraphComponent, Graph>();
- checkConcept<GraphItem<>, UEdge>();
- //checkConcept<UGraphEdge<Graph>, Edge>();
-
- graph.first(ue);
- graph.next(ue);
-
- const_constraints();
- }
- void const_constraints() {
- Node n;
- n = graph.target(ue);
- n = graph.source(ue);
- n = graph.oppositeNode(n0, ue);
-
- bool b;
- b = graph.direction(e);
- Edge e = graph.direct(UEdge(), true);
- e = graph.direct(UEdge(), n);
-
- ignore_unused_variable_warning(b);
- }
-
- Graph graph;
- Edge e;
- Node n0;
- UEdge ue;
- };
-
- };
-
-
- struct IterableUGraphConcept {
-
- template <typename Graph>
- struct Constraints {
- void constraints() {
- /// \todo we don't need the iterable component to be base iterable
- /// Don't we really???
- //checkConcept< BaseIterableUGraphConcept, Graph > ();
-
- checkConcept<IterableGraphComponent, Graph> ();
-
- typedef typename Graph::UEdge UEdge;
- typedef typename Graph::UEdgeIt UEdgeIt;
- typedef typename Graph::IncEdgeIt IncEdgeIt;
-
- checkConcept<GraphIterator<Graph, UEdge>, UEdgeIt>();
- checkConcept<GraphIncIterator<Graph, UEdge>, IncEdgeIt>();
- }
- };
-
- };
-
- struct MappableUGraphConcept {
-
- template <typename Graph>
- struct Constraints {
-
- struct Dummy {
- int value;
- Dummy() : value(0) {}
- Dummy(int _v) : value(_v) {}
- };
-
- void constraints() {
- checkConcept<MappableGraphComponent, Graph>();
-
- typedef typename Graph::template UEdgeMap<int> IntMap;
- checkConcept<GraphMap<Graph, typename Graph::UEdge, int>,
- IntMap >();
-
- typedef typename Graph::template UEdgeMap<bool> BoolMap;
- checkConcept<GraphMap<Graph, typename Graph::UEdge, bool>,
- BoolMap >();
-
- typedef typename Graph::template UEdgeMap<Dummy> DummyMap;
- checkConcept<GraphMap<Graph, typename Graph::UEdge, Dummy>,
- DummyMap >();
- }
- };
-
- };
-
- struct ExtendableUGraphConcept {
-
- template <typename Graph>
- struct Constraints {
- void constraints() {
- node_a = graph.addNode();
- uedge = graph.addEdge(node_a, node_b);
- }
- typename Graph::Node node_a, node_b;
- typename Graph::UEdge uedge;
- Graph graph;
- };
-
- };
-
- struct ErasableUGraphConcept {
-
- template <typename Graph>
- struct Constraints {
- void constraints() {
- graph.erase(n);
- graph.erase(e);
- }
- Graph graph;
- typename Graph::Node n;
- typename Graph::UEdge e;
- };
-
- };
-
/// \addtogroup graph_concepts
/// @{
@@ -231,13 +46,13 @@
/// run properly, of couse.
///
/// In LEMON undirected graphs also fulfill the concept of directed
- /// graphs (\ref lemon::concept::StaticGraph "Graph Concept"). For
- /// explanation of this and more see also the page \ref ugraphs,
- /// a tutorial about undirected graphs.
+ /// graphs (\ref lemon::concept::Graph "Graph Concept"). For
+ /// explanation of this and more see also the page \ref graphs,
+ /// a tutorial about graphs.
///
/// You can assume that all undirected graph can be handled
- /// as a static directed graph. This way it is fully conform
- /// to the StaticGraph concept.
+ /// as a directed graph. This way it is fully conform
+ /// to the Graph concept.
class UGraph {
public:
@@ -799,74 +614,23 @@
/// \brief Target node of the directed edge.
Node target(Edge) const { return INVALID; }
-// /// \brief First node of the graph
-// ///
-// /// \note This method is part of so called \ref
-// /// developpers_interface "Developpers' interface", so it shouldn't
-// /// be used in an end-user program.
void first(Node&) const {}
-// /// \brief Next node of the graph
-// ///
-// /// \note This method is part of so called \ref
-// /// developpers_interface "Developpers' interface", so it shouldn't
-// /// be used in an end-user program.
void next(Node&) const {}
-// /// \brief First undirected edge of the graph
-// ///
-// /// \note This method is part of so called \ref
-// /// developpers_interface "Developpers' interface", so it shouldn't
-// /// be used in an end-user program.
void first(UEdge&) const {}
-// /// \brief Next undirected edge of the graph
-// ///
-// /// \note This method is part of so called \ref
-// /// developpers_interface "Developpers' interface", so it shouldn't
-// /// be used in an end-user program.
void next(UEdge&) const {}
-// /// \brief First directed edge of the graph
-// ///
-// /// \note This method is part of so called \ref
-// /// developpers_interface "Developpers' interface", so it shouldn't
-// /// be used in an end-user program.
void first(Edge&) const {}
-// /// \brief Next directed edge of the graph
-// ///
-// /// \note This method is part of so called \ref
-// /// developpers_interface "Developpers' interface", so it shouldn't
-// /// be used in an end-user program.
void next(Edge&) const {}
-// /// \brief First outgoing edge from a given node
-// ///
-// /// \note This method is part of so called \ref
-// /// developpers_interface "Developpers' interface", so it shouldn't
-// /// be used in an end-user program.
void firstOut(Edge&, Node) const {}
-// /// \brief Next outgoing edge to a node
-// ///
-// /// \note This method is part of so called \ref
-// /// developpers_interface "Developpers' interface", so it shouldn't
-// /// be used in an end-user program.
void nextOut(Edge&) const {}
-// /// \brief First incoming edge to a given node
-// ///
-// /// \note This method is part of so called \ref
-// /// developpers_interface "Developpers' interface", so it shouldn't
-// /// be used in an end-user program.
void firstIn(Edge&, Node) const {}
-// /// \brief Next incoming edge to a node
-// ///
-// /// \note This method is part of so called \ref
-// /// developpers_interface "Developpers' interface", so it shouldn't
-// /// be used in an end-user program.
void nextIn(Edge&) const {}
void firstInc(UEdge &, bool &, const Node &) const {}
-
void nextInc(UEdge &, bool &) const {}
/// \brief Base node of the iterator
@@ -922,74 +686,6 @@
};
- /// \brief An empty non-static undirected graph class.
- ///
- /// This class provides everything that \ref UGraph does.
- /// Additionally it enables building graphs from scratch.
- class ExtendableUGraph : public UGraph {
- public:
-
- /// \brief Add a new node to the graph.
- ///
- /// Add a new node to the graph.
- /// \return the new node.
- Node addNode();
-
- /// \brief Add a new undirected edge to the graph.
- ///
- /// Add a new undirected edge to the graph.
- /// \return the new edge.
- UEdge addEdge(const Node& from, const Node& to);
-
- /// \brief Resets the graph.
- ///
- /// This function deletes all undirected edges and nodes of the graph.
- /// It also frees the memory allocated to store them.
- void clear() { }
-
- template <typename Graph>
- struct Constraints {
- void constraints() {
- checkConcept<BaseIterableUGraphConcept, Graph>();
- checkConcept<IterableUGraphConcept, Graph>();
- checkConcept<MappableUGraphConcept, Graph>();
-
- checkConcept<UGraph, Graph>();
- checkConcept<ExtendableUGraphConcept, Graph>();
- checkConcept<ClearableGraphComponent, Graph>();
- }
- };
-
- };
-
- /// \brief An empty erasable undirected graph class.
- ///
- /// This class is an extension of \ref ExtendableUGraph. It makes it
- /// possible to erase undirected edges or nodes.
- class ErasableUGraph : public ExtendableUGraph {
- public:
-
- /// \brief Deletes a node.
- ///
- /// Deletes a node.
- ///
- void erase(Node) { }
- /// \brief Deletes an undirected edge.
- ///
- /// Deletes an undirected edge.
- ///
- void erase(UEdge) { }
-
- template <typename Graph>
- struct Constraints {
- void constraints() {
- checkConcept<ExtendableUGraph, Graph>();
- checkConcept<ErasableUGraphConcept, Graph>();
- }
- };
-
- };
-
/// @}
}
Modified: hugo/trunk/lemon/dag_shortest_path.h
==============================================================================
--- hugo/trunk/lemon/dag_shortest_path.h (original)
+++ hugo/trunk/lemon/dag_shortest_path.h Wed Jun 28 17:06:24 2006
@@ -274,7 +274,7 @@
/// is \ref ListGraph. The value of _Graph is not used directly by
/// DagShortestPath, it is only passed to \ref DagShortestPathDefaultTraits.
/// \param _LengthMap This read-only EdgeMap determines the lengths of the
- /// edges. The default map type is \ref concept::StaticGraph::EdgeMap
+ /// edges. The default map type is \ref concept::Graph::EdgeMap
/// "Graph::EdgeMap<int>". The value of _LengthMap is not used directly
/// by DagShortestPath, it is only passed to \ref DagShortestPathDefaultTraits.
/// \param _Traits Traits class to set various data types used by the
Modified: hugo/trunk/lemon/dijkstra.h
==============================================================================
--- hugo/trunk/lemon/dijkstra.h (original)
+++ hugo/trunk/lemon/dijkstra.h Wed Jun 28 17:06:24 2006
@@ -157,7 +157,7 @@
///edges. It is read once for each edge, so the map may involve in
///relatively time consuming process to compute the edge length if
///it is necessary. The default map type is \ref
- ///concept::StaticGraph::EdgeMap "Graph::EdgeMap<int>". The value
+ ///concept::Graph::EdgeMap "Graph::EdgeMap<int>". The value
///of LM is not used directly by Dijkstra, it is only passed to \ref
///DijkstraDefaultTraits. \param TR Traits class to set
///various data types used by the algorithm. The default traits
Modified: hugo/trunk/lemon/edge_set.h
==============================================================================
--- hugo/trunk/lemon/edge_set.h (original)
+++ hugo/trunk/lemon/edge_set.h Wed Jun 28 17:06:24 2006
@@ -238,11 +238,11 @@
/// original graph.
///
/// \param _Graph The type of the graph which shares its node set with
- /// this class. Its interface must conform to the \ref concept::StaticGraph
- /// "StaticGraph" concept.
+ /// this class. Its interface must conform to the \ref concept::Graph
+ /// "Graph" concept.
///
/// In the edge extension and removing it conforms to the
- /// \ref concept::ErasableGraph "ErasableGraph" concept.
+ /// \ref concept::Graph "Graph" concept.
template <typename _Graph>
class ListEdgeSet : public EdgeSetExtender<ListEdgeSetBase<_Graph> > {
@@ -330,11 +330,11 @@
/// original graph.
///
/// \param _Graph The type of the graph which shares its node set with
- /// this class. Its interface must conform to the \ref concept::StaticGraph
- /// "StaticGraph" concept.
+ /// this class. Its interface must conform to the \ref concept::Graph
+ /// "Graph" concept.
///
/// In the edge extension and removing it conforms to the
- /// \ref concept::ErasableUGraph "ErasableUGraph" concept.
+ /// \ref concept::UGraph "UGraph" concept.
template <typename _Graph>
class ListUEdgeSet
: public UEdgeSetExtender<UndirGraphExtender<ListEdgeSetBase<_Graph> > > {
@@ -567,11 +567,11 @@
/// original graph.
///
/// \param _Graph The type of the graph which shares its node set with
- /// this class. Its interface must conform to the \ref concept::StaticGraph
- /// "StaticGraph" concept.
+ /// this class. Its interface must conform to the \ref concept::Graph
+ /// "Graph" concept.
///
/// In the edge extension and removing it conforms to the
- /// \ref concept::ExtendableGraph "ExtendableGraph" concept.
+ /// \ref concept::Graph "Graph" concept.
template <typename _Graph>
class SmartEdgeSet : public EdgeSetExtender<SmartEdgeSetBase<_Graph> > {
@@ -662,11 +662,11 @@
/// original graph.
///
/// \param _Graph The type of the graph which shares its node set with
- /// this class. Its interface must conform to the \ref concept::StaticGraph
- /// "StaticGraph" concept.
+ /// this class. Its interface must conform to the \ref concept::Graph
+ /// "Graph" concept.
///
/// In the edge extension and removing it conforms to the
- /// \ref concept::ExtendableUGraph "ExtendableUGraph" concept.
+ /// \ref concept::UGraph "UGraph" concept.
template <typename _Graph>
class SmartUEdgeSet
: public UEdgeSetExtender<UndirGraphExtender<SmartEdgeSetBase<_Graph> > > {
Modified: hugo/trunk/lemon/floyd_warshall.h
==============================================================================
--- hugo/trunk/lemon/floyd_warshall.h (original)
+++ hugo/trunk/lemon/floyd_warshall.h Wed Jun 28 17:06:24 2006
@@ -171,7 +171,7 @@
/// edges. It is read once for each edge, so the map may involve in
/// relatively time consuming process to compute the edge length if
/// it is necessary. The default map type is \ref
- /// concept::StaticGraph::EdgeMap "Graph::EdgeMap<int>". The value
+ /// concept::Graph::EdgeMap "Graph::EdgeMap<int>". The value
/// of _LengthMap is not used directly by FloydWarshall, it is only passed
/// to \ref FloydWarshallDefaultTraits. \param _Traits Traits class to set
/// various data types used by the algorithm. The default traits
Modified: hugo/trunk/lemon/full_graph.h
==============================================================================
--- hugo/trunk/lemon/full_graph.h (original)
+++ hugo/trunk/lemon/full_graph.h Wed Jun 28 17:06:24 2006
@@ -214,8 +214,8 @@
/// It is completely static, so you can neither add nor delete either
/// edges or nodes.
/// Thus it conforms to
- /// the \ref concept::StaticGraph "StaticGraph" concept
- /// \sa concept::StaticGraph.
+ /// the \ref concept::Graph "Graph" concept
+ /// \sa concept::Graph.
///
/// \sa FullGraphBase
/// \sa FullUGraph
Modified: hugo/trunk/lemon/graph_adaptor.h
==============================================================================
--- hugo/trunk/lemon/graph_adaptor.h (original)
+++ hugo/trunk/lemon/graph_adaptor.h Wed Jun 28 17:06:24 2006
@@ -2424,7 +2424,7 @@
/// The full code can be found in the \ref disjoint_paths_demo.cc demo file.
///
/// This graph adaptor is fully conform to the
- /// \ref concept::StaticGraph "StaticGraph" concept and
+ /// \ref concept::Graph "Graph" concept and
/// contains some additional member functions and types. The
/// documentation of some member functions may be found just in the
/// SplitGraphAdaptorBase class.
Modified: hugo/trunk/lemon/hypercube_graph.h
==============================================================================
--- hugo/trunk/lemon/hypercube_graph.h (original)
+++ hugo/trunk/lemon/hypercube_graph.h Wed Jun 28 17:06:24 2006
@@ -249,7 +249,7 @@
/// reasons. This way the maximal dimension of this implementation
/// is 26.
///
- /// The graph type is fully conform to the \ref concept::StaticGraph
+ /// The graph type is fully conform to the \ref concept::Graph
/// concept but it does not conform to the \ref concept::UGraph.
///
/// \see HyperCubeGraphBase
Modified: hugo/trunk/lemon/johnson.h
==============================================================================
--- hugo/trunk/lemon/johnson.h (original)
+++ hugo/trunk/lemon/johnson.h Wed Jun 28 17:06:24 2006
@@ -206,7 +206,7 @@
/// edges. It is read once for each edge, so the map may involve in
/// relatively time consuming process to compute the edge length if
/// it is necessary. The default map type is \ref
- /// concept::StaticGraph::EdgeMap "Graph::EdgeMap<int>". The value
+ /// concept::Graph::EdgeMap "Graph::EdgeMap<int>". The value
/// of _LengthMap is not used directly by Johnson, it is only passed
/// to \ref JohnsonDefaultTraits. \param _Traits Traits class to set
/// various data types used by the algorithm. The default traits
Modified: hugo/trunk/lemon/kruskal.h
==============================================================================
--- hugo/trunk/lemon/kruskal.h (original)
+++ hugo/trunk/lemon/kruskal.h Wed Jun 28 17:06:24 2006
@@ -44,7 +44,7 @@
/// Due to hard C++ hacking, it accepts various input and output types.
///
/// \param g The graph the algorithm runs on.
- /// It can be either \ref concept::StaticGraph "directed" or
+ /// It can be either \ref concept::Graph "directed" or
/// \ref concept::UGraph "undirected".
/// If the graph is directed, the algorithm consider it to be
/// undirected by disregarding the direction of the edges.
Modified: hugo/trunk/lemon/list_graph.h
==============================================================================
--- hugo/trunk/lemon/list_graph.h (original)
+++ hugo/trunk/lemon/list_graph.h Wed Jun 28 17:06:24 2006
@@ -274,7 +274,7 @@
}
protected:
- void _changeTarget(Edge e, Node n)
+ void changeTarget(Edge e, Node n)
{
if(edges[e.id].next_in != -1)
edges[edges[e.id].next_in].prev_in = edges[e.id].prev_in;
@@ -289,7 +289,7 @@
edges[e.id].next_in = nodes[n.id].first_in;
nodes[n.id].first_in = e.id;
}
- void _changeSource(Edge e, Node n)
+ void changeSource(Edge e, Node n)
{
if(edges[e.id].next_out != -1)
edges[edges[e.id].next_out].prev_out = edges[e.id].prev_out;
@@ -316,16 +316,32 @@
///This is a simple and fast erasable graph implementation.
///
- ///It conforms to the
- ///\ref concept::ErasableGraph "ErasableGraph" concept and
- ///it also provides several additional useful extra functionalities.
- ///\sa concept::ErasableGraph.
+ ///It conforms to the \ref concept::Graph "Graph" concept and it
+ ///also provides several additional useful extra functionalities.
+ ///The most of the member functions and nested classes are
+ ///documented only in the concept class.
+ ///\sa concept::Graph.
class ListGraph : public ExtendedListGraphBase {
public:
typedef ExtendedListGraphBase Parent;
+ ///Add a new node to the graph.
+
+ /// \return the new node.
+ ///
+ Node addNode() { return Parent::addNode(); }
+
+ ///Add a new edge to the graph.
+
+ ///Add a new edge to the graph with source node \c s
+ ///and target node \c t.
+ ///\return the new edge.
+ Edge addEdge(const Node& s, const Node& t) {
+ return Parent::addEdge(s, t);
+ }
+
/// Changes the target of \c e to \c n
/// Changes the target of \c e to \c n
@@ -334,7 +350,7 @@
///referencing the changed edge remain
///valid. However <tt>InEdge</tt>s are invalidated.
void changeTarget(Edge e, Node n) {
- _changeTarget(e,n);
+ Parent::changeTarget(e,n);
}
/// Changes the source of \c e to \c n
@@ -344,7 +360,7 @@
///referencing the changed edge remain
///valid. However <tt>OutEdge</tt>s are invalidated.
void changeSource(Edge e, Node n) {
- _changeSource(e,n);
+ Parent::changeSource(e,n);
}
/// Invert the direction of an edge.
@@ -354,12 +370,12 @@
///valid. However <tt>OutEdge</tt>s and <tt>InEdge</tt>s are invalidated.
void reverseEdge(Edge e) {
Node t=target(e);
- _changeTarget(e,source(e));
- _changeSource(e,t);
+ changeTarget(e,source(e));
+ changeSource(e,t);
}
- ///Using this it is possible to avoid the superfluous memory
- ///allocation.
+ /// \brief Using this it is possible to avoid the superfluous memory
+ /// allocation.
///Using this it is possible to avoid the superfluous memory
///allocation: if you know that the graph you want to build will
@@ -367,8 +383,8 @@
///space for this amount before starting to build the graph.
void reserveNode(int n) { nodes.reserve(n); };
- ///Using this it is possible to avoid the superfluous memory
- ///allocation.
+ /// \brief Using this it is possible to avoid the superfluous memory
+ /// allocation.
///Using this it is possible to avoid the superfluous memory
///allocation: see the \ref reserveNode function.
@@ -598,6 +614,20 @@
class ListUGraph : public ExtendedListUGraphBase {
public:
typedef ExtendedListUGraphBase Parent;
+ /// \brief Add a new node to the graph.
+ ///
+ /// \return the new node.
+ ///
+ Node addNode() { return Parent::addNode(); }
+
+ /// \brief Add a new edge to the graph.
+ ///
+ /// Add a new edge to the graph with source node \c s
+ /// and target node \c t.
+ /// \return the new undirected edge.
+ UEdge addEdge(const Node& s, const Node& t) {
+ return Parent::addEdge(s, t);
+ }
/// \brief Changes the target of \c e to \c n
///
/// Changes the target of \c e to \c n
@@ -606,7 +636,7 @@
/// referencing the changed edge remain
/// valid. However <tt>InEdge</tt>'s are invalidated.
void changeTarget(UEdge e, Node n) {
- _changeTarget(e,n);
+ Parent::changeTarget(e,n);
}
/// Changes the source of \c e to \c n
///
@@ -616,7 +646,7 @@
///referencing the changed edge remain
///valid. However <tt>OutEdge</tt>'s are invalidated.
void changeSource(UEdge e, Node n) {
- _changeSource(e,n);
+ Parent::changeSource(e,n);
}
/// \brief Contract two nodes.
///
Modified: hugo/trunk/lemon/min_cost_arborescence.h
==============================================================================
--- hugo/trunk/lemon/min_cost_arborescence.h (original)
+++ hugo/trunk/lemon/min_cost_arborescence.h Wed Jun 28 17:06:24 2006
@@ -110,7 +110,7 @@
/// edges. It is read once for each edge, so the map may involve in
/// relatively time consuming process to compute the edge cost if
/// it is necessary. The default map type is \ref
- /// concept::StaticGraph::EdgeMap "Graph::EdgeMap<int>". The value
+ /// concept::Graph::EdgeMap "Graph::EdgeMap<int>". The value
/// of _CostMap is not used directly by MinCostArborescence,
/// it is only passed to \ref MinCostArborescenceDefaultTraits.
/// \param _Traits Traits class to set various data types used
Modified: hugo/trunk/lemon/min_cut.h
==============================================================================
--- hugo/trunk/lemon/min_cut.h (original)
+++ hugo/trunk/lemon/min_cut.h Wed Jun 28 17:06:24 2006
@@ -179,7 +179,7 @@
/// the edges. It is read once for each edge, so the map may involve in
/// relatively time consuming process to compute the edge capacity if
/// it is necessary. The default map type is \ref
- /// concept::StaticGraph::EdgeMap "Graph::EdgeMap<int>". The value
+ /// concept::Graph::EdgeMap "Graph::EdgeMap<int>". The value
/// of CapacityMap is not used directly by search algorithm, it is only
/// passed to \ref MaxCardinalitySearchDefaultTraits.
/// \param _Traits Traits class to set various data types used by the
@@ -701,7 +701,7 @@
/// The graph type the algorithm runs on.
typedef _Graph Graph;
- /// The AuxGraph type which is an ErasableGraph
+ /// The AuxGraph type which is an Graph
typedef ListUGraph AuxGraph;
/// \brief Instantiates a AuxGraph.
Modified: hugo/trunk/lemon/smart_graph.h
==============================================================================
--- hugo/trunk/lemon/smart_graph.h (original)
+++ hugo/trunk/lemon/smart_graph.h Wed Jun 28 17:06:24 2006
@@ -239,8 +239,8 @@
///that <b> it does support only limited (only stack-like)
///node and edge deletions</b>.
///It conforms to
- ///the \ref concept::ExtendableGraph "ExtendableGraph" concept.
- ///\sa concept::ExtendableGraph.
+ ///the \ref concept::Graph "Graph" concept.
+ ///\sa concept::Graph.
///
///\author Alpar Juttner
class SmartGraph : public ExtendedSmartGraphBase {
Modified: hugo/trunk/lemon/topology.h
==============================================================================
--- hugo/trunk/lemon/topology.h (original)
+++ hugo/trunk/lemon/topology.h Wed Jun 28 17:06:24 2006
@@ -244,7 +244,7 @@
/// \note By definition, the empty graph is strongly connected.
template <typename Graph>
bool stronglyConnected(const Graph& graph) {
- checkConcept<concept::StaticGraph, Graph>();
+ checkConcept<concept::Graph, Graph>();
typedef typename Graph::Node Node;
typedef typename Graph::NodeIt NodeIt;
@@ -302,7 +302,7 @@
/// strongly connected components.
template <typename Graph>
int countStronglyConnectedComponents(const Graph& graph) {
- checkConcept<concept::StaticGraph, Graph>();
+ checkConcept<concept::Graph, Graph>();
using namespace _topology_bits;
@@ -371,7 +371,7 @@
///
template <typename Graph, typename NodeMap>
int stronglyConnectedComponents(const Graph& graph, NodeMap& compMap) {
- checkConcept<concept::StaticGraph, Graph>();
+ checkConcept<concept::Graph, Graph>();
typedef typename Graph::Node Node;
typedef typename Graph::NodeIt NodeIt;
checkConcept<concept::WriteMap<Node, int>, NodeMap>();
@@ -434,7 +434,7 @@
/// \return The number of cut edges
template <typename Graph, typename EdgeMap>
int stronglyConnectedCutEdges(const Graph& graph, EdgeMap& cutMap) {
- checkConcept<concept::StaticGraph, Graph>();
+ checkConcept<concept::Graph, Graph>();
typedef typename Graph::Node Node;
typedef typename Graph::Edge Edge;
typedef typename Graph::NodeIt NodeIt;
@@ -1205,7 +1205,7 @@
void topologicalSort(const Graph& graph, NodeMap& order) {
using namespace _topology_bits;
- checkConcept<concept::StaticGraph, Graph>();
+ checkConcept<concept::Graph, Graph>();
checkConcept<concept::WriteMap<typename Graph::Node, int>, NodeMap>();
typedef typename Graph::Node Node;
@@ -1247,7 +1247,7 @@
bool checkedTopologicalSort(const Graph& graph, NodeMap& order) {
using namespace _topology_bits;
- checkConcept<concept::StaticGraph, Graph>();
+ checkConcept<concept::Graph, Graph>();
checkConcept<concept::ReadWriteMap<typename Graph::Node, int>, NodeMap>();
typedef typename Graph::Node Node;
@@ -1290,7 +1290,7 @@
template <typename Graph>
bool dag(const Graph& graph) {
- checkConcept<concept::StaticGraph, Graph>();
+ checkConcept<concept::Graph, Graph>();
typedef typename Graph::Node Node;
typedef typename Graph::NodeIt NodeIt;
Modified: hugo/trunk/test/bfs_test.cc
==============================================================================
--- hugo/trunk/test/bfs_test.cc (original)
+++ hugo/trunk/test/bfs_test.cc Wed Jun 28 17:06:24 2006
@@ -29,7 +29,7 @@
void check_Bfs_Compile()
{
- typedef concept::StaticGraph Graph;
+ typedef concept::Graph Graph;
typedef Graph::Edge Edge;
typedef Graph::Node Node;
@@ -66,7 +66,7 @@
void check_Bfs_Function_Compile()
{
typedef int VType;
- typedef concept::StaticGraph Graph;
+ typedef concept::Graph Graph;
typedef Graph::Edge Edge;
typedef Graph::Node Node;
Modified: hugo/trunk/test/dfs_test.cc
==============================================================================
--- hugo/trunk/test/dfs_test.cc (original)
+++ hugo/trunk/test/dfs_test.cc Wed Jun 28 17:06:24 2006
@@ -29,7 +29,7 @@
void check_Dfs_SmartGraph_Compile()
{
- typedef concept::StaticGraph Graph;
+ typedef concept::Graph Graph;
typedef Graph::Edge Edge;
typedef Graph::Node Node;
@@ -67,7 +67,7 @@
void check_Dfs_Function_Compile()
{
typedef int VType;
- typedef concept::StaticGraph Graph;
+ typedef concept::Graph Graph;
typedef Graph::Edge Edge;
typedef Graph::Node Node;
Modified: hugo/trunk/test/dijkstra_test.cc
==============================================================================
--- hugo/trunk/test/dijkstra_test.cc (original)
+++ hugo/trunk/test/dijkstra_test.cc Wed Jun 28 17:06:24 2006
@@ -31,7 +31,7 @@
void check_Dijkstra_BinHeap_Compile()
{
typedef int VType;
- typedef concept::StaticGraph Graph;
+ typedef concept::Graph Graph;
typedef Graph::Edge Edge;
typedef Graph::Node Node;
@@ -70,7 +70,7 @@
void check_Dijkstra_Function_Compile()
{
typedef int VType;
- typedef concept::StaticGraph Graph;
+ typedef concept::Graph Graph;
typedef Graph::Edge Edge;
typedef Graph::Node Node;
Modified: hugo/trunk/test/edge_set_test.cc
==============================================================================
--- hugo/trunk/test/edge_set_test.cc (original)
+++ hugo/trunk/test/edge_set_test.cc Wed Jun 28 17:06:24 2006
@@ -17,14 +17,14 @@
using namespace lemon;
using namespace lemon::concept;
-typedef SmartGraph Graph;
+typedef SmartGraph RGraph;
int main() {
{ // checking edge_sets
- checkConcept<StaticGraph, ListEdgeSet<Graph> >();
- checkConcept<UGraph, ListUEdgeSet<Graph> >();
- checkConcept<StaticGraph, SmartEdgeSet<Graph> >();
- checkConcept<UGraph, SmartUEdgeSet<Graph> >();
+ checkConcept<Graph, ListEdgeSet<RGraph> >();
+ checkConcept<UGraph, ListUEdgeSet<RGraph> >();
+ checkConcept<Graph, SmartEdgeSet<RGraph> >();
+ checkConcept<UGraph, SmartUEdgeSet<RGraph> >();
}
std::cout << __FILE__ ": All tests passed.\n";
Modified: hugo/trunk/test/graph_adaptor_test.cc
==============================================================================
--- hugo/trunk/test/graph_adaptor_test.cc (original)
+++ hugo/trunk/test/graph_adaptor_test.cc Wed Jun 28 17:06:24 2006
@@ -46,22 +46,22 @@
int main()
{
{
- typedef StaticGraph Graph;
- checkConcept<StaticGraph, GraphAdaptor<Graph> >();
+ typedef Graph Graph;
+ checkConcept<Graph, GraphAdaptor<Graph> >();
- checkConcept<StaticGraph, RevGraphAdaptor<Graph> >();
+ checkConcept<Graph, RevGraphAdaptor<Graph> >();
- checkConcept<StaticGraph, SubGraphAdaptor<Graph,
+ checkConcept<Graph, SubGraphAdaptor<Graph,
Graph::NodeMap<bool> , Graph::EdgeMap<bool> > >();
- checkConcept<StaticGraph, NodeSubGraphAdaptor<Graph,
+ checkConcept<Graph, NodeSubGraphAdaptor<Graph,
Graph::NodeMap<bool> > >();
- checkConcept<StaticGraph, EdgeSubGraphAdaptor<Graph,
+ checkConcept<Graph, EdgeSubGraphAdaptor<Graph,
Graph::EdgeMap<bool> > >();
- checkConcept<StaticGraph, ResGraphAdaptor<Graph, int,
+ checkConcept<Graph, ResGraphAdaptor<Graph, int,
Graph::EdgeMap<int>, Graph::EdgeMap<int> > >();
- checkConcept<StaticGraph, ErasingFirstGraphAdaptor<Graph,
+ checkConcept<Graph, ErasingFirstGraphAdaptor<Graph,
Graph::NodeMap<Graph::Edge> > >();
checkConcept<UGraph, UndirGraphAdaptor<Graph> >();
@@ -73,7 +73,7 @@
checkConcept<UGraph, EdgeSubUGraphAdaptor<UGraph,
UGraph::UEdgeMap<bool> > >();
- checkConcept<StaticGraph, DirUGraphAdaptor<UGraph,
+ checkConcept<Graph, DirUGraphAdaptor<UGraph,
UGraph::UEdgeMap<bool> > >();
}
std::cout << __FILE__ ": All tests passed.\n";
Modified: hugo/trunk/test/graph_factory_test.cc
==============================================================================
--- hugo/trunk/test/graph_factory_test.cc (original)
+++ hugo/trunk/test/graph_factory_test.cc Wed Jun 28 17:06:24 2006
@@ -70,20 +70,20 @@
}
//Compile Graph
-template void lemon::concept::checkCompileStaticGraph<concept::StaticGraph>
-(concept::StaticGraph &);
+template void lemon::concept::checkCompileGraph<concept::Graph>
+(concept::Graph &);
template
-void lemon::concept::checkCompileExtendableGraph<concept::ExtendableGraph>
-(concept::ExtendableGraph &);
+void lemon::concept::checkCompileGraph<concept::Graph>
+(concept::Graph &);
template
-void lemon::concept::checkCompileErasableGraph<concept::ErasableGraph>
-(concept::ErasableGraph &);
+void lemon::concept::checkCompileGraph<concept::Graph>
+(concept::Graph &);
//Compile SmartGraph
template
-void lemon::concept::checkCompileExtendableGraph<SmartGraph>(SmartGraph &);
+void lemon::concept::checkCompileGraph<SmartGraph>(SmartGraph &);
template
void lemon::concept::checkCompileGraphFindEdge<SmartGraph>(SmartGraph &);
@@ -93,20 +93,20 @@
//Compile ListGraph
template
-void lemon::concept::checkCompileExtendableGraph<ListGraph>(ListGraph &);
+void lemon::concept::checkCompileGraph<ListGraph>(ListGraph &);
template
-void lemon::concept::checkCompileErasableGraph<ListGraph>(ListGraph &);
+void lemon::concept::checkCompileGraph<ListGraph>(ListGraph &);
template
void lemon::concept::checkCompileGraphFindEdge<ListGraph>(ListGraph &);
//Compile SymListGraph
//template void hugo::checkCompileGraph<SymListGraph>(SymListGraph &);
-//template void hugo::checkCompileErasableGraph<SymListGraph>(SymListGraph &);
+//template void hugo::checkCompileGraph<SymListGraph>(SymListGraph &);
//template void hugo::checkCompileGraphFindEdge<SymListGraph>(SymListGraph &);
//Compile FullGraph
-template void lemon::concept::checkCompileStaticGraph<FullGraph>(FullGraph &);
+template void lemon::concept::checkCompileGraph<FullGraph>(FullGraph &);
template
void lemon::concept::checkCompileGraphFindEdge<FullGraph>(FullGraph &);
Modified: hugo/trunk/test/graph_test.cc
==============================================================================
--- hugo/trunk/test/graph_test.cc (original)
+++ hugo/trunk/test/graph_test.cc Wed Jun 28 17:06:24 2006
@@ -43,41 +43,33 @@
checkConcept<IDableGraphComponent, IDableGraphComponent >();
checkConcept<MaxIDableGraphComponent, MaxIDableGraphComponent >();
- checkConcept<BaseExtendableGraphComponent, BaseExtendableGraphComponent >();
- checkConcept<BaseErasableGraphComponent, BaseErasableGraphComponent >();
-
checkConcept<IterableGraphComponent, IterableGraphComponent >();
checkConcept<MappableGraphComponent, MappableGraphComponent >();
- checkConcept<ExtendableGraphComponent, ExtendableGraphComponent >();
- checkConcept<ErasableGraphComponent, ErasableGraphComponent >();
- checkConcept<ClearableGraphComponent, ClearableGraphComponent >();
}
{ // checking skeleton graphs
- checkConcept<StaticGraph, StaticGraph >();
- checkConcept<ExtendableGraph, ExtendableGraph >();
- checkConcept<ErasableGraph, ErasableGraph >();
+ checkConcept<Graph, Graph >();
}
{ // checking list graph
- checkConcept<ErasableGraph, ListGraph >();
+ checkConcept<Graph, ListGraph >();
checkGraph<ListGraph>();
checkGraphNodeMap<ListGraph>();
checkGraphEdgeMap<ListGraph>();
}
{ // checking smart graph
- checkConcept<ExtendableGraph, SmartGraph >();
+ checkConcept<Graph, SmartGraph >();
checkGraph<SmartGraph>();
checkGraphNodeMap<SmartGraph>();
checkGraphEdgeMap<SmartGraph>();
}
{ // checking full graph
- checkConcept<StaticGraph, FullGraph >();
+ checkConcept<Graph, FullGraph >();
}
{ // checking full graph
- checkConcept<StaticGraph, HyperCubeGraph >();
+ checkConcept<Graph, HyperCubeGraph >();
}
std::cout << __FILE__ ": All tests passed.\n";
Modified: hugo/trunk/test/kruskal_test.cc
==============================================================================
--- hugo/trunk/test/kruskal_test.cc (original)
+++ hugo/trunk/test/kruskal_test.cc Wed Jun 28 17:06:24 2006
@@ -32,10 +32,10 @@
void checkCompileKruskal()
{
- concept::WriteMap<concept::StaticGraph::Edge,bool> w;
+ concept::WriteMap<concept::Graph::Edge,bool> w;
- kruskal(concept::StaticGraph(),
- concept::ReadMap<concept::StaticGraph::Edge,int>(),
+ kruskal(concept::Graph(),
+ concept::ReadMap<concept::Graph::Edge,int>(),
w);
}
Modified: hugo/trunk/test/preflow_test.cc
==============================================================================
--- hugo/trunk/test/preflow_test.cc (original)
+++ hugo/trunk/test/preflow_test.cc Wed Jun 28 17:06:24 2006
@@ -31,7 +31,7 @@
void check_Preflow()
{
typedef int VType;
- typedef concept::StaticGraph Graph;
+ typedef concept::Graph Graph;
typedef Graph::Node Node;
typedef Graph::Edge Edge;
Modified: hugo/trunk/test/ugraph_test.cc
==============================================================================
--- hugo/trunk/test/ugraph_test.cc (original)
+++ hugo/trunk/test/ugraph_test.cc Wed Jun 28 17:06:24 2006
@@ -33,10 +33,8 @@
void check_concepts() {
checkConcept<UGraph, ListUGraph>();
- checkConcept<ErasableUGraph, ListUGraph>();
checkConcept<UGraph, SmartUGraph>();
- checkConcept<ExtendableUGraph, SmartUGraph>();
checkConcept<UGraph, FullUGraph>();
More information about the Lemon-commits
mailing list