1.1 --- a/doc/groups.dox Tue Dec 02 11:01:48 2008 +0000
1.2 +++ b/doc/groups.dox Tue Dec 02 15:33:22 2008 +0000
1.3 @@ -62,6 +62,79 @@
1.4 */
1.5
1.6 /**
1.7 +@defgroup graph_adaptors Adaptor Classes for graphs
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.64 +RevGraphAdaptor has constructor
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.73 + RevGraphAdaptor<const ListDigraph> rg(g);
1.74 + return algorithm2(rg);
1.75 +}
1.76 +\endcode
1.77 +*/
1.78 +
1.79 +/**
1.80 @defgroup semi_adaptors Semi-Adaptor Classes for Graphs
1.81 @ingroup graphs
1.82 \brief Graph types between real graphs and graph adaptors.
2.1 --- a/lemon/Makefile.am Tue Dec 02 11:01:48 2008 +0000
2.2 +++ b/lemon/Makefile.am Tue Dec 02 15:33:22 2008 +0000
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 \
2.11 @@ -60,10 +61,12 @@
2.12 lemon/bits/bezier.h \
2.13 lemon/bits/default_map.h \
2.14 lemon/bits/enable_if.h \
2.15 + lemon/bits/graph_adaptor_extender.h \
2.16 lemon/bits/graph_extender.h \
2.17 lemon/bits/map_extender.h \
2.18 lemon/bits/path_dump.h \
2.19 lemon/bits/traits.h \
2.20 + lemon/bits/variant.h \
2.21 lemon/bits/vector_map.h
2.22
2.23 concept_HEADERS += \
3.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
3.2 +++ b/lemon/adaptors.h Tue Dec 02 15:33:22 2008 +0000
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 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
4.2 +++ b/lemon/bits/graph_adaptor_extender.h Tue Dec 02 15:33:22 2008 +0000
4.3 @@ -0,0 +1,403 @@
4.4 +/* -*- mode: C++; indent-tabs-mode: nil; -*-
4.5 + *
4.6 + * This file is a part of LEMON, a generic C++ optimization library.
4.7 + *
4.8 + * Copyright (C) 2003-2008
4.9 + * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
4.10 + * (Egervary Research Group on Combinatorial Optimization, EGRES).
4.11 + *
4.12 + * Permission to use, modify and distribute this software is granted
4.13 + * provided that this copyright notice appears in all copies. For
4.14 + * precise terms see the accompanying LICENSE file.
4.15 + *
4.16 + * This software is provided "AS IS" with no warranty of any kind,
4.17 + * express or implied, and with no claim as to its suitability for any
4.18 + * purpose.
4.19 + *
4.20 + */
4.21 +
4.22 +#ifndef LEMON_BITS_GRAPH_ADAPTOR_EXTENDER_H
4.23 +#define LEMON_BITS_GRAPH_ADAPTOR_EXTENDER_H
4.24 +
4.25 +#include <lemon/core.h>
4.26 +#include <lemon/error.h>
4.27 +
4.28 +#include <lemon/bits/default_map.h>
4.29 +
4.30 +namespace lemon {
4.31 +
4.32 + template <typename _Digraph>
4.33 + class DigraphAdaptorExtender : public _Digraph {
4.34 + public:
4.35 +
4.36 + typedef _Digraph Parent;
4.37 + typedef _Digraph Digraph;
4.38 + typedef DigraphAdaptorExtender Adaptor;
4.39 +
4.40 + // Base extensions
4.41 +
4.42 + typedef typename Parent::Node Node;
4.43 + typedef typename Parent::Arc Arc;
4.44 +
4.45 + int maxId(Node) const {
4.46 + return Parent::maxNodeId();
4.47 + }
4.48 +
4.49 + int maxId(Arc) const {
4.50 + return Parent::maxArcId();
4.51 + }
4.52 +
4.53 + Node fromId(int id, Node) const {
4.54 + return Parent::nodeFromId(id);
4.55 + }
4.56 +
4.57 + Arc fromId(int id, Arc) const {
4.58 + return Parent::arcFromId(id);
4.59 + }
4.60 +
4.61 + Node oppositeNode(const Node &n, const Arc &e) const {
4.62 + if (n == Parent::source(e))
4.63 + return Parent::target(e);
4.64 + else if(n==Parent::target(e))
4.65 + return Parent::source(e);
4.66 + else
4.67 + return INVALID;
4.68 + }
4.69 +
4.70 + class NodeIt : public Node {
4.71 + const Adaptor* _adaptor;
4.72 + public:
4.73 +
4.74 + NodeIt() {}
4.75 +
4.76 + NodeIt(Invalid i) : Node(i) { }
4.77 +
4.78 + explicit NodeIt(const Adaptor& adaptor) : _adaptor(&adaptor) {
4.79 + _adaptor->first(static_cast<Node&>(*this));
4.80 + }
4.81 +
4.82 + NodeIt(const Adaptor& adaptor, const Node& node)
4.83 + : Node(node), _adaptor(&adaptor) {}
4.84 +
4.85 + NodeIt& operator++() {
4.86 + _adaptor->next(*this);
4.87 + return *this;
4.88 + }
4.89 +
4.90 + };
4.91 +
4.92 +
4.93 + class ArcIt : public Arc {
4.94 + const Adaptor* _adaptor;
4.95 + public:
4.96 +
4.97 + ArcIt() { }
4.98 +
4.99 + ArcIt(Invalid i) : Arc(i) { }
4.100 +
4.101 + explicit ArcIt(const Adaptor& adaptor) : _adaptor(&adaptor) {
4.102 + _adaptor->first(static_cast<Arc&>(*this));
4.103 + }
4.104 +
4.105 + ArcIt(const Adaptor& adaptor, const Arc& e) :
4.106 + Arc(e), _adaptor(&adaptor) { }
4.107 +
4.108 + ArcIt& operator++() {
4.109 + _adaptor->next(*this);
4.110 + return *this;
4.111 + }
4.112 +
4.113 + };
4.114 +
4.115 +
4.116 + class OutArcIt : public Arc {
4.117 + const Adaptor* _adaptor;
4.118 + public:
4.119 +
4.120 + OutArcIt() { }
4.121 +
4.122 + OutArcIt(Invalid i) : Arc(i) { }
4.123 +
4.124 + OutArcIt(const Adaptor& adaptor, const Node& node)
4.125 + : _adaptor(&adaptor) {
4.126 + _adaptor->firstOut(*this, node);
4.127 + }
4.128 +
4.129 + OutArcIt(const Adaptor& adaptor, const Arc& arc)
4.130 + : Arc(arc), _adaptor(&adaptor) {}
4.131 +
4.132 + OutArcIt& operator++() {
4.133 + _adaptor->nextOut(*this);
4.134 + return *this;
4.135 + }
4.136 +
4.137 + };
4.138 +
4.139 +
4.140 + class InArcIt : public Arc {
4.141 + const Adaptor* _adaptor;
4.142 + public:
4.143 +
4.144 + InArcIt() { }
4.145 +
4.146 + InArcIt(Invalid i) : Arc(i) { }
4.147 +
4.148 + InArcIt(const Adaptor& adaptor, const Node& node)
4.149 + : _adaptor(&adaptor) {
4.150 + _adaptor->firstIn(*this, node);
4.151 + }
4.152 +
4.153 + InArcIt(const Adaptor& adaptor, const Arc& arc) :
4.154 + Arc(arc), _adaptor(&adaptor) {}
4.155 +
4.156 + InArcIt& operator++() {
4.157 + _adaptor->nextIn(*this);
4.158 + return *this;
4.159 + }
4.160 +
4.161 + };
4.162 +
4.163 + Node baseNode(const OutArcIt &e) const {
4.164 + return Parent::source(e);
4.165 + }
4.166 + Node runningNode(const OutArcIt &e) const {
4.167 + return Parent::target(e);
4.168 + }
4.169 +
4.170 + Node baseNode(const InArcIt &e) const {
4.171 + return Parent::target(e);
4.172 + }
4.173 + Node runningNode(const InArcIt &e) const {
4.174 + return Parent::source(e);
4.175 + }
4.176 +
4.177 + };
4.178 +
4.179 +
4.180 + /// \ingroup digraphbits
4.181 + ///
4.182 + /// \brief Extender for the GraphAdaptors
4.183 + template <typename _Graph>
4.184 + class GraphAdaptorExtender : public _Graph {
4.185 + public:
4.186 +
4.187 + typedef _Graph Parent;
4.188 + typedef _Graph Graph;
4.189 + typedef GraphAdaptorExtender Adaptor;
4.190 +
4.191 + typedef typename Parent::Node Node;
4.192 + typedef typename Parent::Arc Arc;
4.193 + typedef typename Parent::Edge Edge;
4.194 +
4.195 + // Graph extension
4.196 +
4.197 + int maxId(Node) const {
4.198 + return Parent::maxNodeId();
4.199 + }
4.200 +
4.201 + int maxId(Arc) const {
4.202 + return Parent::maxArcId();
4.203 + }
4.204 +
4.205 + int maxId(Edge) const {
4.206 + return Parent::maxEdgeId();
4.207 + }
4.208 +
4.209 + Node fromId(int id, Node) const {
4.210 + return Parent::nodeFromId(id);
4.211 + }
4.212 +
4.213 + Arc fromId(int id, Arc) const {
4.214 + return Parent::arcFromId(id);
4.215 + }
4.216 +
4.217 + Edge fromId(int id, Edge) const {
4.218 + return Parent::edgeFromId(id);
4.219 + }
4.220 +
4.221 + Node oppositeNode(const Node &n, const Edge &e) const {
4.222 + if( n == Parent::u(e))
4.223 + return Parent::v(e);
4.224 + else if( n == Parent::v(e))
4.225 + return Parent::u(e);
4.226 + else
4.227 + return INVALID;
4.228 + }
4.229 +
4.230 + Arc oppositeArc(const Arc &a) const {
4.231 + return Parent::direct(a, !Parent::direction(a));
4.232 + }
4.233 +
4.234 + using Parent::direct;
4.235 + Arc direct(const Edge &e, const Node &s) const {
4.236 + return Parent::direct(e, Parent::u(e) == s);
4.237 + }
4.238 +
4.239 +
4.240 + class NodeIt : public Node {
4.241 + const Adaptor* _adaptor;
4.242 + public:
4.243 +
4.244 + NodeIt() {}
4.245 +
4.246 + NodeIt(Invalid i) : Node(i) { }
4.247 +
4.248 + explicit NodeIt(const Adaptor& adaptor) : _adaptor(&adaptor) {
4.249 + _adaptor->first(static_cast<Node&>(*this));
4.250 + }
4.251 +
4.252 + NodeIt(const Adaptor& adaptor, const Node& node)
4.253 + : Node(node), _adaptor(&adaptor) {}
4.254 +
4.255 + NodeIt& operator++() {
4.256 + _adaptor->next(*this);
4.257 + return *this;
4.258 + }
4.259 +
4.260 + };
4.261 +
4.262 +
4.263 + class ArcIt : public Arc {
4.264 + const Adaptor* _adaptor;
4.265 + public:
4.266 +
4.267 + ArcIt() { }
4.268 +
4.269 + ArcIt(Invalid i) : Arc(i) { }
4.270 +
4.271 + explicit ArcIt(const Adaptor& adaptor) : _adaptor(&adaptor) {
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 +
4.278 + ArcIt& operator++() {
4.279 + _adaptor->next(*this);
4.280 + return *this;
4.281 + }
4.282 +
4.283 + };
4.284 +
4.285 +
4.286 + class OutArcIt : public Arc {
4.287 + const Adaptor* _adaptor;
4.288 + public:
4.289 +
4.290 + OutArcIt() { }
4.291 +
4.292 + OutArcIt(Invalid i) : Arc(i) { }
4.293 +
4.294 + OutArcIt(const Adaptor& adaptor, const Node& node)
4.295 + : _adaptor(&adaptor) {
4.296 + _adaptor->firstOut(*this, node);
4.297 + }
4.298 +
4.299 + OutArcIt(const Adaptor& adaptor, const Arc& arc)
4.300 + : Arc(arc), _adaptor(&adaptor) {}
4.301 +
4.302 + OutArcIt& operator++() {
4.303 + _adaptor->nextOut(*this);
4.304 + return *this;
4.305 + }
4.306 +
4.307 + };
4.308 +
4.309 +
4.310 + class InArcIt : public Arc {
4.311 + const Adaptor* _adaptor;
4.312 + public:
4.313 +
4.314 + InArcIt() { }
4.315 +
4.316 + InArcIt(Invalid i) : Arc(i) { }
4.317 +
4.318 + InArcIt(const Adaptor& adaptor, const Node& node)
4.319 + : _adaptor(&adaptor) {
4.320 + _adaptor->firstIn(*this, node);
4.321 + }
4.322 +
4.323 + InArcIt(const Adaptor& adaptor, const Arc& arc) :
4.324 + Arc(arc), _adaptor(&adaptor) {}
4.325 +
4.326 + InArcIt& operator++() {
4.327 + _adaptor->nextIn(*this);
4.328 + return *this;
4.329 + }
4.330 +
4.331 + };
4.332 +
4.333 + class EdgeIt : public Parent::Edge {
4.334 + const Adaptor* _adaptor;
4.335 + public:
4.336 +
4.337 + EdgeIt() { }
4.338 +
4.339 + EdgeIt(Invalid i) : Edge(i) { }
4.340 +
4.341 + explicit EdgeIt(const Adaptor& adaptor) : _adaptor(&adaptor) {
4.342 + _adaptor->first(static_cast<Edge&>(*this));
4.343 + }
4.344 +
4.345 + EdgeIt(const Adaptor& adaptor, const Edge& e) :
4.346 + Edge(e), _adaptor(&adaptor) { }
4.347 +
4.348 + EdgeIt& operator++() {
4.349 + _adaptor->next(*this);
4.350 + return *this;
4.351 + }
4.352 +
4.353 + };
4.354 +
4.355 + class IncEdgeIt : public Edge {
4.356 + friend class GraphAdaptorExtender;
4.357 + const Adaptor* _adaptor;
4.358 + bool direction;
4.359 + public:
4.360 +
4.361 + IncEdgeIt() { }
4.362 +
4.363 + IncEdgeIt(Invalid i) : Edge(i), direction(false) { }
4.364 +
4.365 + IncEdgeIt(const Adaptor& adaptor, const Node &n) : _adaptor(&adaptor) {
4.366 + _adaptor->firstInc(static_cast<Edge&>(*this), direction, n);
4.367 + }
4.368 +
4.369 + IncEdgeIt(const Adaptor& adaptor, const Edge &e, const Node &n)
4.370 + : _adaptor(&adaptor), Edge(e) {
4.371 + direction = (_adaptor->u(e) == n);
4.372 + }
4.373 +
4.374 + IncEdgeIt& operator++() {
4.375 + _adaptor->nextInc(*this, direction);
4.376 + return *this;
4.377 + }
4.378 + };
4.379 +
4.380 + Node baseNode(const OutArcIt &a) const {
4.381 + return Parent::source(a);
4.382 + }
4.383 + Node runningNode(const OutArcIt &a) const {
4.384 + return Parent::target(a);
4.385 + }
4.386 +
4.387 + Node baseNode(const InArcIt &a) const {
4.388 + return Parent::target(a);
4.389 + }
4.390 + Node runningNode(const InArcIt &a) const {
4.391 + return Parent::source(a);
4.392 + }
4.393 +
4.394 + Node baseNode(const IncEdgeIt &e) const {
4.395 + return e.direction ? Parent::u(e) : Parent::v(e);
4.396 + }
4.397 + Node runningNode(const IncEdgeIt &e) const {
4.398 + return e.direction ? Parent::v(e) : Parent::u(e);
4.399 + }
4.400 +
4.401 + };
4.402 +
4.403 +}
4.404 +
4.405 +
4.406 +#endif
5.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
5.2 +++ b/lemon/bits/variant.h Tue Dec 02 15:33:22 2008 +0000
5.3 @@ -0,0 +1,494 @@
5.4 +/* -*- mode: C++; indent-tabs-mode: nil; -*-
5.5 + *
5.6 + * This file is a part of LEMON, a generic C++ optimization library.
5.7 + *
5.8 + * Copyright (C) 2003-2008
5.9 + * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
5.10 + * (Egervary Research Group on Combinatorial Optimization, EGRES).
5.11 + *
5.12 + * Permission to use, modify and distribute this software is granted
5.13 + * provided that this copyright notice appears in all copies. For
5.14 + * precise terms see the accompanying LICENSE file.
5.15 + *
5.16 + * This software is provided "AS IS" with no warranty of any kind,
5.17 + * express or implied, and with no claim as to its suitability for any
5.18 + * purpose.
5.19 + *
5.20 + */
5.21 +
5.22 +#ifndef LEMON_BITS_VARIANT_H
5.23 +#define LEMON_BITS_VARIANT_H
5.24 +
5.25 +#include <lemon/assert.h>
5.26 +
5.27 +/// \file
5.28 +/// \brief Variant types
5.29 +
5.30 +namespace lemon {
5.31 +
5.32 + namespace _variant_bits {
5.33 +
5.34 + template <int left, int right>
5.35 + struct CTMax {
5.36 + static const int value = left < right ? right : left;
5.37 + };
5.38 +
5.39 + }
5.40 +
5.41 +
5.42 + /// \brief Simple Variant type for two types
5.43 + ///
5.44 + /// Simple Variant type for two types. The Variant type is a type
5.45 + /// safe union. The C++ has strong limitations for using unions, by
5.46 + /// example we can not store type with non default constructor or
5.47 + /// destructor in an union. This class always knowns the current
5.48 + /// state of the variant and it cares for the proper construction
5.49 + /// and destruction.
5.50 + template <typename _First, typename _Second>
5.51 + class BiVariant {
5.52 + public:
5.53 +
5.54 + /// \brief The \c First type.
5.55 + typedef _First First;
5.56 + /// \brief The \c Second type.
5.57 + typedef _Second Second;
5.58 +
5.59 + /// \brief Constructor
5.60 + ///
5.61 + /// This constructor initalizes to the default value of the \c First
5.62 + /// type.
5.63 + BiVariant() {
5.64 + flag = true;
5.65 + new(reinterpret_cast<First*>(data)) First();
5.66 + }
5.67 +
5.68 + /// \brief Constructor
5.69 + ///
5.70 + /// This constructor initalizes to the given value of the \c First
5.71 + /// type.
5.72 + BiVariant(const First& f) {
5.73 + flag = true;
5.74 + new(reinterpret_cast<First*>(data)) First(f);
5.75 + }
5.76 +
5.77 + /// \brief Constructor
5.78 + ///
5.79 + /// This constructor initalizes to the given value of the \c
5.80 + /// Second type.
5.81 + BiVariant(const Second& s) {
5.82 + flag = false;
5.83 + new(reinterpret_cast<Second*>(data)) Second(s);
5.84 + }
5.85 +
5.86 + /// \brief Copy constructor
5.87 + ///
5.88 + /// Copy constructor
5.89 + BiVariant(const BiVariant& bivariant) {
5.90 + flag = bivariant.flag;
5.91 + if (flag) {
5.92 + new(reinterpret_cast<First*>(data)) First(bivariant.first());
5.93 + } else {
5.94 + new(reinterpret_cast<Second*>(data)) Second(bivariant.second());
5.95 + }
5.96 + }
5.97 +
5.98 + /// \brief Destrcutor
5.99 + ///
5.100 + /// Destructor
5.101 + ~BiVariant() {
5.102 + destroy();
5.103 + }
5.104 +
5.105 + /// \brief Set to the default value of the \c First type.
5.106 + ///
5.107 + /// This function sets the variant to the default value of the \c
5.108 + /// First type.
5.109 + BiVariant& setFirst() {
5.110 + destroy();
5.111 + flag = true;
5.112 + new(reinterpret_cast<First*>(data)) First();
5.113 + return *this;
5.114 + }
5.115 +
5.116 + /// \brief Set to the given value of the \c First type.
5.117 + ///
5.118 + /// This function sets the variant to the given value of the \c
5.119 + /// First type.
5.120 + BiVariant& setFirst(const First& f) {
5.121 + destroy();
5.122 + flag = true;
5.123 + new(reinterpret_cast<First*>(data)) First(f);
5.124 + return *this;
5.125 + }
5.126 +
5.127 + /// \brief Set to the default value of the \c Second type.
5.128 + ///
5.129 + /// This function sets the variant to the default value of the \c
5.130 + /// Second type.
5.131 + BiVariant& setSecond() {
5.132 + destroy();
5.133 + flag = false;
5.134 + new(reinterpret_cast<Second*>(data)) Second();
5.135 + return *this;
5.136 + }
5.137 +
5.138 + /// \brief Set to the given value of the \c Second type.
5.139 + ///
5.140 + /// This function sets the variant to the given value of the \c
5.141 + /// Second type.
5.142 + BiVariant& setSecond(const Second& s) {
5.143 + destroy();
5.144 + flag = false;
5.145 + new(reinterpret_cast<Second*>(data)) Second(s);
5.146 + return *this;
5.147 + }
5.148 +
5.149 + /// \brief Operator form of the \c setFirst()
5.150 + BiVariant& operator=(const First& f) {
5.151 + return setFirst(f);
5.152 + }
5.153 +
5.154 + /// \brief Operator form of the \c setSecond()
5.155 + BiVariant& operator=(const Second& s) {
5.156 + return setSecond(s);
5.157 + }
5.158 +
5.159 + /// \brief Assign operator
5.160 + BiVariant& operator=(const BiVariant& bivariant) {
5.161 + if (this == &bivariant) return *this;
5.162 + destroy();
5.163 + flag = bivariant.flag;
5.164 + if (flag) {
5.165 + new(reinterpret_cast<First*>(data)) First(bivariant.first());
5.166 + } else {
5.167 + new(reinterpret_cast<Second*>(data)) Second(bivariant.second());
5.168 + }
5.169 + return *this;
5.170 + }
5.171 +
5.172 + /// \brief Reference to the value
5.173 + ///
5.174 + /// Reference to the value of the \c First type.
5.175 + /// \pre The BiVariant should store value of \c First type.
5.176 + First& first() {
5.177 + LEMON_DEBUG(flag, "Variant wrong state");
5.178 + return *reinterpret_cast<First*>(data);
5.179 + }
5.180 +
5.181 + /// \brief Const reference to the value
5.182 + ///
5.183 + /// Const reference to the value of the \c First type.
5.184 + /// \pre The BiVariant should store value of \c First type.
5.185 + const First& first() const {
5.186 + LEMON_DEBUG(flag, "Variant wrong state");
5.187 + return *reinterpret_cast<const First*>(data);
5.188 + }
5.189 +
5.190 + /// \brief Operator form of the \c first()
5.191 + operator First&() { return first(); }
5.192 + /// \brief Operator form of the const \c first()
5.193 + operator const First&() const { return first(); }
5.194 +
5.195 + /// \brief Reference to the value
5.196 + ///
5.197 + /// Reference to the value of the \c Second type.
5.198 + /// \pre The BiVariant should store value of \c Second type.
5.199 + Second& second() {
5.200 + LEMON_DEBUG(!flag, "Variant wrong state");
5.201 + return *reinterpret_cast<Second*>(data);
5.202 + }
5.203 +
5.204 + /// \brief Const reference to the value
5.205 + ///
5.206 + /// Const reference to the value of the \c Second type.
5.207 + /// \pre The BiVariant should store value of \c Second type.
5.208 + const Second& second() const {
5.209 + LEMON_DEBUG(!flag, "Variant wrong state");
5.210 + return *reinterpret_cast<const Second*>(data);
5.211 + }
5.212 +
5.213 + /// \brief Operator form of the \c second()
5.214 + operator Second&() { return second(); }
5.215 + /// \brief Operator form of the const \c second()
5.216 + operator const Second&() const { return second(); }
5.217 +
5.218 + /// \brief %True when the variant is in the first state
5.219 + ///
5.220 + /// %True when the variant stores value of the \c First type.
5.221 + bool firstState() const { return flag; }
5.222 +
5.223 + /// \brief %True when the variant is in the second state
5.224 + ///
5.225 + /// %True when the variant stores value of the \c Second type.
5.226 + bool secondState() const { return !flag; }
5.227 +
5.228 + private:
5.229 +
5.230 + void destroy() {
5.231 + if (flag) {
5.232 + reinterpret_cast<First*>(data)->~First();
5.233 + } else {
5.234 + reinterpret_cast<Second*>(data)->~Second();
5.235 + }
5.236 + }
5.237 +
5.238 + char data[_variant_bits::CTMax<sizeof(First), sizeof(Second)>::value];
5.239 + bool flag;
5.240 + };
5.241 +
5.242 + namespace _variant_bits {
5.243 +
5.244 + template <int _idx, typename _TypeMap>
5.245 + struct Memory {
5.246 +
5.247 + typedef typename _TypeMap::template Map<_idx>::Type Current;
5.248 +
5.249 + static void destroy(int index, char* place) {
5.250 + if (index == _idx) {
5.251 + reinterpret_cast<Current*>(place)->~Current();
5.252 + } else {
5.253 + Memory<_idx - 1, _TypeMap>::destroy(index, place);
5.254 + }
5.255 + }
5.256 +
5.257 + static void copy(int index, char* to, const char* from) {
5.258 + if (index == _idx) {
5.259 + new (reinterpret_cast<Current*>(to))
5.260 + Current(reinterpret_cast<const Current*>(from));
5.261 + } else {
5.262 + Memory<_idx - 1, _TypeMap>::copy(index, to, from);
5.263 + }
5.264 + }
5.265 +
5.266 + };
5.267 +
5.268 + template <typename _TypeMap>
5.269 + struct Memory<-1, _TypeMap> {
5.270 +
5.271 + static void destroy(int, char*) {
5.272 + LEMON_DEBUG(false, "Variant wrong index.");
5.273 + }
5.274 +
5.275 + static void copy(int, char*, const char*) {
5.276 + LEMON_DEBUG(false, "Variant wrong index.");
5.277 + }
5.278 + };
5.279 +
5.280 + template <int _idx, typename _TypeMap>
5.281 + struct Size {
5.282 + static const int value =
5.283 + CTMax<sizeof(typename _TypeMap::template Map<_idx>::Type),
5.284 + Size<_idx - 1, _TypeMap>::value>::value;
5.285 + };
5.286 +
5.287 + template <typename _TypeMap>
5.288 + struct Size<0, _TypeMap> {
5.289 + static const int value =
5.290 + sizeof(typename _TypeMap::template Map<0>::Type);
5.291 + };
5.292 +
5.293 + }
5.294 +
5.295 + /// \brief Variant type
5.296 + ///
5.297 + /// Simple Variant type. The Variant type is a type safe union. The
5.298 + /// C++ has strong limitations for using unions, for example we
5.299 + /// cannot store type with non default constructor or destructor in
5.300 + /// a union. This class always knowns the current state of the
5.301 + /// variant and it cares for the proper construction and
5.302 + /// destruction.
5.303 + ///
5.304 + /// \param _num The number of the types which can be stored in the
5.305 + /// variant type.
5.306 + /// \param _TypeMap This class describes the types of the Variant. The
5.307 + /// _TypeMap::Map<index>::Type should be a valid type for each index
5.308 + /// in the range {0, 1, ..., _num - 1}. The \c VariantTypeMap is helper
5.309 + /// class to define such type mappings up to 10 types.
5.310 + ///
5.311 + /// And the usage of the class:
5.312 + ///\code
5.313 + /// typedef Variant<3, VariantTypeMap<int, std::string, double> > MyVariant;
5.314 + /// MyVariant var;
5.315 + /// var.set<0>(12);
5.316 + /// std::cout << var.get<0>() << std::endl;
5.317 + /// var.set<1>("alpha");
5.318 + /// std::cout << var.get<1>() << std::endl;
5.319 + /// var.set<2>(0.75);
5.320 + /// std::cout << var.get<2>() << std::endl;
5.321 + ///\endcode
5.322 + ///
5.323 + /// The result of course:
5.324 + ///\code
5.325 + /// 12
5.326 + /// alpha
5.327 + /// 0.75
5.328 + ///\endcode
5.329 + template <int _num, typename _TypeMap>
5.330 + class Variant {
5.331 + public:
5.332 +
5.333 + static const int num = _num;
5.334 +
5.335 + typedef _TypeMap TypeMap;
5.336 +
5.337 + /// \brief Constructor
5.338 + ///
5.339 + /// This constructor initalizes to the default value of the \c type
5.340 + /// with 0 index.
5.341 + Variant() {
5.342 + flag = 0;
5.343 + new(reinterpret_cast<typename TypeMap::template Map<0>::Type*>(data))
5.344 + typename TypeMap::template Map<0>::Type();
5.345 + }
5.346 +
5.347 +
5.348 + /// \brief Copy constructor
5.349 + ///
5.350 + /// Copy constructor
5.351 + Variant(const Variant& variant) {
5.352 + flag = variant.flag;
5.353 + _variant_bits::Memory<num - 1, TypeMap>::copy(flag, data, variant.data);
5.354 + }
5.355 +
5.356 + /// \brief Assign operator
5.357 + ///
5.358 + /// Assign operator
5.359 + Variant& operator=(const Variant& variant) {
5.360 + if (this == &variant) return *this;
5.361 + _variant_bits::Memory<num - 1, TypeMap>::
5.362 + destroy(flag, data);
5.363 + flag = variant.flag;
5.364 + _variant_bits::Memory<num - 1, TypeMap>::
5.365 + copy(flag, data, variant.data);
5.366 + return *this;
5.367 + }
5.368 +
5.369 + /// \brief Destrcutor
5.370 + ///
5.371 + /// Destructor
5.372 + ~Variant() {
5.373 + _variant_bits::Memory<num - 1, TypeMap>::destroy(flag, data);
5.374 + }
5.375 +
5.376 + /// \brief Set to the default value of the type with \c _idx index.
5.377 + ///
5.378 + /// This function sets the variant to the default value of the
5.379 + /// type with \c _idx index.
5.380 + template <int _idx>
5.381 + Variant& set() {
5.382 + _variant_bits::Memory<num - 1, TypeMap>::destroy(flag, data);
5.383 + flag = _idx;
5.384 + new(reinterpret_cast<typename TypeMap::template Map<_idx>::Type*>(data))
5.385 + typename TypeMap::template Map<_idx>::Type();
5.386 + return *this;
5.387 + }
5.388 +
5.389 + /// \brief Set to the given value of the type with \c _idx index.
5.390 + ///
5.391 + /// This function sets the variant to the given value of the type
5.392 + /// with \c _idx index.
5.393 + template <int _idx>
5.394 + Variant& set(const typename _TypeMap::template Map<_idx>::Type& init) {
5.395 + _variant_bits::Memory<num - 1, TypeMap>::destroy(flag, data);
5.396 + flag = _idx;
5.397 + new(reinterpret_cast<typename TypeMap::template Map<_idx>::Type*>(data))
5.398 + typename TypeMap::template Map<_idx>::Type(init);
5.399 + return *this;
5.400 + }
5.401 +
5.402 + /// \brief Gets the current value of the type with \c _idx index.
5.403 + ///
5.404 + /// Gets the current value of the type with \c _idx index.
5.405 + template <int _idx>
5.406 + const typename TypeMap::template Map<_idx>::Type& get() const {
5.407 + LEMON_DEBUG(_idx == flag, "Variant wrong index");
5.408 + return *reinterpret_cast<const typename TypeMap::
5.409 + template Map<_idx>::Type*>(data);
5.410 + }
5.411 +
5.412 + /// \brief Gets the current value of the type with \c _idx index.
5.413 + ///
5.414 + /// Gets the current value of the type with \c _idx index.
5.415 + template <int _idx>
5.416 + typename _TypeMap::template Map<_idx>::Type& get() {
5.417 + LEMON_DEBUG(_idx == flag, "Variant wrong index");
5.418 + return *reinterpret_cast<typename TypeMap::template Map<_idx>::Type*>
5.419 + (data);
5.420 + }
5.421 +
5.422 + /// \brief Returns the current state of the variant.
5.423 + ///
5.424 + /// Returns the current state of the variant.
5.425 + int state() const {
5.426 + return flag;
5.427 + }
5.428 +
5.429 + private:
5.430 +
5.431 + char data[_variant_bits::Size<num - 1, TypeMap>::value];
5.432 + int flag;
5.433 + };
5.434 +
5.435 + namespace _variant_bits {
5.436 +
5.437 + template <int _index, typename _List>
5.438 + struct Get {
5.439 + typedef typename Get<_index - 1, typename _List::Next>::Type Type;
5.440 + };
5.441 +
5.442 + template <typename _List>
5.443 + struct Get<0, _List> {
5.444 + typedef typename _List::Type Type;
5.445 + };
5.446 +
5.447 + struct List {};
5.448 +
5.449 + template <typename _Type, typename _List>
5.450 + struct Insert {
5.451 + typedef _List Next;
5.452 + typedef _Type Type;
5.453 + };
5.454 +
5.455 + template <int _idx, typename _T0, typename _T1, typename _T2,
5.456 + typename _T3, typename _T5, typename _T4, typename _T6,
5.457 + typename _T7, typename _T8, typename _T9>
5.458 + struct Mapper {
5.459 + typedef List L10;
5.460 + typedef Insert<_T9, L10> L9;
5.461 + typedef Insert<_T8, L9> L8;
5.462 + typedef Insert<_T7, L8> L7;
5.463 + typedef Insert<_T6, L7> L6;
5.464 + typedef Insert<_T5, L6> L5;
5.465 + typedef Insert<_T4, L5> L4;
5.466 + typedef Insert<_T3, L4> L3;
5.467 + typedef Insert<_T2, L3> L2;
5.468 + typedef Insert<_T1, L2> L1;
5.469 + typedef Insert<_T0, L1> L0;
5.470 + typedef typename Get<_idx, L0>::Type Type;
5.471 + };
5.472 +
5.473 + }
5.474 +
5.475 + /// \brief Helper class for Variant
5.476 + ///
5.477 + /// Helper class to define type mappings for Variant. This class
5.478 + /// converts the template parameters to be mappable by integer.
5.479 + /// \see Variant
5.480 + template <
5.481 + typename _T0,
5.482 + typename _T1 = void, typename _T2 = void, typename _T3 = void,
5.483 + typename _T5 = void, typename _T4 = void, typename _T6 = void,
5.484 + typename _T7 = void, typename _T8 = void, typename _T9 = void>
5.485 + struct VariantTypeMap {
5.486 + template <int _idx>
5.487 + struct Map {
5.488 + typedef typename _variant_bits::
5.489 + Mapper<_idx, _T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9>::Type
5.490 + Type;
5.491 + };
5.492 + };
5.493 +
5.494 +}
5.495 +
5.496 +
5.497 +#endif
6.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
6.2 +++ b/lemon/connectivity.h Tue Dec 02 15:33:22 2008 +0000
6.3 @@ -0,0 +1,1572 @@
6.4 +/* -*- mode: C++; indent-tabs-mode: nil; -*-
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_TOPOLOGY_H
6.23 +#define LEMON_TOPOLOGY_H
6.24 +
6.25 +#include <lemon/dfs.h>
6.26 +#include <lemon/bfs.h>
6.27 +#include <lemon/core.h>
6.28 +#include <lemon/maps.h>
6.29 +#include <lemon/adaptors.h>
6.30 +
6.31 +#include <lemon/concepts/digraph.h>
6.32 +#include <lemon/concepts/graph.h>
6.33 +#include <lemon/concept_check.h>
6.34 +
6.35 +#include <stack>
6.36 +#include <functional>
6.37 +
6.38 +/// \ingroup connectivity
6.39 +/// \file
6.40 +/// \brief Connectivity algorithms
6.41 +///
6.42 +/// Connectivity algorithms
6.43 +
6.44 +namespace lemon {
6.45 +
6.46 + /// \ingroup connectivity
6.47 + ///
6.48 + /// \brief Check whether the given undirected graph is connected.
6.49 + ///
6.50 + /// Check whether the given undirected graph is connected.
6.51 + /// \param graph The undirected graph.
6.52 + /// \return %True when there is path between any two nodes in the graph.
6.53 + /// \note By definition, the empty graph is connected.
6.54 + template <typename Graph>
6.55 + bool connected(const Graph& graph) {
6.56 + checkConcept<concepts::Graph, Graph>();
6.57 + typedef typename Graph::NodeIt NodeIt;
6.58 + if (NodeIt(graph) == INVALID) return true;
6.59 + Dfs<Graph> dfs(graph);
6.60 + dfs.run(NodeIt(graph));
6.61 + for (NodeIt it(graph); it != INVALID; ++it) {
6.62 + if (!dfs.reached(it)) {
6.63 + return false;
6.64 + }
6.65 + }
6.66 + return true;
6.67 + }
6.68 +
6.69 + /// \ingroup connectivity
6.70 + ///
6.71 + /// \brief Count the number of connected components of an undirected graph
6.72 + ///
6.73 + /// Count the number of connected components of an undirected graph
6.74 + ///
6.75 + /// \param graph The graph. It must be undirected.
6.76 + /// \return The number of components
6.77 + /// \note By definition, the empty graph consists
6.78 + /// of zero connected components.
6.79 + template <typename Graph>
6.80 + int countConnectedComponents(const Graph &graph) {
6.81 + checkConcept<concepts::Graph, Graph>();
6.82 + typedef typename Graph::Node Node;
6.83 + typedef typename Graph::Arc Arc;
6.84 +
6.85 + typedef NullMap<Node, Arc> PredMap;
6.86 + typedef NullMap<Node, int> DistMap;
6.87 +
6.88 + int compNum = 0;
6.89 + typename Bfs<Graph>::
6.90 + template SetPredMap<PredMap>::
6.91 + template SetDistMap<DistMap>::
6.92 + Create bfs(graph);
6.93 +
6.94 + PredMap predMap;
6.95 + bfs.predMap(predMap);
6.96 +
6.97 + DistMap distMap;
6.98 + bfs.distMap(distMap);
6.99 +
6.100 + bfs.init();
6.101 + for(typename Graph::NodeIt n(graph); n != INVALID; ++n) {
6.102 + if (!bfs.reached(n)) {
6.103 + bfs.addSource(n);
6.104 + bfs.start();
6.105 + ++compNum;
6.106 + }
6.107 + }
6.108 + return compNum;
6.109 + }
6.110 +
6.111 + /// \ingroup connectivity
6.112 + ///
6.113 + /// \brief Find the connected components of an undirected graph
6.114 + ///
6.115 + /// Find the connected components of an undirected graph.
6.116 + ///
6.117 + /// \param graph The graph. It must be undirected.
6.118 + /// \retval compMap A writable node map. The values will be set from 0 to
6.119 + /// the number of the connected components minus one. Each values of the map
6.120 + /// will be set exactly once, the values of a certain component will be
6.121 + /// set continuously.
6.122 + /// \return The number of components
6.123 + ///
6.124 + template <class Graph, class NodeMap>
6.125 + int connectedComponents(const Graph &graph, NodeMap &compMap) {
6.126 + checkConcept<concepts::Graph, Graph>();
6.127 + typedef typename Graph::Node Node;
6.128 + typedef typename Graph::Arc Arc;
6.129 + checkConcept<concepts::WriteMap<Node, int>, NodeMap>();
6.130 +
6.131 + typedef NullMap<Node, Arc> PredMap;
6.132 + typedef NullMap<Node, int> DistMap;
6.133 +
6.134 + int compNum = 0;
6.135 + typename Bfs<Graph>::
6.136 + template SetPredMap<PredMap>::
6.137 + template SetDistMap<DistMap>::
6.138 + Create bfs(graph);
6.139 +
6.140 + PredMap predMap;
6.141 + bfs.predMap(predMap);
6.142 +
6.143 + DistMap distMap;
6.144 + bfs.distMap(distMap);
6.145 +
6.146 + bfs.init();
6.147 + for(typename Graph::NodeIt n(graph); n != INVALID; ++n) {
6.148 + if(!bfs.reached(n)) {
6.149 + bfs.addSource(n);
6.150 + while (!bfs.emptyQueue()) {
6.151 + compMap.set(bfs.nextNode(), compNum);
6.152 + bfs.processNextNode();
6.153 + }
6.154 + ++compNum;
6.155 + }
6.156 + }
6.157 + return compNum;
6.158 + }
6.159 +
6.160 + namespace _topology_bits {
6.161 +
6.162 + template <typename Digraph, typename Iterator >
6.163 + struct LeaveOrderVisitor : public DfsVisitor<Digraph> {
6.164 + public:
6.165 + typedef typename Digraph::Node Node;
6.166 + LeaveOrderVisitor(Iterator it) : _it(it) {}
6.167 +
6.168 + void leave(const Node& node) {
6.169 + *(_it++) = node;
6.170 + }
6.171 +
6.172 + private:
6.173 + Iterator _it;
6.174 + };
6.175 +
6.176 + template <typename Digraph, typename Map>
6.177 + struct FillMapVisitor : public DfsVisitor<Digraph> {
6.178 + public:
6.179 + typedef typename Digraph::Node Node;
6.180 + typedef typename Map::Value Value;
6.181 +
6.182 + FillMapVisitor(Map& map, Value& value)
6.183 + : _map(map), _value(value) {}
6.184 +
6.185 + void reach(const Node& node) {
6.186 + _map.set(node, _value);
6.187 + }
6.188 + private:
6.189 + Map& _map;
6.190 + Value& _value;
6.191 + };
6.192 +
6.193 + template <typename Digraph, typename ArcMap>
6.194 + struct StronglyConnectedCutEdgesVisitor : public DfsVisitor<Digraph> {
6.195 + public:
6.196 + typedef typename Digraph::Node Node;
6.197 + typedef typename Digraph::Arc Arc;
6.198 +
6.199 + StronglyConnectedCutEdgesVisitor(const Digraph& digraph,
6.200 + ArcMap& cutMap,
6.201 + int& cutNum)
6.202 + : _digraph(digraph), _cutMap(cutMap), _cutNum(cutNum),
6.203 + _compMap(digraph), _num(0) {
6.204 + }
6.205 +
6.206 + void stop(const Node&) {
6.207 + ++_num;
6.208 + }
6.209 +
6.210 + void reach(const Node& node) {
6.211 + _compMap.set(node, _num);
6.212 + }
6.213 +
6.214 + void examine(const Arc& arc) {
6.215 + if (_compMap[_digraph.source(arc)] !=
6.216 + _compMap[_digraph.target(arc)]) {
6.217 + _cutMap.set(arc, true);
6.218 + ++_cutNum;
6.219 + }
6.220 + }
6.221 + private:
6.222 + const Digraph& _digraph;
6.223 + ArcMap& _cutMap;
6.224 + int& _cutNum;
6.225 +
6.226 + typename Digraph::template NodeMap<int> _compMap;
6.227 + int _num;
6.228 + };
6.229 +
6.230 + }
6.231 +
6.232 +
6.233 + /// \ingroup connectivity
6.234 + ///
6.235 + /// \brief Check whether the given directed graph is strongly connected.
6.236 + ///
6.237 + /// Check whether the given directed graph is strongly connected. The
6.238 + /// graph is strongly connected when any two nodes of the graph are
6.239 + /// connected with directed paths in both direction.
6.240 + /// \return %False when the graph is not strongly connected.
6.241 + /// \see connected
6.242 + ///
6.243 + /// \note By definition, the empty graph is strongly connected.
6.244 + template <typename Digraph>
6.245 + bool stronglyConnected(const Digraph& digraph) {
6.246 + checkConcept<concepts::Digraph, Digraph>();
6.247 +
6.248 + typedef typename Digraph::Node Node;
6.249 + typedef typename Digraph::NodeIt NodeIt;
6.250 +
6.251 + typename Digraph::Node source = NodeIt(digraph);
6.252 + if (source == INVALID) return true;
6.253 +
6.254 + using namespace _topology_bits;
6.255 +
6.256 + typedef DfsVisitor<Digraph> Visitor;
6.257 + Visitor visitor;
6.258 +
6.259 + DfsVisit<Digraph, Visitor> dfs(digraph, visitor);
6.260 + dfs.init();
6.261 + dfs.addSource(source);
6.262 + dfs.start();
6.263 +
6.264 + for (NodeIt it(digraph); it != INVALID; ++it) {
6.265 + if (!dfs.reached(it)) {
6.266 + return false;
6.267 + }
6.268 + }
6.269 +
6.270 + typedef ReverseDigraph<const Digraph> RDigraph;
6.271 + RDigraph rdigraph(digraph);
6.272 +
6.273 + typedef DfsVisitor<Digraph> RVisitor;
6.274 + RVisitor rvisitor;
6.275 +
6.276 + DfsVisit<RDigraph, RVisitor> rdfs(rdigraph, rvisitor);
6.277 + rdfs.init();
6.278 + rdfs.addSource(source);
6.279 + rdfs.start();
6.280 +
6.281 + for (NodeIt it(rdigraph); it != INVALID; ++it) {
6.282 + if (!rdfs.reached(it)) {
6.283 + return false;
6.284 + }
6.285 + }
6.286 +
6.287 + return true;
6.288 + }
6.289 +
6.290 + /// \ingroup connectivity
6.291 + ///
6.292 + /// \brief Count the strongly connected components of a directed graph
6.293 + ///
6.294 + /// Count the strongly connected components of a directed graph.
6.295 + /// The strongly connected components are the classes of an
6.296 + /// equivalence relation on the nodes of the graph. Two nodes are in
6.297 + /// the same class if they are connected with directed paths in both
6.298 + /// direction.
6.299 + ///
6.300 + /// \param graph The graph.
6.301 + /// \return The number of components
6.302 + /// \note By definition, the empty graph has zero
6.303 + /// strongly connected components.
6.304 + template <typename Digraph>
6.305 + int countStronglyConnectedComponents(const Digraph& digraph) {
6.306 + checkConcept<concepts::Digraph, Digraph>();
6.307 +
6.308 + using namespace _topology_bits;
6.309 +
6.310 + typedef typename Digraph::Node Node;
6.311 + typedef typename Digraph::Arc Arc;
6.312 + typedef typename Digraph::NodeIt NodeIt;
6.313 + typedef typename Digraph::ArcIt ArcIt;
6.314 +
6.315 + typedef std::vector<Node> Container;
6.316 + typedef typename Container::iterator Iterator;
6.317 +
6.318 + Container nodes(countNodes(digraph));
6.319 + typedef LeaveOrderVisitor<Digraph, Iterator> Visitor;
6.320 + Visitor visitor(nodes.begin());
6.321 +
6.322 + DfsVisit<Digraph, Visitor> dfs(digraph, visitor);
6.323 + dfs.init();
6.324 + for (NodeIt it(digraph); it != INVALID; ++it) {
6.325 + if (!dfs.reached(it)) {
6.326 + dfs.addSource(it);
6.327 + dfs.start();
6.328 + }
6.329 + }
6.330 +
6.331 + typedef typename Container::reverse_iterator RIterator;
6.332 + typedef ReverseDigraph<const Digraph> RDigraph;
6.333 +
6.334 + RDigraph rdigraph(digraph);
6.335 +
6.336 + typedef DfsVisitor<Digraph> RVisitor;
6.337 + RVisitor rvisitor;
6.338 +
6.339 + DfsVisit<RDigraph, RVisitor> rdfs(rdigraph, rvisitor);
6.340 +
6.341 + int compNum = 0;
6.342 +
6.343 + rdfs.init();
6.344 + for (RIterator it = nodes.rbegin(); it != nodes.rend(); ++it) {
6.345 + if (!rdfs.reached(*it)) {
6.346 + rdfs.addSource(*it);
6.347 + rdfs.start();
6.348 + ++compNum;
6.349 + }
6.350 + }
6.351 + return compNum;
6.352 + }
6.353 +
6.354 + /// \ingroup connectivity
6.355 + ///
6.356 + /// \brief Find the strongly connected components of a directed graph
6.357 + ///
6.358 + /// Find the strongly connected components of a directed graph. The
6.359 + /// strongly connected components are the classes of an equivalence
6.360 + /// relation on the nodes of the graph. Two nodes are in
6.361 + /// relationship when there are directed paths between them in both
6.362 + /// direction. In addition, the numbering of components will satisfy
6.363 + /// that there is no arc going from a higher numbered component to
6.364 + /// a lower.
6.365 + ///
6.366 + /// \param digraph The digraph.
6.367 + /// \retval compMap A writable node map. The values will be set from 0 to
6.368 + /// the number of the strongly connected components minus one. Each value
6.369 + /// of the map will be set exactly once, the values of a certain component
6.370 + /// will be set continuously.
6.371 + /// \return The number of components
6.372 + ///
6.373 + template <typename Digraph, typename NodeMap>
6.374 + int stronglyConnectedComponents(const Digraph& digraph, NodeMap& compMap) {
6.375 + checkConcept<concepts::Digraph, Digraph>();
6.376 + typedef typename Digraph::Node Node;
6.377 + typedef typename Digraph::NodeIt NodeIt;
6.378 + checkConcept<concepts::WriteMap<Node, int>, NodeMap>();
6.379 +
6.380 + using namespace _topology_bits;
6.381 +
6.382 + typedef std::vector<Node> Container;
6.383 + typedef typename Container::iterator Iterator;
6.384 +
6.385 + Container nodes(countNodes(digraph));
6.386 + typedef LeaveOrderVisitor<Digraph, Iterator> Visitor;
6.387 + Visitor visitor(nodes.begin());
6.388 +
6.389 + DfsVisit<Digraph, Visitor> dfs(digraph, visitor);
6.390 + dfs.init();
6.391 + for (NodeIt it(digraph); it != INVALID; ++it) {
6.392 + if (!dfs.reached(it)) {
6.393 + dfs.addSource(it);
6.394 + dfs.start();
6.395 + }
6.396 + }
6.397 +
6.398 + typedef typename Container::reverse_iterator RIterator;
6.399 + typedef ReverseDigraph<const Digraph> RDigraph;
6.400 +
6.401 + RDigraph rdigraph(digraph);
6.402 +
6.403 + int compNum = 0;
6.404 +
6.405 + typedef FillMapVisitor<RDigraph, NodeMap> RVisitor;
6.406 + RVisitor rvisitor(compMap, compNum);
6.407 +
6.408 + DfsVisit<RDigraph, RVisitor> rdfs(rdigraph, rvisitor);
6.409 +
6.410 + rdfs.init();
6.411 + for (RIterator it = nodes.rbegin(); it != nodes.rend(); ++it) {
6.412 + if (!rdfs.reached(*it)) {
6.413 + rdfs.addSource(*it);
6.414 + rdfs.start();
6.415 + ++compNum;
6.416 + }
6.417 + }
6.418 + return compNum;
6.419 + }
6.420 +
6.421 + /// \ingroup connectivity
6.422 + ///
6.423 + /// \brief Find the cut arcs of the strongly connected components.
6.424 + ///
6.425 + /// Find the cut arcs of the strongly connected components.
6.426 + /// The strongly connected components are the classes of an equivalence
6.427 + /// relation on the nodes of the graph. Two nodes are in relationship
6.428 + /// when there are directed paths between them in both direction.
6.429 + /// The strongly connected components are separated by the cut arcs.
6.430 + ///
6.431 + /// \param graph The graph.
6.432 + /// \retval cutMap A writable node map. The values will be set true when the
6.433 + /// arc is a cut arc.
6.434 + ///
6.435 + /// \return The number of cut arcs
6.436 + template <typename Digraph, typename ArcMap>
6.437 + int stronglyConnectedCutArcs(const Digraph& graph, ArcMap& cutMap) {
6.438 + checkConcept<concepts::Digraph, Digraph>();
6.439 + typedef typename Digraph::Node Node;
6.440 + typedef typename Digraph::Arc Arc;
6.441 + typedef typename Digraph::NodeIt NodeIt;
6.442 + checkConcept<concepts::WriteMap<Arc, bool>, ArcMap>();
6.443 +
6.444 + using namespace _topology_bits;
6.445 +
6.446 + typedef std::vector<Node> Container;
6.447 + typedef typename Container::iterator Iterator;
6.448 +
6.449 + Container nodes(countNodes(graph));
6.450 + typedef LeaveOrderVisitor<Digraph, Iterator> Visitor;
6.451 + Visitor visitor(nodes.begin());
6.452 +
6.453 + DfsVisit<Digraph, Visitor> dfs(graph, visitor);
6.454 + dfs.init();
6.455 + for (NodeIt it(graph); it != INVALID; ++it) {
6.456 + if (!dfs.reached(it)) {
6.457 + dfs.addSource(it);
6.458 + dfs.start();
6.459 + }
6.460 + }
6.461 +
6.462 + typedef typename Container::reverse_iterator RIterator;
6.463 + typedef ReverseDigraph<const Digraph> RDigraph;
6.464 +
6.465 + RDigraph rgraph(graph);
6.466 +
6.467 + int cutNum = 0;
6.468 +
6.469 + typedef StronglyConnectedCutEdgesVisitor<RDigraph, ArcMap> RVisitor;
6.470 + RVisitor rvisitor(rgraph, cutMap, cutNum);
6.471 +
6.472 + DfsVisit<RDigraph, RVisitor> rdfs(rgraph, rvisitor);
6.473 +
6.474 + rdfs.init();
6.475 + for (RIterator it = nodes.rbegin(); it != nodes.rend(); ++it) {
6.476 + if (!rdfs.reached(*it)) {
6.477 + rdfs.addSource(*it);
6.478 + rdfs.start();
6.479 + }
6.480 + }
6.481 + return cutNum;
6.482 + }
6.483 +
6.484 + namespace _topology_bits {
6.485 +
6.486 + template <typename Digraph>
6.487 + class CountBiNodeConnectedComponentsVisitor : public DfsVisitor<Digraph> {
6.488 + public:
6.489 + typedef typename Digraph::Node Node;
6.490 + typedef typename Digraph::Arc Arc;
6.491 + typedef typename Digraph::Edge Edge;
6.492 +
6.493 + CountBiNodeConnectedComponentsVisitor(const Digraph& graph, int &compNum)
6.494 + : _graph(graph), _compNum(compNum),
6.495 + _numMap(graph), _retMap(graph), _predMap(graph), _num(0) {}
6.496 +
6.497 + void start(const Node& node) {
6.498 + _predMap.set(node, INVALID);
6.499 + }
6.500 +
6.501 + void reach(const Node& node) {
6.502 + _numMap.set(node, _num);
6.503 + _retMap.set(node, _num);
6.504 + ++_num;
6.505 + }
6.506 +
6.507 + void discover(const Arc& edge) {
6.508 + _predMap.set(_graph.target(edge), _graph.source(edge));
6.509 + }
6.510 +
6.511 + void examine(const Arc& edge) {
6.512 + if (_graph.source(edge) == _graph.target(edge) &&
6.513 + _graph.direction(edge)) {
6.514 + ++_compNum;
6.515 + return;
6.516 + }
6.517 + if (_predMap[_graph.source(edge)] == _graph.target(edge)) {
6.518 + return;
6.519 + }
6.520 + if (_retMap[_graph.source(edge)] > _numMap[_graph.target(edge)]) {
6.521 + _retMap.set(_graph.source(edge), _numMap[_graph.target(edge)]);
6.522 + }
6.523 + }
6.524 +
6.525 + void backtrack(const Arc& edge) {
6.526 + if (_retMap[_graph.source(edge)] > _retMap[_graph.target(edge)]) {
6.527 + _retMap.set(_graph.source(edge), _retMap[_graph.target(edge)]);
6.528 + }
6.529 + if (_numMap[_graph.source(edge)] <= _retMap[_graph.target(edge)]) {
6.530 + ++_compNum;
6.531 + }
6.532 + }
6.533 +
6.534 + private:
6.535 + const Digraph& _graph;
6.536 + int& _compNum;
6.537 +
6.538 + typename Digraph::template NodeMap<int> _numMap;
6.539 + typename Digraph::template NodeMap<int> _retMap;
6.540 + typename Digraph::template NodeMap<Node> _predMap;
6.541 + int _num;
6.542 + };
6.543 +
6.544 + template <typename Digraph, typename ArcMap>
6.545 + class BiNodeConnectedComponentsVisitor : public DfsVisitor<Digraph> {
6.546 + public:
6.547 + typedef typename Digraph::Node Node;
6.548 + typedef typename Digraph::Arc Arc;
6.549 + typedef typename Digraph::Edge Edge;
6.550 +
6.551 + BiNodeConnectedComponentsVisitor(const Digraph& graph,
6.552 + ArcMap& compMap, int &compNum)
6.553 + : _graph(graph), _compMap(compMap), _compNum(compNum),
6.554 + _numMap(graph), _retMap(graph), _predMap(graph), _num(0) {}
6.555 +
6.556 + void start(const Node& node) {
6.557 + _predMap.set(node, INVALID);
6.558 + }
6.559 +
6.560 + void reach(const Node& node) {
6.561 + _numMap.set(node, _num);
6.562 + _retMap.set(node, _num);
6.563 + ++_num;
6.564 + }
6.565 +
6.566 + void discover(const Arc& edge) {
6.567 + Node target = _graph.target(edge);
6.568 + _predMap.set(target, edge);
6.569 + _edgeStack.push(edge);
6.570 + }
6.571 +
6.572 + void examine(const Arc& edge) {
6.573 + Node source = _graph.source(edge);
6.574 + Node target = _graph.target(edge);
6.575 + if (source == target && _graph.direction(edge)) {
6.576 + _compMap.set(edge, _compNum);
6.577 + ++_compNum;
6.578 + return;
6.579 + }
6.580 + if (_numMap[target] < _numMap[source]) {
6.581 + if (_predMap[source] != _graph.oppositeArc(edge)) {
6.582 + _edgeStack.push(edge);
6.583 + }
6.584 + }
6.585 + if (_predMap[source] != INVALID &&
6.586 + target == _graph.source(_predMap[source])) {
6.587 + return;
6.588 + }
6.589 + if (_retMap[source] > _numMap[target]) {
6.590 + _retMap.set(source, _numMap[target]);
6.591 + }
6.592 + }
6.593 +
6.594 + void backtrack(const Arc& edge) {
6.595 + Node source = _graph.source(edge);
6.596 + Node target = _graph.target(edge);
6.597 + if (_retMap[source] > _retMap[target]) {
6.598 + _retMap.set(source, _retMap[target]);
6.599 + }
6.600 + if (_numMap[source] <= _retMap[target]) {
6.601 + while (_edgeStack.top() != edge) {
6.602 + _compMap.set(_edgeStack.top(), _compNum);
6.603 + _edgeStack.pop();
6.604 + }
6.605 + _compMap.set(edge, _compNum);
6.606 + _edgeStack.pop();
6.607 + ++_compNum;
6.608 + }
6.609 + }
6.610 +
6.611 + private:
6.612 + const Digraph& _graph;
6.613 + ArcMap& _compMap;
6.614 + int& _compNum;
6.615 +
6.616 + typename Digraph::template NodeMap<int> _numMap;
6.617 + typename Digraph::template NodeMap<int> _retMap;
6.618 + typename Digraph::template NodeMap<Arc> _predMap;
6.619 + std::stack<Edge> _edgeStack;
6.620 + int _num;
6.621 + };
6.622 +
6.623 +
6.624 + template <typename Digraph, typename NodeMap>
6.625 + class BiNodeConnectedCutNodesVisitor : public DfsVisitor<Digraph> {
6.626 + public:
6.627 + typedef typename Digraph::Node Node;
6.628 + typedef typename Digraph::Arc Arc;
6.629 + typedef typename Digraph::Edge Edge;
6.630 +
6.631 + BiNodeConnectedCutNodesVisitor(const Digraph& graph, NodeMap& cutMap,
6.632 + int& cutNum)
6.633 + : _graph(graph), _cutMap(cutMap), _cutNum(cutNum),
6.634 + _numMap(graph), _retMap(graph), _predMap(graph), _num(0) {}
6.635 +
6.636 + void start(const Node& node) {
6.637 + _predMap.set(node, INVALID);
6.638 + rootCut = false;
6.639 + }
6.640 +
6.641 + void reach(const Node& node) {
6.642 + _numMap.set(node, _num);
6.643 + _retMap.set(node, _num);
6.644 + ++_num;
6.645 + }
6.646 +
6.647 + void discover(const Arc& edge) {
6.648 + _predMap.set(_graph.target(edge), _graph.source(edge));
6.649 + }
6.650 +
6.651 + void examine(const Arc& edge) {
6.652 + if (_graph.source(edge) == _graph.target(edge) &&
6.653 + _graph.direction(edge)) {
6.654 + if (!_cutMap[_graph.source(edge)]) {
6.655 + _cutMap.set(_graph.source(edge), true);
6.656 + ++_cutNum;
6.657 + }
6.658 + return;
6.659 + }
6.660 + if (_predMap[_graph.source(edge)] == _graph.target(edge)) return;
6.661 + if (_retMap[_graph.source(edge)] > _numMap[_graph.target(edge)]) {
6.662 + _retMap.set(_graph.source(edge), _numMap[_graph.target(edge)]);
6.663 + }
6.664 + }
6.665 +
6.666 + void backtrack(const Arc& edge) {
6.667 + if (_retMap[_graph.source(edge)] > _retMap[_graph.target(edge)]) {
6.668 + _retMap.set(_graph.source(edge), _retMap[_graph.target(edge)]);
6.669 + }
6.670 + if (_numMap[_graph.source(edge)] <= _retMap[_graph.target(edge)]) {
6.671 + if (_predMap[_graph.source(edge)] != INVALID) {
6.672 + if (!_cutMap[_graph.source(edge)]) {
6.673 + _cutMap.set(_graph.source(edge), true);
6.674 + ++_cutNum;
6.675 + }
6.676 + } else if (rootCut) {
6.677 + if (!_cutMap[_graph.source(edge)]) {
6.678 + _cutMap.set(_graph.source(edge), true);
6.679 + ++_cutNum;
6.680 + }
6.681 + } else {
6.682 + rootCut = true;
6.683 + }
6.684 + }
6.685 + }
6.686 +
6.687 + private:
6.688 + const Digraph& _graph;
6.689 + NodeMap& _cutMap;
6.690 + int& _cutNum;
6.691 +
6.692 + typename Digraph::template NodeMap<int> _numMap;
6.693 + typename Digraph::template NodeMap<int> _retMap;
6.694 + typename Digraph::template NodeMap<Node> _predMap;
6.695 + std::stack<Edge> _edgeStack;
6.696 + int _num;
6.697 + bool rootCut;
6.698 + };
6.699 +
6.700 + }
6.701 +
6.702 + template <typename Graph>
6.703 + int countBiNodeConnectedComponents(const Graph& graph);
6.704 +
6.705 + /// \ingroup connectivity
6.706 + ///
6.707 + /// \brief Checks the graph is bi-node-connected.
6.708 + ///
6.709 + /// This function checks that the undirected graph is bi-node-connected
6.710 + /// graph. The graph is bi-node-connected if any two undirected edge is
6.711 + /// on same circle.
6.712 + ///
6.713 + /// \param graph The graph.
6.714 + /// \return %True when the graph bi-node-connected.
6.715 + template <typename Graph>
6.716 + bool biNodeConnected(const Graph& graph) {
6.717 + return countBiNodeConnectedComponents(graph) <= 1;
6.718 + }
6.719 +
6.720 + /// \ingroup connectivity
6.721 + ///
6.722 + /// \brief Count the biconnected components.
6.723 + ///
6.724 + /// This function finds the bi-node-connected components in an undirected
6.725 + /// graph. The biconnected components are the classes of an equivalence
6.726 + /// relation on the undirected edges. Two undirected edge is in relationship
6.727 + /// when they are on same circle.
6.728 + ///
6.729 + /// \param graph The graph.
6.730 + /// \return The number of components.
6.731 + template <typename Graph>
6.732 + int countBiNodeConnectedComponents(const Graph& graph) {
6.733 + checkConcept<concepts::Graph, Graph>();
6.734 + typedef typename Graph::NodeIt NodeIt;
6.735 +
6.736 + using namespace _topology_bits;
6.737 +
6.738 + typedef CountBiNodeConnectedComponentsVisitor<Graph> Visitor;
6.739 +
6.740 + int compNum = 0;
6.741 + Visitor visitor(graph, compNum);
6.742 +
6.743 + DfsVisit<Graph, Visitor> dfs(graph, visitor);
6.744 + dfs.init();
6.745 +
6.746 + for (NodeIt it(graph); it != INVALID; ++it) {
6.747 + if (!dfs.reached(it)) {
6.748 + dfs.addSource(it);
6.749 + dfs.start();
6.750 + }
6.751 + }
6.752 + return compNum;
6.753 + }
6.754 +
6.755 + /// \ingroup connectivity
6.756 + ///
6.757 + /// \brief Find the bi-node-connected components.
6.758 + ///
6.759 + /// This function finds the bi-node-connected components in an undirected
6.760 + /// graph. The bi-node-connected components are the classes of an equivalence
6.761 + /// relation on the undirected edges. Two undirected edge are in relationship
6.762 + /// when they are on same circle.
6.763 + ///
6.764 + /// \param graph The graph.
6.765 + /// \retval compMap A writable uedge map. The values will be set from 0
6.766 + /// to the number of the biconnected components minus one. Each values
6.767 + /// of the map will be set exactly once, the values of a certain component
6.768 + /// will be set continuously.
6.769 + /// \return The number of components.
6.770 + ///
6.771 + template <typename Graph, typename EdgeMap>
6.772 + int biNodeConnectedComponents(const Graph& graph,
6.773 + EdgeMap& compMap) {
6.774 + checkConcept<concepts::Graph, Graph>();
6.775 + typedef typename Graph::NodeIt NodeIt;
6.776 + typedef typename Graph::Edge Edge;
6.777 + checkConcept<concepts::WriteMap<Edge, int>, EdgeMap>();
6.778 +
6.779 + using namespace _topology_bits;
6.780 +
6.781 + typedef BiNodeConnectedComponentsVisitor<Graph, EdgeMap> Visitor;
6.782 +
6.783 + int compNum = 0;
6.784 + Visitor visitor(graph, compMap, compNum);
6.785 +
6.786 + DfsVisit<Graph, Visitor> dfs(graph, visitor);
6.787 + dfs.init();
6.788 +
6.789 + for (NodeIt it(graph); it != INVALID; ++it) {
6.790 + if (!dfs.reached(it)) {
6.791 + dfs.addSource(it);
6.792 + dfs.start();
6.793 + }
6.794 + }
6.795 + return compNum;
6.796 + }
6.797 +
6.798 + /// \ingroup connectivity
6.799 + ///
6.800 + /// \brief Find the bi-node-connected cut nodes.
6.801 + ///
6.802 + /// This function finds the bi-node-connected cut nodes in an undirected
6.803 + /// graph. The bi-node-connected components are the classes of an equivalence
6.804 + /// relation on the undirected edges. Two undirected edges are in
6.805 + /// relationship when they are on same circle. The biconnected components
6.806 + /// are separted by nodes which are the cut nodes of the components.
6.807 + ///
6.808 + /// \param graph The graph.
6.809 + /// \retval cutMap A writable edge map. The values will be set true when
6.810 + /// the node separate two or more components.
6.811 + /// \return The number of the cut nodes.
6.812 + template <typename Graph, typename NodeMap>
6.813 + int biNodeConnectedCutNodes(const Graph& graph, NodeMap& cutMap) {
6.814 + checkConcept<concepts::Graph, Graph>();
6.815 + typedef typename Graph::Node Node;
6.816 + typedef typename Graph::NodeIt NodeIt;
6.817 + checkConcept<concepts::WriteMap<Node, bool>, NodeMap>();
6.818 +
6.819 + using namespace _topology_bits;
6.820 +
6.821 + typedef BiNodeConnectedCutNodesVisitor<Graph, NodeMap> Visitor;
6.822 +
6.823 + int cutNum = 0;
6.824 + Visitor visitor(graph, cutMap, cutNum);
6.825 +
6.826 + DfsVisit<Graph, Visitor> dfs(graph, visitor);
6.827 + dfs.init();
6.828 +
6.829 + for (NodeIt it(graph); it != INVALID; ++it) {
6.830 + if (!dfs.reached(it)) {
6.831 + dfs.addSource(it);
6.832 + dfs.start();
6.833 + }
6.834 + }
6.835 + return cutNum;
6.836 + }
6.837 +
6.838 + namespace _topology_bits {
6.839 +
6.840 + template <typename Digraph>
6.841 + class CountBiEdgeConnectedComponentsVisitor : public DfsVisitor<Digraph> {
6.842 + public:
6.843 + typedef typename Digraph::Node Node;
6.844 + typedef typename Digraph::Arc Arc;
6.845 + typedef typename Digraph::Edge Edge;
6.846 +
6.847 + CountBiEdgeConnectedComponentsVisitor(const Digraph& graph, int &compNum)
6.848 + : _graph(graph), _compNum(compNum),
6.849 + _numMap(graph), _retMap(graph), _predMap(graph), _num(0) {}
6.850 +
6.851 + void start(const Node& node) {
6.852 + _predMap.set(node, INVALID);
6.853 + }
6.854 +
6.855 + void reach(const Node& node) {
6.856 + _numMap.set(node, _num);
6.857 + _retMap.set(node, _num);
6.858 + ++_num;
6.859 + }
6.860 +
6.861 + void leave(const Node& node) {
6.862 + if (_numMap[node] <= _retMap[node]) {
6.863 + ++_compNum;
6.864 + }
6.865 + }
6.866 +
6.867 + void discover(const Arc& edge) {
6.868 + _predMap.set(_graph.target(edge), edge);
6.869 + }
6.870 +
6.871 + void examine(const Arc& edge) {
6.872 + if (_predMap[_graph.source(edge)] == _graph.oppositeArc(edge)) {
6.873 + return;
6.874 + }
6.875 + if (_retMap[_graph.source(edge)] > _retMap[_graph.target(edge)]) {
6.876 + _retMap.set(_graph.source(edge), _retMap[_graph.target(edge)]);
6.877 + }
6.878 + }
6.879 +
6.880 + void backtrack(const Arc& edge) {
6.881 + if (_retMap[_graph.source(edge)] > _retMap[_graph.target(edge)]) {
6.882 + _retMap.set(_graph.source(edge), _retMap[_graph.target(edge)]);
6.883 + }
6.884 + }
6.885 +
6.886 + private:
6.887 + const Digraph& _graph;
6.888 + int& _compNum;
6.889 +
6.890 + typename Digraph::template NodeMap<int> _numMap;
6.891 + typename Digraph::template NodeMap<int> _retMap;
6.892 + typename Digraph::template NodeMap<Arc> _predMap;
6.893 + int _num;
6.894 + };
6.895 +
6.896 + template <typename Digraph, typename NodeMap>
6.897 + class BiEdgeConnectedComponentsVisitor : public DfsVisitor<Digraph> {
6.898 + public:
6.899 + typedef typename Digraph::Node Node;
6.900 + typedef typename Digraph::Arc Arc;
6.901 + typedef typename Digraph::Edge Edge;
6.902 +
6.903 + BiEdgeConnectedComponentsVisitor(const Digraph& graph,
6.904 + NodeMap& compMap, int &compNum)
6.905 + : _graph(graph), _compMap(compMap), _compNum(compNum),
6.906 + _numMap(graph), _retMap(graph), _predMap(graph), _num(0) {}
6.907 +
6.908 + void start(const Node& node) {
6.909 + _predMap.set(node, INVALID);
6.910 + }
6.911 +
6.912 + void reach(const Node& node) {
6.913 + _numMap.set(node, _num);
6.914 + _retMap.set(node, _num);
6.915 + _nodeStack.push(node);
6.916 + ++_num;
6.917 + }
6.918 +
6.919 + void leave(const Node& node) {
6.920 + if (_numMap[node] <= _retMap[node]) {
6.921 + while (_nodeStack.top() != node) {
6.922 + _compMap.set(_nodeStack.top(), _compNum);
6.923 + _nodeStack.pop();
6.924 + }
6.925 + _compMap.set(node, _compNum);
6.926 + _nodeStack.pop();
6.927 + ++_compNum;
6.928 + }
6.929 + }
6.930 +
6.931 + void discover(const Arc& edge) {
6.932 + _predMap.set(_graph.target(edge), edge);
6.933 + }
6.934 +
6.935 + void examine(const Arc& edge) {
6.936 + if (_predMap[_graph.source(edge)] == _graph.oppositeArc(edge)) {
6.937 + return;
6.938 + }
6.939 + if (_retMap[_graph.source(edge)] > _retMap[_graph.target(edge)]) {
6.940 + _retMap.set(_graph.source(edge), _retMap[_graph.target(edge)]);
6.941 + }
6.942 + }
6.943 +
6.944 + void backtrack(const Arc& edge) {
6.945 + if (_retMap[_graph.source(edge)] > _retMap[_graph.target(edge)]) {
6.946 + _retMap.set(_graph.source(edge), _retMap[_graph.target(edge)]);
6.947 + }
6.948 + }
6.949 +
6.950 + private:
6.951 + const Digraph& _graph;
6.952 + NodeMap& _compMap;
6.953 + int& _compNum;
6.954 +
6.955 + typename Digraph::template NodeMap<int> _numMap;
6.956 + typename Digraph::template NodeMap<int> _retMap;
6.957 + typename Digraph::template NodeMap<Arc> _predMap;
6.958 + std::stack<Node> _nodeStack;
6.959 + int _num;
6.960 + };
6.961 +
6.962 +
6.963 + template <typename Digraph, typename ArcMap>
6.964 + class BiEdgeConnectedCutEdgesVisitor : public DfsVisitor<Digraph> {
6.965 + public:
6.966 + typedef typename Digraph::Node Node;
6.967 + typedef typename Digraph::Arc Arc;
6.968 + typedef typename Digraph::Edge Edge;
6.969 +
6.970 + BiEdgeConnectedCutEdgesVisitor(const Digraph& graph,
6.971 + ArcMap& cutMap, int &cutNum)
6.972 + : _graph(graph), _cutMap(cutMap), _cutNum(cutNum),
6.973 + _numMap(graph), _retMap(graph), _predMap(graph), _num(0) {}
6.974 +
6.975 + void start(const Node& node) {
6.976 + _predMap[node] = INVALID;
6.977 + }
6.978 +
6.979 + void reach(const Node& node) {
6.980 + _numMap.set(node, _num);
6.981 + _retMap.set(node, _num);
6.982 + ++_num;
6.983 + }
6.984 +
6.985 + void leave(const Node& node) {
6.986 + if (_numMap[node] <= _retMap[node]) {
6.987 + if (_predMap[node] != INVALID) {
6.988 + _cutMap.set(_predMap[node], true);
6.989 + ++_cutNum;
6.990 + }
6.991 + }
6.992 + }
6.993 +
6.994 + void discover(const Arc& edge) {
6.995 + _predMap.set(_graph.target(edge), edge);
6.996 + }
6.997 +
6.998 + void examine(const Arc& edge) {
6.999 + if (_predMap[_graph.source(edge)] == _graph.oppositeArc(edge)) {
6.1000 + return;
6.1001 + }
6.1002 + if (_retMap[_graph.source(edge)] > _retMap[_graph.target(edge)]) {
6.1003 + _retMap.set(_graph.source(edge), _retMap[_graph.target(edge)]);
6.1004 + }
6.1005 + }
6.1006 +
6.1007 + void backtrack(const Arc& edge) {
6.1008 + if (_retMap[_graph.source(edge)] > _retMap[_graph.target(edge)]) {
6.1009 + _retMap.set(_graph.source(edge), _retMap[_graph.target(edge)]);
6.1010 + }
6.1011 + }
6.1012 +
6.1013 + private:
6.1014 + const Digraph& _graph;
6.1015 + ArcMap& _cutMap;
6.1016 + int& _cutNum;
6.1017 +
6.1018 + typename Digraph::template NodeMap<int> _numMap;
6.1019 + typename Digraph::template NodeMap<int> _retMap;
6.1020 + typename Digraph::template NodeMap<Arc> _predMap;
6.1021 + int _num;
6.1022 + };
6.1023 + }
6.1024 +
6.1025 + template <typename Graph>
6.1026 + int countBiEdgeConnectedComponents(const Graph& graph);
6.1027 +
6.1028 + /// \ingroup connectivity
6.1029 + ///
6.1030 + /// \brief Checks that the graph is bi-edge-connected.
6.1031 + ///
6.1032 + /// This function checks that the graph is bi-edge-connected. The undirected
6.1033 + /// graph is bi-edge-connected when any two nodes are connected with two
6.1034 + /// edge-disjoint paths.
6.1035 + ///
6.1036 + /// \param graph The undirected graph.
6.1037 + /// \return The number of components.
6.1038 + template <typename Graph>
6.1039 + bool biEdgeConnected(const Graph& graph) {
6.1040 + return countBiEdgeConnectedComponents(graph) <= 1;
6.1041 + }
6.1042 +
6.1043 + /// \ingroup connectivity
6.1044 + ///
6.1045 + /// \brief Count the bi-edge-connected components.
6.1046 + ///
6.1047 + /// This function count the bi-edge-connected components in an undirected
6.1048 + /// graph. The bi-edge-connected components are the classes of an equivalence
6.1049 + /// relation on the nodes. Two nodes are in relationship when they are
6.1050 + /// connected with at least two edge-disjoint paths.
6.1051 + ///
6.1052 + /// \param graph The undirected graph.
6.1053 + /// \return The number of components.
6.1054 + template <typename Graph>
6.1055 + int countBiEdgeConnectedComponents(const Graph& graph) {
6.1056 + checkConcept<concepts::Graph, Graph>();
6.1057 + typedef typename Graph::NodeIt NodeIt;
6.1058 +
6.1059 + using namespace _topology_bits;
6.1060 +
6.1061 + typedef CountBiEdgeConnectedComponentsVisitor<Graph> Visitor;
6.1062 +
6.1063 + int compNum = 0;
6.1064 + Visitor visitor(graph, compNum);
6.1065 +
6.1066 + DfsVisit<Graph, Visitor> dfs(graph, visitor);
6.1067 + dfs.init();
6.1068 +
6.1069 + for (NodeIt it(graph); it != INVALID; ++it) {
6.1070 + if (!dfs.reached(it)) {
6.1071 + dfs.addSource(it);
6.1072 + dfs.start();
6.1073 + }
6.1074 + }
6.1075 + return compNum;
6.1076 + }
6.1077 +
6.1078 + /// \ingroup connectivity
6.1079 + ///
6.1080 + /// \brief Find the bi-edge-connected components.
6.1081 + ///
6.1082 + /// This function finds the bi-edge-connected components in an undirected
6.1083 + /// graph. The bi-edge-connected components are the classes of an equivalence
6.1084 + /// relation on the nodes. Two nodes are in relationship when they are
6.1085 + /// connected at least two edge-disjoint paths.
6.1086 + ///
6.1087 + /// \param graph The graph.
6.1088 + /// \retval compMap A writable node map. The values will be set from 0 to
6.1089 + /// the number of the biconnected components minus one. Each values
6.1090 + /// of the map will be set exactly once, the values of a certain component
6.1091 + /// will be set continuously.
6.1092 + /// \return The number of components.
6.1093 + ///
6.1094 + template <typename Graph, typename NodeMap>
6.1095 + int biEdgeConnectedComponents(const Graph& graph, NodeMap& compMap) {
6.1096 + checkConcept<concepts::Graph, Graph>();
6.1097 + typedef typename Graph::NodeIt NodeIt;
6.1098 + typedef typename Graph::Node Node;
6.1099 + checkConcept<concepts::WriteMap<Node, int>, NodeMap>();
6.1100 +
6.1101 + using namespace _topology_bits;
6.1102 +
6.1103 + typedef BiEdgeConnectedComponentsVisitor<Graph, NodeMap> Visitor;
6.1104 +
6.1105 + int compNum = 0;
6.1106 + Visitor visitor(graph, compMap, compNum);
6.1107 +
6.1108 + DfsVisit<Graph, Visitor> dfs(graph, visitor);
6.1109 + dfs.init();
6.1110 +
6.1111 + for (NodeIt it(graph); it != INVALID; ++it) {
6.1112 + if (!dfs.reached(it)) {
6.1113 + dfs.addSource(it);
6.1114 + dfs.start();
6.1115 + }
6.1116 + }
6.1117 + return compNum;
6.1118 + }
6.1119 +
6.1120 + /// \ingroup connectivity
6.1121 + ///
6.1122 + /// \brief Find the bi-edge-connected cut edges.
6.1123 + ///
6.1124 + /// This function finds the bi-edge-connected components in an undirected
6.1125 + /// graph. The bi-edge-connected components are the classes of an equivalence
6.1126 + /// relation on the nodes. Two nodes are in relationship when they are
6.1127 + /// connected with at least two edge-disjoint paths. The bi-edge-connected
6.1128 + /// components are separted by edges which are the cut edges of the
6.1129 + /// components.
6.1130 + ///
6.1131 + /// \param graph The graph.
6.1132 + /// \retval cutMap A writable node map. The values will be set true when the
6.1133 + /// edge is a cut edge.
6.1134 + /// \return The number of cut edges.
6.1135 + template <typename Graph, typename EdgeMap>
6.1136 + int biEdgeConnectedCutEdges(const Graph& graph, EdgeMap& cutMap) {
6.1137 + checkConcept<concepts::Graph, Graph>();
6.1138 + typedef typename Graph::NodeIt NodeIt;
6.1139 + typedef typename Graph::Edge Edge;
6.1140 + checkConcept<concepts::WriteMap<Edge, bool>, EdgeMap>();
6.1141 +
6.1142 + using namespace _topology_bits;
6.1143 +
6.1144 + typedef BiEdgeConnectedCutEdgesVisitor<Graph, EdgeMap> Visitor;
6.1145 +
6.1146 + int cutNum = 0;
6.1147 + Visitor visitor(graph, cutMap, cutNum);
6.1148 +
6.1149 + DfsVisit<Graph, Visitor> dfs(graph, visitor);
6.1150 + dfs.init();
6.1151 +
6.1152 + for (NodeIt it(graph); it != INVALID; ++it) {
6.1153 + if (!dfs.reached(it)) {
6.1154 + dfs.addSource(it);
6.1155 + dfs.start();
6.1156 + }
6.1157 + }
6.1158 + return cutNum;
6.1159 + }
6.1160 +
6.1161 +
6.1162 + namespace _topology_bits {
6.1163 +
6.1164 + template <typename Digraph, typename IntNodeMap>
6.1165 + class TopologicalSortVisitor : public DfsVisitor<Digraph> {
6.1166 + public:
6.1167 + typedef typename Digraph::Node Node;
6.1168 + typedef typename Digraph::Arc edge;
6.1169 +
6.1170 + TopologicalSortVisitor(IntNodeMap& order, int num)
6.1171 + : _order(order), _num(num) {}
6.1172 +
6.1173 + void leave(const Node& node) {
6.1174 + _order.set(node, --_num);
6.1175 + }
6.1176 +
6.1177 + private:
6.1178 + IntNodeMap& _order;
6.1179 + int _num;
6.1180 + };
6.1181 +
6.1182 + }
6.1183 +
6.1184 + /// \ingroup connectivity
6.1185 + ///
6.1186 + /// \brief Sort the nodes of a DAG into topolgical order.
6.1187 + ///
6.1188 + /// Sort the nodes of a DAG into topolgical order.
6.1189 + ///
6.1190 + /// \param graph The graph. It must be directed and acyclic.
6.1191 + /// \retval order A writable node map. The values will be set from 0 to
6.1192 + /// the number of the nodes in the graph minus one. Each values of the map
6.1193 + /// will be set exactly once, the values will be set descending order.
6.1194 + ///
6.1195 + /// \see checkedTopologicalSort
6.1196 + /// \see dag
6.1197 + template <typename Digraph, typename NodeMap>
6.1198 + void topologicalSort(const Digraph& graph, NodeMap& order) {
6.1199 + using namespace _topology_bits;
6.1200 +
6.1201 + checkConcept<concepts::Digraph, Digraph>();
6.1202 + checkConcept<concepts::WriteMap<typename Digraph::Node, int>, NodeMap>();
6.1203 +
6.1204 + typedef typename Digraph::Node Node;
6.1205 + typedef typename Digraph::NodeIt NodeIt;
6.1206 + typedef typename Digraph::Arc Arc;
6.1207 +
6.1208 + TopologicalSortVisitor<Digraph, NodeMap>
6.1209 + visitor(order, countNodes(graph));
6.1210 +
6.1211 + DfsVisit<Digraph, TopologicalSortVisitor<Digraph, NodeMap> >
6.1212 + dfs(graph, visitor);
6.1213 +
6.1214 + dfs.init();
6.1215 + for (NodeIt it(graph); it != INVALID; ++it) {
6.1216 + if (!dfs.reached(it)) {
6.1217 + dfs.addSource(it);
6.1218 + dfs.start();
6.1219 + }
6.1220 + }
6.1221 + }
6.1222 +
6.1223 + /// \ingroup connectivity
6.1224 + ///
6.1225 + /// \brief Sort the nodes of a DAG into topolgical order.
6.1226 + ///
6.1227 + /// Sort the nodes of a DAG into topolgical order. It also checks
6.1228 + /// that the given graph is DAG.
6.1229 + ///
6.1230 + /// \param graph The graph. It must be directed and acyclic.
6.1231 + /// \retval order A readable - writable node map. The values will be set
6.1232 + /// from 0 to the number of the nodes in the graph minus one. Each values
6.1233 + /// of the map will be set exactly once, the values will be set descending
6.1234 + /// order.
6.1235 + /// \return %False when the graph is not DAG.
6.1236 + ///
6.1237 + /// \see topologicalSort
6.1238 + /// \see dag
6.1239 + template <typename Digraph, typename NodeMap>
6.1240 + bool checkedTopologicalSort(const Digraph& graph, NodeMap& order) {
6.1241 + using namespace _topology_bits;
6.1242 +
6.1243 + checkConcept<concepts::Digraph, Digraph>();
6.1244 + checkConcept<concepts::ReadWriteMap<typename Digraph::Node, int>,
6.1245 + NodeMap>();
6.1246 +
6.1247 + typedef typename Digraph::Node Node;
6.1248 + typedef typename Digraph::NodeIt NodeIt;
6.1249 + typedef typename Digraph::Arc Arc;
6.1250 +
6.1251 + order = constMap<Node, int, -1>();
6.1252 +
6.1253 + TopologicalSortVisitor<Digraph, NodeMap>
6.1254 + visitor(order, countNodes(graph));
6.1255 +
6.1256 + DfsVisit<Digraph, TopologicalSortVisitor<Digraph, NodeMap> >
6.1257 + dfs(graph, visitor);
6.1258 +
6.1259 + dfs.init();
6.1260 + for (NodeIt it(graph); it != INVALID; ++it) {
6.1261 + if (!dfs.reached(it)) {
6.1262 + dfs.addSource(it);
6.1263 + while (!dfs.emptyQueue()) {
6.1264 + Arc edge = dfs.nextArc();
6.1265 + Node target = graph.target(edge);
6.1266 + if (dfs.reached(target) && order[target] == -1) {
6.1267 + return false;
6.1268 + }
6.1269 + dfs.processNextArc();
6.1270 + }
6.1271 + }
6.1272 + }
6.1273 + return true;
6.1274 + }
6.1275 +
6.1276 + /// \ingroup connectivity
6.1277 + ///
6.1278 + /// \brief Check that the given directed graph is a DAG.
6.1279 + ///
6.1280 + /// Check that the given directed graph is a DAG. The DAG is
6.1281 + /// an Directed Acyclic Digraph.
6.1282 + /// \return %False when the graph is not DAG.
6.1283 + /// \see acyclic
6.1284 + template <typename Digraph>
6.1285 + bool dag(const Digraph& graph) {
6.1286 +
6.1287 + checkConcept<concepts::Digraph, Digraph>();
6.1288 +
6.1289 + typedef typename Digraph::Node Node;
6.1290 + typedef typename Digraph::NodeIt NodeIt;
6.1291 + typedef typename Digraph::Arc Arc;
6.1292 +
6.1293 + typedef typename Digraph::template NodeMap<bool> ProcessedMap;
6.1294 +
6.1295 + typename Dfs<Digraph>::template SetProcessedMap<ProcessedMap>::
6.1296 + Create dfs(graph);
6.1297 +
6.1298 + ProcessedMap processed(graph);
6.1299 + dfs.processedMap(processed);
6.1300 +
6.1301 + dfs.init();
6.1302 + for (NodeIt it(graph); it != INVALID; ++it) {
6.1303 + if (!dfs.reached(it)) {
6.1304 + dfs.addSource(it);
6.1305 + while (!dfs.emptyQueue()) {
6.1306 + Arc edge = dfs.nextArc();
6.1307 + Node target = graph.target(edge);
6.1308 + if (dfs.reached(target) && !processed[target]) {
6.1309 + return false;
6.1310 + }
6.1311 + dfs.processNextArc();
6.1312 + }
6.1313 + }
6.1314 + }
6.1315 + return true;
6.1316 + }
6.1317 +
6.1318 + /// \ingroup connectivity
6.1319 + ///
6.1320 + /// \brief Check that the given undirected graph is acyclic.
6.1321 + ///
6.1322 + /// Check that the given undirected graph acyclic.
6.1323 + /// \param graph The undirected graph.
6.1324 + /// \return %True when there is no circle in the graph.
6.1325 + /// \see dag
6.1326 + template <typename Graph>
6.1327 + bool acyclic(const Graph& graph) {
6.1328 + checkConcept<concepts::Graph, Graph>();
6.1329 + typedef typename Graph::Node Node;
6.1330 + typedef typename Graph::NodeIt NodeIt;
6.1331 + typedef typename Graph::Arc Arc;
6.1332 + Dfs<Graph> dfs(graph);
6.1333 + dfs.init();
6.1334 + for (NodeIt it(graph); it != INVALID; ++it) {
6.1335 + if (!dfs.reached(it)) {
6.1336 + dfs.addSource(it);
6.1337 + while (!dfs.emptyQueue()) {
6.1338 + Arc edge = dfs.nextArc();
6.1339 + Node source = graph.source(edge);
6.1340 + Node target = graph.target(edge);
6.1341 + if (dfs.reached(target) &&
6.1342 + dfs.predArc(source) != graph.oppositeArc(edge)) {
6.1343 + return false;
6.1344 + }
6.1345 + dfs.processNextArc();
6.1346 + }
6.1347 + }
6.1348 + }
6.1349 + return true;
6.1350 + }
6.1351 +
6.1352 + /// \ingroup connectivity
6.1353 + ///
6.1354 + /// \brief Check that the given undirected graph is tree.
6.1355 + ///
6.1356 + /// Check that the given undirected graph is tree.
6.1357 + /// \param graph The undirected graph.
6.1358 + /// \return %True when the graph is acyclic and connected.
6.1359 + template <typename Graph>
6.1360 + bool tree(const Graph& graph) {
6.1361 + checkConcept<concepts::Graph, Graph>();
6.1362 + typedef typename Graph::Node Node;
6.1363 + typedef typename Graph::NodeIt NodeIt;
6.1364 + typedef typename Graph::Arc Arc;
6.1365 + Dfs<Graph> dfs(graph);
6.1366 + dfs.init();
6.1367 + dfs.addSource(NodeIt(graph));
6.1368 + while (!dfs.emptyQueue()) {
6.1369 + Arc edge = dfs.nextArc();
6.1370 + Node source = graph.source(edge);
6.1371 + Node target = graph.target(edge);
6.1372 + if (dfs.reached(target) &&
6.1373 + dfs.predArc(source) != graph.oppositeArc(edge)) {
6.1374 + return false;
6.1375 + }
6.1376 + dfs.processNextArc();
6.1377 + }
6.1378 + for (NodeIt it(graph); it != INVALID; ++it) {
6.1379 + if (!dfs.reached(it)) {
6.1380 + return false;
6.1381 + }
6.1382 + }
6.1383 + return true;
6.1384 + }
6.1385 +
6.1386 + namespace _topology_bits {
6.1387 +
6.1388 + template <typename Digraph>
6.1389 + class BipartiteVisitor : public BfsVisitor<Digraph> {
6.1390 + public:
6.1391 + typedef typename Digraph::Arc Arc;
6.1392 + typedef typename Digraph::Node Node;
6.1393 +
6.1394 + BipartiteVisitor(const Digraph& graph, bool& bipartite)
6.1395 + : _graph(graph), _part(graph), _bipartite(bipartite) {}
6.1396 +
6.1397 + void start(const Node& node) {
6.1398 + _part[node] = true;
6.1399 + }
6.1400 + void discover(const Arc& edge) {
6.1401 + _part.set(_graph.target(edge), !_part[_graph.source(edge)]);
6.1402 + }
6.1403 + void examine(const Arc& edge) {
6.1404 + _bipartite = _bipartite &&
6.1405 + _part[_graph.target(edge)] != _part[_graph.source(edge)];
6.1406 + }
6.1407 +
6.1408 + private:
6.1409 +
6.1410 + const Digraph& _graph;
6.1411 + typename Digraph::template NodeMap<bool> _part;
6.1412 + bool& _bipartite;
6.1413 + };
6.1414 +
6.1415 + template <typename Digraph, typename PartMap>
6.1416 + class BipartitePartitionsVisitor : public BfsVisitor<Digraph> {
6.1417 + public:
6.1418 + typedef typename Digraph::Arc Arc;
6.1419 + typedef typename Digraph::Node Node;
6.1420 +
6.1421 + BipartitePartitionsVisitor(const Digraph& graph,
6.1422 + PartMap& part, bool& bipartite)
6.1423 + : _graph(graph), _part(part), _bipartite(bipartite) {}
6.1424 +
6.1425 + void start(const Node& node) {
6.1426 + _part.set(node, true);
6.1427 + }
6.1428 + void discover(const Arc& edge) {
6.1429 + _part.set(_graph.target(edge), !_part[_graph.source(edge)]);
6.1430 + }
6.1431 + void examine(const Arc& edge) {
6.1432 + _bipartite = _bipartite &&
6.1433 + _part[_graph.target(edge)] != _part[_graph.source(edge)];
6.1434 + }
6.1435 +
6.1436 + private:
6.1437 +
6.1438 + const Digraph& _graph;
6.1439 + PartMap& _part;
6.1440 + bool& _bipartite;
6.1441 + };
6.1442 + }
6.1443 +
6.1444 + /// \ingroup connectivity
6.1445 + ///
6.1446 + /// \brief Check if the given undirected graph is bipartite or not
6.1447 + ///
6.1448 + /// The function checks if the given undirected \c graph graph is bipartite
6.1449 + /// or not. The \ref Bfs algorithm is used to calculate the result.
6.1450 + /// \param graph The undirected graph.
6.1451 + /// \return %True if \c graph is bipartite, %false otherwise.
6.1452 + /// \sa bipartitePartitions
6.1453 + template<typename Graph>
6.1454 + inline bool bipartite(const Graph &graph){
6.1455 + using namespace _topology_bits;
6.1456 +
6.1457 + checkConcept<concepts::Graph, Graph>();
6.1458 +
6.1459 + typedef typename Graph::NodeIt NodeIt;
6.1460 + typedef typename Graph::ArcIt ArcIt;
6.1461 +
6.1462 + bool bipartite = true;
6.1463 +
6.1464 + BipartiteVisitor<Graph>
6.1465 + visitor(graph, bipartite);
6.1466 + BfsVisit<Graph, BipartiteVisitor<Graph> >
6.1467 + bfs(graph, visitor);
6.1468 + bfs.init();
6.1469 + for(NodeIt it(graph); it != INVALID; ++it) {
6.1470 + if(!bfs.reached(it)){
6.1471 + bfs.addSource(it);
6.1472 + while (!bfs.emptyQueue()) {
6.1473 + bfs.processNextNode();
6.1474 + if (!bipartite) return false;
6.1475 + }
6.1476 + }
6.1477 + }
6.1478 + return true;
6.1479 + }
6.1480 +
6.1481 + /// \ingroup connectivity
6.1482 + ///
6.1483 + /// \brief Check if the given undirected graph is bipartite or not
6.1484 + ///
6.1485 + /// The function checks if the given undirected graph is bipartite
6.1486 + /// or not. The \ref Bfs algorithm is used to calculate the result.
6.1487 + /// During the execution, the \c partMap will be set as the two
6.1488 + /// partitions of the graph.
6.1489 + /// \param graph The undirected graph.
6.1490 + /// \retval partMap A writable bool map of nodes. It will be set as the
6.1491 + /// two partitions of the graph.
6.1492 + /// \return %True if \c graph is bipartite, %false otherwise.
6.1493 + template<typename Graph, typename NodeMap>
6.1494 + inline bool bipartitePartitions(const Graph &graph, NodeMap &partMap){
6.1495 + using namespace _topology_bits;
6.1496 +
6.1497 + checkConcept<concepts::Graph, Graph>();
6.1498 +
6.1499 + typedef typename Graph::Node Node;
6.1500 + typedef typename Graph::NodeIt NodeIt;
6.1501 + typedef typename Graph::ArcIt ArcIt;
6.1502 +
6.1503 + bool bipartite = true;
6.1504 +
6.1505 + BipartitePartitionsVisitor<Graph, NodeMap>
6.1506 + visitor(graph, partMap, bipartite);
6.1507 + BfsVisit<Graph, BipartitePartitionsVisitor<Graph, NodeMap> >
6.1508 + bfs(graph, visitor);
6.1509 + bfs.init();
6.1510 + for(NodeIt it(graph); it != INVALID; ++it) {
6.1511 + if(!bfs.reached(it)){
6.1512 + bfs.addSource(it);
6.1513 + while (!bfs.emptyQueue()) {
6.1514 + bfs.processNextNode();
6.1515 + if (!bipartite) return false;
6.1516 + }
6.1517 + }
6.1518 + }
6.1519 + return true;
6.1520 + }
6.1521 +
6.1522 + /// \brief Returns true when there are not loop edges in the graph.
6.1523 + ///
6.1524 + /// Returns true when there are not loop edges in the graph.
6.1525 + template <typename Digraph>
6.1526 + bool loopFree(const Digraph& graph) {
6.1527 + for (typename Digraph::ArcIt it(graph); it != INVALID; ++it) {
6.1528 + if (graph.source(it) == graph.target(it)) return false;
6.1529 + }
6.1530 + return true;
6.1531 + }
6.1532 +
6.1533 + /// \brief Returns true when there are not parallel edges in the graph.
6.1534 + ///
6.1535 + /// Returns true when there are not parallel edges in the graph.
6.1536 + template <typename Digraph>
6.1537 + bool parallelFree(const Digraph& graph) {
6.1538 + typename Digraph::template NodeMap<bool> reached(graph, false);
6.1539 + for (typename Digraph::NodeIt n(graph); n != INVALID; ++n) {
6.1540 + for (typename Digraph::OutArcIt e(graph, n); e != INVALID; ++e) {
6.1541 + if (reached[graph.target(e)]) return false;
6.1542 + reached.set(graph.target(e), true);
6.1543 + }
6.1544 + for (typename Digraph::OutArcIt e(graph, n); e != INVALID; ++e) {
6.1545 + reached.set(graph.target(e), false);
6.1546 + }
6.1547 + }
6.1548 + return true;
6.1549 + }
6.1550 +
6.1551 + /// \brief Returns true when there are not loop edges and parallel
6.1552 + /// edges in the graph.
6.1553 + ///
6.1554 + /// Returns true when there are not loop edges and parallel edges in
6.1555 + /// the graph.
6.1556 + template <typename Digraph>
6.1557 + bool simpleDigraph(const Digraph& graph) {
6.1558 + typename Digraph::template NodeMap<bool> reached(graph, false);
6.1559 + for (typename Digraph::NodeIt n(graph); n != INVALID; ++n) {
6.1560 + reached.set(n, true);
6.1561 + for (typename Digraph::OutArcIt e(graph, n); e != INVALID; ++e) {
6.1562 + if (reached[graph.target(e)]) return false;
6.1563 + reached.set(graph.target(e), true);
6.1564 + }
6.1565 + for (typename Digraph::OutArcIt e(graph, n); e != INVALID; ++e) {
6.1566 + reached.set(graph.target(e), false);
6.1567 + }
6.1568 + reached.set(n, false);
6.1569 + }
6.1570 + return true;
6.1571 + }
6.1572 +
6.1573 +} //namespace lemon
6.1574 +
6.1575 +#endif //LEMON_TOPOLOGY_H
7.1 --- a/test/Makefile.am Tue Dec 02 11:01:48 2008 +0000
7.2 +++ b/test/Makefile.am Tue Dec 02 15:33:22 2008 +0000
7.3 @@ -16,6 +16,7 @@
7.4 test/dijkstra_test \
7.5 test/dim_test \
7.6 test/error_test \
7.7 + test/graph_adaptor_test \
7.8 test/graph_copy_test \
7.9 test/graph_test \
7.10 test/graph_utils_test \
7.11 @@ -44,6 +45,7 @@
7.12 test_dijkstra_test_SOURCES = test/dijkstra_test.cc
7.13 test_dim_test_SOURCES = test/dim_test.cc
7.14 test_error_test_SOURCES = test/error_test.cc
7.15 +test_graph_adaptor_test_SOURCES = test/graph_adaptor_test.cc
7.16 test_graph_copy_test_SOURCES = test/graph_copy_test.cc
7.17 test_graph_test_SOURCES = test/graph_test.cc
7.18 test_graph_utils_test_SOURCES = test/graph_utils_test.cc
8.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
8.2 +++ b/test/graph_adaptor_test.cc Tue Dec 02 15:33:22 2008 +0000
8.3 @@ -0,0 +1,984 @@
8.4 +/* -*- mode: C++; indent-tabs-mode: nil; -*-
8.5 + *
8.6 + * This file is a part of LEMON, a generic C++ optimization library.
8.7 + *
8.8 + * Copyright (C) 2003-2008
8.9 + * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
8.10 + * (Egervary Research Group on Combinatorial Optimization, EGRES).
8.11 + *
8.12 + * Permission to use, modify and distribute this software is granted
8.13 + * provided that this copyright notice appears in all copies. For
8.14 + * precise terms see the accompanying LICENSE file.
8.15 + *
8.16 + * This software is provided "AS IS" with no warranty of any kind,
8.17 + * express or implied, and with no claim as to its suitability for any
8.18 + * purpose.
8.19 + *
8.20 + */
8.21 +
8.22 +#include<iostream>
8.23 +#include<lemon/concept_check.h>
8.24 +
8.25 +#include<lemon/list_graph.h>
8.26 +#include<lemon/smart_graph.h>
8.27 +
8.28 +#include<lemon/concepts/digraph.h>
8.29 +#include<lemon/concepts/graph.h>
8.30 +
8.31 +#include<lemon/adaptors.h>
8.32 +
8.33 +#include <limits>
8.34 +#include <lemon/bfs.h>
8.35 +#include <lemon/path.h>
8.36 +
8.37 +#include"test/test_tools.h"
8.38 +#include"test/graph_test.h"
8.39 +
8.40 +using namespace lemon;
8.41 +
8.42 +void checkReverseDigraph() {
8.43 + checkConcept<concepts::Digraph, ReverseDigraph<concepts::Digraph> >();
8.44 +
8.45 + typedef ListDigraph Digraph;
8.46 + typedef ReverseDigraph<Digraph> Adaptor;
8.47 +
8.48 + Digraph digraph;
8.49 + Adaptor adaptor(digraph);
8.50 +
8.51 + Digraph::Node n1 = digraph.addNode();
8.52 + Digraph::Node n2 = digraph.addNode();
8.53 + Digraph::Node n3 = digraph.addNode();
8.54 +
8.55 + Digraph::Arc a1 = digraph.addArc(n1, n2);
8.56 + Digraph::Arc a2 = digraph.addArc(n1, n3);
8.57 + Digraph::Arc a3 = digraph.addArc(n2, n3);
8.58 +
8.59 + checkGraphNodeList(adaptor, 3);
8.60 + checkGraphArcList(adaptor, 3);
8.61 + checkGraphConArcList(adaptor, 3);
8.62 +
8.63 + checkGraphOutArcList(adaptor, n1, 0);
8.64 + checkGraphOutArcList(adaptor, n2, 1);
8.65 + checkGraphOutArcList(adaptor, n3, 2);
8.66 +
8.67 + checkGraphInArcList(adaptor, n1, 2);
8.68 + checkGraphInArcList(adaptor, n2, 1);
8.69 + checkGraphInArcList(adaptor, n3, 0);
8.70 +
8.71 + checkNodeIds(adaptor);
8.72 + checkArcIds(adaptor);
8.73 +
8.74 + checkGraphNodeMap(adaptor);
8.75 + checkGraphArcMap(adaptor);
8.76 +
8.77 + for (Adaptor::ArcIt a(adaptor); a != INVALID; ++a) {
8.78 + check(adaptor.source(a) == digraph.target(a), "Wrong reverse");
8.79 + check(adaptor.target(a) == digraph.source(a), "Wrong reverse");
8.80 + }
8.81 +}
8.82 +
8.83 +void checkSubDigraph() {
8.84 + checkConcept<concepts::Digraph,
8.85 + SubDigraph<concepts::Digraph,
8.86 + concepts::Digraph::NodeMap<bool>,
8.87 + concepts::Digraph::ArcMap<bool> > >();
8.88 +
8.89 + typedef ListDigraph Digraph;
8.90 + typedef Digraph::NodeMap<bool> NodeFilter;
8.91 + typedef Digraph::ArcMap<bool> ArcFilter;
8.92 + typedef SubDigraph<Digraph, NodeFilter, ArcFilter> Adaptor;
8.93 +
8.94 + Digraph digraph;
8.95 + NodeFilter node_filter(digraph);
8.96 + ArcFilter arc_filter(digraph);
8.97 + Adaptor adaptor(digraph, node_filter, arc_filter);
8.98 +
8.99 + Digraph::Node n1 = digraph.addNode();
8.100 + Digraph::Node n2 = digraph.addNode();
8.101 + Digraph::Node n3 = digraph.addNode();
8.102 +
8.103 + Digraph::Arc a1 = digraph.addArc(n1, n2);
8.104 + Digraph::Arc a2 = digraph.addArc(n1, n3);
8.105 + Digraph::Arc a3 = digraph.addArc(n2, n3);
8.106 +
8.107 + node_filter[n1] = node_filter[n2] = node_filter[n3] = true;
8.108 + arc_filter[a1] = arc_filter[a2] = arc_filter[a3] = true;
8.109 +
8.110 + checkGraphNodeList(adaptor, 3);
8.111 + checkGraphArcList(adaptor, 3);
8.112 + checkGraphConArcList(adaptor, 3);
8.113 +
8.114 + checkGraphOutArcList(adaptor, n1, 2);
8.115 + checkGraphOutArcList(adaptor, n2, 1);
8.116 + checkGraphOutArcList(adaptor, n3, 0);
8.117 +
8.118 + checkGraphInArcList(adaptor, n1, 0);
8.119 + checkGraphInArcList(adaptor, n2, 1);
8.120 + checkGraphInArcList(adaptor, n3, 2);
8.121 +
8.122 + checkNodeIds(adaptor);
8.123 + checkArcIds(adaptor);
8.124 +
8.125 + checkGraphNodeMap(adaptor);
8.126 + checkGraphArcMap(adaptor);
8.127 +
8.128 + arc_filter[a2] = false;
8.129 +
8.130 + checkGraphNodeList(adaptor, 3);
8.131 + checkGraphArcList(adaptor, 2);
8.132 + checkGraphConArcList(adaptor, 2);
8.133 +
8.134 + checkGraphOutArcList(adaptor, n1, 1);
8.135 + checkGraphOutArcList(adaptor, n2, 1);
8.136 + checkGraphOutArcList(adaptor, n3, 0);
8.137 +
8.138 + checkGraphInArcList(adaptor, n1, 0);
8.139 + checkGraphInArcList(adaptor, n2, 1);
8.140 + checkGraphInArcList(adaptor, n3, 1);
8.141 +
8.142 + checkNodeIds(adaptor);
8.143 + checkArcIds(adaptor);
8.144 +
8.145 + checkGraphNodeMap(adaptor);
8.146 + checkGraphArcMap(adaptor);
8.147 +
8.148 + node_filter[n1] = false;
8.149 +
8.150 + checkGraphNodeList(adaptor, 2);
8.151 + checkGraphArcList(adaptor, 1);
8.152 + checkGraphConArcList(adaptor, 1);
8.153 +
8.154 + checkGraphOutArcList(adaptor, n2, 1);
8.155 + checkGraphOutArcList(adaptor, n3, 0);
8.156 +
8.157 + checkGraphInArcList(adaptor, n2, 0);
8.158 + checkGraphInArcList(adaptor, n3, 1);
8.159 +
8.160 + checkNodeIds(adaptor);
8.161 + checkArcIds(adaptor);
8.162 +
8.163 + checkGraphNodeMap(adaptor);
8.164 + checkGraphArcMap(adaptor);
8.165 +
8.166 + node_filter[n1] = node_filter[n2] = node_filter[n3] = false;
8.167 + arc_filter[a1] = arc_filter[a2] = arc_filter[a3] = false;
8.168 +
8.169 + checkGraphNodeList(adaptor, 0);
8.170 + checkGraphArcList(adaptor, 0);
8.171 + checkGraphConArcList(adaptor, 0);
8.172 +
8.173 + checkNodeIds(adaptor);
8.174 + checkArcIds(adaptor);
8.175 +
8.176 + checkGraphNodeMap(adaptor);
8.177 + checkGraphArcMap(adaptor);
8.178 +}
8.179 +
8.180 +void checkFilterNodes1() {
8.181 + checkConcept<concepts::Digraph,
8.182 + FilterNodes<concepts::Digraph,
8.183 + concepts::Digraph::NodeMap<bool> > >();
8.184 +
8.185 + typedef ListDigraph Digraph;
8.186 + typedef Digraph::NodeMap<bool> NodeFilter;
8.187 + typedef FilterNodes<Digraph, NodeFilter> Adaptor;
8.188 +
8.189 + Digraph digraph;
8.190 + NodeFilter node_filter(digraph);
8.191 + Adaptor adaptor(digraph, node_filter);
8.192 +
8.193 + Digraph::Node n1 = digraph.addNode();
8.194 + Digraph::Node n2 = digraph.addNode();
8.195 + Digraph::Node n3 = digraph.addNode();
8.196 +
8.197 + Digraph::Arc a1 = digraph.addArc(n1, n2);
8.198 + Digraph::Arc a2 = digraph.addArc(n1, n3);
8.199 + Digraph::Arc a3 = digraph.addArc(n2, n3);
8.200 +
8.201 + node_filter[n1] = node_filter[n2] = node_filter[n3] = true;
8.202 +
8.203 + checkGraphNodeList(adaptor, 3);
8.204 + checkGraphArcList(adaptor, 3);
8.205 + checkGraphConArcList(adaptor, 3);
8.206 +
8.207 + checkGraphOutArcList(adaptor, n1, 2);
8.208 + checkGraphOutArcList(adaptor, n2, 1);
8.209 + checkGraphOutArcList(adaptor, n3, 0);
8.210 +
8.211 + checkGraphInArcList(adaptor, n1, 0);
8.212 + checkGraphInArcList(adaptor, n2, 1);
8.213 + checkGraphInArcList(adaptor, n3, 2);
8.214 +
8.215 + checkNodeIds(adaptor);
8.216 + checkArcIds(adaptor);
8.217 +
8.218 + checkGraphNodeMap(adaptor);
8.219 + checkGraphArcMap(adaptor);
8.220 +
8.221 + node_filter[n1] = false;
8.222 +
8.223 + checkGraphNodeList(adaptor, 2);
8.224 + checkGraphArcList(adaptor, 1);
8.225 + checkGraphConArcList(adaptor, 1);
8.226 +
8.227 + checkGraphOutArcList(adaptor, n2, 1);
8.228 + checkGraphOutArcList(adaptor, n3, 0);
8.229 +
8.230 + checkGraphInArcList(adaptor, n2, 0);
8.231 + checkGraphInArcList(adaptor, n3, 1);
8.232 +
8.233 + checkNodeIds(adaptor);
8.234 + checkArcIds(adaptor);
8.235 +
8.236 + checkGraphNodeMap(adaptor);
8.237 + checkGraphArcMap(adaptor);
8.238 +
8.239 + node_filter[n1] = node_filter[n2] = node_filter[n3] = false;
8.240 +
8.241 + checkGraphNodeList(adaptor, 0);
8.242 + checkGraphArcList(adaptor, 0);
8.243 + checkGraphConArcList(adaptor, 0);
8.244 +
8.245 + checkNodeIds(adaptor);
8.246 + checkArcIds(adaptor);
8.247 +
8.248 + checkGraphNodeMap(adaptor);
8.249 + checkGraphArcMap(adaptor);
8.250 +}
8.251 +
8.252 +void checkFilterArcs() {
8.253 + checkConcept<concepts::Digraph,
8.254 + FilterArcs<concepts::Digraph,
8.255 + concepts::Digraph::ArcMap<bool> > >();
8.256 +
8.257 + typedef ListDigraph Digraph;
8.258 + typedef Digraph::ArcMap<bool> ArcFilter;
8.259 + typedef FilterArcs<Digraph, ArcFilter> Adaptor;
8.260 +
8.261 + Digraph digraph;
8.262 + ArcFilter arc_filter(digraph);
8.263 + Adaptor adaptor(digraph, arc_filter);
8.264 +
8.265 + Digraph::Node n1 = digraph.addNode();
8.266 + Digraph::Node n2 = digraph.addNode();
8.267 + Digraph::Node n3 = digraph.addNode();
8.268 +
8.269 + Digraph::Arc a1 = digraph.addArc(n1, n2);
8.270 + Digraph::Arc a2 = digraph.addArc(n1, n3);
8.271 + Digraph::Arc a3 = digraph.addArc(n2, n3);
8.272 +
8.273 + arc_filter[a1] = arc_filter[a2] = arc_filter[a3] = true;
8.274 +
8.275 + checkGraphNodeList(adaptor, 3);
8.276 + checkGraphArcList(adaptor, 3);
8.277 + checkGraphConArcList(adaptor, 3);
8.278 +
8.279 + checkGraphOutArcList(adaptor, n1, 2);
8.280 + checkGraphOutArcList(adaptor, n2, 1);
8.281 + checkGraphOutArcList(adaptor, n3, 0);
8.282 +
8.283 + checkGraphInArcList(adaptor, n1, 0);
8.284 + checkGraphInArcList(adaptor, n2, 1);
8.285 + checkGraphInArcList(adaptor, n3, 2);
8.286 +
8.287 + checkNodeIds(adaptor);
8.288 + checkArcIds(adaptor);
8.289 +
8.290 + checkGraphNodeMap(adaptor);
8.291 + checkGraphArcMap(adaptor);
8.292 +
8.293 + arc_filter[a2] = false;
8.294 +
8.295 + checkGraphNodeList(adaptor, 3);
8.296 + checkGraphArcList(adaptor, 2);
8.297 + checkGraphConArcList(adaptor, 2);
8.298 +
8.299 + checkGraphOutArcList(adaptor, n1, 1);
8.300 + checkGraphOutArcList(adaptor, n2, 1);
8.301 + checkGraphOutArcList(adaptor, n3, 0);
8.302 +
8.303 + checkGraphInArcList(adaptor, n1, 0);
8.304 + checkGraphInArcList(adaptor, n2, 1);
8.305 + checkGraphInArcList(adaptor, n3, 1);
8.306 +
8.307 + checkNodeIds(adaptor);
8.308 + checkArcIds(adaptor);
8.309 +
8.310 + checkGraphNodeMap(adaptor);
8.311 + checkGraphArcMap(adaptor);
8.312 +
8.313 + arc_filter[a1] = arc_filter[a2] = arc_filter[a3] = false;
8.314 +
8.315 + checkGraphNodeList(adaptor, 3);
8.316 + checkGraphArcList(adaptor, 0);
8.317 + checkGraphConArcList(adaptor, 0);
8.318 +
8.319 + checkNodeIds(adaptor);
8.320 + checkArcIds(adaptor);
8.321 +
8.322 + checkGraphNodeMap(adaptor);
8.323 + checkGraphArcMap(adaptor);
8.324 +}
8.325 +
8.326 +void checkUndirector() {
8.327 + checkConcept<concepts::Graph, Undirector<concepts::Digraph> >();
8.328 +
8.329 + typedef ListDigraph Digraph;
8.330 + typedef Undirector<Digraph> Adaptor;
8.331 +
8.332 + Digraph digraph;
8.333 + Adaptor adaptor(digraph);
8.334 +
8.335 + Digraph::Node n1 = digraph.addNode();
8.336 + Digraph::Node n2 = digraph.addNode();
8.337 + Digraph::Node n3 = digraph.addNode();
8.338 +
8.339 + Digraph::Arc a1 = digraph.addArc(n1, n2);
8.340 + Digraph::Arc a2 = digraph.addArc(n1, n3);
8.341 + Digraph::Arc a3 = digraph.addArc(n2, n3);
8.342 +
8.343 + checkGraphNodeList(adaptor, 3);
8.344 + checkGraphArcList(adaptor, 6);
8.345 + checkGraphEdgeList(adaptor, 3);
8.346 + checkGraphConArcList(adaptor, 6);
8.347 + checkGraphConEdgeList(adaptor, 3);
8.348 +
8.349 + checkGraphOutArcList(adaptor, n1, 2);
8.350 + checkGraphOutArcList(adaptor, n2, 2);
8.351 + checkGraphOutArcList(adaptor, n3, 2);
8.352 +
8.353 + checkGraphInArcList(adaptor, n1, 2);
8.354 + checkGraphInArcList(adaptor, n2, 2);
8.355 + checkGraphInArcList(adaptor, n3, 2);
8.356 +
8.357 + checkGraphIncEdgeList(adaptor, n1, 2);
8.358 + checkGraphIncEdgeList(adaptor, n2, 2);
8.359 + checkGraphIncEdgeList(adaptor, n3, 2);
8.360 +
8.361 + checkNodeIds(adaptor);
8.362 + checkArcIds(adaptor);
8.363 + checkEdgeIds(adaptor);
8.364 +
8.365 + checkGraphNodeMap(adaptor);
8.366 + checkGraphArcMap(adaptor);
8.367 + checkGraphEdgeMap(adaptor);
8.368 +
8.369 + for (Adaptor::EdgeIt e(adaptor); e != INVALID; ++e) {
8.370 + check(adaptor.u(e) == digraph.source(e), "Wrong undir");
8.371 + check(adaptor.v(e) == digraph.target(e), "Wrong undir");
8.372 + }
8.373 +
8.374 +}
8.375 +
8.376 +void checkResidual() {
8.377 + checkConcept<concepts::Digraph,
8.378 + Residual<concepts::Digraph,
8.379 + concepts::Digraph::ArcMap<int>,
8.380 + concepts::Digraph::ArcMap<int> > >();
8.381 +
8.382 + typedef ListDigraph Digraph;
8.383 + typedef Digraph::ArcMap<int> IntArcMap;
8.384 + typedef Residual<Digraph, IntArcMap> Adaptor;
8.385 +
8.386 + Digraph digraph;
8.387 + IntArcMap capacity(digraph), flow(digraph);
8.388 + Adaptor adaptor(digraph, capacity, flow);
8.389 +
8.390 + Digraph::Node n1 = digraph.addNode();
8.391 + Digraph::Node n2 = digraph.addNode();
8.392 + Digraph::Node n3 = digraph.addNode();
8.393 + Digraph::Node n4 = digraph.addNode();
8.394 +
8.395 + Digraph::Arc a1 = digraph.addArc(n1, n2);
8.396 + Digraph::Arc a2 = digraph.addArc(n1, n3);
8.397 + Digraph::Arc a3 = digraph.addArc(n1, n4);
8.398 + Digraph::Arc a4 = digraph.addArc(n2, n3);
8.399 + Digraph::Arc a5 = digraph.addArc(n2, n4);
8.400 + Digraph::Arc a6 = digraph.addArc(n3, n4);
8.401 +
8.402 + capacity[a1] = 8;
8.403 + capacity[a2] = 6;
8.404 + capacity[a3] = 4;
8.405 + capacity[a4] = 4;
8.406 + capacity[a5] = 6;
8.407 + capacity[a6] = 10;
8.408 +
8.409 + for (Adaptor::ArcIt a(adaptor); a != INVALID; ++a) {
8.410 + flow[a] = 0;
8.411 + }
8.412 +
8.413 + checkGraphNodeList(adaptor, 4);
8.414 + checkGraphArcList(adaptor, 6);
8.415 + checkGraphConArcList(adaptor, 6);
8.416 +
8.417 + checkGraphOutArcList(adaptor, n1, 3);
8.418 + checkGraphOutArcList(adaptor, n2, 2);
8.419 + checkGraphOutArcList(adaptor, n3, 1);
8.420 + checkGraphOutArcList(adaptor, n4, 0);
8.421 +
8.422 + checkGraphInArcList(adaptor, n1, 0);
8.423 + checkGraphInArcList(adaptor, n2, 1);
8.424 + checkGraphInArcList(adaptor, n3, 2);
8.425 + checkGraphInArcList(adaptor, n4, 3);
8.426 +
8.427 + for (Adaptor::ArcIt a(adaptor); a != INVALID; ++a) {
8.428 + flow[a] = capacity[a] / 2;
8.429 + }
8.430 +
8.431 + checkGraphNodeList(adaptor, 4);
8.432 + checkGraphArcList(adaptor, 12);
8.433 + checkGraphConArcList(adaptor, 12);
8.434 +
8.435 + checkGraphOutArcList(adaptor, n1, 3);
8.436 + checkGraphOutArcList(adaptor, n2, 3);
8.437 + checkGraphOutArcList(adaptor, n3, 3);
8.438 + checkGraphOutArcList(adaptor, n4, 3);
8.439 +
8.440 + checkGraphInArcList(adaptor, n1, 3);
8.441 + checkGraphInArcList(adaptor, n2, 3);
8.442 + checkGraphInArcList(adaptor, n3, 3);
8.443 + checkGraphInArcList(adaptor, n4, 3);
8.444 +
8.445 + checkNodeIds(adaptor);
8.446 + checkArcIds(adaptor);
8.447 +
8.448 + checkGraphNodeMap(adaptor);
8.449 + checkGraphArcMap(adaptor);
8.450 +
8.451 + for (Adaptor::ArcIt a(adaptor); a != INVALID; ++a) {
8.452 + flow[a] = capacity[a];
8.453 + }
8.454 +
8.455 + checkGraphNodeList(adaptor, 4);
8.456 + checkGraphArcList(adaptor, 6);
8.457 + checkGraphConArcList(adaptor, 6);
8.458 +
8.459 + checkGraphOutArcList(adaptor, n1, 0);
8.460 + checkGraphOutArcList(adaptor, n2, 1);
8.461 + checkGraphOutArcList(adaptor, n3, 2);
8.462 + checkGraphOutArcList(adaptor, n4, 3);
8.463 +
8.464 + checkGraphInArcList(adaptor, n1, 3);
8.465 + checkGraphInArcList(adaptor, n2, 2);
8.466 + checkGraphInArcList(adaptor, n3, 1);
8.467 + checkGraphInArcList(adaptor, n4, 0);
8.468 +
8.469 + for (Adaptor::ArcIt a(adaptor); a != INVALID; ++a) {
8.470 + flow[a] = 0;
8.471 + }
8.472 +
8.473 + int flow_value = 0;
8.474 + while (true) {
8.475 +
8.476 + Bfs<Adaptor> bfs(adaptor);
8.477 + bfs.run(n1, n4);
8.478 +
8.479 + if (!bfs.reached(n4)) break;
8.480 +
8.481 + Path<Adaptor> p = bfs.path(n4);
8.482 +
8.483 + int min = std::numeric_limits<int>::max();
8.484 + for (Path<Adaptor>::ArcIt a(p); a != INVALID; ++a) {
8.485 + if (adaptor.residualCapacity(a) < min)
8.486 + min = adaptor.residualCapacity(a);
8.487 + }
8.488 +
8.489 + for (Path<Adaptor>::ArcIt a(p); a != INVALID; ++a) {
8.490 + adaptor.augment(a, min);
8.491 + }
8.492 + flow_value += min;
8.493 + }
8.494 +
8.495 + check(flow_value == 18, "Wrong flow with res graph adaptor");
8.496 +
8.497 +}
8.498 +
8.499 +void checkSplitNodes() {
8.500 + checkConcept<concepts::Digraph, SplitNodes<concepts::Digraph> >();
8.501 +
8.502 + typedef ListDigraph Digraph;
8.503 + typedef SplitNodes<Digraph> Adaptor;
8.504 +
8.505 + Digraph digraph;
8.506 + Adaptor adaptor(digraph);
8.507 +
8.508 + Digraph::Node n1 = digraph.addNode();
8.509 + Digraph::Node n2 = digraph.addNode();
8.510 + Digraph::Node n3 = digraph.addNode();
8.511 +
8.512 + Digraph::Arc a1 = digraph.addArc(n1, n2);
8.513 + Digraph::Arc a2 = digraph.addArc(n1, n3);
8.514 + Digraph::Arc a3 = digraph.addArc(n2, n3);
8.515 +
8.516 + checkGraphNodeList(adaptor, 6);
8.517 + checkGraphArcList(adaptor, 6);
8.518 + checkGraphConArcList(adaptor, 6);
8.519 +
8.520 + checkGraphOutArcList(adaptor, adaptor.inNode(n1), 1);
8.521 + checkGraphOutArcList(adaptor, adaptor.outNode(n1), 2);
8.522 + checkGraphOutArcList(adaptor, adaptor.inNode(n2), 1);
8.523 + checkGraphOutArcList(adaptor, adaptor.outNode(n2), 1);
8.524 + checkGraphOutArcList(adaptor, adaptor.inNode(n3), 1);
8.525 + checkGraphOutArcList(adaptor, adaptor.outNode(n3), 0);
8.526 +
8.527 + checkGraphInArcList(adaptor, adaptor.inNode(n1), 0);
8.528 + checkGraphInArcList(adaptor, adaptor.outNode(n1), 1);
8.529 + checkGraphInArcList(adaptor, adaptor.inNode(n2), 1);
8.530 + checkGraphInArcList(adaptor, adaptor.outNode(n2), 1);
8.531 + checkGraphInArcList(adaptor, adaptor.inNode(n3), 2);
8.532 + checkGraphInArcList(adaptor, adaptor.outNode(n3), 1);
8.533 +
8.534 + checkNodeIds(adaptor);
8.535 + checkArcIds(adaptor);
8.536 +
8.537 + checkGraphNodeMap(adaptor);
8.538 + checkGraphArcMap(adaptor);
8.539 +
8.540 + for (Adaptor::ArcIt a(adaptor); a != INVALID; ++a) {
8.541 + if (adaptor.origArc(a)) {
8.542 + Digraph::Arc oa = a;
8.543 + check(adaptor.source(a) == adaptor.outNode(digraph.source(oa)),
8.544 + "Wrong split");
8.545 + check(adaptor.target(a) == adaptor.inNode(digraph.target(oa)),
8.546 + "Wrong split");
8.547 + } else {
8.548 + Digraph::Node on = a;
8.549 + check(adaptor.source(a) == adaptor.inNode(on), "Wrong split");
8.550 + check(adaptor.target(a) == adaptor.outNode(on), "Wrong split");
8.551 + }
8.552 + }
8.553 +}
8.554 +
8.555 +void checkSubGraph() {
8.556 + checkConcept<concepts::Graph,
8.557 + SubGraph<concepts::Graph,
8.558 + concepts::Graph::NodeMap<bool>,
8.559 + concepts::Graph::EdgeMap<bool> > >();
8.560 +
8.561 + typedef ListGraph Graph;
8.562 + typedef Graph::NodeMap<bool> NodeFilter;
8.563 + typedef Graph::EdgeMap<bool> EdgeFilter;
8.564 + typedef SubGraph<Graph, NodeFilter, EdgeFilter> Adaptor;
8.565 +
8.566 + Graph graph;
8.567 + NodeFilter node_filter(graph);
8.568 + EdgeFilter edge_filter(graph);
8.569 + Adaptor adaptor(graph, node_filter, edge_filter);
8.570 +
8.571 + Graph::Node n1 = graph.addNode();
8.572 + Graph::Node n2 = graph.addNode();
8.573 + Graph::Node n3 = graph.addNode();
8.574 + Graph::Node n4 = graph.addNode();
8.575 +
8.576 + Graph::Edge e1 = graph.addEdge(n1, n2);
8.577 + Graph::Edge e2 = graph.addEdge(n1, n3);
8.578 + Graph::Edge e3 = graph.addEdge(n2, n3);
8.579 + Graph::Edge e4 = graph.addEdge(n3, n4);
8.580 +
8.581 + node_filter[n1] = node_filter[n2] = node_filter[n3] = node_filter[n4] = true;
8.582 + edge_filter[e1] = edge_filter[e2] = edge_filter[e3] = edge_filter[e4] = true;
8.583 +
8.584 + checkGraphNodeList(adaptor, 4);
8.585 + checkGraphArcList(adaptor, 8);
8.586 + checkGraphEdgeList(adaptor, 4);
8.587 + checkGraphConArcList(adaptor, 8);
8.588 + checkGraphConEdgeList(adaptor, 4);
8.589 +
8.590 + checkGraphOutArcList(adaptor, n1, 2);
8.591 + checkGraphOutArcList(adaptor, n2, 2);
8.592 + checkGraphOutArcList(adaptor, n3, 3);
8.593 + checkGraphOutArcList(adaptor, n4, 1);
8.594 +
8.595 + checkGraphInArcList(adaptor, n1, 2);
8.596 + checkGraphInArcList(adaptor, n2, 2);
8.597 + checkGraphInArcList(adaptor, n3, 3);
8.598 + checkGraphInArcList(adaptor, n4, 1);
8.599 +
8.600 + checkGraphIncEdgeList(adaptor, n1, 2);
8.601 + checkGraphIncEdgeList(adaptor, n2, 2);
8.602 + checkGraphIncEdgeList(adaptor, n3, 3);
8.603 + checkGraphIncEdgeList(adaptor, n4, 1);
8.604 +
8.605 + checkNodeIds(adaptor);
8.606 + checkArcIds(adaptor);
8.607 + checkEdgeIds(adaptor);
8.608 +
8.609 + checkGraphNodeMap(adaptor);
8.610 + checkGraphArcMap(adaptor);
8.611 + checkGraphEdgeMap(adaptor);
8.612 +
8.613 + edge_filter[e2] = false;
8.614 +
8.615 + checkGraphNodeList(adaptor, 4);
8.616 + checkGraphArcList(adaptor, 6);
8.617 + checkGraphEdgeList(adaptor, 3);
8.618 + checkGraphConArcList(adaptor, 6);
8.619 + checkGraphConEdgeList(adaptor, 3);
8.620 +
8.621 + checkGraphOutArcList(adaptor, n1, 1);
8.622 + checkGraphOutArcList(adaptor, n2, 2);
8.623 + checkGraphOutArcList(adaptor, n3, 2);
8.624 + checkGraphOutArcList(adaptor, n4, 1);
8.625 +
8.626 + checkGraphInArcList(adaptor, n1, 1);
8.627 + checkGraphInArcList(adaptor, n2, 2);
8.628 + checkGraphInArcList(adaptor, n3, 2);
8.629 + checkGraphInArcList(adaptor, n4, 1);
8.630 +
8.631 + checkGraphIncEdgeList(adaptor, n1, 1);
8.632 + checkGraphIncEdgeList(adaptor, n2, 2);
8.633 + checkGraphIncEdgeList(adaptor, n3, 2);
8.634 + checkGraphIncEdgeList(adaptor, n4, 1);
8.635 +
8.636 + checkNodeIds(adaptor);
8.637 + checkArcIds(adaptor);
8.638 + checkEdgeIds(adaptor);
8.639 +
8.640 + checkGraphNodeMap(adaptor);
8.641 + checkGraphArcMap(adaptor);
8.642 + checkGraphEdgeMap(adaptor);
8.643 +
8.644 + node_filter[n1] = false;
8.645 +
8.646 + checkGraphNodeList(adaptor, 3);
8.647 + checkGraphArcList(adaptor, 4);
8.648 + checkGraphEdgeList(adaptor, 2);
8.649 + checkGraphConArcList(adaptor, 4);
8.650 + checkGraphConEdgeList(adaptor, 2);
8.651 +
8.652 + checkGraphOutArcList(adaptor, n2, 1);
8.653 + checkGraphOutArcList(adaptor, n3, 2);
8.654 + checkGraphOutArcList(adaptor, n4, 1);
8.655 +
8.656 + checkGraphInArcList(adaptor, n2, 1);
8.657 + checkGraphInArcList(adaptor, n3, 2);
8.658 + checkGraphInArcList(adaptor, n4, 1);
8.659 +
8.660 + checkGraphIncEdgeList(adaptor, n2, 1);
8.661 + checkGraphIncEdgeList(adaptor, n3, 2);
8.662 + checkGraphIncEdgeList(adaptor, n4, 1);
8.663 +
8.664 + checkNodeIds(adaptor);
8.665 + checkArcIds(adaptor);
8.666 + checkEdgeIds(adaptor);
8.667 +
8.668 + checkGraphNodeMap(adaptor);
8.669 + checkGraphArcMap(adaptor);
8.670 + checkGraphEdgeMap(adaptor);
8.671 +
8.672 + node_filter[n1] = node_filter[n2] = node_filter[n3] = node_filter[n4] = false;
8.673 + edge_filter[e1] = edge_filter[e2] = edge_filter[e3] = edge_filter[e4] = false;
8.674 +
8.675 + checkGraphNodeList(adaptor, 0);
8.676 + checkGraphArcList(adaptor, 0);
8.677 + checkGraphEdgeList(adaptor, 0);
8.678 + checkGraphConArcList(adaptor, 0);
8.679 + checkGraphConEdgeList(adaptor, 0);
8.680 +
8.681 + checkNodeIds(adaptor);
8.682 + checkArcIds(adaptor);
8.683 + checkEdgeIds(adaptor);
8.684 +
8.685 + checkGraphNodeMap(adaptor);
8.686 + checkGraphArcMap(adaptor);
8.687 + checkGraphEdgeMap(adaptor);
8.688 +}
8.689 +
8.690 +void checkFilterNodes2() {
8.691 + checkConcept<concepts::Graph,
8.692 + FilterNodes<concepts::Graph,
8.693 + concepts::Graph::NodeMap<bool> > >();
8.694 +
8.695 + typedef ListGraph Graph;
8.696 + typedef Graph::NodeMap<bool> NodeFilter;
8.697 + typedef FilterNodes<Graph, NodeFilter> Adaptor;
8.698 +
8.699 + Graph graph;
8.700 + NodeFilter node_filter(graph);
8.701 + Adaptor adaptor(graph, node_filter);
8.702 +
8.703 + Graph::Node n1 = graph.addNode();
8.704 + Graph::Node n2 = graph.addNode();
8.705 + Graph::Node n3 = graph.addNode();
8.706 + Graph::Node n4 = graph.addNode();
8.707 +
8.708 + Graph::Edge e1 = graph.addEdge(n1, n2);
8.709 + Graph::Edge e2 = graph.addEdge(n1, n3);
8.710 + Graph::Edge e3 = graph.addEdge(n2, n3);
8.711 + Graph::Edge e4 = graph.addEdge(n3, n4);
8.712 +
8.713 + node_filter[n1] = node_filter[n2] = node_filter[n3] = node_filter[n4] = true;
8.714 +
8.715 + checkGraphNodeList(adaptor, 4);
8.716 + checkGraphArcList(adaptor, 8);
8.717 + checkGraphEdgeList(adaptor, 4);
8.718 + checkGraphConArcList(adaptor, 8);
8.719 + checkGraphConEdgeList(adaptor, 4);
8.720 +
8.721 + checkGraphOutArcList(adaptor, n1, 2);
8.722 + checkGraphOutArcList(adaptor, n2, 2);
8.723 + checkGraphOutArcList(adaptor, n3, 3);
8.724 + checkGraphOutArcList(adaptor, n4, 1);
8.725 +
8.726 + checkGraphInArcList(adaptor, n1, 2);
8.727 + checkGraphInArcList(adaptor, n2, 2);
8.728 + checkGraphInArcList(adaptor, n3, 3);
8.729 + checkGraphInArcList(adaptor, n4, 1);
8.730 +
8.731 + checkGraphIncEdgeList(adaptor, n1, 2);
8.732 + checkGraphIncEdgeList(adaptor, n2, 2);
8.733 + checkGraphIncEdgeList(adaptor, n3, 3);
8.734 + checkGraphIncEdgeList(adaptor, n4, 1);
8.735 +
8.736 + checkNodeIds(adaptor);
8.737 + checkArcIds(adaptor);
8.738 + checkEdgeIds(adaptor);
8.739 +
8.740 + checkGraphNodeMap(adaptor);
8.741 + checkGraphArcMap(adaptor);
8.742 + checkGraphEdgeMap(adaptor);
8.743 +
8.744 + node_filter[n1] = false;
8.745 +
8.746 + checkGraphNodeList(adaptor, 3);
8.747 + checkGraphArcList(adaptor, 4);
8.748 + checkGraphEdgeList(adaptor, 2);
8.749 + checkGraphConArcList(adaptor, 4);
8.750 + checkGraphConEdgeList(adaptor, 2);
8.751 +
8.752 + checkGraphOutArcList(adaptor, n2, 1);
8.753 + checkGraphOutArcList(adaptor, n3, 2);
8.754 + checkGraphOutArcList(adaptor, n4, 1);
8.755 +
8.756 + checkGraphInArcList(adaptor, n2, 1);
8.757 + checkGraphInArcList(adaptor, n3, 2);
8.758 + checkGraphInArcList(adaptor, n4, 1);
8.759 +
8.760 + checkGraphIncEdgeList(adaptor, n2, 1);
8.761 + checkGraphIncEdgeList(adaptor, n3, 2);
8.762 + checkGraphIncEdgeList(adaptor, n4, 1);
8.763 +
8.764 + checkNodeIds(adaptor);
8.765 + checkArcIds(adaptor);
8.766 + checkEdgeIds(adaptor);
8.767 +
8.768 + checkGraphNodeMap(adaptor);
8.769 + checkGraphArcMap(adaptor);
8.770 + checkGraphEdgeMap(adaptor);
8.771 +
8.772 + node_filter[n1] = node_filter[n2] = node_filter[n3] = node_filter[n4] = false;
8.773 +
8.774 + checkGraphNodeList(adaptor, 0);
8.775 + checkGraphArcList(adaptor, 0);
8.776 + checkGraphEdgeList(adaptor, 0);
8.777 + checkGraphConArcList(adaptor, 0);
8.778 + checkGraphConEdgeList(adaptor, 0);
8.779 +
8.780 + checkNodeIds(adaptor);
8.781 + checkArcIds(adaptor);
8.782 + checkEdgeIds(adaptor);
8.783 +
8.784 + checkGraphNodeMap(adaptor);
8.785 + checkGraphArcMap(adaptor);
8.786 + checkGraphEdgeMap(adaptor);
8.787 +}
8.788 +
8.789 +void checkFilterEdges() {
8.790 + checkConcept<concepts::Graph,
8.791 + FilterEdges<concepts::Graph,
8.792 + concepts::Graph::EdgeMap<bool> > >();
8.793 +
8.794 + typedef ListGraph Graph;
8.795 + typedef Graph::EdgeMap<bool> EdgeFilter;
8.796 + typedef FilterEdges<Graph, EdgeFilter> Adaptor;
8.797 +
8.798 + Graph graph;
8.799 + EdgeFilter edge_filter(graph);
8.800 + Adaptor adaptor(graph, edge_filter);
8.801 +
8.802 + Graph::Node n1 = graph.addNode();
8.803 + Graph::Node n2 = graph.addNode();
8.804 + Graph::Node n3 = graph.addNode();
8.805 + Graph::Node n4 = graph.addNode();
8.806 +
8.807 + Graph::Edge e1 = graph.addEdge(n1, n2);
8.808 + Graph::Edge e2 = graph.addEdge(n1, n3);
8.809 + Graph::Edge e3 = graph.addEdge(n2, n3);
8.810 + Graph::Edge e4 = graph.addEdge(n3, n4);
8.811 +
8.812 + edge_filter[e1] = edge_filter[e2] = edge_filter[e3] = edge_filter[e4] = true;
8.813 +
8.814 + checkGraphNodeList(adaptor, 4);
8.815 + checkGraphArcList(adaptor, 8);
8.816 + checkGraphEdgeList(adaptor, 4);
8.817 + checkGraphConArcList(adaptor, 8);
8.818 + checkGraphConEdgeList(adaptor, 4);
8.819 +
8.820 + checkGraphOutArcList(adaptor, n1, 2);
8.821 + checkGraphOutArcList(adaptor, n2, 2);
8.822 + checkGraphOutArcList(adaptor, n3, 3);
8.823 + checkGraphOutArcList(adaptor, n4, 1);
8.824 +
8.825 + checkGraphInArcList(adaptor, n1, 2);
8.826 + checkGraphInArcList(adaptor, n2, 2);
8.827 + checkGraphInArcList(adaptor, n3, 3);
8.828 + checkGraphInArcList(adaptor, n4, 1);
8.829 +
8.830 + checkGraphIncEdgeList(adaptor, n1, 2);
8.831 + checkGraphIncEdgeList(adaptor, n2, 2);
8.832 + checkGraphIncEdgeList(adaptor, n3, 3);
8.833 + checkGraphIncEdgeList(adaptor, n4, 1);
8.834 +
8.835 + checkNodeIds(adaptor);
8.836 + checkArcIds(adaptor);
8.837 + checkEdgeIds(adaptor);
8.838 +
8.839 + checkGraphNodeMap(adaptor);
8.840 + checkGraphArcMap(adaptor);
8.841 + checkGraphEdgeMap(adaptor);
8.842 +
8.843 + edge_filter[e2] = false;
8.844 +
8.845 + checkGraphNodeList(adaptor, 4);
8.846 + checkGraphArcList(adaptor, 6);
8.847 + checkGraphEdgeList(adaptor, 3);
8.848 + checkGraphConArcList(adaptor, 6);
8.849 + checkGraphConEdgeList(adaptor, 3);
8.850 +
8.851 + checkGraphOutArcList(adaptor, n1, 1);
8.852 + checkGraphOutArcList(adaptor, n2, 2);
8.853 + checkGraphOutArcList(adaptor, n3, 2);
8.854 + checkGraphOutArcList(adaptor, n4, 1);
8.855 +
8.856 + checkGraphInArcList(adaptor, n1, 1);
8.857 + checkGraphInArcList(adaptor, n2, 2);
8.858 + checkGraphInArcList(adaptor, n3, 2);
8.859 + checkGraphInArcList(adaptor, n4, 1);
8.860 +
8.861 + checkGraphIncEdgeList(adaptor, n1, 1);
8.862 + checkGraphIncEdgeList(adaptor, n2, 2);
8.863 + checkGraphIncEdgeList(adaptor, n3, 2);
8.864 + checkGraphIncEdgeList(adaptor, n4, 1);
8.865 +
8.866 + checkNodeIds(adaptor);
8.867 + checkArcIds(adaptor);
8.868 + checkEdgeIds(adaptor);
8.869 +
8.870 + checkGraphNodeMap(adaptor);
8.871 + checkGraphArcMap(adaptor);
8.872 + checkGraphEdgeMap(adaptor);
8.873 +
8.874 + edge_filter[e1] = edge_filter[e2] = edge_filter[e3] = edge_filter[e4] = false;
8.875 +
8.876 + checkGraphNodeList(adaptor, 4);
8.877 + checkGraphArcList(adaptor, 0);
8.878 + checkGraphEdgeList(adaptor, 0);
8.879 + checkGraphConArcList(adaptor, 0);
8.880 + checkGraphConEdgeList(adaptor, 0);
8.881 +
8.882 + checkNodeIds(adaptor);
8.883 + checkArcIds(adaptor);
8.884 + checkEdgeIds(adaptor);
8.885 +
8.886 + checkGraphNodeMap(adaptor);
8.887 + checkGraphArcMap(adaptor);
8.888 + checkGraphEdgeMap(adaptor);
8.889 +}
8.890 +
8.891 +void checkOrienter() {
8.892 + checkConcept<concepts::Digraph,
8.893 + Orienter<concepts::Graph, concepts::Graph::EdgeMap<bool> > >();
8.894 +
8.895 + typedef ListGraph Graph;
8.896 + typedef ListGraph::EdgeMap<bool> DirMap;
8.897 + typedef Orienter<Graph> Adaptor;
8.898 +
8.899 + Graph graph;
8.900 + DirMap dir(graph, true);
8.901 + Adaptor adaptor(graph, dir);
8.902 +
8.903 + Graph::Node n1 = graph.addNode();
8.904 + Graph::Node n2 = graph.addNode();
8.905 + Graph::Node n3 = graph.addNode();
8.906 +
8.907 + Graph::Edge e1 = graph.addEdge(n1, n2);
8.908 + Graph::Edge e2 = graph.addEdge(n1, n3);
8.909 + Graph::Edge e3 = graph.addEdge(n2, n3);
8.910 +
8.911 + checkGraphNodeList(adaptor, 3);
8.912 + checkGraphArcList(adaptor, 3);
8.913 + checkGraphConArcList(adaptor, 3);
8.914 +
8.915 + {
8.916 + dir[e1] = true;
8.917 + Adaptor::Node u = adaptor.source(e1);
8.918 + Adaptor::Node v = adaptor.target(e1);
8.919 +
8.920 + dir[e1] = false;
8.921 + check (u == adaptor.target(e1), "Wrong dir");
8.922 + check (v == adaptor.source(e1), "Wrong dir");
8.923 +
8.924 + check ((u == n1 && v == n2) || (u == n2 && v == n1), "Wrong dir");
8.925 + dir[e1] = n1 == u;
8.926 + }
8.927 +
8.928 + {
8.929 + dir[e2] = true;
8.930 + Adaptor::Node u = adaptor.source(e2);
8.931 + Adaptor::Node v = adaptor.target(e2);
8.932 +
8.933 + dir[e2] = false;
8.934 + check (u == adaptor.target(e2), "Wrong dir");
8.935 + check (v == adaptor.source(e2), "Wrong dir");
8.936 +
8.937 + check ((u == n1 && v == n3) || (u == n3 && v == n1), "Wrong dir");
8.938 + dir[e2] = n3 == u;
8.939 + }
8.940 +
8.941 + {
8.942 + dir[e3] = true;
8.943 + Adaptor::Node u = adaptor.source(e3);
8.944 + Adaptor::Node v = adaptor.target(e3);
8.945 +
8.946 + dir[e3] = false;
8.947 + check (u == adaptor.target(e3), "Wrong dir");
8.948 + check (v == adaptor.source(e3), "Wrong dir");
8.949 +
8.950 + check ((u == n2 && v == n3) || (u == n3 && v == n2), "Wrong dir");
8.951 + dir[e3] = n2 == u;
8.952 + }
8.953 +
8.954 + checkGraphOutArcList(adaptor, n1, 1);
8.955 + checkGraphOutArcList(adaptor, n2, 1);
8.956 + checkGraphOutArcList(adaptor, n3, 1);
8.957 +
8.958 + checkGraphInArcList(adaptor, n1, 1);
8.959 + checkGraphInArcList(adaptor, n2, 1);
8.960 + checkGraphInArcList(adaptor, n3, 1);
8.961 +
8.962 + checkNodeIds(adaptor);
8.963 + checkArcIds(adaptor);
8.964 +
8.965 + checkGraphNodeMap(adaptor);
8.966 + checkGraphArcMap(adaptor);
8.967 +
8.968 +}
8.969 +
8.970 +
8.971 +int main(int, const char **) {
8.972 +
8.973 + checkReverseDigraph();
8.974 + checkSubDigraph();
8.975 + checkFilterNodes1();
8.976 + checkFilterArcs();
8.977 + checkUndirector();
8.978 + checkResidual();
8.979 + checkSplitNodes();
8.980 +
8.981 + checkSubGraph();
8.982 + checkFilterNodes2();
8.983 + checkFilterEdges();
8.984 + checkOrienter();
8.985 +
8.986 + return 0;
8.987 +}