author Balazs Dezso Sun, 30 Nov 2008 19:18:32 +0100 changeset 416 76287c8caa26 parent 415 4b6112235fad child 417 6ff53afe98b5
Reorganication of graph adaptors and doc improvements (#67)

- Moving to one file, lemon/adaptors.h
- Renamings
- Doc cleanings
 doc/groups.dox file | annotate | diff | comparison | revisions lemon/Makefile.am file | annotate | diff | comparison | revisions lemon/adaptors.h file | annotate | diff | comparison | revisions lemon/bits/graph_adaptor_extender.h file | annotate | diff | comparison | revisions lemon/bits/variant.h file | annotate | diff | comparison | revisions lemon/digraph_adaptor.h file | annotate | diff | comparison | revisions lemon/graph_adaptor.h file | annotate | diff | comparison | revisions test/graph_adaptor_test.cc file | annotate | diff | comparison | revisions
     1.1 --- a/doc/groups.dox	Sun Nov 30 19:00:30 2008 +0100
1.2 +++ b/doc/groups.dox	Sun Nov 30 19:18:32 2008 +0100
1.3 @@ -60,6 +60,79 @@
1.4  */
1.5
1.6  /**
1.8 +@ingroup graphs
1.9 +\brief This group contains several adaptor classes for digraphs and graphs
1.10 +
1.11 +The main parts of LEMON are the different graph structures, generic
1.12 +graph algorithms, graph concepts which couple these, and graph
1.13 +adaptors. While the previous notions are more or less clear, the
1.14 +latter one needs further explanation. Graph adaptors are graph classes
1.15 +which serve for considering graph structures in different ways.
1.16 +
1.17 +A short example makes this much clearer.  Suppose that we have an
1.18 +instance \c g of a directed graph type say ListDigraph and an algorithm
1.19 +\code
1.20 +template <typename Digraph>
1.21 +int algorithm(const Digraph&);
1.22 +\endcode
1.23 +is needed to run on the reverse oriented graph.  It may be expensive
1.24 +(in time or in memory usage) to copy \c g with the reversed
1.25 +arcs.  In this case, an adaptor class is used, which (according
1.26 +to LEMON digraph concepts) works as a digraph.  The adaptor uses the
1.27 +original digraph structure and digraph operations when methods of the
1.28 +reversed oriented graph are called.  This means that the adaptor have
1.29 +minor memory usage, and do not perform sophisticated algorithmic
1.30 +actions.  The purpose of it is to give a tool for the cases when a
1.31 +graph have to be used in a specific alteration.  If this alteration is
1.32 +obtained by a usual construction like filtering the arc-set or
1.33 +considering a new orientation, then an adaptor is worthwhile to use.
1.34 +To come back to the reverse oriented graph, in this situation
1.35 +\code
1.36 +template<typename Digraph> class ReverseDigraph;
1.37 +\endcode
1.38 +template class can be used. The code looks as follows
1.39 +\code
1.40 +ListDigraph g;
1.41 +ReverseDigraph<ListGraph> rg(g);
1.42 +int result = algorithm(rg);
1.43 +\endcode
1.44 +After running the algorithm, the original graph \c g is untouched.
1.45 +This techniques gives rise to an elegant code, and based on stable
1.46 +graph adaptors, complex algorithms can be implemented easily.
1.47 +
1.48 +In flow, circulation and bipartite matching problems, the residual
1.49 +graph is of particular importance. Combining an adaptor implementing
1.50 +this, shortest path algorithms and minimum mean cycle algorithms,
1.51 +a range of weighted and cardinality optimization algorithms can be
1.52 +obtained. For other examples, the interested user is referred to the
1.53 +detailed documentation of particular adaptors.
1.54 +
1.55 +The behavior of graph adaptors can be very different. Some of them keep
1.56 +capabilities of the original graph while in other cases this would be
1.57 +meaningless. This means that the concepts that they are models of depend
1.58 +on the graph adaptor, and the wrapped graph(s).
1.59 +If an arc of \c rg is deleted, this is carried out by deleting the
1.60 +corresponding arc of \c g, thus the adaptor modifies the original graph.
1.61 +
1.62 +But for a residual graph, this operation has no sense.
1.63 +Let us stand one more example here to simplify your work.
1.65 +\code
1.66 +ReverseDigraph(Digraph& digraph);
1.67 +\endcode
1.68 +This means that in a situation, when a <tt>const ListDigraph&</tt>
1.69 +reference to a graph is given, then it have to be instantiated with
1.70 +<tt>Digraph=const ListDigraph</tt>.
1.71 +\code
1.72 +int algorithm1(const ListDigraph& g) {
1.74 +  return algorithm2(rg);
1.75 +}
1.76 +\endcode
1.77 +*/
1.78 +
1.79 +/**
1.81  @ingroup graphs
1.82  \brief Graph types between real graphs and graph adaptors.

     2.1 --- a/lemon/Makefile.am	Sun Nov 30 19:00:30 2008 +0100
2.2 +++ b/lemon/Makefile.am	Sun Nov 30 19:18:32 2008 +0100
2.3 @@ -16,6 +16,7 @@
2.4  #lemon_libemon_la_LDFLAGS = $(GLPK_LIBS)$(CPLEX_LIBS) $(SOPLEX_LIBS) 2.5 2.6 lemon_HEADERS += \ 2.7 + lemon/adaptors.h \ 2.8 lemon/arg_parser.h \ 2.9 lemon/assert.h \ 2.10 lemon/bfs.h \   3.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000 3.2 +++ b/lemon/adaptors.h Sun Nov 30 19:18:32 2008 +0100 3.3 @@ -0,0 +1,3347 @@ 3.4 +/* -*- mode: C++; indent-tabs-mode: nil; -*- 3.5 + * 3.6 + * This file is a part of LEMON, a generic C++ optimization library. 3.7 + * 3.8 + * Copyright (C) 2003-2008 3.9 + * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport 3.10 + * (Egervary Research Group on Combinatorial Optimization, EGRES). 3.11 + * 3.12 + * Permission to use, modify and distribute this software is granted 3.13 + * provided that this copyright notice appears in all copies. For 3.14 + * precise terms see the accompanying LICENSE file. 3.15 + * 3.16 + * This software is provided "AS IS" with no warranty of any kind, 3.17 + * express or implied, and with no claim as to its suitability for any 3.18 + * purpose. 3.19 + * 3.20 + */ 3.21 + 3.22 +#ifndef LEMON_ADAPTORS_H 3.23 +#define LEMON_ADAPTORS_H 3.24 + 3.25 +/// \ingroup graph_adaptors 3.26 +/// \file 3.27 +/// \brief Several graph adaptors 3.28 +/// 3.29 +/// This file contains several useful adaptors for digraphs and graphs. 3.30 + 3.31 +#include <lemon/core.h> 3.32 +#include <lemon/maps.h> 3.33 +#include <lemon/bits/variant.h> 3.34 + 3.35 +#include <lemon/bits/graph_adaptor_extender.h> 3.36 +#include <lemon/tolerance.h> 3.37 + 3.38 +#include <algorithm> 3.39 + 3.40 +namespace lemon { 3.41 + 3.42 + template<typename _Digraph> 3.43 + class DigraphAdaptorBase { 3.44 + public: 3.45 + typedef _Digraph Digraph; 3.46 + typedef DigraphAdaptorBase Adaptor; 3.47 + typedef Digraph ParentDigraph; 3.48 + 3.49 + protected: 3.50 + Digraph* _digraph; 3.51 + DigraphAdaptorBase() : _digraph(0) { } 3.52 + void setDigraph(Digraph& digraph) { _digraph = &digraph; } 3.53 + 3.54 + public: 3.55 + DigraphAdaptorBase(Digraph& digraph) : _digraph(&digraph) { } 3.56 + 3.57 + typedef typename Digraph::Node Node; 3.58 + typedef typename Digraph::Arc Arc; 3.59 + 3.60 + void first(Node& i) const { _digraph->first(i); } 3.61 + void first(Arc& i) const { _digraph->first(i); } 3.62 + void firstIn(Arc& i, const Node& n) const { _digraph->firstIn(i, n); } 3.63 + void firstOut(Arc& i, const Node& n ) const { _digraph->firstOut(i, n); } 3.64 + 3.65 + void next(Node& i) const { _digraph->next(i); } 3.66 + void next(Arc& i) const { _digraph->next(i); } 3.67 + void nextIn(Arc& i) const { _digraph->nextIn(i); } 3.68 + void nextOut(Arc& i) const { _digraph->nextOut(i); } 3.69 + 3.70 + Node source(const Arc& a) const { return _digraph->source(a); } 3.71 + Node target(const Arc& a) const { return _digraph->target(a); } 3.72 + 3.73 + typedef NodeNumTagIndicator<Digraph> NodeNumTag; 3.74 + int nodeNum() const { return _digraph->nodeNum(); } 3.75 + 3.76 + typedef EdgeNumTagIndicator<Digraph> EdgeNumTag; 3.77 + int arcNum() const { return _digraph->arcNum(); } 3.78 + 3.79 + typedef FindEdgeTagIndicator<Digraph> FindEdgeTag; 3.80 + Arc findArc(const Node& u, const Node& v, const Arc& prev = INVALID) { 3.81 + return _digraph->findArc(u, v, prev); 3.82 + } 3.83 + 3.84 + Node addNode() { return _digraph->addNode(); } 3.85 + Arc addArc(const Node& u, const Node& v) { return _digraph->addArc(u, v); } 3.86 + 3.87 + void erase(const Node& n) const { _digraph->erase(n); } 3.88 + void erase(const Arc& a) const { _digraph->erase(a); } 3.89 + 3.90 + void clear() const { _digraph->clear(); } 3.91 + 3.92 + int id(const Node& n) const { return _digraph->id(n); } 3.93 + int id(const Arc& a) const { return _digraph->id(a); } 3.94 + 3.95 + Node nodeFromId(int ix) const { return _digraph->nodeFromId(ix); } 3.96 + Arc arcFromId(int ix) const { return _digraph->arcFromId(ix); } 3.97 + 3.98 + int maxNodeId() const { return _digraph->maxNodeId(); } 3.99 + int maxArcId() const { return _digraph->maxArcId(); } 3.100 + 3.101 + typedef typename ItemSetTraits<Digraph, Node>::ItemNotifier NodeNotifier; 3.102 + NodeNotifier& notifier(Node) const { return _digraph->notifier(Node()); } 3.103 + 3.104 + typedef typename ItemSetTraits<Digraph, Arc>::ItemNotifier ArcNotifier; 3.105 + ArcNotifier& notifier(Arc) const { return _digraph->notifier(Arc()); } 3.106 + 3.107 + template <typename _Value> 3.108 + class NodeMap : public Digraph::template NodeMap<_Value> { 3.109 + public: 3.110 + 3.111 + typedef typename Digraph::template NodeMap<_Value> Parent; 3.112 + 3.113 + explicit NodeMap(const Adaptor& adaptor) 3.114 + : Parent(*adaptor._digraph) {} 3.115 + 3.116 + NodeMap(const Adaptor& adaptor, const _Value& value) 3.117 + : Parent(*adaptor._digraph, value) { } 3.118 + 3.119 + private: 3.120 + NodeMap& operator=(const NodeMap& cmap) { 3.121 + return operator=<NodeMap>(cmap); 3.122 + } 3.123 + 3.124 + template <typename CMap> 3.125 + NodeMap& operator=(const CMap& cmap) { 3.126 + Parent::operator=(cmap); 3.127 + return *this; 3.128 + } 3.129 + 3.130 + }; 3.131 + 3.132 + template <typename _Value> 3.133 + class ArcMap : public Digraph::template ArcMap<_Value> { 3.134 + public: 3.135 + 3.136 + typedef typename Digraph::template ArcMap<_Value> Parent; 3.137 + 3.138 + explicit ArcMap(const Adaptor& adaptor) 3.139 + : Parent(*adaptor._digraph) {} 3.140 + 3.141 + ArcMap(const Adaptor& adaptor, const _Value& value) 3.142 + : Parent(*adaptor._digraph, value) {} 3.143 + 3.144 + private: 3.145 + ArcMap& operator=(const ArcMap& cmap) { 3.146 + return operator=<ArcMap>(cmap); 3.147 + } 3.148 + 3.149 + template <typename CMap> 3.150 + ArcMap& operator=(const CMap& cmap) { 3.151 + Parent::operator=(cmap); 3.152 + return *this; 3.153 + } 3.154 + 3.155 + }; 3.156 + 3.157 + }; 3.158 + 3.159 + template<typename _Graph> 3.160 + class GraphAdaptorBase { 3.161 + public: 3.162 + typedef _Graph Graph; 3.163 + typedef Graph ParentGraph; 3.164 + 3.165 + protected: 3.166 + Graph* _graph; 3.167 + 3.168 + GraphAdaptorBase() : _graph(0) {} 3.169 + 3.170 + void setGraph(Graph& graph) { _graph = &graph; } 3.171 + 3.172 + public: 3.173 + GraphAdaptorBase(Graph& graph) : _graph(&graph) {} 3.174 + 3.175 + typedef typename Graph::Node Node; 3.176 + typedef typename Graph::Arc Arc; 3.177 + typedef typename Graph::Edge Edge; 3.178 + 3.179 + void first(Node& i) const { _graph->first(i); } 3.180 + void first(Arc& i) const { _graph->first(i); } 3.181 + void first(Edge& i) const { _graph->first(i); } 3.182 + void firstIn(Arc& i, const Node& n) const { _graph->firstIn(i, n); } 3.183 + void firstOut(Arc& i, const Node& n ) const { _graph->firstOut(i, n); } 3.184 + void firstInc(Edge &i, bool &d, const Node &n) const { 3.185 + _graph->firstInc(i, d, n); 3.186 + } 3.187 + 3.188 + void next(Node& i) const { _graph->next(i); } 3.189 + void next(Arc& i) const { _graph->next(i); } 3.190 + void next(Edge& i) const { _graph->next(i); } 3.191 + void nextIn(Arc& i) const { _graph->nextIn(i); } 3.192 + void nextOut(Arc& i) const { _graph->nextOut(i); } 3.193 + void nextInc(Edge &i, bool &d) const { _graph->nextInc(i, d); } 3.194 + 3.195 + Node u(const Edge& e) const { return _graph->u(e); } 3.196 + Node v(const Edge& e) const { return _graph->v(e); } 3.197 + 3.198 + Node source(const Arc& a) const { return _graph->source(a); } 3.199 + Node target(const Arc& a) const { return _graph->target(a); } 3.200 + 3.201 + typedef NodeNumTagIndicator<Graph> NodeNumTag; 3.202 + int nodeNum() const { return _graph->nodeNum(); } 3.203 + 3.204 + typedef EdgeNumTagIndicator<Graph> EdgeNumTag; 3.205 + int arcNum() const { return _graph->arcNum(); } 3.206 + int edgeNum() const { return _graph->edgeNum(); } 3.207 + 3.208 + typedef FindEdgeTagIndicator<Graph> FindEdgeTag; 3.209 + Arc findArc(const Node& u, const Node& v, const Arc& prev = INVALID) { 3.210 + return _graph->findArc(u, v, prev); 3.211 + } 3.212 + Edge findEdge(const Node& u, const Node& v, const Edge& prev = INVALID) { 3.213 + return _graph->findEdge(u, v, prev); 3.214 + } 3.215 + 3.216 + Node addNode() { return _graph->addNode(); } 3.217 + Edge addEdge(const Node& u, const Node& v) { return _graph->addEdge(u, v); } 3.218 + 3.219 + void erase(const Node& i) { _graph->erase(i); } 3.220 + void erase(const Edge& i) { _graph->erase(i); } 3.221 + 3.222 + void clear() { _graph->clear(); } 3.223 + 3.224 + bool direction(const Arc& a) const { return _graph->direction(a); } 3.225 + Arc direct(const Edge& e, bool d) const { return _graph->direct(e, d); } 3.226 + 3.227 + int id(const Node& v) const { return _graph->id(v); } 3.228 + int id(const Arc& a) const { return _graph->id(a); } 3.229 + int id(const Edge& e) const { return _graph->id(e); } 3.230 + 3.231 + Node nodeFromId(int ix) const { return _graph->nodeFromId(ix); } 3.232 + Arc arcFromId(int ix) const { return _graph->arcFromId(ix); } 3.233 + Edge edgeFromId(int ix) const { return _graph->edgeFromId(ix); } 3.234 + 3.235 + int maxNodeId() const { return _graph->maxNodeId(); } 3.236 + int maxArcId() const { return _graph->maxArcId(); } 3.237 + int maxEdgeId() const { return _graph->maxEdgeId(); } 3.238 + 3.239 + typedef typename ItemSetTraits<Graph, Node>::ItemNotifier NodeNotifier; 3.240 + NodeNotifier& notifier(Node) const { return _graph->notifier(Node()); } 3.241 + 3.242 + typedef typename ItemSetTraits<Graph, Arc>::ItemNotifier ArcNotifier; 3.243 + ArcNotifier& notifier(Arc) const { return _graph->notifier(Arc()); } 3.244 + 3.245 + typedef typename ItemSetTraits<Graph, Edge>::ItemNotifier EdgeNotifier; 3.246 + EdgeNotifier& notifier(Edge) const { return _graph->notifier(Edge()); } 3.247 + 3.248 + template <typename _Value> 3.249 + class NodeMap : public Graph::template NodeMap<_Value> { 3.250 + public: 3.251 + typedef typename Graph::template NodeMap<_Value> Parent; 3.252 + explicit NodeMap(const GraphAdaptorBase<Graph>& adapter) 3.253 + : Parent(*adapter._graph) {} 3.254 + NodeMap(const GraphAdaptorBase<Graph>& adapter, const _Value& value) 3.255 + : Parent(*adapter._graph, value) {} 3.256 + 3.257 + private: 3.258 + NodeMap& operator=(const NodeMap& cmap) { 3.259 + return operator=<NodeMap>(cmap); 3.260 + } 3.261 + 3.262 + template <typename CMap> 3.263 + NodeMap& operator=(const CMap& cmap) { 3.264 + Parent::operator=(cmap); 3.265 + return *this; 3.266 + } 3.267 + 3.268 + }; 3.269 + 3.270 + template <typename _Value> 3.271 + class ArcMap : public Graph::template ArcMap<_Value> { 3.272 + public: 3.273 + typedef typename Graph::template ArcMap<_Value> Parent; 3.274 + explicit ArcMap(const GraphAdaptorBase<Graph>& adapter) 3.275 + : Parent(*adapter._graph) {} 3.276 + ArcMap(const GraphAdaptorBase<Graph>& adapter, const _Value& value) 3.277 + : Parent(*adapter._graph, value) {} 3.278 + 3.279 + private: 3.280 + ArcMap& operator=(const ArcMap& cmap) { 3.281 + return operator=<ArcMap>(cmap); 3.282 + } 3.283 + 3.284 + template <typename CMap> 3.285 + ArcMap& operator=(const CMap& cmap) { 3.286 + Parent::operator=(cmap); 3.287 + return *this; 3.288 + } 3.289 + }; 3.290 + 3.291 + template <typename _Value> 3.292 + class EdgeMap : public Graph::template EdgeMap<_Value> { 3.293 + public: 3.294 + typedef typename Graph::template EdgeMap<_Value> Parent; 3.295 + explicit EdgeMap(const GraphAdaptorBase<Graph>& adapter) 3.296 + : Parent(*adapter._graph) {} 3.297 + EdgeMap(const GraphAdaptorBase<Graph>& adapter, const _Value& value) 3.298 + : Parent(*adapter._graph, value) {} 3.299 + 3.300 + private: 3.301 + EdgeMap& operator=(const EdgeMap& cmap) { 3.302 + return operator=<EdgeMap>(cmap); 3.303 + } 3.304 + 3.305 + template <typename CMap> 3.306 + EdgeMap& operator=(const CMap& cmap) { 3.307 + Parent::operator=(cmap); 3.308 + return *this; 3.309 + } 3.310 + }; 3.311 + 3.312 + }; 3.313 + 3.314 + template <typename _Digraph> 3.315 + class ReverseDigraphBase : public DigraphAdaptorBase<_Digraph> { 3.316 + public: 3.317 + typedef _Digraph Digraph; 3.318 + typedef DigraphAdaptorBase<_Digraph> Parent; 3.319 + protected: 3.320 + ReverseDigraphBase() : Parent() { } 3.321 + public: 3.322 + typedef typename Parent::Node Node; 3.323 + typedef typename Parent::Arc Arc; 3.324 + 3.325 + void firstIn(Arc& a, const Node& n) const { Parent::firstOut(a, n); } 3.326 + void firstOut(Arc& a, const Node& n ) const { Parent::firstIn(a, n); } 3.327 + 3.328 + void nextIn(Arc& a) const { Parent::nextOut(a); } 3.329 + void nextOut(Arc& a) const { Parent::nextIn(a); } 3.330 + 3.331 + Node source(const Arc& a) const { return Parent::target(a); } 3.332 + Node target(const Arc& a) const { return Parent::source(a); } 3.333 + 3.334 + Arc addArc(const Node& u, const Node& v) { return Parent::addArc(v, u); } 3.335 + 3.336 + typedef FindEdgeTagIndicator<Digraph> FindEdgeTag; 3.337 + Arc findArc(const Node& u, const Node& v, 3.338 + const Arc& prev = INVALID) { 3.339 + return Parent::findArc(v, u, prev); 3.340 + } 3.341 + 3.342 + }; 3.343 + 3.344 + /// \ingroup graph_adaptors 3.345 + /// 3.346 + /// \brief A digraph adaptor which reverses the orientation of the arcs. 3.347 + /// 3.348 + /// ReverseDigraph reverses the arcs in the adapted digraph. The 3.349 + /// SubDigraph is conform to the \ref concepts::Digraph 3.350 + /// "Digraph concept". 3.351 + /// 3.352 + /// \tparam _Digraph It must be conform to the \ref concepts::Digraph 3.353 + /// "Digraph concept". The type can be specified to be const. 3.354 + template<typename _Digraph> 3.355 + class ReverseDigraph : 3.356 + public DigraphAdaptorExtender<ReverseDigraphBase<_Digraph> > { 3.357 + public: 3.358 + typedef _Digraph Digraph; 3.359 + typedef DigraphAdaptorExtender< 3.360 + ReverseDigraphBase<_Digraph> > Parent; 3.361 + protected: 3.362 + ReverseDigraph() { } 3.363 + public: 3.364 + 3.365 + /// \brief Constructor 3.366 + /// 3.367 + /// Creates a reverse digraph adaptor for the given digraph 3.368 + explicit ReverseDigraph(Digraph& digraph) { 3.369 + Parent::setDigraph(digraph); 3.370 + } 3.371 + }; 3.372 + 3.373 + /// \brief Just gives back a reverse digraph adaptor 3.374 + /// 3.375 + /// Just gives back a reverse digraph adaptor 3.376 + template<typename Digraph> 3.377 + ReverseDigraph<const Digraph> reverseDigraph(const Digraph& digraph) { 3.378 + return ReverseDigraph<const Digraph>(digraph); 3.379 + } 3.380 + 3.381 + template <typename _Digraph, typename _NodeFilterMap, 3.382 + typename _ArcFilterMap, bool _checked = true> 3.383 + class SubDigraphBase : public DigraphAdaptorBase<_Digraph> { 3.384 + public: 3.385 + typedef _Digraph Digraph; 3.386 + typedef _NodeFilterMap NodeFilterMap; 3.387 + typedef _ArcFilterMap ArcFilterMap; 3.388 + 3.389 + typedef SubDigraphBase Adaptor; 3.390 + typedef DigraphAdaptorBase<_Digraph> Parent; 3.391 + protected: 3.392 + NodeFilterMap* _node_filter; 3.393 + ArcFilterMap* _arc_filter; 3.394 + SubDigraphBase() 3.395 + : Parent(), _node_filter(0), _arc_filter(0) { } 3.396 + 3.397 + void setNodeFilterMap(NodeFilterMap& node_filter) { 3.398 + _node_filter = &node_filter; 3.399 + } 3.400 + void setArcFilterMap(ArcFilterMap& arc_filter) { 3.401 + _arc_filter = &arc_filter; 3.402 + } 3.403 + 3.404 + public: 3.405 + 3.406 + typedef typename Parent::Node Node; 3.407 + typedef typename Parent::Arc Arc; 3.408 + 3.409 + void first(Node& i) const { 3.410 + Parent::first(i); 3.411 + while (i != INVALID && !(*_node_filter)[i]) Parent::next(i); 3.412 + } 3.413 + 3.414 + void first(Arc& i) const { 3.415 + Parent::first(i); 3.416 + while (i != INVALID && (!(*_arc_filter)[i] 3.417 + || !(*_node_filter)[Parent::source(i)] 3.418 + || !(*_node_filter)[Parent::target(i)])) 3.419 + Parent::next(i); 3.420 + } 3.421 + 3.422 + void firstIn(Arc& i, const Node& n) const { 3.423 + Parent::firstIn(i, n); 3.424 + while (i != INVALID && (!(*_arc_filter)[i] 3.425 + || !(*_node_filter)[Parent::source(i)])) 3.426 + Parent::nextIn(i); 3.427 + } 3.428 + 3.429 + void firstOut(Arc& i, const Node& n) const { 3.430 + Parent::firstOut(i, n); 3.431 + while (i != INVALID && (!(*_arc_filter)[i] 3.432 + || !(*_node_filter)[Parent::target(i)])) 3.433 + Parent::nextOut(i); 3.434 + } 3.435 + 3.436 + void next(Node& i) const { 3.437 + Parent::next(i); 3.438 + while (i != INVALID && !(*_node_filter)[i]) Parent::next(i); 3.439 + } 3.440 + 3.441 + void next(Arc& i) const { 3.442 + Parent::next(i); 3.443 + while (i != INVALID && (!(*_arc_filter)[i] 3.444 + || !(*_node_filter)[Parent::source(i)] 3.445 + || !(*_node_filter)[Parent::target(i)])) 3.446 + Parent::next(i); 3.447 + } 3.448 + 3.449 + void nextIn(Arc& i) const { 3.450 + Parent::nextIn(i); 3.451 + while (i != INVALID && (!(*_arc_filter)[i] 3.452 + || !(*_node_filter)[Parent::source(i)])) 3.453 + Parent::nextIn(i); 3.454 + } 3.455 + 3.456 + void nextOut(Arc& i) const { 3.457 + Parent::nextOut(i); 3.458 + while (i != INVALID && (!(*_arc_filter)[i] 3.459 + || !(*_node_filter)[Parent::target(i)])) 3.460 + Parent::nextOut(i); 3.461 + } 3.462 + 3.463 + void hide(const Node& n) const { _node_filter->set(n, false); } 3.464 + void hide(const Arc& a) const { _arc_filter->set(a, false); } 3.465 + 3.466 + void unHide(const Node& n) const { _node_filter->set(n, true); } 3.467 + void unHide(const Arc& a) const { _arc_filter->set(a, true); } 3.468 + 3.469 + bool hidden(const Node& n) const { return !(*_node_filter)[n]; } 3.470 + bool hidden(const Arc& a) const { return !(*_arc_filter)[a]; } 3.471 + 3.472 + typedef False NodeNumTag; 3.473 + typedef False EdgeNumTag; 3.474 + 3.475 + typedef FindEdgeTagIndicator<Digraph> FindEdgeTag; 3.476 + Arc findArc(const Node& source, const Node& target, 3.477 + const Arc& prev = INVALID) { 3.478 + if (!(*_node_filter)[source] || !(*_node_filter)[target]) { 3.479 + return INVALID; 3.480 + } 3.481 + Arc arc = Parent::findArc(source, target, prev); 3.482 + while (arc != INVALID && !(*_arc_filter)[arc]) { 3.483 + arc = Parent::findArc(source, target, arc); 3.484 + } 3.485 + return arc; 3.486 + } 3.487 + 3.488 + template <typename _Value> 3.489 + class NodeMap : public SubMapExtender<Adaptor, 3.490 + typename Parent::template NodeMap<_Value> > { 3.491 + public: 3.492 + typedef _Value Value; 3.493 + typedef SubMapExtender<Adaptor, typename Parent:: 3.494 + template NodeMap<Value> > MapParent; 3.495 + 3.496 + NodeMap(const Adaptor& adaptor) 3.497 + : MapParent(adaptor) {} 3.498 + NodeMap(const Adaptor& adaptor, const Value& value) 3.499 + : MapParent(adaptor, value) {} 3.500 + 3.501 + private: 3.502 + NodeMap& operator=(const NodeMap& cmap) { 3.503 + return operator=<NodeMap>(cmap); 3.504 + } 3.505 + 3.506 + template <typename CMap> 3.507 + NodeMap& operator=(const CMap& cmap) { 3.508 + MapParent::operator=(cmap); 3.509 + return *this; 3.510 + } 3.511 + }; 3.512 + 3.513 + template <typename _Value> 3.514 + class ArcMap : public SubMapExtender<Adaptor, 3.515 + typename Parent::template ArcMap<_Value> > { 3.516 + public: 3.517 + typedef _Value Value; 3.518 + typedef SubMapExtender<Adaptor, typename Parent:: 3.519 + template ArcMap<Value> > MapParent; 3.520 + 3.521 + ArcMap(const Adaptor& adaptor) 3.522 + : MapParent(adaptor) {} 3.523 + ArcMap(const Adaptor& adaptor, const Value& value) 3.524 + : MapParent(adaptor, value) {} 3.525 + 3.526 + private: 3.527 + ArcMap& operator=(const ArcMap& cmap) { 3.528 + return operator=<ArcMap>(cmap); 3.529 + } 3.530 + 3.531 + template <typename CMap> 3.532 + ArcMap& operator=(const CMap& cmap) { 3.533 + MapParent::operator=(cmap); 3.534 + return *this; 3.535 + } 3.536 + }; 3.537 + 3.538 + }; 3.539 + 3.540 + template <typename _Digraph, typename _NodeFilterMap, typename _ArcFilterMap> 3.541 + class SubDigraphBase<_Digraph, _NodeFilterMap, _ArcFilterMap, false> 3.542 + : public DigraphAdaptorBase<_Digraph> { 3.543 + public: 3.544 + typedef _Digraph Digraph; 3.545 + typedef _NodeFilterMap NodeFilterMap; 3.546 + typedef _ArcFilterMap ArcFilterMap; 3.547 + 3.548 + typedef SubDigraphBase Adaptor; 3.549 + typedef DigraphAdaptorBase<Digraph> Parent; 3.550 + protected: 3.551 + NodeFilterMap* _node_filter; 3.552 + ArcFilterMap* _arc_filter; 3.553 + SubDigraphBase() 3.554 + : Parent(), _node_filter(0), _arc_filter(0) { } 3.555 + 3.556 + void setNodeFilterMap(NodeFilterMap& node_filter) { 3.557 + _node_filter = &node_filter; 3.558 + } 3.559 + void setArcFilterMap(ArcFilterMap& arc_filter) { 3.560 + _arc_filter = &arc_filter; 3.561 + } 3.562 + 3.563 + public: 3.564 + 3.565 + typedef typename Parent::Node Node; 3.566 + typedef typename Parent::Arc Arc; 3.567 + 3.568 + void first(Node& i) const { 3.569 + Parent::first(i); 3.570 + while (i!=INVALID && !(*_node_filter)[i]) Parent::next(i); 3.571 + } 3.572 + 3.573 + void first(Arc& i) const { 3.574 + Parent::first(i); 3.575 + while (i!=INVALID && !(*_arc_filter)[i]) Parent::next(i); 3.576 + } 3.577 + 3.578 + void firstIn(Arc& i, const Node& n) const { 3.579 + Parent::firstIn(i, n); 3.580 + while (i!=INVALID && !(*_arc_filter)[i]) Parent::nextIn(i); 3.581 + } 3.582 + 3.583 + void firstOut(Arc& i, const Node& n) const { 3.584 + Parent::firstOut(i, n); 3.585 + while (i!=INVALID && !(*_arc_filter)[i]) Parent::nextOut(i); 3.586 + } 3.587 + 3.588 + void next(Node& i) const { 3.589 + Parent::next(i); 3.590 + while (i!=INVALID && !(*_node_filter)[i]) Parent::next(i); 3.591 + } 3.592 + void next(Arc& i) const { 3.593 + Parent::next(i); 3.594 + while (i!=INVALID && !(*_arc_filter)[i]) Parent::next(i); 3.595 + } 3.596 + void nextIn(Arc& i) const { 3.597 + Parent::nextIn(i); 3.598 + while (i!=INVALID && !(*_arc_filter)[i]) Parent::nextIn(i); 3.599 + } 3.600 + 3.601 + void nextOut(Arc& i) const { 3.602 + Parent::nextOut(i); 3.603 + while (i!=INVALID && !(*_arc_filter)[i]) Parent::nextOut(i); 3.604 + } 3.605 + 3.606 + void hide(const Node& n) const { _node_filter->set(n, false); } 3.607 + void hide(const Arc& e) const { _arc_filter->set(e, false); } 3.608 + 3.609 + void unHide(const Node& n) const { _node_filter->set(n, true); } 3.610 + void unHide(const Arc& e) const { _arc_filter->set(e, true); } 3.611 + 3.612 + bool hidden(const Node& n) const { return !(*_node_filter)[n]; } 3.613 + bool hidden(const Arc& e) const { return !(*_arc_filter)[e]; } 3.614 + 3.615 + typedef False NodeNumTag; 3.616 + typedef False EdgeNumTag; 3.617 + 3.618 + typedef FindEdgeTagIndicator<Digraph> FindEdgeTag; 3.619 + Arc findArc(const Node& source, const Node& target, 3.620 + const Arc& prev = INVALID) { 3.621 + if (!(*_node_filter)[source] || !(*_node_filter)[target]) { 3.622 + return INVALID; 3.623 + } 3.624 + Arc arc = Parent::findArc(source, target, prev); 3.625 + while (arc != INVALID && !(*_arc_filter)[arc]) { 3.626 + arc = Parent::findArc(source, target, arc); 3.627 + } 3.628 + return arc; 3.629 + } 3.630 + 3.631 + template <typename _Value> 3.632 + class NodeMap : public SubMapExtender<Adaptor, 3.633 + typename Parent::template NodeMap<_Value> > { 3.634 + public: 3.635 + typedef _Value Value; 3.636 + typedef SubMapExtender<Adaptor, typename Parent:: 3.637 + template NodeMap<Value> > MapParent; 3.638 + 3.639 + NodeMap(const Adaptor& adaptor) 3.640 + : MapParent(adaptor) {} 3.641 + NodeMap(const Adaptor& adaptor, const Value& value) 3.642 + : MapParent(adaptor, value) {} 3.643 + 3.644 + private: 3.645 + NodeMap& operator=(const NodeMap& cmap) { 3.646 + return operator=<NodeMap>(cmap); 3.647 + } 3.648 + 3.649 + template <typename CMap> 3.650 + NodeMap& operator=(const CMap& cmap) { 3.651 + MapParent::operator=(cmap); 3.652 + return *this; 3.653 + } 3.654 + }; 3.655 + 3.656 + template <typename _Value> 3.657 + class ArcMap : public SubMapExtender<Adaptor, 3.658 + typename Parent::template ArcMap<_Value> > { 3.659 + public: 3.660 + typedef _Value Value; 3.661 + typedef SubMapExtender<Adaptor, typename Parent:: 3.662 + template ArcMap<Value> > MapParent; 3.663 + 3.664 + ArcMap(const Adaptor& adaptor) 3.665 + : MapParent(adaptor) {} 3.666 + ArcMap(const Adaptor& adaptor, const Value& value) 3.667 + : MapParent(adaptor, value) {} 3.668 + 3.669 + private: 3.670 + ArcMap& operator=(const ArcMap& cmap) { 3.671 + return operator=<ArcMap>(cmap); 3.672 + } 3.673 + 3.674 + template <typename CMap> 3.675 + ArcMap& operator=(const CMap& cmap) { 3.676 + MapParent::operator=(cmap); 3.677 + return *this; 3.678 + } 3.679 + }; 3.680 + 3.681 + }; 3.682 + 3.683 + /// \ingroup graph_adaptors 3.684 + /// 3.685 + /// \brief An adaptor for hiding nodes and arcs in a digraph 3.686 + /// 3.687 + /// SubDigraph hides nodes and arcs in a digraph. A bool node map 3.688 + /// and a bool arc map must be specified, which define the filters 3.689 + /// for nodes and arcs. Just the nodes and arcs with true value are 3.690 + /// shown in the subdigraph. The SubDigraph is conform to the \ref 3.691 + /// concepts::Digraph "Digraph concept". If the \c _checked parameter 3.692 + /// is true, then the arcs incident to filtered nodes are also 3.693 + /// filtered out. 3.694 + /// 3.695 + /// \tparam _Digraph It must be conform to the \ref 3.696 + /// concepts::Digraph "Digraph concept". The type can be specified 3.697 + /// to const. 3.698 + /// \tparam _NodeFilterMap A bool valued node map of the the adapted digraph. 3.699 + /// \tparam _ArcFilterMap A bool valued arc map of the the adapted digraph. 3.700 + /// \tparam _checked If the parameter is false then the arc filtering 3.701 + /// is not checked with respect to node filter. Otherwise, each arc 3.702 + /// is automatically filtered, which is incident to a filtered node. 3.703 + /// 3.704 + /// \see FilterNodes 3.705 + /// \see FilterArcs 3.706 + template<typename _Digraph, 3.707 + typename _NodeFilterMap = typename _Digraph::template NodeMap<bool>, 3.708 + typename _ArcFilterMap = typename _Digraph::template ArcMap<bool>, 3.709 + bool _checked = true> 3.710 + class SubDigraph 3.711 + : public DigraphAdaptorExtender< 3.712 + SubDigraphBase<_Digraph, _NodeFilterMap, _ArcFilterMap, _checked> > { 3.713 + public: 3.714 + typedef _Digraph Digraph; 3.715 + typedef _NodeFilterMap NodeFilterMap; 3.716 + typedef _ArcFilterMap ArcFilterMap; 3.717 + 3.718 + typedef DigraphAdaptorExtender< 3.719 + SubDigraphBase<Digraph, NodeFilterMap, ArcFilterMap, _checked> > 3.720 + Parent; 3.721 + 3.722 + typedef typename Parent::Node Node; 3.723 + typedef typename Parent::Arc Arc; 3.724 + 3.725 + protected: 3.726 + SubDigraph() { } 3.727 + public: 3.728 + 3.729 + /// \brief Constructor 3.730 + /// 3.731 + /// Creates a subdigraph for the given digraph with 3.732 + /// given node and arc map filters. 3.733 + SubDigraph(Digraph& digraph, NodeFilterMap& node_filter, 3.734 + ArcFilterMap& arc_filter) { 3.735 + setDigraph(digraph); 3.736 + setNodeFilterMap(node_filter); 3.737 + setArcFilterMap(arc_filter); 3.738 + } 3.739 + 3.740 + /// \brief Hides the node of the graph 3.741 + /// 3.742 + /// This function hides \c n in the digraph, i.e. the iteration 3.743 + /// jumps over it. This is done by simply setting the value of \c n 3.744 + /// to be false in the corresponding node-map. 3.745 + void hide(const Node& n) const { Parent::hide(n); } 3.746 + 3.747 + /// \brief Hides the arc of the graph 3.748 + /// 3.749 + /// This function hides \c a in the digraph, i.e. the iteration 3.750 + /// jumps over it. This is done by simply setting the value of \c a 3.751 + /// to be false in the corresponding arc-map. 3.752 + void hide(const Arc& a) const { Parent::hide(a); } 3.753 + 3.754 + /// \brief Unhides the node of the graph 3.755 + /// 3.756 + /// The value of \c n is set to be true in the node-map which stores 3.757 + /// hide information. If \c n was hidden previuosly, then it is shown 3.758 + /// again 3.759 + void unHide(const Node& n) const { Parent::unHide(n); } 3.760 + 3.761 + /// \brief Unhides the arc of the graph 3.762 + /// 3.763 + /// The value of \c a is set to be true in the arc-map which stores 3.764 + /// hide information. If \c a was hidden previuosly, then it is shown 3.765 + /// again 3.766 + void unHide(const Arc& a) const { Parent::unHide(a); } 3.767 + 3.768 + /// \brief Returns true if \c n is hidden. 3.769 + /// 3.770 + /// Returns true if \c n is hidden. 3.771 + /// 3.772 + bool hidden(const Node& n) const { return Parent::hidden(n); } 3.773 + 3.774 + /// \brief Returns true if \c a is hidden. 3.775 + /// 3.776 + /// Returns true if \c a is hidden. 3.777 + /// 3.778 + bool hidden(const Arc& a) const { return Parent::hidden(a); } 3.779 + 3.780 + }; 3.781 + 3.782 + /// \brief Just gives back a subdigraph 3.783 + /// 3.784 + /// Just gives back a subdigraph 3.785 + template<typename Digraph, typename NodeFilterMap, typename ArcFilterMap> 3.786 + SubDigraph<const Digraph, NodeFilterMap, ArcFilterMap> 3.787 + subDigraph(const Digraph& digraph, NodeFilterMap& nfm, ArcFilterMap& afm) { 3.788 + return SubDigraph<const Digraph, NodeFilterMap, ArcFilterMap> 3.789 + (digraph, nfm, afm); 3.790 + } 3.791 + 3.792 + template<typename Digraph, typename NodeFilterMap, typename ArcFilterMap> 3.793 + SubDigraph<const Digraph, const NodeFilterMap, ArcFilterMap> 3.794 + subDigraph(const Digraph& digraph, 3.795 + const NodeFilterMap& nfm, ArcFilterMap& afm) { 3.796 + return SubDigraph<const Digraph, const NodeFilterMap, ArcFilterMap> 3.797 + (digraph, nfm, afm); 3.798 + } 3.799 + 3.800 + template<typename Digraph, typename NodeFilterMap, typename ArcFilterMap> 3.801 + SubDigraph<const Digraph, NodeFilterMap, const ArcFilterMap> 3.802 + subDigraph(const Digraph& digraph, 3.803 + NodeFilterMap& nfm, const ArcFilterMap& afm) { 3.804 + return SubDigraph<const Digraph, NodeFilterMap, const ArcFilterMap> 3.805 + (digraph, nfm, afm); 3.806 + } 3.807 + 3.808 + template<typename Digraph, typename NodeFilterMap, typename ArcFilterMap> 3.809 + SubDigraph<const Digraph, const NodeFilterMap, const ArcFilterMap> 3.810 + subDigraph(const Digraph& digraph, 3.811 + const NodeFilterMap& nfm, const ArcFilterMap& afm) { 3.812 + return SubDigraph<const Digraph, const NodeFilterMap, 3.813 + const ArcFilterMap>(digraph, nfm, afm); 3.814 + } 3.815 + 3.816 + 3.817 + template <typename _Graph, typename NodeFilterMap, 3.818 + typename EdgeFilterMap, bool _checked = true> 3.819 + class SubGraphBase : public GraphAdaptorBase<_Graph> { 3.820 + public: 3.821 + typedef _Graph Graph; 3.822 + typedef SubGraphBase Adaptor; 3.823 + typedef GraphAdaptorBase<_Graph> Parent; 3.824 + protected: 3.825 + 3.826 + NodeFilterMap* _node_filter_map; 3.827 + EdgeFilterMap* _edge_filter_map; 3.828 + 3.829 + SubGraphBase() 3.830 + : Parent(), _node_filter_map(0), _edge_filter_map(0) { } 3.831 + 3.832 + void setNodeFilterMap(NodeFilterMap& node_filter_map) { 3.833 + _node_filter_map=&node_filter_map; 3.834 + } 3.835 + void setEdgeFilterMap(EdgeFilterMap& edge_filter_map) { 3.836 + _edge_filter_map=&edge_filter_map; 3.837 + } 3.838 + 3.839 + public: 3.840 + 3.841 + typedef typename Parent::Node Node; 3.842 + typedef typename Parent::Arc Arc; 3.843 + typedef typename Parent::Edge Edge; 3.844 + 3.845 + void first(Node& i) const { 3.846 + Parent::first(i); 3.847 + while (i!=INVALID && !(*_node_filter_map)[i]) Parent::next(i); 3.848 + } 3.849 + 3.850 + void first(Arc& i) const { 3.851 + Parent::first(i); 3.852 + while (i!=INVALID && (!(*_edge_filter_map)[i] 3.853 + || !(*_node_filter_map)[Parent::source(i)] 3.854 + || !(*_node_filter_map)[Parent::target(i)])) 3.855 + Parent::next(i); 3.856 + } 3.857 + 3.858 + void first(Edge& i) const { 3.859 + Parent::first(i); 3.860 + while (i!=INVALID && (!(*_edge_filter_map)[i] 3.861 + || !(*_node_filter_map)[Parent::u(i)] 3.862 + || !(*_node_filter_map)[Parent::v(i)])) 3.863 + Parent::next(i); 3.864 + } 3.865 + 3.866 + void firstIn(Arc& i, const Node& n) const { 3.867 + Parent::firstIn(i, n); 3.868 + while (i!=INVALID && (!(*_edge_filter_map)[i] 3.869 + || !(*_node_filter_map)[Parent::source(i)])) 3.870 + Parent::nextIn(i); 3.871 + } 3.872 + 3.873 + void firstOut(Arc& i, const Node& n) const { 3.874 + Parent::firstOut(i, n); 3.875 + while (i!=INVALID && (!(*_edge_filter_map)[i] 3.876 + || !(*_node_filter_map)[Parent::target(i)])) 3.877 + Parent::nextOut(i); 3.878 + } 3.879 + 3.880 + void firstInc(Edge& i, bool& d, const Node& n) const { 3.881 + Parent::firstInc(i, d, n); 3.882 + while (i!=INVALID && (!(*_edge_filter_map)[i] 3.883 + || !(*_node_filter_map)[Parent::u(i)] 3.884 + || !(*_node_filter_map)[Parent::v(i)])) 3.885 + Parent::nextInc(i, d); 3.886 + } 3.887 + 3.888 + void next(Node& i) const { 3.889 + Parent::next(i); 3.890 + while (i!=INVALID && !(*_node_filter_map)[i]) Parent::next(i); 3.891 + } 3.892 + 3.893 + void next(Arc& i) const { 3.894 + Parent::next(i); 3.895 + while (i!=INVALID && (!(*_edge_filter_map)[i] 3.896 + || !(*_node_filter_map)[Parent::source(i)] 3.897 + || !(*_node_filter_map)[Parent::target(i)])) 3.898 + Parent::next(i); 3.899 + } 3.900 + 3.901 + void next(Edge& i) const { 3.902 + Parent::next(i); 3.903 + while (i!=INVALID && (!(*_edge_filter_map)[i] 3.904 + || !(*_node_filter_map)[Parent::u(i)] 3.905 + || !(*_node_filter_map)[Parent::v(i)])) 3.906 + Parent::next(i); 3.907 + } 3.908 + 3.909 + void nextIn(Arc& i) const { 3.910 + Parent::nextIn(i); 3.911 + while (i!=INVALID && (!(*_edge_filter_map)[i] 3.912 + || !(*_node_filter_map)[Parent::source(i)])) 3.913 + Parent::nextIn(i); 3.914 + } 3.915 + 3.916 + void nextOut(Arc& i) const { 3.917 + Parent::nextOut(i); 3.918 + while (i!=INVALID && (!(*_edge_filter_map)[i] 3.919 + || !(*_node_filter_map)[Parent::target(i)])) 3.920 + Parent::nextOut(i); 3.921 + } 3.922 + 3.923 + void nextInc(Edge& i, bool& d) const { 3.924 + Parent::nextInc(i, d); 3.925 + while (i!=INVALID && (!(*_edge_filter_map)[i] 3.926 + || !(*_node_filter_map)[Parent::u(i)] 3.927 + || !(*_node_filter_map)[Parent::v(i)])) 3.928 + Parent::nextInc(i, d); 3.929 + } 3.930 + 3.931 + void hide(const Node& n) const { _node_filter_map->set(n, false); } 3.932 + void hide(const Edge& e) const { _edge_filter_map->set(e, false); } 3.933 + 3.934 + void unHide(const Node& n) const { _node_filter_map->set(n, true); } 3.935 + void unHide(const Edge& e) const { _edge_filter_map->set(e, true); } 3.936 + 3.937 + bool hidden(const Node& n) const { return !(*_node_filter_map)[n]; } 3.938 + bool hidden(const Edge& e) const { return !(*_edge_filter_map)[e]; } 3.939 + 3.940 + typedef False NodeNumTag; 3.941 + typedef False EdgeNumTag; 3.942 + 3.943 + typedef FindEdgeTagIndicator<Graph> FindEdgeTag; 3.944 + Arc findArc(const Node& u, const Node& v, 3.945 + const Arc& prev = INVALID) { 3.946 + if (!(*_node_filter_map)[u] || !(*_node_filter_map)[v]) { 3.947 + return INVALID; 3.948 + } 3.949 + Arc arc = Parent::findArc(u, v, prev); 3.950 + while (arc != INVALID && !(*_edge_filter_map)[arc]) { 3.951 + arc = Parent::findArc(u, v, arc); 3.952 + } 3.953 + return arc; 3.954 + } 3.955 + Edge findEdge(const Node& u, const Node& v, 3.956 + const Edge& prev = INVALID) { 3.957 + if (!(*_node_filter_map)[u] || !(*_node_filter_map)[v]) { 3.958 + return INVALID; 3.959 + } 3.960 + Edge edge = Parent::findEdge(u, v, prev); 3.961 + while (edge != INVALID && !(*_edge_filter_map)[edge]) { 3.962 + edge = Parent::findEdge(u, v, edge); 3.963 + } 3.964 + return edge; 3.965 + } 3.966 + 3.967 + template <typename _Value> 3.968 + class NodeMap : public SubMapExtender<Adaptor, 3.969 + typename Parent::template NodeMap<_Value> > { 3.970 + public: 3.971 + typedef _Value Value; 3.972 + typedef SubMapExtender<Adaptor, typename Parent:: 3.973 + template NodeMap<Value> > MapParent; 3.974 + 3.975 + NodeMap(const Adaptor& adaptor) 3.976 + : MapParent(adaptor) {} 3.977 + NodeMap(const Adaptor& adaptor, const Value& value) 3.978 + : MapParent(adaptor, value) {} 3.979 + 3.980 + private: 3.981 + NodeMap& operator=(const NodeMap& cmap) { 3.982 + return operator=<NodeMap>(cmap); 3.983 + } 3.984 + 3.985 + template <typename CMap> 3.986 + NodeMap& operator=(const CMap& cmap) { 3.987 + MapParent::operator=(cmap); 3.988 + return *this; 3.989 + } 3.990 + }; 3.991 + 3.992 + template <typename _Value> 3.993 + class ArcMap : public SubMapExtender<Adaptor, 3.994 + typename Parent::template ArcMap<_Value> > { 3.995 + public: 3.996 + typedef _Value Value; 3.997 + typedef SubMapExtender<Adaptor, typename Parent:: 3.998 + template ArcMap<Value> > MapParent; 3.999 + 3.1000 + ArcMap(const Adaptor& adaptor) 3.1001 + : MapParent(adaptor) {} 3.1002 + ArcMap(const Adaptor& adaptor, const Value& value) 3.1003 + : MapParent(adaptor, value) {} 3.1004 + 3.1005 + private: 3.1006 + ArcMap& operator=(const ArcMap& cmap) { 3.1007 + return operator=<ArcMap>(cmap); 3.1008 + } 3.1009 + 3.1010 + template <typename CMap> 3.1011 + ArcMap& operator=(const CMap& cmap) { 3.1012 + MapParent::operator=(cmap); 3.1013 + return *this; 3.1014 + } 3.1015 + }; 3.1016 + 3.1017 + template <typename _Value> 3.1018 + class EdgeMap : public SubMapExtender<Adaptor, 3.1019 + typename Parent::template EdgeMap<_Value> > { 3.1020 + public: 3.1021 + typedef _Value Value; 3.1022 + typedef SubMapExtender<Adaptor, typename Parent:: 3.1023 + template EdgeMap<Value> > MapParent; 3.1024 + 3.1025 + EdgeMap(const Adaptor& adaptor) 3.1026 + : MapParent(adaptor) {} 3.1027 + 3.1028 + EdgeMap(const Adaptor& adaptor, const Value& value) 3.1029 + : MapParent(adaptor, value) {} 3.1030 + 3.1031 + private: 3.1032 + EdgeMap& operator=(const EdgeMap& cmap) { 3.1033 + return operator=<EdgeMap>(cmap); 3.1034 + } 3.1035 + 3.1036 + template <typename CMap> 3.1037 + EdgeMap& operator=(const CMap& cmap) { 3.1038 + MapParent::operator=(cmap); 3.1039 + return *this; 3.1040 + } 3.1041 + }; 3.1042 + 3.1043 + }; 3.1044 + 3.1045 + template <typename _Graph, typename NodeFilterMap, typename EdgeFilterMap> 3.1046 + class SubGraphBase<_Graph, NodeFilterMap, EdgeFilterMap, false> 3.1047 + : public GraphAdaptorBase<_Graph> { 3.1048 + public: 3.1049 + typedef _Graph Graph; 3.1050 + typedef SubGraphBase Adaptor; 3.1051 + typedef GraphAdaptorBase<_Graph> Parent; 3.1052 + protected: 3.1053 + NodeFilterMap* _node_filter_map; 3.1054 + EdgeFilterMap* _edge_filter_map; 3.1055 + SubGraphBase() : Parent(), 3.1056 + _node_filter_map(0), _edge_filter_map(0) { } 3.1057 + 3.1058 + void setNodeFilterMap(NodeFilterMap& node_filter_map) { 3.1059 + _node_filter_map=&node_filter_map; 3.1060 + } 3.1061 + void setEdgeFilterMap(EdgeFilterMap& edge_filter_map) { 3.1062 + _edge_filter_map=&edge_filter_map; 3.1063 + } 3.1064 + 3.1065 + public: 3.1066 + 3.1067 + typedef typename Parent::Node Node; 3.1068 + typedef typename Parent::Arc Arc; 3.1069 + typedef typename Parent::Edge Edge; 3.1070 + 3.1071 + void first(Node& i) const { 3.1072 + Parent::first(i); 3.1073 + while (i!=INVALID && !(*_node_filter_map)[i]) Parent::next(i); 3.1074 + } 3.1075 + 3.1076 + void first(Arc& i) const { 3.1077 + Parent::first(i); 3.1078 + while (i!=INVALID && !(*_edge_filter_map)[i]) Parent::next(i); 3.1079 + } 3.1080 + 3.1081 + void first(Edge& i) const { 3.1082 + Parent::first(i); 3.1083 + while (i!=INVALID && !(*_edge_filter_map)[i]) Parent::next(i); 3.1084 + } 3.1085 + 3.1086 + void firstIn(Arc& i, const Node& n) const { 3.1087 + Parent::firstIn(i, n); 3.1088 + while (i!=INVALID && !(*_edge_filter_map)[i]) Parent::nextIn(i); 3.1089 + } 3.1090 + 3.1091 + void firstOut(Arc& i, const Node& n) const { 3.1092 + Parent::firstOut(i, n); 3.1093 + while (i!=INVALID && !(*_edge_filter_map)[i]) Parent::nextOut(i); 3.1094 + } 3.1095 + 3.1096 + void firstInc(Edge& i, bool& d, const Node& n) const { 3.1097 + Parent::firstInc(i, d, n); 3.1098 + while (i!=INVALID && !(*_edge_filter_map)[i]) Parent::nextInc(i, d); 3.1099 + } 3.1100 + 3.1101 + void next(Node& i) const { 3.1102 + Parent::next(i); 3.1103 + while (i!=INVALID && !(*_node_filter_map)[i]) Parent::next(i); 3.1104 + } 3.1105 + void next(Arc& i) const { 3.1106 + Parent::next(i); 3.1107 + while (i!=INVALID && !(*_edge_filter_map)[i]) Parent::next(i); 3.1108 + } 3.1109 + void next(Edge& i) const { 3.1110 + Parent::next(i); 3.1111 + while (i!=INVALID && !(*_edge_filter_map)[i]) Parent::next(i); 3.1112 + } 3.1113 + void nextIn(Arc& i) const { 3.1114 + Parent::nextIn(i); 3.1115 + while (i!=INVALID && !(*_edge_filter_map)[i]) Parent::nextIn(i); 3.1116 + } 3.1117 + 3.1118 + void nextOut(Arc& i) const { 3.1119 + Parent::nextOut(i); 3.1120 + while (i!=INVALID && !(*_edge_filter_map)[i]) Parent::nextOut(i); 3.1121 + } 3.1122 + void nextInc(Edge& i, bool& d) const { 3.1123 + Parent::nextInc(i, d); 3.1124 + while (i!=INVALID && !(*_edge_filter_map)[i]) Parent::nextInc(i, d); 3.1125 + } 3.1126 + 3.1127 + void hide(const Node& n) const { _node_filter_map->set(n, false); } 3.1128 + void hide(const Edge& e) const { _edge_filter_map->set(e, false); } 3.1129 + 3.1130 + void unHide(const Node& n) const { _node_filter_map->set(n, true); } 3.1131 + void unHide(const Edge& e) const { _edge_filter_map->set(e, true); } 3.1132 + 3.1133 + bool hidden(const Node& n) const { return !(*_node_filter_map)[n]; } 3.1134 + bool hidden(const Edge& e) const { return !(*_edge_filter_map)[e]; } 3.1135 + 3.1136 + typedef False NodeNumTag; 3.1137 + typedef False EdgeNumTag; 3.1138 + 3.1139 + typedef FindEdgeTagIndicator<Graph> FindEdgeTag; 3.1140 + Arc findArc(const Node& u, const Node& v, 3.1141 + const Arc& prev = INVALID) { 3.1142 + Arc arc = Parent::findArc(u, v, prev); 3.1143 + while (arc != INVALID && !(*_edge_filter_map)[arc]) { 3.1144 + arc = Parent::findArc(u, v, arc); 3.1145 + } 3.1146 + return arc; 3.1147 + } 3.1148 + Edge findEdge(const Node& u, const Node& v, 3.1149 + const Edge& prev = INVALID) { 3.1150 + Edge edge = Parent::findEdge(u, v, prev); 3.1151 + while (edge != INVALID && !(*_edge_filter_map)[edge]) { 3.1152 + edge = Parent::findEdge(u, v, edge); 3.1153 + } 3.1154 + return edge; 3.1155 + } 3.1156 + 3.1157 + template <typename _Value> 3.1158 + class NodeMap : public SubMapExtender<Adaptor, 3.1159 + typename Parent::template NodeMap<_Value> > { 3.1160 + public: 3.1161 + typedef _Value Value; 3.1162 + typedef SubMapExtender<Adaptor, typename Parent:: 3.1163 + template NodeMap<Value> > MapParent; 3.1164 + 3.1165 + NodeMap(const Adaptor& adaptor) 3.1166 + : MapParent(adaptor) {} 3.1167 + NodeMap(const Adaptor& adaptor, const Value& value) 3.1168 + : MapParent(adaptor, value) {} 3.1169 + 3.1170 + private: 3.1171 + NodeMap& operator=(const NodeMap& cmap) { 3.1172 + return operator=<NodeMap>(cmap); 3.1173 + } 3.1174 + 3.1175 + template <typename CMap> 3.1176 + NodeMap& operator=(const CMap& cmap) { 3.1177 + MapParent::operator=(cmap); 3.1178 + return *this; 3.1179 + } 3.1180 + }; 3.1181 + 3.1182 + template <typename _Value> 3.1183 + class ArcMap : public SubMapExtender<Adaptor, 3.1184 + typename Parent::template ArcMap<_Value> > { 3.1185 + public: 3.1186 + typedef _Value Value; 3.1187 + typedef SubMapExtender<Adaptor, typename Parent:: 3.1188 + template ArcMap<Value> > MapParent; 3.1189 + 3.1190 + ArcMap(const Adaptor& adaptor) 3.1191 + : MapParent(adaptor) {} 3.1192 + ArcMap(const Adaptor& adaptor, const Value& value) 3.1193 + : MapParent(adaptor, value) {} 3.1194 + 3.1195 + private: 3.1196 + ArcMap& operator=(const ArcMap& cmap) { 3.1197 + return operator=<ArcMap>(cmap); 3.1198 + } 3.1199 + 3.1200 + template <typename CMap> 3.1201 + ArcMap& operator=(const CMap& cmap) { 3.1202 + MapParent::operator=(cmap); 3.1203 + return *this; 3.1204 + } 3.1205 + }; 3.1206 + 3.1207 + template <typename _Value> 3.1208 + class EdgeMap : public SubMapExtender<Adaptor, 3.1209 + typename Parent::template EdgeMap<_Value> > { 3.1210 + public: 3.1211 + typedef _Value Value; 3.1212 + typedef SubMapExtender<Adaptor, typename Parent:: 3.1213 + template EdgeMap<Value> > MapParent; 3.1214 + 3.1215 + EdgeMap(const Adaptor& adaptor) 3.1216 + : MapParent(adaptor) {} 3.1217 + 3.1218 + EdgeMap(const Adaptor& adaptor, const _Value& value) 3.1219 + : MapParent(adaptor, value) {} 3.1220 + 3.1221 + private: 3.1222 + EdgeMap& operator=(const EdgeMap& cmap) { 3.1223 + return operator=<EdgeMap>(cmap); 3.1224 + } 3.1225 + 3.1226 + template <typename CMap> 3.1227 + EdgeMap& operator=(const CMap& cmap) { 3.1228 + MapParent::operator=(cmap); 3.1229 + return *this; 3.1230 + } 3.1231 + }; 3.1232 + 3.1233 + }; 3.1234 + 3.1235 + /// \ingroup graph_adaptors 3.1236 + /// 3.1237 + /// \brief A graph adaptor for hiding nodes and edges in an 3.1238 + /// undirected graph. 3.1239 + /// 3.1240 + /// SubGraph hides nodes and edges in a graph. A bool node map and a 3.1241 + /// bool edge map must be specified, which define the filters for 3.1242 + /// nodes and edges. Just the nodes and edges with true value are 3.1243 + /// shown in the subgraph. The SubGraph is conform to the \ref 3.1244 + /// concepts::Graph "Graph concept". If the \c _checked parameter is 3.1245 + /// true, then the edges incident to filtered nodes are also 3.1246 + /// filtered out. 3.1247 + /// 3.1248 + /// \tparam _Graph It must be conform to the \ref 3.1249 + /// concepts::Graph "Graph concept". The type can be specified 3.1250 + /// to const. 3.1251 + /// \tparam _NodeFilterMap A bool valued node map of the the adapted graph. 3.1252 + /// \tparam _EdgeFilterMap A bool valued edge map of the the adapted graph. 3.1253 + /// \tparam _checked If the parameter is false then the edge filtering 3.1254 + /// is not checked with respect to node filter. Otherwise, each edge 3.1255 + /// is automatically filtered, which is incident to a filtered node. 3.1256 + /// 3.1257 + /// \see FilterNodes 3.1258 + /// \see FilterEdges 3.1259 + template<typename _Graph, typename NodeFilterMap, 3.1260 + typename EdgeFilterMap, bool _checked = true> 3.1261 + class SubGraph 3.1262 + : public GraphAdaptorExtender< 3.1263 + SubGraphBase<_Graph, NodeFilterMap, EdgeFilterMap, _checked> > { 3.1264 + public: 3.1265 + typedef _Graph Graph; 3.1266 + typedef GraphAdaptorExtender< 3.1267 + SubGraphBase<_Graph, NodeFilterMap, EdgeFilterMap> > Parent; 3.1268 + 3.1269 + typedef typename Parent::Node Node; 3.1270 + typedef typename Parent::Edge Edge; 3.1271 + 3.1272 + protected: 3.1273 + SubGraph() { } 3.1274 + public: 3.1275 + 3.1276 + /// \brief Constructor 3.1277 + /// 3.1278 + /// Creates a subgraph for the given graph with given node and 3.1279 + /// edge map filters. 3.1280 + SubGraph(Graph& _graph, NodeFilterMap& node_filter_map, 3.1281 + EdgeFilterMap& edge_filter_map) { 3.1282 + setGraph(_graph); 3.1283 + setNodeFilterMap(node_filter_map); 3.1284 + setEdgeFilterMap(edge_filter_map); 3.1285 + } 3.1286 + 3.1287 + /// \brief Hides the node of the graph 3.1288 + /// 3.1289 + /// This function hides \c n in the graph, i.e. the iteration 3.1290 + /// jumps over it. This is done by simply setting the value of \c n 3.1291 + /// to be false in the corresponding node-map. 3.1292 + void hide(const Node& n) const { Parent::hide(n); } 3.1293 + 3.1294 + /// \brief Hides the edge of the graph 3.1295 + /// 3.1296 + /// This function hides \c e in the graph, i.e. the iteration 3.1297 + /// jumps over it. This is done by simply setting the value of \c e 3.1298 + /// to be false in the corresponding edge-map. 3.1299 + void hide(const Edge& e) const { Parent::hide(e); } 3.1300 + 3.1301 + /// \brief Unhides the node of the graph 3.1302 + /// 3.1303 + /// The value of \c n is set to be true in the node-map which stores 3.1304 + /// hide information. If \c n was hidden previuosly, then it is shown 3.1305 + /// again 3.1306 + void unHide(const Node& n) const { Parent::unHide(n); } 3.1307 + 3.1308 + /// \brief Unhides the edge of the graph 3.1309 + /// 3.1310 + /// The value of \c e is set to be true in the edge-map which stores 3.1311 + /// hide information. If \c e was hidden previuosly, then it is shown 3.1312 + /// again 3.1313 + void unHide(const Edge& e) const { Parent::unHide(e); } 3.1314 + 3.1315 + /// \brief Returns true if \c n is hidden. 3.1316 + /// 3.1317 + /// Returns true if \c n is hidden. 3.1318 + /// 3.1319 + bool hidden(const Node& n) const { return Parent::hidden(n); } 3.1320 + 3.1321 + /// \brief Returns true if \c e is hidden. 3.1322 + /// 3.1323 + /// Returns true if \c e is hidden. 3.1324 + /// 3.1325 + bool hidden(const Edge& e) const { return Parent::hidden(e); } 3.1326 + }; 3.1327 + 3.1328 + /// \brief Just gives back a subgraph 3.1329 + /// 3.1330 + /// Just gives back a subgraph 3.1331 + template<typename Graph, typename NodeFilterMap, typename ArcFilterMap> 3.1332 + SubGraph<const Graph, NodeFilterMap, ArcFilterMap> 3.1333 + subGraph(const Graph& graph, NodeFilterMap& nfm, ArcFilterMap& efm) { 3.1334 + return SubGraph<const Graph, NodeFilterMap, ArcFilterMap>(graph, nfm, efm); 3.1335 + } 3.1336 + 3.1337 + template<typename Graph, typename NodeFilterMap, typename ArcFilterMap> 3.1338 + SubGraph<const Graph, const NodeFilterMap, ArcFilterMap> 3.1339 + subGraph(const Graph& graph, 3.1340 + const NodeFilterMap& nfm, ArcFilterMap& efm) { 3.1341 + return SubGraph<const Graph, const NodeFilterMap, ArcFilterMap> 3.1342 + (graph, nfm, efm); 3.1343 + } 3.1344 + 3.1345 + template<typename Graph, typename NodeFilterMap, typename ArcFilterMap> 3.1346 + SubGraph<const Graph, NodeFilterMap, const ArcFilterMap> 3.1347 + subGraph(const Graph& graph, 3.1348 + NodeFilterMap& nfm, const ArcFilterMap& efm) { 3.1349 + return SubGraph<const Graph, NodeFilterMap, const ArcFilterMap> 3.1350 + (graph, nfm, efm); 3.1351 + } 3.1352 + 3.1353 + template<typename Graph, typename NodeFilterMap, typename ArcFilterMap> 3.1354 + SubGraph<const Graph, const NodeFilterMap, const ArcFilterMap> 3.1355 + subGraph(const Graph& graph, 3.1356 + const NodeFilterMap& nfm, const ArcFilterMap& efm) { 3.1357 + return SubGraph<const Graph, const NodeFilterMap, const ArcFilterMap> 3.1358 + (graph, nfm, efm); 3.1359 + } 3.1360 + 3.1361 + /// \ingroup graph_adaptors 3.1362 + /// 3.1363 + /// \brief An adaptor for hiding nodes from a digraph or a graph. 3.1364 + /// 3.1365 + /// FilterNodes adaptor hides nodes in a graph or a digraph. A bool 3.1366 + /// node map must be specified, which defines the filters for 3.1367 + /// nodes. Just the unfiltered nodes and the arcs or edges incident 3.1368 + /// to unfiltered nodes are shown in the subdigraph or subgraph. The 3.1369 + /// FilterNodes is conform to the \ref concepts::Digraph 3.1370 + /// "Digraph concept" or \ref concepts::Graph "Graph concept" depending 3.1371 + /// on the \c _Digraph template parameter. If the \c _checked 3.1372 + /// parameter is true, then the arc or edges incident to filtered nodes 3.1373 + /// are also filtered out. 3.1374 + /// 3.1375 + /// \tparam _Digraph It must be conform to the \ref 3.1376 + /// concepts::Digraph "Digraph concept" or \ref concepts::Graph 3.1377 + /// "Graph concept". The type can be specified to be const. 3.1378 + /// \tparam _NodeFilterMap A bool valued node map of the the adapted graph. 3.1379 + /// \tparam _checked If the parameter is false then the arc or edge 3.1380 + /// filtering is not checked with respect to node filter. In this 3.1381 + /// case just isolated nodes can be filtered out from the 3.1382 + /// graph. 3.1383 +#ifdef DOXYGEN 3.1384 + template<typename _Digraph, 3.1385 + typename _NodeFilterMap = typename _Digraph::template NodeMap<bool>, 3.1386 + bool _checked = true> 3.1387 +#else 3.1388 + template<typename _Digraph, 3.1389 + typename _NodeFilterMap = typename _Digraph::template NodeMap<bool>, 3.1390 + bool _checked = true, 3.1391 + typename Enable = void> 3.1392 +#endif 3.1393 + class FilterNodes 3.1394 + : public SubDigraph<_Digraph, _NodeFilterMap, 3.1395 + ConstMap<typename _Digraph::Arc, bool>, _checked> { 3.1396 + public: 3.1397 + 3.1398 + typedef _Digraph Digraph; 3.1399 + typedef _NodeFilterMap NodeFilterMap; 3.1400 + 3.1401 + typedef SubDigraph<Digraph, NodeFilterMap, 3.1402 + ConstMap<typename Digraph::Arc, bool>, _checked> 3.1403 + Parent; 3.1404 + 3.1405 + typedef typename Parent::Node Node; 3.1406 + 3.1407 + protected: 3.1408 + ConstMap<typename Digraph::Arc, bool> const_true_map; 3.1409 + 3.1410 + FilterNodes() : const_true_map(true) { 3.1411 + Parent::setArcFilterMap(const_true_map); 3.1412 + } 3.1413 + 3.1414 + public: 3.1415 + 3.1416 + /// \brief Constructor 3.1417 + /// 3.1418 + /// Creates an adaptor for the given digraph or graph with 3.1419 + /// given node filter map. 3.1420 + FilterNodes(Digraph& _digraph, NodeFilterMap& node_filter) : 3.1421 + Parent(), const_true_map(true) { 3.1422 + Parent::setDigraph(_digraph); 3.1423 + Parent::setNodeFilterMap(node_filter); 3.1424 + Parent::setArcFilterMap(const_true_map); 3.1425 + } 3.1426 + 3.1427 + /// \brief Hides the node of the graph 3.1428 + /// 3.1429 + /// This function hides \c n in the digraph or graph, i.e. the iteration 3.1430 + /// jumps over it. This is done by simply setting the value of \c n 3.1431 + /// to be false in the corresponding node map. 3.1432 + void hide(const Node& n) const { Parent::hide(n); } 3.1433 + 3.1434 + /// \brief Unhides the node of the graph 3.1435 + /// 3.1436 + /// The value of \c n is set to be true in the node-map which stores 3.1437 + /// hide information. If \c n was hidden previuosly, then it is shown 3.1438 + /// again 3.1439 + void unHide(const Node& n) const { Parent::unHide(n); } 3.1440 + 3.1441 + /// \brief Returns true if \c n is hidden. 3.1442 + /// 3.1443 + /// Returns true if \c n is hidden. 3.1444 + /// 3.1445 + bool hidden(const Node& n) const { return Parent::hidden(n); } 3.1446 + 3.1447 + }; 3.1448 + 3.1449 + template<typename _Graph, typename _NodeFilterMap, bool _checked> 3.1450 + class FilterNodes<_Graph, _NodeFilterMap, _checked, 3.1451 + typename enable_if<UndirectedTagIndicator<_Graph> >::type> 3.1452 + : public SubGraph<_Graph, _NodeFilterMap, 3.1453 + ConstMap<typename _Graph::Edge, bool>, _checked> { 3.1454 + public: 3.1455 + typedef _Graph Graph; 3.1456 + typedef _NodeFilterMap NodeFilterMap; 3.1457 + typedef SubGraph<Graph, NodeFilterMap, 3.1458 + ConstMap<typename Graph::Edge, bool> > Parent; 3.1459 + 3.1460 + typedef typename Parent::Node Node; 3.1461 + protected: 3.1462 + ConstMap<typename Graph::Edge, bool> const_true_map; 3.1463 + 3.1464 + FilterNodes() : const_true_map(true) { 3.1465 + Parent::setEdgeFilterMap(const_true_map); 3.1466 + } 3.1467 + 3.1468 + public: 3.1469 + 3.1470 + FilterNodes(Graph& _graph, NodeFilterMap& node_filter_map) : 3.1471 + Parent(), const_true_map(true) { 3.1472 + Parent::setGraph(_graph); 3.1473 + Parent::setNodeFilterMap(node_filter_map); 3.1474 + Parent::setEdgeFilterMap(const_true_map); 3.1475 + } 3.1476 + 3.1477 + void hide(const Node& n) const { Parent::hide(n); } 3.1478 + void unHide(const Node& n) const { Parent::unHide(n); } 3.1479 + bool hidden(const Node& n) const { return Parent::hidden(n); } 3.1480 + 3.1481 + }; 3.1482 + 3.1483 + 3.1484 + /// \brief Just gives back a FilterNodes adaptor 3.1485 + /// 3.1486 + /// Just gives back a FilterNodes adaptor 3.1487 + template<typename Digraph, typename NodeFilterMap> 3.1488 + FilterNodes<const Digraph, NodeFilterMap> 3.1489 + filterNodes(const Digraph& digraph, NodeFilterMap& nfm) { 3.1490 + return FilterNodes<const Digraph, NodeFilterMap>(digraph, nfm); 3.1491 + } 3.1492 + 3.1493 + template<typename Digraph, typename NodeFilterMap> 3.1494 + FilterNodes<const Digraph, const NodeFilterMap> 3.1495 + filterNodes(const Digraph& digraph, const NodeFilterMap& nfm) { 3.1496 + return FilterNodes<const Digraph, const NodeFilterMap>(digraph, nfm); 3.1497 + } 3.1498 + 3.1499 + /// \ingroup graph_adaptors 3.1500 + /// 3.1501 + /// \brief An adaptor for hiding arcs from a digraph. 3.1502 + /// 3.1503 + /// FilterArcs adaptor hides arcs in a digraph. A bool arc map must 3.1504 + /// be specified, which defines the filters for arcs. Just the 3.1505 + /// unfiltered arcs are shown in the subdigraph. The FilterArcs is 3.1506 + /// conform to the \ref concepts::Digraph "Digraph concept". 3.1507 + /// 3.1508 + /// \tparam _Digraph It must be conform to the \ref concepts::Digraph 3.1509 + /// "Digraph concept". The type can be specified to be const. 3.1510 + /// \tparam _ArcFilterMap A bool valued arc map of the the adapted 3.1511 + /// graph. 3.1512 + template<typename _Digraph, typename _ArcFilterMap> 3.1513 + class FilterArcs : 3.1514 + public SubDigraph<_Digraph, ConstMap<typename _Digraph::Node, bool>, 3.1515 + _ArcFilterMap, false> { 3.1516 + public: 3.1517 + typedef _Digraph Digraph; 3.1518 + typedef _ArcFilterMap ArcFilterMap; 3.1519 + 3.1520 + typedef SubDigraph<Digraph, ConstMap<typename Digraph::Node, bool>, 3.1521 + ArcFilterMap, false> Parent; 3.1522 + 3.1523 + typedef typename Parent::Arc Arc; 3.1524 + 3.1525 + protected: 3.1526 + ConstMap<typename Digraph::Node, bool> const_true_map; 3.1527 + 3.1528 + FilterArcs() : const_true_map(true) { 3.1529 + Parent::setNodeFilterMap(const_true_map); 3.1530 + } 3.1531 + 3.1532 + public: 3.1533 + 3.1534 + /// \brief Constructor 3.1535 + /// 3.1536 + /// Creates a FilterArcs adaptor for the given graph with 3.1537 + /// given arc map filter. 3.1538 + FilterArcs(Digraph& digraph, ArcFilterMap& arc_filter) 3.1539 + : Parent(), const_true_map(true) { 3.1540 + Parent::setDigraph(digraph); 3.1541 + Parent::setNodeFilterMap(const_true_map); 3.1542 + Parent::setArcFilterMap(arc_filter); 3.1543 + } 3.1544 + 3.1545 + /// \brief Hides the arc of the graph 3.1546 + /// 3.1547 + /// This function hides \c a in the graph, i.e. the iteration 3.1548 + /// jumps over it. This is done by simply setting the value of \c a 3.1549 + /// to be false in the corresponding arc map. 3.1550 + void hide(const Arc& a) const { Parent::hide(a); } 3.1551 + 3.1552 + /// \brief Unhides the arc of the graph 3.1553 + /// 3.1554 + /// The value of \c a is set to be true in the arc-map which stores 3.1555 + /// hide information. If \c a was hidden previuosly, then it is shown 3.1556 + /// again 3.1557 + void unHide(const Arc& a) const { Parent::unHide(a); } 3.1558 + 3.1559 + /// \brief Returns true if \c a is hidden. 3.1560 + /// 3.1561 + /// Returns true if \c a is hidden. 3.1562 + /// 3.1563 + bool hidden(const Arc& a) const { return Parent::hidden(a); } 3.1564 + 3.1565 + }; 3.1566 + 3.1567 + /// \brief Just gives back an FilterArcs adaptor 3.1568 + /// 3.1569 + /// Just gives back an FilterArcs adaptor 3.1570 + template<typename Digraph, typename ArcFilterMap> 3.1571 + FilterArcs<const Digraph, ArcFilterMap> 3.1572 + filterArcs(const Digraph& digraph, ArcFilterMap& afm) { 3.1573 + return FilterArcs<const Digraph, ArcFilterMap>(digraph, afm); 3.1574 + } 3.1575 + 3.1576 + template<typename Digraph, typename ArcFilterMap> 3.1577 + FilterArcs<const Digraph, const ArcFilterMap> 3.1578 + filterArcs(const Digraph& digraph, const ArcFilterMap& afm) { 3.1579 + return FilterArcs<const Digraph, const ArcFilterMap>(digraph, afm); 3.1580 + } 3.1581 + 3.1582 + /// \ingroup graph_adaptors 3.1583 + /// 3.1584 + /// \brief An adaptor for hiding edges from a graph. 3.1585 + /// 3.1586 + /// FilterEdges adaptor hides edges in a digraph. A bool edge map must 3.1587 + /// be specified, which defines the filters for edges. Just the 3.1588 + /// unfiltered edges are shown in the subdigraph. The FilterEdges is 3.1589 + /// conform to the \ref concepts::Graph "Graph concept". 3.1590 + /// 3.1591 + /// \tparam _Graph It must be conform to the \ref concepts::Graph 3.1592 + /// "Graph concept". The type can be specified to be const. 3.1593 + /// \tparam _EdgeFilterMap A bool valued edge map of the the adapted 3.1594 + /// graph. 3.1595 + template<typename _Graph, typename _EdgeFilterMap> 3.1596 + class FilterEdges : 3.1597 + public SubGraph<_Graph, ConstMap<typename _Graph::Node,bool>, 3.1598 + _EdgeFilterMap, false> { 3.1599 + public: 3.1600 + typedef _Graph Graph; 3.1601 + typedef _EdgeFilterMap EdgeFilterMap; 3.1602 + typedef SubGraph<Graph, ConstMap<typename Graph::Node,bool>, 3.1603 + EdgeFilterMap, false> Parent; 3.1604 + typedef typename Parent::Edge Edge; 3.1605 + protected: 3.1606 + ConstMap<typename Graph::Node, bool> const_true_map; 3.1607 + 3.1608 + FilterEdges() : const_true_map(true) { 3.1609 + Parent::setNodeFilterMap(const_true_map); 3.1610 + } 3.1611 + 3.1612 + public: 3.1613 + 3.1614 + /// \brief Constructor 3.1615 + /// 3.1616 + /// Creates a FilterEdges adaptor for the given graph with 3.1617 + /// given edge map filters. 3.1618 + FilterEdges(Graph& _graph, EdgeFilterMap& edge_filter_map) : 3.1619 + Parent(), const_true_map(true) { 3.1620 + Parent::setGraph(_graph); 3.1621 + Parent::setNodeFilterMap(const_true_map); 3.1622 + Parent::setEdgeFilterMap(edge_filter_map); 3.1623 + } 3.1624 + 3.1625 + /// \brief Hides the edge of the graph 3.1626 + /// 3.1627 + /// This function hides \c e in the graph, i.e. the iteration 3.1628 + /// jumps over it. This is done by simply setting the value of \c e 3.1629 + /// to be false in the corresponding edge-map. 3.1630 + void hide(const Edge& e) const { Parent::hide(e); } 3.1631 + 3.1632 + /// \brief Unhides the edge of the graph 3.1633 + /// 3.1634 + /// The value of \c e is set to be true in the edge-map which stores 3.1635 + /// hide information. If \c e was hidden previuosly, then it is shown 3.1636 + /// again 3.1637 + void unHide(const Edge& e) const { Parent::unHide(e); } 3.1638 + 3.1639 + /// \brief Returns true if \c e is hidden. 3.1640 + /// 3.1641 + /// Returns true if \c e is hidden. 3.1642 + /// 3.1643 + bool hidden(const Edge& e) const { return Parent::hidden(e); } 3.1644 + 3.1645 + }; 3.1646 + 3.1647 + /// \brief Just gives back a FilterEdges adaptor 3.1648 + /// 3.1649 + /// Just gives back a FilterEdges adaptor 3.1650 + template<typename Graph, typename EdgeFilterMap> 3.1651 + FilterEdges<const Graph, EdgeFilterMap> 3.1652 + filterEdges(const Graph& graph, EdgeFilterMap& efm) { 3.1653 + return FilterEdges<const Graph, EdgeFilterMap>(graph, efm); 3.1654 + } 3.1655 + 3.1656 + template<typename Graph, typename EdgeFilterMap> 3.1657 + FilterEdges<const Graph, const EdgeFilterMap> 3.1658 + filterEdges(const Graph& graph, const EdgeFilterMap& efm) { 3.1659 + return FilterEdges<const Graph, const EdgeFilterMap>(graph, efm); 3.1660 + } 3.1661 + 3.1662 + template <typename _Digraph> 3.1663 + class UndirectorBase { 3.1664 + public: 3.1665 + typedef _Digraph Digraph; 3.1666 + typedef UndirectorBase Adaptor; 3.1667 + 3.1668 + typedef True UndirectedTag; 3.1669 + 3.1670 + typedef typename Digraph::Arc Edge; 3.1671 + typedef typename Digraph::Node Node; 3.1672 + 3.1673 + class Arc : public Edge { 3.1674 + friend class UndirectorBase; 3.1675 + protected: 3.1676 + bool _forward; 3.1677 + 3.1678 + Arc(const Edge& edge, bool forward) : 3.1679 + Edge(edge), _forward(forward) {} 3.1680 + 3.1681 + public: 3.1682 + Arc() {} 3.1683 + 3.1684 + Arc(Invalid) : Edge(INVALID), _forward(true) {} 3.1685 + 3.1686 + bool operator==(const Arc &other) const { 3.1687 + return _forward == other._forward && 3.1688 + static_cast<const Edge&>(*this) == static_cast<const Edge&>(other); 3.1689 + } 3.1690 + bool operator!=(const Arc &other) const { 3.1691 + return _forward != other._forward || 3.1692 + static_cast<const Edge&>(*this) != static_cast<const Edge&>(other); 3.1693 + } 3.1694 + bool operator<(const Arc &other) const { 3.1695 + return _forward < other._forward || 3.1696 + (_forward == other._forward && 3.1697 + static_cast<const Edge&>(*this) < static_cast<const Edge&>(other)); 3.1698 + } 3.1699 + }; 3.1700 + 3.1701 + 3.1702 + 3.1703 + void first(Node& n) const { 3.1704 + _digraph->first(n); 3.1705 + } 3.1706 + 3.1707 + void next(Node& n) const { 3.1708 + _digraph->next(n); 3.1709 + } 3.1710 + 3.1711 + void first(Arc& a) const { 3.1712 + _digraph->first(a); 3.1713 + a._forward = true; 3.1714 + } 3.1715 + 3.1716 + void next(Arc& a) const { 3.1717 + if (a._forward) { 3.1718 + a._forward = false; 3.1719 + } else { 3.1720 + _digraph->next(a); 3.1721 + a._forward = true; 3.1722 + } 3.1723 + } 3.1724 + 3.1725 + void first(Edge& e) const { 3.1726 + _digraph->first(e); 3.1727 + } 3.1728 + 3.1729 + void next(Edge& e) const { 3.1730 + _digraph->next(e); 3.1731 + } 3.1732 + 3.1733 + void firstOut(Arc& a, const Node& n) const { 3.1734 + _digraph->firstIn(a, n); 3.1735 + if( static_cast<const Edge&>(a) != INVALID ) { 3.1736 + a._forward = false; 3.1737 + } else { 3.1738 + _digraph->firstOut(a, n); 3.1739 + a._forward = true; 3.1740 + } 3.1741 + } 3.1742 + void nextOut(Arc &a) const { 3.1743 + if (!a._forward) { 3.1744 + Node n = _digraph->target(a); 3.1745 + _digraph->nextIn(a); 3.1746 + if (static_cast<const Edge&>(a) == INVALID ) { 3.1747 + _digraph->firstOut(a, n); 3.1748 + a._forward = true; 3.1749 + } 3.1750 + } 3.1751 + else { 3.1752 + _digraph->nextOut(a); 3.1753 + } 3.1754 + } 3.1755 + 3.1756 + void firstIn(Arc &a, const Node &n) const { 3.1757 + _digraph->firstOut(a, n); 3.1758 + if (static_cast<const Edge&>(a) != INVALID ) { 3.1759 + a._forward = false; 3.1760 + } else { 3.1761 + _digraph->firstIn(a, n); 3.1762 + a._forward = true; 3.1763 + } 3.1764 + } 3.1765 + void nextIn(Arc &a) const { 3.1766 + if (!a._forward) { 3.1767 + Node n = _digraph->source(a); 3.1768 + _digraph->nextOut(a); 3.1769 + if( static_cast<const Edge&>(a) == INVALID ) { 3.1770 + _digraph->firstIn(a, n); 3.1771 + a._forward = true; 3.1772 + } 3.1773 + } 3.1774 + else { 3.1775 + _digraph->nextIn(a); 3.1776 + } 3.1777 + } 3.1778 + 3.1779 + void firstInc(Edge &e, bool &d, const Node &n) const { 3.1780 + d = true; 3.1781 + _digraph->firstOut(e, n); 3.1782 + if (e != INVALID) return; 3.1783 + d = false; 3.1784 + _digraph->firstIn(e, n); 3.1785 + } 3.1786 + 3.1787 + void nextInc(Edge &e, bool &d) const { 3.1788 + if (d) { 3.1789 + Node s = _digraph->source(e); 3.1790 + _digraph->nextOut(e); 3.1791 + if (e != INVALID) return; 3.1792 + d = false; 3.1793 + _digraph->firstIn(e, s); 3.1794 + } else { 3.1795 + _digraph->nextIn(e); 3.1796 + } 3.1797 + } 3.1798 + 3.1799 + Node u(const Edge& e) const { 3.1800 + return _digraph->source(e); 3.1801 + } 3.1802 + 3.1803 + Node v(const Edge& e) const { 3.1804 + return _digraph->target(e); 3.1805 + } 3.1806 + 3.1807 + Node source(const Arc &a) const { 3.1808 + return a._forward ? _digraph->source(a) : _digraph->target(a); 3.1809 + } 3.1810 + 3.1811 + Node target(const Arc &a) const { 3.1812 + return a._forward ? _digraph->target(a) : _digraph->source(a); 3.1813 + } 3.1814 + 3.1815 + static Arc direct(const Edge &e, bool d) { 3.1816 + return Arc(e, d); 3.1817 + } 3.1818 + Arc direct(const Edge &e, const Node& n) const { 3.1819 + return Arc(e, _digraph->source(e) == n); 3.1820 + } 3.1821 + 3.1822 + static bool direction(const Arc &a) { return a._forward; } 3.1823 + 3.1824 + Node nodeFromId(int ix) const { return _digraph->nodeFromId(ix); } 3.1825 + Arc arcFromId(int ix) const { 3.1826 + return direct(_digraph->arcFromId(ix >> 1), bool(ix & 1)); 3.1827 + } 3.1828 + Edge edgeFromId(int ix) const { return _digraph->arcFromId(ix); } 3.1829 + 3.1830 + int id(const Node &n) const { return _digraph->id(n); } 3.1831 + int id(const Arc &a) const { 3.1832 + return (_digraph->id(a) << 1) | (a._forward ? 1 : 0); 3.1833 + } 3.1834 + int id(const Edge &e) const { return _digraph->id(e); } 3.1835 + 3.1836 + int maxNodeId() const { return _digraph->maxNodeId(); } 3.1837 + int maxArcId() const { return (_digraph->maxArcId() << 1) | 1; } 3.1838 + int maxEdgeId() const { return _digraph->maxArcId(); } 3.1839 + 3.1840 + Node addNode() { return _digraph->addNode(); } 3.1841 + Edge addEdge(const Node& u, const Node& v) { 3.1842 + return _digraph->addArc(u, v); 3.1843 + } 3.1844 + 3.1845 + void erase(const Node& i) { _digraph->erase(i); } 3.1846 + void erase(const Edge& i) { _digraph->erase(i); } 3.1847 + 3.1848 + void clear() { _digraph->clear(); } 3.1849 + 3.1850 + typedef NodeNumTagIndicator<Digraph> NodeNumTag; 3.1851 + int nodeNum() const { return 2 * _digraph->arcNum(); } 3.1852 + typedef EdgeNumTagIndicator<Digraph> EdgeNumTag; 3.1853 + int arcNum() const { return 2 * _digraph->arcNum(); } 3.1854 + int edgeNum() const { return _digraph->arcNum(); } 3.1855 + 3.1856 + typedef FindEdgeTagIndicator<Digraph> FindEdgeTag; 3.1857 + Arc findArc(Node s, Node t, Arc p = INVALID) const { 3.1858 + if (p == INVALID) { 3.1859 + Edge arc = _digraph->findArc(s, t); 3.1860 + if (arc != INVALID) return direct(arc, true); 3.1861 + arc = _digraph->findArc(t, s); 3.1862 + if (arc != INVALID) return direct(arc, false); 3.1863 + } else if (direction(p)) { 3.1864 + Edge arc = _digraph->findArc(s, t, p); 3.1865 + if (arc != INVALID) return direct(arc, true); 3.1866 + arc = _digraph->findArc(t, s); 3.1867 + if (arc != INVALID) return direct(arc, false); 3.1868 + } else { 3.1869 + Edge arc = _digraph->findArc(t, s, p); 3.1870 + if (arc != INVALID) return direct(arc, false); 3.1871 + } 3.1872 + return INVALID; 3.1873 + } 3.1874 + 3.1875 + Edge findEdge(Node s, Node t, Edge p = INVALID) const { 3.1876 + if (s != t) { 3.1877 + if (p == INVALID) { 3.1878 + Edge arc = _digraph->findArc(s, t); 3.1879 + if (arc != INVALID) return arc; 3.1880 + arc = _digraph->findArc(t, s); 3.1881 + if (arc != INVALID) return arc; 3.1882 + } else if (_digraph->s(p) == s) { 3.1883 + Edge arc = _digraph->findArc(s, t, p); 3.1884 + if (arc != INVALID) return arc; 3.1885 + arc = _digraph->findArc(t, s); 3.1886 + if (arc != INVALID) return arc; 3.1887 + } else { 3.1888 + Edge arc = _digraph->findArc(t, s, p); 3.1889 + if (arc != INVALID) return arc; 3.1890 + } 3.1891 + } else { 3.1892 + return _digraph->findArc(s, t, p); 3.1893 + } 3.1894 + return INVALID; 3.1895 + } 3.1896 + 3.1897 + private: 3.1898 + 3.1899 + template <typename _Value> 3.1900 + class ArcMapBase { 3.1901 + private: 3.1902 + 3.1903 + typedef typename Digraph::template ArcMap<_Value> MapImpl; 3.1904 + 3.1905 + public: 3.1906 + 3.1907 + typedef typename MapTraits<MapImpl>::ReferenceMapTag ReferenceMapTag; 3.1908 + 3.1909 + typedef _Value Value; 3.1910 + typedef Arc Key; 3.1911 + 3.1912 + ArcMapBase(const Adaptor& adaptor) : 3.1913 + _forward(*adaptor._digraph), _backward(*adaptor._digraph) {} 3.1914 + 3.1915 + ArcMapBase(const Adaptor& adaptor, const Value& v) 3.1916 + : _forward(*adaptor._digraph, v), _backward(*adaptor._digraph, v) {} 3.1917 + 3.1918 + void set(const Arc& a, const Value& v) { 3.1919 + if (direction(a)) { 3.1920 + _forward.set(a, v); 3.1921 + } else { 3.1922 + _backward.set(a, v); 3.1923 + } 3.1924 + } 3.1925 + 3.1926 + typename MapTraits<MapImpl>::ConstReturnValue 3.1927 + operator[](const Arc& a) const { 3.1928 + if (direction(a)) { 3.1929 + return _forward[a]; 3.1930 + } else { 3.1931 + return _backward[a]; 3.1932 + } 3.1933 + } 3.1934 + 3.1935 + typename MapTraits<MapImpl>::ReturnValue 3.1936 + operator[](const Arc& a) { 3.1937 + if (direction(a)) { 3.1938 + return _forward[a]; 3.1939 + } else { 3.1940 + return _backward[a]; 3.1941 + } 3.1942 + } 3.1943 + 3.1944 + protected: 3.1945 + 3.1946 + MapImpl _forward, _backward; 3.1947 + 3.1948 + }; 3.1949 + 3.1950 + public: 3.1951 + 3.1952 + template <typename _Value> 3.1953 + class NodeMap : public Digraph::template NodeMap<_Value> { 3.1954 + public: 3.1955 + 3.1956 + typedef _Value Value; 3.1957 + typedef typename Digraph::template NodeMap<Value> Parent; 3.1958 + 3.1959 + explicit NodeMap(const Adaptor& adaptor) 3.1960 + : Parent(*adaptor._digraph) {} 3.1961 + 3.1962 + NodeMap(const Adaptor& adaptor, const _Value& value) 3.1963 + : Parent(*adaptor._digraph, value) { } 3.1964 + 3.1965 + private: 3.1966 + NodeMap& operator=(const NodeMap& cmap) { 3.1967 + return operator=<NodeMap>(cmap); 3.1968 + } 3.1969 + 3.1970 + template <typename CMap> 3.1971 + NodeMap& operator=(const CMap& cmap) { 3.1972 + Parent::operator=(cmap); 3.1973 + return *this; 3.1974 + } 3.1975 + 3.1976 + }; 3.1977 + 3.1978 + template <typename _Value> 3.1979 + class ArcMap 3.1980 + : public SubMapExtender<Adaptor, ArcMapBase<_Value> > 3.1981 + { 3.1982 + public: 3.1983 + typedef _Value Value; 3.1984 + typedef SubMapExtender<Adaptor, ArcMapBase<Value> > Parent; 3.1985 + 3.1986 + ArcMap(const Adaptor& adaptor) 3.1987 + : Parent(adaptor) {} 3.1988 + 3.1989 + ArcMap(const Adaptor& adaptor, const Value& value) 3.1990 + : Parent(adaptor, value) {} 3.1991 + 3.1992 + private: 3.1993 + ArcMap& operator=(const ArcMap& cmap) { 3.1994 + return operator=<ArcMap>(cmap); 3.1995 + } 3.1996 + 3.1997 + template <typename CMap> 3.1998 + ArcMap& operator=(const CMap& cmap) { 3.1999 + Parent::operator=(cmap); 3.2000 + return *this; 3.2001 + } 3.2002 + }; 3.2003 + 3.2004 + template <typename _Value> 3.2005 + class EdgeMap : public Digraph::template ArcMap<_Value> { 3.2006 + public: 3.2007 + 3.2008 + typedef _Value Value; 3.2009 + typedef typename Digraph::template ArcMap<Value> Parent; 3.2010 + 3.2011 + explicit EdgeMap(const Adaptor& adaptor) 3.2012 + : Parent(*adaptor._digraph) {} 3.2013 + 3.2014 + EdgeMap(const Adaptor& adaptor, const Value& value) 3.2015 + : Parent(*adaptor._digraph, value) {} 3.2016 + 3.2017 + private: 3.2018 + EdgeMap& operator=(const EdgeMap& cmap) { 3.2019 + return operator=<EdgeMap>(cmap); 3.2020 + } 3.2021 + 3.2022 + template <typename CMap> 3.2023 + EdgeMap& operator=(const CMap& cmap) { 3.2024 + Parent::operator=(cmap); 3.2025 + return *this; 3.2026 + } 3.2027 + 3.2028 + }; 3.2029 + 3.2030 + typedef typename ItemSetTraits<Digraph, Node>::ItemNotifier NodeNotifier; 3.2031 + NodeNotifier& notifier(Node) const { return _digraph->notifier(Node()); } 3.2032 + 3.2033 + protected: 3.2034 + 3.2035 + UndirectorBase() : _digraph(0) {} 3.2036 + 3.2037 + Digraph* _digraph; 3.2038 + 3.2039 + void setDigraph(Digraph& digraph) { 3.2040 + _digraph = &digraph; 3.2041 + } 3.2042 + 3.2043 + }; 3.2044 + 3.2045 + /// \ingroup graph_adaptors 3.2046 + /// 3.2047 + /// \brief Undirect the graph 3.2048 + /// 3.2049 + /// This adaptor makes an undirected graph from a directed 3.2050 + /// graph. All arcs of the underlying digraph will be showed in the 3.2051 + /// adaptor as an edge. The Orienter adaptor is conform to the \ref 3.2052 + /// concepts::Graph "Graph concept". 3.2053 + /// 3.2054 + /// \tparam _Digraph It must be conform to the \ref 3.2055 + /// concepts::Digraph "Digraph concept". The type can be specified 3.2056 + /// to const. 3.2057 + template<typename _Digraph> 3.2058 + class Undirector 3.2059 + : public GraphAdaptorExtender<UndirectorBase<_Digraph> > { 3.2060 + public: 3.2061 + typedef _Digraph Digraph; 3.2062 + typedef GraphAdaptorExtender<UndirectorBase<Digraph> > Parent; 3.2063 + protected: 3.2064 + Undirector() { } 3.2065 + public: 3.2066 + 3.2067 + /// \brief Constructor 3.2068 + /// 3.2069 + /// Creates a undirected graph from the given digraph 3.2070 + Undirector(_Digraph& digraph) { 3.2071 + setDigraph(digraph); 3.2072 + } 3.2073 + 3.2074 + /// \brief ArcMap combined from two original ArcMap 3.2075 + /// 3.2076 + /// This class adapts two original digraph ArcMap to 3.2077 + /// get an arc map on the undirected graph. 3.2078 + template <typename _ForwardMap, typename _BackwardMap> 3.2079 + class CombinedArcMap { 3.2080 + public: 3.2081 + 3.2082 + typedef _ForwardMap ForwardMap; 3.2083 + typedef _BackwardMap BackwardMap; 3.2084 + 3.2085 + typedef typename MapTraits<ForwardMap>::ReferenceMapTag ReferenceMapTag; 3.2086 + 3.2087 + typedef typename ForwardMap::Value Value; 3.2088 + typedef typename Parent::Arc Key; 3.2089 + 3.2090 + /// \brief Constructor 3.2091 + /// 3.2092 + /// Constructor 3.2093 + CombinedArcMap(ForwardMap& forward, BackwardMap& backward) 3.2094 + : _forward(&forward), _backward(&backward) {} 3.2095 + 3.2096 + 3.2097 + /// \brief Sets the value associated with a key. 3.2098 + /// 3.2099 + /// Sets the value associated with a key. 3.2100 + void set(const Key& e, const Value& a) { 3.2101 + if (Parent::direction(e)) { 3.2102 + _forward->set(e, a); 3.2103 + } else { 3.2104 + _backward->set(e, a); 3.2105 + } 3.2106 + } 3.2107 + 3.2108 + /// \brief Returns the value associated with a key. 3.2109 + /// 3.2110 + /// Returns the value associated with a key. 3.2111 + typename MapTraits<ForwardMap>::ConstReturnValue 3.2112 + operator[](const Key& e) const { 3.2113 + if (Parent::direction(e)) { 3.2114 + return (*_forward)[e]; 3.2115 + } else { 3.2116 + return (*_backward)[e]; 3.2117 + } 3.2118 + } 3.2119 + 3.2120 + /// \brief Returns the value associated with a key. 3.2121 + /// 3.2122 + /// Returns the value associated with a key. 3.2123 + typename MapTraits<ForwardMap>::ReturnValue 3.2124 + operator[](const Key& e) { 3.2125 + if (Parent::direction(e)) { 3.2126 + return (*_forward)[e]; 3.2127 + } else { 3.2128 + return (*_backward)[e]; 3.2129 + } 3.2130 + } 3.2131 + 3.2132 + protected: 3.2133 + 3.2134 + ForwardMap* _forward; 3.2135 + BackwardMap* _backward; 3.2136 + 3.2137 + }; 3.2138 + 3.2139 + /// \brief Just gives back a combined arc map 3.2140 + /// 3.2141 + /// Just gives back a combined arc map 3.2142 + template <typename ForwardMap, typename BackwardMap> 3.2143 + static CombinedArcMap<ForwardMap, BackwardMap> 3.2144 + combinedArcMap(ForwardMap& forward, BackwardMap& backward) { 3.2145 + return CombinedArcMap<ForwardMap, BackwardMap>(forward, backward); 3.2146 + } 3.2147 + 3.2148 + template <typename ForwardMap, typename BackwardMap> 3.2149 + static CombinedArcMap<const ForwardMap, BackwardMap> 3.2150 + combinedArcMap(const ForwardMap& forward, BackwardMap& backward) { 3.2151 + return CombinedArcMap<const ForwardMap, 3.2152 + BackwardMap>(forward, backward); 3.2153 + } 3.2154 + 3.2155 + template <typename ForwardMap, typename BackwardMap> 3.2156 + static CombinedArcMap<ForwardMap, const BackwardMap> 3.2157 + combinedArcMap(ForwardMap& forward, const BackwardMap& backward) { 3.2158 + return CombinedArcMap<ForwardMap, 3.2159 + const BackwardMap>(forward, backward); 3.2160 + } 3.2161 + 3.2162 + template <typename ForwardMap, typename BackwardMap> 3.2163 + static CombinedArcMap<const ForwardMap, const BackwardMap> 3.2164 + combinedArcMap(const ForwardMap& forward, const BackwardMap& backward) { 3.2165 + return CombinedArcMap<const ForwardMap, 3.2166 + const BackwardMap>(forward, backward); 3.2167 + } 3.2168 + 3.2169 + }; 3.2170 + 3.2171 + /// \brief Just gives back an undirected view of the given digraph 3.2172 + /// 3.2173 + /// Just gives back an undirected view of the given digraph 3.2174 + template<typename Digraph> 3.2175 + Undirector<const Digraph> 3.2176 + undirector(const Digraph& digraph) { 3.2177 + return Undirector<const Digraph>(digraph); 3.2178 + } 3.2179 + 3.2180 + template <typename _Graph, typename _DirectionMap> 3.2181 + class OrienterBase { 3.2182 + public: 3.2183 + 3.2184 + typedef _Graph Graph; 3.2185 + typedef _DirectionMap DirectionMap; 3.2186 + 3.2187 + typedef typename Graph::Node Node; 3.2188 + typedef typename Graph::Edge Arc; 3.2189 + 3.2190 + void reverseArc(const Arc& arc) { 3.2191 + _direction->set(arc, !(*_direction)[arc]); 3.2192 + } 3.2193 + 3.2194 + void first(Node& i) const { _graph->first(i); } 3.2195 + void first(Arc& i) const { _graph->first(i); } 3.2196 + void firstIn(Arc& i, const Node& n) const { 3.2197 + bool d; 3.2198 + _graph->firstInc(i, d, n); 3.2199 + while (i != INVALID && d == (*_direction)[i]) _graph->nextInc(i, d); 3.2200 + } 3.2201 + void firstOut(Arc& i, const Node& n ) const { 3.2202 + bool d; 3.2203 + _graph->firstInc(i, d, n); 3.2204 + while (i != INVALID && d != (*_direction)[i]) _graph->nextInc(i, d); 3.2205 + } 3.2206 + 3.2207 + void next(Node& i) const { _graph->next(i); } 3.2208 + void next(Arc& i) const { _graph->next(i); } 3.2209 + void nextIn(Arc& i) const { 3.2210 + bool d = !(*_direction)[i]; 3.2211 + _graph->nextInc(i, d); 3.2212 + while (i != INVALID && d == (*_direction)[i]) _graph->nextInc(i, d); 3.2213 + } 3.2214 + void nextOut(Arc& i) const { 3.2215 + bool d = (*_direction)[i]; 3.2216 + _graph->nextInc(i, d); 3.2217 + while (i != INVALID && d != (*_direction)[i]) _graph->nextInc(i, d); 3.2218 + } 3.2219 + 3.2220 + Node source(const Arc& e) const { 3.2221 + return (*_direction)[e] ? _graph->u(e) : _graph->v(e); 3.2222 + } 3.2223 + Node target(const Arc& e) const { 3.2224 + return (*_direction)[e] ? _graph->v(e) : _graph->u(e); 3.2225 + } 3.2226 + 3.2227 + typedef NodeNumTagIndicator<Graph> NodeNumTag; 3.2228 + int nodeNum() const { return _graph->nodeNum(); } 3.2229 + 3.2230 + typedef EdgeNumTagIndicator<Graph> EdgeNumTag; 3.2231 + int arcNum() const { return _graph->edgeNum(); } 3.2232 + 3.2233 + typedef FindEdgeTagIndicator<Graph> FindEdgeTag; 3.2234 + Arc findArc(const Node& u, const Node& v, 3.2235 + const Arc& prev = INVALID) { 3.2236 + Arc arc = prev; 3.2237 + bool d = arc == INVALID ? true : (*_direction)[arc]; 3.2238 + if (d) { 3.2239 + arc = _graph->findEdge(u, v, arc); 3.2240 + while (arc != INVALID && !(*_direction)[arc]) { 3.2241 + _graph->findEdge(u, v, arc); 3.2242 + } 3.2243 + if (arc != INVALID) return arc; 3.2244 + } 3.2245 + _graph->findEdge(v, u, arc); 3.2246 + while (arc != INVALID && (*_direction)[arc]) { 3.2247 + _graph->findEdge(u, v, arc); 3.2248 + } 3.2249 + return arc; 3.2250 + } 3.2251 + 3.2252 + Node addNode() { 3.2253 + return Node(_graph->addNode()); 3.2254 + } 3.2255 + 3.2256 + Arc addArc(const Node& u, const Node& v) { 3.2257 + Arc arc = _graph->addArc(u, v); 3.2258 + _direction->set(arc, _graph->source(arc) == u); 3.2259 + return arc; 3.2260 + } 3.2261 + 3.2262 + void erase(const Node& i) { _graph->erase(i); } 3.2263 + void erase(const Arc& i) { _graph->erase(i); } 3.2264 + 3.2265 + void clear() { _graph->clear(); } 3.2266 + 3.2267 + int id(const Node& v) const { return _graph->id(v); } 3.2268 + int id(const Arc& e) const { return _graph->id(e); } 3.2269 + 3.2270 + Node nodeFromId(int idx) const { return _graph->nodeFromId(idx); } 3.2271 + Arc arcFromId(int idx) const { return _graph->edgeFromId(idx); } 3.2272 + 3.2273 + int maxNodeId() const { return _graph->maxNodeId(); } 3.2274 + int maxArcId() const { return _graph->maxEdgeId(); } 3.2275 + 3.2276 + typedef typename ItemSetTraits<Graph, Node>::ItemNotifier NodeNotifier; 3.2277 + NodeNotifier& notifier(Node) const { return _graph->notifier(Node()); } 3.2278 + 3.2279 + typedef typename ItemSetTraits<Graph, Arc>::ItemNotifier ArcNotifier; 3.2280 + ArcNotifier& notifier(Arc) const { return _graph->notifier(Arc()); } 3.2281 + 3.2282 + template <typename _Value> 3.2283 + class NodeMap : public _Graph::template NodeMap<_Value> { 3.2284 + public: 3.2285 + 3.2286 + typedef typename _Graph::template NodeMap<_Value> Parent; 3.2287 + 3.2288 + explicit NodeMap(const OrienterBase& adapter) 3.2289 + : Parent(*adapter._graph) {} 3.2290 + 3.2291 + NodeMap(const OrienterBase& adapter, const _Value& value) 3.2292 + : Parent(*adapter._graph, value) {} 3.2293 + 3.2294 + private: 3.2295 + NodeMap& operator=(const NodeMap& cmap) { 3.2296 + return operator=<NodeMap>(cmap); 3.2297 + } 3.2298 + 3.2299 + template <typename CMap> 3.2300 + NodeMap& operator=(const CMap& cmap) { 3.2301 + Parent::operator=(cmap); 3.2302 + return *this; 3.2303 + } 3.2304 + 3.2305 + }; 3.2306 + 3.2307 + template <typename _Value> 3.2308 + class ArcMap : public _Graph::template EdgeMap<_Value> { 3.2309 + public: 3.2310 + 3.2311 + typedef typename Graph::template EdgeMap<_Value> Parent; 3.2312 + 3.2313 + explicit ArcMap(const OrienterBase& adapter) 3.2314 + : Parent(*adapter._graph) { } 3.2315 + 3.2316 + ArcMap(const OrienterBase& adapter, const _Value& value) 3.2317 + : Parent(*adapter._graph, value) { } 3.2318 + 3.2319 + private: 3.2320 + ArcMap& operator=(const ArcMap& cmap) { 3.2321 + return operator=<ArcMap>(cmap); 3.2322 + } 3.2323 + 3.2324 + template <typename CMap> 3.2325 + ArcMap& operator=(const CMap& cmap) { 3.2326 + Parent::operator=(cmap); 3.2327 + return *this; 3.2328 + } 3.2329 + }; 3.2330 + 3.2331 + 3.2332 + 3.2333 + protected: 3.2334 + Graph* _graph; 3.2335 + DirectionMap* _direction; 3.2336 + 3.2337 + void setDirectionMap(DirectionMap& direction) { 3.2338 + _direction = &direction; 3.2339 + } 3.2340 + 3.2341 + void setGraph(Graph& graph) { 3.2342 + _graph = &graph; 3.2343 + } 3.2344 + 3.2345 + }; 3.2346 + 3.2347 + /// \ingroup graph_adaptors 3.2348 + /// 3.2349 + /// \brief Orients the edges of the graph to get a digraph 3.2350 + /// 3.2351 + /// This adaptor orients each edge in the undirected graph. The 3.2352 + /// direction of the arcs stored in an edge node map. The arcs can 3.2353 + /// be easily reverted by the \c reverseArc() member function in the 3.2354 + /// adaptor. The Orienter adaptor is conform to the \ref 3.2355 + /// concepts::Digraph "Digraph concept". 3.2356 + /// 3.2357 + /// \tparam _Graph It must be conform to the \ref concepts::Graph 3.2358 + /// "Graph concept". The type can be specified to be const. 3.2359 + /// \tparam _DirectionMap A bool valued edge map of the the adapted 3.2360 + /// graph. 3.2361 + /// 3.2362 + /// \sa orienter 3.2363 + template<typename _Graph, 3.2364 + typename DirectionMap = typename _Graph::template EdgeMap<bool> > 3.2365 + class Orienter : 3.2366 + public DigraphAdaptorExtender<OrienterBase<_Graph, DirectionMap> > { 3.2367 + public: 3.2368 + typedef _Graph Graph; 3.2369 + typedef DigraphAdaptorExtender< 3.2370 + OrienterBase<_Graph, DirectionMap> > Parent; 3.2371 + typedef typename Parent::Arc Arc; 3.2372 + protected: 3.2373 + Orienter() { } 3.2374 + public: 3.2375 + 3.2376 + /// \brief Constructor of the adaptor 3.2377 + /// 3.2378 + /// Constructor of the adaptor 3.2379 + Orienter(Graph& graph, DirectionMap& direction) { 3.2380 + setGraph(graph); 3.2381 + setDirectionMap(direction); 3.2382 + } 3.2383 + 3.2384 + /// \brief Reverse arc 3.2385 + /// 3.2386 + /// It reverse the given arc. It simply negate the direction in the map. 3.2387 + void reverseArc(const Arc& a) { 3.2388 + Parent::reverseArc(a); 3.2389 + } 3.2390 + }; 3.2391 + 3.2392 + /// \brief Just gives back a Orienter 3.2393 + /// 3.2394 + /// Just gives back a Orienter 3.2395 + template<typename Graph, typename DirectionMap> 3.2396 + Orienter<const Graph, DirectionMap> 3.2397 + orienter(const Graph& graph, DirectionMap& dm) { 3.2398 + return Orienter<const Graph, DirectionMap>(graph, dm); 3.2399 + } 3.2400 + 3.2401 + template<typename Graph, typename DirectionMap> 3.2402 + Orienter<const Graph, const DirectionMap> 3.2403 + orienter(const Graph& graph, const DirectionMap& dm) { 3.2404 + return Orienter<const Graph, const DirectionMap>(graph, dm); 3.2405 + } 3.2406 + 3.2407 + namespace _adaptor_bits { 3.2408 + 3.2409 + template<typename _Digraph, 3.2410 + typename _CapacityMap = typename _Digraph::template ArcMap<int>, 3.2411 + typename _FlowMap = _CapacityMap, 3.2412 + typename _Tolerance = Tolerance<typename _CapacityMap::Value> > 3.2413 + class ResForwardFilter { 3.2414 + public: 3.2415 + 3.2416 + typedef _Digraph Digraph; 3.2417 + typedef _CapacityMap CapacityMap; 3.2418 + typedef _FlowMap FlowMap; 3.2419 + typedef _Tolerance Tolerance; 3.2420 + 3.2421 + typedef typename Digraph::Arc Key; 3.2422 + typedef bool Value; 3.2423 + 3.2424 + private: 3.2425 + 3.2426 + const CapacityMap* _capacity; 3.2427 + const FlowMap* _flow; 3.2428 + Tolerance _tolerance; 3.2429 + public: 3.2430 + 3.2431 + ResForwardFilter(const CapacityMap& capacity, const FlowMap& flow, 3.2432 + const Tolerance& tolerance = Tolerance()) 3.2433 + : _capacity(&capacity), _flow(&flow), _tolerance(tolerance) { } 3.2434 + 3.2435 + bool operator[](const typename Digraph::Arc& a) const { 3.2436 + return _tolerance.positive((*_capacity)[a] - (*_flow)[a]); 3.2437 + } 3.2438 + }; 3.2439 + 3.2440 + template<typename _Digraph, 3.2441 + typename _CapacityMap = typename _Digraph::template ArcMap<int>, 3.2442 + typename _FlowMap = _CapacityMap, 3.2443 + typename _Tolerance = Tolerance<typename _CapacityMap::Value> > 3.2444 + class ResBackwardFilter { 3.2445 + public: 3.2446 + 3.2447 + typedef _Digraph Digraph; 3.2448 + typedef _CapacityMap CapacityMap; 3.2449 + typedef _FlowMap FlowMap; 3.2450 + typedef _Tolerance Tolerance; 3.2451 + 3.2452 + typedef typename Digraph::Arc Key; 3.2453 + typedef bool Value; 3.2454 + 3.2455 + private: 3.2456 + 3.2457 + const CapacityMap* _capacity; 3.2458 + const FlowMap* _flow; 3.2459 + Tolerance _tolerance; 3.2460 + 3.2461 + public: 3.2462 + 3.2463 + ResBackwardFilter(const CapacityMap& capacity, const FlowMap& flow, 3.2464 + const Tolerance& tolerance = Tolerance()) 3.2465 + : _capacity(&capacity), _flow(&flow), _tolerance(tolerance) { } 3.2466 + 3.2467 + bool operator[](const typename Digraph::Arc& a) const { 3.2468 + return _tolerance.positive((*_flow)[a]); 3.2469 + } 3.2470 + }; 3.2471 + 3.2472 + } 3.2473 + 3.2474 + /// \ingroup graph_adaptors 3.2475 + /// 3.2476 + /// \brief An adaptor for composing the residual graph for directed 3.2477 + /// flow and circulation problems. 3.2478 + /// 3.2479 + /// An adaptor for composing the residual graph for directed flow and 3.2480 + /// circulation problems. Let \f$ G=(V, A) \f$be a directed graph 3.2481 + /// and let \f$ F \f$be a number type. Let moreover \f$ f,c:A\to F \f$, 3.2482 + /// be functions on the arc-set. 3.2483 + /// 3.2484 + /// Then Residual implements the digraph structure with 3.2485 + /// node-set \f$ V \f$and arc-set \f$ A_{forward}\cup A_{backward} \f$, 3.2486 + /// where \f$ A_{forward}=\{uv : uv\in A, f(uv)<c(uv)\} \f$and 3.2487 + /// \f$ A_{backward}=\{vu : uv\in A, f(uv)>0\} \f$, i.e. the so 3.2488 + /// called residual graph. When we take the union 3.2489 + /// \f$ A_{forward}\cup A_{backward} \f$, multiplicities are counted, 3.2490 + /// i.e. if an arc is in both \f$ A_{forward} \f$and 3.2491 + /// \f$ A_{backward} \f$, then in the adaptor it appears in both 3.2492 + /// orientation. 3.2493 + /// 3.2494 + /// \tparam _Digraph It must be conform to the \ref concepts::Digraph 3.2495 + /// "Digraph concept". The type is implicitly const. 3.2496 + /// \tparam _CapacityMap An arc map of some numeric type, it defines 3.2497 + /// the capacities in the flow problem. The map is implicitly const. 3.2498 + /// \tparam _FlowMap An arc map of some numeric type, it defines 3.2499 + /// the capacities in the flow problem. 3.2500 + /// \tparam _Tolerance Handler for inexact computation. 3.2501 + template<typename _Digraph, 3.2502 + typename _CapacityMap = typename _Digraph::template ArcMap<int>, 3.2503 + typename _FlowMap = _CapacityMap, 3.2504 + typename _Tolerance = Tolerance<typename _CapacityMap::Value> > 3.2505 + class Residual : 3.2506 + public FilterArcs< 3.2507 + Undirector<const _Digraph>, 3.2508 + typename Undirector<const _Digraph>::template CombinedArcMap< 3.2509 + _adaptor_bits::ResForwardFilter<const _Digraph, _CapacityMap, 3.2510 + _FlowMap, _Tolerance>, 3.2511 + _adaptor_bits::ResBackwardFilter<const _Digraph, _CapacityMap, 3.2512 + _FlowMap, _Tolerance> > > 3.2513 + { 3.2514 + public: 3.2515 + 3.2516 + typedef _Digraph Digraph; 3.2517 + typedef _CapacityMap CapacityMap; 3.2518 + typedef _FlowMap FlowMap; 3.2519 + typedef _Tolerance Tolerance; 3.2520 + 3.2521 + typedef typename CapacityMap::Value Value; 3.2522 + typedef Residual Adaptor; 3.2523 + 3.2524 + protected: 3.2525 + 3.2526 + typedef Undirector<const Digraph> Undirected; 3.2527 + 3.2528 + typedef _adaptor_bits::ResForwardFilter<const Digraph, CapacityMap, 3.2529 + FlowMap, Tolerance> ForwardFilter; 3.2530 + 3.2531 + typedef _adaptor_bits::ResBackwardFilter<const Digraph, CapacityMap, 3.2532 + FlowMap, Tolerance> BackwardFilter; 3.2533 + 3.2534 + typedef typename Undirected:: 3.2535 + template CombinedArcMap<ForwardFilter, BackwardFilter> ArcFilter; 3.2536 + 3.2537 + typedef FilterArcs<Undirected, ArcFilter> Parent; 3.2538 + 3.2539 + const CapacityMap* _capacity; 3.2540 + FlowMap* _flow; 3.2541 + 3.2542 + Undirected _graph; 3.2543 + ForwardFilter _forward_filter; 3.2544 + BackwardFilter _backward_filter; 3.2545 + ArcFilter _arc_filter; 3.2546 + 3.2547 + public: 3.2548 + 3.2549 + /// \brief Constructor of the residual digraph. 3.2550 + /// 3.2551 + /// Constructor of the residual graph. The parameters are the digraph, 3.2552 + /// the flow map, the capacity map and a tolerance object. 3.2553 + Residual(const Digraph& digraph, const CapacityMap& capacity, 3.2554 + FlowMap& flow, const Tolerance& tolerance = Tolerance()) 3.2555 + : Parent(), _capacity(&capacity), _flow(&flow), _graph(digraph), 3.2556 + _forward_filter(capacity, flow, tolerance), 3.2557 + _backward_filter(capacity, flow, tolerance), 3.2558 + _arc_filter(_forward_filter, _backward_filter) 3.2559 + { 3.2560 + Parent::setDigraph(_graph); 3.2561 + Parent::setArcFilterMap(_arc_filter); 3.2562 + } 3.2563 + 3.2564 + typedef typename Parent::Arc Arc; 3.2565 + 3.2566 + /// \brief Gives back the residual capacity of the arc. 3.2567 + /// 3.2568 + /// Gives back the residual capacity of the arc. 3.2569 + Value residualCapacity(const Arc& a) const { 3.2570 + if (Undirected::direction(a)) { 3.2571 + return (*_capacity)[a] - (*_flow)[a]; 3.2572 + } else { 3.2573 + return (*_flow)[a]; 3.2574 + } 3.2575 + } 3.2576 + 3.2577 + /// \brief Augment on the given arc in the residual graph. 3.2578 + /// 3.2579 + /// Augment on the given arc in the residual graph. It increase 3.2580 + /// or decrease the flow on the original arc depend on the direction 3.2581 + /// of the residual arc. 3.2582 + void augment(const Arc& a, const Value& v) const { 3.2583 + if (Undirected::direction(a)) { 3.2584 + _flow->set(a, (*_flow)[a] + v); 3.2585 + } else { 3.2586 + _flow->set(a, (*_flow)[a] - v); 3.2587 + } 3.2588 + } 3.2589 + 3.2590 + /// \brief Returns the direction of the arc. 3.2591 + /// 3.2592 + /// Returns true when the arc is same oriented as the original arc. 3.2593 + static bool forward(const Arc& a) { 3.2594 + return Undirected::direction(a); 3.2595 + } 3.2596 + 3.2597 + /// \brief Returns the direction of the arc. 3.2598 + /// 3.2599 + /// Returns true when the arc is opposite oriented as the original arc. 3.2600 + static bool backward(const Arc& a) { 3.2601 + return !Undirected::direction(a); 3.2602 + } 3.2603 + 3.2604 + /// \brief Gives back the forward oriented residual arc. 3.2605 + /// 3.2606 + /// Gives back the forward oriented residual arc. 3.2607 + static Arc forward(const typename Digraph::Arc& a) { 3.2608 + return Undirected::direct(a, true); 3.2609 + } 3.2610 + 3.2611 + /// \brief Gives back the backward oriented residual arc. 3.2612 + /// 3.2613 + /// Gives back the backward oriented residual arc. 3.2614 + static Arc backward(const typename Digraph::Arc& a) { 3.2615 + return Undirected::direct(a, false); 3.2616 + } 3.2617 + 3.2618 + /// \brief Residual capacity map. 3.2619 + /// 3.2620 + /// In generic residual graph the residual capacity can be obtained 3.2621 + /// as a map. 3.2622 + class ResidualCapacity { 3.2623 + protected: 3.2624 + const Adaptor* _adaptor; 3.2625 + public: 3.2626 + /// The Key type 3.2627 + typedef Arc Key; 3.2628 + /// The Value type 3.2629 + typedef typename _CapacityMap::Value Value; 3.2630 + 3.2631 + /// Constructor 3.2632 + ResidualCapacity(const Adaptor& adaptor) : _adaptor(&adaptor) {} 3.2633 + 3.2634 + /// \e 3.2635 + Value operator[](const Arc& a) const { 3.2636 + return _adaptor->residualCapacity(a); 3.2637 + } 3.2638 + 3.2639 + }; 3.2640 + 3.2641 + }; 3.2642 + 3.2643 + template <typename _Digraph> 3.2644 + class SplitNodesBase { 3.2645 + public: 3.2646 + 3.2647 + typedef _Digraph Digraph; 3.2648 + typedef DigraphAdaptorBase<const _Digraph> Parent; 3.2649 + typedef SplitNodesBase Adaptor; 3.2650 + 3.2651 + typedef typename Digraph::Node DigraphNode; 3.2652 + typedef typename Digraph::Arc DigraphArc; 3.2653 + 3.2654 + class Node; 3.2655 + class Arc; 3.2656 + 3.2657 + private: 3.2658 + 3.2659 + template <typename T> class NodeMapBase; 3.2660 + template <typename T> class ArcMapBase; 3.2661 + 3.2662 + public: 3.2663 + 3.2664 + class Node : public DigraphNode { 3.2665 + friend class SplitNodesBase; 3.2666 + template <typename T> friend class NodeMapBase; 3.2667 + private: 3.2668 + 3.2669 + bool _in; 3.2670 + Node(DigraphNode node, bool in) 3.2671 + : DigraphNode(node), _in(in) {} 3.2672 + 3.2673 + public: 3.2674 + 3.2675 + Node() {} 3.2676 + Node(Invalid) : DigraphNode(INVALID), _in(true) {} 3.2677 + 3.2678 + bool operator==(const Node& node) const { 3.2679 + return DigraphNode::operator==(node) && _in == node._in; 3.2680 + } 3.2681 + 3.2682 + bool operator!=(const Node& node) const { 3.2683 + return !(*this == node); 3.2684 + } 3.2685 + 3.2686 + bool operator<(const Node& node) const { 3.2687 + return DigraphNode::operator<(node) || 3.2688 + (DigraphNode::operator==(node) && _in < node._in); 3.2689 + } 3.2690 + }; 3.2691 + 3.2692 + class Arc { 3.2693 + friend class SplitNodesBase; 3.2694 + template <typename T> friend class ArcMapBase; 3.2695 + private: 3.2696 + typedef BiVariant<DigraphArc, DigraphNode> ArcImpl; 3.2697 + 3.2698 + explicit Arc(const DigraphArc& arc) : _item(arc) {} 3.2699 + explicit Arc(const DigraphNode& node) : _item(node) {} 3.2700 + 3.2701 + ArcImpl _item; 3.2702 + 3.2703 + public: 3.2704 + Arc() {} 3.2705 + Arc(Invalid) : _item(DigraphArc(INVALID)) {} 3.2706 + 3.2707 + bool operator==(const Arc& arc) const { 3.2708 + if (_item.firstState()) { 3.2709 + if (arc._item.firstState()) { 3.2710 + return _item.first() == arc._item.first(); 3.2711 + } 3.2712 + } else { 3.2713 + if (arc._item.secondState()) { 3.2714 + return _item.second() == arc._item.second(); 3.2715 + } 3.2716 + } 3.2717 + return false; 3.2718 + } 3.2719 + 3.2720 + bool operator!=(const Arc& arc) const { 3.2721 + return !(*this == arc); 3.2722 + } 3.2723 + 3.2724 + bool operator<(const Arc& arc) const { 3.2725 + if (_item.firstState()) { 3.2726 + if (arc._item.firstState()) { 3.2727 + return _item.first() < arc._item.first(); 3.2728 + } 3.2729 + return false; 3.2730 + } else { 3.2731 + if (arc._item.secondState()) { 3.2732 + return _item.second() < arc._item.second(); 3.2733 + } 3.2734 + return true; 3.2735 + } 3.2736 + } 3.2737 + 3.2738 + operator DigraphArc() const { return _item.first(); } 3.2739 + operator DigraphNode() const { return _item.second(); } 3.2740 + 3.2741 + }; 3.2742 + 3.2743 + void first(Node& n) const { 3.2744 + _digraph->first(n); 3.2745 + n._in = true; 3.2746 + } 3.2747 + 3.2748 + void next(Node& n) const { 3.2749 + if (n._in) { 3.2750 + n._in = false; 3.2751 + } else { 3.2752 + n._in = true; 3.2753 + _digraph->next(n); 3.2754 + } 3.2755 + } 3.2756 + 3.2757 + void first(Arc& e) const { 3.2758 + e._item.setSecond(); 3.2759 + _digraph->first(e._item.second()); 3.2760 + if (e._item.second() == INVALID) { 3.2761 + e._item.setFirst(); 3.2762 + _digraph->first(e._item.first()); 3.2763 + } 3.2764 + } 3.2765 + 3.2766 + void next(Arc& e) const { 3.2767 + if (e._item.secondState()) { 3.2768 + _digraph->next(e._item.second()); 3.2769 + if (e._item.second() == INVALID) { 3.2770 + e._item.setFirst(); 3.2771 + _digraph->first(e._item.first()); 3.2772 + } 3.2773 + } else { 3.2774 + _digraph->next(e._item.first()); 3.2775 + } 3.2776 + } 3.2777 + 3.2778 + void firstOut(Arc& e, const Node& n) const { 3.2779 + if (n._in) { 3.2780 + e._item.setSecond(n); 3.2781 + } else { 3.2782 + e._item.setFirst(); 3.2783 + _digraph->firstOut(e._item.first(), n); 3.2784 + } 3.2785 + } 3.2786 + 3.2787 + void nextOut(Arc& e) const { 3.2788 + if (!e._item.firstState()) { 3.2789 + e._item.setFirst(INVALID); 3.2790 + } else { 3.2791 + _digraph->nextOut(e._item.first()); 3.2792 + } 3.2793 + } 3.2794 + 3.2795 + void firstIn(Arc& e, const Node& n) const { 3.2796 + if (!n._in) { 3.2797 + e._item.setSecond(n); 3.2798 + } else { 3.2799 + e._item.setFirst(); 3.2800 + _digraph->firstIn(e._item.first(), n); 3.2801 + } 3.2802 + } 3.2803 + 3.2804 + void nextIn(Arc& e) const { 3.2805 + if (!e._item.firstState()) { 3.2806 + e._item.setFirst(INVALID); 3.2807 + } else { 3.2808 + _digraph->nextIn(e._item.first()); 3.2809 + } 3.2810 + } 3.2811 + 3.2812 + Node source(const Arc& e) const { 3.2813 + if (e._item.firstState()) { 3.2814 + return Node(_digraph->source(e._item.first()), false); 3.2815 + } else { 3.2816 + return Node(e._item.second(), true); 3.2817 + } 3.2818 + } 3.2819 + 3.2820 + Node target(const Arc& e) const { 3.2821 + if (e._item.firstState()) { 3.2822 + return Node(_digraph->target(e._item.first()), true); 3.2823 + } else { 3.2824 + return Node(e._item.second(), false); 3.2825 + } 3.2826 + } 3.2827 + 3.2828 + int id(const Node& n) const { 3.2829 + return (_digraph->id(n) << 1) | (n._in ? 0 : 1); 3.2830 + } 3.2831 + Node nodeFromId(int ix) const { 3.2832 + return Node(_digraph->nodeFromId(ix >> 1), (ix & 1) == 0); 3.2833 + } 3.2834 + int maxNodeId() const { 3.2835 + return 2 * _digraph->maxNodeId() + 1; 3.2836 + } 3.2837 + 3.2838 + int id(const Arc& e) const { 3.2839 + if (e._item.firstState()) { 3.2840 + return _digraph->id(e._item.first()) << 1; 3.2841 + } else { 3.2842 + return (_digraph->id(e._item.second()) << 1) | 1; 3.2843 + } 3.2844 + } 3.2845 + Arc arcFromId(int ix) const { 3.2846 + if ((ix & 1) == 0) { 3.2847 + return Arc(_digraph->arcFromId(ix >> 1)); 3.2848 + } else { 3.2849 + return Arc(_digraph->nodeFromId(ix >> 1)); 3.2850 + } 3.2851 + } 3.2852 + int maxArcId() const { 3.2853 + return std::max(_digraph->maxNodeId() << 1, 3.2854 + (_digraph->maxArcId() << 1) | 1); 3.2855 + } 3.2856 + 3.2857 + static bool inNode(const Node& n) { 3.2858 + return n._in; 3.2859 + } 3.2860 + 3.2861 + static bool outNode(const Node& n) { 3.2862 + return !n._in; 3.2863 + } 3.2864 + 3.2865 + static bool origArc(const Arc& e) { 3.2866 + return e._item.firstState(); 3.2867 + } 3.2868 + 3.2869 + static bool bindArc(const Arc& e) { 3.2870 + return e._item.secondState(); 3.2871 + } 3.2872 + 3.2873 + static Node inNode(const DigraphNode& n) { 3.2874 + return Node(n, true); 3.2875 + } 3.2876 + 3.2877 + static Node outNode(const DigraphNode& n) { 3.2878 + return Node(n, false); 3.2879 + } 3.2880 + 3.2881 + static Arc arc(const DigraphNode& n) { 3.2882 + return Arc(n); 3.2883 + } 3.2884 + 3.2885 + static Arc arc(const DigraphArc& e) { 3.2886 + return Arc(e); 3.2887 + } 3.2888 + 3.2889 + typedef True NodeNumTag; 3.2890 + 3.2891 + int nodeNum() const { 3.2892 + return 2 * countNodes(*_digraph); 3.2893 + } 3.2894 + 3.2895 + typedef True EdgeNumTag; 3.2896 + int arcNum() const { 3.2897 + return countArcs(*_digraph) + countNodes(*_digraph); 3.2898 + } 3.2899 + 3.2900 + typedef True FindEdgeTag; 3.2901 + Arc findArc(const Node& u, const Node& v, 3.2902 + const Arc& prev = INVALID) const { 3.2903 + if (inNode(u)) { 3.2904 + if (outNode(v)) { 3.2905 + if (static_cast<const DigraphNode&>(u) == 3.2906 + static_cast<const DigraphNode&>(v) && prev == INVALID) { 3.2907 + return Arc(u); 3.2908 + } 3.2909 + } 3.2910 + } else { 3.2911 + if (inNode(v)) { 3.2912 + return Arc(::lemon::findArc(*_digraph, u, v, prev)); 3.2913 + } 3.2914 + } 3.2915 + return INVALID; 3.2916 + } 3.2917 + 3.2918 + private: 3.2919 + 3.2920 + template <typename _Value> 3.2921 + class NodeMapBase 3.2922 + : public MapTraits<typename Parent::template NodeMap<_Value> > { 3.2923 + typedef typename Parent::template NodeMap<_Value> NodeImpl; 3.2924 + public: 3.2925 + typedef Node Key; 3.2926 + typedef _Value Value; 3.2927 + 3.2928 + NodeMapBase(const Adaptor& adaptor) 3.2929 + : _in_map(*adaptor._digraph), _out_map(*adaptor._digraph) {} 3.2930 + NodeMapBase(const Adaptor& adaptor, const Value& value) 3.2931 + : _in_map(*adaptor._digraph, value), 3.2932 + _out_map(*adaptor._digraph, value) {} 3.2933 + 3.2934 + void set(const Node& key, const Value& val) { 3.2935 + if (Adaptor::inNode(key)) { _in_map.set(key, val); } 3.2936 + else {_out_map.set(key, val); } 3.2937 + } 3.2938 + 3.2939 + typename MapTraits<NodeImpl>::ReturnValue 3.2940 + operator[](const Node& key) { 3.2941 + if (Adaptor::inNode(key)) { return _in_map[key]; } 3.2942 + else { return _out_map[key]; } 3.2943 + } 3.2944 + 3.2945 + typename MapTraits<NodeImpl>::ConstReturnValue 3.2946 + operator[](const Node& key) const { 3.2947 + if (Adaptor::inNode(key)) { return _in_map[key]; } 3.2948 + else { return _out_map[key]; } 3.2949 + } 3.2950 + 3.2951 + private: 3.2952 + NodeImpl _in_map, _out_map; 3.2953 + }; 3.2954 + 3.2955 + template <typename _Value> 3.2956 + class ArcMapBase 3.2957 + : public MapTraits<typename Parent::template ArcMap<_Value> > { 3.2958 + typedef typename Parent::template ArcMap<_Value> ArcImpl; 3.2959 + typedef typename Parent::template NodeMap<_Value> NodeImpl; 3.2960 + public: 3.2961 + typedef Arc Key; 3.2962 + typedef _Value Value; 3.2963 + 3.2964 + ArcMapBase(const Adaptor& adaptor) 3.2965 + : _arc_map(*adaptor._digraph), _node_map(*adaptor._digraph) {} 3.2966 + ArcMapBase(const Adaptor& adaptor, const Value& value) 3.2967 + : _arc_map(*adaptor._digraph, value), 3.2968 + _node_map(*adaptor._digraph, value) {} 3.2969 + 3.2970 + void set(const Arc& key, const Value& val) { 3.2971 + if (Adaptor::origArc(key)) { 3.2972 + _arc_map.set(key._item.first(), val); 3.2973 + } else { 3.2974 + _node_map.set(key._item.second(), val); 3.2975 + } 3.2976 + } 3.2977 + 3.2978 + typename MapTraits<ArcImpl>::ReturnValue 3.2979 + operator[](const Arc& key) { 3.2980 + if (Adaptor::origArc(key)) { 3.2981 + return _arc_map[key._item.first()]; 3.2982 + } else { 3.2983 + return _node_map[key._item.second()]; 3.2984 + } 3.2985 + } 3.2986 + 3.2987 + typename MapTraits<ArcImpl>::ConstReturnValue 3.2988 + operator[](const Arc& key) const { 3.2989 + if (Adaptor::origArc(key)) { 3.2990 + return _arc_map[key._item.first()]; 3.2991 + } else { 3.2992 + return _node_map[key._item.second()]; 3.2993 + } 3.2994 + } 3.2995 + 3.2996 + private: 3.2997 + ArcImpl _arc_map; 3.2998 + NodeImpl _node_map; 3.2999 + }; 3.3000 + 3.3001 + public: 3.3002 + 3.3003 + template <typename _Value> 3.3004 + class NodeMap 3.3005 + : public SubMapExtender<Adaptor, NodeMapBase<_Value> > 3.3006 + { 3.3007 + public: 3.3008 + typedef _Value Value; 3.3009 + typedef SubMapExtender<Adaptor, NodeMapBase<Value> > Parent; 3.3010 + 3.3011 + NodeMap(const Adaptor& adaptor) 3.3012 + : Parent(adaptor) {} 3.3013 + 3.3014 + NodeMap(const Adaptor& adaptor, const Value& value) 3.3015 + : Parent(adaptor, value) {} 3.3016 + 3.3017 + private: 3.3018 + NodeMap& operator=(const NodeMap& cmap) { 3.3019 + return operator=<NodeMap>(cmap); 3.3020 + } 3.3021 + 3.3022 + template <typename CMap> 3.3023 + NodeMap& operator=(const CMap& cmap) { 3.3024 + Parent::operator=(cmap); 3.3025 + return *this; 3.3026 + } 3.3027 + }; 3.3028 + 3.3029 + template <typename _Value> 3.3030 + class ArcMap 3.3031 + : public SubMapExtender<Adaptor, ArcMapBase<_Value> > 3.3032 + { 3.3033 + public: 3.3034 + typedef _Value Value; 3.3035 + typedef SubMapExtender<Adaptor, ArcMapBase<Value> > Parent; 3.3036 + 3.3037 + ArcMap(const Adaptor& adaptor) 3.3038 + : Parent(adaptor) {} 3.3039 + 3.3040 + ArcMap(const Adaptor& adaptor, const Value& value) 3.3041 + : Parent(adaptor, value) {} 3.3042 + 3.3043 + private: 3.3044 + ArcMap& operator=(const ArcMap& cmap) { 3.3045 + return operator=<ArcMap>(cmap); 3.3046 + } 3.3047 + 3.3048 + template <typename CMap> 3.3049 + ArcMap& operator=(const CMap& cmap) { 3.3050 + Parent::operator=(cmap); 3.3051 + return *this; 3.3052 + } 3.3053 + }; 3.3054 + 3.3055 + protected: 3.3056 + 3.3057 + SplitNodesBase() : _digraph(0) {} 3.3058 + 3.3059 + Digraph* _digraph; 3.3060 + 3.3061 + void setDigraph(Digraph& digraph) { 3.3062 + _digraph = &digraph; 3.3063 + } 3.3064 + 3.3065 + }; 3.3066 + 3.3067 + /// \ingroup graph_adaptors 3.3068 + /// 3.3069 + /// \brief Split the nodes of a directed graph 3.3070 + /// 3.3071 + /// The SplitNodes adaptor splits each node into an in-node and an 3.3072 + /// out-node. Formaly, the adaptor replaces each \f$ u \f$node in 3.3073 + /// the digraph with two nodes(namely node \f$ u_{in} \f$and node 3.3074 + /// \f$ u_{out} \f$). If there is a \f$ (v, u) \f$arc in the 3.3075 + /// original digraph the new target of the arc will be \f$ u_{in} \f$3.3076 + /// and similarly the source of the original \f$ (u, v) \f$arc 3.3077 + /// will be \f$ u_{out} \f$. The adaptor will add for each node in 3.3078 + /// the original digraph an additional arc which connects 3.3079 + /// \f$ (u_{in}, u_{out}) \f$. 3.3080 + /// 3.3081 + /// The aim of this class is to run algorithm with node costs if the 3.3082 + /// algorithm can use directly just arc costs. In this case we should use 3.3083 + /// a \c SplitNodes and set the node cost of the graph to the 3.3084 + /// bind arc in the adapted graph. 3.3085 + /// 3.3086 + /// \tparam _Digraph It must be conform to the \ref concepts::Digraph 3.3087 + /// "Digraph concept". The type can be specified to be const. 3.3088 + template <typename _Digraph> 3.3089 + class SplitNodes 3.3090 + : public DigraphAdaptorExtender<SplitNodesBase<_Digraph> > { 3.3091 + public: 3.3092 + typedef _Digraph Digraph; 3.3093 + typedef DigraphAdaptorExtender<SplitNodesBase<Digraph> > Parent; 3.3094 + 3.3095 + typedef typename Digraph::Node DigraphNode; 3.3096 + typedef typename Digraph::Arc DigraphArc; 3.3097 + 3.3098 + typedef typename Parent::Node Node; 3.3099 + typedef typename Parent::Arc Arc; 3.3100 + 3.3101 + /// \brief Constructor of the adaptor. 3.3102 + /// 3.3103 + /// Constructor of the adaptor. 3.3104 + SplitNodes(Digraph& g) { 3.3105 + Parent::setDigraph(g); 3.3106 + } 3.3107 + 3.3108 + /// \brief Returns true when the node is in-node. 3.3109 + /// 3.3110 + /// Returns true when the node is in-node. 3.3111 + static bool inNode(const Node& n) { 3.3112 + return Parent::inNode(n); 3.3113 + } 3.3114 + 3.3115 + /// \brief Returns true when the node is out-node. 3.3116 + /// 3.3117 + /// Returns true when the node is out-node. 3.3118 + static bool outNode(const Node& n) { 3.3119 + return Parent::outNode(n); 3.3120 + } 3.3121 + 3.3122 + /// \brief Returns true when the arc is arc in the original digraph. 3.3123 + /// 3.3124 + /// Returns true when the arc is arc in the original digraph. 3.3125 + static bool origArc(const Arc& a) { 3.3126 + return Parent::origArc(a); 3.3127 + } 3.3128 + 3.3129 + /// \brief Returns true when the arc binds an in-node and an out-node. 3.3130 + /// 3.3131 + /// Returns true when the arc binds an in-node and an out-node. 3.3132 + static bool bindArc(const Arc& a) { 3.3133 + return Parent::bindArc(a); 3.3134 + } 3.3135 + 3.3136 + /// \brief Gives back the in-node created from the \c node. 3.3137 + /// 3.3138 + /// Gives back the in-node created from the \c node. 3.3139 + static Node inNode(const DigraphNode& n) { 3.3140 + return Parent::inNode(n); 3.3141 + } 3.3142 + 3.3143 + /// \brief Gives back the out-node created from the \c node. 3.3144 + /// 3.3145 + /// Gives back the out-node created from the \c node. 3.3146 + static Node outNode(const DigraphNode& n) { 3.3147 + return Parent::outNode(n); 3.3148 + } 3.3149 + 3.3150 + /// \brief Gives back the arc binds the two part of the node. 3.3151 + /// 3.3152 + /// Gives back the arc binds the two part of the node. 3.3153 + static Arc arc(const DigraphNode& n) { 3.3154 + return Parent::arc(n); 3.3155 + } 3.3156 + 3.3157 + /// \brief Gives back the arc of the original arc. 3.3158 + /// 3.3159 + /// Gives back the arc of the original arc. 3.3160 + static Arc arc(const DigraphArc& a) { 3.3161 + return Parent::arc(a); 3.3162 + } 3.3163 + 3.3164 + /// \brief NodeMap combined from two original NodeMap 3.3165 + /// 3.3166 + /// This class adapt two of the original digraph NodeMap to 3.3167 + /// get a node map on the adapted digraph. 3.3168 + template <typename InNodeMap, typename OutNodeMap> 3.3169 + class CombinedNodeMap { 3.3170 + public: 3.3171 + 3.3172 + typedef Node Key; 3.3173 + typedef typename InNodeMap::Value Value; 3.3174 + 3.3175 + /// \brief Constructor 3.3176 + /// 3.3177 + /// Constructor. 3.3178 + CombinedNodeMap(InNodeMap& in_map, OutNodeMap& out_map) 3.3179 + : _in_map(in_map), _out_map(out_map) {} 3.3180 + 3.3181 + /// \brief The subscript operator. 3.3182 + /// 3.3183 + /// The subscript operator. 3.3184 + Value& operator[](const Key& key) { 3.3185 + if (Parent::inNode(key)) { 3.3186 + return _in_map[key]; 3.3187 + } else { 3.3188 + return _out_map[key]; 3.3189 + } 3.3190 + } 3.3191 + 3.3192 + /// \brief The const subscript operator. 3.3193 + /// 3.3194 + /// The const subscript operator. 3.3195 + Value operator[](const Key& key) const { 3.3196 + if (Parent::inNode(key)) { 3.3197 + return _in_map[key]; 3.3198 + } else { 3.3199 + return _out_map[key]; 3.3200 + } 3.3201 + } 3.3202 + 3.3203 + /// \brief The setter function of the map. 3.3204 + /// 3.3205 + /// The setter function of the map. 3.3206 + void set(const Key& key, const Value& value) { 3.3207 + if (Parent::inNode(key)) { 3.3208 + _in_map.set(key, value); 3.3209 + } else { 3.3210 + _out_map.set(key, value); 3.3211 + } 3.3212 + } 3.3213 + 3.3214 + private: 3.3215 + 3.3216 + InNodeMap& _in_map; 3.3217 + OutNodeMap& _out_map; 3.3218 + 3.3219 + }; 3.3220 + 3.3221 + 3.3222 + /// \brief Just gives back a combined node map 3.3223 + /// 3.3224 + /// Just gives back a combined node map 3.3225 + template <typename InNodeMap, typename OutNodeMap> 3.3226 + static CombinedNodeMap<InNodeMap, OutNodeMap> 3.3227 + combinedNodeMap(InNodeMap& in_map, OutNodeMap& out_map) { 3.3228 + return CombinedNodeMap<InNodeMap, OutNodeMap>(in_map, out_map); 3.3229 + } 3.3230 + 3.3231 + template <typename InNodeMap, typename OutNodeMap> 3.3232 + static CombinedNodeMap<const InNodeMap, OutNodeMap> 3.3233 + combinedNodeMap(const InNodeMap& in_map, OutNodeMap& out_map) { 3.3234 + return CombinedNodeMap<const InNodeMap, OutNodeMap>(in_map, out_map); 3.3235 + } 3.3236 + 3.3237 + template <typename InNodeMap, typename OutNodeMap> 3.3238 + static CombinedNodeMap<InNodeMap, const OutNodeMap> 3.3239 + combinedNodeMap(InNodeMap& in_map, const OutNodeMap& out_map) { 3.3240 + return CombinedNodeMap<InNodeMap, const OutNodeMap>(in_map, out_map); 3.3241 + } 3.3242 + 3.3243 + template <typename InNodeMap, typename OutNodeMap> 3.3244 + static CombinedNodeMap<const InNodeMap, const OutNodeMap> 3.3245 + combinedNodeMap(const InNodeMap& in_map, const OutNodeMap& out_map) { 3.3246 + return CombinedNodeMap<const InNodeMap, 3.3247 + const OutNodeMap>(in_map, out_map); 3.3248 + } 3.3249 + 3.3250 + /// \brief ArcMap combined from an original ArcMap and a NodeMap 3.3251 + /// 3.3252 + /// This class adapt an original ArcMap and a NodeMap to get an 3.3253 + /// arc map on the adapted digraph 3.3254 + template <typename DigraphArcMap, typename DigraphNodeMap> 3.3255 + class CombinedArcMap { 3.3256 + public: 3.3257 + 3.3258 + typedef Arc Key; 3.3259 + typedef typename DigraphArcMap::Value Value; 3.3260 + 3.3261 + /// \brief Constructor 3.3262 + /// 3.3263 + /// Constructor. 3.3264 + CombinedArcMap(DigraphArcMap& arc_map, DigraphNodeMap& node_map) 3.3265 + : _arc_map(arc_map), _node_map(node_map) {} 3.3266 + 3.3267 + /// \brief The subscript operator. 3.3268 + /// 3.3269 + /// The subscript operator. 3.3270 + void set(const Arc& arc, const Value& val) { 3.3271 + if (Parent::origArc(arc)) { 3.3272 + _arc_map.set(arc, val); 3.3273 + } else { 3.3274 + _node_map.set(arc, val); 3.3275 + } 3.3276 + } 3.3277 + 3.3278 + /// \brief The const subscript operator. 3.3279 + /// 3.3280 + /// The const subscript operator. 3.3281 + Value operator[](const Key& arc) const { 3.3282 + if (Parent::origArc(arc)) { 3.3283 + return _arc_map[arc]; 3.3284 + } else { 3.3285 + return _node_map[arc]; 3.3286 + } 3.3287 + } 3.3288 + 3.3289 + /// \brief The const subscript operator. 3.3290 + /// 3.3291 + /// The const subscript operator. 3.3292 + Value& operator[](const Key& arc) { 3.3293 + if (Parent::origArc(arc)) { 3.3294 + return _arc_map[arc]; 3.3295 + } else { 3.3296 + return _node_map[arc]; 3.3297 + } 3.3298 + } 3.3299 + 3.3300 + private: 3.3301 + DigraphArcMap& _arc_map; 3.3302 + DigraphNodeMap& _node_map; 3.3303 + }; 3.3304 + 3.3305 + /// \brief Just gives back a combined arc map 3.3306 + /// 3.3307 + /// Just gives back a combined arc map 3.3308 + template <typename DigraphArcMap, typename DigraphNodeMap> 3.3309 + static CombinedArcMap<DigraphArcMap, DigraphNodeMap> 3.3310 + combinedArcMap(DigraphArcMap& arc_map, DigraphNodeMap& node_map) { 3.3311 + return CombinedArcMap<DigraphArcMap, DigraphNodeMap>(arc_map, node_map); 3.3312 + } 3.3313 + 3.3314 + template <typename DigraphArcMap, typename DigraphNodeMap> 3.3315 + static CombinedArcMap<const DigraphArcMap, DigraphNodeMap> 3.3316 + combinedArcMap(const DigraphArcMap& arc_map, DigraphNodeMap& node_map) { 3.3317 + return CombinedArcMap<const DigraphArcMap, 3.3318 + DigraphNodeMap>(arc_map, node_map); 3.3319 + } 3.3320 + 3.3321 + template <typename DigraphArcMap, typename DigraphNodeMap> 3.3322 + static CombinedArcMap<DigraphArcMap, const DigraphNodeMap> 3.3323 + combinedArcMap(DigraphArcMap& arc_map, const DigraphNodeMap& node_map) { 3.3324 + return CombinedArcMap<DigraphArcMap, 3.3325 + const DigraphNodeMap>(arc_map, node_map); 3.3326 + } 3.3327 + 3.3328 + template <typename DigraphArcMap, typename DigraphNodeMap> 3.3329 + static CombinedArcMap<const DigraphArcMap, const DigraphNodeMap> 3.3330 + combinedArcMap(const DigraphArcMap& arc_map, 3.3331 + const DigraphNodeMap& node_map) { 3.3332 + return CombinedArcMap<const DigraphArcMap, 3.3333 + const DigraphNodeMap>(arc_map, node_map); 3.3334 + } 3.3335 + 3.3336 + }; 3.3337 + 3.3338 + /// \brief Just gives back a node splitter 3.3339 + /// 3.3340 + /// Just gives back a node splitter 3.3341 + template<typename Digraph> 3.3342 + SplitNodes<Digraph> 3.3343 + splitNodes(const Digraph& digraph) { 3.3344 + return SplitNodes<Digraph>(digraph); 3.3345 + } 3.3346 + 3.3347 + 3.3348 +} //namespace lemon 3.3349 + 3.3350 +#endif //LEMON_ADAPTORS_H   4.1 --- a/lemon/bits/graph_adaptor_extender.h Sun Nov 30 19:00:30 2008 +0100 4.2 +++ b/lemon/bits/graph_adaptor_extender.h Sun Nov 30 19:18:32 2008 +0100 4.3 @@ -1,6 +1,6 @@ 4.4 -/* -*- C++ -*- 4.5 +/* -*- mode: C++; indent-tabs-mode: nil; -*- 4.6 * 4.7 - * This file is a part of LEMON, a generic C++ optimization library 4.8 + * This file is a part of LEMON, a generic C++ optimization library. 4.9 * 4.10 * Copyright (C) 2003-2008 4.11 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport 4.12 @@ -24,15 +24,8 @@ 4.13 4.14 #include <lemon/bits/default_map.h> 4.15 4.16 - 4.17 -///\ingroup digraphbits 4.18 -///\file 4.19 -///\brief Extenders for the digraph adaptor types 4.20 namespace lemon { 4.21 4.22 - /// \ingroup digraphbits 4.23 - /// 4.24 - /// \brief Extender for the DigraphAdaptors 4.25 template <typename _Digraph> 4.26 class DigraphAdaptorExtender : public _Digraph { 4.27 public: 4.28 @@ -64,14 +57,14 @@ 4.29 4.30 Node oppositeNode(const Node &n, const Arc &e) const { 4.31 if (n == Parent::source(e)) 4.32 - return Parent::target(e); 4.33 + return Parent::target(e); 4.34 else if(n==Parent::target(e)) 4.35 - return Parent::source(e); 4.36 + return Parent::source(e); 4.37 else 4.38 - return INVALID; 4.39 + return INVALID; 4.40 } 4.41 4.42 - class NodeIt : public Node { 4.43 + class NodeIt : public Node { 4.44 const Adaptor* _adaptor; 4.45 public: 4.46 4.47 @@ -80,21 +73,21 @@ 4.48 NodeIt(Invalid i) : Node(i) { } 4.49 4.50 explicit NodeIt(const Adaptor& adaptor) : _adaptor(&adaptor) { 4.51 - _adaptor->first(static_cast<Node&>(*this)); 4.52 + _adaptor->first(static_cast<Node&>(*this)); 4.53 } 4.54 4.55 - NodeIt(const Adaptor& adaptor, const Node& node) 4.56 - : Node(node), _adaptor(&adaptor) {} 4.57 + NodeIt(const Adaptor& adaptor, const Node& node) 4.58 + : Node(node), _adaptor(&adaptor) {} 4.59 4.60 - NodeIt& operator++() { 4.61 - _adaptor->next(*this); 4.62 - return *this; 4.63 + NodeIt& operator++() { 4.64 + _adaptor->next(*this); 4.65 + return *this; 4.66 } 4.67 4.68 }; 4.69 4.70 4.71 - class ArcIt : public Arc { 4.72 + class ArcIt : public Arc { 4.73 const Adaptor* _adaptor; 4.74 public: 4.75 4.76 @@ -103,21 +96,21 @@ 4.77 ArcIt(Invalid i) : Arc(i) { } 4.78 4.79 explicit ArcIt(const Adaptor& adaptor) : _adaptor(&adaptor) { 4.80 - _adaptor->first(static_cast<Arc&>(*this)); 4.81 + _adaptor->first(static_cast<Arc&>(*this)); 4.82 } 4.83 4.84 - ArcIt(const Adaptor& adaptor, const Arc& e) : 4.85 - Arc(e), _adaptor(&adaptor) { } 4.86 + ArcIt(const Adaptor& adaptor, const Arc& e) : 4.87 + Arc(e), _adaptor(&adaptor) { } 4.88 4.89 - ArcIt& operator++() { 4.90 - _adaptor->next(*this); 4.91 - return *this; 4.92 + ArcIt& operator++() { 4.93 + _adaptor->next(*this); 4.94 + return *this; 4.95 } 4.96 4.97 }; 4.98 4.99 4.100 - class OutArcIt : public Arc { 4.101 + class OutArcIt : public Arc { 4.102 const Adaptor* _adaptor; 4.103 public: 4.104 4.105 @@ -125,23 +118,23 @@ 4.106 4.107 OutArcIt(Invalid i) : Arc(i) { } 4.108 4.109 - OutArcIt(const Adaptor& adaptor, const Node& node) 4.110 - : _adaptor(&adaptor) { 4.111 - _adaptor->firstOut(*this, node); 4.112 + OutArcIt(const Adaptor& adaptor, const Node& node) 4.113 + : _adaptor(&adaptor) { 4.114 + _adaptor->firstOut(*this, node); 4.115 } 4.116 4.117 - OutArcIt(const Adaptor& adaptor, const Arc& arc) 4.118 - : Arc(arc), _adaptor(&adaptor) {} 4.119 + OutArcIt(const Adaptor& adaptor, const Arc& arc) 4.120 + : Arc(arc), _adaptor(&adaptor) {} 4.121 4.122 - OutArcIt& operator++() { 4.123 - _adaptor->nextOut(*this); 4.124 - return *this; 4.125 + OutArcIt& operator++() { 4.126 + _adaptor->nextOut(*this); 4.127 + return *this; 4.128 } 4.129 4.130 }; 4.131 4.132 4.133 - class InArcIt : public Arc { 4.134 + class InArcIt : public Arc { 4.135 const Adaptor* _adaptor; 4.136 public: 4.137 4.138 @@ -149,45 +142,31 @@ 4.139 4.140 InArcIt(Invalid i) : Arc(i) { } 4.141 4.142 - InArcIt(const Adaptor& adaptor, const Node& node) 4.143 - : _adaptor(&adaptor) { 4.144 - _adaptor->firstIn(*this, node); 4.145 + InArcIt(const Adaptor& adaptor, const Node& node) 4.146 + : _adaptor(&adaptor) { 4.147 + _adaptor->firstIn(*this, node); 4.148 } 4.149 4.150 - InArcIt(const Adaptor& adaptor, const Arc& arc) : 4.151 - Arc(arc), _adaptor(&adaptor) {} 4.152 + InArcIt(const Adaptor& adaptor, const Arc& arc) : 4.153 + Arc(arc), _adaptor(&adaptor) {} 4.154 4.155 - InArcIt& operator++() { 4.156 - _adaptor->nextIn(*this); 4.157 - return *this; 4.158 + InArcIt& operator++() { 4.159 + _adaptor->nextIn(*this); 4.160 + return *this; 4.161 } 4.162 4.163 }; 4.164 4.165 - /// \brief Base node of the iterator 4.166 - /// 4.167 - /// Returns the base node (ie. the source in this case) of the iterator 4.168 Node baseNode(const OutArcIt &e) const { 4.169 return Parent::source(e); 4.170 } 4.171 - /// \brief Running node of the iterator 4.172 - /// 4.173 - /// Returns the running node (ie. the target in this case) of the 4.174 - /// iterator 4.175 Node runningNode(const OutArcIt &e) const { 4.176 return Parent::target(e); 4.177 } 4.178 4.179 - /// \brief Base node of the iterator 4.180 - /// 4.181 - /// Returns the base node (ie. the target in this case) of the iterator 4.182 Node baseNode(const InArcIt &e) const { 4.183 return Parent::target(e); 4.184 } 4.185 - /// \brief Running node of the iterator 4.186 - /// 4.187 - /// Returns the running node (ie. the source in this case) of the 4.188 - /// iterator 4.189 Node runningNode(const InArcIt &e) const { 4.190 return Parent::source(e); 4.191 } 4.192 @@ -198,10 +177,10 @@ 4.193 /// \ingroup digraphbits 4.194 /// 4.195 /// \brief Extender for the GraphAdaptors 4.196 - template <typename _Graph> 4.197 + template <typename _Graph> 4.198 class GraphAdaptorExtender : public _Graph { 4.199 public: 4.200 - 4.201 + 4.202 typedef _Graph Parent; 4.203 typedef _Graph Graph; 4.204 typedef GraphAdaptorExtender Adaptor; 4.205 @@ -210,7 +189,7 @@ 4.206 typedef typename Parent::Arc Arc; 4.207 typedef typename Parent::Edge Edge; 4.208 4.209 - // Graph extension 4.210 + // Graph extension 4.211 4.212 int maxId(Node) const { 4.213 return Parent::maxNodeId(); 4.214 @@ -238,11 +217,11 @@ 4.215 4.216 Node oppositeNode(const Node &n, const Edge &e) const { 4.217 if( n == Parent::u(e)) 4.218 - return Parent::v(e); 4.219 + return Parent::v(e); 4.220 else if( n == Parent::v(e)) 4.221 - return Parent::u(e); 4.222 + return Parent::u(e); 4.223 else 4.224 - return INVALID; 4.225 + return INVALID; 4.226 } 4.227 4.228 Arc oppositeArc(const Arc &a) const { 4.229 @@ -255,7 +234,7 @@ 4.230 } 4.231 4.232 4.233 - class NodeIt : public Node { 4.234 + class NodeIt : public Node { 4.235 const Adaptor* _adaptor; 4.236 public: 4.237 4.238 @@ -264,21 +243,21 @@ 4.239 NodeIt(Invalid i) : Node(i) { } 4.240 4.241 explicit NodeIt(const Adaptor& adaptor) : _adaptor(&adaptor) { 4.242 - _adaptor->first(static_cast<Node&>(*this)); 4.243 + _adaptor->first(static_cast<Node&>(*this)); 4.244 } 4.245 4.246 - NodeIt(const Adaptor& adaptor, const Node& node) 4.247 - : Node(node), _adaptor(&adaptor) {} 4.248 + NodeIt(const Adaptor& adaptor, const Node& node) 4.249 + : Node(node), _adaptor(&adaptor) {} 4.250 4.251 - NodeIt& operator++() { 4.252 - _adaptor->next(*this); 4.253 - return *this; 4.254 + NodeIt& operator++() { 4.255 + _adaptor->next(*this); 4.256 + return *this; 4.257 } 4.258 4.259 }; 4.260 4.261 4.262 - class ArcIt : public Arc { 4.263 + class ArcIt : public Arc { 4.264 const Adaptor* _adaptor; 4.265 public: 4.266 4.267 @@ -287,21 +266,21 @@ 4.268 ArcIt(Invalid i) : Arc(i) { } 4.269 4.270 explicit ArcIt(const Adaptor& adaptor) : _adaptor(&adaptor) { 4.271 - _adaptor->first(static_cast<Arc&>(*this)); 4.272 + _adaptor->first(static_cast<Arc&>(*this)); 4.273 } 4.274 4.275 - ArcIt(const Adaptor& adaptor, const Arc& e) : 4.276 - Arc(e), _adaptor(&adaptor) { } 4.277 + ArcIt(const Adaptor& adaptor, const Arc& e) : 4.278 + Arc(e), _adaptor(&adaptor) { } 4.279 4.280 - ArcIt& operator++() { 4.281 - _adaptor->next(*this); 4.282 - return *this; 4.283 + ArcIt& operator++() { 4.284 + _adaptor->next(*this); 4.285 + return *this; 4.286 } 4.287 4.288 }; 4.289 4.290 4.291 - class OutArcIt : public Arc { 4.292 + class OutArcIt : public Arc { 4.293 const Adaptor* _adaptor; 4.294 public: 4.295 4.296 @@ -309,23 +288,23 @@ 4.297 4.298 OutArcIt(Invalid i) : Arc(i) { } 4.299 4.300 - OutArcIt(const Adaptor& adaptor, const Node& node) 4.301 - : _adaptor(&adaptor) { 4.302 - _adaptor->firstOut(*this, node); 4.303 + OutArcIt(const Adaptor& adaptor, const Node& node) 4.304 + : _adaptor(&adaptor) { 4.305 + _adaptor->firstOut(*this, node); 4.306 } 4.307 4.308 - OutArcIt(const Adaptor& adaptor, const Arc& arc) 4.309 - : Arc(arc), _adaptor(&adaptor) {} 4.310 + OutArcIt(const Adaptor& adaptor, const Arc& arc) 4.311 + : Arc(arc), _adaptor(&adaptor) {} 4.312 4.313 - OutArcIt& operator++() { 4.314 - _adaptor->nextOut(*this); 4.315 - return *this; 4.316 + OutArcIt& operator++() { 4.317 + _adaptor->nextOut(*this); 4.318 + return *this; 4.319 } 4.320 4.321 }; 4.322 4.323 4.324 - class InArcIt : public Arc { 4.325 + class InArcIt : public Arc { 4.326 const Adaptor* _adaptor; 4.327 public: 4.328 4.329 @@ -333,22 +312,22 @@ 4.330 4.331 InArcIt(Invalid i) : Arc(i) { } 4.332 4.333 - InArcIt(const Adaptor& adaptor, const Node& node) 4.334 - : _adaptor(&adaptor) { 4.335 - _adaptor->firstIn(*this, node); 4.336 + InArcIt(const Adaptor& adaptor, const Node& node) 4.337 + : _adaptor(&adaptor) { 4.338 + _adaptor->firstIn(*this, node); 4.339 } 4.340 4.341 - InArcIt(const Adaptor& adaptor, const Arc& arc) : 4.342 - Arc(arc), _adaptor(&adaptor) {} 4.343 + InArcIt(const Adaptor& adaptor, const Arc& arc) : 4.344 + Arc(arc), _adaptor(&adaptor) {} 4.345 4.346 - InArcIt& operator++() { 4.347 - _adaptor->nextIn(*this); 4.348 - return *this; 4.349 + InArcIt& operator++() { 4.350 + _adaptor->nextIn(*this); 4.351 + return *this; 4.352 } 4.353 4.354 }; 4.355 4.356 - class EdgeIt : public Parent::Edge { 4.357 + class EdgeIt : public Parent::Edge { 4.358 const Adaptor* _adaptor; 4.359 public: 4.360 4.361 @@ -357,20 +336,20 @@ 4.362 EdgeIt(Invalid i) : Edge(i) { } 4.363 4.364 explicit EdgeIt(const Adaptor& adaptor) : _adaptor(&adaptor) { 4.365 - _adaptor->first(static_cast<Edge&>(*this)); 4.366 + _adaptor->first(static_cast<Edge&>(*this)); 4.367 } 4.368 4.369 - EdgeIt(const Adaptor& adaptor, const Edge& e) : 4.370 - Edge(e), _adaptor(&adaptor) { } 4.371 + EdgeIt(const Adaptor& adaptor, const Edge& e) : 4.372 + Edge(e), _adaptor(&adaptor) { } 4.373 4.374 - EdgeIt& operator++() { 4.375 - _adaptor->next(*this); 4.376 - return *this; 4.377 + EdgeIt& operator++() { 4.378 + _adaptor->next(*this); 4.379 + return *this; 4.380 } 4.381 4.382 }; 4.383 4.384 - class IncEdgeIt : public Edge { 4.385 + class IncEdgeIt : public Edge { 4.386 friend class GraphAdaptorExtender; 4.387 const Adaptor* _adaptor; 4.388 bool direction; 4.389 @@ -381,57 +360,37 @@ 4.390 IncEdgeIt(Invalid i) : Edge(i), direction(false) { } 4.391 4.392 IncEdgeIt(const Adaptor& adaptor, const Node &n) : _adaptor(&adaptor) { 4.393 - _adaptor->firstInc(static_cast<Edge&>(*this), direction, n); 4.394 + _adaptor->firstInc(static_cast<Edge&>(*this), direction, n); 4.395 } 4.396 4.397 IncEdgeIt(const Adaptor& adaptor, const Edge &e, const Node &n) 4.398 - : _adaptor(&adaptor), Edge(e) { 4.399 - direction = (_adaptor->u(e) == n); 4.400 + : _adaptor(&adaptor), Edge(e) { 4.401 + direction = (_adaptor->u(e) == n); 4.402 } 4.403 4.404 IncEdgeIt& operator++() { 4.405 - _adaptor->nextInc(*this, direction); 4.406 - return *this; 4.407 + _adaptor->nextInc(*this, direction); 4.408 + return *this; 4.409 } 4.410 }; 4.411 4.412 - /// \brief Base node of the iterator 4.413 - /// 4.414 - /// Returns the base node (ie. the source in this case) of the iterator 4.415 Node baseNode(const OutArcIt &a) const { 4.416 return Parent::source(a); 4.417 } 4.418 - /// \brief Running node of the iterator 4.419 - /// 4.420 - /// Returns the running node (ie. the target in this case) of the 4.421 - /// iterator 4.422 Node runningNode(const OutArcIt &a) const { 4.423 return Parent::target(a); 4.424 } 4.425 4.426 - /// \brief Base node of the iterator 4.427 - /// 4.428 - /// Returns the base node (ie. the target in this case) of the iterator 4.429 Node baseNode(const InArcIt &a) const { 4.430 return Parent::target(a); 4.431 } 4.432 - /// \brief Running node of the iterator 4.433 - /// 4.434 - /// Returns the running node (ie. the source in this case) of the 4.435 - /// iterator 4.436 Node runningNode(const InArcIt &a) const { 4.437 return Parent::source(a); 4.438 } 4.439 4.440 - /// Base node of the iterator 4.441 - /// 4.442 - /// Returns the base node of the iterator 4.443 Node baseNode(const IncEdgeIt &e) const { 4.444 return e.direction ? Parent::u(e) : Parent::v(e); 4.445 } 4.446 - /// Running node of the iterator 4.447 - /// 4.448 - /// Returns the running node of the iterator 4.449 Node runningNode(const IncEdgeIt &e) const { 4.450 return e.direction ? Parent::v(e) : Parent::u(e); 4.451 }   5.1 --- a/lemon/bits/variant.h Sun Nov 30 19:00:30 2008 +0100 5.2 +++ b/lemon/bits/variant.h Sun Nov 30 19:18:32 2008 +0100 5.3 @@ -1,6 +1,6 @@ 5.4 -/* -*- C++ -*- 5.5 +/* -*- mode: C++; indent-tabs-mode: nil; -*- 5.6 * 5.7 - * This file is a part of LEMON, a generic C++ optimization library 5.8 + * This file is a part of LEMON, a generic C++ optimization library. 5.9 * 5.10 * Copyright (C) 2003-2008 5.11 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport 5.12 @@ -27,7 +27,7 @@ 5.13 namespace lemon { 5.14 5.15 namespace _variant_bits { 5.16 - 5.17 + 5.18 template <int left, int right> 5.19 struct CTMax { 5.20 static const int value = left < right ? right : left; 5.21 @@ -86,9 +86,9 @@ 5.22 BiVariant(const BiVariant& bivariant) { 5.23 flag = bivariant.flag; 5.24 if (flag) { 5.25 - new(reinterpret_cast<First*>(data)) First(bivariant.first()); 5.26 + new(reinterpret_cast<First*>(data)) First(bivariant.first()); 5.27 } else { 5.28 - new(reinterpret_cast<Second*>(data)) Second(bivariant.second()); 5.29 + new(reinterpret_cast<Second*>(data)) Second(bivariant.second()); 5.30 } 5.31 } 5.32 5.33 @@ -106,7 +106,7 @@ 5.34 BiVariant& setFirst() { 5.35 destroy(); 5.36 flag = true; 5.37 - new(reinterpret_cast<First*>(data)) First(); 5.38 + new(reinterpret_cast<First*>(data)) First(); 5.39 return *this; 5.40 } 5.41 5.42 @@ -117,7 +117,7 @@ 5.43 BiVariant& setFirst(const First& f) { 5.44 destroy(); 5.45 flag = true; 5.46 - new(reinterpret_cast<First*>(data)) First(f); 5.47 + new(reinterpret_cast<First*>(data)) First(f); 5.48 return *this; 5.49 } 5.50 5.51 @@ -128,7 +128,7 @@ 5.52 BiVariant& setSecond() { 5.53 destroy(); 5.54 flag = false; 5.55 - new(reinterpret_cast<Second*>(data)) Second(); 5.56 + new(reinterpret_cast<Second*>(data)) Second(); 5.57 return *this; 5.58 } 5.59 5.60 @@ -139,7 +139,7 @@ 5.61 BiVariant& setSecond(const Second& s) { 5.62 destroy(); 5.63 flag = false; 5.64 - new(reinterpret_cast<Second*>(data)) Second(s); 5.65 + new(reinterpret_cast<Second*>(data)) Second(s); 5.66 return *this; 5.67 } 5.68 5.69 @@ -159,9 +159,9 @@ 5.70 destroy(); 5.71 flag = bivariant.flag; 5.72 if (flag) { 5.73 - new(reinterpret_cast<First*>(data)) First(bivariant.first()); 5.74 + new(reinterpret_cast<First*>(data)) First(bivariant.first()); 5.75 } else { 5.76 - new(reinterpret_cast<Second*>(data)) Second(bivariant.second()); 5.77 + new(reinterpret_cast<Second*>(data)) Second(bivariant.second()); 5.78 } 5.79 return *this; 5.80 } 5.81 @@ -231,13 +231,13 @@ 5.82 reinterpret_cast<Second*>(data)->~Second(); 5.83 } 5.84 } 5.85 - 5.86 + 5.87 char data[_variant_bits::CTMax<sizeof(First), sizeof(Second)>::value]; 5.88 bool flag; 5.89 }; 5.90 5.91 namespace _variant_bits { 5.92 - 5.93 + 5.94 template <int _idx, typename _TypeMap> 5.95 struct Memory { 5.96 5.97 @@ -276,14 +276,14 @@ 5.98 5.99 template <int _idx, typename _TypeMap> 5.100 struct Size { 5.101 - static const int value = 5.102 - CTMax<sizeof(typename _TypeMap::template Map<_idx>::Type), 5.103 + static const int value = 5.104 + CTMax<sizeof(typename _TypeMap::template Map<_idx>::Type), 5.105 Size<_idx - 1, _TypeMap>::value>::value; 5.106 }; 5.107 5.108 template <typename _TypeMap> 5.109 struct Size<0, _TypeMap> { 5.110 - static const int value = 5.111 + static const int value = 5.112 sizeof(typename _TypeMap::template Map<0>::Type); 5.113 }; 5.114 5.115 @@ -301,7 +301,7 @@ 5.116 /// \param _num The number of the types which can be stored in the 5.117 /// variant type. 5.118 /// \param _TypeMap This class describes the types of the Variant. The 5.119 - /// _TypeMap::Map<index>::Type should be a valid type for each index 5.120 + /// _TypeMap::Map<index>::Type should be a valid type for each index 5.121 /// in the range {0, 1, ..., _num - 1}. The \c VariantTypeMap is helper 5.122 /// class to define such type mappings up to 10 types. 5.123 /// 5.124 @@ -337,7 +337,7 @@ 5.125 /// with 0 index. 5.126 Variant() { 5.127 flag = 0; 5.128 - new(reinterpret_cast<typename TypeMap::template Map<0>::Type*>(data)) 5.129 + new(reinterpret_cast<typename TypeMap::template Map<0>::Type*>(data)) 5.130 typename TypeMap::template Map<0>::Type(); 5.131 } 5.132 5.133 @@ -378,7 +378,7 @@ 5.134 Variant& set() { 5.135 _variant_bits::Memory<num - 1, TypeMap>::destroy(flag, data); 5.136 flag = _idx; 5.137 - new(reinterpret_cast<typename TypeMap::template Map<_idx>::Type*>(data)) 5.138 + new(reinterpret_cast<typename TypeMap::template Map<_idx>::Type*>(data)) 5.139 typename TypeMap::template Map<_idx>::Type(); 5.140 return *this; 5.141 } 5.142 @@ -391,7 +391,7 @@ 5.143 Variant& set(const typename _TypeMap::template Map<_idx>::Type& init) { 5.144 _variant_bits::Memory<num - 1, TypeMap>::destroy(flag, data); 5.145 flag = _idx; 5.146 - new(reinterpret_cast<typename TypeMap::template Map<_idx>::Type*>(data)) 5.147 + new(reinterpret_cast<typename TypeMap::template Map<_idx>::Type*>(data)) 5.148 typename TypeMap::template Map<_idx>::Type(init); 5.149 return *this; 5.150 } 5.151 @@ -403,7 +403,7 @@ 5.152 const typename TypeMap::template Map<_idx>::Type& get() const { 5.153 LEMON_DEBUG(_idx == flag, "Variant wrong index"); 5.154 return *reinterpret_cast<const typename TypeMap:: 5.155 - template Map<_idx>::Type*>(data); 5.156 + template Map<_idx>::Type*>(data); 5.157 } 5.158 5.159 /// \brief Gets the current value of the type with \c _idx index. 5.160 @@ -413,7 +413,7 @@ 5.161 typename _TypeMap::template Map<_idx>::Type& get() { 5.162 LEMON_DEBUG(_idx == flag, "Variant wrong index"); 5.163 return *reinterpret_cast<typename TypeMap::template Map<_idx>::Type*> 5.164 - (data); 5.165 + (data); 5.166 } 5.167 5.168 /// \brief Returns the current state of the variant. 5.169 @@ -424,7 +424,7 @@ 5.170 } 5.171 5.172 private: 5.173 - 5.174 + 5.175 char data[_variant_bits::Size<num - 1, TypeMap>::value]; 5.176 int flag; 5.177 }; 5.178 @@ -442,14 +442,14 @@ 5.179 }; 5.180 5.181 struct List {}; 5.182 - 5.183 + 5.184 template <typename _Type, typename _List> 5.185 struct Insert { 5.186 typedef _List Next; 5.187 typedef _Type Type; 5.188 }; 5.189 5.190 - template <int _idx, typename _T0, typename _T1, typename _T2, 5.191 + template <int _idx, typename _T0, typename _T1, typename _T2, 5.192 typename _T3, typename _T5, typename _T4, typename _T6, 5.193 typename _T7, typename _T8, typename _T9> 5.194 struct Mapper { 5.195 @@ -466,7 +466,7 @@ 5.196 typedef Insert<_T0, L1> L0; 5.197 typedef typename Get<_idx, L0>::Type Type; 5.198 }; 5.199 - 5.200 + 5.201 } 5.202 5.203 /// \brief Helper class for Variant 5.204 @@ -475,7 +475,7 @@ 5.205 /// converts the template parameters to be mappable by integer. 5.206 /// \see Variant 5.207 template < 5.208 - typename _T0, 5.209 + typename _T0, 5.210 typename _T1 = void, typename _T2 = void, typename _T3 = void, 5.211 typename _T5 = void, typename _T4 = void, typename _T6 = void, 5.212 typename _T7 = void, typename _T8 = void, typename _T9 = void> 5.213 @@ -487,7 +487,7 @@ 5.214 Type; 5.215 }; 5.216 }; 5.217 - 5.218 + 5.219 } 5.220 5.221   6.1 --- a/lemon/digraph_adaptor.h Sun Nov 30 19:00:30 2008 +0100 6.2 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 6.3 @@ -1,2547 +0,0 @@ 6.4 -/* -*- C++ -*- 6.5 - * 6.6 - * This file is a part of LEMON, a generic C++ optimization library 6.7 - * 6.8 - * Copyright (C) 2003-2008 6.9 - * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport 6.10 - * (Egervary Research Group on Combinatorial Optimization, EGRES). 6.11 - * 6.12 - * Permission to use, modify and distribute this software is granted 6.13 - * provided that this copyright notice appears in all copies. For 6.14 - * precise terms see the accompanying LICENSE file. 6.15 - * 6.16 - * This software is provided "AS IS" with no warranty of any kind, 6.17 - * express or implied, and with no claim as to its suitability for any 6.18 - * purpose. 6.19 - * 6.20 - */ 6.21 - 6.22 -#ifndef LEMON_DIGRAPH_ADAPTOR_H 6.23 -#define LEMON_DIGRAPH_ADAPTOR_H 6.24 - 6.25 -///\ingroup graph_adaptors 6.26 -///\file 6.27 -///\brief Several digraph adaptors. 6.28 -/// 6.29 -///This file contains several useful digraph adaptor classes. 6.30 - 6.31 -#include <lemon/core.h> 6.32 -#include <lemon/maps.h> 6.33 -#include <lemon/bits/variant.h> 6.34 - 6.35 -#include <lemon/bits/base_extender.h> 6.36 -#include <lemon/bits/graph_adaptor_extender.h> 6.37 -#include <lemon/bits/graph_extender.h> 6.38 -#include <lemon/tolerance.h> 6.39 - 6.40 -#include <algorithm> 6.41 - 6.42 -namespace lemon { 6.43 - 6.44 - template<typename _Digraph> 6.45 - class DigraphAdaptorBase { 6.46 - public: 6.47 - typedef _Digraph Digraph; 6.48 - typedef DigraphAdaptorBase Adaptor; 6.49 - typedef Digraph ParentDigraph; 6.50 - 6.51 - protected: 6.52 - Digraph* _digraph; 6.53 - DigraphAdaptorBase() : _digraph(0) { } 6.54 - void setDigraph(Digraph& digraph) { _digraph = &digraph; } 6.55 - 6.56 - public: 6.57 - DigraphAdaptorBase(Digraph& digraph) : _digraph(&digraph) { } 6.58 - 6.59 - typedef typename Digraph::Node Node; 6.60 - typedef typename Digraph::Arc Arc; 6.61 - 6.62 - void first(Node& i) const { _digraph->first(i); } 6.63 - void first(Arc& i) const { _digraph->first(i); } 6.64 - void firstIn(Arc& i, const Node& n) const { _digraph->firstIn(i, n); } 6.65 - void firstOut(Arc& i, const Node& n ) const { _digraph->firstOut(i, n); } 6.66 - 6.67 - void next(Node& i) const { _digraph->next(i); } 6.68 - void next(Arc& i) const { _digraph->next(i); } 6.69 - void nextIn(Arc& i) const { _digraph->nextIn(i); } 6.70 - void nextOut(Arc& i) const { _digraph->nextOut(i); } 6.71 - 6.72 - Node source(const Arc& a) const { return _digraph->source(a); } 6.73 - Node target(const Arc& a) const { return _digraph->target(a); } 6.74 - 6.75 - typedef NodeNumTagIndicator<Digraph> NodeNumTag; 6.76 - int nodeNum() const { return _digraph->nodeNum(); } 6.77 - 6.78 - typedef EdgeNumTagIndicator<Digraph> EdgeNumTag; 6.79 - int arcNum() const { return _digraph->arcNum(); } 6.80 - 6.81 - typedef FindEdgeTagIndicator<Digraph> FindEdgeTag; 6.82 - Arc findArc(const Node& u, const Node& v, const Arc& prev = INVALID) { 6.83 - return _digraph->findArc(u, v, prev); 6.84 - } 6.85 - 6.86 - Node addNode() { return _digraph->addNode(); } 6.87 - Arc addArc(const Node& u, const Node& v) { return _digraph->addArc(u, v); } 6.88 - 6.89 - void erase(const Node& n) const { _digraph->erase(n); } 6.90 - void erase(const Arc& a) const { _digraph->erase(a); } 6.91 - 6.92 - void clear() const { _digraph->clear(); } 6.93 - 6.94 - int id(const Node& n) const { return _digraph->id(n); } 6.95 - int id(const Arc& a) const { return _digraph->id(a); } 6.96 - 6.97 - Node nodeFromId(int ix) const { return _digraph->nodeFromId(ix); } 6.98 - Arc arcFromId(int ix) const { return _digraph->arcFromId(ix); } 6.99 - 6.100 - int maxNodeId() const { return _digraph->maxNodeId(); } 6.101 - int maxArcId() const { return _digraph->maxArcId(); } 6.102 - 6.103 - typedef typename ItemSetTraits<Digraph, Node>::ItemNotifier NodeNotifier; 6.104 - NodeNotifier& notifier(Node) const { return _digraph->notifier(Node()); } 6.105 - 6.106 - typedef typename ItemSetTraits<Digraph, Arc>::ItemNotifier ArcNotifier; 6.107 - ArcNotifier& notifier(Arc) const { return _digraph->notifier(Arc()); } 6.108 - 6.109 - template <typename _Value> 6.110 - class NodeMap : public Digraph::template NodeMap<_Value> { 6.111 - public: 6.112 - 6.113 - typedef typename Digraph::template NodeMap<_Value> Parent; 6.114 - 6.115 - explicit NodeMap(const Adaptor& adaptor) 6.116 - : Parent(*adaptor._digraph) {} 6.117 - 6.118 - NodeMap(const Adaptor& adaptor, const _Value& value) 6.119 - : Parent(*adaptor._digraph, value) { } 6.120 - 6.121 - private: 6.122 - NodeMap& operator=(const NodeMap& cmap) { 6.123 - return operator=<NodeMap>(cmap); 6.124 - } 6.125 - 6.126 - template <typename CMap> 6.127 - NodeMap& operator=(const CMap& cmap) { 6.128 - Parent::operator=(cmap); 6.129 - return *this; 6.130 - } 6.131 - 6.132 - }; 6.133 - 6.134 - template <typename _Value> 6.135 - class ArcMap : public Digraph::template ArcMap<_Value> { 6.136 - public: 6.137 - 6.138 - typedef typename Digraph::template ArcMap<_Value> Parent; 6.139 - 6.140 - explicit ArcMap(const Adaptor& adaptor) 6.141 - : Parent(*adaptor._digraph) {} 6.142 - 6.143 - ArcMap(const Adaptor& adaptor, const _Value& value) 6.144 - : Parent(*adaptor._digraph, value) {} 6.145 - 6.146 - private: 6.147 - ArcMap& operator=(const ArcMap& cmap) { 6.148 - return operator=<ArcMap>(cmap); 6.149 - } 6.150 - 6.151 - template <typename CMap> 6.152 - ArcMap& operator=(const CMap& cmap) { 6.153 - Parent::operator=(cmap); 6.154 - return *this; 6.155 - } 6.156 - 6.157 - }; 6.158 - 6.159 - }; 6.160 - 6.161 - 6.162 - template <typename _Digraph> 6.163 - class RevDigraphAdaptorBase : public DigraphAdaptorBase<_Digraph> { 6.164 - public: 6.165 - typedef _Digraph Digraph; 6.166 - typedef DigraphAdaptorBase<_Digraph> Parent; 6.167 - protected: 6.168 - RevDigraphAdaptorBase() : Parent() { } 6.169 - public: 6.170 - typedef typename Parent::Node Node; 6.171 - typedef typename Parent::Arc Arc; 6.172 - 6.173 - void firstIn(Arc& a, const Node& n) const { Parent::firstOut(a, n); } 6.174 - void firstOut(Arc& a, const Node& n ) const { Parent::firstIn(a, n); } 6.175 - 6.176 - void nextIn(Arc& a) const { Parent::nextOut(a); } 6.177 - void nextOut(Arc& a) const { Parent::nextIn(a); } 6.178 - 6.179 - Node source(const Arc& a) const { return Parent::target(a); } 6.180 - Node target(const Arc& a) const { return Parent::source(a); } 6.181 - 6.182 - typedef FindEdgeTagIndicator<Digraph> FindEdgeTag; 6.183 - Arc findArc(const Node& u, const Node& v, 6.184 - const Arc& prev = INVALID) { 6.185 - return Parent::findArc(v, u, prev); 6.186 - } 6.187 - 6.188 - }; 6.189 - 6.190 - 6.191 - ///\ingroup graph_adaptors 6.192 - /// 6.193 - ///\brief A digraph adaptor which reverses the orientation of the arcs. 6.194 - /// 6.195 - /// If \c g is defined as 6.196 - ///\code 6.197 - /// ListDigraph dg; 6.198 - ///\endcode 6.199 - /// then 6.200 - ///\code 6.201 - /// RevDigraphAdaptor<ListDigraph> dga(dg); 6.202 - ///\endcode 6.203 - /// implements the digraph obtained from \c dg by 6.204 - /// reversing the orientation of its arcs. 6.205 - /// 6.206 - /// A good example of using RevDigraphAdaptor is to decide whether 6.207 - /// the directed graph is strongly connected or not. The digraph is 6.208 - /// strongly connected iff each node is reachable from one node and 6.209 - /// this node is reachable from the others. Instead of this 6.210 - /// condition we use a slightly different, from one node each node 6.211 - /// is reachable both in the digraph and the reversed digraph. Now 6.212 - /// this condition can be checked with the Dfs algorithm and the 6.213 - /// RevDigraphAdaptor class. 6.214 - /// 6.215 - /// The implementation: 6.216 - ///\code 6.217 - /// bool stronglyConnected(const Digraph& digraph) { 6.218 - /// if (NodeIt(digraph) == INVALID) return true; 6.219 - /// Dfs<Digraph> dfs(digraph); 6.220 - /// dfs.run(NodeIt(digraph)); 6.221 - /// for (NodeIt it(digraph); it != INVALID; ++it) { 6.222 - /// if (!dfs.reached(it)) { 6.223 - /// return false; 6.224 - /// } 6.225 - /// } 6.226 - /// typedef RevDigraphAdaptor<const Digraph> RDigraph; 6.227 - /// RDigraph rdigraph(digraph); 6.228 - /// DfsVisit<RDigraph> rdfs(rdigraph); 6.229 - /// rdfs.run(NodeIt(digraph)); 6.230 - /// for (NodeIt it(digraph); it != INVALID; ++it) { 6.231 - /// if (!rdfs.reached(it)) { 6.232 - /// return false; 6.233 - /// } 6.234 - /// } 6.235 - /// return true; 6.236 - /// } 6.237 - ///\endcode 6.238 - template<typename _Digraph> 6.239 - class RevDigraphAdaptor : 6.240 - public DigraphAdaptorExtender<RevDigraphAdaptorBase<_Digraph> > { 6.241 - public: 6.242 - typedef _Digraph Digraph; 6.243 - typedef DigraphAdaptorExtender< 6.244 - RevDigraphAdaptorBase<_Digraph> > Parent; 6.245 - protected: 6.246 - RevDigraphAdaptor() { } 6.247 - public: 6.248 - 6.249 - /// \brief Constructor 6.250 - /// 6.251 - /// Creates a reverse graph adaptor for the given digraph 6.252 - explicit RevDigraphAdaptor(Digraph& digraph) { 6.253 - Parent::setDigraph(digraph); 6.254 - } 6.255 - }; 6.256 - 6.257 - /// \brief Just gives back a reverse digraph adaptor 6.258 - /// 6.259 - /// Just gives back a reverse digraph adaptor 6.260 - template<typename Digraph> 6.261 - RevDigraphAdaptor<const Digraph> 6.262 - revDigraphAdaptor(const Digraph& digraph) { 6.263 - return RevDigraphAdaptor<const Digraph>(digraph); 6.264 - } 6.265 - 6.266 - template <typename _Digraph, typename _NodeFilterMap, 6.267 - typename _ArcFilterMap, bool checked = true> 6.268 - class SubDigraphAdaptorBase : public DigraphAdaptorBase<_Digraph> { 6.269 - public: 6.270 - typedef _Digraph Digraph; 6.271 - typedef _NodeFilterMap NodeFilterMap; 6.272 - typedef _ArcFilterMap ArcFilterMap; 6.273 - 6.274 - typedef SubDigraphAdaptorBase Adaptor; 6.275 - typedef DigraphAdaptorBase<_Digraph> Parent; 6.276 - protected: 6.277 - NodeFilterMap* _node_filter; 6.278 - ArcFilterMap* _arc_filter; 6.279 - SubDigraphAdaptorBase() 6.280 - : Parent(), _node_filter(0), _arc_filter(0) { } 6.281 - 6.282 - void setNodeFilterMap(NodeFilterMap& node_filter) { 6.283 - _node_filter = &node_filter; 6.284 - } 6.285 - void setArcFilterMap(ArcFilterMap& arc_filter) { 6.286 - _arc_filter = &arc_filter; 6.287 - } 6.288 - 6.289 - public: 6.290 - 6.291 - typedef typename Parent::Node Node; 6.292 - typedef typename Parent::Arc Arc; 6.293 - 6.294 - void first(Node& i) const { 6.295 - Parent::first(i); 6.296 - while (i != INVALID && !(*_node_filter)[i]) Parent::next(i); 6.297 - } 6.298 - 6.299 - void first(Arc& i) const { 6.300 - Parent::first(i); 6.301 - while (i != INVALID && (!(*_arc_filter)[i] 6.302 - || !(*_node_filter)[Parent::source(i)] 6.303 - || !(*_node_filter)[Parent::target(i)])) Parent::next(i); 6.304 - } 6.305 - 6.306 - void firstIn(Arc& i, const Node& n) const { 6.307 - Parent::firstIn(i, n); 6.308 - while (i != INVALID && (!(*_arc_filter)[i] 6.309 - || !(*_node_filter)[Parent::source(i)])) Parent::nextIn(i); 6.310 - } 6.311 - 6.312 - void firstOut(Arc& i, const Node& n) const { 6.313 - Parent::firstOut(i, n); 6.314 - while (i != INVALID && (!(*_arc_filter)[i] 6.315 - || !(*_node_filter)[Parent::target(i)])) Parent::nextOut(i); 6.316 - } 6.317 - 6.318 - void next(Node& i) const { 6.319 - Parent::next(i); 6.320 - while (i != INVALID && !(*_node_filter)[i]) Parent::next(i); 6.321 - } 6.322 - 6.323 - void next(Arc& i) const { 6.324 - Parent::next(i); 6.325 - while (i != INVALID && (!(*_arc_filter)[i] 6.326 - || !(*_node_filter)[Parent::source(i)] 6.327 - || !(*_node_filter)[Parent::target(i)])) Parent::next(i); 6.328 - } 6.329 - 6.330 - void nextIn(Arc& i) const { 6.331 - Parent::nextIn(i); 6.332 - while (i != INVALID && (!(*_arc_filter)[i] 6.333 - || !(*_node_filter)[Parent::source(i)])) Parent::nextIn(i); 6.334 - } 6.335 - 6.336 - void nextOut(Arc& i) const { 6.337 - Parent::nextOut(i); 6.338 - while (i != INVALID && (!(*_arc_filter)[i] 6.339 - || !(*_node_filter)[Parent::target(i)])) Parent::nextOut(i); 6.340 - } 6.341 - 6.342 - void hide(const Node& n) const { _node_filter->set(n, false); } 6.343 - void hide(const Arc& a) const { _arc_filter->set(a, false); } 6.344 - 6.345 - void unHide(const Node& n) const { _node_filter->set(n, true); } 6.346 - void unHide(const Arc& a) const { _arc_filter->set(a, true); } 6.347 - 6.348 - bool hidden(const Node& n) const { return !(*_node_filter)[n]; } 6.349 - bool hidden(const Arc& a) const { return !(*_arc_filter)[a]; } 6.350 - 6.351 - typedef False NodeNumTag; 6.352 - typedef False EdgeNumTag; 6.353 - 6.354 - typedef FindEdgeTagIndicator<Digraph> FindEdgeTag; 6.355 - Arc findArc(const Node& source, const Node& target, 6.356 - const Arc& prev = INVALID) { 6.357 - if (!(*_node_filter)[source] || !(*_node_filter)[target]) { 6.358 - return INVALID; 6.359 - } 6.360 - Arc arc = Parent::findArc(source, target, prev); 6.361 - while (arc != INVALID && !(*_arc_filter)[arc]) { 6.362 - arc = Parent::findArc(source, target, arc); 6.363 - } 6.364 - return arc; 6.365 - } 6.366 - 6.367 - template <typename _Value> 6.368 - class NodeMap : public SubMapExtender<Adaptor, 6.369 - typename Parent::template NodeMap<_Value> > { 6.370 - public: 6.371 - typedef _Value Value; 6.372 - typedef SubMapExtender<Adaptor, typename Parent:: 6.373 - template NodeMap<Value> > MapParent; 6.374 - 6.375 - NodeMap(const Adaptor& adaptor) 6.376 - : MapParent(adaptor) {} 6.377 - NodeMap(const Adaptor& adaptor, const Value& value) 6.378 - : MapParent(adaptor, value) {} 6.379 - 6.380 - private: 6.381 - NodeMap& operator=(const NodeMap& cmap) { 6.382 - return operator=<NodeMap>(cmap); 6.383 - } 6.384 - 6.385 - template <typename CMap> 6.386 - NodeMap& operator=(const CMap& cmap) { 6.387 - MapParent::operator=(cmap); 6.388 - return *this; 6.389 - } 6.390 - }; 6.391 - 6.392 - template <typename _Value> 6.393 - class ArcMap : public SubMapExtender<Adaptor, 6.394 - typename Parent::template ArcMap<_Value> > { 6.395 - public: 6.396 - typedef _Value Value; 6.397 - typedef SubMapExtender<Adaptor, typename Parent:: 6.398 - template ArcMap<Value> > MapParent; 6.399 - 6.400 - ArcMap(const Adaptor& adaptor) 6.401 - : MapParent(adaptor) {} 6.402 - ArcMap(const Adaptor& adaptor, const Value& value) 6.403 - : MapParent(adaptor, value) {} 6.404 - 6.405 - private: 6.406 - ArcMap& operator=(const ArcMap& cmap) { 6.407 - return operator=<ArcMap>(cmap); 6.408 - } 6.409 - 6.410 - template <typename CMap> 6.411 - ArcMap& operator=(const CMap& cmap) { 6.412 - MapParent::operator=(cmap); 6.413 - return *this; 6.414 - } 6.415 - }; 6.416 - 6.417 - }; 6.418 - 6.419 - template <typename _Digraph, typename _NodeFilterMap, typename _ArcFilterMap> 6.420 - class SubDigraphAdaptorBase<_Digraph, _NodeFilterMap, _ArcFilterMap, false> 6.421 - : public DigraphAdaptorBase<_Digraph> { 6.422 - public: 6.423 - typedef _Digraph Digraph; 6.424 - typedef _NodeFilterMap NodeFilterMap; 6.425 - typedef _ArcFilterMap ArcFilterMap; 6.426 - 6.427 - typedef SubDigraphAdaptorBase Adaptor; 6.428 - typedef DigraphAdaptorBase<Digraph> Parent; 6.429 - protected: 6.430 - NodeFilterMap* _node_filter; 6.431 - ArcFilterMap* _arc_filter; 6.432 - SubDigraphAdaptorBase() 6.433 - : Parent(), _node_filter(0), _arc_filter(0) { } 6.434 - 6.435 - void setNodeFilterMap(NodeFilterMap& node_filter) { 6.436 - _node_filter = &node_filter; 6.437 - } 6.438 - void setArcFilterMap(ArcFilterMap& arc_filter) { 6.439 - _arc_filter = &arc_filter; 6.440 - } 6.441 - 6.442 - public: 6.443 - 6.444 - typedef typename Parent::Node Node; 6.445 - typedef typename Parent::Arc Arc; 6.446 - 6.447 - void first(Node& i) const { 6.448 - Parent::first(i); 6.449 - while (i!=INVALID && !(*_node_filter)[i]) Parent::next(i); 6.450 - } 6.451 - 6.452 - void first(Arc& i) const { 6.453 - Parent::first(i); 6.454 - while (i!=INVALID && !(*_arc_filter)[i]) Parent::next(i); 6.455 - } 6.456 - 6.457 - void firstIn(Arc& i, const Node& n) const { 6.458 - Parent::firstIn(i, n); 6.459 - while (i!=INVALID && !(*_arc_filter)[i]) Parent::nextIn(i); 6.460 - } 6.461 - 6.462 - void firstOut(Arc& i, const Node& n) const { 6.463 - Parent::firstOut(i, n); 6.464 - while (i!=INVALID && !(*_arc_filter)[i]) Parent::nextOut(i); 6.465 - } 6.466 - 6.467 - void next(Node& i) const { 6.468 - Parent::next(i); 6.469 - while (i!=INVALID && !(*_node_filter)[i]) Parent::next(i); 6.470 - } 6.471 - void next(Arc& i) const { 6.472 - Parent::next(i); 6.473 - while (i!=INVALID && !(*_arc_filter)[i]) Parent::next(i); 6.474 - } 6.475 - void nextIn(Arc& i) const { 6.476 - Parent::nextIn(i); 6.477 - while (i!=INVALID && !(*_arc_filter)[i]) Parent::nextIn(i); 6.478 - } 6.479 - 6.480 - void nextOut(Arc& i) const { 6.481 - Parent::nextOut(i); 6.482 - while (i!=INVALID && !(*_arc_filter)[i]) Parent::nextOut(i); 6.483 - } 6.484 - 6.485 - void hide(const Node& n) const { _node_filter->set(n, false); } 6.486 - void hide(const Arc& e) const { _arc_filter->set(e, false); } 6.487 - 6.488 - void unHide(const Node& n) const { _node_filter->set(n, true); } 6.489 - void unHide(const Arc& e) const { _arc_filter->set(e, true); } 6.490 - 6.491 - bool hidden(const Node& n) const { return !(*_node_filter)[n]; } 6.492 - bool hidden(const Arc& e) const { return !(*_arc_filter)[e]; } 6.493 - 6.494 - typedef False NodeNumTag; 6.495 - typedef False EdgeNumTag; 6.496 - 6.497 - typedef FindEdgeTagIndicator<Digraph> FindEdgeTag; 6.498 - Arc findArc(const Node& source, const Node& target, 6.499 - const Arc& prev = INVALID) { 6.500 - if (!(*_node_filter)[source] || !(*_node_filter)[target]) { 6.501 - return INVALID; 6.502 - } 6.503 - Arc arc = Parent::findArc(source, target, prev); 6.504 - while (arc != INVALID && !(*_arc_filter)[arc]) { 6.505 - arc = Parent::findArc(source, target, arc); 6.506 - } 6.507 - return arc; 6.508 - } 6.509 - 6.510 - template <typename _Value> 6.511 - class NodeMap : public SubMapExtender<Adaptor, 6.512 - typename Parent::template NodeMap<_Value> > { 6.513 - public: 6.514 - typedef _Value Value; 6.515 - typedef SubMapExtender<Adaptor, typename Parent:: 6.516 - template NodeMap<Value> > MapParent; 6.517 - 6.518 - NodeMap(const Adaptor& adaptor) 6.519 - : MapParent(adaptor) {} 6.520 - NodeMap(const Adaptor& adaptor, const Value& value) 6.521 - : MapParent(adaptor, value) {} 6.522 - 6.523 - private: 6.524 - NodeMap& operator=(const NodeMap& cmap) { 6.525 - return operator=<NodeMap>(cmap); 6.526 - } 6.527 - 6.528 - template <typename CMap> 6.529 - NodeMap& operator=(const CMap& cmap) { 6.530 - MapParent::operator=(cmap); 6.531 - return *this; 6.532 - } 6.533 - }; 6.534 - 6.535 - template <typename _Value> 6.536 - class ArcMap : public SubMapExtender<Adaptor, 6.537 - typename Parent::template ArcMap<_Value> > { 6.538 - public: 6.539 - typedef _Value Value; 6.540 - typedef SubMapExtender<Adaptor, typename Parent:: 6.541 - template ArcMap<Value> > MapParent; 6.542 - 6.543 - ArcMap(const Adaptor& adaptor) 6.544 - : MapParent(adaptor) {} 6.545 - ArcMap(const Adaptor& adaptor, const Value& value) 6.546 - : MapParent(adaptor, value) {} 6.547 - 6.548 - private: 6.549 - ArcMap& operator=(const ArcMap& cmap) { 6.550 - return operator=<ArcMap>(cmap); 6.551 - } 6.552 - 6.553 - template <typename CMap> 6.554 - ArcMap& operator=(const CMap& cmap) { 6.555 - MapParent::operator=(cmap); 6.556 - return *this; 6.557 - } 6.558 - }; 6.559 - 6.560 - }; 6.561 - 6.562 - /// \ingroup graph_adaptors 6.563 - /// 6.564 - /// \brief A digraph adaptor for hiding nodes and arcs from a digraph. 6.565 - /// 6.566 - /// SubDigraphAdaptor shows the digraph with filtered node-set and 6.567 - /// arc-set. If the \c checked parameter is true then it filters the arc-set 6.568 - /// respect to the source and target. 6.569 - /// 6.570 - /// If the \c checked template parameter is false then the 6.571 - /// node-iterator cares only the filter on the node-set, and the 6.572 - /// arc-iterator cares only the filter on the arc-set. Therefore 6.573 - /// the arc-map have to filter all arcs which's source or target is 6.574 - /// filtered by the node-filter. 6.575 - ///\code 6.576 - /// typedef ListDigraph Digraph; 6.577 - /// DIGRAPH_TYPEDEFS(Digraph); 6.578 - /// Digraph g; 6.579 - /// Node u=g.addNode(); //node of id 0 6.580 - /// Node v=g.addNode(); //node of id 1 6.581 - /// Arc a=g.addArc(u, v); //arc of id 0 6.582 - /// Arc f=g.addArc(v, u); //arc of id 1 6.583 - /// BoolNodeMap nm(g, true); 6.584 - /// nm.set(u, false); 6.585 - /// BoolArcMap am(g, true); 6.586 - /// am.set(a, false); 6.587 - /// typedef SubDigraphAdaptor<Digraph, BoolNodeMap, BoolArcMap> SubDGA; 6.588 - /// SubDGA ga(g, nm, am); 6.589 - /// for (SubDGA::NodeIt n(ga); n!=INVALID; ++n) 6.590 - /// std::cout << g.id(n) << std::endl; 6.591 - /// for (SubDGA::ArcIt a(ga); a!=INVALID; ++a) 6.592 - /// std::cout << g.id(a) << std::endl; 6.593 - ///\endcode 6.594 - /// The output of the above code is the following. 6.595 - ///\code 6.596 - /// 1 6.597 - /// 1 6.598 - ///\endcode 6.599 - /// Note that \c n is of type \c SubDGA::NodeIt, but it can be converted to 6.600 - /// \c Digraph::Node that is why \c g.id(n) can be applied. 6.601 - /// 6.602 - /// For other examples see also the documentation of 6.603 - /// NodeSubDigraphAdaptor and ArcSubDigraphAdaptor. 6.604 - template<typename _Digraph, 6.605 - typename _NodeFilterMap = typename _Digraph::template NodeMap<bool>, 6.606 - typename _ArcFilterMap = typename _Digraph::template ArcMap<bool>, 6.607 - bool checked = true> 6.608 - class SubDigraphAdaptor : 6.609 - public DigraphAdaptorExtender< 6.610 - SubDigraphAdaptorBase<_Digraph, _NodeFilterMap, _ArcFilterMap, checked> > { 6.611 - public: 6.612 - typedef _Digraph Digraph; 6.613 - typedef _NodeFilterMap NodeFilterMap; 6.614 - typedef _ArcFilterMap ArcFilterMap; 6.615 - 6.616 - typedef DigraphAdaptorExtender< 6.617 - SubDigraphAdaptorBase<Digraph, NodeFilterMap, ArcFilterMap, checked> > 6.618 - Parent; 6.619 - 6.620 - typedef typename Parent::Node Node; 6.621 - typedef typename Parent::Arc Arc; 6.622 - 6.623 - protected: 6.624 - SubDigraphAdaptor() { } 6.625 - public: 6.626 - 6.627 - /// \brief Constructor 6.628 - /// 6.629 - /// Creates a sub-digraph-adaptor for the given digraph with 6.630 - /// given node and arc map filters. 6.631 - SubDigraphAdaptor(Digraph& digraph, NodeFilterMap& node_filter, 6.632 - ArcFilterMap& arc_filter) { 6.633 - setDigraph(digraph); 6.634 - setNodeFilterMap(node_filter); 6.635 - setArcFilterMap(arc_filter); 6.636 - } 6.637 - 6.638 - /// \brief Hides the node of the graph 6.639 - /// 6.640 - /// This function hides \c n in the digraph, i.e. the iteration 6.641 - /// jumps over it. This is done by simply setting the value of \c n 6.642 - /// to be false in the corresponding node-map. 6.643 - void hide(const Node& n) const { Parent::hide(n); } 6.644 - 6.645 - /// \brief Hides the arc of the graph 6.646 - /// 6.647 - /// This function hides \c a in the digraph, i.e. the iteration 6.648 - /// jumps over it. This is done by simply setting the value of \c a 6.649 - /// to be false in the corresponding arc-map. 6.650 - void hide(const Arc& a) const { Parent::hide(a); } 6.651 - 6.652 - /// \brief Unhides the node of the graph 6.653 - /// 6.654 - /// The value of \c n is set to be true in the node-map which stores 6.655 - /// hide information. If \c n was hidden previuosly, then it is shown 6.656 - /// again 6.657 - void unHide(const Node& n) const { Parent::unHide(n); } 6.658 - 6.659 - /// \brief Unhides the arc of the graph 6.660 - /// 6.661 - /// The value of \c a is set to be true in the arc-map which stores 6.662 - /// hide information. If \c a was hidden previuosly, then it is shown 6.663 - /// again 6.664 - void unHide(const Arc& a) const { Parent::unHide(a); } 6.665 - 6.666 - /// \brief Returns true if \c n is hidden. 6.667 - /// 6.668 - /// Returns true if \c n is hidden. 6.669 - /// 6.670 - bool hidden(const Node& n) const { return Parent::hidden(n); } 6.671 - 6.672 - /// \brief Returns true if \c a is hidden. 6.673 - /// 6.674 - /// Returns true if \c a is hidden. 6.675 - /// 6.676 - bool hidden(const Arc& a) const { return Parent::hidden(a); } 6.677 - 6.678 - }; 6.679 - 6.680 - /// \brief Just gives back a sub-digraph-adaptor 6.681 - /// 6.682 - /// Just gives back a sub-digraph-adaptor 6.683 - template<typename Digraph, typename NodeFilterMap, typename ArcFilterMap> 6.684 - SubDigraphAdaptor<const Digraph, NodeFilterMap, ArcFilterMap> 6.685 - subDigraphAdaptor(const Digraph& digraph, 6.686 - NodeFilterMap& nfm, ArcFilterMap& afm) { 6.687 - return SubDigraphAdaptor<const Digraph, NodeFilterMap, ArcFilterMap> 6.688 - (digraph, nfm, afm); 6.689 - } 6.690 - 6.691 - template<typename Digraph, typename NodeFilterMap, typename ArcFilterMap> 6.692 - SubDigraphAdaptor<const Digraph, const NodeFilterMap, ArcFilterMap> 6.693 - subDigraphAdaptor(const Digraph& digraph, 6.694 - NodeFilterMap& nfm, ArcFilterMap& afm) { 6.695 - return SubDigraphAdaptor<const Digraph, const NodeFilterMap, ArcFilterMap> 6.696 - (digraph, nfm, afm); 6.697 - } 6.698 - 6.699 - template<typename Digraph, typename NodeFilterMap, typename ArcFilterMap> 6.700 - SubDigraphAdaptor<const Digraph, NodeFilterMap, const ArcFilterMap> 6.701 - subDigraphAdaptor(const Digraph& digraph, 6.702 - NodeFilterMap& nfm, ArcFilterMap& afm) { 6.703 - return SubDigraphAdaptor<const Digraph, NodeFilterMap, const ArcFilterMap> 6.704 - (digraph, nfm, afm); 6.705 - } 6.706 - 6.707 - template<typename Digraph, typename NodeFilterMap, typename ArcFilterMap> 6.708 - SubDigraphAdaptor<const Digraph, const NodeFilterMap, const ArcFilterMap> 6.709 - subDigraphAdaptor(const Digraph& digraph, 6.710 - NodeFilterMap& nfm, ArcFilterMap& afm) { 6.711 - return SubDigraphAdaptor<const Digraph, const NodeFilterMap, 6.712 - const ArcFilterMap>(digraph, nfm, afm); 6.713 - 6.714 - } 6.715 - 6.716 - 6.717 - 6.718 - ///\ingroup graph_adaptors 6.719 - /// 6.720 - ///\brief An adaptor for hiding nodes from a digraph. 6.721 - /// 6.722 - ///An adaptor for hiding nodes from a digraph. This adaptor 6.723 - ///specializes SubDigraphAdaptor in the way that only the node-set 6.724 - ///can be filtered. In usual case the checked parameter is true, we 6.725 - ///get the induced subgraph. But if the checked parameter is false 6.726 - ///then we can filter only isolated nodes. 6.727 - template<typename _Digraph, 6.728 - typename _NodeFilterMap = typename _Digraph::template NodeMap<bool>, 6.729 - bool checked = true> 6.730 - class NodeSubDigraphAdaptor : 6.731 - public SubDigraphAdaptor<_Digraph, _NodeFilterMap, 6.732 - ConstMap<typename _Digraph::Arc, bool>, checked> { 6.733 - public: 6.734 - 6.735 - typedef _Digraph Digraph; 6.736 - typedef _NodeFilterMap NodeFilterMap; 6.737 - 6.738 - typedef SubDigraphAdaptor<Digraph, NodeFilterMap, 6.739 - ConstMap<typename Digraph::Arc, bool>, checked> 6.740 - Parent; 6.741 - 6.742 - typedef typename Parent::Node Node; 6.743 - 6.744 - protected: 6.745 - ConstMap<typename Digraph::Arc, bool> const_true_map; 6.746 - 6.747 - NodeSubDigraphAdaptor() : const_true_map(true) { 6.748 - Parent::setArcFilterMap(const_true_map); 6.749 - } 6.750 - 6.751 - public: 6.752 - 6.753 - /// \brief Constructor 6.754 - /// 6.755 - /// Creates a node-sub-digraph-adaptor for the given digraph with 6.756 - /// given node map filter. 6.757 - NodeSubDigraphAdaptor(Digraph& _digraph, NodeFilterMap& node_filter) : 6.758 - Parent(), const_true_map(true) { 6.759 - Parent::setDigraph(_digraph); 6.760 - Parent::setNodeFilterMap(node_filter); 6.761 - Parent::setArcFilterMap(const_true_map); 6.762 - } 6.763 - 6.764 - /// \brief Hides the node of the graph 6.765 - /// 6.766 - /// This function hides \c n in the digraph, i.e. the iteration 6.767 - /// jumps over it. This is done by simply setting the value of \c n 6.768 - /// to be false in the corresponding node-map. 6.769 - void hide(const Node& n) const { Parent::hide(n); } 6.770 - 6.771 - /// \brief Unhides the node of the graph 6.772 - /// 6.773 - /// The value of \c n is set to be true in the node-map which stores 6.774 - /// hide information. If \c n was hidden previuosly, then it is shown 6.775 - /// again 6.776 - void unHide(const Node& n) const { Parent::unHide(n); } 6.777 - 6.778 - /// \brief Returns true if \c n is hidden. 6.779 - /// 6.780 - /// Returns true if \c n is hidden. 6.781 - /// 6.782 - bool hidden(const Node& n) const { return Parent::hidden(n); } 6.783 - 6.784 - }; 6.785 - 6.786 - 6.787 - /// \brief Just gives back a node-sub-digraph adaptor 6.788 - /// 6.789 - /// Just gives back a node-sub-digraph adaptor 6.790 - template<typename Digraph, typename NodeFilterMap> 6.791 - NodeSubDigraphAdaptor<const Digraph, NodeFilterMap> 6.792 - nodeSubDigraphAdaptor(const Digraph& digraph, NodeFilterMap& nfm) { 6.793 - return NodeSubDigraphAdaptor<const Digraph, NodeFilterMap>(digraph, nfm); 6.794 - } 6.795 - 6.796 - template<typename Digraph, typename NodeFilterMap> 6.797 - NodeSubDigraphAdaptor<const Digraph, const NodeFilterMap> 6.798 - nodeSubDigraphAdaptor(const Digraph& digraph, const NodeFilterMap& nfm) { 6.799 - return NodeSubDigraphAdaptor<const Digraph, const NodeFilterMap> 6.800 - (digraph, nfm); 6.801 - } 6.802 - 6.803 - ///\ingroup graph_adaptors 6.804 - /// 6.805 - ///\brief An adaptor for hiding arcs from a digraph. 6.806 - /// 6.807 - ///An adaptor for hiding arcs from a digraph. This adaptor 6.808 - ///specializes SubDigraphAdaptor in the way that only the arc-set 6.809 - ///can be filtered. The usefulness of this adaptor is demonstrated 6.810 - ///in the problem of searching a maximum number of arc-disjoint 6.811 - ///shortest paths between two nodes \c s and \c t. Shortest here 6.812 - ///means being shortest with respect to non-negative 6.813 - ///arc-lengths. Note that the comprehension of the presented 6.814 - ///solution need's some elementary knowledge from combinatorial 6.815 - ///optimization. 6.816 - /// 6.817 - ///If a single shortest path is to be searched between \c s and \c 6.818 - ///t, then this can be done easily by applying the Dijkstra 6.819 - ///algorithm. What happens, if a maximum number of arc-disjoint 6.820 - ///shortest paths is to be computed. It can be proved that an arc 6.821 - ///can be in a shortest path if and only if it is tight with respect 6.822 - ///to the potential function computed by Dijkstra. Moreover, any 6.823 - ///path containing only such arcs is a shortest one. Thus we have 6.824 - ///to compute a maximum number of arc-disjoint paths between \c s 6.825 - ///and \c t in the digraph which has arc-set all the tight arcs. The 6.826 - ///computation will be demonstrated on the following digraph, which 6.827 - ///is read from the dimacs file \c sub_digraph_adaptor_demo.dim. 6.828 - ///The full source code is available in \ref 6.829 - ///sub_digraph_adaptor_demo.cc. If you are interested in more demo 6.830 - ///programs, you can use \ref dim_to_dot.cc to generate .dot files 6.831 - ///from dimacs files. The .dot file of the following figure was 6.832 - ///generated by the demo program \ref dim_to_dot.cc. 6.833 - /// 6.834 - ///\dot 6.835 - ///digraph lemon_dot_example { 6.836 - ///node [ shape=ellipse, fontname=Helvetica, fontsize=10 ]; 6.837 - ///n0 [ label="0 (s)" ]; 6.838 - ///n1 [ label="1" ]; 6.839 - ///n2 [ label="2" ]; 6.840 - ///n3 [ label="3" ]; 6.841 - ///n4 [ label="4" ]; 6.842 - ///n5 [ label="5" ]; 6.843 - ///n6 [ label="6 (t)" ]; 6.844 - ///arc [ shape=ellipse, fontname=Helvetica, fontsize=10 ]; 6.845 - ///n5 -> n6 [ label="9, length:4" ]; 6.846 - ///n4 -> n6 [ label="8, length:2" ]; 6.847 - ///n3 -> n5 [ label="7, length:1" ]; 6.848 - ///n2 -> n5 [ label="6, length:3" ]; 6.849 - ///n2 -> n6 [ label="5, length:5" ]; 6.850 - ///n2 -> n4 [ label="4, length:2" ]; 6.851 - ///n1 -> n4 [ label="3, length:3" ]; 6.852 - ///n0 -> n3 [ label="2, length:1" ]; 6.853 - ///n0 -> n2 [ label="1, length:2" ]; 6.854 - ///n0 -> n1 [ label="0, length:3" ]; 6.855 - ///} 6.856 - ///\enddot 6.857 - /// 6.858 - ///\code 6.859 - ///Digraph g; 6.860 - ///Node s, t; 6.861 - ///LengthMap length(g); 6.862 - /// 6.863 - ///readDimacs(std::cin, g, length, s, t); 6.864 - /// 6.865 - ///cout << "arcs with lengths (of form id, source--length->target): " << endl; 6.866 - ///for(ArcIt e(g); e!=INVALID; ++e) 6.867 - /// cout << g.id(e) << ", " << g.id(g.source(e)) << "--" 6.868 - /// << length[e] << "->" << g.id(g.target(e)) << endl; 6.869 - /// 6.870 - ///cout << "s: " << g.id(s) << " t: " << g.id(t) << endl; 6.871 - ///\endcode 6.872 - ///Next, the potential function is computed with Dijkstra. 6.873 - ///\code 6.874 - ///typedef Dijkstra<Digraph, LengthMap> Dijkstra; 6.875 - ///Dijkstra dijkstra(g, length); 6.876 - ///dijkstra.run(s); 6.877 - ///\endcode 6.878 - ///Next, we consrtruct a map which filters the arc-set to the tight arcs. 6.879 - ///\code 6.880 - ///typedef TightArcFilterMap<Digraph, const Dijkstra::DistMap, LengthMap> 6.881 - /// TightArcFilter; 6.882 - ///TightArcFilter tight_arc_filter(g, dijkstra.distMap(), length); 6.883 - /// 6.884 - ///typedef ArcSubDigraphAdaptor<Digraph, TightArcFilter> SubGA; 6.885 - ///SubGA ga(g, tight_arc_filter); 6.886 - ///\endcode 6.887 - ///Then, the maximum nimber of arc-disjoint \c s-\c t paths are computed 6.888 - ///with a max flow algorithm Preflow. 6.889 - ///\code 6.890 - ///ConstMap<Arc, int> const_1_map(1); 6.891 - ///Digraph::ArcMap<int> flow(g, 0); 6.892 - /// 6.893 - ///Preflow<SubGA, ConstMap<Arc, int>, Digraph::ArcMap<int> > 6.894 - /// preflow(ga, const_1_map, s, t); 6.895 - ///preflow.run(); 6.896 - ///\endcode 6.897 - ///Last, the output is: 6.898 - ///\code 6.899 - ///cout << "maximum number of arc-disjoint shortest path: " 6.900 - /// << preflow.flowValue() << endl; 6.901 - ///cout << "arcs of the maximum number of arc-disjoint shortest s-t paths: " 6.902 - /// << endl; 6.903 - ///for(ArcIt e(g); e!=INVALID; ++e) 6.904 - /// if (preflow.flow(e)) 6.905 - /// cout << " " << g.id(g.source(e)) << "--" 6.906 - /// << length[e] << "->" << g.id(g.target(e)) << endl; 6.907 - ///\endcode 6.908 - ///The program has the following (expected :-)) output: 6.909 - ///\code 6.910 - ///arcs with lengths (of form id, source--length->target): 6.911 - /// 9, 5--4->6 6.912 - /// 8, 4--2->6 6.913 - /// 7, 3--1->5 6.914 - /// 6, 2--3->5 6.915 - /// 5, 2--5->6 6.916 - /// 4, 2--2->4 6.917 - /// 3, 1--3->4 6.918 - /// 2, 0--1->3 6.919 - /// 1, 0--2->2 6.920 - /// 0, 0--3->1 6.921 - ///s: 0 t: 6 6.922 - ///maximum number of arc-disjoint shortest path: 2 6.923 - ///arcs of the maximum number of arc-disjoint shortest s-t paths: 6.924 - /// 9, 5--4->6 6.925 - /// 8, 4--2->6 6.926 - /// 7, 3--1->5 6.927 - /// 4, 2--2->4 6.928 - /// 2, 0--1->3 6.929 - /// 1, 0--2->2 6.930 - ///\endcode 6.931 - template<typename _Digraph, typename _ArcFilterMap> 6.932 - class ArcSubDigraphAdaptor : 6.933 - public SubDigraphAdaptor<_Digraph, ConstMap<typename _Digraph::Node, bool>, 6.934 - _ArcFilterMap, false> { 6.935 - public: 6.936 - typedef _Digraph Digraph; 6.937 - typedef _ArcFilterMap ArcFilterMap; 6.938 - 6.939 - typedef SubDigraphAdaptor<Digraph, ConstMap<typename Digraph::Node, bool>, 6.940 - ArcFilterMap, false> Parent; 6.941 - 6.942 - typedef typename Parent::Arc Arc; 6.943 - 6.944 - protected: 6.945 - ConstMap<typename Digraph::Node, bool> const_true_map; 6.946 - 6.947 - ArcSubDigraphAdaptor() : const_true_map(true) { 6.948 - Parent::setNodeFilterMap(const_true_map); 6.949 - } 6.950 - 6.951 - public: 6.952 - 6.953 - /// \brief Constructor 6.954 - /// 6.955 - /// Creates a arc-sub-digraph-adaptor for the given digraph with 6.956 - /// given arc map filter. 6.957 - ArcSubDigraphAdaptor(Digraph& digraph, ArcFilterMap& arc_filter) 6.958 - : Parent(), const_true_map(true) { 6.959 - Parent::setDigraph(digraph); 6.960 - Parent::setNodeFilterMap(const_true_map); 6.961 - Parent::setArcFilterMap(arc_filter); 6.962 - } 6.963 - 6.964 - /// \brief Hides the arc of the graph 6.965 - /// 6.966 - /// This function hides \c a in the digraph, i.e. the iteration 6.967 - /// jumps over it. This is done by simply setting the value of \c a 6.968 - /// to be false in the corresponding arc-map. 6.969 - void hide(const Arc& a) const { Parent::hide(a); } 6.970 - 6.971 - /// \brief Unhides the arc of the graph 6.972 - /// 6.973 - /// The value of \c a is set to be true in the arc-map which stores 6.974 - /// hide information. If \c a was hidden previuosly, then it is shown 6.975 - /// again 6.976 - void unHide(const Arc& a) const { Parent::unHide(a); } 6.977 - 6.978 - /// \brief Returns true if \c a is hidden. 6.979 - /// 6.980 - /// Returns true if \c a is hidden. 6.981 - /// 6.982 - bool hidden(const Arc& a) const { return Parent::hidden(a); } 6.983 - 6.984 - }; 6.985 - 6.986 - /// \brief Just gives back an arc-sub-digraph adaptor 6.987 - /// 6.988 - /// Just gives back an arc-sub-digraph adaptor 6.989 - template<typename Digraph, typename ArcFilterMap> 6.990 - ArcSubDigraphAdaptor<const Digraph, ArcFilterMap> 6.991 - arcSubDigraphAdaptor(const Digraph& digraph, ArcFilterMap& afm) { 6.992 - return ArcSubDigraphAdaptor<const Digraph, ArcFilterMap>(digraph, afm); 6.993 - } 6.994 - 6.995 - template<typename Digraph, typename ArcFilterMap> 6.996 - ArcSubDigraphAdaptor<const Digraph, const ArcFilterMap> 6.997 - arcSubDigraphAdaptor(const Digraph& digraph, const ArcFilterMap& afm) { 6.998 - return ArcSubDigraphAdaptor<const Digraph, const ArcFilterMap> 6.999 - (digraph, afm); 6.1000 - } 6.1001 - 6.1002 - template <typename _Digraph> 6.1003 - class UndirDigraphAdaptorBase { 6.1004 - public: 6.1005 - typedef _Digraph Digraph; 6.1006 - typedef UndirDigraphAdaptorBase Adaptor; 6.1007 - 6.1008 - typedef True UndirectedTag; 6.1009 - 6.1010 - typedef typename Digraph::Arc Edge; 6.1011 - typedef typename Digraph::Node Node; 6.1012 - 6.1013 - class Arc : public Edge { 6.1014 - friend class UndirDigraphAdaptorBase; 6.1015 - protected: 6.1016 - bool _forward; 6.1017 - 6.1018 - Arc(const Edge& edge, bool forward) : 6.1019 - Edge(edge), _forward(forward) {} 6.1020 - 6.1021 - public: 6.1022 - Arc() {} 6.1023 - 6.1024 - Arc(Invalid) : Edge(INVALID), _forward(true) {} 6.1025 - 6.1026 - bool operator==(const Arc &other) const { 6.1027 - return _forward == other._forward && 6.1028 - static_cast<const Edge&>(*this) == static_cast<const Edge&>(other); 6.1029 - } 6.1030 - bool operator!=(const Arc &other) const { 6.1031 - return _forward != other._forward || 6.1032 - static_cast<const Edge&>(*this) != static_cast<const Edge&>(other); 6.1033 - } 6.1034 - bool operator<(const Arc &other) const { 6.1035 - return _forward < other._forward || 6.1036 - (_forward == other._forward && 6.1037 - static_cast<const Edge&>(*this) < static_cast<const Edge&>(other)); 6.1038 - } 6.1039 - }; 6.1040 - 6.1041 - 6.1042 - 6.1043 - void first(Node& n) const { 6.1044 - _digraph->first(n); 6.1045 - } 6.1046 - 6.1047 - void next(Node& n) const { 6.1048 - _digraph->next(n); 6.1049 - } 6.1050 - 6.1051 - void first(Arc& a) const { 6.1052 - _digraph->first(a); 6.1053 - a._forward = true; 6.1054 - } 6.1055 - 6.1056 - void next(Arc& a) const { 6.1057 - if (a._forward) { 6.1058 - a._forward = false; 6.1059 - } else { 6.1060 - _digraph->next(a); 6.1061 - a._forward = true; 6.1062 - } 6.1063 - } 6.1064 - 6.1065 - void first(Edge& e) const { 6.1066 - _digraph->first(e); 6.1067 - } 6.1068 - 6.1069 - void next(Edge& e) const { 6.1070 - _digraph->next(e); 6.1071 - } 6.1072 - 6.1073 - void firstOut(Arc& a, const Node& n) const { 6.1074 - _digraph->firstIn(a, n); 6.1075 - if( static_cast<const Edge&>(a) != INVALID ) { 6.1076 - a._forward = false; 6.1077 - } else { 6.1078 - _digraph->firstOut(a, n); 6.1079 - a._forward = true; 6.1080 - } 6.1081 - } 6.1082 - void nextOut(Arc &a) const { 6.1083 - if (!a._forward) { 6.1084 - Node n = _digraph->target(a); 6.1085 - _digraph->nextIn(a); 6.1086 - if (static_cast<const Edge&>(a) == INVALID ) { 6.1087 - _digraph->firstOut(a, n); 6.1088 - a._forward = true; 6.1089 - } 6.1090 - } 6.1091 - else { 6.1092 - _digraph->nextOut(a); 6.1093 - } 6.1094 - } 6.1095 - 6.1096 - void firstIn(Arc &a, const Node &n) const { 6.1097 - _digraph->firstOut(a, n); 6.1098 - if (static_cast<const Edge&>(a) != INVALID ) { 6.1099 - a._forward = false; 6.1100 - } else { 6.1101 - _digraph->firstIn(a, n); 6.1102 - a._forward = true; 6.1103 - } 6.1104 - } 6.1105 - void nextIn(Arc &a) const { 6.1106 - if (!a._forward) { 6.1107 - Node n = _digraph->source(a); 6.1108 - _digraph->nextOut(a); 6.1109 - if( static_cast<const Edge&>(a) == INVALID ) { 6.1110 - _digraph->firstIn(a, n); 6.1111 - a._forward = true; 6.1112 - } 6.1113 - } 6.1114 - else { 6.1115 - _digraph->nextIn(a); 6.1116 - } 6.1117 - } 6.1118 - 6.1119 - void firstInc(Edge &e, bool &d, const Node &n) const { 6.1120 - d = true; 6.1121 - _digraph->firstOut(e, n); 6.1122 - if (e != INVALID) return; 6.1123 - d = false; 6.1124 - _digraph->firstIn(e, n); 6.1125 - } 6.1126 - 6.1127 - void nextInc(Edge &e, bool &d) const { 6.1128 - if (d) { 6.1129 - Node s = _digraph->source(e); 6.1130 - _digraph->nextOut(e); 6.1131 - if (e != INVALID) return; 6.1132 - d = false; 6.1133 - _digraph->firstIn(e, s); 6.1134 - } else { 6.1135 - _digraph->nextIn(e); 6.1136 - } 6.1137 - } 6.1138 - 6.1139 - Node u(const Edge& e) const { 6.1140 - return _digraph->source(e); 6.1141 - } 6.1142 - 6.1143 - Node v(const Edge& e) const { 6.1144 - return _digraph->target(e); 6.1145 - } 6.1146 - 6.1147 - Node source(const Arc &a) const { 6.1148 - return a._forward ? _digraph->source(a) : _digraph->target(a); 6.1149 - } 6.1150 - 6.1151 - Node target(const Arc &a) const { 6.1152 - return a._forward ? _digraph->target(a) : _digraph->source(a); 6.1153 - } 6.1154 - 6.1155 - static Arc direct(const Edge &e, bool d) { 6.1156 - return Arc(e, d); 6.1157 - } 6.1158 - Arc direct(const Edge &e, const Node& n) const { 6.1159 - return Arc(e, _digraph->source(e) == n); 6.1160 - } 6.1161 - 6.1162 - static bool direction(const Arc &a) { return a._forward; } 6.1163 - 6.1164 - Node nodeFromId(int ix) const { return _digraph->nodeFromId(ix); } 6.1165 - Arc arcFromId(int ix) const { 6.1166 - return direct(_digraph->arcFromId(ix >> 1), bool(ix & 1)); 6.1167 - } 6.1168 - Edge edgeFromId(int ix) const { return _digraph->arcFromId(ix); } 6.1169 - 6.1170 - int id(const Node &n) const { return _digraph->id(n); } 6.1171 - int id(const Arc &a) const { 6.1172 - return (_digraph->id(a) << 1) | (a._forward ? 1 : 0); 6.1173 - } 6.1174 - int id(const Edge &e) const { return _digraph->id(e); } 6.1175 - 6.1176 - int maxNodeId() const { return _digraph->maxNodeId(); } 6.1177 - int maxArcId() const { return (_digraph->maxArcId() << 1) | 1; } 6.1178 - int maxEdgeId() const { return _digraph->maxArcId(); } 6.1179 - 6.1180 - Node addNode() { return _digraph->addNode(); } 6.1181 - Edge addEdge(const Node& u, const Node& v) { 6.1182 - return _digraph->addArc(u, v); 6.1183 - } 6.1184 - 6.1185 - void erase(const Node& i) { _digraph->erase(i); } 6.1186 - void erase(const Edge& i) { _digraph->erase(i); } 6.1187 - 6.1188 - void clear() { _digraph->clear(); } 6.1189 - 6.1190 - typedef NodeNumTagIndicator<Digraph> NodeNumTag; 6.1191 - int nodeNum() const { return 2 * _digraph->arcNum(); } 6.1192 - typedef EdgeNumTagIndicator<Digraph> EdgeNumTag; 6.1193 - int arcNum() const { return 2 * _digraph->arcNum(); } 6.1194 - int edgeNum() const { return _digraph->arcNum(); } 6.1195 - 6.1196 - typedef FindEdgeTagIndicator<Digraph> FindEdgeTag; 6.1197 - Arc findArc(Node s, Node t, Arc p = INVALID) const { 6.1198 - if (p == INVALID) { 6.1199 - Edge arc = _digraph->findArc(s, t); 6.1200 - if (arc != INVALID) return direct(arc, true); 6.1201 - arc = _digraph->findArc(t, s); 6.1202 - if (arc != INVALID) return direct(arc, false); 6.1203 - } else if (direction(p)) { 6.1204 - Edge arc = _digraph->findArc(s, t, p); 6.1205 - if (arc != INVALID) return direct(arc, true); 6.1206 - arc = _digraph->findArc(t, s); 6.1207 - if (arc != INVALID) return direct(arc, false); 6.1208 - } else { 6.1209 - Edge arc = _digraph->findArc(t, s, p); 6.1210 - if (arc != INVALID) return direct(arc, false); 6.1211 - } 6.1212 - return INVALID; 6.1213 - } 6.1214 - 6.1215 - Edge findEdge(Node s, Node t, Edge p = INVALID) const { 6.1216 - if (s != t) { 6.1217 - if (p == INVALID) { 6.1218 - Edge arc = _digraph->findArc(s, t); 6.1219 - if (arc != INVALID) return arc; 6.1220 - arc = _digraph->findArc(t, s); 6.1221 - if (arc != INVALID) return arc; 6.1222 - } else if (_digraph->s(p) == s) { 6.1223 - Edge arc = _digraph->findArc(s, t, p); 6.1224 - if (arc != INVALID) return arc; 6.1225 - arc = _digraph->findArc(t, s); 6.1226 - if (arc != INVALID) return arc; 6.1227 - } else { 6.1228 - Edge arc = _digraph->findArc(t, s, p); 6.1229 - if (arc != INVALID) return arc; 6.1230 - } 6.1231 - } else { 6.1232 - return _digraph->findArc(s, t, p); 6.1233 - } 6.1234 - return INVALID; 6.1235 - } 6.1236 - 6.1237 - private: 6.1238 - 6.1239 - template <typename _Value> 6.1240 - class ArcMapBase { 6.1241 - private: 6.1242 - 6.1243 - typedef typename Digraph::template ArcMap<_Value> MapImpl; 6.1244 - 6.1245 - public: 6.1246 - 6.1247 - typedef typename MapTraits<MapImpl>::ReferenceMapTag ReferenceMapTag; 6.1248 - 6.1249 - typedef _Value Value; 6.1250 - typedef Arc Key; 6.1251 - 6.1252 - ArcMapBase(const Adaptor& adaptor) : 6.1253 - _forward(*adaptor._digraph), _backward(*adaptor._digraph) {} 6.1254 - 6.1255 - ArcMapBase(const Adaptor& adaptor, const Value& v) 6.1256 - : _forward(*adaptor._digraph, v), _backward(*adaptor._digraph, v) {} 6.1257 - 6.1258 - void set(const Arc& a, const Value& v) { 6.1259 - if (direction(a)) { 6.1260 - _forward.set(a, v); 6.1261 - } else { 6.1262 - _backward.set(a, v); 6.1263 - } 6.1264 - } 6.1265 - 6.1266 - typename MapTraits<MapImpl>::ConstReturnValue 6.1267 - operator[](const Arc& a) const { 6.1268 - if (direction(a)) { 6.1269 - return _forward[a]; 6.1270 - } else { 6.1271 - return _backward[a]; 6.1272 - } 6.1273 - } 6.1274 - 6.1275 - typename MapTraits<MapImpl>::ReturnValue 6.1276 - operator[](const Arc& a) { 6.1277 - if (direction(a)) { 6.1278 - return _forward[a]; 6.1279 - } else { 6.1280 - return _backward[a]; 6.1281 - } 6.1282 - } 6.1283 - 6.1284 - protected: 6.1285 - 6.1286 - MapImpl _forward, _backward; 6.1287 - 6.1288 - }; 6.1289 - 6.1290 - public: 6.1291 - 6.1292 - template <typename _Value> 6.1293 - class NodeMap : public Digraph::template NodeMap<_Value> { 6.1294 - public: 6.1295 - 6.1296 - typedef _Value Value; 6.1297 - typedef typename Digraph::template NodeMap<Value> Parent; 6.1298 - 6.1299 - explicit NodeMap(const Adaptor& adaptor) 6.1300 - : Parent(*adaptor._digraph) {} 6.1301 - 6.1302 - NodeMap(const Adaptor& adaptor, const _Value& value) 6.1303 - : Parent(*adaptor._digraph, value) { } 6.1304 - 6.1305 - private: 6.1306 - NodeMap& operator=(const NodeMap& cmap) { 6.1307 - return operator=<NodeMap>(cmap); 6.1308 - } 6.1309 - 6.1310 - template <typename CMap> 6.1311 - NodeMap& operator=(const CMap& cmap) { 6.1312 - Parent::operator=(cmap); 6.1313 - return *this; 6.1314 - } 6.1315 - 6.1316 - }; 6.1317 - 6.1318 - template <typename _Value> 6.1319 - class ArcMap 6.1320 - : public SubMapExtender<Adaptor, ArcMapBase<_Value> > 6.1321 - { 6.1322 - public: 6.1323 - typedef _Value Value; 6.1324 - typedef SubMapExtender<Adaptor, ArcMapBase<Value> > Parent; 6.1325 - 6.1326 - ArcMap(const Adaptor& adaptor) 6.1327 - : Parent(adaptor) {} 6.1328 - 6.1329 - ArcMap(const Adaptor& adaptor, const Value& value) 6.1330 - : Parent(adaptor, value) {} 6.1331 - 6.1332 - private: 6.1333 - ArcMap& operator=(const ArcMap& cmap) { 6.1334 - return operator=<ArcMap>(cmap); 6.1335 - } 6.1336 - 6.1337 - template <typename CMap> 6.1338 - ArcMap& operator=(const CMap& cmap) { 6.1339 - Parent::operator=(cmap); 6.1340 - return *this; 6.1341 - } 6.1342 - }; 6.1343 - 6.1344 - template <typename _Value> 6.1345 - class EdgeMap : public Digraph::template ArcMap<_Value> { 6.1346 - public: 6.1347 - 6.1348 - typedef _Value Value; 6.1349 - typedef typename Digraph::template ArcMap<Value> Parent; 6.1350 - 6.1351 - explicit EdgeMap(const Adaptor& adaptor) 6.1352 - : Parent(*adaptor._digraph) {} 6.1353 - 6.1354 - EdgeMap(const Adaptor& adaptor, const Value& value) 6.1355 - : Parent(*adaptor._digraph, value) {} 6.1356 - 6.1357 - private: 6.1358 - EdgeMap& operator=(const EdgeMap& cmap) { 6.1359 - return operator=<EdgeMap>(cmap); 6.1360 - } 6.1361 - 6.1362 - template <typename CMap> 6.1363 - EdgeMap& operator=(const CMap& cmap) { 6.1364 - Parent::operator=(cmap); 6.1365 - return *this; 6.1366 - } 6.1367 - 6.1368 - }; 6.1369 - 6.1370 - typedef typename ItemSetTraits<Digraph, Node>::ItemNotifier NodeNotifier; 6.1371 - NodeNotifier& notifier(Node) const { return _digraph->notifier(Node()); } 6.1372 - 6.1373 - protected: 6.1374 - 6.1375 - UndirDigraphAdaptorBase() : _digraph(0) {} 6.1376 - 6.1377 - Digraph* _digraph; 6.1378 - 6.1379 - void setDigraph(Digraph& digraph) { 6.1380 - _digraph = &digraph; 6.1381 - } 6.1382 - 6.1383 - }; 6.1384 - 6.1385 - ///\ingroup graph_adaptors 6.1386 - /// 6.1387 - /// \brief A graph is made from a directed digraph by an adaptor 6.1388 - /// 6.1389 - /// This adaptor makes an undirected graph from a directed 6.1390 - /// graph. All arc of the underlying digraph will be showed in the 6.1391 - /// adaptor as an edge. Let's see an informal example about using 6.1392 - /// this adaptor. 6.1393 - /// 6.1394 - /// There is a network of the streets of a town. Of course there are 6.1395 - /// some one-way street in the town hence the network is a directed 6.1396 - /// one. There is a crazy driver who go oppositely in the one-way 6.1397 - /// street without moral sense. Of course he can pass this streets 6.1398 - /// slower than the regular way, in fact his speed is half of the 6.1399 - /// normal speed. How long should he drive to get from a source 6.1400 - /// point to the target? Let see the example code which calculate it: 6.1401 - /// 6.1402 - /// \todo BadCode, SimpleMap does no exists 6.1403 - ///\code 6.1404 - /// typedef UndirDigraphAdaptor<Digraph> Graph; 6.1405 - /// Graph graph(digraph); 6.1406 - /// 6.1407 - /// typedef SimpleMap<LengthMap> FLengthMap; 6.1408 - /// FLengthMap flength(length); 6.1409 - /// 6.1410 - /// typedef ScaleMap<LengthMap> RLengthMap; 6.1411 - /// RLengthMap rlength(length, 2.0); 6.1412 - /// 6.1413 - /// typedef Graph::CombinedArcMap<FLengthMap, RLengthMap > ULengthMap; 6.1414 - /// ULengthMap ulength(flength, rlength); 6.1415 - /// 6.1416 - /// Dijkstra<Graph, ULengthMap> dijkstra(graph, ulength); 6.1417 - /// std::cout << "Driving time : " << dijkstra.run(src, trg) << std::endl; 6.1418 - ///\endcode 6.1419 - /// 6.1420 - /// The combined arc map makes the length map for the undirected 6.1421 - /// graph. It is created from a forward and reverse map. The forward 6.1422 - /// map is created from the original length map with a SimpleMap 6.1423 - /// adaptor which just makes a read-write map from the reference map 6.1424 - /// i.e. it forgets that it can be return reference to values. The 6.1425 - /// reverse map is just the scaled original map with the ScaleMap 6.1426 - /// adaptor. The combination solves that passing the reverse way 6.1427 - /// takes double time than the original. To get the driving time we 6.1428 - /// run the dijkstra algorithm on the graph. 6.1429 - template<typename _Digraph> 6.1430 - class UndirDigraphAdaptor 6.1431 - : public GraphAdaptorExtender<UndirDigraphAdaptorBase<_Digraph> > { 6.1432 - public: 6.1433 - typedef _Digraph Digraph; 6.1434 - typedef GraphAdaptorExtender<UndirDigraphAdaptorBase<Digraph> > Parent; 6.1435 - protected: 6.1436 - UndirDigraphAdaptor() { } 6.1437 - public: 6.1438 - 6.1439 - /// \brief Constructor 6.1440 - /// 6.1441 - /// Constructor 6.1442 - UndirDigraphAdaptor(_Digraph& _digraph) { 6.1443 - setDigraph(_digraph); 6.1444 - } 6.1445 - 6.1446 - /// \brief ArcMap combined from two original ArcMap 6.1447 - /// 6.1448 - /// This class adapts two original digraph ArcMap to 6.1449 - /// get an arc map on the adaptor. 6.1450 - template <typename _ForwardMap, typename _BackwardMap> 6.1451 - class CombinedArcMap { 6.1452 - public: 6.1453 - 6.1454 - typedef _ForwardMap ForwardMap; 6.1455 - typedef _BackwardMap BackwardMap; 6.1456 - 6.1457 - typedef typename MapTraits<ForwardMap>::ReferenceMapTag ReferenceMapTag; 6.1458 - 6.1459 - typedef typename ForwardMap::Value Value; 6.1460 - typedef typename Parent::Arc Key; 6.1461 - 6.1462 - /// \brief Constructor 6.1463 - /// 6.1464 - /// Constructor 6.1465 - CombinedArcMap() : _forward(0), _backward(0) {} 6.1466 - 6.1467 - /// \brief Constructor 6.1468 - /// 6.1469 - /// Constructor 6.1470 - CombinedArcMap(ForwardMap& forward, BackwardMap& backward) 6.1471 - : _forward(&forward), _backward(&backward) {} 6.1472 - 6.1473 - 6.1474 - /// \brief Sets the value associated with a key. 6.1475 - /// 6.1476 - /// Sets the value associated with a key. 6.1477 - void set(const Key& e, const Value& a) { 6.1478 - if (Parent::direction(e)) { 6.1479 - _forward->set(e, a); 6.1480 - } else { 6.1481 - _backward->set(e, a); 6.1482 - } 6.1483 - } 6.1484 - 6.1485 - /// \brief Returns the value associated with a key. 6.1486 - /// 6.1487 - /// Returns the value associated with a key. 6.1488 - typename MapTraits<ForwardMap>::ConstReturnValue 6.1489 - operator[](const Key& e) const { 6.1490 - if (Parent::direction(e)) { 6.1491 - return (*_forward)[e]; 6.1492 - } else { 6.1493 - return (*_backward)[e]; 6.1494 - } 6.1495 - } 6.1496 - 6.1497 - /// \brief Returns the value associated with a key. 6.1498 - /// 6.1499 - /// Returns the value associated with a key. 6.1500 - typename MapTraits<ForwardMap>::ReturnValue 6.1501 - operator[](const Key& e) { 6.1502 - if (Parent::direction(e)) { 6.1503 - return (*_forward)[e]; 6.1504 - } else { 6.1505 - return (*_backward)[e]; 6.1506 - } 6.1507 - } 6.1508 - 6.1509 - /// \brief Sets the forward map 6.1510 - /// 6.1511 - /// Sets the forward map 6.1512 - void setForwardMap(ForwardMap& forward) { 6.1513 - _forward = &forward; 6.1514 - } 6.1515 - 6.1516 - /// \brief Sets the backward map 6.1517 - /// 6.1518 - /// Sets the backward map 6.1519 - void setBackwardMap(BackwardMap& backward) { 6.1520 - _backward = &backward; 6.1521 - } 6.1522 - 6.1523 - protected: 6.1524 - 6.1525 - ForwardMap* _forward; 6.1526 - BackwardMap* _backward; 6.1527 - 6.1528 - }; 6.1529 - 6.1530 - }; 6.1531 - 6.1532 - /// \brief Just gives back an undir digraph adaptor 6.1533 - /// 6.1534 - /// Just gives back an undir digraph adaptor 6.1535 - template<typename Digraph> 6.1536 - UndirDigraphAdaptor<const Digraph> 6.1537 - undirDigraphAdaptor(const Digraph& digraph) { 6.1538 - return UndirDigraphAdaptor<const Digraph>(digraph); 6.1539 - } 6.1540 - 6.1541 - template<typename _Digraph, 6.1542 - typename _CapacityMap = typename _Digraph::template ArcMap<int>, 6.1543 - typename _FlowMap = _CapacityMap, 6.1544 - typename _Tolerance = Tolerance<typename _CapacityMap::Value> > 6.1545 - class ResForwardFilter { 6.1546 - public: 6.1547 - 6.1548 - typedef _Digraph Digraph; 6.1549 - typedef _CapacityMap CapacityMap; 6.1550 - typedef _FlowMap FlowMap; 6.1551 - typedef _Tolerance Tolerance; 6.1552 - 6.1553 - typedef typename Digraph::Arc Key; 6.1554 - typedef bool Value; 6.1555 - 6.1556 - private: 6.1557 - 6.1558 - const CapacityMap* _capacity; 6.1559 - const FlowMap* _flow; 6.1560 - Tolerance _tolerance; 6.1561 - public: 6.1562 - 6.1563 - ResForwardFilter(const CapacityMap& capacity, const FlowMap& flow, 6.1564 - const Tolerance& tolerance = Tolerance()) 6.1565 - : _capacity(&capacity), _flow(&flow), _tolerance(tolerance) { } 6.1566 - 6.1567 - ResForwardFilter(const Tolerance& tolerance = Tolerance()) 6.1568 - : _capacity(0), _flow(0), _tolerance(tolerance) { } 6.1569 - 6.1570 - void setCapacity(const CapacityMap& capacity) { _capacity = &capacity; } 6.1571 - void setFlow(const FlowMap& flow) { _flow = &flow; } 6.1572 - 6.1573 - bool operator[](const typename Digraph::Arc& a) const { 6.1574 - return _tolerance.positive((*_capacity)[a] - (*_flow)[a]); 6.1575 - } 6.1576 - }; 6.1577 - 6.1578 - template<typename _Digraph, 6.1579 - typename _CapacityMap = typename _Digraph::template ArcMap<int>, 6.1580 - typename _FlowMap = _CapacityMap, 6.1581 - typename _Tolerance = Tolerance<typename _CapacityMap::Value> > 6.1582 - class ResBackwardFilter { 6.1583 - public: 6.1584 - 6.1585 - typedef _Digraph Digraph; 6.1586 - typedef _CapacityMap CapacityMap; 6.1587 - typedef _FlowMap FlowMap; 6.1588 - typedef _Tolerance Tolerance; 6.1589 - 6.1590 - typedef typename Digraph::Arc Key; 6.1591 - typedef bool Value; 6.1592 - 6.1593 - private: 6.1594 - 6.1595 - const CapacityMap* _capacity; 6.1596 - const FlowMap* _flow; 6.1597 - Tolerance _tolerance; 6.1598 - 6.1599 - public: 6.1600 - 6.1601 - ResBackwardFilter(const CapacityMap& capacity, const FlowMap& flow, 6.1602 - const Tolerance& tolerance = Tolerance()) 6.1603 - : _capacity(&capacity), _flow(&flow), _tolerance(tolerance) { } 6.1604 - ResBackwardFilter(const Tolerance& tolerance = Tolerance()) 6.1605 - : _capacity(0), _flow(0), _tolerance(tolerance) { } 6.1606 - 6.1607 - void setCapacity(const CapacityMap& capacity) { _capacity = &capacity; } 6.1608 - void setFlow(const FlowMap& flow) { _flow = &flow; } 6.1609 - 6.1610 - bool operator[](const typename Digraph::Arc& a) const { 6.1611 - return _tolerance.positive((*_flow)[a]); 6.1612 - } 6.1613 - }; 6.1614 - 6.1615 - 6.1616 - ///\ingroup graph_adaptors 6.1617 - /// 6.1618 - ///\brief An adaptor for composing the residual graph for directed 6.1619 - ///flow and circulation problems. 6.1620 - /// 6.1621 - ///An adaptor for composing the residual graph for directed flow and 6.1622 - ///circulation problems. Let \f$ G=(V, A) \f$be a directed digraph 6.1623 - ///and let \f$ F \f$be a number type. Let moreover \f$ f,c:A\to F
6.1624 -  ///\f$, be functions on the arc-set. 6.1625 - /// 6.1626 - ///In the appications of ResDigraphAdaptor, \f$ f \f$usually stands 6.1627 - ///for a flow and \f$ c \f$for a capacity function. Suppose that a 6.1628 - ///graph instance \c g of type \c ListDigraph implements \f$ G \f$. 6.1629 - /// 6.1630 - ///\code 6.1631 - /// ListDigraph g; 6.1632 - ///\endcode 6.1633 - /// 6.1634 - ///Then ResDigraphAdaptor implements the digraph structure with 6.1635 - /// node-set \f$ V \f$and arc-set \f$ A_{forward}\cup A_{backward}
6.1636 -  /// \f$, where \f$ A_{forward}=\{uv : uv\in A, f(uv)<c(uv)\} \f$and 6.1637 - /// \f$ A_{backward}=\{vu : uv\in A, f(uv)>0\} \f$, i.e. the so 6.1638 - /// called residual graph. When we take the union \f$
6.1639 -  /// A_{forward}\cup A_{backward} \f$, multilicities are counted, 6.1640 - /// i.e. if an arc is in both \f$ A_{forward} \f$and \f$
6.1641 -  /// A_{backward} \f$, then in the adaptor it appears twice. The 6.1642 - /// following code shows how such an instance can be constructed. 6.1643 - /// 6.1644 - ///\code 6.1645 - /// typedef ListDigraph Digraph; 6.1646 - /// IntArcMap f(g), c(g); 6.1647 - /// ResDigraphAdaptor<Digraph, int, IntArcMap, IntArcMap> ga(g); 6.1648 - ///\endcode 6.1649 - template<typename _Digraph, 6.1650 - typename _CapacityMap = typename _Digraph::template ArcMap<int>, 6.1651 - typename _FlowMap = _CapacityMap, 6.1652 - typename _Tolerance = Tolerance<typename _CapacityMap::Value> > 6.1653 - class ResDigraphAdaptor : 6.1654 - public ArcSubDigraphAdaptor< 6.1655 - UndirDigraphAdaptor<const _Digraph>, 6.1656 - typename UndirDigraphAdaptor<const _Digraph>::template CombinedArcMap< 6.1657 - ResForwardFilter<const _Digraph, _CapacityMap, _FlowMap>, 6.1658 - ResBackwardFilter<const _Digraph, _CapacityMap, _FlowMap> > > { 6.1659 - public: 6.1660 - 6.1661 - typedef _Digraph Digraph; 6.1662 - typedef _CapacityMap CapacityMap; 6.1663 - typedef _FlowMap FlowMap; 6.1664 - typedef _Tolerance Tolerance; 6.1665 - 6.1666 - typedef typename CapacityMap::Value Value; 6.1667 - typedef ResDigraphAdaptor Adaptor; 6.1668 - 6.1669 - protected: 6.1670 - 6.1671 - typedef UndirDigraphAdaptor<const Digraph> UndirDigraph; 6.1672 - 6.1673 - typedef ResForwardFilter<const Digraph, CapacityMap, FlowMap> 6.1674 - ForwardFilter; 6.1675 - 6.1676 - typedef ResBackwardFilter<const Digraph, CapacityMap, FlowMap> 6.1677 - BackwardFilter; 6.1678 - 6.1679 - typedef typename UndirDigraph:: 6.1680 - template CombinedArcMap<ForwardFilter, BackwardFilter> ArcFilter; 6.1681 - 6.1682 - typedef ArcSubDigraphAdaptor<UndirDigraph, ArcFilter> Parent; 6.1683 - 6.1684 - const CapacityMap* _capacity; 6.1685 - FlowMap* _flow; 6.1686 - 6.1687 - UndirDigraph _graph; 6.1688 - ForwardFilter _forward_filter; 6.1689 - BackwardFilter _backward_filter; 6.1690 - ArcFilter _arc_filter; 6.1691 - 6.1692 - void setCapacityMap(const CapacityMap& capacity) { 6.1693 - _capacity = &capacity; 6.1694 - _forward_filter.setCapacity(capacity); 6.1695 - _backward_filter.setCapacity(capacity); 6.1696 - } 6.1697 - 6.1698 - void setFlowMap(FlowMap& flow) { 6.1699 - _flow = &flow; 6.1700 - _forward_filter.setFlow(flow); 6.1701 - _backward_filter.setFlow(flow); 6.1702 - } 6.1703 - 6.1704 - public: 6.1705 - 6.1706 - /// \brief Constructor of the residual digraph. 6.1707 - /// 6.1708 - /// Constructor of the residual graph. The parameters are the digraph type, 6.1709 - /// the flow map, the capacity map and a tolerance object. 6.1710 - ResDigraphAdaptor(const Digraph& digraph, const CapacityMap& capacity, 6.1711 - FlowMap& flow, const Tolerance& tolerance = Tolerance()) 6.1712 - : Parent(), _capacity(&capacity), _flow(&flow), _graph(digraph), 6.1713 - _forward_filter(capacity, flow, tolerance), 6.1714 - _backward_filter(capacity, flow, tolerance), 6.1715 - _arc_filter(_forward_filter, _backward_filter) 6.1716 - { 6.1717 - Parent::setDigraph(_graph); 6.1718 - Parent::setArcFilterMap(_arc_filter); 6.1719 - } 6.1720 - 6.1721 - typedef typename Parent::Arc Arc; 6.1722 - 6.1723 - /// \brief Gives back the residual capacity of the arc. 6.1724 - /// 6.1725 - /// Gives back the residual capacity of the arc. 6.1726 - Value rescap(const Arc& arc) const { 6.1727 - if (UndirDigraph::direction(arc)) { 6.1728 - return (*_capacity)[arc] - (*_flow)[arc]; 6.1729 - } else { 6.1730 - return (*_flow)[arc]; 6.1731 - } 6.1732 - } 6.1733 - 6.1734 - /// \brief Augment on the given arc in the residual digraph. 6.1735 - /// 6.1736 - /// Augment on the given arc in the residual digraph. It increase 6.1737 - /// or decrease the flow on the original arc depend on the direction 6.1738 - /// of the residual arc. 6.1739 - void augment(const Arc& e, const Value& a) const { 6.1740 - if (UndirDigraph::direction(e)) { 6.1741 - _flow->set(e, (*_flow)[e] + a); 6.1742 - } else { 6.1743 - _flow->set(e, (*_flow)[e] - a); 6.1744 - } 6.1745 - } 6.1746 - 6.1747 - /// \brief Returns the direction of the arc. 6.1748 - /// 6.1749 - /// Returns true when the arc is same oriented as the original arc. 6.1750 - static bool forward(const Arc& e) { 6.1751 - return UndirDigraph::direction(e); 6.1752 - } 6.1753 - 6.1754 - /// \brief Returns the direction of the arc. 6.1755 - /// 6.1756 - /// Returns true when the arc is opposite oriented as the original arc. 6.1757 - static bool backward(const Arc& e) { 6.1758 - return !UndirDigraph::direction(e); 6.1759 - } 6.1760 - 6.1761 - /// \brief Gives back the forward oriented residual arc. 6.1762 - /// 6.1763 - /// Gives back the forward oriented residual arc. 6.1764 - static Arc forward(const typename Digraph::Arc& e) { 6.1765 - return UndirDigraph::direct(e, true); 6.1766 - } 6.1767 - 6.1768 - /// \brief Gives back the backward oriented residual arc. 6.1769 - /// 6.1770 - /// Gives back the backward oriented residual arc. 6.1771 - static Arc backward(const typename Digraph::Arc& e) { 6.1772 - return UndirDigraph::direct(e, false); 6.1773 - } 6.1774 - 6.1775 - /// \brief Residual capacity map. 6.1776 - /// 6.1777 - /// In generic residual digraphs the residual capacity can be obtained 6.1778 - /// as a map. 6.1779 - class ResCap { 6.1780 - protected: 6.1781 - const Adaptor* _adaptor; 6.1782 - public: 6.1783 - typedef Arc Key; 6.1784 - typedef typename _CapacityMap::Value Value; 6.1785 - 6.1786 - ResCap(const Adaptor& adaptor) : _adaptor(&adaptor) {} 6.1787 - 6.1788 - Value operator[](const Arc& e) const { 6.1789 - return _adaptor->rescap(e); 6.1790 - } 6.1791 - 6.1792 - }; 6.1793 - 6.1794 - }; 6.1795 - 6.1796 - template <typename _Digraph> 6.1797 - class SplitDigraphAdaptorBase { 6.1798 - public: 6.1799 - 6.1800 - typedef _Digraph Digraph; 6.1801 - typedef DigraphAdaptorBase<const _Digraph> Parent; 6.1802 - typedef SplitDigraphAdaptorBase Adaptor; 6.1803 - 6.1804 - typedef typename Digraph::Node DigraphNode; 6.1805 - typedef typename Digraph::Arc DigraphArc; 6.1806 - 6.1807 - class Node; 6.1808 - class Arc; 6.1809 - 6.1810 - private: 6.1811 - 6.1812 - template <typename T> class NodeMapBase; 6.1813 - template <typename T> class ArcMapBase; 6.1814 - 6.1815 - public: 6.1816 - 6.1817 - class Node : public DigraphNode { 6.1818 - friend class SplitDigraphAdaptorBase; 6.1819 - template <typename T> friend class NodeMapBase; 6.1820 - private: 6.1821 - 6.1822 - bool _in; 6.1823 - Node(DigraphNode node, bool in) 6.1824 - : DigraphNode(node), _in(in) {} 6.1825 - 6.1826 - public: 6.1827 - 6.1828 - Node() {} 6.1829 - Node(Invalid) : DigraphNode(INVALID), _in(true) {} 6.1830 - 6.1831 - bool operator==(const Node& node) const { 6.1832 - return DigraphNode::operator==(node) && _in == node._in; 6.1833 - } 6.1834 - 6.1835 - bool operator!=(const Node& node) const { 6.1836 - return !(*this == node); 6.1837 - } 6.1838 - 6.1839 - bool operator<(const Node& node) const { 6.1840 - return DigraphNode::operator<(node) || 6.1841 - (DigraphNode::operator==(node) && _in < node._in); 6.1842 - } 6.1843 - }; 6.1844 - 6.1845 - class Arc { 6.1846 - friend class SplitDigraphAdaptorBase; 6.1847 - template <typename T> friend class ArcMapBase; 6.1848 - private: 6.1849 - typedef BiVariant<DigraphArc, DigraphNode> ArcImpl; 6.1850 - 6.1851 - explicit Arc(const DigraphArc& arc) : _item(arc) {} 6.1852 - explicit Arc(const DigraphNode& node) : _item(node) {} 6.1853 - 6.1854 - ArcImpl _item; 6.1855 - 6.1856 - public: 6.1857 - Arc() {} 6.1858 - Arc(Invalid) : _item(DigraphArc(INVALID)) {} 6.1859 - 6.1860 - bool operator==(const Arc& arc) const { 6.1861 - if (_item.firstState()) { 6.1862 - if (arc._item.firstState()) { 6.1863 - return _item.first() == arc._item.first(); 6.1864 - } 6.1865 - } else { 6.1866 - if (arc._item.secondState()) { 6.1867 - return _item.second() == arc._item.second(); 6.1868 - } 6.1869 - } 6.1870 - return false; 6.1871 - } 6.1872 - 6.1873 - bool operator!=(const Arc& arc) const { 6.1874 - return !(*this == arc); 6.1875 - } 6.1876 - 6.1877 - bool operator<(const Arc& arc) const { 6.1878 - if (_item.firstState()) { 6.1879 - if (arc._item.firstState()) { 6.1880 - return _item.first() < arc._item.first(); 6.1881 - } 6.1882 - return false; 6.1883 - } else { 6.1884 - if (arc._item.secondState()) { 6.1885 - return _item.second() < arc._item.second(); 6.1886 - } 6.1887 - return true; 6.1888 - } 6.1889 - } 6.1890 - 6.1891 - operator DigraphArc() const { return _item.first(); } 6.1892 - operator DigraphNode() const { return _item.second(); } 6.1893 - 6.1894 - }; 6.1895 - 6.1896 - void first(Node& n) const { 6.1897 - _digraph->first(n); 6.1898 - n._in = true; 6.1899 - } 6.1900 - 6.1901 - void next(Node& n) const { 6.1902 - if (n._in) { 6.1903 - n._in = false; 6.1904 - } else { 6.1905 - n._in = true; 6.1906 - _digraph->next(n); 6.1907 - } 6.1908 - } 6.1909 - 6.1910 - void first(Arc& e) const { 6.1911 - e._item.setSecond(); 6.1912 - _digraph->first(e._item.second()); 6.1913 - if (e._item.second() == INVALID) { 6.1914 - e._item.setFirst(); 6.1915 - _digraph->first(e._item.first()); 6.1916 - } 6.1917 - } 6.1918 - 6.1919 - void next(Arc& e) const { 6.1920 - if (e._item.secondState()) { 6.1921 - _digraph->next(e._item.second()); 6.1922 - if (e._item.second() == INVALID) { 6.1923 - e._item.setFirst(); 6.1924 - _digraph->first(e._item.first()); 6.1925 - } 6.1926 - } else { 6.1927 - _digraph->next(e._item.first()); 6.1928 - } 6.1929 - } 6.1930 - 6.1931 - void firstOut(Arc& e, const Node& n) const { 6.1932 - if (n._in) { 6.1933 - e._item.setSecond(n); 6.1934 - } else { 6.1935 - e._item.setFirst(); 6.1936 - _digraph->firstOut(e._item.first(), n); 6.1937 - } 6.1938 - } 6.1939 - 6.1940 - void nextOut(Arc& e) const { 6.1941 - if (!e._item.firstState()) { 6.1942 - e._item.setFirst(INVALID); 6.1943 - } else { 6.1944 - _digraph->nextOut(e._item.first()); 6.1945 - } 6.1946 - } 6.1947 - 6.1948 - void firstIn(Arc& e, const Node& n) const { 6.1949 - if (!n._in) { 6.1950 - e._item.setSecond(n); 6.1951 - } else { 6.1952 - e._item.setFirst(); 6.1953 - _digraph->firstIn(e._item.first(), n); 6.1954 - } 6.1955 - } 6.1956 - 6.1957 - void nextIn(Arc& e) const { 6.1958 - if (!e._item.firstState()) { 6.1959 - e._item.setFirst(INVALID); 6.1960 - } else { 6.1961 - _digraph->nextIn(e._item.first()); 6.1962 - } 6.1963 - } 6.1964 - 6.1965 - Node source(const Arc& e) const { 6.1966 - if (e._item.firstState()) { 6.1967 - return Node(_digraph->source(e._item.first()), false); 6.1968 - } else { 6.1969 - return Node(e._item.second(), true); 6.1970 - } 6.1971 - } 6.1972 - 6.1973 - Node target(const Arc& e) const { 6.1974 - if (e._item.firstState()) { 6.1975 - return Node(_digraph->target(e._item.first()), true); 6.1976 - } else { 6.1977 - return Node(e._item.second(), false); 6.1978 - } 6.1979 - } 6.1980 - 6.1981 - int id(const Node& n) const { 6.1982 - return (_digraph->id(n) << 1) | (n._in ? 0 : 1); 6.1983 - } 6.1984 - Node nodeFromId(int ix) const { 6.1985 - return Node(_digraph->nodeFromId(ix >> 1), (ix & 1) == 0); 6.1986 - } 6.1987 - int maxNodeId() const { 6.1988 - return 2 * _digraph->maxNodeId() + 1; 6.1989 - } 6.1990 - 6.1991 - int id(const Arc& e) const { 6.1992 - if (e._item.firstState()) { 6.1993 - return _digraph->id(e._item.first()) << 1; 6.1994 - } else { 6.1995 - return (_digraph->id(e._item.second()) << 1) | 1; 6.1996 - } 6.1997 - } 6.1998 - Arc arcFromId(int ix) const { 6.1999 - if ((ix & 1) == 0) { 6.2000 - return Arc(_digraph->arcFromId(ix >> 1)); 6.2001 - } else { 6.2002 - return Arc(_digraph->nodeFromId(ix >> 1)); 6.2003 - } 6.2004 - } 6.2005 - int maxArcId() const { 6.2006 - return std::max(_digraph->maxNodeId() << 1, 6.2007 - (_digraph->maxArcId() << 1) | 1); 6.2008 - } 6.2009 - 6.2010 - static bool inNode(const Node& n) { 6.2011 - return n._in; 6.2012 - } 6.2013 - 6.2014 - static bool outNode(const Node& n) { 6.2015 - return !n._in; 6.2016 - } 6.2017 - 6.2018 - static bool origArc(const Arc& e) { 6.2019 - return e._item.firstState(); 6.2020 - } 6.2021 - 6.2022 - static bool bindArc(const Arc& e) { 6.2023 - return e._item.secondState(); 6.2024 - } 6.2025 - 6.2026 - static Node inNode(const DigraphNode& n) { 6.2027 - return Node(n, true); 6.2028 - } 6.2029 - 6.2030 - static Node outNode(const DigraphNode& n) { 6.2031 - return Node(n, false); 6.2032 - } 6.2033 - 6.2034 - static Arc arc(const DigraphNode& n) { 6.2035 - return Arc(n); 6.2036 - } 6.2037 - 6.2038 - static Arc arc(const DigraphArc& e) { 6.2039 - return Arc(e); 6.2040 - } 6.2041 - 6.2042 - typedef True NodeNumTag; 6.2043 - 6.2044 - int nodeNum() const { 6.2045 - return 2 * countNodes(*_digraph); 6.2046 - } 6.2047 - 6.2048 - typedef True EdgeNumTag; 6.2049 - int arcNum() const { 6.2050 - return countArcs(*_digraph) + countNodes(*_digraph); 6.2051 - } 6.2052 - 6.2053 - typedef True FindEdgeTag; 6.2054 - Arc findArc(const Node& u, const Node& v, 6.2055 - const Arc& prev = INVALID) const { 6.2056 - if (inNode(u)) { 6.2057 - if (outNode(v)) { 6.2058 - if (static_cast<const DigraphNode&>(u) == 6.2059 - static_cast<const DigraphNode&>(v) && prev == INVALID) { 6.2060 - return Arc(u); 6.2061 - } 6.2062 - } 6.2063 - } else { 6.2064 - if (inNode(v)) { 6.2065 - return Arc(::lemon::findArc(*_digraph, u, v, prev)); 6.2066 - } 6.2067 - } 6.2068 - return INVALID; 6.2069 - } 6.2070 - 6.2071 - private: 6.2072 - 6.2073 - template <typename _Value> 6.2074 - class NodeMapBase 6.2075 - : public MapTraits<typename Parent::template NodeMap<_Value> > { 6.2076 - typedef typename Parent::template NodeMap<_Value> NodeImpl; 6.2077 - public: 6.2078 - typedef Node Key; 6.2079 - typedef _Value Value; 6.2080 - 6.2081 - NodeMapBase(const Adaptor& adaptor) 6.2082 - : _in_map(*adaptor._digraph), _out_map(*adaptor._digraph) {} 6.2083 - NodeMapBase(const Adaptor& adaptor, const Value& value) 6.2084 - : _in_map(*adaptor._digraph, value), 6.2085 - _out_map(*adaptor._digraph, value) {} 6.2086 - 6.2087 - void set(const Node& key, const Value& val) { 6.2088 - if (Adaptor::inNode(key)) { _in_map.set(key, val); } 6.2089 - else {_out_map.set(key, val); } 6.2090 - } 6.2091 - 6.2092 - typename MapTraits<NodeImpl>::ReturnValue 6.2093 - operator[](const Node& key) { 6.2094 - if (Adaptor::inNode(key)) { return _in_map[key]; } 6.2095 - else { return _out_map[key]; } 6.2096 - } 6.2097 - 6.2098 - typename MapTraits<NodeImpl>::ConstReturnValue 6.2099 - operator[](const Node& key) const { 6.2100 - if (Adaptor::inNode(key)) { return _in_map[key]; } 6.2101 - else { return _out_map[key]; } 6.2102 - } 6.2103 - 6.2104 - private: 6.2105 - NodeImpl _in_map, _out_map; 6.2106 - }; 6.2107 - 6.2108 - template <typename _Value> 6.2109 - class ArcMapBase 6.2110 - : public MapTraits<typename Parent::template ArcMap<_Value> > { 6.2111 - typedef typename Parent::template ArcMap<_Value> ArcImpl; 6.2112 - typedef typename Parent::template NodeMap<_Value> NodeImpl; 6.2113 - public: 6.2114 - typedef Arc Key; 6.2115 - typedef _Value Value; 6.2116 - 6.2117 - ArcMapBase(const Adaptor& adaptor) 6.2118 - : _arc_map(*adaptor._digraph), _node_map(*adaptor._digraph) {} 6.2119 - ArcMapBase(const Adaptor& adaptor, const Value& value) 6.2120 - : _arc_map(*adaptor._digraph, value), 6.2121 - _node_map(*adaptor._digraph, value) {} 6.2122 - 6.2123 - void set(const Arc& key, const Value& val) { 6.2124 - if (Adaptor::origArc(key)) { 6.2125 - _arc_map.set(key._item.first(), val); 6.2126 - } else { 6.2127 - _node_map.set(key._item.second(), val); 6.2128 - } 6.2129 - } 6.2130 - 6.2131 - typename MapTraits<ArcImpl>::ReturnValue 6.2132 - operator[](const Arc& key) { 6.2133 - if (Adaptor::origArc(key)) { 6.2134 - return _arc_map[key._item.first()]; 6.2135 - } else { 6.2136 - return _node_map[key._item.second()]; 6.2137 - } 6.2138 - } 6.2139 - 6.2140 - typename MapTraits<ArcImpl>::ConstReturnValue 6.2141 - operator[](const Arc& key) const { 6.2142 - if (Adaptor::origArc(key)) { 6.2143 - return _arc_map[key._item.first()]; 6.2144 - } else { 6.2145 - return _node_map[key._item.second()]; 6.2146 - } 6.2147 - } 6.2148 - 6.2149 - private: 6.2150 - ArcImpl _arc_map; 6.2151 - NodeImpl _node_map; 6.2152 - }; 6.2153 - 6.2154 - public: 6.2155 - 6.2156 - template <typename _Value> 6.2157 - class NodeMap 6.2158 - : public SubMapExtender<Adaptor, NodeMapBase<_Value> > 6.2159 - { 6.2160 - public: 6.2161 - typedef _Value Value; 6.2162 - typedef SubMapExtender<Adaptor, NodeMapBase<Value> > Parent; 6.2163 - 6.2164 - NodeMap(const Adaptor& adaptor) 6.2165 - : Parent(adaptor) {} 6.2166 - 6.2167 - NodeMap(const Adaptor& adaptor, const Value& value) 6.2168 - : Parent(adaptor, value) {} 6.2169 - 6.2170 - private: 6.2171 - NodeMap& operator=(const NodeMap& cmap) { 6.2172 - return operator=<NodeMap>(cmap); 6.2173 - } 6.2174 - 6.2175 - template <typename CMap> 6.2176 - NodeMap& operator=(const CMap& cmap) { 6.2177 - Parent::operator=(cmap); 6.2178 - return *this; 6.2179 - } 6.2180 - }; 6.2181 - 6.2182 - template <typename _Value> 6.2183 - class ArcMap 6.2184 - : public SubMapExtender<Adaptor, ArcMapBase<_Value> > 6.2185 - { 6.2186 - public: 6.2187 - typedef _Value Value; 6.2188 - typedef SubMapExtender<Adaptor, ArcMapBase<Value> > Parent; 6.2189 - 6.2190 - ArcMap(const Adaptor& adaptor) 6.2191 - : Parent(adaptor) {} 6.2192 - 6.2193 - ArcMap(const Adaptor& adaptor, const Value& value) 6.2194 - : Parent(adaptor, value) {} 6.2195 - 6.2196 - private: 6.2197 - ArcMap& operator=(const ArcMap& cmap) { 6.2198 - return operator=<ArcMap>(cmap); 6.2199 - } 6.2200 - 6.2201 - template <typename CMap> 6.2202 - ArcMap& operator=(const CMap& cmap) { 6.2203 - Parent::operator=(cmap); 6.2204 - return *this; 6.2205 - } 6.2206 - }; 6.2207 - 6.2208 - protected: 6.2209 - 6.2210 - SplitDigraphAdaptorBase() : _digraph(0) {} 6.2211 - 6.2212 - Digraph* _digraph; 6.2213 - 6.2214 - void setDigraph(Digraph& digraph) { 6.2215 - _digraph = &digraph; 6.2216 - } 6.2217 - 6.2218 - }; 6.2219 - 6.2220 - /// \ingroup graph_adaptors 6.2221 - /// 6.2222 - /// \brief Split digraph adaptor class 6.2223 - /// 6.2224 - /// This is an digraph adaptor which splits all node into an in-node 6.2225 - /// and an out-node. Formaly, the adaptor replaces each \f$ u \f$6.2226 - /// node in the digraph with two node, \f$ u_{in} \f$node and 6.2227 - /// \f$ u_{out} \f$node. If there is an \f$ (v, u) \f$arc in the 6.2228 - /// original digraph the new target of the arc will be \f$ u_{in} \f$and 6.2229 - /// similarly the source of the original \f$ (u, v) \f$arc will be 6.2230 - /// \f$ u_{out} \f$. The adaptor will add for each node in the 6.2231 - /// original digraph an additional arc which will connect 6.2232 - /// \f$ (u_{in}, u_{out}) \f\$.
6.2233 -  ///
6.2234 -  /// The aim of this class is to run algorithm with node costs if the
6.2235 -  /// algorithm can use directly just arc costs. In this case we should use
6.2236 -  /// a \c SplitDigraphAdaptor and set the node cost of the digraph to the
6.2237 -  /// bind arc in the adapted digraph.
6.2238 -  ///
6.2239 -  /// For example a maximum flow algorithm can compute how many arc
6.2240 -  /// disjoint paths are in the digraph. But we would like to know how
6.2241 -  /// many node disjoint paths are in the digraph. First we have to
6.2242 -  /// adapt the digraph with the \c SplitDigraphAdaptor. Then run the flow
6.2243 -  /// algorithm on the adapted digraph. The bottleneck of the flow will
6.2244 -  /// be the bind arcs which bounds the flow with the count of the
6.2245 -  /// node disjoint paths.
6.2246 -  ///
6.2247 -  ///\code
6.2248 -  ///
6.2249 -  /// typedef SplitDigraphAdaptor<SmartDigraph> SDigraph;
6.2250 -  ///
6.2251 -  /// SDigraph sdigraph(digraph);
6.2252 -  ///
6.2253 -  /// typedef ConstMap<SDigraph::Arc, int> SCapacity;
6.2254 -  /// SCapacity scapacity(1);
6.2255 -  ///
6.2256 -  /// SDigraph::ArcMap<int> sflow(sdigraph);
6.2257 -  ///
6.2258 -  /// Preflow<SDigraph, SCapacity>
6.2259 -  ///   spreflow(sdigraph, scapacity,
6.2260 -  ///            SDigraph::outNode(source), SDigraph::inNode(target));
6.2261 -  ///
6.2262 -  /// spreflow.run();
6.2263 -  ///
6.2264 -  ///\endcode
6.2265 -  ///
6.2266 -  /// The result of the mamixum flow on the original digraph
6.2267 -  /// shows the next figure:
6.2268 -  ///
6.2269 -  /// \image html arc_disjoint.png
6.2270 -  /// \image latex arc_disjoint.eps "Arc disjoint paths" width=\textwidth
6.2271 -  ///
6.2272 -  /// And the maximum flow on the adapted digraph:
6.2273 -  ///
6.2274 -  /// \image html node_disjoint.png
6.2275 -  /// \image latex node_disjoint.eps "Node disjoint paths" width=\textwidth
6.2276 -  ///
6.2277 -  /// The second solution contains just 3 disjoint paths while the first 4.
6.2278 -  /// The full code can be found in the \ref disjoint_paths_demo.cc demo file.
6.2279 -  ///
6.2280 -  /// This digraph adaptor is fully conform to the
6.2281 -  /// \ref concepts::Digraph "Digraph" concept and
6.2282 -  /// contains some additional member functions and types. The
6.2283 -  /// documentation of some member functions may be found just in the
6.2285 -  ///
6.2287 -  template <typename _Digraph>
6.2290 -  public:
6.2291 -    typedef _Digraph Digraph;
6.2293 -
6.2294 -    typedef typename Digraph::Node DigraphNode;
6.2295 -    typedef typename Digraph::Arc DigraphArc;
6.2296 -
6.2297 -    typedef typename Parent::Node Node;
6.2298 -    typedef typename Parent::Arc Arc;
6.2299 -
6.2300 -    /// \brief Constructor of the adaptor.
6.2301 -    ///
6.2302 -    /// Constructor of the adaptor.
6.2304 -      Parent::setDigraph(g);
6.2305 -    }
6.2306 -
6.2307 -    /// \brief Returns true when the node is in-node.
6.2308 -    ///
6.2309 -    /// Returns true when the node is in-node.
6.2310 -    static bool inNode(const Node& n) {
6.2311 -      return Parent::inNode(n);
6.2312 -    }
6.2313 -
6.2314 -    /// \brief Returns true when the node is out-node.
6.2315 -    ///
6.2316 -    /// Returns true when the node is out-node.
6.2317 -    static bool outNode(const Node& n) {
6.2318 -      return Parent::outNode(n);
6.2319 -    }
6.2320 -
6.2321 -    /// \brief Returns true when the arc is arc in the original digraph.
6.2322 -    ///
6.2323 -    /// Returns true when the arc is arc in the original digraph.
6.2324 -    static bool origArc(const Arc& a) {
6.2325 -      return Parent::origArc(a);
6.2326 -    }
6.2327 -
6.2328 -    /// \brief Returns true when the arc binds an in-node and an out-node.
6.2329 -    ///
6.2330 -    /// Returns true when the arc binds an in-node and an out-node.
6.2331 -    static bool bindArc(const Arc& a) {
6.2332 -      return Parent::bindArc(a);
6.2333 -    }
6.2334 -
6.2335 -    /// \brief Gives back the in-node created from the \c node.
6.2336 -    ///
6.2337 -    /// Gives back the in-node created from the \c node.
6.2338 -    static Node inNode(const DigraphNode& n) {
6.2339 -      return Parent::inNode(n);
6.2340 -    }
6.2341 -
6.2342 -    /// \brief Gives back the out-node created from the \c node.
6.2343 -    ///
6.2344 -    /// Gives back the out-node created from the \c node.
6.2345 -    static Node outNode(const DigraphNode& n) {
6.2346 -      return Parent::outNode(n);
6.2347 -    }
6.2348 -
6.2349 -    /// \brief Gives back the arc binds the two part of the node.
6.2350 -    ///
6.2351 -    /// Gives back the arc binds the two part of the node.
6.2352 -    static Arc arc(const DigraphNode& n) {
6.2353 -      return Parent::arc(n);
6.2354 -    }
6.2355 -
6.2356 -    /// \brief Gives back the arc of the original arc.
6.2357 -    ///
6.2358 -    /// Gives back the arc of the original arc.
6.2359 -    static Arc arc(const DigraphArc& a) {
6.2360 -      return Parent::arc(a);
6.2361 -    }
6.2362 -
6.2363 -    /// \brief NodeMap combined from two original NodeMap
6.2364 -    ///
6.2365 -    /// This class adapt two of the original digraph NodeMap to
6.2366 -    /// get a node map on the adapted digraph.
6.2367 -    template <typename InNodeMap, typename OutNodeMap>
6.2368 -    class CombinedNodeMap {
6.2369 -    public:
6.2370 -
6.2371 -      typedef Node Key;
6.2372 -      typedef typename InNodeMap::Value Value;
6.2373 -
6.2374 -      /// \brief Constructor
6.2375 -      ///
6.2376 -      /// Constructor.
6.2377 -      CombinedNodeMap(InNodeMap& in_map, OutNodeMap& out_map)
6.2378 -	: _in_map(in_map), _out_map(out_map) {}
6.2379 -
6.2380 -      /// \brief The subscript operator.
6.2381 -      ///
6.2382 -      /// The subscript operator.
6.2383 -      Value& operator[](const Key& key) {
6.2384 -	if (Parent::inNode(key)) {
6.2385 -	  return _in_map[key];
6.2386 -	} else {
6.2387 -	  return _out_map[key];
6.2388 -	}
6.2389 -      }
6.2390 -
6.2391 -      /// \brief The const subscript operator.
6.2392 -      ///
6.2393 -      /// The const subscript operator.
6.2394 -      Value operator[](const Key& key) const {
6.2395 -	if (Parent::inNode(key)) {
6.2396 -	  return _in_map[key];
6.2397 -	} else {
6.2398 -	  return _out_map[key];
6.2399 -	}
6.2400 -      }
6.2401 -
6.2402 -      /// \brief The setter function of the map.
6.2403 -      ///
6.2404 -      /// The setter function of the map.
6.2405 -      void set(const Key& key, const Value& value) {
6.2406 -	if (Parent::inNode(key)) {
6.2407 -	  _in_map.set(key, value);
6.2408 -	} else {
6.2409 -	  _out_map.set(key, value);
6.2410 -	}
6.2411 -      }
6.2412 -
6.2413 -    private:
6.2414 -
6.2415 -      InNodeMap& _in_map;
6.2416 -      OutNodeMap& _out_map;
6.2417 -
6.2418 -    };
6.2419 -
6.2420 -
6.2421 -    /// \brief Just gives back a combined node map.
6.2422 -    ///
6.2423 -    /// Just gives back a combined node map.
6.2424 -    template <typename InNodeMap, typename OutNodeMap>
6.2425 -    static CombinedNodeMap<InNodeMap, OutNodeMap>
6.2426 -    combinedNodeMap(InNodeMap& in_map, OutNodeMap& out_map) {
6.2427 -      return CombinedNodeMap<InNodeMap, OutNodeMap>(in_map, out_map);
6.2428 -    }
6.2429 -
6.2430 -    template <typename InNodeMap, typename OutNodeMap>
6.2431 -    static CombinedNodeMap<const InNodeMap, OutNodeMap>
6.2432 -    combinedNodeMap(const InNodeMap& in_map, OutNodeMap& out_map) {
6.2433 -      return CombinedNodeMap<const InNodeMap, OutNodeMap>(in_map, out_map);
6.2434 -    }
6.2435 -
6.2436 -    template <typename InNodeMap, typename OutNodeMap>
6.2437 -    static CombinedNodeMap<InNodeMap, const OutNodeMap>
6.2438 -    combinedNodeMap(InNodeMap& in_map, const OutNodeMap& out_map) {
6.2439 -      return CombinedNodeMap<InNodeMap, const OutNodeMap>(in_map, out_map);
6.2440 -    }
6.2441 -
6.2442 -    template <typename InNodeMap, typename OutNodeMap>
6.2443 -    static CombinedNodeMap<const InNodeMap, const OutNodeMap>
6.2444 -    combinedNodeMap(const InNodeMap& in_map, const OutNodeMap& out_map) {
6.2445 -      return CombinedNodeMap<const InNodeMap,
6.2446 -        const OutNodeMap>(in_map, out_map);
6.2447 -    }
6.2448 -
6.2449 -    /// \brief ArcMap combined from an original ArcMap and NodeMap
6.2450 -    ///
6.2451 -    /// This class adapt an original digraph ArcMap and NodeMap to
6.2452 -    /// get an arc map on the adapted digraph.
6.2453 -    template <typename DigraphArcMap, typename DigraphNodeMap>
6.2454 -    class CombinedArcMap {
6.2455 -    public:
6.2456 -
6.2457 -      typedef Arc Key;
6.2458 -      typedef typename DigraphArcMap::Value Value;
6.2459 -
6.2460 -      /// \brief Constructor
6.2461 -      ///
6.2462 -      /// Constructor.
6.2463 -      CombinedArcMap(DigraphArcMap& arc_map, DigraphNodeMap& node_map)
6.2464 -	: _arc_map(arc_map), _node_map(node_map) {}
6.2465 -
6.2466 -      /// \brief The subscript operator.
6.2467 -      ///
6.2468 -      /// The subscript operator.
6.2469 -      void set(const Arc& arc, const Value& val) {
6.2470 -	if (Parent::origArc(arc)) {
6.2471 -	  _arc_map.set(arc, val);
6.2472 -	} else {
6.2473 -	  _node_map.set(arc, val);
6.2474 -	}
6.2475 -      }
6.2476 -
6.2477 -      /// \brief The const subscript operator.
6.2478 -      ///
6.2479 -      /// The const subscript operator.
6.2480 -      Value operator[](const Key& arc) const {
6.2481 -	if (Parent::origArc(arc)) {
6.2482 -	  return _arc_map[arc];
6.2483 -	} else {
6.2484 -	  return _node_map[arc];
6.2485 -	}
6.2486 -      }
6.2487 -
6.2488 -      /// \brief The const subscript operator.
6.2489 -      ///
6.2490 -      /// The const subscript operator.
6.2491 -      Value& operator[](const Key& arc) {
6.2492 -	if (Parent::origArc(arc)) {
6.2493 -	  return _arc_map[arc];
6.2494 -	} else {
6.2495 -	  return _node_map[arc];
6.2496 -	}
6.2497 -      }
6.2498 -
6.2499 -    private:
6.2500 -      DigraphArcMap& _arc_map;
6.2501 -      DigraphNodeMap& _node_map;
6.2502 -    };
6.2503 -
6.2504 -    /// \brief Just gives back a combined arc map.
6.2505 -    ///
6.2506 -    /// Just gives back a combined arc map.
6.2507 -    template <typename DigraphArcMap, typename DigraphNodeMap>
6.2508 -    static CombinedArcMap<DigraphArcMap, DigraphNodeMap>
6.2509 -    combinedArcMap(DigraphArcMap& arc_map, DigraphNodeMap& node_map) {
6.2510 -      return CombinedArcMap<DigraphArcMap, DigraphNodeMap>(arc_map, node_map);
6.2511 -    }
6.2512 -
6.2513 -    template <typename DigraphArcMap, typename DigraphNodeMap>
6.2514 -    static CombinedArcMap<const DigraphArcMap, DigraphNodeMap>
6.2515 -    combinedArcMap(const DigraphArcMap& arc_map, DigraphNodeMap& node_map) {
6.2516 -      return CombinedArcMap<const DigraphArcMap,
6.2517 -        DigraphNodeMap>(arc_map, node_map);
6.2518 -    }
6.2519 -
6.2520 -    template <typename DigraphArcMap, typename DigraphNodeMap>
6.2521 -    static CombinedArcMap<DigraphArcMap, const DigraphNodeMap>
6.2522 -    combinedArcMap(DigraphArcMap& arc_map, const DigraphNodeMap& node_map) {
6.2523 -      return CombinedArcMap<DigraphArcMap,
6.2524 -        const DigraphNodeMap>(arc_map, node_map);
6.2525 -    }
6.2526 -
6.2527 -    template <typename DigraphArcMap, typename DigraphNodeMap>
6.2528 -    static CombinedArcMap<const DigraphArcMap, const DigraphNodeMap>
6.2529 -    combinedArcMap(const DigraphArcMap& arc_map,
6.2530 -                    const DigraphNodeMap& node_map) {
6.2531 -      return CombinedArcMap<const DigraphArcMap,
6.2532 -        const DigraphNodeMap>(arc_map, node_map);
6.2533 -    }
6.2534 -
6.2535 -  };
6.2536 -
6.2537 -  /// \brief Just gives back a split digraph adaptor
6.2538 -  ///
6.2539 -  /// Just gives back a split digraph adaptor
6.2540 -  template<typename Digraph>
6.2542 -  splitDigraphAdaptor(const Digraph& digraph) {
6.2544 -  }
6.2545 -
6.2546 -
6.2547 -} //namespace lemon
6.2548 -
6.2550 -

     7.1 --- a/lemon/graph_adaptor.h	Sun Nov 30 19:00:30 2008 +0100
7.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
7.3 @@ -1,1164 +0,0 @@
7.4 -/* -*- C++ -*-
7.5 - *
7.6 - * This file is a part of LEMON, a generic C++ optimization library
7.7 - *
7.8 - * Copyright (C) 2003-2008
7.9 - * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7.10 - * (Egervary Research Group on Combinatorial Optimization, EGRES).
7.11 - *
7.12 - * Permission to use, modify and distribute this software is granted
7.13 - * provided that this copyright notice appears in all copies. For
7.14 - * precise terms see the accompanying LICENSE file.
7.15 - *
7.16 - * This software is provided "AS IS" with no warranty of any kind,
7.17 - * express or implied, and with no claim as to its suitability for any
7.18 - * purpose.
7.19 - *
7.20 - */
7.21 -
7.24 -
7.26 -///\file
7.28 -///
7.29 -///This file contains several useful undirected graph adaptor classes.
7.30 -
7.31 -#include <lemon/core.h>
7.32 -#include <lemon/maps.h>
7.34 -
7.35 -namespace lemon {
7.36 -
7.37 -  template<typename _Graph>
7.39 -  public:
7.40 -    typedef _Graph Graph;
7.41 -    typedef Graph ParentGraph;
7.42 -
7.43 -  protected:
7.44 -    Graph* _graph;
7.45 -
7.46 -    GraphAdaptorBase() : _graph(0) {}
7.47 -
7.48 -    void setGraph(Graph& graph) { _graph = &graph; }
7.49 -
7.50 -  public:
7.51 -    GraphAdaptorBase(Graph& graph) : _graph(&graph) {}
7.52 -
7.53 -    typedef typename Graph::Node Node;
7.54 -    typedef typename Graph::Arc Arc;
7.55 -    typedef typename Graph::Edge Edge;
7.56 -
7.57 -    void first(Node& i) const { _graph->first(i); }
7.58 -    void first(Arc& i) const { _graph->first(i); }
7.59 -    void first(Edge& i) const { _graph->first(i); }
7.60 -    void firstIn(Arc& i, const Node& n) const { _graph->firstIn(i, n); }
7.61 -    void firstOut(Arc& i, const Node& n ) const { _graph->firstOut(i, n); }
7.62 -    void firstInc(Edge &i, bool &d, const Node &n) const {
7.63 -      _graph->firstInc(i, d, n);
7.64 -    }
7.65 -
7.66 -    void next(Node& i) const { _graph->next(i); }
7.67 -    void next(Arc& i) const { _graph->next(i); }
7.68 -    void next(Edge& i) const { _graph->next(i); }
7.69 -    void nextIn(Arc& i) const { _graph->nextIn(i); }
7.70 -    void nextOut(Arc& i) const { _graph->nextOut(i); }
7.71 -    void nextInc(Edge &i, bool &d) const { _graph->nextInc(i, d); }
7.72 -
7.73 -    Node u(const Edge& e) const { return _graph->u(e); }
7.74 -    Node v(const Edge& e) const { return _graph->v(e); }
7.75 -
7.76 -    Node source(const Arc& a) const { return _graph->source(a); }
7.77 -    Node target(const Arc& a) const { return _graph->target(a); }
7.78 -
7.79 -    typedef NodeNumTagIndicator<Graph> NodeNumTag;
7.80 -    int nodeNum() const { return _graph->nodeNum(); }
7.81 -
7.82 -    typedef EdgeNumTagIndicator<Graph> EdgeNumTag;
7.83 -    int arcNum() const { return _graph->arcNum(); }
7.84 -    int edgeNum() const { return _graph->edgeNum(); }
7.85 -
7.86 -    typedef FindEdgeTagIndicator<Graph> FindEdgeTag;
7.87 -    Arc findArc(const Node& u, const Node& v, const Arc& prev = INVALID) {
7.88 -      return _graph->findArc(u, v, prev);
7.89 -    }
7.90 -    Edge findEdge(const Node& u, const Node& v, const Edge& prev = INVALID) {
7.91 -      return _graph->findEdge(u, v, prev);
7.92 -    }
7.93 -
7.95 -    Edge addEdge(const Node& u, const Node& v) { return _graph->addEdge(u, v); }
7.96 -
7.97 -    void erase(const Node& i) { _graph->erase(i); }
7.98 -    void erase(const Edge& i) { _graph->erase(i); }
7.99 -
7.100 -    void clear() { _graph->clear(); }
7.101 -
7.102 -    bool direction(const Arc& a) const { return _graph->direction(a); }
7.103 -    Arc direct(const Edge& e, bool d) const { return _graph->direct(e, d); }
7.104 -
7.105 -    int id(const Node& v) const { return _graph->id(v); }
7.106 -    int id(const Arc& a) const { return _graph->id(a); }
7.107 -    int id(const Edge& e) const { return _graph->id(e); }
7.108 -
7.109 -    Node nodeFromId(int ix) const { return _graph->nodeFromId(ix); }
7.110 -    Arc arcFromId(int ix) const { return _graph->arcFromId(ix); }
7.111 -    Edge edgeFromId(int ix) const { return _graph->edgeFromId(ix); }
7.112 -
7.113 -    int maxNodeId() const { return _graph->maxNodeId(); }
7.114 -    int maxArcId() const { return _graph->maxArcId(); }
7.115 -    int maxEdgeId() const { return _graph->maxEdgeId(); }
7.116 -
7.117 -    typedef typename ItemSetTraits<Graph, Node>::ItemNotifier NodeNotifier;
7.118 -    NodeNotifier& notifier(Node) const { return _graph->notifier(Node()); }
7.119 -
7.120 -    typedef typename ItemSetTraits<Graph, Arc>::ItemNotifier ArcNotifier;
7.121 -    ArcNotifier& notifier(Arc) const { return _graph->notifier(Arc()); }
7.122 -
7.123 -    typedef typename ItemSetTraits<Graph, Edge>::ItemNotifier EdgeNotifier;
7.124 -    EdgeNotifier& notifier(Edge) const { return _graph->notifier(Edge()); }
7.125 -
7.126 -    template <typename _Value>
7.127 -    class NodeMap : public Graph::template NodeMap<_Value> {
7.128 -    public:
7.129 -      typedef typename Graph::template NodeMap<_Value> Parent;
7.133 -	: Parent(*adapter._graph, value) {}
7.134 -
7.135 -    private:
7.136 -      NodeMap& operator=(const NodeMap& cmap) {
7.137 -	return operator=<NodeMap>(cmap);
7.138 -      }
7.139 -
7.140 -      template <typename CMap>
7.141 -      NodeMap& operator=(const CMap& cmap) {
7.142 -        Parent::operator=(cmap);
7.143 -        return *this;
7.144 -      }
7.145 -
7.146 -    };
7.147 -
7.148 -    template <typename _Value>
7.149 -    class ArcMap : public Graph::template ArcMap<_Value> {
7.150 -    public:
7.151 -      typedef typename Graph::template ArcMap<_Value> Parent;
7.155 -	: Parent(*adapter._graph, value) {}
7.156 -
7.157 -    private:
7.158 -      ArcMap& operator=(const ArcMap& cmap) {
7.159 -	return operator=<ArcMap>(cmap);
7.160 -      }
7.161 -
7.162 -      template <typename CMap>
7.163 -      ArcMap& operator=(const CMap& cmap) {
7.164 -        Parent::operator=(cmap);
7.165 -	return *this;
7.166 -      }
7.167 -    };
7.168 -
7.169 -    template <typename _Value>
7.170 -    class EdgeMap : public Graph::template EdgeMap<_Value> {
7.171 -    public:
7.172 -      typedef typename Graph::template EdgeMap<_Value> Parent;
7.176 -	: Parent(*adapter._graph, value) {}
7.177 -
7.178 -    private:
7.179 -      EdgeMap& operator=(const EdgeMap& cmap) {
7.180 -	return operator=<EdgeMap>(cmap);
7.181 -      }
7.182 -
7.183 -      template <typename CMap>
7.184 -      EdgeMap& operator=(const CMap& cmap) {
7.185 -        Parent::operator=(cmap);
7.186 -        return *this;
7.187 -      }
7.188 -    };
7.189 -
7.190 -  };
7.191 -
7.192 -  template <typename _Graph, typename NodeFilterMap,
7.193 -	    typename EdgeFilterMap, bool checked = true>
7.195 -  public:
7.196 -    typedef _Graph Graph;
7.199 -  protected:
7.200 -
7.201 -    NodeFilterMap* _node_filter_map;
7.202 -    EdgeFilterMap* _edge_filter_map;
7.203 -
7.205 -      : Parent(), _node_filter_map(0), _edge_filter_map(0) { }
7.206 -
7.207 -    void setNodeFilterMap(NodeFilterMap& node_filter_map) {
7.208 -      _node_filter_map=&node_filter_map;
7.209 -    }
7.210 -    void setEdgeFilterMap(EdgeFilterMap& edge_filter_map) {
7.211 -      _edge_filter_map=&edge_filter_map;
7.212 -    }
7.213 -
7.214 -  public:
7.215 -
7.216 -    typedef typename Parent::Node Node;
7.217 -    typedef typename Parent::Arc Arc;
7.218 -    typedef typename Parent::Edge Edge;
7.219 -
7.220 -    void first(Node& i) const {
7.221 -      Parent::first(i);
7.222 -      while (i!=INVALID && !(*_node_filter_map)[i]) Parent::next(i);
7.223 -    }
7.224 -
7.225 -    void first(Arc& i) const {
7.226 -      Parent::first(i);
7.227 -      while (i!=INVALID && (!(*_edge_filter_map)[i]
7.228 -	     || !(*_node_filter_map)[Parent::source(i)]
7.229 -	     || !(*_node_filter_map)[Parent::target(i)])) Parent::next(i);
7.230 -    }
7.231 -
7.232 -    void first(Edge& i) const {
7.233 -      Parent::first(i);
7.234 -      while (i!=INVALID && (!(*_edge_filter_map)[i]
7.235 -	     || !(*_node_filter_map)[Parent::u(i)]
7.236 -	     || !(*_node_filter_map)[Parent::v(i)])) Parent::next(i);
7.237 -    }
7.238 -
7.239 -    void firstIn(Arc& i, const Node& n) const {
7.240 -      Parent::firstIn(i, n);
7.241 -      while (i!=INVALID && (!(*_edge_filter_map)[i]
7.242 -	     || !(*_node_filter_map)[Parent::source(i)])) Parent::nextIn(i);
7.243 -    }
7.244 -
7.245 -    void firstOut(Arc& i, const Node& n) const {
7.246 -      Parent::firstOut(i, n);
7.247 -      while (i!=INVALID && (!(*_edge_filter_map)[i]
7.248 -	     || !(*_node_filter_map)[Parent::target(i)])) Parent::nextOut(i);
7.249 -    }
7.250 -
7.251 -    void firstInc(Edge& i, bool& d, const Node& n) const {
7.252 -      Parent::firstInc(i, d, n);
7.253 -      while (i!=INVALID && (!(*_edge_filter_map)[i]
7.254 -            || !(*_node_filter_map)[Parent::u(i)]
7.255 -            || !(*_node_filter_map)[Parent::v(i)])) Parent::nextInc(i, d);
7.256 -    }
7.257 -
7.258 -    void next(Node& i) const {
7.259 -      Parent::next(i);
7.260 -      while (i!=INVALID && !(*_node_filter_map)[i]) Parent::next(i);
7.261 -    }
7.262 -
7.263 -    void next(Arc& i) const {
7.264 -      Parent::next(i);
7.265 -      while (i!=INVALID && (!(*_edge_filter_map)[i]
7.266 -	     || !(*_node_filter_map)[Parent::source(i)]
7.267 -	     || !(*_node_filter_map)[Parent::target(i)])) Parent::next(i);
7.268 -    }
7.269 -
7.270 -    void next(Edge& i) const {
7.271 -      Parent::next(i);
7.272 -      while (i!=INVALID && (!(*_edge_filter_map)[i]
7.273 -	     || !(*_node_filter_map)[Parent::u(i)]
7.274 -	     || !(*_node_filter_map)[Parent::v(i)])) Parent::next(i);
7.275 -    }
7.276 -
7.277 -    void nextIn(Arc& i) const {
7.278 -      Parent::nextIn(i);
7.279 -      while (i!=INVALID && (!(*_edge_filter_map)[i]
7.280 -	     || !(*_node_filter_map)[Parent::source(i)])) Parent::nextIn(i);
7.281 -    }
7.282 -
7.283 -    void nextOut(Arc& i) const {
7.284 -      Parent::nextOut(i);
7.285 -      while (i!=INVALID && (!(*_edge_filter_map)[i]
7.286 -	     || !(*_node_filter_map)[Parent::target(i)])) Parent::nextOut(i);
7.287 -    }
7.288 -
7.289 -    void nextInc(Edge& i, bool& d) const {
7.290 -      Parent::nextInc(i, d);
7.291 -      while (i!=INVALID && (!(*_edge_filter_map)[i]
7.292 -            || !(*_node_filter_map)[Parent::u(i)]
7.293 -            || !(*_node_filter_map)[Parent::v(i)])) Parent::nextInc(i, d);
7.294 -    }
7.295 -
7.296 -    void hide(const Node& n) const { _node_filter_map->set(n, false); }
7.297 -    void hide(const Edge& e) const { _edge_filter_map->set(e, false); }
7.298 -
7.299 -    void unHide(const Node& n) const { _node_filter_map->set(n, true); }
7.300 -    void unHide(const Edge& e) const { _edge_filter_map->set(e, true); }
7.301 -
7.302 -    bool hidden(const Node& n) const { return !(*_node_filter_map)[n]; }
7.303 -    bool hidden(const Edge& e) const { return !(*_edge_filter_map)[e]; }
7.304 -
7.305 -    typedef False NodeNumTag;
7.306 -    typedef False EdgeNumTag;
7.307 -
7.308 -    typedef FindEdgeTagIndicator<Graph> FindEdgeTag;
7.309 -    Arc findArc(const Node& u, const Node& v,
7.310 -		  const Arc& prev = INVALID) {
7.311 -      if (!(*_node_filter_map)[u] || !(*_node_filter_map)[v]) {
7.312 -        return INVALID;
7.313 -      }
7.314 -      Arc arc = Parent::findArc(u, v, prev);
7.315 -      while (arc != INVALID && !(*_edge_filter_map)[arc]) {
7.316 -        arc = Parent::findArc(u, v, arc);
7.317 -      }
7.318 -      return arc;
7.319 -    }
7.320 -    Edge findEdge(const Node& u, const Node& v,
7.321 -		  const Edge& prev = INVALID) {
7.322 -      if (!(*_node_filter_map)[u] || !(*_node_filter_map)[v]) {
7.323 -        return INVALID;
7.324 -      }
7.325 -      Edge edge = Parent::findEdge(u, v, prev);
7.326 -      while (edge != INVALID && !(*_edge_filter_map)[edge]) {
7.327 -        edge = Parent::findEdge(u, v, edge);
7.328 -      }
7.329 -      return edge;
7.330 -    }
7.331 -
7.332 -    template <typename _Value>
7.333 -    class NodeMap : public SubMapExtender<Adaptor,
7.334 -        typename Parent::template NodeMap<_Value> > {
7.335 -    public:
7.336 -      typedef _Value Value;
7.337 -      typedef SubMapExtender<Adaptor, typename Parent::
7.338 -                             template NodeMap<Value> > MapParent;
7.339 -
7.343 -	: MapParent(adaptor, value) {}
7.344 -
7.345 -    private:
7.346 -      NodeMap& operator=(const NodeMap& cmap) {
7.347 -	return operator=<NodeMap>(cmap);
7.348 -      }
7.349 -
7.350 -      template <typename CMap>
7.351 -      NodeMap& operator=(const CMap& cmap) {
7.352 -        MapParent::operator=(cmap);
7.353 -	return *this;
7.354 -      }
7.355 -    };
7.356 -
7.357 -    template <typename _Value>
7.358 -    class ArcMap : public SubMapExtender<Adaptor,
7.359 -	typename Parent::template ArcMap<_Value> > {
7.360 -    public:
7.361 -      typedef _Value Value;
7.362 -      typedef SubMapExtender<Adaptor, typename Parent::
7.363 -                             template ArcMap<Value> > MapParent;
7.364 -
7.368 -	: MapParent(adaptor, value) {}
7.369 -
7.370 -    private:
7.371 -      ArcMap& operator=(const ArcMap& cmap) {
7.372 -	return operator=<ArcMap>(cmap);
7.373 -      }
7.374 -
7.375 -      template <typename CMap>
7.376 -      ArcMap& operator=(const CMap& cmap) {
7.377 -        MapParent::operator=(cmap);
7.378 -	return *this;
7.379 -      }
7.380 -    };
7.381 -
7.382 -    template <typename _Value>
7.383 -    class EdgeMap : public SubMapExtender<Adaptor,
7.384 -        typename Parent::template EdgeMap<_Value> > {
7.385 -    public:
7.386 -      typedef _Value Value;
7.387 -      typedef SubMapExtender<Adaptor, typename Parent::
7.388 -                             template EdgeMap<Value> > MapParent;
7.389 -
7.392 -
7.394 -	: MapParent(adaptor, value) {}
7.395 -
7.396 -    private:
7.397 -      EdgeMap& operator=(const EdgeMap& cmap) {
7.398 -	return operator=<EdgeMap>(cmap);
7.399 -      }
7.400 -
7.401 -      template <typename CMap>
7.402 -      EdgeMap& operator=(const CMap& cmap) {
7.403 -        MapParent::operator=(cmap);
7.404 -	return *this;
7.405 -      }
7.406 -    };
7.407 -
7.408 -  };
7.409 -
7.410 -  template <typename _Graph, typename NodeFilterMap, typename EdgeFilterMap>
7.411 -  class SubGraphAdaptorBase<_Graph, NodeFilterMap, EdgeFilterMap, false>
7.412 -    : public GraphAdaptorBase<_Graph> {
7.413 -  public:
7.414 -    typedef _Graph Graph;
7.417 -  protected:
7.418 -    NodeFilterMap* _node_filter_map;
7.419 -    EdgeFilterMap* _edge_filter_map;
7.421 -			    _node_filter_map(0), _edge_filter_map(0) { }
7.422 -
7.423 -    void setNodeFilterMap(NodeFilterMap& node_filter_map) {
7.424 -      _node_filter_map=&node_filter_map;
7.425 -    }
7.426 -    void setEdgeFilterMap(EdgeFilterMap& edge_filter_map) {
7.427 -      _edge_filter_map=&edge_filter_map;
7.428 -    }
7.429 -
7.430 -  public:
7.431 -
7.432 -    typedef typename Parent::Node Node;
7.433 -    typedef typename Parent::Arc Arc;
7.434 -    typedef typename Parent::Edge Edge;
7.435 -
7.436 -    void first(Node& i) const {
7.437 -      Parent::first(i);
7.438 -      while (i!=INVALID && !(*_node_filter_map)[i]) Parent::next(i);
7.439 -    }
7.440 -
7.441 -    void first(Arc& i) const {
7.442 -      Parent::first(i);
7.443 -      while (i!=INVALID && !(*_edge_filter_map)[i]) Parent::next(i);
7.444 -    }
7.445 -
7.446 -    void first(Edge& i) const {
7.447 -      Parent::first(i);
7.448 -      while (i!=INVALID && !(*_edge_filter_map)[i]) Parent::next(i);
7.449 -    }
7.450 -
7.451 -    void firstIn(Arc& i, const Node& n) const {
7.452 -      Parent::firstIn(i, n);
7.453 -      while (i!=INVALID && !(*_edge_filter_map)[i]) Parent::nextIn(i);
7.454 -    }
7.455 -
7.456 -    void firstOut(Arc& i, const Node& n) const {
7.457 -      Parent::firstOut(i, n);
7.458 -      while (i!=INVALID && !(*_edge_filter_map)[i]) Parent::nextOut(i);
7.459 -    }
7.460 -
7.461 -    void firstInc(Edge& i, bool& d, const Node& n) const {
7.462 -      Parent::firstInc(i, d, n);
7.463 -      while (i!=INVALID && !(*_edge_filter_map)[i]) Parent::nextInc(i, d);
7.464 -    }
7.465 -
7.466 -    void next(Node& i) const {
7.467 -      Parent::next(i);
7.468 -      while (i!=INVALID && !(*_node_filter_map)[i]) Parent::next(i);
7.469 -    }
7.470 -    void next(Arc& i) const {
7.471 -      Parent::next(i);
7.472 -      while (i!=INVALID && !(*_edge_filter_map)[i]) Parent::next(i);
7.473 -    }
7.474 -    void next(Edge& i) const {
7.475 -      Parent::next(i);
7.476 -      while (i!=INVALID && !(*_edge_filter_map)[i]) Parent::next(i);
7.477 -    }
7.478 -    void nextIn(Arc& i) const {
7.479 -      Parent::nextIn(i);
7.480 -      while (i!=INVALID && !(*_edge_filter_map)[i]) Parent::nextIn(i);
7.481 -    }
7.482 -
7.483 -    void nextOut(Arc& i) const {
7.484 -      Parent::nextOut(i);
7.485 -      while (i!=INVALID && !(*_edge_filter_map)[i]) Parent::nextOut(i);
7.486 -    }
7.487 -    void nextInc(Edge& i, bool& d) const {
7.488 -      Parent::nextInc(i, d);
7.489 -      while (i!=INVALID && !(*_edge_filter_map)[i]) Parent::nextInc(i, d);
7.490 -    }
7.491 -
7.492 -    void hide(const Node& n) const { _node_filter_map->set(n, false); }
7.493 -    void hide(const Edge& e) const { _edge_filter_map->set(e, false); }
7.494 -
7.495 -    void unHide(const Node& n) const { _node_filter_map->set(n, true); }
7.496 -    void unHide(const Edge& e) const { _edge_filter_map->set(e, true); }
7.497 -
7.498 -    bool hidden(const Node& n) const { return !(*_node_filter_map)[n]; }
7.499 -    bool hidden(const Edge& e) const { return !(*_edge_filter_map)[e]; }
7.500 -
7.501 -    typedef False NodeNumTag;
7.502 -    typedef False EdgeNumTag;
7.503 -
7.504 -    typedef FindEdgeTagIndicator<Graph> FindEdgeTag;
7.505 -    Arc findArc(const Node& u, const Node& v,
7.506 -		  const Arc& prev = INVALID) {
7.507 -      Arc arc = Parent::findArc(u, v, prev);
7.508 -      while (arc != INVALID && !(*_edge_filter_map)[arc]) {
7.509 -        arc = Parent::findArc(u, v, arc);
7.510 -      }
7.511 -      return arc;
7.512 -    }
7.513 -    Edge findEdge(const Node& u, const Node& v,
7.514 -		  const Edge& prev = INVALID) {
7.515 -      Edge edge = Parent::findEdge(u, v, prev);
7.516 -      while (edge != INVALID && !(*_edge_filter_map)[edge]) {
7.517 -        edge = Parent::findEdge(u, v, edge);
7.518 -      }
7.519 -      return edge;
7.520 -    }
7.521 -
7.522 -    template <typename _Value>
7.523 -    class NodeMap : public SubMapExtender<Adaptor,
7.524 -        typename Parent::template NodeMap<_Value> > {
7.525 -    public:
7.526 -      typedef _Value Value;
7.527 -      typedef SubMapExtender<Adaptor, typename Parent::
7.528 -                             template NodeMap<Value> > MapParent;
7.529 -
7.533 -	: MapParent(adaptor, value) {}
7.534 -
7.535 -    private:
7.536 -      NodeMap& operator=(const NodeMap& cmap) {
7.537 -	return operator=<NodeMap>(cmap);
7.538 -      }
7.539 -
7.540 -      template <typename CMap>
7.541 -      NodeMap& operator=(const CMap& cmap) {
7.542 -        MapParent::operator=(cmap);
7.543 -	return *this;
7.544 -      }
7.545 -    };
7.546 -
7.547 -    template <typename _Value>
7.548 -    class ArcMap : public SubMapExtender<Adaptor,
7.549 -	typename Parent::template ArcMap<_Value> > {
7.550 -    public:
7.551 -      typedef _Value Value;
7.552 -      typedef SubMapExtender<Adaptor, typename Parent::
7.553 -                             template ArcMap<Value> > MapParent;
7.554 -
7.558 -	: MapParent(adaptor, value) {}
7.559 -
7.560 -    private:
7.561 -      ArcMap& operator=(const ArcMap& cmap) {
7.562 -	return operator=<ArcMap>(cmap);
7.563 -      }
7.564 -
7.565 -      template <typename CMap>
7.566 -      ArcMap& operator=(const CMap& cmap) {
7.567 -        MapParent::operator=(cmap);
7.568 -	return *this;
7.569 -      }
7.570 -    };
7.571 -
7.572 -    template <typename _Value>
7.573 -    class EdgeMap : public SubMapExtender<Adaptor,
7.574 -        typename Parent::template EdgeMap<_Value> > {
7.575 -    public:
7.576 -      typedef _Value Value;
7.577 -      typedef SubMapExtender<Adaptor, typename Parent::
7.578 -                             template EdgeMap<Value> > MapParent;
7.579 -
7.582 -
7.584 -	: MapParent(adaptor, value) {}
7.585 -
7.586 -    private:
7.587 -      EdgeMap& operator=(const EdgeMap& cmap) {
7.588 -	return operator=<EdgeMap>(cmap);
7.589 -      }
7.590 -
7.591 -      template <typename CMap>
7.592 -      EdgeMap& operator=(const CMap& cmap) {
7.593 -        MapParent::operator=(cmap);
7.594 -	return *this;
7.595 -      }
7.596 -    };
7.597 -
7.598 -  };
7.599 -
7.601 -  ///
7.602 -  /// \brief A graph adaptor for hiding nodes and edges from an
7.603 -  /// undirected graph.
7.604 -  ///
7.605 -  /// SubGraphAdaptor shows the graph with filtered node-set and
7.606 -  /// edge-set. If the \c checked parameter is true then it filters
7.607 -  /// the edge-set to do not get invalid edges which incident node is
7.608 -  /// filtered.
7.609 -  ///
7.610 -  /// If the \c checked template parameter is false then we have to
7.611 -  /// note that the node-iterator cares only the filter on the
7.612 -  /// node-set, and the edge-iterator cares only the filter on the
7.613 -  /// edge-set.  This way the edge-map should filter all arcs which
7.614 -  /// has filtered end node.
7.615 -  template<typename _Graph, typename NodeFilterMap,
7.616 -	   typename EdgeFilterMap, bool checked = true>
7.619 -    SubGraphAdaptorBase<_Graph, NodeFilterMap, EdgeFilterMap, checked> > {
7.620 -  public:
7.621 -    typedef _Graph Graph;
7.623 -      SubGraphAdaptorBase<_Graph, NodeFilterMap, EdgeFilterMap> > Parent;
7.624 -
7.625 -    typedef typename Parent::Node Node;
7.626 -    typedef typename Parent::Edge Edge;
7.627 -
7.628 -  protected:
7.630 -  public:
7.631 -
7.632 -    /// \brief Constructor
7.633 -    ///
7.634 -    /// Creates a sub-graph-adaptor for the given graph with
7.635 -    /// given node and edge map filters.
7.636 -    SubGraphAdaptor(Graph& _graph, NodeFilterMap& node_filter_map,
7.637 -		    EdgeFilterMap& edge_filter_map) {
7.638 -      setGraph(_graph);
7.639 -      setNodeFilterMap(node_filter_map);
7.640 -      setEdgeFilterMap(edge_filter_map);
7.641 -    }
7.642 -
7.643 -    /// \brief Hides the node of the graph
7.644 -    ///
7.645 -    /// This function hides \c n in the digraph, i.e. the iteration
7.646 -    /// jumps over it. This is done by simply setting the value of \c n
7.647 -    /// to be false in the corresponding node-map.
7.648 -    void hide(const Node& n) const { Parent::hide(n); }
7.649 -
7.650 -    /// \brief Hides the edge of the graph
7.651 -    ///
7.652 -    /// This function hides \c e in the digraph, i.e. the iteration
7.653 -    /// jumps over it. This is done by simply setting the value of \c e
7.654 -    /// to be false in the corresponding edge-map.
7.655 -    void hide(const Edge& e) const { Parent::hide(e); }
7.656 -
7.657 -    /// \brief Unhides the node of the graph
7.658 -    ///
7.659 -    /// The value of \c n is set to be true in the node-map which stores
7.660 -    /// hide information. If \c n was hidden previuosly, then it is shown
7.661 -    /// again
7.662 -    void unHide(const Node& n) const { Parent::unHide(n); }
7.663 -
7.664 -    /// \brief Unhides the edge of the graph
7.665 -    ///
7.666 -    /// The value of \c e is set to be true in the edge-map which stores
7.667 -    /// hide information. If \c e was hidden previuosly, then it is shown
7.668 -    /// again
7.669 -    void unHide(const Edge& e) const { Parent::unHide(e); }
7.670 -
7.671 -    /// \brief Returns true if \c n is hidden.
7.672 -    ///
7.673 -    /// Returns true if \c n is hidden.
7.674 -    ///
7.675 -    bool hidden(const Node& n) const { return Parent::hidden(n); }
7.676 -
7.677 -    /// \brief Returns true if \c e is hidden.
7.678 -    ///
7.679 -    /// Returns true if \c e is hidden.
7.680 -    ///
7.681 -    bool hidden(const Edge& e) const { return Parent::hidden(e); }
7.682 -  };
7.683 -
7.684 -  /// \brief Just gives back a sub-graph adaptor
7.685 -  ///
7.686 -  /// Just gives back a sub-graph adaptor
7.687 -  template<typename Graph, typename NodeFilterMap, typename ArcFilterMap>
7.688 -  SubGraphAdaptor<const Graph, NodeFilterMap, ArcFilterMap>
7.690 -                   NodeFilterMap& nfm, ArcFilterMap& efm) {
7.691 -    return SubGraphAdaptor<const Graph, NodeFilterMap, ArcFilterMap>
7.692 -      (graph, nfm, efm);
7.693 -  }
7.694 -
7.695 -  template<typename Graph, typename NodeFilterMap, typename ArcFilterMap>
7.696 -  SubGraphAdaptor<const Graph, const NodeFilterMap, ArcFilterMap>
7.698 -                   NodeFilterMap& nfm, ArcFilterMap& efm) {
7.699 -    return SubGraphAdaptor<const Graph, const NodeFilterMap, ArcFilterMap>
7.700 -      (graph, nfm, efm);
7.701 -  }
7.702 -
7.703 -  template<typename Graph, typename NodeFilterMap, typename ArcFilterMap>
7.704 -  SubGraphAdaptor<const Graph, NodeFilterMap, const ArcFilterMap>
7.706 -                   NodeFilterMap& nfm, ArcFilterMap& efm) {
7.707 -    return SubGraphAdaptor<const Graph, NodeFilterMap, const ArcFilterMap>
7.708 -      (graph, nfm, efm);
7.709 -  }
7.710 -
7.711 -  template<typename Graph, typename NodeFilterMap, typename ArcFilterMap>
7.712 -  SubGraphAdaptor<const Graph, const NodeFilterMap, const ArcFilterMap>
7.714 -                   NodeFilterMap& nfm, ArcFilterMap& efm) {
7.715 -    return SubGraphAdaptor<const Graph, const NodeFilterMap,
7.716 -      const ArcFilterMap>(graph, nfm, efm);
7.717 -  }
7.718 -
7.720 -  ///
7.721 -  /// \brief An adaptor for hiding nodes from an graph.
7.722 -  ///
7.723 -  /// An adaptor for hiding nodes from an graph.  This
7.724 -  /// adaptor specializes SubGraphAdaptor in the way that only the
7.725 -  /// node-set can be filtered. In usual case the checked parameter is
7.726 -  /// true, we get the induced subgraph. But if the checked parameter
7.727 -  /// is false then we can filter only isolated nodes.
7.728 -  template<typename _Graph, typename _NodeFilterMap, bool checked = true>
7.731 -			   ConstMap<typename _Graph::Edge, bool>, checked> {
7.732 -  public:
7.733 -    typedef _Graph Graph;
7.734 -    typedef _NodeFilterMap NodeFilterMap;
7.736 -			    ConstMap<typename Graph::Edge, bool> > Parent;
7.737 -
7.738 -    typedef typename Parent::Node Node;
7.739 -  protected:
7.740 -    ConstMap<typename Graph::Edge, bool> const_true_map;
7.741 -
7.742 -    NodeSubGraphAdaptor() : const_true_map(true) {
7.743 -      Parent::setEdgeFilterMap(const_true_map);
7.744 -    }
7.745 -
7.746 -  public:
7.747 -
7.748 -    /// \brief Constructor
7.749 -    ///
7.750 -    /// Creates a node-sub-graph-adaptor for the given graph with
7.751 -    /// given node map filters.
7.752 -    NodeSubGraphAdaptor(Graph& _graph, NodeFilterMap& node_filter_map) :
7.753 -      Parent(), const_true_map(true) {
7.754 -      Parent::setGraph(_graph);
7.755 -      Parent::setNodeFilterMap(node_filter_map);
7.756 -      Parent::setEdgeFilterMap(const_true_map);
7.757 -    }
7.758 -
7.759 -    /// \brief Hides the node of the graph
7.760 -    ///
7.761 -    /// This function hides \c n in the digraph, i.e. the iteration
7.762 -    /// jumps over it. This is done by simply setting the value of \c n
7.763 -    /// to be false in the corresponding node-map.
7.764 -    void hide(const Node& n) const { Parent::hide(n); }
7.765 -
7.766 -    /// \brief Unhides the node of the graph
7.767 -    ///
7.768 -    /// The value of \c n is set to be true in the node-map which stores
7.769 -    /// hide information. If \c n was hidden previuosly, then it is shown
7.770 -    /// again
7.771 -    void unHide(const Node& n) const { Parent::unHide(n); }
7.772 -
7.773 -    /// \brief Returns true if \c n is hidden.
7.774 -    ///
7.775 -    /// Returns true if \c n is hidden.
7.776 -    ///
7.777 -    bool hidden(const Node& n) const { return Parent::hidden(n); }
7.778 -
7.779 -  };
7.780 -
7.781 -  /// \brief Just gives back a node-sub-graph adaptor
7.782 -  ///
7.783 -  /// Just gives back a node-sub-graph adaptor
7.784 -  template<typename Graph, typename NodeFilterMap>
7.786 -  nodeSubGraphAdaptor(const Graph& graph, NodeFilterMap& nfm) {
7.787 -    return NodeSubGraphAdaptor<const Graph, NodeFilterMap>(graph, nfm);
7.788 -  }
7.789 -
7.790 -  template<typename Graph, typename NodeFilterMap>
7.791 -  NodeSubGraphAdaptor<const Graph, const NodeFilterMap>
7.792 -  nodeSubGraphAdaptor(const Graph& graph, const NodeFilterMap& nfm) {
7.793 -    return NodeSubGraphAdaptor<const Graph, const NodeFilterMap>(graph, nfm);
7.794 -  }
7.795 -
7.797 -  ///
7.798 -  /// \brief An adaptor for hiding edges from an graph.
7.799 -  ///
7.800 -  /// \warning Graph adaptors are in even more experimental state
7.801 -  /// than the other parts of the lib. Use them at you own risk.
7.802 -  ///
7.803 -  /// An adaptor for hiding edges from an graph.
7.805 -  /// only the arc-set
7.806 -  /// can be filtered.
7.807 -  template<typename _Graph, typename _EdgeFilterMap>
7.809 -    public SubGraphAdaptor<_Graph, ConstMap<typename _Graph::Node,bool>,
7.810 -                           _EdgeFilterMap, false> {
7.811 -  public:
7.812 -    typedef _Graph Graph;
7.813 -    typedef _EdgeFilterMap EdgeFilterMap;
7.814 -    typedef SubGraphAdaptor<Graph, ConstMap<typename Graph::Node,bool>,
7.815 -			    EdgeFilterMap, false> Parent;
7.816 -    typedef typename Parent::Edge Edge;
7.817 -  protected:
7.818 -    ConstMap<typename Graph::Node, bool> const_true_map;
7.819 -
7.820 -    EdgeSubGraphAdaptor() : const_true_map(true) {
7.821 -      Parent::setNodeFilterMap(const_true_map);
7.822 -    }
7.823 -
7.824 -  public:
7.825 -
7.826 -    /// \brief Constructor
7.827 -    ///
7.828 -    /// Creates a edge-sub-graph-adaptor for the given graph with
7.829 -    /// given node map filters.
7.830 -    EdgeSubGraphAdaptor(Graph& _graph, EdgeFilterMap& edge_filter_map) :
7.831 -      Parent(), const_true_map(true) {
7.832 -      Parent::setGraph(_graph);
7.833 -      Parent::setNodeFilterMap(const_true_map);
7.834 -      Parent::setEdgeFilterMap(edge_filter_map);
7.835 -    }
7.836 -
7.837 -    /// \brief Hides the edge of the graph
7.838 -    ///
7.839 -    /// This function hides \c e in the digraph, i.e. the iteration
7.840 -    /// jumps over it. This is done by simply setting the value of \c e
7.841 -    /// to be false in the corresponding edge-map.
7.842 -    void hide(const Edge& e) const { Parent::hide(e); }
7.843 -
7.844 -    /// \brief Unhides the edge of the graph
7.845 -    ///
7.846 -    /// The value of \c e is set to be true in the edge-map which stores
7.847 -    /// hide information. If \c e was hidden previuosly, then it is shown
7.848 -    /// again
7.849 -    void unHide(const Edge& e) const { Parent::unHide(e); }
7.850 -
7.851 -    /// \brief Returns true if \c e is hidden.
7.852 -    ///
7.853 -    /// Returns true if \c e is hidden.
7.854 -    ///
7.855 -    bool hidden(const Edge& e) const { return Parent::hidden(e); }
7.856 -
7.857 -  };
7.858 -
7.859 -  /// \brief Just gives back an edge-sub-graph adaptor
7.860 -  ///
7.861 -  /// Just gives back an edge-sub-graph adaptor
7.862 -  template<typename Graph, typename EdgeFilterMap>
7.864 -  edgeSubGraphAdaptor(const Graph& graph, EdgeFilterMap& efm) {
7.865 -    return EdgeSubGraphAdaptor<const Graph, EdgeFilterMap>(graph, efm);
7.866 -  }
7.867 -
7.868 -  template<typename Graph, typename EdgeFilterMap>
7.869 -  EdgeSubGraphAdaptor<const Graph, const EdgeFilterMap>
7.870 -  edgeSubGraphAdaptor(const Graph& graph, const EdgeFilterMap& efm) {
7.871 -    return EdgeSubGraphAdaptor<const Graph, const EdgeFilterMap>(graph, efm);
7.872 -  }
7.873 -
7.874 -  template <typename _Graph, typename _DirectionMap>
7.876 -  public:
7.877 -
7.878 -    typedef _Graph Graph;
7.879 -    typedef _DirectionMap DirectionMap;
7.880 -
7.881 -    typedef typename Graph::Node Node;
7.882 -    typedef typename Graph::Edge Arc;
7.883 -
7.884 -    /// \brief Reverse arc
7.885 -    ///
7.886 -    /// It reverse the given arc. It simply negate the direction in the map.
7.887 -    void reverseArc(const Arc& arc) {
7.888 -      _direction->set(arc, !(*_direction)[arc]);
7.889 -    }
7.890 -
7.891 -    void first(Node& i) const { _graph->first(i); }
7.892 -    void first(Arc& i) const { _graph->first(i); }
7.893 -    void firstIn(Arc& i, const Node& n) const {
7.894 -      bool d;
7.895 -      _graph->firstInc(i, d, n);
7.896 -      while (i != INVALID && d == (*_direction)[i]) _graph->nextInc(i, d);
7.897 -    }
7.898 -    void firstOut(Arc& i, const Node& n ) const {
7.899 -      bool d;
7.900 -      _graph->firstInc(i, d, n);
7.901 -      while (i != INVALID && d != (*_direction)[i]) _graph->nextInc(i, d);
7.902 -    }
7.903 -
7.904 -    void next(Node& i) const { _graph->next(i); }
7.905 -    void next(Arc& i) const { _graph->next(i); }
7.906 -    void nextIn(Arc& i) const {
7.907 -      bool d = !(*_direction)[i];
7.908 -      _graph->nextInc(i, d);
7.909 -      while (i != INVALID && d == (*_direction)[i]) _graph->nextInc(i, d);
7.910 -    }
7.911 -    void nextOut(Arc& i) const {
7.912 -      bool d = (*_direction)[i];
7.913 -      _graph->nextInc(i, d);
7.914 -      while (i != INVALID && d != (*_direction)[i]) _graph->nextInc(i, d);
7.915 -    }
7.916 -
7.917 -    Node source(const Arc& e) const {
7.918 -      return (*_direction)[e] ? _graph->u(e) : _graph->v(e);
7.919 -    }
7.920 -    Node target(const Arc& e) const {
7.921 -      return (*_direction)[e] ? _graph->v(e) : _graph->u(e);
7.922 -    }
7.923 -
7.924 -    typedef NodeNumTagIndicator<Graph> NodeNumTag;
7.925 -    int nodeNum() const { return _graph->nodeNum(); }
7.926 -
7.927 -    typedef EdgeNumTagIndicator<Graph> EdgeNumTag;
7.928 -    int arcNum() const { return _graph->edgeNum(); }
7.929 -
7.930 -    typedef FindEdgeTagIndicator<Graph> FindEdgeTag;
7.931 -    Arc findArc(const Node& u, const Node& v,
7.932 -		  const Arc& prev = INVALID) {
7.933 -      Arc arc = prev;
7.934 -      bool d = arc == INVALID ? true : (*_direction)[arc];
7.935 -      if (d) {
7.936 -        arc = _graph->findEdge(u, v, arc);
7.937 -        while (arc != INVALID && !(*_direction)[arc]) {
7.938 -          _graph->findEdge(u, v, arc);
7.939 -        }
7.940 -        if (arc != INVALID) return arc;
7.941 -      }
7.942 -      _graph->findEdge(v, u, arc);
7.943 -      while (arc != INVALID && (*_direction)[arc]) {
7.944 -        _graph->findEdge(u, v, arc);
7.945 -      }
7.946 -      return arc;
7.947 -    }
7.948 -
7.951 -    }
7.952 -
7.953 -    Arc addArc(const Node& u, const Node& v) {
7.954 -      Arc arc = _graph->addArc(u, v);
7.955 -      _direction->set(arc, _graph->source(arc) == u);
7.956 -      return arc;
7.957 -    }
7.958 -
7.959 -    void erase(const Node& i) { _graph->erase(i); }
7.960 -    void erase(const Arc& i) { _graph->erase(i); }
7.961 -
7.962 -    void clear() { _graph->clear(); }
7.963 -
7.964 -    int id(const Node& v) const { return _graph->id(v); }
7.965 -    int id(const Arc& e) const { return _graph->id(e); }
7.966 -
7.967 -    Node nodeFromId(int idx) const { return _graph->nodeFromId(idx); }
7.968 -    Arc arcFromId(int idx) const { return _graph->edgeFromId(idx); }
7.969 -
7.970 -    int maxNodeId() const { return _graph->maxNodeId(); }
7.971 -    int maxArcId() const { return _graph->maxEdgeId(); }
7.972 -
7.973 -    typedef typename ItemSetTraits<Graph, Node>::ItemNotifier NodeNotifier;
7.974 -    NodeNotifier& notifier(Node) const { return _graph->notifier(Node()); }
7.975 -
7.976 -    typedef typename ItemSetTraits<Graph, Arc>::ItemNotifier ArcNotifier;
7.977 -    ArcNotifier& notifier(Arc) const { return _graph->notifier(Arc()); }
7.978 -
7.979 -    template <typename _Value>
7.980 -    class NodeMap : public _Graph::template NodeMap<_Value> {
7.981 -    public:
7.982 -
7.983 -      typedef typename _Graph::template NodeMap<_Value> Parent;
7.984 -
7.987 -
7.989 -	: Parent(*adapter._graph, value) {}
7.990 -
7.991 -    private:
7.992 -      NodeMap& operator=(const NodeMap& cmap) {
7.993 -        return operator=<NodeMap>(cmap);
7.994 -      }
7.995 -
7.996 -      template <typename CMap>
7.997 -      NodeMap& operator=(const CMap& cmap) {
7.998 -        Parent::operator=(cmap);
7.999 -        return *this;
7.1000 -      }
7.1001 -
7.1002 -    };
7.1003 -
7.1004 -    template <typename _Value>
7.1005 -    class ArcMap : public _Graph::template EdgeMap<_Value> {
7.1006 -    public:
7.1007 -
7.1008 -      typedef typename Graph::template EdgeMap<_Value> Parent;
7.1009 -
7.1011 -	: Parent(*adapter._graph) { }
7.1012 -
7.1014 -	: Parent(*adapter._graph, value) { }
7.1015 -
7.1016 -    private:
7.1017 -      ArcMap& operator=(const ArcMap& cmap) {
7.1018 -        return operator=<ArcMap>(cmap);
7.1019 -      }
7.1020 -
7.1021 -      template <typename CMap>
7.1022 -      ArcMap& operator=(const CMap& cmap) {
7.1023 -        Parent::operator=(cmap);
7.1024 -        return *this;
7.1025 -      }
7.1026 -    };
7.1027 -
7.1028 -
7.1029 -
7.1030 -  protected:
7.1031 -    Graph* _graph;
7.1032 -    DirectionMap* _direction;
7.1033 -
7.1034 -    void setDirectionMap(DirectionMap& direction) {
7.1035 -      _direction = &direction;
7.1036 -    }
7.1037 -
7.1038 -    void setGraph(Graph& graph) {
7.1039 -      _graph = &graph;
7.1040 -    }
7.1041 -
7.1042 -  };
7.1043 -
7.1044 -
7.1046 -  ///
7.1047 -  /// \brief A directed graph is made from an graph by an adaptor
7.1048 -  ///
7.1049 -  /// This adaptor gives a direction for each edge in the undirected
7.1050 -  /// graph. The direction of the arcs stored in the
7.1051 -  /// DirectionMap. This map is a bool map on the edges. If
7.1052 -  /// the edge is mapped to true then the direction of the directed
7.1053 -  /// arc will be the same as the default direction of the edge. The
7.1054 -  /// arcs can be easily reverted by the \ref
7.1055 -  /// DirGraphAdaptorBase::reverseArc "reverseArc()" member in the
7.1057 -  ///
7.1058 -  /// It can be used to solve orientation problems on directed graphs.
7.1059 -  /// For example how can we orient an graph to get the minimum
7.1060 -  /// number of strongly connected components. If we orient the arcs with
7.1061 -  /// the dfs algorithm out from the source then we will get such an
7.1062 -  /// orientation.
7.1063 -  ///
7.1064 -  /// We use the \ref DfsVisitor "visitor" interface of the
7.1065 -  /// \ref DfsVisit "dfs" algorithm:
7.1066 -  ///\code
7.1067 -  /// template <typename DirMap>
7.1068 -  /// class OrientVisitor : public DfsVisitor<Graph> {
7.1069 -  /// public:
7.1070 -  ///
7.1071 -  ///   OrientVisitor(const Graph& graph, DirMap& dirMap)
7.1072 -  ///     : _graph(graph), _dirMap(dirMap), _processed(graph, false) {}
7.1073 -  ///
7.1074 -  ///   void discover(const Arc& arc) {
7.1075 -  ///     _processed.set(arc, true);
7.1076 -  ///     _dirMap.set(arc, _graph.direction(arc));
7.1077 -  ///   }
7.1078 -  ///
7.1079 -  ///   void examine(const Arc& arc) {
7.1080 -  ///     if (_processed[arc]) return;
7.1081 -  ///     _processed.set(arc, true);
7.1082 -  ///     _dirMap.set(arc, _graph.direction(arc));
7.1083 -  ///   }
7.1084 -  ///
7.1085 -  /// private:
7.1086 -  ///   const Graph& _graph;
7.1087 -  ///   DirMap& _dirMap;
7.1088 -  ///   Graph::EdgeMap<bool> _processed;
7.1089 -  /// };
7.1090 -  ///\endcode
7.1091 -  ///
7.1092 -  /// And now we can use the orientation:
7.1093 -  ///\code
7.1094 -  /// Graph::EdgeMap<bool> dmap(graph);
7.1095 -  ///
7.1096 -  /// typedef OrientVisitor<Graph::EdgeMap<bool> > Visitor;
7.1097 -  /// Visitor visitor(graph, dmap);
7.1098 -  ///
7.1099 -  /// DfsVisit<Graph, Visitor> dfs(graph, visitor);
7.1100 -  ///
7.1101 -  /// dfs.run();
7.1102 -  ///
7.1103 -  /// typedef DirGraphAdaptor<Graph> DGraph;
7.1104 -  /// DGraph dgraph(graph, dmap);
7.1105 -  ///
7.1106 -  /// LEMON_ASSERT(countStronglyConnectedComponents(dgraph) ==
7.1107 -  ///              countBiArcConnectedComponents(graph), "Wrong Orientation");
7.1108 -  ///\endcode
7.1109 -  ///
7.1110 -  /// The number of the bi-connected components is a lower bound for
7.1111 -  /// the number of the strongly connected components in the directed
7.1112 -  /// graph because if we contract the bi-connected components to
7.1113 -  /// nodes we will get a tree therefore we cannot orient arcs in
7.1114 -  /// both direction between bi-connected components. In the other way
7.1115 -  /// the algorithm will orient one component to be strongly
7.1116 -  /// connected. The two relations proof that the assertion will
7.1117 -  /// be always true and the found solution is optimal.
7.1118 -  ///
7.1121 -  template<typename _Graph,
7.1122 -           typename DirectionMap = typename _Graph::template EdgeMap<bool> >
7.1125 -  public:
7.1126 -    typedef _Graph Graph;
7.1128 -      DirGraphAdaptorBase<_Graph, DirectionMap> > Parent;
7.1129 -    typedef typename Parent::Arc Arc;
7.1130 -  protected:
7.1132 -  public:
7.1133 -
7.1134 -    /// \brief Constructor of the adaptor
7.1135 -    ///
7.1136 -    /// Constructor of the adaptor
7.1137 -    DirGraphAdaptor(Graph& graph, DirectionMap& direction) {
7.1138 -      setGraph(graph);
7.1139 -      setDirectionMap(direction);
7.1140 -    }
7.1141 -
7.1142 -    /// \brief Reverse arc
7.1143 -    ///
7.1144 -    /// It reverse the given arc. It simply negate the direction in the map.
7.1145 -    void reverseArc(const Arc& a) {
7.1146 -      Parent::reverseArc(a);
7.1147 -    }
7.1148 -  };
7.1149 -
7.1150 -  /// \brief Just gives back a DirGraphAdaptor
7.1151 -  ///
7.1152 -  /// Just gives back a DirGraphAdaptor
7.1153 -  template<typename Graph, typename DirectionMap>
7.1155 -  dirGraphAdaptor(const Graph& graph, DirectionMap& dm) {
7.1156 -    return DirGraphAdaptor<const Graph, DirectionMap>(graph, dm);
7.1157 -  }
7.1158 -
7.1159 -  template<typename Graph, typename DirectionMap>
7.1160 -  DirGraphAdaptor<const Graph, const DirectionMap>
7.1161 -  dirGraphAdaptor(const Graph& graph, const DirectionMap& dm) {
7.1162 -    return DirGraphAdaptor<const Graph, const DirectionMap>(graph, dm);
7.1163 -  }
7.1164 -
7.1165 -}
7.1166 -
7.1167 -#endif

     8.1 --- a/test/graph_adaptor_test.cc	Sun Nov 30 19:00:30 2008 +0100
8.2 +++ b/test/graph_adaptor_test.cc	Sun Nov 30 19:18:32 2008 +0100
8.3 @@ -1,6 +1,6 @@
8.4 -/* -*- C++ -*-
8.5 +/* -*- mode: C++; indent-tabs-mode: nil; -*-
8.6   *
8.7 - * This file is a part of LEMON, a generic C++ optimization library
8.8 + * This file is a part of LEMON, a generic C++ optimization library.
8.9   *
8.11   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
8.12 @@ -25,8 +25,7 @@
8.13  #include<lemon/concepts/digraph.h>
8.14  #include<lemon/concepts/graph.h>
8.15
8.19
8.20  #include <limits>
8.21  #include <lemon/bfs.h>
8.22 @@ -37,11 +36,11 @@
8.23
8.24  using namespace lemon;
8.25
8.28 +void checkReverseDigraph() {
8.29 +  checkConcept<concepts::Digraph, ReverseDigraph<concepts::Digraph> >();
8.30
8.31    typedef ListDigraph Digraph;
8.34
8.35    Digraph digraph;
8.37 @@ -53,7 +52,7 @@
8.38    Digraph::Arc a1 = digraph.addArc(n1, n2);
8.39    Digraph::Arc a2 = digraph.addArc(n1, n3);
8.40    Digraph::Arc a3 = digraph.addArc(n2, n3);
8.41 -
8.42 +
8.46 @@ -78,16 +77,16 @@
8.47    }
8.48  }
8.49
8.51 -  checkConcept<concepts::Digraph,
8.53 +void checkSubDigraph() {
8.54 +  checkConcept<concepts::Digraph,
8.55 +    SubDigraph<concepts::Digraph,
8.56      concepts::Digraph::NodeMap<bool>,
8.57      concepts::Digraph::ArcMap<bool> > >();
8.58
8.59    typedef ListDigraph Digraph;
8.60    typedef Digraph::NodeMap<bool> NodeFilter;
8.61    typedef Digraph::ArcMap<bool> ArcFilter;
8.63 +  typedef SubDigraph<Digraph, NodeFilter, ArcFilter> Adaptor;
8.64
8.65    Digraph digraph;
8.66    NodeFilter node_filter(digraph);
8.67 @@ -123,7 +122,7 @@
8.70
8.71 -  arc_filter[a2] = false;
8.72 +  arc_filter[a2] = false;
8.73
8.76 @@ -143,7 +142,7 @@
8.79
8.80 -  node_filter[n1] = false;
8.81 +  node_filter[n1] = false;
8.82
8.85 @@ -175,14 +174,14 @@
8.87  }
8.88
8.90 -  checkConcept<concepts::Digraph,
8.92 +void checkFilterNodes1() {
8.93 +  checkConcept<concepts::Digraph,
8.94 +    FilterNodes<concepts::Digraph,
8.95        concepts::Digraph::NodeMap<bool> > >();
8.96
8.97    typedef ListDigraph Digraph;
8.98    typedef Digraph::NodeMap<bool> NodeFilter;
8.100 +  typedef FilterNodes<Digraph, NodeFilter> Adaptor;
8.101
8.102    Digraph digraph;
8.103    NodeFilter node_filter(digraph);
8.104 @@ -216,7 +215,7 @@
8.107
8.108 -  node_filter[n1] = false;
8.109 +  node_filter[n1] = false;
8.110
8.113 @@ -247,14 +246,14 @@
8.115  }
8.116
8.118 -  checkConcept<concepts::Digraph,
8.120 +void checkFilterArcs() {
8.121 +  checkConcept<concepts::Digraph,
8.122 +    FilterArcs<concepts::Digraph,
8.123      concepts::Digraph::ArcMap<bool> > >();
8.124
8.125    typedef ListDigraph Digraph;
8.126    typedef Digraph::ArcMap<bool> ArcFilter;
8.128 +  typedef FilterArcs<Digraph, ArcFilter> Adaptor;
8.129
8.130    Digraph digraph;
8.131    ArcFilter arc_filter(digraph);
8.132 @@ -288,7 +287,7 @@
8.135
8.136 -  arc_filter[a2] = false;
8.137 +  arc_filter[a2] = false;
8.138
8.141 @@ -321,11 +320,11 @@
8.143  }
8.144
8.147 +void checkUndirector() {
8.148 +  checkConcept<concepts::Graph, Undirector<concepts::Digraph> >();
8.149
8.150    typedef ListDigraph Digraph;
8.153
8.154    Digraph digraph;
8.156 @@ -337,7 +336,7 @@
8.157    Digraph::Arc a1 = digraph.addArc(n1, n2);
8.158    Digraph::Arc a2 = digraph.addArc(n1, n3);
8.159    Digraph::Arc a3 = digraph.addArc(n2, n3);
8.160 -
8.161 +
8.165 @@ -371,15 +370,15 @@
8.166
8.167  }
8.168
8.170 -  checkConcept<concepts::Digraph,
8.172 -    concepts::Digraph::ArcMap<int>,
8.173 +void checkResidual() {
8.174 +  checkConcept<concepts::Digraph,
8.175 +    Residual<concepts::Digraph,
8.176 +    concepts::Digraph::ArcMap<int>,
8.177      concepts::Digraph::ArcMap<int> > >();
8.178
8.179    typedef ListDigraph Digraph;
8.180    typedef Digraph::ArcMap<int> IntArcMap;
8.182 +  typedef Residual<Digraph, IntArcMap> Adaptor;
8.183
8.184    Digraph digraph;
8.185    IntArcMap capacity(digraph), flow(digraph);
8.186 @@ -407,7 +406,7 @@
8.188      flow[a] = 0;
8.189    }
8.190 -
8.191 +
8.195 @@ -425,7 +424,7 @@
8.197      flow[a] = capacity[a] / 2;
8.198    }
8.199 -
8.200 +
8.204 @@ -449,7 +448,7 @@
8.206      flow[a] = capacity[a];
8.207    }
8.208 -
8.209 +
8.213 @@ -470,17 +469,18 @@
8.214
8.215    int flow_value = 0;
8.216    while (true) {
8.217 -
8.218 +
8.220      bfs.run(n1, n4);
8.221 -
8.222 +
8.223      if (!bfs.reached(n4)) break;
8.224
8.226 -
8.227 +
8.228      int min = std::numeric_limits<int>::max();
8.229      for (Path<Adaptor>::ArcIt a(p); a != INVALID; ++a) {
8.231 +      if (adaptor.residualCapacity(a) < min)
8.233      }
8.234
8.235      for (Path<Adaptor>::ArcIt a(p); a != INVALID; ++a) {
8.236 @@ -493,11 +493,11 @@
8.237
8.238  }
8.239
8.242 +void checkSplitNodes() {
8.243 +  checkConcept<concepts::Digraph, SplitNodes<concepts::Digraph> >();
8.244
8.245    typedef ListDigraph Digraph;
8.248
8.249    Digraph digraph;
8.251 @@ -509,7 +509,7 @@
8.252    Digraph::Arc a1 = digraph.addArc(n1, n2);
8.253    Digraph::Arc a2 = digraph.addArc(n1, n3);
8.254    Digraph::Arc a3 = digraph.addArc(n2, n3);
8.255 -
8.256 +
8.260 @@ -530,17 +530,17 @@
8.261
8.264 -
8.265 +
8.268
8.271        Digraph::Arc oa = a;
8.273 -	    "Wrong split");
8.275 -	    "Wrong split");
8.277 +            "Wrong split");
8.279 +            "Wrong split");
8.280      } else {
8.281        Digraph::Node on = a;
8.283 @@ -549,16 +549,16 @@
8.284    }
8.285  }
8.286
8.288 -  checkConcept<concepts::Graph,
8.290 +void checkSubGraph() {
8.291 +  checkConcept<concepts::Graph,
8.292 +    SubGraph<concepts::Graph,
8.293      concepts::Graph::NodeMap<bool>,
8.294      concepts::Graph::EdgeMap<bool> > >();
8.295
8.296    typedef ListGraph Graph;
8.297    typedef Graph::NodeMap<bool> NodeFilter;
8.298    typedef Graph::EdgeMap<bool> EdgeFilter;
8.300 +  typedef SubGraph<Graph, NodeFilter, EdgeFilter> Adaptor;
8.301
8.302    Graph graph;
8.303    NodeFilter node_filter(graph);
8.304 @@ -607,7 +607,7 @@
8.307
8.308 -  edge_filter[e2] = false;
8.309 +  edge_filter[e2] = false;
8.310
8.313 @@ -638,7 +638,7 @@
8.316
8.317 -  node_filter[n1] = false;
8.318 +  node_filter[n1] = false;
8.319
8.322 @@ -684,14 +684,14 @@
8.324  }
8.325
8.327 -  checkConcept<concepts::Graph,
8.329 +void checkFilterNodes2() {
8.330 +  checkConcept<concepts::Graph,
8.331 +    FilterNodes<concepts::Graph,
8.332        concepts::Graph::NodeMap<bool> > >();
8.333
8.334    typedef ListGraph Graph;
8.335    typedef Graph::NodeMap<bool> NodeFilter;
8.337 +  typedef FilterNodes<Graph, NodeFilter> Adaptor;
8.338
8.339    Graph graph;
8.340    NodeFilter node_filter(graph);
8.341 @@ -738,7 +738,7 @@
8.344
8.345 -  node_filter[n1] = false;
8.346 +  node_filter[n1] = false;
8.347
8.350 @@ -783,14 +783,14 @@
8.352  }
8.353
8.355 -  checkConcept<concepts::Graph,
8.357 +void checkFilterEdges() {
8.358 +  checkConcept<concepts::Graph,
8.359 +    FilterEdges<concepts::Graph,
8.360      concepts::Graph::EdgeMap<bool> > >();
8.361
8.362    typedef ListGraph Graph;
8.363    typedef Graph::EdgeMap<bool> EdgeFilter;
8.365 +  typedef FilterEdges<Graph, EdgeFilter> Adaptor;
8.366
8.367    Graph graph;
8.368    EdgeFilter edge_filter(graph);
8.369 @@ -837,7 +837,7 @@
8.372
8.373 -  edge_filter[e2] = false;
8.374 +  edge_filter[e2] = false;
8.375
8.378 @@ -885,13 +885,13 @@
8.380  }
8.381
8.383 -  checkConcept<concepts::Digraph,
8.384 -    DirGraphAdaptor<concepts::Graph, concepts::Graph::EdgeMap<bool> > >();
8.385 +void checkOrienter() {
8.386 +  checkConcept<concepts::Digraph,
8.387 +    Orienter<concepts::Graph, concepts::Graph::EdgeMap<bool> > >();
8.388
8.389    typedef ListGraph Graph;
8.390    typedef ListGraph::EdgeMap<bool> DirMap;