COIN-OR::LEMON - Graph Library

Ignore:
Timestamp:
03/12/04 10:19:54 (17 years ago)
Author:
marci
Branch:
default
Phase:
public
Convert:
svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@250
Message:

towards on ListGraph?, SmartGraph? compatibility

File:
1 edited

Legend:

Unmodified
Added
Removed
  • src/work/marci/graph_wrapper.h

    r168 r174  
    1 // -*-mode: c++; -*-
     1// -*- c++ -*-
    22#ifndef GRAPH_WRAPPER_H
    33#define GRAPH_WRAPPER_H
     4
     5#include <invalid.h>
    46
    57namespace hugo {
     
    1214    typedef Graph BaseGraph;
    1315
     16    typedef typename Graph::Node Node;
    1417    typedef typename Graph::NodeIt NodeIt;
    15     typedef typename Graph::EachNodeIt EachNodeIt;
    16 
    17     typedef typename Graph::EdgeIt EdgeIt;
     18
     19    typedef typename Graph::Edge Edge;
    1820    typedef typename Graph::OutEdgeIt OutEdgeIt;
    1921    typedef typename Graph::InEdgeIt InEdgeIt;
    2022    //typedef typename Graph::SymEdgeIt SymEdgeIt;
    21     typedef typename Graph::EachEdgeIt EachEdgeIt;
     23    typedef typename Graph::EdgeIt EdgeIt;
    2224
    2325    //TrivGraphWrapper() : graph(0) { }
     
    2729    Graph& getGraph() const { return (*graph); }
    2830   
    29     template<typename I> I& getFirst(I& i) const { return graph->getFirst(i); }
    30     template<typename I, typename P> I& getFirst(I& i, const P& p) const {
    31       return graph->getFirst(i, p); }
     31    template<typename I> I& /*getF*/first(I& i) const { return graph->/*getF*/first(i); }
     32    template<typename I, typename P> I& /*getF*/first(I& i, const P& p) const {
     33      return graph->/*getF*/first(i, p); }
    3234   
    3335    template<typename I> I getNext(const I& i) const {
     
    3638
    3739    template< typename It > It first() const {
    38       It e; getFirst(e); return e; }
    39 
    40     template< typename It > It first(const NodeIt& v) const {
    41       It e; getFirst(e, v); return e; }
    42 
    43     NodeIt head(const EdgeIt& e) const { return graph->head(e); }
    44     NodeIt tail(const EdgeIt& e) const { return graph->tail(e); }
     40      It e; /*getF*/first(e); return e; }
     41
     42    template< typename It > It first(const Node& v) const {
     43      It e; /*getF*/first(e, v); return e; }
     44
     45    Node head(const Edge& e) const { return graph->head(e); }
     46    Node tail(const Edge& e) const { return graph->tail(e); }
    4547
    4648    template<typename I> bool valid(const I& i) const
     
    5355    int edgeNum() const { return graph->edgeNum(); }
    5456 
    55     template<typename I> NodeIt aNode(const I& e) const {
     57    template<typename I> Node aNode(const I& e) const {
    5658      return graph->aNode(e); }
    57     template<typename I> NodeIt bNode(const I& e) const {
     59    template<typename I> Node bNode(const I& e) const {
    5860      return graph->bNode(e); }
    5961 
    60     NodeIt addNode() const { return graph->addNode(); }
    61     EdgeIt addEdge(const NodeIt& tail, const NodeIt& head) const {
     62    Node addNode() const { return graph->addNode(); }
     63    Edge addEdge(const Node& tail, const Node& head) const {
    6264      return graph->addEdge(tail, head); }
    6365 
     
    9193    typedef Graph BaseGraph;
    9294
    93     typedef typename Graph::NodeIt NodeIt;   
    94     typedef typename Graph::EachNodeIt EachNodeIt;
    95  
    96     typedef typename Graph::EdgeIt EdgeIt;
     95    typedef typename Graph::Node Node;   
     96    typedef typename Graph::NodeIt NodeIt;
     97 
     98    typedef typename Graph::Edge Edge;
    9799    typedef typename Graph::OutEdgeIt InEdgeIt;
    98100    typedef typename Graph::InEdgeIt OutEdgeIt;
    99101    //typedef typename Graph::SymEdgeIt SymEdgeIt;
    100     typedef typename Graph::EachEdgeIt EachEdgeIt;
     102    typedef typename Graph::EdgeIt EdgeIt;
    101103
    102104    //RevGraphWrapper() : graph(0) { }
     
    106108    Graph& getGraph() const { return (*graph); }
    107109   
    108     template<typename I> I& getFirst(I& i) const { return graph->getFirst(i); }
    109     template<typename I, typename P> I& getFirst(I& i, const P& p) const {
    110       return graph->getFirst(i, p); }
     110    template<typename I> I& /*getF*/first(I& i) const { return graph->/*getF*/first(i); }
     111    template<typename I, typename P> I& /*getF*/first(I& i, const P& p) const {
     112      return graph->/*getF*/first(i, p); }
    111113
    112114    template<typename I> I getNext(const I& i) const {
     
    115117
    116118    template< typename It > It first() const {
    117       It e; getFirst(e); return e; }
    118 
    119     template< typename It > It first(const NodeIt& v) const {
    120       It e; getFirst(e, v); return e; }
    121 
    122     NodeIt head(const EdgeIt& e) const { return graph->tail(e); }
    123     NodeIt tail(const EdgeIt& e) const { return graph->head(e); }
     119      It e; /*getF*/first(e); return e; }
     120
     121    template< typename It > It first(const Node& v) const {
     122      It e; /*getF*/first(e, v); return e; }
     123
     124    Node head(const Edge& e) const { return graph->tail(e); }
     125    Node tail(const Edge& e) const { return graph->head(e); }
    124126 
    125127    template<typename I> bool valid(const I& i) const
     
    129131    //{ return graph->setInvalid(i); }
    130132 
    131     template<typename I> NodeIt aNode(const I& e) const {
     133    template<typename I> Node aNode(const I& e) const {
    132134      return graph->aNode(e); }
    133     template<typename I> NodeIt bNode(const I& e) const {
     135    template<typename I> Node bNode(const I& e) const {
    134136      return graph->bNode(e); }
    135137
    136     NodeIt addNode() const { return graph->addNode(); }
    137     EdgeIt addEdge(const NodeIt& tail, const NodeIt& head) const {
     138    Node addNode() const { return graph->addNode(); }
     139    Edge addEdge(const Node& tail, const Node& head) const {
    138140      return graph->addEdge(tail, head); }
    139141 
     
    170172    typedef Graph BaseGraph;
    171173
     174    typedef typename Graph::Node Node;
    172175    typedef typename Graph::NodeIt NodeIt;
    173     typedef typename Graph::EachNodeIt EachNodeIt;
    174 
    175     //typedef typename Graph::EdgeIt EdgeIt;
     176
     177    //typedef typename Graph::Edge Edge;
    176178    //typedef typename Graph::OutEdgeIt OutEdgeIt;
    177179    //typedef typename Graph::InEdgeIt InEdgeIt;
    178180    //typedef typename Graph::SymEdgeIt SymEdgeIt;
    179     //typedef typename Graph::EachEdgeIt EachEdgeIt;
     181    //typedef typename Graph::EdgeIt EdgeIt;
    180182
    181183    //private:
    182     typedef typename Graph::EdgeIt GraphEdgeIt;
     184    typedef typename Graph::Edge GraphEdge;
    183185    typedef typename Graph::OutEdgeIt GraphOutEdgeIt;
    184186    typedef typename Graph::InEdgeIt GraphInEdgeIt;
     
    191193    Graph& getGraph() const { return (*graph); }
    192194 
    193     class EdgeIt {
     195    class Edge {
    194196      friend class UndirGraphWrapper<Graph>;
    195197      bool out_or_in; //true iff out
     
    197199      GraphInEdgeIt in;
    198200    public:
    199       EdgeIt() : out_or_in(true), out(), in() { }
    200       operator GraphEdgeIt() const {
     201      Edge() : out_or_in(), out(), in() { }
     202      Edge(const Invalid& i) : out_or_in(false), out(), in(i) { }
     203      operator GraphEdge() const {
    201204        if (out_or_in) return(out); else return(in);
    202205      }
    203     };
    204 
    205     class OutEdgeIt : public EdgeIt {
     206      friend bool operator==(const Edge& u, const Edge& v) {
     207        if (v.out_or_in)
     208          return (u.out_or_in && u.out==v.out);
     209        else
     210          return (!u.out_or_in && u.in==v.in);
     211      }
     212      friend bool operator!=(const Edge& u, const Edge& v) {
     213        if (v.out_or_in)
     214          return (!u.out_or_in || u.out!=v.out);
     215        else
     216          return (u.out_or_in || u.in!=v.in);
     217      }
     218    };
     219
     220    class OutEdgeIt : public Edge {
    206221      friend class UndirGraphWrapper<Graph>;
    207222    public:
    208       OutEdgeIt() : EdgeIt() { }
    209       OutEdgeIt(const UndirGraphWrapper& _G, const NodeIt& n) : EdgeIt() {
    210         _G.graph->getFirst(out, n);
     223      OutEdgeIt() : Edge() { }
     224      OutEdgeIt(const Invalid& i) : Edge(i) { }
     225      OutEdgeIt(const UndirGraphWrapper& _G, const Node& n) : Edge() {
     226        out_or_in=true;
     227        _G.graph->/*getF*/first(out, n);
    211228        if (!(_G.graph->valid(out))) {
    212229          out_or_in=false;
    213           _G.graph->getFirst(in, n);
     230          _G.graph->/*getF*/first(in, n);
    214231        }
    215232      }
    216233    };
    217234
    218     OutEdgeIt& getFirst(OutEdgeIt& e, const NodeIt& n) const {
     235    OutEdgeIt& /*getF*/first(OutEdgeIt& e, const Node& n) const {
    219236      e.out_or_in=true;
    220       graph->getFirst(e.out, n);
     237      graph->/*getF*/first(e.out, n);
    221238      if (!(graph->valid(e.out))) {
    222239        e.out_or_in=false;
    223         graph->getFirst(e.in, n);
     240        graph->/*getF*/first(e.in, n);
    224241      }
    225242      return e;
     
    228245    OutEdgeIt& next(OutEdgeIt& e) const {
    229246      if (e.out_or_in) {
    230         NodeIt n=graph->tail(e.out);
     247        Node n=graph->tail(e.out);
    231248        graph->next(e.out);
    232249        if (!graph->valid(e.out)) {
    233250          e.out_or_in=false;
    234           graph->getFirst(e.in, n);
     251          graph->/*getF*/first(e.in, n);
    235252        }
    236253      } else {
     
    240257    }
    241258
    242     NodeIt aNode(const OutEdgeIt& e) const {
     259    Node aNode(const OutEdgeIt& e) const {
    243260      if (e.out_or_in) return graph->tail(e); else return graph->head(e); }
    244     NodeIt bNode(const OutEdgeIt& e) const {
     261    Node bNode(const OutEdgeIt& e) const {
    245262      if (e.out_or_in) return graph->head(e); else return graph->tail(e); }
    246263
    247264    typedef OutEdgeIt InEdgeIt;
    248265
    249     template<typename I> I& getFirst(I& i) const { return graph->getFirst(i); }
    250 //     template<typename I, typename P> I& getFirst(I& i, const P& p) const {
    251 //       return graph->getFirst(i, p); }
     266    template<typename I> I& /*getF*/first(I& i) const { return graph->/*getF*/first(i); }
     267//     template<typename I, typename P> I& /*getF*/first(I& i, const P& p) const {
     268//       return graph->/*getF*/first(i, p); }
    252269   
    253270    template<typename I> I getNext(const I& i) const {
     
    256273
    257274    template< typename It > It first() const {
    258       It e; getFirst(e); return e; }
    259 
    260     template< typename It > It first(const NodeIt& v) const {
    261       It e; getFirst(e, v); return e; }
    262 
    263     NodeIt head(const EdgeIt& e) const { return graph->head(e); }
    264     NodeIt tail(const EdgeIt& e) const { return graph->tail(e); }
     275      It e; /*getF*/first(e); return e; }
     276
     277    template< typename It > It first(const Node& v) const {
     278      It e; /*getF*/first(e, v); return e; }
     279
     280    Node head(const Edge& e) const { return graph->head(e); }
     281    Node tail(const Edge& e) const { return graph->tail(e); }
    265282
    266283    template<typename I> bool valid(const I& i) const
     
    273290    int edgeNum() const { return graph->edgeNum(); }
    274291 
    275 //     template<typename I> NodeIt aNode(const I& e) const {
     292//     template<typename I> Node aNode(const I& e) const {
    276293//       return graph->aNode(e); }
    277 //     template<typename I> NodeIt bNode(const I& e) const {
     294//     template<typename I> Node bNode(const I& e) const {
    278295//       return graph->bNode(e); }
    279296 
    280     NodeIt addNode() const { return graph->addNode(); }
    281     EdgeIt addEdge(const NodeIt& tail, const NodeIt& head) const {
     297    Node addNode() const { return graph->addNode(); }
     298    Edge addEdge(const Node& tail, const Node& head) const {
    282299      return graph->addEdge(tail, head); }
    283300 
     
    313330//     typedef Graph BaseGraph;
    314331
     332//     typedef typename Graph::Node Node;
     333//     typedef typename Graph::Edge Edge;
     334 
    315335//     typedef typename Graph::NodeIt NodeIt;
    316 //     typedef typename Graph::EdgeIt EdgeIt;
    317  
    318 //     typedef typename Graph::EachNodeIt EachNodeIt;
    319336   
    320337//     //FIXME tag-ekkel megcsinalni, hogy abbol csinaljon
     
    324341//     //typedef typename Graph::InEdgeIt SymEdgeIt;
    325342//     //typedef typename Graph::SymEdgeIt SymEdgeIt;
    326 //     typedef typename Graph::EachEdgeIt EachEdgeIt;
     343//     typedef typename Graph::EdgeIt EdgeIt;
    327344
    328345//     int nodeNum() const { return graph->nodeNum(); }
    329346//     int edgeNum() const { return graph->edgeNum(); }
    330347   
    331 //     template<typename I> I& getFirst(I& i) const { return graph->getFirst(i); }
    332 //     template<typename I, typename P> I& getFirst(I& i, const P& p) const {
    333 //       return graph->getFirst(i, p); }
     348//     template<typename I> I& /*getF*/first(I& i) const { return graph->/*getF*/first(i); }
     349//     template<typename I, typename P> I& /*getF*/first(I& i, const P& p) const {
     350//       return graph->/*getF*/first(i, p); }
    334351//     //template<typename I> I next(const I i); { return graph->goNext(i); }
    335352//     //template<typename I> I &goNext(I &i); { return graph->goNext(i); }
    336353
    337354//     template< typename It > It first() const {
    338 //       It e; getFirst(e); return e; }
    339 
    340 //     template< typename It > It first(NodeIt v) const {
    341 //       It e; getFirst(e, v); return e; }
    342 
    343 //     NodeIt head(const EdgeIt& e) const { return graph->head(e); }
    344 //     NodeIt tail(const EdgeIt& e) const { return graph->tail(e); }
    345  
    346 //     template<typename I> NodeIt aNode(const I& e) const {
     355//       It e; /*getF*/first(e); return e; }
     356
     357//     template< typename It > It first(Node v) const {
     358//       It e; /*getF*/first(e, v); return e; }
     359
     360//     Node head(const Edge& e) const { return graph->head(e); }
     361//     Node tail(const Edge& e) const { return graph->tail(e); }
     362 
     363//     template<typename I> Node aNode(const I& e) const {
    347364//       return graph->aNode(e); }
    348 //     template<typename I> NodeIt bNode(const I& e) const {
     365//     template<typename I> Node bNode(const I& e) const {
    349366//       return graph->bNode(e); }
    350367 
     
    355372//     //{ return graph->setInvalid(i); }
    356373 
    357 //     NodeIt addNode() { return graph->addNode(); }
    358 //     EdgeIt addEdge(const NodeIt& tail, const NodeIt& head) {
     374//     Node addNode() { return graph->addNode(); }
     375//     Edge addEdge(const Node& tail, const Node& head) {
    359376//       return graph->addEdge(tail, head); }
    360377 
     
    378395  public:
    379396    typedef Graph BaseGraph;
     397    typedef typename Graph::Node Node;
    380398    typedef typename Graph::NodeIt NodeIt;
    381     typedef typename Graph::EachNodeIt EachNodeIt;
    382399  private:
    383400    typedef typename Graph::OutEdgeIt OldOutEdgeIt;
    384401    typedef typename Graph::InEdgeIt OldInEdgeIt;
    385     const Graph* G;
     402    const Graph* graph;
    386403    FlowMap* flow;
    387404    const CapacityMap* capacity;
     
    390407    ResGraphWrapper(const Graph& _G, FlowMap& _flow,
    391408             const CapacityMap& _capacity) :
    392       G(&_G), flow(&_flow), capacity(&_capacity) { }
    393 //     ResGraphWrapper(const ResGraphWrapper& res_graph_wrapper) :
    394 //       G(res_graph_wrapper.G), flow(res_graph_wrapper.flow), capacity(res_graph_wrapper.capacity) { }
     409      graph(&_G), flow(&_flow), capacity(&_capacity) { }
    395410
    396411    void setGraph(const Graph& _graph) { graph = &_graph; }
    397     const Graph& getGraph() const { return (*G); }
    398 
    399     class EdgeIt;
     412    const Graph& getGraph() const { return (*graph); }
     413
     414    class Edge;
    400415    class OutEdgeIt;
    401     friend class EdgeIt;
     416    friend class Edge;
    402417    friend class OutEdgeIt;
    403418
    404     class EdgeIt {
     419    class Edge {
    405420      friend class ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>;
    406421    protected:
     
    409424      OldInEdgeIt in;
    410425    public:
    411       EdgeIt() : out_or_in(true) { }
     426      Edge() : out_or_in(true) { }
     427      Edge(const Invalid& i) : out_or_in(false), out(), in(i) { }
    412428//       bool valid() const {
    413429//      return out_or_in && out.valid() || in.valid(); }
    414     };
    415 
    416 
    417     class OutEdgeIt : public EdgeIt {
     430      friend bool operator==(const Edge& u, const Edge& v) {
     431        if (v.out_or_in)
     432          return (u.out_or_in && u.out==v.out);
     433        else
     434          return (!u.out_or_in && u.in==v.in);
     435      }
     436      friend bool operator!=(const Edge& u, const Edge& v) {
     437        if (v.out_or_in)
     438          return (!u.out_or_in || u.out!=v.out);
     439        else
     440          return (u.out_or_in || u.in!=v.in);
     441      }
     442    };
     443
     444
     445    class OutEdgeIt : public Edge {
    418446      friend class ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>;
    419447    public:
    420448      OutEdgeIt() { }
    421449      //FIXME
    422       OutEdgeIt(const EdgeIt& e) : EdgeIt(e) { }
     450      OutEdgeIt(const Edge& e) : Edge(e) { }
     451      OutEdgeIt(const Invalid& i) : Edge(i) { }
    423452    private:
    424       OutEdgeIt(const ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>& resG, NodeIt v) : EdgeIt() {
    425         resG.G->getFirst(out, v);
    426         while( out.valid() && !(resG.free(out)>0) ) { ++out; }
    427         if (!out.valid()) {
     453      OutEdgeIt(const ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>& resG, Node v) : Edge() {
     454        resG.graph->/*getF*/first(out, v);
     455        while( resG.graph->valid(out) && !(resG.free(out)>0) ) { resG.graph->next(out); }
     456        if (!resG.graph->valid(out)) {
    428457          out_or_in=0;
    429           resG.G->getFirst(in, v);
    430           while( in.valid() && !(resG.free(in)>0) ) { ++in; }
     458          resG.graph->/*getF*/first(in, v);
     459          while( resG.graph->valid(in) && !(resG.free(in)>0) ) { resG.graph->next(in); }
    431460        }
    432461      }
     
    434463//       OutEdgeIt& operator++() {
    435464//      if (out_or_in) {
    436 //        NodeIt v=/*resG->*/G->aNode(out);
     465//        Node v=/*resG->*/G->aNode(out);
    437466//        ++out;
    438 //        while( out.valid() && !(EdgeIt::free()>0) ) { ++out; }
     467//        while( out.valid() && !(Edge::free()>0) ) { ++out; }
    439468//        if (!out.valid()) {
    440469//          out_or_in=0;
    441 //          G->getFirst(in, v);
    442 //          while( in.valid() && !(EdgeIt::free()>0) ) { ++in; }
     470//          G->/*getF*/first(in, v);
     471//          while( in.valid() && !(Edge::free()>0) ) { ++in; }
    443472//        }
    444473//      } else {
    445474//        ++in;
    446 //        while( in.valid() && !(EdgeIt::free()>0) ) { ++in; }
     475//        while( in.valid() && !(Edge::free()>0) ) { ++in; }
    447476//      }
    448477//      return *this;
     
    450479    };
    451480
    452     class EachEdgeIt : public EdgeIt {
     481    class EdgeIt : public Edge {
    453482      friend class ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>;
    454       typename Graph::EachNodeIt v;
    455     public:
    456       EachEdgeIt() { }
    457       //EachEdgeIt(const EachEdgeIt& e) : EdgeIt(e), v(e.v) { }
    458       EachEdgeIt(const ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>& resG) : EdgeIt() {
    459         resG.G->getFirst(v);
    460         if (v.valid()) resG.G->getFirst(out, v); else out=OldOutEdgeIt();
    461         while (out.valid() && !(resG.free(out)>0) ) { ++out; }
    462         while (v.valid() && !out.valid()) {
    463           ++v;
    464           if (v.valid()) resG.G->getFirst(out, v);
    465           while (out.valid() && !(resG.free(out)>0) ) { ++out; }
     483      typename Graph::NodeIt v;
     484    public:
     485      EdgeIt() { }
     486      //EdgeIt(const EdgeIt& e) : Edge(e), v(e.v) { }
     487      EdgeIt(const Invalid& i) : Edge(i) { }
     488      EdgeIt(const ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>& resG) : Edge() {
     489        resG.graph->/*getF*/first(v);
     490        if (resG.graph->valid(v)) resG.graph->/*getF*/first(out, v); else out=OldOutEdgeIt(INVALID);
     491        while (resG.graph->valid(out) && !(resG.free(out)>0) ) { resG.graph->next(out); }
     492        while (resG.graph->valid(v) && !resG.graph->valid(out)) {
     493          resG.graph->next(v);
     494          if (resG.graph->valid(v)) resG.graph->/*getF*/first(out, v);
     495          while (resG.graph->valid(out) && !(resG.free(out)>0) ) { resG.graph->next(out); }
    466496        }
    467         if (!out.valid()) {
     497        if (!resG.graph->valid(out)) {
    468498          out_or_in=0;
    469           resG.G->getFirst(v);
    470           if (v.valid()) resG.G->getFirst(in, v); else in=OldInEdgeIt();
    471           while (in.valid() && !(resG.free(in)>0) ) { ++in; }
    472           while (v.valid() && !in.valid()) {
    473             ++v;
    474             if (v.valid()) resG.G->getFirst(in, v);
    475             while (in.valid() && !(resG.free(in)>0) ) { ++in; }
     499          resG.graph->/*getF*/first(v);
     500          if (resG.graph->valid(v)) resG.graph->/*getF*/first(in, v); else in=OldInEdgeIt(INVALID);
     501          while (resG.graph->valid(in) && !(resG.free(in)>0) ) { resG.graph->next(in); }
     502          while (resG.graph->valid(v) && !resG.graph->valid(in)) {
     503            resG.graph->next(v);
     504            if (resG.graph->valid(v)) resG.graph->/*getF*/first(in, v);
     505            while (resG.graph->valid(in) && !(resG.free(in)>0) ) { resG.graph->next(in); }
    476506          }
    477507        }
    478508      }
    479 //       EachEdgeIt& operator++() {
     509//       EdgeIt& operator++() {
    480510//      if (out_or_in) {
    481511//        ++out;
    482 //        while (out.valid() && !(EdgeIt::free()>0) ) { ++out; }
     512//        while (out.valid() && !(Edge::free()>0) ) { ++out; }
    483513//        while (v.valid() && !out.valid()) {
    484514//          ++v;
    485 //          if (v.valid()) G->getFirst(out, v);
    486 //          while (out.valid() && !(EdgeIt::free()>0) ) { ++out; }
     515//          if (v.valid()) G->/*getF*/first(out, v);
     516//          while (out.valid() && !(Edge::free()>0) ) { ++out; }
    487517//        }
    488518//        if (!out.valid()) {
    489519//          out_or_in=0;
    490 //          G->getFirst(v);
    491 //          if (v.valid()) G->getFirst(in, v); else in=OldInEdgeIt();
    492 //          while (in.valid() && !(EdgeIt::free()>0) ) { ++in; }
     520//          G->/*getF*/first(v);
     521//          if (v.valid()) G->/*getF*/first(in, v); else in=OldInEdgeIt();
     522//          while (in.valid() && !(Edge::free()>0) ) { ++in; }
    493523//          while (v.valid() && !in.valid()) {
    494524//            ++v;
    495 //            if (v.valid()) G->getFirst(in, v);
    496 //            while (in.valid() && !(EdgeIt::free()>0) ) { ++in; }
     525//            if (v.valid()) G->/*getF*/first(in, v);
     526//            while (in.valid() && !(Edge::free()>0) ) { ++in; }
    497527//          } 
    498528//        }
    499529//      } else {
    500530//        ++in;
    501 //        while (in.valid() && !(EdgeIt::free()>0) ) { ++in; }
     531//        while (in.valid() && !(Edge::free()>0) ) { ++in; }
    502532//        while (v.valid() && !in.valid()) {
    503533//          ++v;
    504 //          if (v.valid()) G->getFirst(in, v);
    505 //          while (in.valid() && !(EdgeIt::free()>0) ) { ++in; }
     534//          if (v.valid()) G->/*getF*/first(in, v);
     535//          while (in.valid() && !(Edge::free()>0) ) { ++in; }
    506536//        }
    507537//      }
     
    510540    };
    511541
    512     EachNodeIt& getFirst(EachNodeIt& v) const { G->getFirst(v); }
    513     OutEdgeIt& getFirst(OutEdgeIt& e, NodeIt v) const {
     542    NodeIt& /*getF*/first(NodeIt& v) const { return graph->/*getF*/first(v); }
     543    OutEdgeIt& /*getF*/first(OutEdgeIt& e, Node v) const {
    514544      e=OutEdgeIt(*this, v);
    515     }
    516     EachEdgeIt& getFirst(EachEdgeIt& e) const {
    517       e=EachEdgeIt(*this);
     545      return e;
     546    }
     547    EdgeIt& /*getF*/first(EdgeIt& e) const {
     548      e=EdgeIt(*this);
     549      return e;
    518550    }
    519551   
    520     EachNodeIt& next(EachNodeIt& n) const { return G->next(n); }
     552    NodeIt& next(NodeIt& n) const { return graph->next(n); }
    521553
    522554    OutEdgeIt& next(OutEdgeIt& e) const {
    523555      if (e.out_or_in) {
    524         NodeIt v=G->aNode(e.out);
    525         ++(e.out);
    526         while( G->valid(e.out) && !(free(e.out)>0) ) { ++(e.out); }
    527         if (!G->valid(e.out)) {
     556        Node v=graph->aNode(e.out);
     557        graph->next(e.out);
     558        while( graph->valid(e.out) && !(free(e.out)>0) ) { graph->next(e.out); }
     559        if (!graph->valid(e.out)) {
    528560          e.out_or_in=0;
    529           G->getFirst(e.in, v);
    530           while( G->valid(e.in) && !(free(e.in)>0) ) { ++(e.in); }
     561          graph->/*getF*/first(e.in, v);
     562          while( graph->valid(e.in) && !(free(e.in)>0) ) { graph->next(e.in); }
    531563        }
    532564      } else {
    533         ++(e.in);
    534         while( G->valid(e.in) && !(free(e.in)>0) ) { ++(e.in); }
     565        graph->next(e.in);
     566        while( graph->valid(e.in) && !(free(e.in)>0) ) { graph->next(e.in); }
    535567      }
    536568      return e;
    537569    }
    538570
    539     EachEdgeIt& next(EachEdgeIt& e) const {
     571    EdgeIt& next(EdgeIt& e) const {
    540572      if (e.out_or_in) {
    541         ++(e.out);
    542         while (G->valid(e.out) && !(free(e.out)>0) ) { ++(e.out); }
    543           while (G->valid(e.v) && !G->valid(e.out)) {
    544             ++(e.v);
    545             if (G->valid(e.v)) G->getFirst(e.out, e.v);
    546             while (G->valid(e.out) && !(free(e.out)>0) ) { ++(e.out); }
     573        graph->next(e.out);
     574        while (graph->valid(e.out) && !(free(e.out)>0) ) { graph->next(e.out); }
     575          while (graph->valid(e.v) && !graph->valid(e.out)) {
     576            graph->next(e.v);
     577            if (graph->valid(e.v)) graph->/*getF*/first(e.out, e.v);
     578            while (graph->valid(e.out) && !(free(e.out)>0) ) { graph->next(e.out); }
    547579          }
    548           if (!G->valid(e.out)) {
     580          if (!graph->valid(e.out)) {
    549581            e.out_or_in=0;
    550             G->getFirst(e.v);
    551             if (G->valid(e.v)) G->getFirst(e.in, e.v); else e.in=OldInEdgeIt();
    552             while (G->valid(e.in) && !(free(e.in)>0) ) { ++(e.in); }
    553             while (G->valid(e.v) && !G->valid(e.in)) {
    554               ++(e.v);
    555               if (G->valid(e.v)) G->getFirst(e.in, e.v);
    556               while (G->valid(e.in) && !(free(e.in)>0) ) { ++(e.in); }
     582            graph->/*getF*/first(e.v);
     583            if (graph->valid(e.v)) graph->/*getF*/first(e.in, e.v); else e.in=OldInEdgeIt(INVALID);
     584            while (graph->valid(e.in) && !(free(e.in)>0) ) { graph->next(e.in); }
     585            while (graph->valid(e.v) && !graph->valid(e.in)) {
     586              graph->next(e.v);
     587              if (graph->valid(e.v)) graph->/*getF*/first(e.in, e.v);
     588              while (graph->valid(e.in) && !(free(e.in)>0) ) { graph->next(e.in); }
    557589            } 
    558590          }
    559591        } else {
    560           ++(e.in);
    561           while (G->valid(e.in) && !(free(e.in)>0) ) { ++(e.in); }
    562           while (G->valid(e.v) && !G->valid(e.in)) {
    563             ++(e.v);
    564             if (G->valid(e.v)) G->getFirst(e.in, e.v);
    565             while (G->valid(e.in) && !(free(e.in)>0) ) { ++(e.in); }
     592          graph->next(e.in);
     593          while (graph->valid(e.in) && !(free(e.in)>0) ) { graph->next(e.in); }
     594          while (graph->valid(e.v) && !graph->valid(e.in)) {
     595            graph->next(e.v);
     596            if (graph->valid(e.v)) graph->/*getF*/first(e.in, e.v);
     597            while (graph->valid(e.in) && !(free(e.in)>0) ) { graph->next(e.in); }
    566598          }
    567599        }
     
    573605    It first() const {
    574606      It e;
    575       getFirst(e);
     607      /*getF*/first(e);
    576608      return e;
    577609    }
    578610
    579611    template< typename It >
    580     It first(NodeIt v) const {
     612    It first(Node v) const {
    581613      It e;
    582       getFirst(e, v);
     614      /*getF*/first(e, v);
    583615      return e;
    584616    }
    585617
    586     NodeIt tail(EdgeIt e) const {
    587       return ((e.out_or_in) ? G->aNode(e.out) : G->aNode(e.in)); }
    588     NodeIt head(EdgeIt e) const {
    589       return ((e.out_or_in) ? G->bNode(e.out) : G->bNode(e.in)); }
    590 
    591     NodeIt aNode(OutEdgeIt e) const {
    592       return ((e.out_or_in) ? G->aNode(e.out) : G->aNode(e.in)); }
    593     NodeIt bNode(OutEdgeIt e) const {
    594       return ((e.out_or_in) ? G->bNode(e.out) : G->bNode(e.in)); }
    595 
    596     int id(NodeIt v) const { return G->id(v); }
    597 
    598     bool valid(NodeIt n) const { return G->valid(n); }
    599     bool valid(EdgeIt e) const {
    600       return e.out_or_in ? G->valid(e.out) : G->valid(e.in); }
    601 
    602     void augment(const EdgeIt& e, Number a) const {
     618    Node tail(Edge e) const {
     619      return ((e.out_or_in) ? graph->aNode(e.out) : graph->aNode(e.in)); }
     620    Node head(Edge e) const {
     621      return ((e.out_or_in) ? graph->bNode(e.out) : graph->bNode(e.in)); }
     622
     623    Node aNode(OutEdgeIt e) const {
     624      return ((e.out_or_in) ? graph->aNode(e.out) : graph->aNode(e.in)); }
     625    Node bNode(OutEdgeIt e) const {
     626      return ((e.out_or_in) ? graph->bNode(e.out) : graph->bNode(e.in)); }
     627
     628    int id(Node v) const { return graph->id(v); }
     629
     630    bool valid(Node n) const { return graph->valid(n); }
     631    bool valid(Edge e) const {
     632      return e.out_or_in ? graph->valid(e.out) : graph->valid(e.in); }
     633
     634    void augment(const Edge& e, Number a) const {
    603635      if (e.out_or_in) 
    604636        flow->set(e.out, flow->get(e.out)+a);
     
    607639    }
    608640
    609     Number free(const EdgeIt& e) const {
     641    Number free(const Edge& e) const {
    610642      if (e.out_or_in)
    611643        return (capacity->get(e.out)-flow->get(e.out));
     
    634666//       typename Graph::NodeMap<T> node_map;
    635667//     public:
    636 //       NodeMap(const ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>& _G) : node_map(*(_G.G)) { }
    637 //       NodeMap(const ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>& _G, T a) : node_map(*(_G.G), a) { }
    638 //       void set(NodeIt nit, T a) { node_map.set(nit, a); }
    639 //       T get(NodeIt nit) const { return node_map.get(nit); }
     668//       NodeMap(const ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>& _G) : node_map(*(_G.graph)) { }
     669//       NodeMap(const ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>& _G, T a) : node_map(*(_G.graph), a) { }
     670//       void set(Node nit, T a) { node_map.set(nit, a); }
     671//       T get(Node nit) const { return node_map.get(nit); }
    640672//     };
    641673
     
    646678      EdgeMap(const ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>& _G) : forward_map(_G.getGraph()), backward_map(_G.getGraph()) { }
    647679      EdgeMap(const ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>& _G, T a) : forward_map(_G.getGraph(), a), backward_map(_G.getGraph(), a) { }
    648       void set(EdgeIt e, T a) {
     680      void set(Edge e, T a) {
    649681        if (e.out_or_in)
    650682          forward_map.set(e.out, a);
     
    652684          backward_map.set(e.in, a);
    653685      }
    654       T get(EdgeIt e) {
     686      T get(Edge e) {
    655687        if (e.out_or_in)
    656688          return forward_map.get(e.out);
     
    671703      ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>(_G, _flow, _capacity),
    672704      first_out_edges(*this) /*, dist(*this)*/ {
    673       for(EachNodeIt n=this->template first<EachNodeIt>(); this->valid(n); this->next(n)) {
     705      for(NodeIt n=this->template first<NodeIt>(); this->valid(n); this->next(n)) {
    674706        OutEdgeIt e;
    675         ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::getFirst(e, n);
     707        ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::/*getF*/first(e, n);
    676708        first_out_edges.set(n, e);
    677709      }
     
    686718    //typedef Graph BaseGraph;
    687719
     720    //typedef typename Graph::Node Node;
    688721    //typedef typename Graph::NodeIt NodeIt;
    689     //typedef typename Graph::EachNodeIt EachNodeIt;
    690 
    691     //typedef typename Graph::EdgeIt EdgeIt;
     722
     723    //typedef typename Graph::Edge Edge;
    692724    //typedef typename Graph::OutEdgeIt OutEdgeIt;
    693725    //typedef typename Graph::InEdgeIt InEdgeIt;
    694726    //typedef typename Graph::SymEdgeIt SymEdgeIt;
    695     //typedef typename Graph::EachEdgeIt EachEdgeIt;
    696 
     727    //typedef typename Graph::EdgeIt EdgeIt;
     728
     729    typedef typename ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::Node Node;
    697730    typedef typename ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::NodeIt NodeIt;
    698     typedef typename ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::EachNodeIt EachNodeIt;
    699 
    700     typedef typename ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::EdgeIt EdgeIt;
     731
     732    typedef typename ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::Edge Edge;
    701733    typedef typename ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::OutEdgeIt OutEdgeIt;
    702734    //typedef typename ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::InEdgeIt InEdgeIt;
    703735    //typedef typename Graph::SymEdgeIt SymEdgeIt;
    704     //typedef typename ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::EachEdgeIt EachEdgeIt;
    705 
    706     EachNodeIt& getFirst(EachNodeIt& n) const {
    707       return ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::getFirst(n);
    708     }
    709 
    710     OutEdgeIt& getFirst(OutEdgeIt& e, const NodeIt& n) const {
     736    //typedef typename ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::EdgeIt EdgeIt;
     737
     738    NodeIt& /*getF*/first(NodeIt& n) const {
     739      return ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::/*getF*/first(n);
     740    }
     741
     742    OutEdgeIt& /*getF*/first(OutEdgeIt& e, const Node& n) const {
    711743      e=first_out_edges.get(n);
    712744      return e;
    713745    }
    714746   
    715     //ROSSZ template<typename I> I& getFirst(I& i) const { return getFirst(i); }
    716     //ROSSZ template<typename I, typename P> I& getFirst(I& i, const P& p) const {
    717     //  return getFirst(i, p); }
     747    //ROSSZ template<typename I> I& /*getF*/first(I& i) const { return /*getF*/first(i); }
     748    //ROSSZ template<typename I, typename P> I& /*getF*/first(I& i, const P& p) const {
     749    //  return /*getF*/first(i, p); }
    718750   
    719751    //template<typename I> I getNext(const I& i) const {
     
    722754
    723755    template< typename It > It first() const {
    724       It e; getFirst(e); return e; }
    725 
    726     template< typename It > It first(const NodeIt& v) const {
    727       It e; getFirst(e, v); return e; }
    728 
    729     //NodeIt head(const EdgeIt& e) const { return graph->head(e); }
    730     //NodeIt tail(const EdgeIt& e) const { return graph->tail(e); }
     756      It e; /*getF*/first(e); return e; }
     757
     758    template< typename It > It first(const Node& v) const {
     759      It e; /*getF*/first(e, v); return e; }
     760
     761    //Node head(const Edge& e) const { return graph->head(e); }
     762    //Node tail(const Edge& e) const { return graph->tail(e); }
    731763
    732764    //template<typename I> bool valid(const I& i) const
     
    736768    //int edgeNum() const { return graph->edgeNum(); }
    737769 
    738     //template<typename I> NodeIt aNode(const I& e) const {
     770    //template<typename I> Node aNode(const I& e) const {
    739771    //  return graph->aNode(e); }
    740     //template<typename I> NodeIt bNode(const I& e) const {
     772    //template<typename I> Node bNode(const I& e) const {
    741773    //  return graph->bNode(e); }
    742774 
    743     //NodeIt addNode() const { return graph->addNode(); }
    744     //EdgeIt addEdge(const NodeIt& tail, const NodeIt& head) const {
     775    //Node addNode() const { return graph->addNode(); }
     776    //Edge addEdge(const Node& tail, const Node& head) const {
    745777    //  return graph->addEdge(tail, head); }
    746778 
     
    748780    //  first_out_edge(this->tail(e))=e;
    749781    //}
    750     void erase(const EdgeIt& e) {
     782    void erase(const Edge& e) {
    751783      OutEdgeIt f(e);
    752784      next(f);
     
    786818    //typedef Graph BaseGraph;
    787819
     820    typedef typename ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::Node Node;
    788821    typedef typename ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::NodeIt NodeIt;
    789     typedef typename ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::EachNodeIt EachNodeIt;
    790 
    791     typedef typename ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::EdgeIt EdgeIt;
     822
     823    typedef typename ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::Edge Edge;
    792824    typedef typename ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::OutEdgeIt OutEdgeIt;
    793825    //typedef typename ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::InEdgeIt InEdgeIt;
    794826    //typedef typename Graph::SymEdgeIt SymEdgeIt;
    795     typedef typename ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::EachEdgeIt EachEdgeIt;
     827    typedef typename ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::EdgeIt EdgeIt;
    796828
    797829    //FilterGraphWrapper<Graph, Number, FlowMap, CapacityMap>::NodeMap<typename ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::OutEdgeIt> first_out_edges;
     
    803835    }
    804836
    805     OutEdgeIt& getFirst(OutEdgeIt& e, const NodeIt& n) const {
    806       ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::getFirst(e, n);
     837    OutEdgeIt& /*getF*/first(OutEdgeIt& e, const Node& n) const {
     838      ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::/*getF*/first(e, n);
    807839      while (valid(e) && (dist.get(tail(e))+1!=dist.get(head(e))))
    808840        ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::next(e);
     
    810842    }
    811843
    812     EachNodeIt& next(EachNodeIt& e) const {
     844    NodeIt& next(NodeIt& e) const {
    813845      return ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::next(e);
    814846    }
     
    821853    }
    822854
    823     EachNodeIt& getFirst(EachNodeIt& n) const {
    824       return ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::getFirst(n);
    825     }
    826 
    827     void erase(const EdgeIt& e) {
     855    NodeIt& /*getF*/first(NodeIt& n) const {
     856      return ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::/*getF*/first(n);
     857    }
     858
     859    void erase(const Edge& e) {
    828860      OutEdgeIt f(e);
    829861      ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::next(f);
     
    839871    //Graph& getGraph() const { return (*graph); }
    840872   
    841     //template<typename I> I& getFirst(I& i) const { return graph->getFirst(i); }
    842     //template<typename I, typename P> I& getFirst(I& i, const P& p) const {
    843     //  return graph->getFirst(i, p); }
     873    //template<typename I> I& /*getF*/first(I& i) const { return graph->/*getF*/first(i); }
     874    //template<typename I, typename P> I& /*getF*/first(I& i, const P& p) const {
     875    //  return graph->/*getF*/first(i, p); }
    844876   
    845877    //template<typename I> I getNext(const I& i) const {
     
    848880
    849881    template< typename It > It first() const {
    850       It e; getFirst(e); return e; }
    851 
    852     template< typename It > It first(const NodeIt& v) const {
    853       It e; getFirst(e, v); return e; }
    854 
    855     //NodeIt head(const EdgeIt& e) const { return graph->head(e); }
    856     //NodeIt tail(const EdgeIt& e) const { return graph->tail(e); }
     882      It e; /*getF*/first(e); return e; }
     883
     884    template< typename It > It first(const Node& v) const {
     885      It e; /*getF*/first(e, v); return e; }
     886
     887    //Node head(const Edge& e) const { return graph->head(e); }
     888    //Node tail(const Edge& e) const { return graph->tail(e); }
    857889
    858890    //template<typename I> bool valid(const I& i) const
     
    865897    //int edgeNum() const { return graph->edgeNum(); }
    866898 
    867     //template<typename I> NodeIt aNode(const I& e) const {
     899    //template<typename I> Node aNode(const I& e) const {
    868900    //  return graph->aNode(e); }
    869     //template<typename I> NodeIt bNode(const I& e) const {
     901    //template<typename I> Node bNode(const I& e) const {
    870902    //  return graph->bNode(e); }
    871903 
    872     //NodeIt addNode() const { return graph->addNode(); }
    873     //EdgeIt addEdge(const NodeIt& tail, const NodeIt& head) const {
     904    //Node addNode() const { return graph->addNode(); }
     905    //Edge addEdge(const Node& tail, const Node& head) const {
    874906    //  return graph->addEdge(tail, head); }
    875907 
     
    910942//     typedef Graph BaseGraph;
    911943
     944//     typedef typename Graph::Node Node;
     945//     typedef typename Graph::Edge Edge;
     946 
    912947//     typedef typename Graph::NodeIt NodeIt;
    913 //     typedef typename Graph::EdgeIt EdgeIt;
    914  
    915 //     typedef typename Graph::EachNodeIt EachNodeIt;
    916948   
    917949//     class OutEdgeIt {
    918950//     public:
    919 //       //Graph::NodeIt n;
     951//       //Graph::Node n;
    920952//       bool out_or_in;
    921953//       typename Graph::OutEdgeIt o;
     
    924956//     class InEdgeIt {
    925957//     public:
    926 //       //Graph::NodeIt n;
     958//       //Graph::Node n;
    927959//       bool out_or_in;
    928960//       typename Graph::OutEdgeIt o;
     
    930962//     };
    931963//     typedef typename Graph::SymEdgeIt SymEdgeIt;
    932 //     typedef typename Graph::EachEdgeIt EachEdgeIt;
     964//     typedef typename Graph::EdgeIt EdgeIt;
    933965
    934966//     int nodeNum() const { return graph->nodeNum(); }
    935967//     int edgeNum() const { return graph->edgeNum(); }
    936968
    937 //     NodeIt& getFirst(NodeIt& n) const { return graph->getFirst(n); }
    938 
    939 //     // EachEdge and SymEdge  is missing!!!!
    940 //     // EdgeIt <-> In/OutEdgeIt conversion is missing!!!!
     969//     Node& /*getF*/first(Node& n) const { return graph->/*getF*/first(n); }
     970
     971//     // Edge and SymEdge  is missing!!!!
     972//     // Edge <-> In/OutEdgeIt conversion is missing!!!!
    941973
    942974//     //FIXME
    943 //     OutEdgeIt& getFirst(OutEdgeIt& e, const NodeIt& n) const
     975//     OutEdgeIt& /*getF*/first(OutEdgeIt& e, const Node& n) const
    944976//       {
    945977//      e.n=n;
    946 //      graph->getFirst(e.o,n);
     978//      graph->/*getF*/first(e.o,n);
    947979//      while(graph->valid(e.o) && fmap.get(e.o)>=himap.get(e.o))
    948980//        graph->goNext(e.o);
    949981//      if(!graph->valid(e.o)) {
    950 //        graph->getFirst(e.i,n);
     982//        graph->/*getF*/first(e.i,n);
    951983//        while(graph->valid(e.i) && fmap.get(e.i)<=lomap.get(e.i))
    952984//          graph->goNext(e.i);
     
    961993//   graph->goNext(e.o);
    962994//   if(graph->valid(e.o)) return e;
    963 //   else graph->getFirst(e.i,e.n);
     995//   else graph->/*getF*/first(e.i,e.n);
    964996//   }
    965997//   else {
     
    9741006
    9751007//     //FIXME
    976 //     InEdgeIt& getFirst(InEdgeIt& e, const NodeIt& n) const
     1008//     InEdgeIt& /*getF*/first(InEdgeIt& e, const Node& n) const
    9771009//       {
    9781010//      e.n=n;
    979 //      graph->getFirst(e.i,n);
     1011//      graph->/*getF*/first(e.i,n);
    9801012//      while(graph->valid(e.i) && fmap.get(e.i)>=himap.get(e.i))
    9811013//        graph->goNext(e.i);
    9821014//      if(!graph->valid(e.i)) {
    983 //        graph->getFirst(e.o,n);
     1015//        graph->/*getF*/first(e.o,n);
    9841016//        while(graph->valid(e.o) && fmap.get(e.o)<=lomap.get(e.o))
    9851017//          graph->goNext(e.o);
     
    9941026//   graph->goNext(e.i);
    9951027//   if(graph->valid(e.i)) return e;
    996 //   else graph->getFirst(e.o,e.n);
     1028//   else graph->/*getF*/first(e.o,e.n);
    9971029//   }
    9981030//   else {
     
    10101042
    10111043//     template< typename It > It first() const {
    1012 //       It e; getFirst(e); return e; }
    1013 
    1014 //     template< typename It > It first(NodeIt v) const {
    1015 //       It e; getFirst(e, v); return e; }
    1016 
    1017 //     NodeIt head(const EdgeIt& e) const { return graph->head(e); }
    1018 //     NodeIt tail(const EdgeIt& e) const { return graph->tail(e); }
    1019  
    1020 //     template<typename I> NodeIt aNode(const I& e) const {
     1044//       It e; /*getF*/first(e); return e; }
     1045
     1046//     template< typename It > It first(Node v) const {
     1047//       It e; /*getF*/first(e, v); return e; }
     1048
     1049//     Node head(const Edge& e) const { return graph->head(e); }
     1050//     Node tail(const Edge& e) const { return graph->tail(e); }
     1051 
     1052//     template<typename I> Node aNode(const I& e) const {
    10211053//       return graph->aNode(e); }
    1022 //     template<typename I> NodeIt bNode(const I& e) const {
     1054//     template<typename I> Node bNode(const I& e) const {
    10231055//       return graph->bNode(e); }
    10241056 
     
    10291061//     //{ return graph->setInvalid(i); }
    10301062 
    1031 //     NodeIt addNode() { return graph->addNode(); }
    1032 //     EdgeIt addEdge(const NodeIt& tail, const NodeIt& head) {
     1063//     Node addNode() { return graph->addNode(); }
     1064//     Edge addEdge(const Node& tail, const Node& head) {
    10331065//       return graph->addEdge(tail, head); }
    10341066 
Note: See TracChangeset for help on using the changeset viewer.