[Lemon-commits] [lemon_svn] alpar: r1863 - in hugo/trunk: doc src/demo src/lemon src/lemon/bits src/test
Lemon SVN
svn at lemon.cs.elte.hu
Mon Nov 6 20:48:17 CET 2006
Author: alpar
Date: Wed May 4 15:07:10 2005
New Revision: 1863
Added:
hugo/trunk/doc/graph-adaptors.dox
- copied, changed from r1862, /hugo/trunk/doc/gwrappers.dox
hugo/trunk/src/demo/sub_graph_adaptor_demo.cc
- copied, changed from r1862, /hugo/trunk/src/demo/sub_graph_wrapper_demo.cc
hugo/trunk/src/demo/sub_graph_adaptor_demo.dim
- copied unchanged from r1862, /hugo/trunk/src/demo/sub_graph_wrapper_demo.dim
hugo/trunk/src/lemon/graph_adaptor.h
- copied, changed from r1862, /hugo/trunk/src/lemon/graph_wrapper.h
hugo/trunk/src/test/graph_adaptor_test.cc
- copied, changed from r1862, /hugo/trunk/src/test/graph_wrapper_test.cc
Removed:
hugo/trunk/doc/gwrappers.dox
hugo/trunk/src/demo/sub_graph_wrapper_demo.cc
hugo/trunk/src/demo/sub_graph_wrapper_demo.dim
hugo/trunk/src/lemon/graph_wrapper.h
hugo/trunk/src/test/graph_wrapper_test.cc
Modified:
hugo/trunk/doc/Makefile.am
hugo/trunk/doc/groups.dox
hugo/trunk/src/demo/Makefile.am
hugo/trunk/src/lemon/Makefile.am
hugo/trunk/src/lemon/bits/undir_graph_extender.h
hugo/trunk/src/lemon/min_cost_flow.h
hugo/trunk/src/test/Makefile.am
Log:
wrapper -> adaptor
Modified: hugo/trunk/doc/Makefile.am
==============================================================================
--- hugo/trunk/doc/Makefile.am (original)
+++ hugo/trunk/doc/Makefile.am Wed May 4 15:07:10 2005
@@ -8,7 +8,7 @@
EXTRA_DIST = html mainpage.dox getstart.dox quicktour.dox \
demoprograms.dox graphs.dox undir_graphs.dox named-param.dox \
maps.dox coding_style.dox groups.dox namespaces.dox license.dox \
- developers_interface.dox graph_io.dox dirs.dox gwrappers.dox
+ developers_interface.dox graph_io.dox dirs.dox graph-adaptors.dox
## all-local: html/index.html
Copied: hugo/trunk/doc/graph-adaptors.dox (from r1862, /hugo/trunk/doc/gwrappers.dox)
==============================================================================
--- /hugo/trunk/doc/gwrappers.dox (original)
+++ hugo/trunk/doc/graph-adaptors.dox Wed May 4 15:07:10 2005
@@ -1,13 +1,13 @@
/**
- @defgroup gwrappers Wrapper Classes for Graphs
- \brief This group contains several wrapper classes for graphs
+ @defgroup graph_adaptors Adaptor Classes for Graphs
+ \brief This group contains several adaptor classes for graphs
@ingroup graphs
The main parts of LEMON are the different graph structures,
generic graph algorithms, graph concepts which couple these, and
- graph wrappers. While the previous notions are more or less clear, the
+ graph adaptors. While the previous notions are more or less clear, the
latter one needs further explanation.
- Graph wrappers are graph classes which serve for considering graph
+ Graph adaptors are graph classes which serve for considering graph
structures in different ways.
A short example makes this much
@@ -18,62 +18,62 @@
is needed to run on the reversed oriented graph.
It may be expensive (in time or in memory usage) to copy
\c g with the reversed orientation.
- In this case, a wrapper class is used, which
+ In this case, an adaptor class is used, which
(according to LEMON graph concepts) works as a graph.
- The wrapper uses
+ The adaptor uses
the original graph structure and graph operations when methods of the
reversed oriented graph are called.
- This means that the wrapper have minor memory usage,
+ This means that the adaptor have minor memory usage,
and do not perform sophisticated algorithmic actions.
The purpose of it is to give a tool for the cases when
a graph have to be used in a specific alteration.
If this alteration is obtained by a usual construction
like filtering the edge-set or considering a new orientation, then
- a wrapper is worthwhile to use.
+ an adaptor is worthwhile to use.
To come back to the reversed oriented graph, in this situation
- \code template<typename Graph> class RevGraphWrapper; \endcode
+ \code template<typename Graph> class RevGraphAdaptor; \endcode
template class can be used.
The code looks as follows
\code
ListGraph g;
- RevGraphWrapper<ListGraph> rgw(g);
+ RevGraphAdaptor<ListGraph> rgw(g);
int result=algorithm(rgw);
\endcode
After running the algorithm, the original graph \c g
is untouched.
This techniques gives rise to an elegant code, and
- based on stable graph wrappers, complex algorithms can be
+ based on stable graph adaptors, complex algorithms can be
implemented easily.
In flow, circulation and bipartite matching problems, the residual
- graph is of particular importance. Combining a wrapper implementing
+ graph is of particular importance. Combining an adaptor implementing
this, shortest path algorithms and minimum mean cycle algorithms,
a range of weighted and cardinality optimization algorithms can be
obtained.
For other examples,
the interested user is referred to the detailed documentation of
- particular wrappers.
+ particular adaptors.
- The behavior of graph wrappers can be very different. Some of them keep
+ The behavior of graph adaptors can be very different. Some of them keep
capabilities of the original graph while in other cases this would be
meaningless. This means that the concepts that they are models of depend
- on the graph wrapper, and the wrapped graph(s).
+ on the graph adaptor, and the wrapped graph(s).
If an edge of \c rgw is deleted, this is carried out by
- deleting the corresponding edge of \c g, thus the wrapper modifies the
+ deleting the corresponding edge of \c g, thus the adaptor modifies the
original graph.
But for a residual
graph, this operation has no sense.
Let us stand one more example here to simplify your work.
- RevGraphWrapper has constructor
+ RevGraphAdaptor has constructor
\code
- RevGraphWrapper(Graph& _g);
+ RevGraphAdaptor(Graph& _g);
\endcode
This means that in a situation,
when a <tt> const ListGraph& </tt> reference to a graph is given,
then it have to be instantiated with <tt>Graph=const ListGraph</tt>.
\code
int algorithm1(const ListGraph& g) {
- RevGraphWrapper<const ListGraph> rgw(g);
+ RevGraphAdaptor<const ListGraph> rgw(g);
return algorithm2(rgw);
}
\endcode
Modified: hugo/trunk/doc/groups.dox
==============================================================================
--- hugo/trunk/doc/groups.dox (original)
+++ hugo/trunk/doc/groups.dox Wed May 4 15:07:10 2005
@@ -31,7 +31,7 @@
the residual graph can be accessed by an other algorithm, or a node-set
is to be shrunk for an other algorithm.
LEMON also provides a variety of graphs for these requirements called
-\ref gwrappers "graph wrappers". Wrappers cannot be used alone but only
+\ref graph_adaptors "graph adaptors". Adaptors cannot be used alone but only
in conjunction with other graph representation.
You are free to use the graph structure that fit your requirements
Modified: hugo/trunk/src/demo/Makefile.am
==============================================================================
--- hugo/trunk/src/demo/Makefile.am (original)
+++ hugo/trunk/src/demo/Makefile.am Wed May 4 15:07:10 2005
@@ -1,14 +1,14 @@
AM_CPPFLAGS = -I$(top_srcdir)/src
LDADD = $(top_builddir)/src/lemon/libemon.la
-EXTRA_DIST = sub_graph_wrapper_demo.dim
+EXTRA_DIST = sub_graph_adaptor_demo.dim
noinst_PROGRAMS = \
dim_to_dot \
dim_to_lgf \
graph_to_eps_demo \
min_route \
- sub_graph_wrapper_demo
+ sub_graph_adaptor_demo
if HAVE_GLPK
noinst_PROGRAMS += lp_demo lp_maxflow_demo
@@ -27,8 +27,8 @@
min_route_SOURCES = min_route.cc
-sub_graph_wrapper_demo_SOURCES = \
- sub_graph_wrapper_demo.cc \
+sub_graph_adaptor_demo_SOURCES = \
+ sub_graph_adaptor_demo.cc \
tight_edge_filter_map.h
lp_demo_SOURCES = lp_demo.cc
Copied: hugo/trunk/src/demo/sub_graph_adaptor_demo.cc (from r1862, /hugo/trunk/src/demo/sub_graph_wrapper_demo.cc)
==============================================================================
--- /hugo/trunk/src/demo/sub_graph_wrapper_demo.cc (original)
+++ hugo/trunk/src/demo/sub_graph_adaptor_demo.cc Wed May 4 15:07:10 2005
@@ -1,7 +1,7 @@
// -*- c++ -*-
// Use a DIMACS max flow file as stdin.
-// sub_graph_wrapper_demo < dimacs_max_flow_file
+// sub_graph_adaptor_demo < dimacs_max_flow_file
// This program computes a maximum number of edge-disjoint shortest paths
// between s and t.
@@ -11,7 +11,7 @@
#include <lemon/smart_graph.h>
#include <lemon/dijkstra.h>
#include <lemon/maps.h>
-#include <lemon/graph_wrapper.h>
+#include <lemon/graph_adaptor.h>
#include <lemon/dimacs.h>
#include <lemon/preflow.h>
#include <tight_edge_filter_map.h>
@@ -57,8 +57,8 @@
// ConstMap<Node, bool> const_true_map(true);
// This graph contains exaclty the tight edges.
-// typedef SubGraphWrapper<Graph, ConstMap<Node, bool>, TightEdgeFilter> SubGW;
- typedef EdgeSubGraphWrapper<Graph, TightEdgeFilter> SubGW;
+// typedef SubGraphAdaptor<Graph, ConstMap<Node, bool>, TightEdgeFilter> SubGW;
+ typedef EdgeSubGraphAdaptor<Graph, TightEdgeFilter> SubGW;
SubGW gw(g, tight_edge_filter);
ConstMap<Edge, int> const_1_map(1);
Modified: hugo/trunk/src/lemon/Makefile.am
==============================================================================
--- hugo/trunk/src/lemon/Makefile.am (original)
+++ hugo/trunk/src/lemon/Makefile.am Wed May 4 15:07:10 2005
@@ -29,7 +29,7 @@
error.h \
fib_heap.h \
full_graph.h \
- graph_wrapper.h \
+ graph_adaptor.h \
graph_utils.h \
graph_to_eps.h \
invalid.h \
Modified: hugo/trunk/src/lemon/bits/undir_graph_extender.h
==============================================================================
--- hugo/trunk/src/lemon/bits/undir_graph_extender.h (original)
+++ hugo/trunk/src/lemon/bits/undir_graph_extender.h Wed May 4 15:07:10 2005
@@ -38,7 +38,7 @@
friend class UndirGraphExtender;
protected:
- // FIXME: Marci use opposite logic in his graph wrappers. It would
+ // FIXME: Marci use opposite logic in his graph adaptors. It would
// be reasonable to syncronize...
bool forward;
Copied: hugo/trunk/src/lemon/graph_adaptor.h (from r1862, /hugo/trunk/src/lemon/graph_wrapper.h)
==============================================================================
--- /hugo/trunk/src/lemon/graph_wrapper.h (original)
+++ hugo/trunk/src/lemon/graph_adaptor.h Wed May 4 15:07:10 2005
@@ -1,5 +1,5 @@
/* -*- C++ -*-
- * src/lemon/graph_wrapper.h - Part of LEMON, a generic C++ optimization library
+ * src/lemon/graph_adaptor.h - Part of LEMON, a generic C++ optimization library
*
* Copyright (C) 2005 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
* (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -14,14 +14,14 @@
*
*/
-#ifndef LEMON_GRAPH_WRAPPER_H
-#define LEMON_GRAPH_WRAPPER_H
+#ifndef LEMON_GRAPH_ADAPTOR_H
+#define LEMON_GRAPH_ADAPTOR_H
-///\ingroup gwrappers
+///\ingroup graph_adaptors
///\file
-///\brief Several graph wrappers.
+///\brief Several graph adaptors.
///
-///This file contains several useful graph wrapper functions.
+///This file contains several useful graph adaptor functions.
///
///\author Marton Makai
@@ -33,31 +33,31 @@
namespace lemon {
- // Graph wrappers
+ // Graph adaptors
/*!
- \addtogroup gwrappers
+ \addtogroup graph_adaptors
@{
*/
/*!
- Base type for the Graph Wrappers
+ Base type for the Graph Adaptors
- \warning Graph wrappers 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 is the base type for most of LEMON graph wrappers.
- This class implements a trivial graph wrapper i.e. it only wraps the
+ This is the base type for most of LEMON graph adaptors.
+ This class implements a trivial graph adaptor i.e. it only wraps the
functions and types of the graph. The purpose of this class is to
- make easier implementing graph wrappers. E.g. if a wrapper is
+ make easier implementing graph adaptors. E.g. if an adaptor is
considered which differs from the wrapped graph only in some of its
- functions or types, then it can be derived from GraphWrapper, and only the
+ functions or types, then it can be derived from GraphAdaptor, and only the
differences should be implemented.
\author Marton Makai
*/
template<typename _Graph>
- class GraphWrapperBase {
+ class GraphAdaptorBase {
public:
typedef _Graph Graph;
/// \todo Is it needed?
@@ -66,11 +66,11 @@
protected:
Graph* graph;
- GraphWrapperBase() : graph(0) { }
+ GraphAdaptorBase() : graph(0) { }
void setGraph(Graph& _graph) { graph=&_graph; }
public:
- GraphWrapperBase(Graph& _graph) : graph(&_graph) { }
+ GraphAdaptorBase(Graph& _graph) : graph(&_graph) { }
typedef typename Graph::Node Node;
typedef typename Graph::Edge Edge;
@@ -112,8 +112,8 @@
class NodeMap : public _Graph::template NodeMap<_Value> {
public:
typedef typename _Graph::template NodeMap<_Value> Parent;
- NodeMap(const GraphWrapperBase<_Graph>& gw) : Parent(*gw.graph) { }
- NodeMap(const GraphWrapperBase<_Graph>& gw, const _Value& value)
+ NodeMap(const GraphAdaptorBase<_Graph>& gw) : Parent(*gw.graph) { }
+ NodeMap(const GraphAdaptorBase<_Graph>& gw, const _Value& value)
: Parent(*gw.graph, value) { }
};
@@ -121,33 +121,33 @@
class EdgeMap : public _Graph::template EdgeMap<_Value> {
public:
typedef typename _Graph::template EdgeMap<_Value> Parent;
- EdgeMap(const GraphWrapperBase<_Graph>& gw) : Parent(*gw.graph) { }
- EdgeMap(const GraphWrapperBase<_Graph>& gw, const _Value& value)
+ EdgeMap(const GraphAdaptorBase<_Graph>& gw) : Parent(*gw.graph) { }
+ EdgeMap(const GraphAdaptorBase<_Graph>& gw, const _Value& value)
: Parent(*gw.graph, value) { }
};
};
template <typename _Graph>
- class GraphWrapper :
- public IterableGraphExtender<GraphWrapperBase<_Graph> > {
+ class GraphAdaptor :
+ public IterableGraphExtender<GraphAdaptorBase<_Graph> > {
public:
typedef _Graph Graph;
- typedef IterableGraphExtender<GraphWrapperBase<_Graph> > Parent;
+ typedef IterableGraphExtender<GraphAdaptorBase<_Graph> > Parent;
protected:
- GraphWrapper() : Parent() { }
+ GraphAdaptor() : Parent() { }
public:
- GraphWrapper(Graph& _graph) { setGraph(_graph); }
+ GraphAdaptor(Graph& _graph) { setGraph(_graph); }
};
template <typename _Graph>
- class RevGraphWrapperBase : public GraphWrapperBase<_Graph> {
+ class RevGraphAdaptorBase : public GraphAdaptorBase<_Graph> {
public:
typedef _Graph Graph;
- typedef GraphWrapperBase<_Graph> Parent;
+ typedef GraphAdaptorBase<_Graph> Parent;
protected:
- RevGraphWrapperBase() : Parent() { }
+ RevGraphAdaptorBase() : Parent() { }
public:
typedef typename Parent::Node Node;
typedef typename Parent::Edge Edge;
@@ -165,9 +165,9 @@
};
- /// A graph wrapper which reverses the orientation of the edges.
+ /// A graph adaptor which reverses the orientation of the edges.
- ///\warning Graph wrappers 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.
///
/// Let \f$G=(V, A)\f$ be a directed graph and
@@ -179,38 +179,38 @@
/// For each directed edge
/// \f$e\in A\f$, let \f$\bar e\f$ denote the edge obtained by
/// reversing its orientation.
- /// Then RevGraphWrapper implements the graph structure with node-set
+ /// Then RevGraphAdaptor implements the graph structure with node-set
/// \f$V\f$ and edge-set
/// \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
- /// RevGraphWrapper<ListGraph> gw(g);
+ /// RevGraphAdaptor<ListGraph> gw(g);
/// \endcode
///\author Marton Makai
template<typename _Graph>
- class RevGraphWrapper :
- public IterableGraphExtender<RevGraphWrapperBase<_Graph> > {
+ class RevGraphAdaptor :
+ public IterableGraphExtender<RevGraphAdaptorBase<_Graph> > {
public:
typedef _Graph Graph;
typedef IterableGraphExtender<
- RevGraphWrapperBase<_Graph> > Parent;
+ RevGraphAdaptorBase<_Graph> > Parent;
protected:
- RevGraphWrapper() { }
+ RevGraphAdaptor() { }
public:
- RevGraphWrapper(_Graph& _graph) { setGraph(_graph); }
+ RevGraphAdaptor(_Graph& _graph) { setGraph(_graph); }
};
template <typename _Graph, typename NodeFilterMap, typename EdgeFilterMap>
- class SubGraphWrapperBase : public GraphWrapperBase<_Graph> {
+ class SubGraphAdaptorBase : public GraphAdaptorBase<_Graph> {
public:
typedef _Graph Graph;
- typedef GraphWrapperBase<_Graph> Parent;
+ typedef GraphAdaptorBase<_Graph> Parent;
protected:
NodeFilterMap* node_filter_map;
EdgeFilterMap* edge_filter_map;
- SubGraphWrapperBase() : Parent(),
+ SubGraphAdaptorBase() : Parent(),
node_filter_map(0), edge_filter_map(0) { }
void setNodeFilterMap(NodeFilterMap& _node_filter_map) {
@@ -221,7 +221,7 @@
}
public:
-// SubGraphWrapperBase(Graph& _graph,
+// SubGraphAdaptorBase(Graph& _graph,
// NodeFilterMap& _node_filter_map,
// EdgeFilterMap& _edge_filter_map) :
// Parent(&_graph),
@@ -314,23 +314,23 @@
};
- /*! \brief A graph wrapper for hiding nodes and edges from a graph.
+ /*! \brief A graph adaptor for hiding nodes and edges from a graph.
- \warning Graph wrappers 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.
- SubGraphWrapper shows the graph with filtered node-set and
+ SubGraphAdaptor shows the graph with filtered node-set and
edge-set.
Let \f$G=(V, A)\f$ be a directed graph
and suppose that the graph instance \c g of type ListGraph implements
\f$G\f$.
Let moreover \f$b_V\f$ and
\f$b_A\f$ be bool-valued functions resp. on the node-set and edge-set.
- SubGraphWrapper<...>::NodeIt iterates
+ SubGraphAdaptor<...>::NodeIt iterates
on the node-set \f$\{v\in V : b_V(v)=true\}\f$ and
- SubGraphWrapper<...>::EdgeIt iterates
+ SubGraphAdaptor<...>::EdgeIt iterates
on the edge-set \f$\{e\in A : b_A(e)=true\}\f$. Similarly,
- SubGraphWrapper<...>::OutEdgeIt and SubGraphWrapper<...>::InEdgeIt iterates
+ SubGraphAdaptor<...>::OutEdgeIt and SubGraphAdaptor<...>::InEdgeIt iterates
only on edges leaving and entering a specific node which have true value.
We have to note that this does not mean that an
@@ -350,7 +350,7 @@
nm.set(u, false);
Graph::EdgeMap<bool> em(g, true);
em.set(e, false);
- typedef SubGraphWrapper<Graph, Graph::NodeMap<bool>, Graph::EdgeMap<bool> > SubGW;
+ typedef SubGraphAdaptor<Graph, Graph::NodeMap<bool>, Graph::EdgeMap<bool> > SubGW;
SubGW gw(g, nm, em);
for (SubGW::NodeIt n(gw); n!=INVALID; ++n) std::cout << g.id(n) << std::endl;
std::cout << ":-)" << std::endl;
@@ -365,24 +365,24 @@
Note that \c n is of type \c SubGW::NodeIt, but it can be converted to
\c Graph::Node that is why \c g.id(n) can be applied.
- For other examples see also the documentation of NodeSubGraphWrapper and
- EdgeSubGraphWrapper.
+ For other examples see also the documentation of NodeSubGraphAdaptor and
+ EdgeSubGraphAdaptor.
\author Marton Makai
*/
template<typename _Graph, typename NodeFilterMap,
typename EdgeFilterMap>
- class SubGraphWrapper :
+ class SubGraphAdaptor :
public IterableGraphExtender<
- SubGraphWrapperBase<_Graph, NodeFilterMap, EdgeFilterMap> > {
+ SubGraphAdaptorBase<_Graph, NodeFilterMap, EdgeFilterMap> > {
public:
typedef _Graph Graph;
typedef IterableGraphExtender<
- SubGraphWrapperBase<_Graph, NodeFilterMap, EdgeFilterMap> > Parent;
+ SubGraphAdaptorBase<_Graph, NodeFilterMap, EdgeFilterMap> > Parent;
protected:
- SubGraphWrapper() { }
+ SubGraphAdaptor() { }
public:
- SubGraphWrapper(_Graph& _graph, NodeFilterMap& _node_filter_map,
+ SubGraphAdaptor(_Graph& _graph, NodeFilterMap& _node_filter_map,
EdgeFilterMap& _edge_filter_map) {
setGraph(_graph);
setNodeFilterMap(_node_filter_map);
@@ -392,28 +392,28 @@
- /*! \brief A wrapper for hiding nodes from a graph.
+ /*! \brief An adaptor for hiding nodes from a graph.
- \warning Graph wrappers 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.
- A wrapper for hiding nodes from a graph.
- This wrapper specializes SubGraphWrapper in the way that only the node-set
+ An adaptor for hiding nodes from a graph.
+ This adaptor specializes SubGraphAdaptor in the way that only the node-set
can be filtered. Note that this does not mean of considering induced
subgraph, the edge-iterators consider the original edge-set.
\author Marton Makai
*/
template<typename Graph, typename NodeFilterMap>
- class NodeSubGraphWrapper :
- public SubGraphWrapper<Graph, NodeFilterMap,
+ class NodeSubGraphAdaptor :
+ public SubGraphAdaptor<Graph, NodeFilterMap,
ConstMap<typename Graph::Edge,bool> > {
public:
- typedef SubGraphWrapper<Graph, NodeFilterMap,
+ typedef SubGraphAdaptor<Graph, NodeFilterMap,
ConstMap<typename Graph::Edge,bool> > Parent;
protected:
ConstMap<typename Graph::Edge, bool> const_true_map;
public:
- NodeSubGraphWrapper(Graph& _graph, NodeFilterMap& _node_filter_map) :
+ NodeSubGraphAdaptor(Graph& _graph, NodeFilterMap& _node_filter_map) :
Parent(), const_true_map(true) {
Parent::setGraph(_graph);
Parent::setNodeFilterMap(_node_filter_map);
@@ -422,14 +422,14 @@
};
- /*! \brief A wrapper for hiding edges from a graph.
+ /*! \brief An adaptor for hiding edges from a graph.
- \warning Graph wrappers 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.
- A wrapper for hiding edges from a graph.
- This wrapper specializes SubGraphWrapper in the way that only the edge-set
- can be filtered. The usefulness of this wrapper is demonstrated in the
+ An adaptor for hiding edges from a graph.
+ This adaptor specializes SubGraphAdaptor in the way that only the edge-set
+ can be filtered. The usefulness of this adaptor is demonstrated in the
problem of searching a maximum number of edge-disjoint shortest paths
between
two nodes \c s and \c t. Shortest here means being shortest w.r.t.
@@ -498,7 +498,7 @@
TightEdgeFilter;
TightEdgeFilter tight_edge_filter(g, dijkstra.distMap(), length);
- typedef EdgeSubGraphWrapper<Graph, TightEdgeFilter> SubGW;
+ typedef EdgeSubGraphAdaptor<Graph, TightEdgeFilter> SubGW;
SubGW gw(g, tight_edge_filter);
\endcode
Then, the maximum nimber of edge-disjoint \c s-\c t paths are computed
@@ -549,16 +549,16 @@
\author Marton Makai
*/
template<typename Graph, typename EdgeFilterMap>
- class EdgeSubGraphWrapper :
- public SubGraphWrapper<Graph, ConstMap<typename Graph::Node,bool>,
+ class EdgeSubGraphAdaptor :
+ public SubGraphAdaptor<Graph, ConstMap<typename Graph::Node,bool>,
EdgeFilterMap> {
public:
- typedef SubGraphWrapper<Graph, ConstMap<typename Graph::Node,bool>,
+ typedef SubGraphAdaptor<Graph, ConstMap<typename Graph::Node,bool>,
EdgeFilterMap> Parent;
protected:
ConstMap<typename Graph::Node, bool> const_true_map;
public:
- EdgeSubGraphWrapper(Graph& _graph, EdgeFilterMap& _edge_filter_map) :
+ EdgeSubGraphAdaptor(Graph& _graph, EdgeFilterMap& _edge_filter_map) :
Parent(), const_true_map(true) {
Parent::setGraph(_graph);
Parent::setNodeFilterMap(const_true_map);
@@ -567,13 +567,13 @@
};
template <typename _Graph>
- class UndirGraphWrapperBase :
- public UndirGraphExtender<GraphWrapperBase<_Graph> > {
+ class UndirGraphAdaptorBase :
+ public UndirGraphExtender<GraphAdaptorBase<_Graph> > {
public:
typedef _Graph Graph;
- typedef UndirGraphExtender<GraphWrapperBase<_Graph> > Parent;
+ typedef UndirGraphExtender<GraphAdaptorBase<_Graph> > Parent;
protected:
- UndirGraphWrapperBase() : Parent() { }
+ UndirGraphAdaptorBase() : Parent() { }
public:
typedef typename Parent::UndirEdge UndirEdge;
typedef typename Parent::Edge Edge;
@@ -584,17 +584,17 @@
template <typename T>
class EdgeMap {
protected:
- const UndirGraphWrapperBase<_Graph>* g;
+ const UndirGraphAdaptorBase<_Graph>* g;
template <typename TT> friend class EdgeMap;
typename _Graph::template EdgeMap<T> forward_map, backward_map;
public:
typedef T Value;
typedef Edge Key;
- EdgeMap(const UndirGraphWrapperBase<_Graph>& _g) : g(&_g),
+ EdgeMap(const UndirGraphAdaptorBase<_Graph>& _g) : g(&_g),
forward_map(*(g->graph)), backward_map(*(g->graph)) { }
- EdgeMap(const UndirGraphWrapperBase<_Graph>& _g, T a) : g(&_g),
+ EdgeMap(const UndirGraphAdaptorBase<_Graph>& _g, T a) : g(&_g),
forward_map(*(g->graph), a), backward_map(*(g->graph), a) { }
void set(Edge e, T a) {
@@ -620,10 +620,10 @@
typedef T Value;
typedef UndirEdge Key;
- UndirEdgeMap(const UndirGraphWrapperBase<_Graph>& g) :
+ UndirEdgeMap(const UndirGraphAdaptorBase<_Graph>& g) :
map(*(g.graph)) { }
- UndirEdgeMap(const UndirGraphWrapperBase<_Graph>& g, T a) :
+ UndirEdgeMap(const UndirGraphAdaptorBase<_Graph>& g, T a) :
map(*(g.graph), a) { }
void set(UndirEdge e, T a) {
@@ -637,24 +637,24 @@
};
- /// \brief An undirected graph is made from a directed graph by a wrapper
+ /// \brief An undirected graph is made from a directed graph by an adaptor
///
/// Undocumented, untested!!!
/// If somebody knows nice demo application, let's polulate it.
///
/// \author Marton Makai
template<typename _Graph>
- class UndirGraphWrapper :
+ class UndirGraphAdaptor :
public IterableUndirGraphExtender<
- UndirGraphWrapperBase<_Graph> > {
+ UndirGraphAdaptorBase<_Graph> > {
public:
typedef _Graph Graph;
typedef IterableUndirGraphExtender<
- UndirGraphWrapperBase<_Graph> > Parent;
+ UndirGraphAdaptorBase<_Graph> > Parent;
protected:
- UndirGraphWrapper() { }
+ UndirGraphAdaptor() { }
public:
- UndirGraphWrapper(_Graph& _graph) {
+ UndirGraphAdaptor(_Graph& _graph) {
setGraph(_graph);
}
};
@@ -662,14 +662,14 @@
template <typename _Graph,
typename ForwardFilterMap, typename BackwardFilterMap>
- class SubBidirGraphWrapperBase : public GraphWrapperBase<_Graph> {
+ class SubBidirGraphAdaptorBase : public GraphAdaptorBase<_Graph> {
public:
typedef _Graph Graph;
- typedef GraphWrapperBase<_Graph> Parent;
+ typedef GraphAdaptorBase<_Graph> Parent;
protected:
ForwardFilterMap* forward_filter;
BackwardFilterMap* backward_filter;
- SubBidirGraphWrapperBase() : Parent(),
+ SubBidirGraphAdaptorBase() : Parent(),
forward_filter(0), backward_filter(0) { }
void setForwardFilterMap(ForwardFilterMap& _forward_filter) {
@@ -680,7 +680,7 @@
}
public:
-// SubGraphWrapperBase(Graph& _graph,
+// SubGraphAdaptorBase(Graph& _graph,
// NodeFilterMap& _node_filter_map,
// EdgeFilterMap& _edge_filter_map) :
// Parent(&_graph),
@@ -690,12 +690,12 @@
typedef typename Parent::Node Node;
typedef typename _Graph::Edge GraphEdge;
template <typename T> class EdgeMap;
- /// SubBidirGraphWrapperBase<..., ..., ...>::Edge is inherited from
+ /// SubBidirGraphAdaptorBase<..., ..., ...>::Edge is inherited from
/// _Graph::Edge. It contains an extra bool flag which is true
/// if and only if the
/// edge is the backward version of the original edge.
class Edge : public _Graph::Edge {
- friend class SubBidirGraphWrapperBase<
+ friend class SubBidirGraphAdaptorBase<
Graph, ForwardFilterMap, BackwardFilterMap>;
template<typename T> friend class EdgeMap;
protected:
@@ -849,7 +849,7 @@
bool backward(const Edge& e) const { return e.backward; }
template <typename T>
- /// \c SubBidirGraphWrapperBase<..., ..., ...>::EdgeMap contains two
+ /// \c SubBidirGraphAdaptorBase<..., ..., ...>::EdgeMap contains two
/// _Graph::EdgeMap one for the forward edges and
/// one for the backward edges.
class EdgeMap {
@@ -859,11 +859,11 @@
typedef T Value;
typedef Edge Key;
- EdgeMap(const SubBidirGraphWrapperBase<_Graph,
+ EdgeMap(const SubBidirGraphAdaptorBase<_Graph,
ForwardFilterMap, BackwardFilterMap>& g) :
forward_map(*(g.graph)), backward_map(*(g.graph)) { }
- EdgeMap(const SubBidirGraphWrapperBase<_Graph,
+ EdgeMap(const SubBidirGraphAdaptorBase<_Graph,
ForwardFilterMap, BackwardFilterMap>& g, T a) :
forward_map(*(g.graph), a), backward_map(*(g.graph), a) { }
@@ -899,13 +899,13 @@
};
- ///\brief A wrapper for composing a subgraph of a
+ ///\brief An adaptor for composing a subgraph of a
/// bidirected graph made from a directed one.
///
- /// A wrapper for composing a subgraph of a
+ /// An adaptor for composing a subgraph of a
/// bidirected graph made from a directed one.
///
- ///\warning Graph wrappers 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.
///
/// Let \f$G=(V, A)\f$ be a directed graph and for each directed edge
@@ -913,7 +913,7 @@
/// reversing its orientation. We are given moreover two bool valued
/// maps on the edge-set,
/// \f$forward\_filter\f$, and \f$backward\_filter\f$.
- /// SubBidirGraphWrapper implements the graph structure with node-set
+ /// SubBidirGraphAdaptor implements the graph structure with node-set
/// \f$V\f$ and edge-set
/// \f$\{e : e\in A \mbox{ and } forward\_filter(e) \mbox{ is true}\}+\{\bar e : e\in A \mbox{ and } backward\_filter(e) \mbox{ is true}\}\f$.
/// The purpose of writing + instead of union is because parallel
@@ -923,34 +923,34 @@
/// As the oppositely directed edges are logically different,
/// the maps are able to attach different values for them.
///
- /// An example for such a construction is \c RevGraphWrapper where the
+ /// An example for such a construction is \c RevGraphAdaptor where the
/// forward_filter is everywhere false and the backward_filter is
/// everywhere true. We note that for sake of efficiency,
- /// \c RevGraphWrapper is implemented in a different way.
- /// But BidirGraphWrapper is obtained from
- /// SubBidirGraphWrapper by considering everywhere true
+ /// \c RevGraphAdaptor is implemented in a different way.
+ /// But BidirGraphAdaptor is obtained from
+ /// SubBidirGraphAdaptor by considering everywhere true
/// valued maps both for forward_filter and backward_filter.
///
- /// The most important application of SubBidirGraphWrapper
- /// is ResGraphWrapper, which stands for the residual graph in directed
+ /// The most important application of SubBidirGraphAdaptor
+ /// is ResGraphAdaptor, which stands for the residual graph in directed
/// flow and circulation problems.
- /// As wrappers usually, the SubBidirGraphWrapper implements the
+ /// As adaptors usually, the SubBidirGraphAdaptor implements the
/// above mentioned graph structure without its physical storage,
/// that is the whole stuff is stored in constant memory.
template<typename _Graph,
typename ForwardFilterMap, typename BackwardFilterMap>
- class SubBidirGraphWrapper :
+ class SubBidirGraphAdaptor :
public IterableGraphExtender<
- SubBidirGraphWrapperBase<_Graph, ForwardFilterMap, BackwardFilterMap> > {
+ SubBidirGraphAdaptorBase<_Graph, ForwardFilterMap, BackwardFilterMap> > {
public:
typedef _Graph Graph;
typedef IterableGraphExtender<
- SubBidirGraphWrapperBase<
+ SubBidirGraphAdaptorBase<
_Graph, ForwardFilterMap, BackwardFilterMap> > Parent;
protected:
- SubBidirGraphWrapper() { }
+ SubBidirGraphAdaptor() { }
public:
- SubBidirGraphWrapper(_Graph& _graph, ForwardFilterMap& _forward_filter,
+ SubBidirGraphAdaptor(_Graph& _graph, ForwardFilterMap& _forward_filter,
BackwardFilterMap& _backward_filter) {
setGraph(_graph);
setForwardFilterMap(_forward_filter);
@@ -960,35 +960,35 @@
- ///\brief A wrapper for composing bidirected graph from a directed one.
+ ///\brief An adaptor for composing bidirected graph from a directed one.
///
- ///\warning Graph wrappers 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.
///
- /// A wrapper for composing bidirected graph from a directed one.
+ /// An adaptor for composing bidirected graph from a directed one.
/// A bidirected graph is composed over the directed one without physical
/// storage. As the oppositely directed edges are logically different ones
/// the maps are able to attach different values for them.
template<typename Graph>
- class BidirGraphWrapper :
- public SubBidirGraphWrapper<
+ class BidirGraphAdaptor :
+ public SubBidirGraphAdaptor<
Graph,
ConstMap<typename Graph::Edge, bool>,
ConstMap<typename Graph::Edge, bool> > {
public:
- typedef SubBidirGraphWrapper<
+ typedef SubBidirGraphAdaptor<
Graph,
ConstMap<typename Graph::Edge, bool>,
ConstMap<typename Graph::Edge, bool> > Parent;
protected:
ConstMap<typename Graph::Edge, bool> cm;
- BidirGraphWrapper() : Parent(), cm(true) {
+ BidirGraphAdaptor() : Parent(), cm(true) {
Parent::setForwardFilterMap(cm);
Parent::setBackwardFilterMap(cm);
}
public:
- BidirGraphWrapper(Graph& _graph) : Parent(), cm(true) {
+ BidirGraphAdaptor(Graph& _graph) : Parent(), cm(true) {
Parent::setGraph(_graph);
Parent::setForwardFilterMap(cm);
Parent::setBackwardFilterMap(cm);
@@ -997,7 +997,7 @@
int edgeNum() const {
return 2*this->graph->edgeNum();
}
- // KEEP_MAPS(Parent, BidirGraphWrapper);
+ // KEEP_MAPS(Parent, BidirGraphAdaptor);
};
@@ -1037,27 +1037,27 @@
};
- /*! \brief A wrapper for composing the residual graph for directed flow and circulation problems.
+ /*! \brief An adaptor for composing the residual graph for directed flow and circulation problems.
- A wrapper for composing the residual graph for directed flow and circulation problems.
+ An adaptor for composing the residual graph for directed flow and circulation problems.
Let \f$G=(V, A)\f$ be a directed graph and let \f$F\f$ be a
number type. Let moreover
\f$f,c:A\to F\f$, be functions on the edge-set.
- In the appications of ResGraphWrapper, \f$f\f$ usually stands for a flow
+ In the appications of ResGraphAdaptor, \f$f\f$ usually stands for a flow
and \f$c\f$ for a capacity function.
Suppose that a graph instange \c g of type
\c ListGraph implements \f$G\f$.
\code
ListGraph g;
\endcode
- Then RevGraphWrapper implements the graph structure with node-set
+ Then RevGraphAdaptor implements the graph structure with node-set
\f$V\f$ and edge-set \f$A_{forward}\cup A_{backward}\f$, where
\f$A_{forward}=\{uv : uv\in A, f(uv)<c(uv)\}\f$ and
\f$A_{backward}=\{vu : uv\in A, f(uv)>0\}\f$,
i.e. the so called residual graph.
When we take the union \f$A_{forward}\cup A_{backward}\f$,
multilicities are counted, i.e. if an edge is in both
- \f$A_{forward}\f$ and \f$A_{backward}\f$, then in the wrapper it
+ \f$A_{forward}\f$ and \f$A_{backward}\f$, then in the adaptor it
appears twice.
The following code shows how
such an instance can be constructed.
@@ -1065,19 +1065,19 @@
typedef ListGraph Graph;
Graph::EdgeMap<int> f(g);
Graph::EdgeMap<int> c(g);
- ResGraphWrapper<Graph, int, Graph::EdgeMap<int>, Graph::EdgeMap<int> > gw(g);
+ ResGraphAdaptor<Graph, int, Graph::EdgeMap<int>, Graph::EdgeMap<int> > gw(g);
\endcode
\author Marton Makai
*/
template<typename Graph, typename Number,
typename CapacityMap, typename FlowMap>
- class ResGraphWrapper :
- public SubBidirGraphWrapper<
+ class ResGraphAdaptor :
+ public SubBidirGraphAdaptor<
Graph,
ResForwardFilter<Graph, Number, CapacityMap, FlowMap>,
ResBackwardFilter<Graph, Number, CapacityMap, FlowMap> > {
public:
- typedef SubBidirGraphWrapper<
+ typedef SubBidirGraphAdaptor<
Graph,
ResForwardFilter<Graph, Number, CapacityMap, FlowMap>,
ResBackwardFilter<Graph, Number, CapacityMap, FlowMap> > Parent;
@@ -1086,7 +1086,7 @@
FlowMap* flow;
ResForwardFilter<Graph, Number, CapacityMap, FlowMap> forward_filter;
ResBackwardFilter<Graph, Number, CapacityMap, FlowMap> backward_filter;
- ResGraphWrapper() : Parent(),
+ ResGraphAdaptor() : Parent(),
capacity(0), flow(0) { }
void setCapacityMap(const CapacityMap& _capacity) {
capacity=&_capacity;
@@ -1099,7 +1099,7 @@
backward_filter.setFlow(_flow);
}
public:
- ResGraphWrapper(Graph& _graph, const CapacityMap& _capacity,
+ ResGraphAdaptor(Graph& _graph, const CapacityMap& _capacity,
FlowMap& _flow) :
Parent(), capacity(&_capacity), flow(&_flow),
forward_filter(/*_graph,*/ _capacity, _flow),
@@ -1124,11 +1124,11 @@
/// as a map.
class ResCap {
protected:
- const ResGraphWrapper<Graph, Number, CapacityMap, FlowMap>* res_graph;
+ const ResGraphAdaptor<Graph, Number, CapacityMap, FlowMap>* res_graph;
public:
typedef Number Value;
typedef Edge Key;
- ResCap(const ResGraphWrapper<Graph, Number, CapacityMap, FlowMap>&
+ ResCap(const ResGraphAdaptor<Graph, Number, CapacityMap, FlowMap>&
_res_graph) : res_graph(&_res_graph) { }
Number operator[](const Edge& e) const {
if (res_graph->forward(e))
@@ -1138,19 +1138,19 @@
}
};
- // KEEP_MAPS(Parent, ResGraphWrapper);
+ // KEEP_MAPS(Parent, ResGraphAdaptor);
};
template <typename _Graph, typename FirstOutEdgesMap>
- class ErasingFirstGraphWrapperBase : public GraphWrapperBase<_Graph> {
+ class ErasingFirstGraphAdaptorBase : public GraphAdaptorBase<_Graph> {
public:
typedef _Graph Graph;
- typedef GraphWrapperBase<_Graph> Parent;
+ typedef GraphAdaptorBase<_Graph> Parent;
protected:
FirstOutEdgesMap* first_out_edges;
- ErasingFirstGraphWrapperBase() : Parent(),
+ ErasingFirstGraphAdaptorBase() : Parent(),
first_out_edges(0) { }
void setFirstOutEdgesMap(FirstOutEdgesMap& _first_out_edges) {
@@ -1177,10 +1177,10 @@
/// For blocking flows.
- ///\warning Graph wrappers 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 wrapper is used for on-the-fly
+ /// 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
@@ -1190,14 +1190,14 @@
///
/// \author Marton Makai
template <typename _Graph, typename FirstOutEdgesMap>
- class ErasingFirstGraphWrapper :
+ class ErasingFirstGraphAdaptor :
public IterableGraphExtender<
- ErasingFirstGraphWrapperBase<_Graph, FirstOutEdgesMap> > {
+ ErasingFirstGraphAdaptorBase<_Graph, FirstOutEdgesMap> > {
public:
typedef _Graph Graph;
typedef IterableGraphExtender<
- ErasingFirstGraphWrapperBase<_Graph, FirstOutEdgesMap> > Parent;
- ErasingFirstGraphWrapper(Graph& _graph,
+ ErasingFirstGraphAdaptorBase<_Graph, FirstOutEdgesMap> > Parent;
+ ErasingFirstGraphAdaptor(Graph& _graph,
FirstOutEdgesMap& _first_out_edges) {
setGraph(_graph);
setFirstOutEdgesMap(_first_out_edges);
@@ -1209,5 +1209,5 @@
} //namespace lemon
-#endif //LEMON_GRAPH_WRAPPER_H
+#endif //LEMON_GRAPH_ADAPTOR_H
Modified: hugo/trunk/src/lemon/min_cost_flow.h
==============================================================================
--- hugo/trunk/src/lemon/min_cost_flow.h (original)
+++ hugo/trunk/src/lemon/min_cost_flow.h Wed May 4 15:07:10 2005
@@ -23,7 +23,7 @@
#include <lemon/dijkstra.h>
-#include <lemon/graph_wrapper.h>
+#include <lemon/graph_adaptor.h>
#include <lemon/maps.h>
#include <vector>
@@ -68,7 +68,7 @@
typedef typename Graph::OutEdgeIt OutEdgeIt;
typedef typename Graph::template EdgeMap<int> EdgeIntMap;
- typedef ResGraphWrapper<const Graph,int,CapacityMap,EdgeIntMap> ResGW;
+ typedef ResGraphAdaptor<const Graph,int,CapacityMap,EdgeIntMap> ResGW;
typedef typename ResGW::Edge ResGraphEdge;
protected:
Modified: hugo/trunk/src/test/Makefile.am
==============================================================================
--- hugo/trunk/src/test/Makefile.am (original)
+++ hugo/trunk/src/test/Makefile.am Wed May 4 15:07:10 2005
@@ -16,7 +16,7 @@
dfs_test \
dijkstra_test \
graph_test \
- graph_wrapper_test \
+ graph_adaptor_test \
graph_utils_test \
kruskal_test \
max_matching_test \
@@ -49,7 +49,7 @@
dijkstra_test_SOURCES = dijkstra_test.cc
graph_test_SOURCES = graph_test.cc
graph_utils_test_SOURCES = graph_utils_test.cc
-graph_wrapper_test_SOURCES = graph_wrapper_test.cc
+graph_adaptor_test_SOURCES = graph_adaptor_test.cc
kruskal_test_SOURCES = kruskal_test.cc
maps_test_SOURCES = maps_test.cc
min_cost_flow_test_SOURCES = min_cost_flow_test.cc
Copied: hugo/trunk/src/test/graph_adaptor_test.cc (from r1862, /hugo/trunk/src/test/graph_wrapper_test.cc)
==============================================================================
--- /hugo/trunk/src/test/graph_wrapper_test.cc (original)
+++ hugo/trunk/src/test/graph_adaptor_test.cc Wed May 4 15:07:10 2005
@@ -1,5 +1,5 @@
/* -*- C++ -*-
- * src/test/graph_wrapper_test.cc - Part of LEMON, a generic C++ optimization library
+ * src/test/graph_adaptor_test.cc - Part of LEMON, a generic C++ optimization library
*
* Copyright (C) 2005 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
* (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -23,14 +23,14 @@
#include<lemon/list_graph.h>
#include<lemon/full_graph.h>
-#include<lemon/graph_wrapper.h>
+#include<lemon/graph_adaptor.h>
#include"test/test_tools.h"
#include"test/graph_test.h"
/**
\file
-This test makes consistency checks of graph wrappers.
+This test makes consistency checks of graph adaptors.
\todo More extensive tests are needed
*/
@@ -44,30 +44,30 @@
{
{
typedef StaticGraph Graph;
- checkConcept<StaticGraph, GraphWrapper<Graph> >();
+ checkConcept<StaticGraph, GraphAdaptor<Graph> >();
- checkConcept<StaticGraph, RevGraphWrapper<Graph> >();
+ checkConcept<StaticGraph, RevGraphAdaptor<Graph> >();
- checkConcept<StaticGraph, SubGraphWrapper<Graph,
+ checkConcept<StaticGraph, SubGraphAdaptor<Graph,
Graph::NodeMap<bool> , Graph::EdgeMap<bool> > >();
- checkConcept<StaticGraph, NodeSubGraphWrapper<Graph,
+ checkConcept<StaticGraph, NodeSubGraphAdaptor<Graph,
Graph::NodeMap<bool> > >();
- checkConcept<StaticGraph, EdgeSubGraphWrapper<Graph,
+ checkConcept<StaticGraph, EdgeSubGraphAdaptor<Graph,
Graph::EdgeMap<bool> > >();
- checkConcept<StaticGraph, SubBidirGraphWrapper<Graph,
+ checkConcept<StaticGraph, SubBidirGraphAdaptor<Graph,
Graph::EdgeMap<bool>, Graph::EdgeMap<bool> > >();
// checkConcept<StaticGraph, BidirGraph<Graph> >();
- checkConcept<StaticGraph, ResGraphWrapper<Graph, int,
+ checkConcept<StaticGraph, ResGraphAdaptor<Graph, int,
Graph::EdgeMap<int>, Graph::EdgeMap<int> > >();
- checkConcept<StaticGraph, ErasingFirstGraphWrapper<Graph,
+ checkConcept<StaticGraph, ErasingFirstGraphAdaptor<Graph,
Graph::NodeMap<Graph::Edge> > >();
/// \bug why does not compile with StaticGraph
- checkConcept<BaseIterableUndirGraphConcept, UndirGraphWrapper<ListGraph> >();
- checkConcept<IterableUndirGraphConcept, UndirGraphWrapper<ListGraph> >();
- checkConcept<MappableUndirGraphConcept, UndirGraphWrapper<ListGraph> >();
+ checkConcept<BaseIterableUndirGraphConcept, UndirGraphAdaptor<ListGraph> >();
+ checkConcept<IterableUndirGraphConcept, UndirGraphAdaptor<ListGraph> >();
+ checkConcept<MappableUndirGraphConcept, UndirGraphAdaptor<ListGraph> >();
}
std::cout << __FILE__ ": All tests passed.\n";
More information about the Lemon-commits
mailing list