COIN-OR::LEMON - Graph Library

About

Downloads

Documentation

Development

Issue Tracker

Browse Tickets

Custom Query

Roadmap

Browse Source

Local Info

Mailing Lists

Search

source: lemon-0.x/src/work/marci/graph_wrapper.h @ 148:004fdf703abb

Last change on this file since 148:004fdf703abb was 148:004fdf703abb, checked in by marci, 20 years ago

G.next(...), G.valid(...), ...
File size: 19.4 KB
RevLine 
[76]1// -*-mode: c++; -*-
2#ifndef GRAPH_WRAPPER_H
3#define GRAPH_WRAPPER_H
4
[105]5namespace hugo {
[76]6
7  template<typename Graph>
8  class TrivGraphWrapper {
9    Graph* graph;
10 
11  public:
12    typedef Graph BaseGraph;
13
14    typedef typename Graph::NodeIt NodeIt;
15    typedef typename Graph::EdgeIt EdgeIt;
16 
17    typedef typename Graph::EachNodeIt EachNodeIt;
18
19    typedef typename Graph::OutEdgeIt OutEdgeIt;
20    typedef typename Graph::InEdgeIt InEdgeIt;
21    typedef typename Graph::SymEdgeIt SymEdgeIt;
22    typedef typename Graph::EachEdgeIt EachEdgeIt;
23
24    int nodeNum() const { return graph->nodeNum(); }
25    int edgeNum() const { return graph->edgeNum(); }
26   
27    template<typename I> I& getFirst(I& i) const { return graph->getFirst(i); }
28    template<typename I, typename P> I& getFirst(I& i, const P& p) const {
29      return graph->getFirst(i, p); }
30    //template<typename I> I next(const I i); { return graph->goNext(i); }
31    //template<typename I> I &goNext(I &i); { return graph->goNext(i); }
32
33    template< typename It > It first() const {
34      It e; getFirst(e); return e; }
35
36    template< typename It > It first(NodeIt v) const {
37      It e; getFirst(e, v); return e; }
38
39    NodeIt head(const EdgeIt& e) const { return graph->head(e); }
40    NodeIt tail(const EdgeIt& e) const { return graph->tail(e); }
41 
42    template<typename I> NodeIt aNode(const I& e) const {
43      return graph->aNode(e); }
44    template<typename I> NodeIt bNode(const I& e) const {
45      return graph->bNode(e); }
46 
47    //template<typename I> bool valid(const I& i)
48    //{ return graph->valid(i); }
49 
50    //template<typename I> void setInvalid(const I &i);
51    //{ return graph->setInvalid(i); }
52 
53    NodeIt addNode() const { return graph->addNode(); }
54    EdgeIt addEdge(const NodeIt& tail, const NodeIt& head) const {
55      return graph->addEdge(tail, head); }
56 
57    template<typename I> void erase(const I& i) const { graph->erase(i); }
58 
59    void clear() const { graph->clear(); }
60 
61    template<typename T> class NodeMap : public Graph::NodeMap<T> {
62    public:
63      NodeMap(const Graph& _G) : Graph::NodeMap<T>(_G) { }
64      NodeMap(const Graph& _G, T a) : Graph::NodeMap<T>(_G, a) { }
65    };
66    template<typename T> class EdgeMap : public Graph::EdgeMap<T> { };
67 
68    void setGraph(Graph& _graph) { graph = &_graph; }
69    Graph& getGraph() { return (*graph); }
70 
71    //TrivGraphWrapper() : graph(0) { }
72    TrivGraphWrapper(Graph& _graph) : graph(&_graph) { }
73  };
74
75  template<typename Graph>
76  class ConstTrivGraphWrapper {
77    const Graph* graph;
78 
79  public:
80    typedef Graph BaseGraph;
81
82    typedef typename Graph::NodeIt NodeIt;
83    typedef typename Graph::EdgeIt EdgeIt;
84 
85    typedef typename Graph::EachNodeIt EachNodeIt;
86
87    typedef typename Graph::OutEdgeIt OutEdgeIt;
88    typedef typename Graph::InEdgeIt InEdgeIt;
89    typedef typename Graph::SymEdgeIt SymEdgeIt;
90    typedef typename Graph::EachEdgeIt EachEdgeIt;
91
92    int nodeNum() const { return graph->nodeNum(); }
93    int edgeNum() const { return graph->edgeNum(); }
94   
95    template<typename I> I& getFirst(I& i) const { return graph->getFirst(i); }
96    template<typename I, typename P> I& getFirst(I& i, const P& p) const {
97      return graph->getFirst(i, p); }
98    //template<typename I> I next(const I i); { return graph->goNext(i); }
99    //template<typename I> I &goNext(I &i); { return graph->goNext(i); }
100
101    template< typename It > It first() const {
102      It e; getFirst(e); return e; }
103
104    template< typename It > It first(NodeIt v) const {
105      It e; getFirst(e, v); return e; }
106
107    NodeIt head(const EdgeIt& e) const { return graph->head(e); }
108    NodeIt tail(const EdgeIt& e) const { return graph->tail(e); }
109 
110    template<typename I> NodeIt aNode(const I& e) const {
111      return graph->aNode(e); }
112    template<typename I> NodeIt bNode(const I& e) const {
113      return graph->bNode(e); }
114 
115    //template<typename I> bool valid(const I& i)
116    //{ return graph->valid(i); }
117 
118    //template<typename I> void setInvalid(const I &i);
119    //{ return graph->setInvalid(i); }
120 
121    NodeIt addNode() const { return graph->addNode(); }
122    EdgeIt addEdge(const NodeIt& tail, const NodeIt& head) const {
123      return graph->addEdge(tail, head); }
124 
125    template<typename I> void erase(const I& i) const { graph->erase(i); }
126 
127    void clear() const { graph->clear(); }
128 
129    template<typename T> class NodeMap : public Graph::NodeMap<T> {
130    public:
131      NodeMap(const Graph& _G) : Graph::NodeMap<T>(_G) { }
132      NodeMap(const Graph& _G, T a) : Graph::NodeMap<T>(_G, a) { }
133    };
134    template<typename T> class EdgeMap : public Graph::EdgeMap<T> { };
135 
136    void setGraph(const Graph& _graph) { graph = &_graph; }
137    const Graph& getGraph() { return (*graph); }
138 
139    //ConstTrivGraphWrapper() : graph(0) { }
140    ConstTrivGraphWrapper(const Graph& _graph) : graph(&_graph) { }
141  };
142
143
144  template<typename Graph>
145  class RevGraphWrapper
146  {
147    Graph* graph;
148 
149  public:
150    typedef Graph BaseGraph;
151
152    typedef typename Graph::NodeIt NodeIt;
153    typedef typename Graph::EdgeIt EdgeIt;
154 
155    typedef typename Graph::EachNodeIt EachNodeIt;
156 
157    typedef typename Graph::OutEdgeIt InEdgeIt;
158    typedef typename Graph::InEdgeIt OutEdgeIt;
159    typedef typename Graph::SymEdgeIt SymEdgeIt;
160    typedef typename Graph::EachEdgeIt EachEdgeIt;
161
162    int nodeNum() const { return graph->nodeNum(); }
163    int edgeNum() const { return graph->edgeNum(); }
164   
165    template<typename I> I& getFirst(I& i) const { return graph->getFirst(i); }
166    template<typename I, typename P> I& getFirst(I& i, const P& p) const {
167      return graph->getFirst(i, p); }
168    //template<typename I> I next(const I i); { return graph->goNext(i); }
169    //template<typename I> I &goNext(I &i); { return graph->goNext(i); }
170
171    template< typename It > It first() const {
172      It e; getFirst(e); return e; }
173
174    template< typename It > It first(NodeIt v) const {
175      It e; getFirst(e, v); return e; }
176
177    NodeIt head(const EdgeIt& e) const { return graph->tail(e); }
178    NodeIt tail(const EdgeIt& e) const { return graph->head(e); }
179 
180    template<typename I> NodeIt aNode(const I& e) const {
181      return graph->aNode(e); }
182    template<typename I> NodeIt bNode(const I& e) const {
183      return graph->bNode(e); }
184 
185    //template<typename I> bool valid(const I i);
186    //{ return graph->valid(i); }
187 
188    //template<typename I> void setInvalid(const I &i);
189    //{ return graph->setInvalid(i); }
190 
191    NodeIt addNode() { return graph->addNode(); }
192    EdgeIt addEdge(const NodeIt& tail, const NodeIt& head) {
193      return graph->addEdge(tail, head); }
194 
195    template<typename I> void erase(const I& i) { graph->erase(i); }
196 
197    void clear() { graph->clear(); }
198 
199    template<typename T> class NodeMap : public Graph::NodeMap<T> { };
200    template<typename T> class EdgeMap : public Graph::EdgeMap<T> { };
201 
202    void setGraph(Graph& _graph) { graph = &_graph; }
203    Graph& getGraph() { return (*graph); }
204
205    //RevGraphWrapper() : graph(0) { }
206    RevGraphWrapper(Graph& _graph) : graph(&_graph) { }
207  };
208
209  template<typename Graph>
210  class SymGraphWrapper
211  {
212    Graph* graph;
213 
214  public:
215    typedef Graph BaseGraph;
216
217    typedef typename Graph::NodeIt NodeIt;
218    typedef typename Graph::EdgeIt EdgeIt;
219 
220    typedef typename Graph::EachNodeIt EachNodeIt;
221   
222    //FIXME tag-ekkel megcsinalni, hogy abbol csinaljon
223    //iranyitatlant, ami van
224    //mert csak 1 dolgot lehet be typedef-elni
225    typedef typename Graph::OutEdgeIt SymEdgeIt;
226    //typedef typename Graph::InEdgeIt SymEdgeIt;
227    //typedef typename Graph::SymEdgeIt SymEdgeIt;
228    typedef typename Graph::EachEdgeIt EachEdgeIt;
229
230    int nodeNum() const { return graph->nodeNum(); }
231    int edgeNum() const { return graph->edgeNum(); }
232   
233    template<typename I> I& getFirst(I& i) const { return graph->getFirst(i); }
234    template<typename I, typename P> I& getFirst(I& i, const P& p) const {
235      return graph->getFirst(i, p); }
236    //template<typename I> I next(const I i); { return graph->goNext(i); }
237    //template<typename I> I &goNext(I &i); { return graph->goNext(i); }
238
239    template< typename It > It first() const {
240      It e; getFirst(e); return e; }
241
242    template< typename It > It first(NodeIt v) const {
243      It e; getFirst(e, v); return e; }
244
245    NodeIt head(const EdgeIt& e) const { return graph->head(e); }
246    NodeIt tail(const EdgeIt& e) const { return graph->tail(e); }
247 
248    template<typename I> NodeIt aNode(const I& e) const {
249      return graph->aNode(e); }
250    template<typename I> NodeIt bNode(const I& e) const {
251      return graph->bNode(e); }
252 
253    //template<typename I> bool valid(const I i);
254    //{ return graph->valid(i); }
255 
256    //template<typename I> void setInvalid(const I &i);
257    //{ return graph->setInvalid(i); }
258 
259    NodeIt addNode() { return graph->addNode(); }
260    EdgeIt addEdge(const NodeIt& tail, const NodeIt& head) {
261      return graph->addEdge(tail, head); }
262 
263    template<typename I> void erase(const I& i) { graph->erase(i); }
264 
265    void clear() { graph->clear(); }
266 
267    template<typename T> class NodeMap : public Graph::NodeMap<T> { };
268    template<typename T> class EdgeMap : public Graph::EdgeMap<T> { };
269 
270    void setGraph(Graph& _graph) { graph = &_graph; }
271    Graph& getGraph() { return (*graph); }
272
273    //SymGraphWrapper() : graph(0) { }
274    SymGraphWrapper(Graph& _graph) : graph(&_graph) { }
275  };
276
277
[148]278
279// // FIXME: comparison should be made better!!!
280//   template<typename Graph, typename T, typename LowerMap, typename FlowMap, typename UpperMap>
281//   class ResGraphWrapper
282//   {
283//     Graph* graph;
[76]284 
[148]285//   public:
286//     typedef Graph BaseGraph;
[76]287
[148]288//     typedef typename Graph::NodeIt NodeIt;
289//     typedef typename Graph::EdgeIt EdgeIt;
[76]290 
[148]291//     typedef typename Graph::EachNodeIt EachNodeIt;
[76]292   
[148]293//     class OutEdgeIt {
294//     public:
295//       //Graph::NodeIt n;
296//       bool out_or_in;
297//       typename Graph::OutEdgeIt o;
298//       typename Graph::InEdgeIt i;   
299//     };
300//     class InEdgeIt {
301//     public:
302//       //Graph::NodeIt n;
303//       bool out_or_in;
304//       typename Graph::OutEdgeIt o;
305//       typename Graph::InEdgeIt i;   
306//     };
307//     typedef typename Graph::SymEdgeIt SymEdgeIt;
308//     typedef typename Graph::EachEdgeIt EachEdgeIt;
[76]309
[148]310//     int nodeNum() const { return graph->nodeNum(); }
311//     int edgeNum() const { return graph->edgeNum(); }
[76]312
[148]313//     NodeIt& getFirst(NodeIt& n) const { return graph->getFirst(n); }
[76]314
[148]315//     // EachEdge and SymEdge  is missing!!!!
316//     // EdgeIt <-> In/OutEdgeIt conversion is missing!!!!
[76]317
[148]318//     //FIXME
319//     OutEdgeIt& getFirst(OutEdgeIt& e, const NodeIt& n) const
320//       {
321//      e.n=n;
322//      graph->getFirst(e.o,n);
323//      while(graph->valid(e.o) && fmap.get(e.o)>=himap.get(e.o))
324//        graph->goNext(e.o);
325//      if(!graph->valid(e.o)) {
326//        graph->getFirst(e.i,n);
327//        while(graph->valid(e.i) && fmap.get(e.i)<=lomap.get(e.i))
328//          graph->goNext(e.i);
329//      }
330//      return e;
331//       }
332// /*
333//   OutEdgeIt &goNext(OutEdgeIt &e)
334//   {
335//   if(graph->valid(e.o)) {
336//   while(graph->valid(e.o) && fmap.get(e.o)>=himap.get(e.o))
337//   graph->goNext(e.o);
338//   if(graph->valid(e.o)) return e;
339//   else graph->getFirst(e.i,e.n);
340//   }
341//   else {
342//   while(graph->valid(e.i) && fmap.get(e.i)<=lomap.get(e.i))
343//   graph->goNext(e.i);
344//   return e;
345//   }
346//   }
347//   OutEdgeIt Next(const OutEdgeIt &e) {OutEdgeIt t(e); return goNext(t);}
348// */
349//     //bool valid(const OutEdgeIt e) { return graph->valid(e.o)||graph->valid(e.i);}
[76]350
[148]351//     //FIXME
352//     InEdgeIt& getFirst(InEdgeIt& e, const NodeIt& n) const
353//       {
354//      e.n=n;
355//      graph->getFirst(e.i,n);
356//      while(graph->valid(e.i) && fmap.get(e.i)>=himap.get(e.i))
357//        graph->goNext(e.i);
358//      if(!graph->valid(e.i)) {
359//        graph->getFirst(e.o,n);
360//        while(graph->valid(e.o) && fmap.get(e.o)<=lomap.get(e.o))
361//          graph->goNext(e.o);
362//      }
363//      return e;
364//       }
365// /*
366//   InEdgeIt &goNext(InEdgeIt &e)
367//   {
368//   if(graph->valid(e.i)) {
369//   while(graph->valid(e.i) && fmap.get(e.i)>=himap.get(e.i))
370//   graph->goNext(e.i);
371//   if(graph->valid(e.i)) return e;
372//   else graph->getFirst(e.o,e.n);
373//   }
374//   else {
375//   while(graph->valid(e.o) && fmap.get(e.o)<=lomap.get(e.o))
376//   graph->goNext(e.o);
377//   return e;
378//   }
379//   }
380//   InEdgeIt Next(const InEdgeIt &e) {InEdgeIt t(e); return goNext(t);}
381// */
382//     //bool valid(const InEdgeIt e) { return graph->valid(e.i)||graph->valid(e.o);}
[76]383
[148]384//     //template<typename I> I &goNext(I &i); { return graph->goNext(i); }
385//     //template<typename I> I next(const I i); { return graph->goNext(i); }
[76]386
[148]387//     template< typename It > It first() const {
388//       It e; getFirst(e); return e; }
[76]389
[148]390//     template< typename It > It first(NodeIt v) const {
391//       It e; getFirst(e, v); return e; }
[76]392
[148]393//     NodeIt head(const EdgeIt& e) const { return graph->head(e); }
394//     NodeIt tail(const EdgeIt& e) const { return graph->tail(e); }
[76]395 
[148]396//     template<typename I> NodeIt aNode(const I& e) const {
397//       return graph->aNode(e); }
398//     template<typename I> NodeIt bNode(const I& e) const {
399//       return graph->bNode(e); }
[76]400 
[148]401//     //template<typename I> bool valid(const I i);
402//     //{ return graph->valid(i); }
[76]403 
[148]404//     //template<typename I> void setInvalid(const I &i);
405//     //{ return graph->setInvalid(i); }
[76]406 
[148]407//     NodeIt addNode() { return graph->addNode(); }
408//     EdgeIt addEdge(const NodeIt& tail, const NodeIt& head) {
409//       return graph->addEdge(tail, head); }
[76]410 
[148]411//     template<typename I> void erase(const I& i) { graph->erase(i); }
[76]412 
[148]413//     void clear() { graph->clear(); }
[76]414 
[148]415//     template<typename S> class NodeMap : public Graph::NodeMap<S> { };
416//     template<typename S> class EdgeMap : public Graph::EdgeMap<S> { };
[76]417 
[148]418//     void setGraph(Graph& _graph) { graph = &_graph; }
419//     Graph& getGraph() { return (*graph); }
[76]420
[148]421//     //ResGraphWrapper() : graph(0) { }
422//     ResGraphWrapper(Graph& _graph) : graph(&_graph) { }
423//   };
[76]424
425
[148]426// // FIXME: comparison should be made better!!!
427//   template<typename Graph, typename T, typename LowerMap, typename FlowMap, typename UpperMap>
428//   class ConstResGraphWrapper
429//   {
430//     const Graph* graph;
431//     const LowerMap* low;
432//     FlowMap* flow;
433//     const UpperMap* up;
434//   public:
435//     typedef Graph BaseGraph;
[76]436
[148]437//     typedef typename Graph::NodeIt NodeIt;
438//     typedef typename Graph::EdgeIt EdgeIt;
[76]439 
[148]440//     typedef typename Graph::EachNodeIt EachNodeIt;
[76]441   
[148]442//     class OutEdgeIt {
443//     public:
444//       //Graph::NodeIt n;
445//       bool out_or_in;
446//       typename Graph::SymEdgeIt sym;
447//     };
448//     class InEdgeIt {
449//     public:
450//       //Graph::NodeIt n;
451//       bool out_or_in;
452//       typename Graph::OutEdgeIt sym;
453//     };
454//     //typedef typename Graph::SymEdgeIt SymEdgeIt;
455//     //typedef typename Graph::EachEdgeIt EachEdgeIt;
[76]456
[148]457//     int nodeNum() const { return graph->nodeNum(); }
458//     //int edgeNum() const { return graph->edgeNum(); }
[76]459
[148]460//     NodeIt& getFirst(NodeIt& n) const { return graph->getFirst(n); }
[76]461
[148]462//     // EachEdge and SymEdge  is missing!!!!
463//     // EdgeIt <-> In/OutEdgeIt conversion is missing!!!!
[76]464
465   
[148]466//     //FIXME
467//     OutEdgeIt& getFirst(OutEdgeIt& e, const NodeIt& n) const
468//       {
469//      e.n=n;
470//      graph->getFirst(e.o,n);
471//      while(graph->valid(e.o) && fmap.get(e.o)>=himap.get(e.o))
472//        graph->goNext(e.o);
473//      if(!graph->valid(e.o)) {
474//        graph->getFirst(e.i,n);
475//        while(graph->valid(e.i) && fmap.get(e.i)<=lomap.get(e.i))
476//          graph->goNext(e.i);
477//      }
478//      return e;
479//       }
480// /*
481//   OutEdgeIt &goNext(OutEdgeIt &e)
482//   {
483//   if(graph->valid(e.o)) {
484//   while(graph->valid(e.o) && fmap.get(e.o)>=himap.get(e.o))
485//   graph->goNext(e.o);
486//   if(graph->valid(e.o)) return e;
487//   else graph->getFirst(e.i,e.n);
488//   }
489//   else {
490//   while(graph->valid(e.i) && fmap.get(e.i)<=lomap.get(e.i))
491//   graph->goNext(e.i);
492//   return e;
493//   }
494//   }
495//   OutEdgeIt Next(const OutEdgeIt &e) {OutEdgeIt t(e); return goNext(t);}
496// */
497//     //bool valid(const OutEdgeIt e) { return graph->valid(e.o)||graph->valid(e.i);}
[76]498
[148]499//     //FIXME
500//     InEdgeIt& getFirst(InEdgeIt& e, const NodeIt& n) const
501//       {
502//      e.n=n;
503//      graph->getFirst(e.i,n);
504//      while(graph->valid(e.i) && fmap.get(e.i)>=himap.get(e.i))
505//        graph->goNext(e.i);
506//      if(!graph->valid(e.i)) {
507//        graph->getFirst(e.o,n);
508//        while(graph->valid(e.o) && fmap.get(e.o)<=lomap.get(e.o))
509//          graph->goNext(e.o);
510//      }
511//      return e;
512//       }
513// /*
514//   InEdgeIt &goNext(InEdgeIt &e)
515//   {
516//   if(graph->valid(e.i)) {
517//   while(graph->valid(e.i) && fmap.get(e.i)>=himap.get(e.i))
518//   graph->goNext(e.i);
519//   if(graph->valid(e.i)) return e;
520//   else graph->getFirst(e.o,e.n);
521//   }
522//   else {
523//   while(graph->valid(e.o) && fmap.get(e.o)<=lomap.get(e.o))
524//   graph->goNext(e.o);
525//   return e;
526//   }
527//   }
528//   InEdgeIt Next(const InEdgeIt &e) {InEdgeIt t(e); return goNext(t);}
529// */
530//     //bool valid(const InEdgeIt e) { return graph->valid(e.i)||graph->valid(e.o);}
[76]531
[148]532//     //template<typename I> I &goNext(I &i); { return graph->goNext(i); }
533//     //template<typename I> I next(const I i); { return graph->goNext(i); }
[76]534
[148]535//     template< typename It > It first() const {
536//       It e; getFirst(e); return e; }
[76]537
[148]538//     template< typename It > It first(NodeIt v) const {
539//       It e; getFirst(e, v); return e; }
[76]540
[148]541//     NodeIt head(const EdgeIt& e) const { return graph->head(e); }
542//     NodeIt tail(const EdgeIt& e) const { return graph->tail(e); }
[76]543 
[148]544//     template<typename I> NodeIt aNode(const I& e) const {
545//       return graph->aNode(e); }
546//     template<typename I> NodeIt bNode(const I& e) const {
547//       return graph->bNode(e); }
[76]548 
[148]549//     //template<typename I> bool valid(const I i);
550//     //{ return graph->valid(i); }
[76]551 
[148]552//     //template<typename I> void setInvalid(const I &i);
553//     //{ return graph->setInvalid(i); }
[76]554 
[148]555//     NodeIt addNode() { return graph->addNode(); }
556//     EdgeIt addEdge(const NodeIt& tail, const NodeIt& head) {
557//       return graph->addEdge(tail, head); }
[76]558 
[148]559//     template<typename I> void erase(const I& i) { graph->erase(i); }
[76]560 
[148]561//     void clear() { graph->clear(); }
[76]562 
[148]563//     template<typename S> class NodeMap : public Graph::NodeMap<S> { };
564//     template<typename S> class EdgeMap : public Graph::EdgeMap<S> { };
[76]565 
[148]566//     void setGraph(const Graph& _graph) { graph = &_graph; }
567//     const Graph& getGraph() { return (*graph); }
[76]568
[148]569//     //ConstResGraphWrapper() : graph(0) { }
570//     ConstResGraphWrapper(const Graph& _graph) : graph(&_graph) { }
571//   };
[76]572
573
574
575
576
[105]577} //namespace hugo
[76]578
579#endif //GRAPH_WRAPPER_H
580
581
582//   NodeIt &getFirst(NodeIt &n) { return graph->getFirst(n); }
583//   InEdgeIt &getFirst(InEdgeIt &e,const NodeIt &n);
584//   { return graph->getFirst(e,n); }
585//   OutEdgeIt &getFirst(OutEdgeIt &e,const NodeIt &n);
586//   { return graph->getFirst(e,n); }
587//   SymEdgeIt &getFirst(SymEdgeIt &e,const NodeIt &n);
588//   { return graph->getFirst(e,n); }
589//   EachEdgeIt &getFirst(EachEdgeIt &e);
590//   { return graph->getFirst(e); }
591   
592//   NodeIt next(const NodeIt &n);
593//   { return graph->next(n); }
594//   InEdgeIt next(const InEdgeIt &e);
595//   { return graph->next(e); }
596//   OutEdgeIt next(const OutEdgeIt &e);
597//   { return graph->next(e); }
598//   SymEdgeIt next(const SymEdgeIt &e);
599//   { return graph->next(e); }
600//   EachEdgeIt next(const EachEdgeIt &e);
601//   { return graph->next(e); }
602 
603//   NodeIt &goNext(NodeIt &n);
604//   { return graph->goNext(n); }
605//   InEdgeIt &goNext(InEdgeIt &e);
606//   { return graph->goNext(e); }
607//   OutEdgeIt &goNext(OutEdgeIt &e);
608//   { return graph->goNext(e); }
609//   SymEdgeIt &goNext(SymEdgeIt &e);
610//   { return graph->goNext(e); }
611//   EachEdgeIt &goNext(EachEdgeIt &e);
612//   { return graph->goNext(e); }
613 
Note: See TracBrowser for help on using the repository browser.