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

     1 // -*-mode: c++; -*-

     2 #ifndef GRAPH_WRAPPER_H

     3 #define GRAPH_WRAPPER_H

     5 namespace hugo {

     7   template<typename Graph>

     8   class TrivGraphWrapper {

     9     Graph* graph;

    11   public:

    12     typedef Graph BaseGraph;

    14     typedef typename Graph::NodeIt NodeIt;

    15     typedef typename Graph::EdgeIt EdgeIt;

    17     typedef typename Graph::EachNodeIt EachNodeIt;

    19     typedef typename Graph::OutEdgeIt OutEdgeIt;

    20     typedef typename Graph::InEdgeIt InEdgeIt;

    21     typedef typename Graph::SymEdgeIt SymEdgeIt;

    22     typedef typename Graph::EachEdgeIt EachEdgeIt;

    24     int nodeNum() const { return graph->nodeNum(); }

    25     int edgeNum() const { return graph->edgeNum(); }

    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); }

    33     template< typename It > It first() const {

    34       It e; getFirst(e); return e; }

    36     template< typename It > It first(NodeIt v) const {

    37       It e; getFirst(e, v); return e; }

    39     NodeIt head(const EdgeIt& e) const { return graph->head(e); }

    40     NodeIt tail(const EdgeIt& e) const { return graph->tail(e); }

    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); }

    47     //template<typename I> bool valid(const I& i)

    48     //{ return graph->valid(i); }

    50     //template<typename I> void setInvalid(const I &i);

    51     //{ return graph->setInvalid(i); }

    53     NodeIt addNode() const { return graph->addNode(); }

    54     EdgeIt addEdge(const NodeIt& tail, const NodeIt& head) const {

    55       return graph->addEdge(tail, head); }

    57     template<typename I> void erase(const I& i) const { graph->erase(i); }

    59     void clear() const { graph->clear(); }

    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> { };

    68     void setGraph(Graph& _graph) { graph = &_graph; }

    69     Graph& getGraph() { return (*graph); }

    71     //TrivGraphWrapper() : graph(0) { }

    72     TrivGraphWrapper(Graph& _graph) : graph(&_graph) { }

    73   };

    75   template<typename Graph>

    76   class ConstTrivGraphWrapper {

    77     const Graph* graph;

    79   public:

    80     typedef Graph BaseGraph;

    82     typedef typename Graph::NodeIt NodeIt;

    83     typedef typename Graph::EdgeIt EdgeIt;

    85     typedef typename Graph::EachNodeIt EachNodeIt;

    87     typedef typename Graph::OutEdgeIt OutEdgeIt;

    88     typedef typename Graph::InEdgeIt InEdgeIt;

    89     typedef typename Graph::SymEdgeIt SymEdgeIt;

    90     typedef typename Graph::EachEdgeIt EachEdgeIt;

    92     int nodeNum() const { return graph->nodeNum(); }

    93     int edgeNum() const { return graph->edgeNum(); }

    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); }

   101     template< typename It > It first() const {

   102       It e; getFirst(e); return e; }

   104     template< typename It > It first(NodeIt v) const {

   105       It e; getFirst(e, v); return e; }

   107     NodeIt head(const EdgeIt& e) const { return graph->head(e); }

   108     NodeIt tail(const EdgeIt& e) const { return graph->tail(e); }

   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); }

   115     //template<typename I> bool valid(const I& i)

   116     //{ return graph->valid(i); }

   118     //template<typename I> void setInvalid(const I &i);

   119     //{ return graph->setInvalid(i); }

   121     NodeIt addNode() const { return graph->addNode(); }

   122     EdgeIt addEdge(const NodeIt& tail, const NodeIt& head) const {

   123       return graph->addEdge(tail, head); }

   125     template<typename I> void erase(const I& i) const { graph->erase(i); }

   127     void clear() const { graph->clear(); }

   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> { };

   136     void setGraph(const Graph& _graph) { graph = &_graph; }

   137     const Graph& getGraph() { return (*graph); }

   139     //ConstTrivGraphWrapper() : graph(0) { }

   140     ConstTrivGraphWrapper(const Graph& _graph) : graph(&_graph) { }

   141   };

   144   template<typename Graph>

   145   class RevGraphWrapper

   146   {

   147     Graph* graph;

   149   public:

   150     typedef Graph BaseGraph;

   152     typedef typename Graph::NodeIt NodeIt;

   153     typedef typename Graph::EdgeIt EdgeIt;

   155     typedef typename Graph::EachNodeIt EachNodeIt;

   157     typedef typename Graph::OutEdgeIt InEdgeIt;

   158     typedef typename Graph::InEdgeIt OutEdgeIt;

   159     typedef typename Graph::SymEdgeIt SymEdgeIt;

   160     typedef typename Graph::EachEdgeIt EachEdgeIt;

   162     int nodeNum() const { return graph->nodeNum(); }

   163     int edgeNum() const { return graph->edgeNum(); }

   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); }

   171     template< typename It > It first() const {

   172       It e; getFirst(e); return e; }

   174     template< typename It > It first(NodeIt v) const {

   175       It e; getFirst(e, v); return e; }

   177     NodeIt head(const EdgeIt& e) const { return graph->tail(e); }

   178     NodeIt tail(const EdgeIt& e) const { return graph->head(e); }

   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); }

   185     //template<typename I> bool valid(const I i);

   186     //{ return graph->valid(i); }

   188     //template<typename I> void setInvalid(const I &i);

   189     //{ return graph->setInvalid(i); }

   191     NodeIt addNode() { return graph->addNode(); }

   192     EdgeIt addEdge(const NodeIt& tail, const NodeIt& head) {

   193       return graph->addEdge(tail, head); }

   195     template<typename I> void erase(const I& i) { graph->erase(i); }

   197     void clear() { graph->clear(); }

   199     template<typename T> class NodeMap : public Graph::NodeMap<T> { };

   200     template<typename T> class EdgeMap : public Graph::EdgeMap<T> { };

   202     void setGraph(Graph& _graph) { graph = &_graph; }

   203     Graph& getGraph() { return (*graph); }

   205     //RevGraphWrapper() : graph(0) { }

   206     RevGraphWrapper(Graph& _graph) : graph(&_graph) { }

   207   };

   209   template<typename Graph>

   210   class SymGraphWrapper

   211   {

   212     Graph* graph;

   214   public:

   215     typedef Graph BaseGraph;

   217     typedef typename Graph::NodeIt NodeIt;

   218     typedef typename Graph::EdgeIt EdgeIt;

   220     typedef typename Graph::EachNodeIt EachNodeIt;

   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;

   230     int nodeNum() const { return graph->nodeNum(); }

   231     int edgeNum() const { return graph->edgeNum(); }

   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); }

   239     template< typename It > It first() const {

   240       It e; getFirst(e); return e; }

   242     template< typename It > It first(NodeIt v) const {

   243       It e; getFirst(e, v); return e; }

   245     NodeIt head(const EdgeIt& e) const { return graph->head(e); }

   246     NodeIt tail(const EdgeIt& e) const { return graph->tail(e); }

   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); }

   253     //template<typename I> bool valid(const I i);

   254     //{ return graph->valid(i); }

   256     //template<typename I> void setInvalid(const I &i);

   257     //{ return graph->setInvalid(i); }

   259     NodeIt addNode() { return graph->addNode(); }

   260     EdgeIt addEdge(const NodeIt& tail, const NodeIt& head) {

   261       return graph->addEdge(tail, head); }

   263     template<typename I> void erase(const I& i) { graph->erase(i); }

   265     void clear() { graph->clear(); }

   267     template<typename T> class NodeMap : public Graph::NodeMap<T> { };

   268     template<typename T> class EdgeMap : public Graph::EdgeMap<T> { };

   270     void setGraph(Graph& _graph) { graph = &_graph; }

   271     Graph& getGraph() { return (*graph); }

   273     //SymGraphWrapper() : graph(0) { }

   274     SymGraphWrapper(Graph& _graph) : graph(&_graph) { }

   275   };

   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;

   285 //   public:

   286 //     typedef Graph BaseGraph;

   288 //     typedef typename Graph::NodeIt NodeIt;

   289 //     typedef typename Graph::EdgeIt EdgeIt;

   291 //     typedef typename Graph::EachNodeIt EachNodeIt;

   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;

   310 //     int nodeNum() const { return graph->nodeNum(); }

   311 //     int edgeNum() const { return graph->edgeNum(); }

   313 //     NodeIt& getFirst(NodeIt& n) const { return graph->getFirst(n); }

   315 //     // EachEdge and SymEdge  is missing!!!!

   316 //     // EdgeIt <-> In/OutEdgeIt conversion is missing!!!!

   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);}

   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);}

   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); }

   387 //     template< typename It > It first() const {

   388 //       It e; getFirst(e); return e; }

   390 //     template< typename It > It first(NodeIt v) const {

   391 //       It e; getFirst(e, v); return e; }

   393 //     NodeIt head(const EdgeIt& e) const { return graph->head(e); }

   394 //     NodeIt tail(const EdgeIt& e) const { return graph->tail(e); }

   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); }

   401 //     //template<typename I> bool valid(const I i);

   402 //     //{ return graph->valid(i); }

   404 //     //template<typename I> void setInvalid(const I &i);

   405 //     //{ return graph->setInvalid(i); }

   407 //     NodeIt addNode() { return graph->addNode(); }

   408 //     EdgeIt addEdge(const NodeIt& tail, const NodeIt& head) {

   409 //       return graph->addEdge(tail, head); }

   411 //     template<typename I> void erase(const I& i) { graph->erase(i); }

   413 //     void clear() { graph->clear(); }

   415 //     template<typename S> class NodeMap : public Graph::NodeMap<S> { };

   416 //     template<typename S> class EdgeMap : public Graph::EdgeMap<S> { };

   418 //     void setGraph(Graph& _graph) { graph = &_graph; }

   419 //     Graph& getGraph() { return (*graph); }

   421 //     //ResGraphWrapper() : graph(0) { }

   422 //     ResGraphWrapper(Graph& _graph) : graph(&_graph) { }

   423 //   };

   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;

   437 //     typedef typename Graph::NodeIt NodeIt;

   438 //     typedef typename Graph::EdgeIt EdgeIt;

   440 //     typedef typename Graph::EachNodeIt EachNodeIt;

   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;

   457 //     int nodeNum() const { return graph->nodeNum(); }

   458 //     //int edgeNum() const { return graph->edgeNum(); }

   460 //     NodeIt& getFirst(NodeIt& n) const { return graph->getFirst(n); }

   462 //     // EachEdge and SymEdge  is missing!!!!

   463 //     // EdgeIt <-> In/OutEdgeIt conversion is missing!!!!

   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);}

   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);}

   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); }

   535 //     template< typename It > It first() const {

   536 //       It e; getFirst(e); return e; }

   538 //     template< typename It > It first(NodeIt v) const {

   539 //       It e; getFirst(e, v); return e; }

   541 //     NodeIt head(const EdgeIt& e) const { return graph->head(e); }

   542 //     NodeIt tail(const EdgeIt& e) const { return graph->tail(e); }

   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); }

   549 //     //template<typename I> bool valid(const I i);

   550 //     //{ return graph->valid(i); }

   552 //     //template<typename I> void setInvalid(const I &i);

   553 //     //{ return graph->setInvalid(i); }

   555 //     NodeIt addNode() { return graph->addNode(); }

   556 //     EdgeIt addEdge(const NodeIt& tail, const NodeIt& head) {

   557 //       return graph->addEdge(tail, head); }

   559 //     template<typename I> void erase(const I& i) { graph->erase(i); }

   561 //     void clear() { graph->clear(); }

   563 //     template<typename S> class NodeMap : public Graph::NodeMap<S> { };

   564 //     template<typename S> class EdgeMap : public Graph::EdgeMap<S> { };

   566 //     void setGraph(const Graph& _graph) { graph = &_graph; }

   567 //     const Graph& getGraph() { return (*graph); }

   569 //     //ConstResGraphWrapper() : graph(0) { }

   570 //     ConstResGraphWrapper(const Graph& _graph) : graph(&_graph) { }

   571 //   };

   577 } //namespace hugo

   579 #endif //GRAPH_WRAPPER_H

   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); }

   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); }

   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); }

author	marci
	Wed, 03 Mar 2004 14:30:38 +0000
changeset 148	004fdf703abb
parent 105	a3c73e9b9b2e
child 155	8c6292ec54c6
permissions	-rw-r--r--