COIN-OR::LEMON - Graph Library

source: lemon-0.x/src/hugo/graph_wrapper.h @ 579:859f8c7e2a40

Last change on this file since 579:859f8c7e2a40 was 576:d00c33d07114, checked in by marci, 17 years ago
File size: 42.6 KB
Line 
1// -*- c++ -*-
2#ifndef HUGO_GRAPH_WRAPPER_H
3#define HUGO_GRAPH_WRAPPER_H
4
5///\ingroup gwrappers
6///\file
7///\brief Several graph wrappers.
8///
9///This file contains several useful graph wrapper functions.
10///
11///\author Marton Makai
12
13#include <hugo/invalid.h>
14//#include <iter_map.h>
15
16namespace hugo {
17
18  // Graph wrappers
19
20  /// \addtogroup gwrappers
21  /// A main parts of HUGOlib are the different graph structures,
22  /// generic graph algorithms, graph concepts which couple these, and
23  /// graph wrappers. While the previous ones are more or less clear, the
24  /// latter notion needs further explanation.
25  /// Graph wrappers are graph classes which serve for considering graph
26  /// structures in different ways. A short example makes the notion much
27  /// clearer.
28  /// Suppose that we have an instance \c g of a directed graph
29  /// type say \c ListGraph and an algorithm
30  /// \code template<typename Graph> int algorithm(const Graph&); \endcode
31  /// is needed to run on the reversely oriented graph.
32  /// It may be expensive (in time or in memory usage) to copy
33  /// \c g with the reverse orientation.
34  /// Thus, a wrapper class
35  /// \code template<typename Graph> class RevGraphWrapper; \endcode is used.
36  /// The code looks as follows
37  /// \code
38  /// ListGraph g;
39  /// RevGraphWrapper<ListGraph> rgw(g);
40  /// int result=algorithm(rgw);
41  /// \endcode
42  /// After running the algorithm, the original graph \c g
43  /// remains untouched. Thus the graph wrapper used above is to consider the
44  /// original graph with reverse orientation.
45  /// This techniques gives rise to an elegant code, and
46  /// based on stable graph wrappers, complex algorithms can be
47  /// implemented easily.
48  /// In flow, circulation and bipartite matching problems, the residual
49  /// graph is of particular importance. Combining a wrapper implementing
50  /// this, shortest path algorithms and minimum mean cycle algorithms,
51  /// a range of weighted and cardinality optimization algorithms can be
52  /// obtained. For lack of space, for other examples,
53  /// the interested user is referred to the detailed documentation of graph
54  /// wrappers.
55  /// The behavior of graph wrappers can be very different. Some of them keep
56  /// capabilities of the original graph while in other cases this would be
57  /// meaningless. This means that the concepts that they are a model of depend
58  /// on the graph wrapper, and the wrapped graph(s).
59  /// If an edge of \c rgw is deleted, this is carried out by
60  /// deleting the corresponding edge of \c g. But for a residual
61  /// graph, this operation has no sense.
62  /// Let we stand one more example here to simplify your work.
63  /// wrapper class
64  /// \code template<typename Graph> class RevGraphWrapper; \endcode
65  /// has constructor
66  /// <tt> RevGraphWrapper(Graph& _g)</tt>.
67  /// This means that in a situation,
68  /// when a <tt> const ListGraph& </tt> reference to a graph is given,
69  /// then it have to be instantiated with <tt>Graph=const ListGraph</tt>.
70  /// \code
71  /// int algorithm1(const ListGraph& g) {
72  ///   RevGraphWrapper<const ListGraph> rgw(g);
73  ///   return algorithm2(rgw);
74  /// }
75  /// \endcode
76
77  /// \addtogroup gwrappers
78  /// @{
79
80  ///Base type for the Graph Wrappers
81
82  ///This is the base type for the Graph Wrappers.
83  ///\todo Some more docs...
84  ///
85  ///\author Marton Makai
86 
87  template<typename Graph>
88  class GraphWrapper {
89  protected:
90    Graph* graph;
91    GraphWrapper() : graph(0) { }
92    void setGraph(Graph& _graph) { graph=&_graph; }
93
94  public:
95    typedef Graph BaseGraph;
96    typedef Graph ParentGraph;
97
98    GraphWrapper(Graph& _graph) : graph(&_graph) { }
99//     Graph& getGraph() const { return *graph; }
100 
101//    typedef typename Graph::Node Node;
102    class Node : public Graph::Node {
103      friend class GraphWrapper<Graph>;
104    public:
105      Node() { }
106      Node(const typename Graph::Node& _n) : Graph::Node(_n) { }
107      Node(const Invalid& i) : Graph::Node(i) { }
108    };
109    class NodeIt {
110      friend class GraphWrapper<Graph>;
111      typename Graph::NodeIt n;
112     public:
113      NodeIt() { }
114      NodeIt(const typename Graph::NodeIt& _n) : n(_n) { }
115      NodeIt(const Invalid& i) : n(i) { }
116      NodeIt(const GraphWrapper<Graph>& _G) : n(*(_G.graph)) { }
117      operator Node() const { return Node(typename Graph::Node(n)); }
118    };
119//    typedef typename Graph::Edge Edge;
120    class Edge : public Graph::Edge {
121      friend class GraphWrapper<Graph>;
122    public:
123      Edge() { }
124      Edge(const typename Graph::Edge& _e) : Graph::Edge(_e) { }
125      Edge(const Invalid& i) : Graph::Edge(i) { }
126    };
127    class OutEdgeIt {
128      friend class GraphWrapper<Graph>;
129      typename Graph::OutEdgeIt e;
130    public:
131      OutEdgeIt() { }
132      OutEdgeIt(const typename Graph::OutEdgeIt& _e) : e(_e) { }
133      OutEdgeIt(const Invalid& i) : e(i) { }
134      OutEdgeIt(const GraphWrapper<Graph>& _G, const Node& _n) :
135        e(*(_G.graph), typename Graph::Node(_n)) { }
136      operator Edge() const { return Edge(typename Graph::Edge(e)); }
137    };
138    class InEdgeIt {
139      friend class GraphWrapper<Graph>;
140      typename Graph::InEdgeIt e;
141    public:
142      InEdgeIt() { }
143      InEdgeIt(const typename Graph::InEdgeIt& _e) : e(_e) { }
144      InEdgeIt(const Invalid& i) : e(i) { }
145      InEdgeIt(const GraphWrapper<Graph>& _G, const Node& _n) :
146        e(*(_G.graph), typename Graph::Node(_n)) { }
147      operator Edge() const { return Edge(typename Graph::Edge(e)); }
148    };
149    //typedef typename Graph::SymEdgeIt SymEdgeIt;
150    class EdgeIt {
151      friend class GraphWrapper<Graph>;
152      typename Graph::EdgeIt e;
153    public:
154      EdgeIt() { }
155      EdgeIt(const typename Graph::EdgeIt& _e) : e(_e) { }
156      EdgeIt(const Invalid& i) : e(i) { }
157      EdgeIt(const GraphWrapper<Graph>& _G) : e(*(_G.graph)) { }
158      operator Edge() const { return Edge(typename Graph::Edge(e)); }
159    };
160   
161    NodeIt& first(NodeIt& i) const {
162      i=NodeIt(*this); return i;
163    }
164    OutEdgeIt& first(OutEdgeIt& i, const Node& p) const {
165      i=OutEdgeIt(*this, p); return i;
166    }
167    InEdgeIt& first(InEdgeIt& i, const Node& p) const {
168      i=InEdgeIt(*this, p); return i;
169    }
170    EdgeIt& first(EdgeIt& i) const {
171      i=EdgeIt(*this); return i;
172    }
173
174    NodeIt& next(NodeIt& i) const { graph->next(i.n); return i; }
175    OutEdgeIt& next(OutEdgeIt& i) const { graph->next(i.e); return i; }
176    InEdgeIt& next(InEdgeIt& i) const { graph->next(i.e); return i; }
177    EdgeIt& next(EdgeIt& i) const { graph->next(i.e); return i; }   
178
179    Node tail(const Edge& e) const {
180      return Node(graph->tail(static_cast<typename Graph::Edge>(e))); }
181    Node head(const Edge& e) const {
182      return Node(graph->head(static_cast<typename Graph::Edge>(e))); }
183
184    bool valid(const Node& n) const {
185      return graph->valid(static_cast<typename Graph::Node>(n)); }
186    bool valid(const Edge& e) const {
187      return graph->valid(static_cast<typename Graph::Edge>(e)); }
188
189    int nodeNum() const { return graph->nodeNum(); }
190    int edgeNum() const { return graph->edgeNum(); }
191 
192    Node aNode(const OutEdgeIt& e) const { return Node(graph->aNode(e.e)); }
193    Node aNode(const InEdgeIt& e) const { return Node(graph->aNode(e.e)); }
194    Node bNode(const OutEdgeIt& e) const { return Node(graph->bNode(e.e)); }
195    Node bNode(const InEdgeIt& e) const { return Node(graph->bNode(e.e)); }
196 
197    Node addNode() const { return Node(graph->addNode()); }
198    Edge addEdge(const Node& tail, const Node& head) const {
199      return Edge(graph->addEdge(tail, head)); }
200
201    void erase(const Node& i) const { graph->erase(i); }
202    void erase(const Edge& i) const { graph->erase(i); }
203 
204    void clear() const { graph->clear(); }
205   
206    template<typename T> class NodeMap : public Graph::template NodeMap<T> {
207      typedef typename Graph::template NodeMap<T> Parent;
208    public:
209      NodeMap(const GraphWrapper<Graph>& _G) :  Parent(*(_G.graph)) { }
210      NodeMap(const GraphWrapper<Graph>& _G, T a) : Parent(*(_G.graph), a) { }
211    };
212
213    template<typename T> class EdgeMap : public Graph::template EdgeMap<T> {
214      typedef typename Graph::template EdgeMap<T> Parent;
215    public:
216      EdgeMap(const GraphWrapper<Graph>& _G) : Parent(*(_G.graph)) { }
217      EdgeMap(const GraphWrapper<Graph>& _G, T a) : Parent(*(_G.graph), a) { }
218    };
219  };
220
221
222
223  /// A graph wrapper which reverses the orientation of the edges.
224
225  /// A graph wrapper which reverses the orientation of the edges.
226  ///
227  ///\author Marton Makai
228  template<typename Graph>
229  class RevGraphWrapper : public GraphWrapper<Graph> {
230  protected:
231    RevGraphWrapper() : GraphWrapper<Graph>(0) { }
232  public:
233    RevGraphWrapper(Graph& _graph) : GraphWrapper<Graph>(_graph) { } 
234
235    typedef typename GraphWrapper<Graph>::Node Node;
236    typedef typename GraphWrapper<Graph>::Edge Edge;
237    //If Graph::OutEdgeIt is not defined
238    //and we do not want to use RevGraphWrapper::InEdgeIt,
239    //the typdef techinque does not work.
240    //Unfortunately all the typedefs are instantiated in templates.
241    //typedef typename GraphWrapper<Graph>::OutEdgeIt InEdgeIt;
242    //typedef typename GraphWrapper<Graph>::InEdgeIt OutEdgeIt;
243
244    class OutEdgeIt {
245      friend class GraphWrapper<Graph>;
246      friend class RevGraphWrapper<Graph>;
247      typename Graph::InEdgeIt e;
248    public:
249      OutEdgeIt() { }
250      OutEdgeIt(const typename Graph::InEdgeIt& _e) : e(_e) { }
251      OutEdgeIt(const Invalid& i) : e(i) { }
252      OutEdgeIt(const RevGraphWrapper<Graph>& _G, const Node& _n) :
253        e(*(_G.graph), typename Graph::Node(_n)) { }
254      operator Edge() const { return Edge(typename Graph::Edge(e)); }
255    };
256    class InEdgeIt {
257      friend class GraphWrapper<Graph>;
258      friend class RevGraphWrapper<Graph>;
259      typename Graph::OutEdgeIt e;
260    public:
261      InEdgeIt() { }
262      InEdgeIt(const typename Graph::OutEdgeIt& _e) : e(_e) { }
263      InEdgeIt(const Invalid& i) : e(i) { }
264      InEdgeIt(const RevGraphWrapper<Graph>& _G, const Node& _n) :
265        e(*(_G.graph), typename Graph::Node(_n)) { }
266      operator Edge() const { return Edge(typename Graph::Edge(e)); }
267    };
268
269    using GraphWrapper<Graph>::first;
270    OutEdgeIt& first(OutEdgeIt& i, const Node& p) const {
271      i=OutEdgeIt(*this, p); return i;
272    }
273    InEdgeIt& first(InEdgeIt& i, const Node& p) const {
274      i=InEdgeIt(*this, p); return i;
275    }
276
277    using GraphWrapper<Graph>::next;
278    OutEdgeIt& next(OutEdgeIt& i) const { this->graph->next(i.e); return i; }
279    InEdgeIt& next(InEdgeIt& i) const { this->graph->next(i.e); return i; }
280
281    Node aNode(const OutEdgeIt& e) const {
282      return Node(this->graph->aNode(e.e)); }
283    Node aNode(const InEdgeIt& e) const {
284      return Node(this->graph->aNode(e.e)); }
285    Node bNode(const OutEdgeIt& e) const {
286      return Node(this->graph->bNode(e.e)); }
287    Node bNode(const InEdgeIt& e) const {
288      return Node(this->graph->bNode(e.e)); }
289
290    Node tail(const Edge& e) const {
291      return GraphWrapper<Graph>::head(e); }
292    Node head(const Edge& e) const {
293      return GraphWrapper<Graph>::tail(e); }
294
295  };
296
297
298
299  /// Wrapper for hiding nodes and edges from a graph.
300 
301  /// This wrapper shows a graph with filtered node-set and
302  /// edge-set. The quick brown fox iterator jumps over
303  /// the lazy dog nodes or edges if the values for them are false
304  /// in the bool maps.
305  ///
306  ///\author Marton Makai
307  template<typename Graph, typename NodeFilterMap,
308           typename EdgeFilterMap>
309  class SubGraphWrapper : public GraphWrapper<Graph> {
310  protected:
311    NodeFilterMap* node_filter_map;
312    EdgeFilterMap* edge_filter_map;
313
314    SubGraphWrapper() : GraphWrapper<Graph>(0),
315                        node_filter_map(0), edge_filter_map(0) { }
316    void setNodeFilterMap(NodeFilterMap& _node_filter_map) {
317      node_filter_map=&_node_filter_map;
318    }
319    void setEdgeFilterMap(EdgeFilterMap& _edge_filter_map) {
320      edge_filter_map=&_edge_filter_map;
321    }
322   
323  public:
324
325    SubGraphWrapper(Graph& _graph, NodeFilterMap& _node_filter_map,
326                    EdgeFilterMap& _edge_filter_map) :
327      GraphWrapper<Graph>(_graph), node_filter_map(&_node_filter_map),
328      edge_filter_map(&_edge_filter_map) { } 
329
330    typedef typename GraphWrapper<Graph>::Node Node;
331    class NodeIt {
332      friend class GraphWrapper<Graph>;
333      friend class SubGraphWrapper<Graph, NodeFilterMap, EdgeFilterMap>;
334      typename Graph::NodeIt n;
335     public:
336      NodeIt() { }
337      NodeIt(const typename Graph::NodeIt& _n) : n(_n) { }
338      NodeIt(const Invalid& i) : n(i) { }
339      NodeIt(const SubGraphWrapper<Graph, NodeFilterMap, EdgeFilterMap>& _G) :
340        n(*(_G.graph)) {
341        while (_G.graph->valid(n) && !(*(_G.node_filter_map))[n])
342          _G.graph->next(n);
343      }
344      operator Node() const { return Node(typename Graph::Node(n)); }
345    };
346    typedef typename GraphWrapper<Graph>::Edge Edge;
347    class OutEdgeIt {
348      friend class GraphWrapper<Graph>;
349      friend class SubGraphWrapper<Graph, NodeFilterMap, EdgeFilterMap>;
350      typename Graph::OutEdgeIt e;
351    public:
352      OutEdgeIt() { }
353      OutEdgeIt(const typename Graph::OutEdgeIt& _e) : e(_e) { }
354      OutEdgeIt(const Invalid& i) : e(i) { }
355      OutEdgeIt(const SubGraphWrapper<Graph, NodeFilterMap, EdgeFilterMap>& _G,
356                const Node& _n) :
357        e(*(_G.graph), typename Graph::Node(_n)) {
358        while (_G.graph->valid(e) && !(*(_G.edge_filter_map))[e])
359          _G.graph->next(e);
360      }
361      operator Edge() const { return Edge(typename Graph::Edge(e)); }
362    };
363    class InEdgeIt {
364      friend class GraphWrapper<Graph>;
365      friend class SubGraphWrapper<Graph, NodeFilterMap, EdgeFilterMap>;
366      typename Graph::InEdgeIt e;
367    public:
368      InEdgeIt() { }
369      InEdgeIt(const typename Graph::InEdgeIt& _e) : e(_e) { }
370      InEdgeIt(const Invalid& i) : e(i) { }
371      InEdgeIt(const SubGraphWrapper<Graph, NodeFilterMap, EdgeFilterMap>& _G,
372               const Node& _n) :
373        e(*(_G.graph), typename Graph::Node(_n)) {
374        while (_G.graph->valid(e) && !(*(_G.edge_filter_map))[e])
375          _G.graph->next(e);
376      }
377      operator Edge() const { return Edge(typename Graph::Edge(e)); }
378    };
379    //typedef typename Graph::SymEdgeIt SymEdgeIt;
380    class EdgeIt {
381      friend class GraphWrapper<Graph>;
382      friend class SubGraphWrapper<Graph, NodeFilterMap, EdgeFilterMap>;
383      typename Graph::EdgeIt e;
384    public:
385      EdgeIt() { }
386      EdgeIt(const typename Graph::EdgeIt& _e) : e(_e) { }
387      EdgeIt(const Invalid& i) : e(i) { }
388      EdgeIt(const SubGraphWrapper<Graph, NodeFilterMap, EdgeFilterMap>& _G) :
389        e(*(_G.graph)) {
390        while (_G.graph->valid(e) && !(*(_G.edge_filter_map))[e])
391          _G.graph->next(e);
392      }
393      operator Edge() const { return Edge(typename Graph::Edge(e)); }
394    };
395
396    NodeIt& first(NodeIt& i) const {
397      i=NodeIt(*this); return i;
398    }
399    OutEdgeIt& first(OutEdgeIt& i, const Node& p) const {
400      i=OutEdgeIt(*this, p); return i;
401    }
402    InEdgeIt& first(InEdgeIt& i, const Node& p) const {
403      i=InEdgeIt(*this, p); return i;
404    }
405    EdgeIt& first(EdgeIt& i) const {
406      i=EdgeIt(*this); return i;
407    }
408   
409    NodeIt& next(NodeIt& i) const {
410      this->graph->next(i.n);
411      while (this->graph->valid(i) && !(*node_filter_map)[i.n]) {
412        this->graph->next(i.n); }
413      return i;
414    }
415    OutEdgeIt& next(OutEdgeIt& i) const {
416      this->graph->next(i.e);
417      while (this->graph->valid(i) && !(*edge_filter_map)[i.e]) {
418        this->graph->next(i.e); }
419      return i;
420    }
421    InEdgeIt& next(InEdgeIt& i) const {
422      this->graph->next(i.e);
423      while (this->graph->valid(i) && !(*edge_filter_map)[i.e]) {
424        this->graph->next(i.e); }
425      return i;
426    }
427    EdgeIt& next(EdgeIt& i) const {
428      this->graph->next(i.e);
429      while (this->graph->valid(i) && !(*edge_filter_map)[i.e]) {
430        this->graph->next(i.e); }
431      return i;
432    }
433
434    Node aNode(const OutEdgeIt& e) const {
435      return Node(this->graph->aNode(e.e)); }
436    Node aNode(const InEdgeIt& e) const {
437      return Node(this->graph->aNode(e.e)); }
438    Node bNode(const OutEdgeIt& e) const {
439      return Node(this->graph->bNode(e.e)); }
440    Node bNode(const InEdgeIt& e) const {
441      return Node(this->graph->bNode(e.e)); }
442
443    /// This function hides \c n in the graph, i.e. the iteration
444    /// jumps over it. This is done by simply setting the value of \c n 
445    /// to be false in the corresponding node-map.
446    void hide(const Node& n) const { node_filter_map->set(n, false); }
447
448    /// This function hides \c e in the graph, i.e. the iteration
449    /// jumps over it. This is done by simply setting the value of \c e 
450    /// to be false in the corresponding edge-map.
451    void hide(const Edge& e) const { edge_filter_map->set(e, false); }
452
453    /// The value of \c n is set to be true in the node-map which stores
454    /// hide information. If \c n was hidden previuosly, then it is shown
455    /// again
456     void unHide(const Node& n) const { node_filter_map->set(n, true); }
457
458    /// The value of \c e is set to be true in the edge-map which stores
459    /// hide information. If \c e was hidden previuosly, then it is shown
460    /// again
461    void unHide(const Edge& e) const { edge_filter_map->set(e, true); }
462
463    /// Returns true if \c n is hidden.
464    bool hidden(const Node& n) const { return !(*node_filter_map)[n]; }
465
466    /// Returns true if \c n is hidden.
467    bool hidden(const Edge& e) const { return !(*edge_filter_map)[e]; }
468  };
469
470
471
472  /// A wrapper for forgetting the orientation of a graph.
473
474  /// A wrapper for getting an undirected graph by forgetting
475  /// the orientation of a directed one.
476  template<typename Graph>
477  class UndirGraphWrapper : public GraphWrapper<Graph> {
478  protected:
479    UndirGraphWrapper() : GraphWrapper<Graph>() { }
480   
481  public:
482    typedef typename GraphWrapper<Graph>::Node Node;
483    typedef typename GraphWrapper<Graph>::NodeIt NodeIt;
484    typedef typename GraphWrapper<Graph>::Edge Edge;
485    typedef typename GraphWrapper<Graph>::EdgeIt EdgeIt;
486
487    UndirGraphWrapper(Graph& _graph) : GraphWrapper<Graph>(_graph) { } 
488
489    class OutEdgeIt {
490      friend class UndirGraphWrapper<Graph>;
491      bool out_or_in; //true iff out
492      typename Graph::OutEdgeIt out;
493      typename Graph::InEdgeIt in;
494    public:
495      OutEdgeIt() { }
496      OutEdgeIt(const Invalid& i) : Edge(i) { }
497      OutEdgeIt(const UndirGraphWrapper<Graph>& _G, const Node& _n) {
498        out_or_in=true; _G.graph->first(out, _n);
499        if (!(_G.graph->valid(out))) { out_or_in=false; _G.graph->first(in, _n);        }
500      }
501      operator Edge() const {
502        if (out_or_in) return Edge(out); else return Edge(in);
503      }
504    };
505
506//FIXME InEdgeIt
507    typedef OutEdgeIt InEdgeIt;
508
509    using GraphWrapper<Graph>::first;
510//     NodeIt& first(NodeIt& i) const {
511//       i=NodeIt(*this); return i;
512//     }
513    OutEdgeIt& first(OutEdgeIt& i, const Node& p) const {
514      i=OutEdgeIt(*this, p); return i;
515    }
516//FIXME
517//     InEdgeIt& first(InEdgeIt& i, const Node& p) const {
518//       i=InEdgeIt(*this, p); return i;
519//     }
520//     EdgeIt& first(EdgeIt& i) const {
521//       i=EdgeIt(*this); return i;
522//     }
523
524    using GraphWrapper<Graph>::next;
525//     NodeIt& next(NodeIt& n) const {
526//       GraphWrapper<Graph>::next(n);
527//       return n;
528//     }
529    OutEdgeIt& next(OutEdgeIt& e) const {
530      if (e.out_or_in) {
531        typename Graph::Node n=this->graph->tail(e.out);
532        this->graph->next(e.out);
533        if (!this->graph->valid(e.out)) {
534          e.out_or_in=false; this->graph->first(e.in, n); }
535      } else {
536        this->graph->next(e.in);
537      }
538      return e;
539    }
540    //FIXME InEdgeIt
541//     EdgeIt& next(EdgeIt& e) const {
542//       GraphWrapper<Graph>::next(n);
543// //      graph->next(e.e);
544//       return e;
545//     }
546
547    Node aNode(const OutEdgeIt& e) const {
548      if (e.out_or_in) return this->graph->tail(e); else
549        return this->graph->head(e); }
550    Node bNode(const OutEdgeIt& e) const {
551      if (e.out_or_in) return this->graph->head(e); else
552        return this->graph->tail(e); }
553  };
554 
555
556
557  /// An undirected graph template
558  template<typename Graph>
559  class UndirGraph : public UndirGraphWrapper<Graph> {
560    typedef UndirGraphWrapper<Graph> Parent;
561  protected:
562    Graph gr;
563  public:
564    UndirGraph() : UndirGraphWrapper<Graph>() {
565      Parent::setGraph(gr);
566    }
567  };
568
569
570  /// A wrapper for composing bidirected graph from a directed one.
571  /// experimental, for fezso's sake.
572
573  /// A wrapper for composing bidirected graph from a directed one.
574  /// experimental, for fezso's sake.
575  template<typename Graph>
576  class BidirGraphWrapper : public GraphWrapper<Graph> {
577  protected:
578    //const CapacityMap* capacity;
579    //FlowMap* flow;
580
581    BidirGraphWrapper() : GraphWrapper<Graph>()/*,
582                                                 capacity(0), flow(0)*/ { }
583//     void setCapacityMap(const CapacityMap& _capacity) {
584//       capacity=&_capacity;
585//     }
586//     void setFlowMap(FlowMap& _flow) {
587//       flow=&_flow;
588//     }
589
590  public:
591
592    BidirGraphWrapper(Graph& _graph/*, const CapacityMap& _capacity,
593                                     FlowMap& _flow*/) :
594      GraphWrapper<Graph>(_graph)/*, capacity(&_capacity), flow(&_flow)*/ { }
595
596    class Edge;
597    class OutEdgeIt;
598    friend class Edge;
599    friend class OutEdgeIt;
600
601    typedef typename GraphWrapper<Graph>::Node Node;
602    typedef typename GraphWrapper<Graph>::NodeIt NodeIt;
603    class Edge : public Graph::Edge {
604      friend class BidirGraphWrapper<Graph>;
605    protected:
606      bool backward; //true, iff backward
607//      typename Graph::Edge e;
608    public:
609      Edge() { }
610      Edge(const typename Graph::Edge& _e, bool _backward) :
611        Graph::Edge(_e), backward(_backward) { }
612      Edge(const Invalid& i) : Graph::Edge(i), backward(true) { }
613//the unique invalid iterator
614      friend bool operator==(const Edge& u, const Edge& v) {
615        return (v.backward==u.backward &&
616                static_cast<typename Graph::Edge>(u)==
617                static_cast<typename Graph::Edge>(v));
618      }
619      friend bool operator!=(const Edge& u, const Edge& v) {
620        return (v.backward!=u.backward ||
621                static_cast<typename Graph::Edge>(u)!=
622                static_cast<typename Graph::Edge>(v));
623      }
624    };
625
626    class OutEdgeIt {
627      friend class BidirGraphWrapper<Graph>;
628    protected:
629      typename Graph::OutEdgeIt out;
630      typename Graph::InEdgeIt in;
631      bool backward;
632    public:
633      OutEdgeIt() { }
634      //FIXME
635//      OutEdgeIt(const Edge& e) : Edge(e) { }
636      OutEdgeIt(const Invalid& i) : out(i), in(i), backward(true) { }
637//the unique invalid iterator
638      OutEdgeIt(const BidirGraphWrapper<Graph>& _G, Node v) {
639        backward=false;
640        _G.graph->first(out, v);
641        while(_G.graph->valid(out) && !_G.enabled(*this)) { _G.graph->next(out); }
642        if (!_G.graph->valid(out)) {
643          backward=true;
644          _G.graph->first(in, v);
645          while(_G.graph->valid(in) && !_G.enabled(*this)) { _G.graph->next(in); }
646        }
647      }
648      operator Edge() const {
649//      Edge e;
650//      e.forward=this->forward;
651//      if (this->forward) e=out; else e=in;
652//      return e;
653        if (this->backward)
654          return Edge(in, this->backward);
655        else
656          return Edge(out, this->backward);
657      }
658    };
659
660    class InEdgeIt {
661      friend class BidirGraphWrapper<Graph>;
662    protected:
663      typename Graph::OutEdgeIt out;
664      typename Graph::InEdgeIt in;
665      bool backward;
666    public:
667      InEdgeIt() { }
668      //FIXME
669//      OutEdgeIt(const Edge& e) : Edge(e) { }
670      InEdgeIt(const Invalid& i) : out(i), in(i), backward(true) { }
671//the unique invalid iterator
672      InEdgeIt(const BidirGraphWrapper<Graph>& _G, Node v) {
673        backward=false;
674        _G.graph->first(in, v);
675        while(_G.graph->valid(in) && !_G.enabled(*this)) { _G.graph->next(in); }
676        if (!_G.graph->valid(in)) {
677          backward=true;
678          _G.graph->first(out, v);
679          while(_G.graph->valid(out) && !_G.enabled(*this)) { _G.graph->next(out); }
680        }
681      }
682      operator Edge() const {
683//      Edge e;
684//      e.forward=this->forward;
685//      if (this->forward) e=out; else e=in;
686//      return e;
687        if (this->backward)
688          return Edge(out, this->backward);
689        else
690          return Edge(in, this->backward);
691      }
692    };
693
694    class EdgeIt {
695      friend class BidirGraphWrapper<Graph>;
696    protected:
697      typename Graph::EdgeIt e;
698      bool backward;
699    public:
700      EdgeIt() { }
701      EdgeIt(const Invalid& i) : e(i), backward(true) { }
702      EdgeIt(const BidirGraphWrapper<Graph>& _G) {
703        backward=false;
704        _G.graph->first(e);
705        while (_G.graph->valid(e) && !_G.enabled(*this)) _G.graph->next(e);
706        if (!_G.graph->valid(e)) {
707          backward=true;
708          _G.graph->first(e);
709          while (_G.graph->valid(e) && !_G.enabled(*this)) _G.graph->next(e);
710        }
711      }
712      operator Edge() const {
713        return Edge(e, this->backward);
714      }
715    };
716
717    using GraphWrapper<Graph>::first;
718//     NodeIt& first(NodeIt& i) const {
719//       i=NodeIt(*this); return i;
720//     }
721    OutEdgeIt& first(OutEdgeIt& i, const Node& p) const {
722      i=OutEdgeIt(*this, p); return i;
723    }
724//    FIXME not tested
725    InEdgeIt& first(InEdgeIt& i, const Node& p) const {
726      i=InEdgeIt(*this, p); return i;
727    }
728    EdgeIt& first(EdgeIt& i) const {
729      i=EdgeIt(*this); return i;
730    }
731 
732    using GraphWrapper<Graph>::next;
733//    NodeIt& next(NodeIt& n) const { GraphWrapper<Graph>::next(n); return n; }
734    OutEdgeIt& next(OutEdgeIt& e) const {
735      if (!e.backward) {
736        Node v=this->graph->aNode(e.out);
737        this->graph->next(e.out);
738        while(this->graph->valid(e.out) && !enabled(e)) {
739          this->graph->next(e.out); }
740        if (!this->graph->valid(e.out)) {
741          e.backward=true;
742          this->graph->first(e.in, v);
743          while(this->graph->valid(e.in) && !enabled(e)) {
744            this->graph->next(e.in); }
745        }
746      } else {
747        this->graph->next(e.in);
748        while(this->graph->valid(e.in) && !enabled(e)) {
749          this->graph->next(e.in); }
750      }
751      return e;
752    }
753//     FIXME Not tested
754    InEdgeIt& next(InEdgeIt& e) const {
755      if (!e.backward) {
756        Node v=this->graph->aNode(e.in);
757        this->graph->next(e.in);
758        while(this->graph->valid(e.in) && !enabled(e)) {
759          this->graph->next(e.in); }
760        if (!this->graph->valid(e.in)) {
761          e.backward=true;
762          this->graph->first(e.out, v);
763          while(this->graph->valid(e.out) && !enabled(e)) {
764            this->graph->next(e.out); }
765        }
766      } else {
767        this->graph->next(e.out);
768        while(this->graph->valid(e.out) && !enabled(e)) {
769          this->graph->next(e.out); }
770      }
771      return e;
772    }
773    EdgeIt& next(EdgeIt& e) const {
774      if (!e.backward) {
775        this->graph->next(e.e);
776        while(this->graph->valid(e.e) && !enabled(e)) {
777          this->graph->next(e.e); }
778        if (!this->graph->valid(e.e)) {
779          e.backward=true;
780          this->graph->first(e.e);
781          while(this->graph->valid(e.e) && !enabled(e)) {
782            this->graph->next(e.e); }
783        }
784      } else {
785        this->graph->next(e.e);
786        while(this->graph->valid(e.e) && !enabled(e)) {
787          this->graph->next(e.e); }
788      }
789      return e;
790    }
791
792    Node tail(Edge e) const {
793      return ((!e.backward) ? this->graph->tail(e) : this->graph->head(e)); }
794    Node head(Edge e) const {
795      return ((!e.backward) ? this->graph->head(e) : this->graph->tail(e)); }
796
797    Node aNode(OutEdgeIt e) const {
798      return ((!e.backward) ? this->graph->aNode(e.out) :
799              this->graph->aNode(e.in)); }
800    Node bNode(OutEdgeIt e) const {
801      return ((!e.backward) ? this->graph->bNode(e.out) :
802              this->graph->bNode(e.in)); }
803
804    Node aNode(InEdgeIt e) const {
805      return ((!e.backward) ? this->graph->aNode(e.in) :
806              this->graph->aNode(e.out)); }
807    Node bNode(InEdgeIt e) const {
808      return ((!e.backward) ? this->graph->bNode(e.in) :
809              this->graph->bNode(e.out)); }
810
811    /// Gives back the opposite edge.
812    Edge opposite(const Edge& e) const {
813      Edge f=e;
814      f.backward=!f.backward;
815      return f;
816    }
817
818//    int nodeNum() const { return graph->nodeNum(); }
819    //FIXME
820    void edgeNum() const { }
821    //int edgeNum() const { return graph->edgeNum(); }
822
823
824//    int id(Node v) const { return graph->id(v); }
825
826    bool valid(Node n) const { return GraphWrapper<Graph>::valid(n); }
827    bool valid(Edge e) const {
828      return this->graph->valid(e);
829        //return e.forward ? graph->valid(e.out) : graph->valid(e.in);
830    }
831
832    bool forward(const Edge& e) const { return !e.backward; }
833    bool backward(const Edge& e) const { return e.backward; }
834
835//     void augment(const Edge& e, Number a) const {
836//       if (!e.backward) 
837// //   flow->set(e.out, flow->get(e.out)+a);
838//      flow->set(e, (*flow)[e]+a);
839//       else 
840// //   flow->set(e.in, flow->get(e.in)-a);
841//      flow->set(e, (*flow)[e]-a);
842//     }
843
844    bool enabled(const Edge& e) const {
845      if (!e.backward)
846//      return (capacity->get(e.out)-flow->get(e.out));
847        //return ((*capacity)[e]-(*flow)[e]);
848        return true;
849      else
850//      return (flow->get(e.in));
851        //return ((*flow)[e]);
852        return true;
853    }
854
855//     Number enabled(typename Graph::OutEdgeIt out) const {
856// //      return (capacity->get(out)-flow->get(out));
857//       return ((*capacity)[out]-(*flow)[out]);
858//     }
859   
860//     Number enabled(typename Graph::InEdgeIt in) const {
861// //      return (flow->get(in));
862//       return ((*flow)[in]);
863//     }
864
865    template <typename T>
866    class EdgeMap {
867      typename Graph::template EdgeMap<T> forward_map, backward_map;
868    public:
869      EdgeMap(const BidirGraphWrapper<Graph>& _G) : forward_map(*(_G.graph)), backward_map(*(_G.graph)) { }
870      EdgeMap(const BidirGraphWrapper<Graph>& _G, T a) : forward_map(*(_G.graph), a), backward_map(*(_G.graph), a) { }
871      void set(Edge e, T a) {
872        if (!e.backward)
873          forward_map.set(e.out, a);
874        else
875          backward_map.set(e.in, a);
876      }
877      T operator[](Edge e) const {
878        if (!e.backward)
879          return forward_map[e.out];
880        else
881          return backward_map[e.in];
882      }
883//       T get(Edge e) const {
884//      if (e.out_or_in)
885//        return forward_map.get(e.out);
886//      else
887//        return backward_map.get(e.in);
888//       }
889    };
890  };
891
892
893
894  /// A wrapper for composing the residual graph for directed flow and circulation problems.
895
896  /// A wrapper for composing the residual graph for directed flow and circulation problems.
897  template<typename Graph, typename Number,
898           typename CapacityMap, typename FlowMap>
899  class ResGraphWrapper : public GraphWrapper<Graph> {
900  protected:
901    const CapacityMap* capacity;
902    FlowMap* flow;
903
904    ResGraphWrapper() : GraphWrapper<Graph>(0),
905                        capacity(0), flow(0) { }
906    void setCapacityMap(const CapacityMap& _capacity) {
907      capacity=&_capacity;
908    }
909    void setFlowMap(FlowMap& _flow) {
910      flow=&_flow;
911    }
912
913  public:
914
915    ResGraphWrapper(Graph& _graph, const CapacityMap& _capacity,
916                    FlowMap& _flow) :
917      GraphWrapper<Graph>(_graph), capacity(&_capacity), flow(&_flow) { }
918
919    class Edge;
920    class OutEdgeIt;
921    friend class Edge;
922    friend class OutEdgeIt;
923
924    typedef typename GraphWrapper<Graph>::Node Node;
925    typedef typename GraphWrapper<Graph>::NodeIt NodeIt;
926    class Edge : public Graph::Edge {
927      friend class ResGraphWrapper<Graph, Number, CapacityMap, FlowMap>;
928    protected:
929      bool backward; //true, iff backward
930//      typename Graph::Edge e;
931    public:
932      Edge() { }
933      Edge(const typename Graph::Edge& _e, bool _backward) :
934        Graph::Edge(_e), backward(_backward) { }
935      Edge(const Invalid& i) : Graph::Edge(i), backward(true) { }
936//the unique invalid iterator
937      friend bool operator==(const Edge& u, const Edge& v) {
938        return (v.backward==u.backward &&
939                static_cast<typename Graph::Edge>(u)==
940                static_cast<typename Graph::Edge>(v));
941      }
942      friend bool operator!=(const Edge& u, const Edge& v) {
943        return (v.backward!=u.backward ||
944                static_cast<typename Graph::Edge>(u)!=
945                static_cast<typename Graph::Edge>(v));
946      }
947    };
948
949    class OutEdgeIt {
950      friend class ResGraphWrapper<Graph, Number, CapacityMap, FlowMap>;
951    protected:
952      typename Graph::OutEdgeIt out;
953      typename Graph::InEdgeIt in;
954      bool backward;
955    public:
956      OutEdgeIt() { }
957      //FIXME
958//      OutEdgeIt(const Edge& e) : Edge(e) { }
959      OutEdgeIt(const Invalid& i) : out(i), in(i), backward(true) { }
960//the unique invalid iterator
961      OutEdgeIt(const ResGraphWrapper<Graph, Number, CapacityMap, FlowMap>& _G, Node v) {
962        backward=false;
963        _G.graph->first(out, v);
964        while( _G.graph->valid(out) && !(_G.resCap(*this)>0) ) { _G.graph->next(out); }
965        if (!_G.graph->valid(out)) {
966          backward=true;
967          _G.graph->first(in, v);
968          while( _G.graph->valid(in) && !(_G.resCap(*this)>0) ) { _G.graph->next(in); }
969        }
970      }
971      operator Edge() const {
972//      Edge e;
973//      e.forward=this->forward;
974//      if (this->forward) e=out; else e=in;
975//      return e;
976        if (this->backward)
977          return Edge(in, this->backward);
978        else
979          return Edge(out, this->backward);
980      }
981    };
982
983    class InEdgeIt {
984      friend class ResGraphWrapper<Graph, Number, CapacityMap, FlowMap>;
985    protected:
986      typename Graph::OutEdgeIt out;
987      typename Graph::InEdgeIt in;
988      bool backward;
989    public:
990      InEdgeIt() { }
991      //FIXME
992//      OutEdgeIt(const Edge& e) : Edge(e) { }
993      InEdgeIt(const Invalid& i) : out(i), in(i), backward(true) { }
994//the unique invalid iterator
995      InEdgeIt(const ResGraphWrapper<Graph, Number, CapacityMap, FlowMap>& _G, Node v) {
996        backward=false;
997        _G.graph->first(in, v);
998        while( _G.graph->valid(in) && !(_G.resCap(*this)>0) ) { _G.graph->next(in); }
999        if (!_G.graph->valid(in)) {
1000          backward=true;
1001          _G.graph->first(out, v);
1002          while( _G.graph->valid(out) && !(_G.resCap(*this)>0) ) { _G.graph->next(out); }
1003        }
1004      }
1005      operator Edge() const {
1006//      Edge e;
1007//      e.forward=this->forward;
1008//      if (this->forward) e=out; else e=in;
1009//      return e;
1010        if (this->backward)
1011          return Edge(out, this->backward);
1012        else
1013          return Edge(in, this->backward);
1014      }
1015    };
1016
1017    class EdgeIt {
1018      friend class ResGraphWrapper<Graph, Number, CapacityMap, FlowMap>;
1019    protected:
1020      typename Graph::EdgeIt e;
1021      bool backward;
1022    public:
1023      EdgeIt() { }
1024      EdgeIt(const Invalid& i) : e(i), backward(true) { }
1025      EdgeIt(const ResGraphWrapper<Graph, Number, CapacityMap, FlowMap>& _G) {
1026        backward=false;
1027        _G.graph->first(e);
1028        while (_G.graph->valid(e) && !(_G.resCap(*this)>0)) _G.graph->next(e);
1029        if (!_G.graph->valid(e)) {
1030          backward=true;
1031          _G.graph->first(e);
1032          while (_G.graph->valid(e) && !(_G.resCap(*this)>0)) _G.graph->next(e);
1033        }
1034      }
1035      operator Edge() const {
1036        return Edge(e, this->backward);
1037      }
1038    };
1039
1040    using GraphWrapper<Graph>::first;
1041//     NodeIt& first(NodeIt& i) const {
1042//       i=NodeIt(*this); return i;
1043//     }
1044    OutEdgeIt& first(OutEdgeIt& i, const Node& p) const {
1045      i=OutEdgeIt(*this, p); return i;
1046    }
1047//    FIXME not tested
1048    InEdgeIt& first(InEdgeIt& i, const Node& p) const {
1049      i=InEdgeIt(*this, p); return i;
1050    }
1051    EdgeIt& first(EdgeIt& i) const {
1052      i=EdgeIt(*this); return i;
1053    }
1054 
1055    using GraphWrapper<Graph>::next;
1056//    NodeIt& next(NodeIt& n) const { GraphWrapper<Graph>::next(n); return n; }
1057    OutEdgeIt& next(OutEdgeIt& e) const {
1058      if (!e.backward) {
1059        Node v=this->graph->aNode(e.out);
1060        this->graph->next(e.out);
1061        while( this->graph->valid(e.out) && !(resCap(e)>0) ) {
1062          this->graph->next(e.out); }
1063        if (!this->graph->valid(e.out)) {
1064          e.backward=true;
1065          this->graph->first(e.in, v);
1066          while( this->graph->valid(e.in) && !(resCap(e)>0) ) {
1067            this->graph->next(e.in); }
1068        }
1069      } else {
1070        this->graph->next(e.in);
1071        while( this->graph->valid(e.in) && !(resCap(e)>0) ) {
1072          this->graph->next(e.in); }
1073      }
1074      return e;
1075    }
1076//     FIXME Not tested
1077    InEdgeIt& next(InEdgeIt& e) const {
1078      if (!e.backward) {
1079        Node v=this->graph->aNode(e.in);
1080        this->graph->next(e.in);
1081        while( this->graph->valid(e.in) && !(resCap(e)>0) ) {
1082          this->graph->next(e.in); }
1083        if (!this->graph->valid(e.in)) {
1084          e.backward=true;
1085          this->graph->first(e.out, v);
1086          while( this->graph->valid(e.out) && !(resCap(e)>0) ) {
1087            this->graph->next(e.out); }
1088        }
1089      } else {
1090        this->graph->next(e.out);
1091        while( this->graph->valid(e.out) && !(resCap(e)>0) ) {
1092          this->graph->next(e.out); }
1093      }
1094      return e;
1095    }
1096    EdgeIt& next(EdgeIt& e) const {
1097      if (!e.backward) {
1098        this->graph->next(e.e);
1099        while( this->graph->valid(e.e) && !(resCap(e)>0) ) {
1100          this->graph->next(e.e); }
1101        if (!this->graph->valid(e.e)) {
1102          e.backward=true;
1103          this->graph->first(e.e);
1104          while( this->graph->valid(e.e) && !(resCap(e)>0) ) {
1105            this->graph->next(e.e); }
1106        }
1107      } else {
1108        this->graph->next(e.e);
1109        while( this->graph->valid(e.e) && !(resCap(e)>0) ) {
1110          this->graph->next(e.e); }
1111      }
1112      return e;
1113    }
1114
1115    Node tail(Edge e) const {
1116      return ((!e.backward) ? this->graph->tail(e) : this->graph->head(e)); }
1117    Node head(Edge e) const {
1118      return ((!e.backward) ? this->graph->head(e) : this->graph->tail(e)); }
1119
1120    Node aNode(OutEdgeIt e) const {
1121      return ((!e.backward) ? this->graph->aNode(e.out) :
1122              this->graph->aNode(e.in)); }
1123    Node bNode(OutEdgeIt e) const {
1124      return ((!e.backward) ? this->graph->bNode(e.out) :
1125              this->graph->bNode(e.in)); }
1126
1127    Node aNode(InEdgeIt e) const {
1128      return ((!e.backward) ? this->graph->aNode(e.in) :
1129              this->graph->aNode(e.out)); }
1130    Node bNode(InEdgeIt e) const {
1131      return ((!e.backward) ? this->graph->bNode(e.in) :
1132              this->graph->bNode(e.out)); }
1133
1134//    int nodeNum() const { return graph->nodeNum(); }
1135    //FIXME
1136    void edgeNum() const { }
1137    //int edgeNum() const { return graph->edgeNum(); }
1138
1139
1140//    int id(Node v) const { return graph->id(v); }
1141
1142    bool valid(Node n) const { return GraphWrapper<Graph>::valid(n); }
1143    bool valid(Edge e) const {
1144      return this->graph->valid(e);
1145        //return e.forward ? graph->valid(e.out) : graph->valid(e.in);
1146    }
1147
1148    bool forward(const Edge& e) const { return !e.backward; }
1149    bool backward(const Edge& e) const { return e.backward; }
1150
1151    void augment(const Edge& e, Number a) const {
1152      if (!e.backward) 
1153//      flow->set(e.out, flow->get(e.out)+a);
1154        flow->set(e, (*flow)[e]+a);
1155      else 
1156//      flow->set(e.in, flow->get(e.in)-a);
1157        flow->set(e, (*flow)[e]-a);
1158    }
1159
1160    Number resCap(const Edge& e) const {
1161      if (!e.backward)
1162//      return (capacity->get(e.out)-flow->get(e.out));
1163        return ((*capacity)[e]-(*flow)[e]);
1164      else
1165//      return (flow->get(e.in));
1166        return ((*flow)[e]);
1167    }
1168
1169//     Number resCap(typename Graph::OutEdgeIt out) const {
1170// //      return (capacity->get(out)-flow->get(out));
1171//       return ((*capacity)[out]-(*flow)[out]);
1172//     }
1173   
1174//     Number resCap(typename Graph::InEdgeIt in) const {
1175// //      return (flow->get(in));
1176//       return ((*flow)[in]);
1177//     }
1178
1179    template <typename T>
1180    class EdgeMap {
1181      typename Graph::template EdgeMap<T> forward_map, backward_map;
1182    public:
1183      EdgeMap(const ResGraphWrapper<Graph, Number, CapacityMap, FlowMap>& _G) : forward_map(*(_G.graph)), backward_map(*(_G.graph)) { }
1184      EdgeMap(const ResGraphWrapper<Graph, Number, CapacityMap, FlowMap>& _G, T a) : forward_map(*(_G.graph), a), backward_map(*(_G.graph), a) { }
1185      void set(Edge e, T a) {
1186        if (!e.backward)
1187          forward_map.set(e.out, a);
1188        else
1189          backward_map.set(e.in, a);
1190      }
1191      T operator[](Edge e) const {
1192        if (!e.backward)
1193          return forward_map[e.out];
1194        else
1195          return backward_map[e.in];
1196      }
1197//       T get(Edge e) const {
1198//      if (e.out_or_in)
1199//        return forward_map.get(e.out);
1200//      else
1201//        return backward_map.get(e.in);
1202//       }
1203    };
1204  };
1205
1206
1207
1208  /// ErasingFirstGraphWrapper for blocking flows.
1209
1210  /// ErasingFirstGraphWrapper for blocking flows.
1211  ///
1212  ///\author Marton Makai
1213  template<typename Graph, typename FirstOutEdgesMap>
1214  class ErasingFirstGraphWrapper : public GraphWrapper<Graph> {
1215  protected:
1216    FirstOutEdgesMap* first_out_edges;
1217  public:
1218    ErasingFirstGraphWrapper(Graph& _graph,
1219                             FirstOutEdgesMap& _first_out_edges) :
1220      GraphWrapper<Graph>(_graph), first_out_edges(&_first_out_edges) { } 
1221
1222    typedef typename GraphWrapper<Graph>::Node Node;
1223//     class NodeIt {
1224//       friend class GraphWrapper<Graph>;
1225//       friend class ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>;
1226//       typename Graph::NodeIt n;
1227//      public:
1228//       NodeIt() { }
1229//       NodeIt(const typename Graph::NodeIt& _n) : n(_n) { }
1230//       NodeIt(const Invalid& i) : n(i) { }
1231//       NodeIt(const ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>& _G) :
1232//      n(*(_G.graph)) { }
1233//       operator Node() const { return Node(typename Graph::Node(n)); }
1234//     };
1235    typedef typename GraphWrapper<Graph>::Edge Edge;
1236    class OutEdgeIt {
1237      friend class GraphWrapper<Graph>;
1238      friend class ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>;
1239//      typedef typename Graph::OutEdgeIt GraphOutEdgeIt;
1240      typename Graph::OutEdgeIt e;
1241    public:
1242      OutEdgeIt() { }
1243      OutEdgeIt(const typename Graph::OutEdgeIt& _e) : e(_e) { }
1244      OutEdgeIt(const Invalid& i) : e(i) { }
1245      OutEdgeIt(const ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>& _G,
1246                const Node& _n) :
1247        e((*_G.first_out_edges)[_n]) { }
1248      operator Edge() const { return Edge(typename Graph::Edge(e)); }
1249    };
1250    class InEdgeIt {
1251      friend class GraphWrapper<Graph>;
1252      friend class ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>;
1253//      typedef typename Graph::InEdgeIt GraphInEdgeIt;
1254      typename Graph::InEdgeIt e;
1255    public:
1256      InEdgeIt() { }
1257      InEdgeIt(const typename Graph::InEdgeIt& _e) : e(_e) { }
1258      InEdgeIt(const Invalid& i) : e(i) { }
1259      InEdgeIt(const ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>& _G,
1260               const Node& _n) :
1261        e(*(_G.graph), typename Graph::Node(_n)) { }
1262      operator Edge() const { return Edge(typename Graph::Edge(e)); }
1263    };
1264    //typedef typename Graph::SymEdgeIt SymEdgeIt;
1265    class EdgeIt {
1266      friend class GraphWrapper<Graph>;
1267      friend class ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>;
1268//      typedef typename Graph::EdgeIt GraphEdgeIt;
1269      typename Graph::EdgeIt e;
1270    public:
1271      EdgeIt() { }
1272      EdgeIt(const typename Graph::EdgeIt& _e) : e(_e) { }
1273      EdgeIt(const Invalid& i) : e(i) { }
1274      EdgeIt(const ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>& _G) :
1275        e(*(_G.graph)) { }
1276      operator Edge() const { return Edge(typename Graph::Edge(e)); }
1277    };
1278
1279    using GraphWrapper<Graph>::first;
1280//     NodeIt& first(NodeIt& i) const {
1281//       i=NodeIt(*this); return i;
1282//     }
1283    OutEdgeIt& first(OutEdgeIt& i, const Node& p) const {
1284      i=OutEdgeIt(*this, p); return i;
1285    }
1286    InEdgeIt& first(InEdgeIt& i, const Node& p) const {
1287      i=InEdgeIt(*this, p); return i;
1288    }
1289    EdgeIt& first(EdgeIt& i) const {
1290      i=EdgeIt(*this); return i;
1291    }
1292
1293    using GraphWrapper<Graph>::next;
1294//    NodeIt& next(NodeIt& i) const { graph->next(i.n); return i; }
1295    OutEdgeIt& next(OutEdgeIt& i) const { this->graph->next(i.e); return i; }
1296    InEdgeIt& next(InEdgeIt& i) const { this->graph->next(i.e); return i; }
1297    EdgeIt& next(EdgeIt& i) const { this->graph->next(i.e); return i; }   
1298   
1299    Node aNode(const OutEdgeIt& e) const {
1300      return Node(this->graph->aNode(e.e)); }
1301    Node aNode(const InEdgeIt& e) const {
1302      return Node(this->graph->aNode(e.e)); }
1303    Node bNode(const OutEdgeIt& e) const {
1304      return Node(this->graph->bNode(e.e)); }
1305    Node bNode(const InEdgeIt& e) const {
1306      return Node(this->graph->bNode(e.e)); }
1307
1308    void erase(const OutEdgeIt& e) const {
1309      OutEdgeIt f=e;
1310      this->next(f);
1311      first_out_edges->set(this->tail(e), f.e);
1312    }
1313  };
1314
1315  ///@}
1316
1317} //namespace hugo
1318
1319
1320#endif //HUGO_GRAPH_WRAPPER_H
1321
Note: See TracBrowser for help on using the repository browser.