Mercuriallemon-0.x / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
src/work/marci/experiment/graph_wrapper_1.h
changeset 473 2cef25dcde3f
parent 281 3fefabfd00b7
child 880 9d0bfd35b97c
equal deleted inserted replaced
0:6436ee1d79b5 1:8f1e4d81f682 
    11   protected:
 
    11   protected:
 
    12     Graph* graph;
 
    12     Graph* graph;
 
    13   
    13   
    14   public:
 
    14   public:
 
    15     typedef Graph BaseGraph;
 
    15     typedef Graph BaseGraph;
 
       
    16 
       
    17 //     TrivGraphWrapper() : graph(0) { }
 
       
    18     TrivGraphWrapper(Graph& _graph) : graph(&_graph) { }
 
       
    19 //     void setGraph(Graph& _graph) { graph = &_graph; }
 
       
    20 //     Graph& getGraph() const { return *graph; }
 
    16 
    21 
    17     typedef typename Graph::Node Node;
 
    22     typedef typename Graph::Node Node;
 
    18     class NodeIt : public Graph::NodeIt { 
    23     class NodeIt : public Graph::NodeIt { 
    19     public:
 
    24     public:
 
    20       NodeIt() { }
 
    25       NodeIt() { }
 
    22       NodeIt(const Invalid& i) : Graph::NodeIt(i) { }
 
    27       NodeIt(const Invalid& i) : Graph::NodeIt(i) { }
 
    23       NodeIt(const TrivGraphWrapper<Graph>& _G) : 
    28       NodeIt(const TrivGraphWrapper<Graph>& _G) : 
    24 	Graph::NodeIt(*(_G.graph)) { }
 
    29 	Graph::NodeIt(*(_G.graph)) { }
 
    25     };
 
    30     };
 
    26     typedef typename Graph::Edge Edge;
 
    31     typedef typename Graph::Edge Edge;
 
    27     //typedef typename Graph::OutEdgeIt OutEdgeIt;
 
       
    28     class OutEdgeIt : public Graph::OutEdgeIt { 
    32     class OutEdgeIt : public Graph::OutEdgeIt { 
    29     public:
 
    33     public:
 
    30       OutEdgeIt() { }
 
    34       OutEdgeIt() { }
 
    31       OutEdgeIt(const typename Graph::OutEdgeIt& e) : Graph::OutEdgeIt(e) { }
 
    35       OutEdgeIt(const typename Graph::OutEdgeIt& e) : Graph::OutEdgeIt(e) { }
 
    32       OutEdgeIt(const Invalid& i) : Graph::OutEdgeIt(i) { }
 
    36       OutEdgeIt(const Invalid& i) : Graph::OutEdgeIt(i) { }
 
    33       OutEdgeIt(const TrivGraphWrapper<Graph>& _G, const Node& n) : 
    37       OutEdgeIt(const TrivGraphWrapper<Graph>& _G, const Node& n) : 
    34 	Graph::OutEdgeIt(*(_G.graph), n) { }
 
    38 	Graph::OutEdgeIt(*(_G.graph), n) { }
 
    35     };
 
    39     };
 
    36     //typedef typename Graph::InEdgeIt InEdgeIt;
 
       
    37     class InEdgeIt : public Graph::InEdgeIt { 
    40     class InEdgeIt : public Graph::InEdgeIt { 
    38     public:
 
    41     public:
 
    39       InEdgeIt() { }
 
    42       InEdgeIt() { }
 
    40       InEdgeIt(const typename Graph::InEdgeIt& e) : Graph::InEdgeIt(e) { }
 
    43       InEdgeIt(const typename Graph::InEdgeIt& e) : Graph::InEdgeIt(e) { }
 
    41       InEdgeIt(const Invalid& i) : Graph::InEdgeIt(i) { }
 
    44       InEdgeIt(const Invalid& i) : Graph::InEdgeIt(i) { }
 
    42       InEdgeIt(const TrivGraphWrapper<Graph>& _G, const Node& n) : 
    45       InEdgeIt(const TrivGraphWrapper<Graph>& _G, const Node& n) : 
    43 	Graph::InEdgeIt(*(_G.graph), n) { }
 
    46 	Graph::InEdgeIt(*(_G.graph), n) { }
 
    44     };
 
    47     };
 
    45     //typedef typename Graph::SymEdgeIt SymEdgeIt;
 
    48     //typedef typename Graph::SymEdgeIt SymEdgeIt;
 
    46     //typedef typename Graph::EdgeIt EdgeIt;
 
       
    47     class EdgeIt : public Graph::EdgeIt { 
    49     class EdgeIt : public Graph::EdgeIt { 
    48     public:
 
    50     public:
 
    49       EdgeIt() { }
 
    51       EdgeIt() { }
 
    50       EdgeIt(const typename Graph::EdgeIt& e) : Graph::EdgeIt(e) { }
 
    52       EdgeIt(const typename Graph::EdgeIt& e) : Graph::EdgeIt(e) { }
 
    51       EdgeIt(const Invalid& i) : Graph::EdgeIt(i) { }
 
    53       EdgeIt(const Invalid& i) : Graph::EdgeIt(i) { }
 
    52       EdgeIt(const TrivGraphWrapper<Graph>& _G) : 
    54       EdgeIt(const TrivGraphWrapper<Graph>& _G) : 
    53 	Graph::EdgeIt(*(_G.graph)) { }
 
    55 	Graph::EdgeIt(*(_G.graph)) { }
 
    54     };
 
    56     };
 
    55 
    57 
    56     //TrivGraphWrapper() : graph(0) { }
 
       
    57     TrivGraphWrapper(Graph& _graph) : graph(&_graph) { }
 
       
    58 
       
    59 //    void setGraph(Graph& _graph) { graph = &_graph; }
 
       
    60 //    Graph& getGraph() const { return (*graph); }
 
       
    61 
       
    62     NodeIt& first(NodeIt& i) const { 
    58     NodeIt& first(NodeIt& i) const { 
    63       i=NodeIt(*this);
 
    59       i=NodeIt(*this);
 
    64       return i;
 
    60       return i;
 
    65     }
 
    61     }
 
    66     EdgeIt& first(EdgeIt& i) const { 
    62     EdgeIt& first(EdgeIt& i) const { 
    67       i=EdgeIt(*this);
 
    63       i=EdgeIt(*this);
 
    68       return i;
 
    64       return i;
 
    69     }
 
    65     }
 
    70 //     template<typename I> I& first(I& i) const { 
    66 //     template<typename I> I& first(I& i) const { 
    71 //       //return graph->first(i); 
       
    72 //       i=I(*this);
 
    67 //       i=I(*this);
 
    73 //       return i;
 
    68 //       return i;
 
    74 //     }
 
    69 //     }
 
    75     OutEdgeIt& first(OutEdgeIt& i, const Node& p) const { 
    70     OutEdgeIt& first(OutEdgeIt& i, const Node& p) const { 
    76       i=OutEdgeIt(*this, p);
 
    71       i=OutEdgeIt(*this, p);
 
    79     InEdgeIt& first(InEdgeIt& i, const Node& p) const { 
    74     InEdgeIt& first(InEdgeIt& i, const Node& p) const { 
    80       i=InEdgeIt(*this, p);
 
    75       i=InEdgeIt(*this, p);
 
    81       return i;
 
    76       return i;
 
    82     }
 
    77     }
 
    83 //     template<typename I, typename P> I& first(I& i, const P& p) const { 
    78 //     template<typename I, typename P> I& first(I& i, const P& p) const { 
    84 //       //return graph->first(i, p);
 
       
    85 //       i=I(*this, p);
 
    79 //       i=I(*this, p);
 
    86 //       return i;
 
    80 //       return i;
 
    87 //     }
 
    81 //     }
 
    88     
    82     
    89 //    template<typename I> I getNext(const I& i) const { 
    83 //    template<typename I> I getNext(const I& i) const { 
    90 //      return graph->getNext(i); }
 
    84 //      return graph->getNext(i); }
 
    91     template<typename I> I& next(I &i) const { graph->next(i); return i; }    
    85     template<typename I> I& next(I &i) const { graph->next(i); return i; }    
    92 
    86 
    93     template< typename It > It first() const { 
    87     template< typename It > It first() const { 
    94       It e; first(e); return e; }
 
    88       It e; this->first(e); return e; }
 
    95 
    89 
    96     template< typename It > It first(const Node& v) const { 
    90     template< typename It > It first(const Node& v) const { 
    97       It e; first(e, v); return e; }
 
    91       It e; this->first(e, v); return e; }
 
    98 
    92 
    99     Node head(const Edge& e) const { return graph->head(e); }
 
    93     Node head(const Edge& e) const { return graph->head(e); }
 
   100     Node tail(const Edge& e) const { return graph->tail(e); }
 
    94     Node tail(const Edge& e) const { return graph->tail(e); }
 
   101 
    95 
   102     template<typename I> bool valid(const I& i) const 
    96     template<typename I> bool valid(const I& i) const { 
   103       { return graph->valid(i); }
 
    97       return graph->valid(i); }
 
   104   
    98   
   105     //template<typename I> void setInvalid(const I &i);
 
    99     //template<typename I> void setInvalid(const I &i);
 
   106     //{ return graph->setInvalid(i); }
 
   100     //{ return graph->setInvalid(i); }
 
   107 
   101 
   108     int nodeNum() const { return graph->nodeNum(); }
 
   102     int nodeNum() const { return graph->nodeNum(); }
 
   140     template<typename Map, typename T> class NodeMapWrapper {
 
   134     template<typename Map, typename T> class NodeMapWrapper {
 
   141     protected:
 
   135     protected:
 
   142       Map* map;
 
   136       Map* map;
 
   143     public:
 
   137     public:
 
   144       NodeMapWrapper(Map& _map) : map(&_map) { }
 
   138       NodeMapWrapper(Map& _map) : map(&_map) { }
 
   145       //template<typename T> 
       
   146       void set(Node n, T a) { map->set(n, a); }
 
   139       void set(Node n, T a) { map->set(n, a); }
 
   147       //template<typename T>
 
       
   148       T get(Node n) const { return map->get(n); }
 
   140       T get(Node n) const { return map->get(n); }
 
   149     };
 
   141     };
 
   150 
   142 
   151     template<typename Map, typename T> class EdgeMapWrapper {
 
   143     template<typename Map, typename T> class EdgeMapWrapper {
 
   152     protected:
 
   144     protected:
 
   153       Map* map;
 
   145       Map* map;
 
   154     public:
 
   146     public:
 
   155       EdgeMapWrapper(Map& _map) : map(&_map) { }
 
   147       EdgeMapWrapper(Map& _map) : map(&_map) { }
 
   156       //template<typename T> 
       
   157       void set(Edge n, T a) { map->set(n, a); }
 
   148       void set(Edge n, T a) { map->set(n, a); }
 
   158       //template<typename T>
 
       
   159       T get(Edge n) const { return map->get(n); }
 
   149       T get(Edge n) const { return map->get(n); }
 
   160     };
 
   150     };
 
   161   };
 
   151   };
 
   162 
   152 
   163   template<typename GraphWrapper>
 
   153 
   164   class GraphWrapperSkeleton {
 
   154   template<typename Graph>
 
       
   155   class GraphWrapper {
 
   165   protected:
 
   156   protected:
 
   166     GraphWrapper gw;
 
   157     Graph* graph;
 
   167   
   158   
   168   public:
 
   159   public:
 
   169     //typedef typename GraphWrapper::BaseGraph BaseGraph;
 
   160     typedef Graph BaseGraph;
 
   170 
   161 
   171 //     typedef typename GraphWrapper::Node Node;
 
   162 //     GraphWrapper() : graph(0) { }
 
   172 //     typedef typename GraphWrapper::NodeIt NodeIt;
 
   163     GraphWrapper(Graph& _graph) : graph(&_graph) { }
 
   173 
   164 //     void setGraph(Graph& _graph) { graph=&_graph; }
 
   174 //     typedef typename GraphWrapper::Edge Edge;
 
   165 //     Graph& getGraph() const { return *graph; }
 
   175 //     typedef typename GraphWrapper::OutEdgeIt OutEdgeIt;
 
   166  
   176 //     typedef typename GraphWrapper::InEdgeIt InEdgeIt;
 
   167     typedef typename Graph::Node Node;
 
   177 //     //typedef typename GraphWrapper::SymEdgeIt SymEdgeIt;
 
   168     class NodeIt : public Graph::NodeIt { 
   178 //     typedef typename GraphWrapper::EdgeIt EdgeIt;
 
       
   179 
       
   180     typedef typename GraphWrapper::Node Node;
 
       
   181     class NodeIt : public GraphWrapper::NodeIt { 
       
   182     public:
 
   169     public:
 
   183       NodeIt() { }
 
   170       NodeIt() { }
 
   184       NodeIt(const typename GraphWrapper::NodeIt& n) : 
   171       NodeIt(const typename Graph::NodeIt& n) : Graph::NodeIt(n) { }
 
   185 	GraphWrapper::NodeIt(n) { }
 
   172       NodeIt(const Invalid& i) : Graph::NodeIt(i) { }
 
   186       NodeIt(const Invalid& i) : GraphWrapper::NodeIt(i) { }
 
   173       NodeIt(const GraphWrapper<Graph>& _G) : 
   187       NodeIt(const GraphWrapperSkeleton<GraphWrapper>& _G) : 
   174 	Graph::NodeIt(*(_G.graph)) { }
 
   188 	GraphWrapper::NodeIt(_G.gw) { }
 
   175     };
 
   189     };
 
   176     typedef typename Graph::Edge Edge;
 
   190     typedef typename GraphWrapper::Edge Edge;
 
   177     class OutEdgeIt : public Graph::OutEdgeIt { 
   191     //typedef typename GraphWrapper::OutEdgeIt OutEdgeIt;
 
       
   192     class OutEdgeIt : public GraphWrapper::OutEdgeIt { 
       
   193     public:
 
   178     public:
 
   194       OutEdgeIt() { }
 
   179       OutEdgeIt() { }
 
   195       OutEdgeIt(const typename GraphWrapper::OutEdgeIt& e) : 
   180       OutEdgeIt(const typename Graph::OutEdgeIt& e) : Graph::OutEdgeIt(e) { }
 
   196 	GraphWrapper::OutEdgeIt(e) { }
 
   181       OutEdgeIt(const Invalid& i) : Graph::OutEdgeIt(i) { }
 
   197       OutEdgeIt(const Invalid& i) : GraphWrapper::OutEdgeIt(i) { }
 
   182       OutEdgeIt(const GraphWrapper<Graph>& _G, const Node& n) : 
   198       OutEdgeIt(const GraphWrapperSkeleton<GraphWrapper>& _G, const Node& n) : 
   183 	Graph::OutEdgeIt(*(_G.graph), n) { }
 
   199 	GraphWrapper::OutEdgeIt(_G.gw, n) { }
 
   184     };
 
   200     };
 
   185     class InEdgeIt : public Graph::InEdgeIt { 
   201     //typedef typename GraphWrapper::InEdgeIt InEdgeIt;
 
       
   202     class InEdgeIt : public GraphWrapper::InEdgeIt { 
       
   203     public:
 
   186     public:
 
   204       InEdgeIt() { }
 
   187       InEdgeIt() { }
 
   205       InEdgeIt(const typename GraphWrapper::InEdgeIt& e) : 
   188       InEdgeIt(const typename Graph::InEdgeIt& e) : Graph::InEdgeIt(e) { }
 
   206 	GraphWrapper::InEdgeIt(e) { }
 
   189       InEdgeIt(const Invalid& i) : Graph::InEdgeIt(i) { }
 
   207       InEdgeIt(const Invalid& i) : GraphWrapper::InEdgeIt(i) { }
 
   190       InEdgeIt(const GraphWrapper<Graph>& _G, const Node& n) : 
   208       InEdgeIt(const GraphWrapperSkeleton<GraphWrapper>& _G, const Node& n) : 
   191 	Graph::InEdgeIt(*(_G.graph), n) { }
 
   209 	GraphWrapper::InEdgeIt(_G.gw, n) { }
 
   192     };
 
   210     };
 
   193     //typedef typename Graph::SymEdgeIt SymEdgeIt;
 
   211     //typedef typename GraphWrapper::SymEdgeIt SymEdgeIt;
 
   194     class EdgeIt : public Graph::EdgeIt { 
   212     //typedef typename GraphWrapper::EdgeIt EdgeIt;
 
       
   213     class EdgeIt : public GraphWrapper::EdgeIt { 
       
   214     public:
 
   195     public:
 
   215       EdgeIt() { }
 
   196       EdgeIt() { }
 
   216       EdgeIt(const typename GraphWrapper::EdgeIt& e) : 
   197       EdgeIt(const typename Graph::EdgeIt& e) : Graph::EdgeIt(e) { }
 
   217 	GraphWrapper::EdgeIt(e) { }
 
   198       EdgeIt(const Invalid& i) : Graph::EdgeIt(i) { }
 
   218       EdgeIt(const Invalid& i) : GraphWrapper::EdgeIt(i) { }
 
   199       EdgeIt(const GraphWrapper<Graph>& _G) : 
   219       EdgeIt(const GraphWrapperSkeleton<GraphWrapper>& _G) : 
   200 	Graph::EdgeIt(*(_G.graph)) { }
 
   220 	GraphWrapper::EdgeIt(_G.gw) { }
 
   201     };
 
   221     };
 
   202    
   222 
   203     NodeIt& first(NodeIt& i) const { 
   223 
   204       i=NodeIt(*this);
 
   224     //GraphWrapperSkeleton() : gw() { }
 
       
   225     GraphWrapperSkeleton(GraphWrapper _gw) : gw(_gw) { }
 
       
   226 
       
   227     //void setGraph(BaseGraph& _graph) { gw.setGraph(_graph); }
 
       
   228     //BaseGraph& getGraph() const { return gw.getGraph(); }
 
       
   229     
       
   230     template<typename I> I& first(I& i) const {       
       
   231       i=I(*this);
 
       
   232       return i;
 
   205       return i;
 
   233     }
 
   206     }
 
   234     template<typename I, typename P> I& first(I& i, const P& p) const { 
   207     EdgeIt& first(EdgeIt& i) const { 
   235       i=I(*this, p);
 
   208       i=EdgeIt(*this);
 
   236       return i; 
   209       return i;
 
   237     }
 
   210     }
 
   238     
   211 //     template<typename I> I& first(I& i) const {       
   239 //    template<typename I> I getNext(const I& i) const { return gw.getNext(i); }
 
   212 //       i=I(*this);
 
   240     template<typename I> I& next(I &i) const { gw.next(i); return i; }    
   213 //       return i;
 
       
   214 //     }
 
       
   215     OutEdgeIt& first(OutEdgeIt& i, const Node& p) const { 
       
   216       i=OutEdgeIt(*this, p);
 
       
   217       return i;
 
       
   218     }
 
       
   219     InEdgeIt& first(InEdgeIt& i, const Node& p) const { 
       
   220       i=InEdgeIt(*this, p);
 
       
   221       return i;
 
       
   222     }
 
       
   223 //     template<typename I, typename P> I& first(I& i, const P& p) const { 
       
   224 //       i=I(*this, p);
 
       
   225 //       return i; 
       
   226 //     }
 
       
   227     
       
   228 //    template<typename I> I getNext(const I& i) const { 
       
   229 //      return gw.getNext(i); }
 
       
   230     template<typename I> I& next(I &i) const { graph->next(i); return i; }    
   241 
   231 
   242     template< typename It > It first() const { 
   232     template< typename It > It first() const { 
   243       It e; this->first(e); return e; }
 
   233       It e; this->first(e); return e; }
 
   244 
   234 
   245     template< typename It > It first(const Node& v) const { 
   235     template< typename It > It first(const Node& v) const { 
   246       It e; this->first(e, v); return e; }
 
   236       It e; this->first(e, v); return e; }
 
   247 
   237 
   248     Node head(const Edge& e) const { return gw.head(e); }
 
   238     Node head(const Edge& e) const { return graph->head(e); }
 
   249     Node tail(const Edge& e) const { return gw.tail(e); }
 
   239     Node tail(const Edge& e) const { return graph->tail(e); }
 
   250 
   240 
   251     template<typename I> bool valid(const I& i) const { return gw.valid(i); }
 
   241     template<typename I> bool valid(const I& i) const { 
       
   242       return graph->valid(i); }
 
   252   
   243   
   253     //template<typename I> void setInvalid(const I &i);
 
   244     //template<typename I> void setInvalid(const I &i);
 
   254     //{ return graph->setInvalid(i); }
 
   245     //{ return graph->setInvalid(i); }
 
   255 
   246 
   256     int nodeNum() const { return gw.nodeNum(); }
 
   247     int nodeNum() const { return graph->nodeNum(); }
 
   257     int edgeNum() const { return gw.edgeNum(); }
 
   248     int edgeNum() const { return graph->edgeNum(); }
 
   258   
   249   
   259     template<typename I> Node aNode(const I& e) const { return gw.aNode(e); }
 
   250     template<typename I> Node aNode(const I& e) const { 
   260     template<typename I> Node bNode(const I& e) const { return gw.bNode(e); }
 
   251       return graph->aNode(e); }
 
   261   
   252     template<typename I> Node bNode(const I& e) const { 
   262     Node addNode() const { return gw.addNode(); }
 
   253       return graph->bNode(e); }
 
       
   254   
       
   255     Node addNode() const { return graph->addNode(); }
 
   263     Edge addEdge(const Node& tail, const Node& head) const { 
   256     Edge addEdge(const Node& tail, const Node& head) const { 
   264       return gw.addEdge(tail, head); }
 
   257       return graph->addEdge(tail, head); }
 
   265   
   258   
   266     template<typename I> void erase(const I& i) const { gw.erase(i); }
 
   259     template<typename I> void erase(const I& i) const { graph->erase(i); }
 
   267   
   260   
   268     void clear() const { gw.clear(); }
 
   261     void clear() const { graph->clear(); }
 
   269     
   262     
   270     template<typename T> class NodeMap : public GraphWrapper::NodeMap<T> { 
   263     template<typename T> class NodeMap : public Graph::NodeMap<T> { 
   271     public:
 
   264     public:
 
   272       NodeMap(const GraphWrapperSkeleton<GraphWrapper>& _G) :  
   265       NodeMap(const GraphWrapper<Graph>& _G) :  
   273 	GraphWrapper::NodeMap<T>(_G.gw) { }
 
   266 	Graph::NodeMap<T>(*(_G.graph)) { }
 
   274       NodeMap(const GraphWrapperSkeleton<GraphWrapper>& _G, T a) : 
   267       NodeMap(const GraphWrapper<Graph>& _G, T a) : 
   275 	GraphWrapper::NodeMap<T>(_G.gw, a) { }
 
   268 	Graph::NodeMap<T>(*(_G.graph), a) { }
 
   276     };
 
   269     };
 
   277 
   270 
   278     template<typename T> class EdgeMap : public GraphWrapper::EdgeMap<T> { 
   271     template<typename T> class EdgeMap : public Graph::EdgeMap<T> { 
   279     public:
 
   272     public:
 
   280       EdgeMap(const GraphWrapperSkeleton<GraphWrapper>& _G) :  
   273       EdgeMap(const GraphWrapper<Graph>& _G) :  
   281 	GraphWrapper::EdgeMap<T>(_G.gw) { }
 
   274 	Graph::EdgeMap<T>(*(_G.graph)) { }
 
   282       EdgeMap(const GraphWrapperSkeleton<GraphWrapper>& _G, T a) : 
   275       EdgeMap(const GraphWrapper<Graph>& _G, T a) : 
   283 	GraphWrapper::EdgeMap<T>(_G.gw, a) { }
 
   276 	Graph::EdgeMap<T>(*(_G.graph), a) { }
 
   284     };
 
       
   285   };
 
       
   286 
       
   287   template<typename GraphWrapper>
 
       
   288   class GraphWrapperSkeleton1 {
 
       
   289   protected:
 
       
   290     GraphWrapper* g;
 
       
   291   
       
   292   public:
 
       
   293     //typedef typename GraphWrapper::BaseGraph BaseGraph;
 
       
   294 
       
   295 //     typedef typename GraphWrapper::Node Node;
 
       
   296 //     typedef typename GraphWrapper::NodeIt NodeIt;
 
       
   297 
       
   298 //     typedef typename GraphWrapper::Edge Edge;
 
       
   299 //     typedef typename GraphWrapper::OutEdgeIt OutEdgeIt;
 
       
   300 //     typedef typename GraphWrapper::InEdgeIt InEdgeIt;
 
       
   301 //     //typedef typename GraphWrapper::SymEdgeIt SymEdgeIt;
 
       
   302 //     typedef typename GraphWrapper::EdgeIt EdgeIt;
 
       
   303 
       
   304     typedef typename GraphWrapper::Node Node;
 
       
   305     class NodeIt : public GraphWrapper::NodeIt { 
       
   306     public:
 
       
   307       NodeIt() { }
 
       
   308       NodeIt(const typename GraphWrapper::NodeIt& n) : 
       
   309 	GraphWrapper::NodeIt(n) { }
 
       
   310       NodeIt(const Invalid& i) : GraphWrapper::NodeIt(i) { }
 
       
   311       NodeIt(const GraphWrapperSkeleton1<GraphWrapper>& _G) : 
       
   312 	GraphWrapper::NodeIt(*(_G.g)) { }
 
       
   313     };
 
       
   314     typedef typename GraphWrapper::Edge Edge;
 
       
   315     //typedef typename GraphWrapper::OutEdgeIt OutEdgeIt;
 
       
   316     class OutEdgeIt : public GraphWrapper::OutEdgeIt { 
       
   317     public:
 
       
   318       OutEdgeIt() { }
 
       
   319       OutEdgeIt(const typename GraphWrapper::OutEdgeIt& e) : 
       
   320 	GraphWrapper::OutEdgeIt(e) { }
 
       
   321       OutEdgeIt(const Invalid& i) : GraphWrapper::OutEdgeIt(i) { }
 
       
   322       OutEdgeIt(const GraphWrapperSkeleton1<GraphWrapper>& _G, const Node& n) : 
       
   323 	GraphWrapper::OutEdgeIt(*(_G.g), n) { }
 
       
   324     };
 
       
   325     //typedef typename GraphWrapper::InEdgeIt InEdgeIt;
 
       
   326     class InEdgeIt : public GraphWrapper::InEdgeIt { 
       
   327     public:
 
       
   328       InEdgeIt() { }
 
       
   329       InEdgeIt(const typename GraphWrapper::InEdgeIt& e) : 
       
   330 	GraphWrapper::InEdgeIt(e) { }
 
       
   331       InEdgeIt(const Invalid& i) : GraphWrapper::InEdgeIt(i) { }
 
       
   332       InEdgeIt(const GraphWrapperSkeleton1<GraphWrapper>& _G, const Node& n) : 
       
   333 	GraphWrapper::InEdgeIt(*(_G.g), n) { }
 
       
   334     };
 
       
   335     //typedef typename GraphWrapper::SymEdgeIt SymEdgeIt;
 
       
   336     //typedef typename GraphWrapper::EdgeIt EdgeIt;
 
       
   337     class EdgeIt : public GraphWrapper::EdgeIt { 
       
   338     public:
 
       
   339       EdgeIt() { }
 
       
   340       EdgeIt(const typename GraphWrapper::EdgeIt& e) : 
       
   341 	GraphWrapper::EdgeIt(e) { }
 
       
   342       EdgeIt(const Invalid& i) : GraphWrapper::EdgeIt(i) { }
 
       
   343       EdgeIt(const GraphWrapperSkeleton1<GraphWrapper>& _G) : 
       
   344 	GraphWrapper::EdgeIt(*(_G.g)) { }
 
       
   345     };
 
       
   346 
       
   347 
       
   348     //GraphWrapperSkeleton() : gw() { }
 
       
   349     GraphWrapperSkeleton1(GraphWrapper& _gw) : g(&_gw) { }
 
       
   350 
       
   351     //void setGraph(BaseGraph& _graph) { gw.setGraph(_graph); }
 
       
   352     //BaseGraph& getGraph() const { return gw.getGraph(); }
 
       
   353     
       
   354     template<typename I> I& first(I& i) const {       
       
   355       i=I(*this);
 
       
   356       return i;
 
       
   357     }
 
       
   358     template<typename I, typename P> I& first(I& i, const P& p) const { 
       
   359       i=I(*this, p);
 
       
   360       return i; 
       
   361     }
 
       
   362     
       
   363 //    template<typename I> I getNext(const I& i) const { return gw.getNext(i); }
 
       
   364     template<typename I> I& next(I &i) const { g->next(i); return i; }    
       
   365 
       
   366     template< typename It > It first() const { 
       
   367       It e; this->first(e); return e; }
 
       
   368 
       
   369     template< typename It > It first(const Node& v) const { 
       
   370       It e; this->first(e, v); return e; }
 
       
   371 
       
   372     Node head(const Edge& e) const { return g->head(e); }
 
       
   373     Node tail(const Edge& e) const { return g->tail(e); }
 
       
   374 
       
   375     template<typename I> bool valid(const I& i) const { return g->valid(i); }
 
       
   376   
       
   377     //template<typename I> void setInvalid(const I &i);
 
       
   378     //{ return graph->setInvalid(i); }
 
       
   379 
       
   380     int nodeNum() const { return g->nodeNum(); }
 
       
   381     int edgeNum() const { return g->edgeNum(); }
 
       
   382   
       
   383     template<typename I> Node aNode(const I& e) const { return g->aNode(e); }
 
       
   384     template<typename I> Node bNode(const I& e) const { return g->bNode(e); }
 
       
   385   
       
   386     Node addNode() const { return g->addNode(); }
 
       
   387     Edge addEdge(const Node& tail, const Node& head) const { 
       
   388       return g->addEdge(tail, head); }
 
       
   389   
       
   390     template<typename I> void erase(const I& i) const { g->erase(i); }
 
       
   391   
       
   392     void clear() const { g->clear(); }
 
       
   393     
       
   394     template<typename T> class NodeMap : public GraphWrapper::NodeMap<T> { 
       
   395     public:
 
       
   396       NodeMap(const GraphWrapperSkeleton1<GraphWrapper>& _G) :  
       
   397 	GraphWrapper::NodeMap<T>(*(_G.g)) { }
 
       
   398       NodeMap(const GraphWrapperSkeleton1<GraphWrapper>& _G, T a) : 
       
   399 	GraphWrapper::NodeMap<T>(*(_G.g), a) { }
 
       
   400     };
 
       
   401 
       
   402     template<typename T> class EdgeMap : public GraphWrapper::EdgeMap<T> { 
       
   403     public:
 
       
   404       EdgeMap(const GraphWrapperSkeleton1<GraphWrapper>& _G) :  
       
   405 	GraphWrapper::EdgeMap<T>(*(_G.g)) { }
 
       
   406       EdgeMap(const GraphWrapperSkeleton1<GraphWrapper>& _G, T a) : 
       
   407 	GraphWrapper::EdgeMap<T>(*(_G.g), a) { }
 
       
   408     };
 
   277     };
 
   409   };
 
   278   };
 
   410 
   279 
   411 
   280 
   412 //   template<typename Graph>
 
   281 //   template<typename Graph>
 
   487 //       EdgeMap(const RevGraphWrapper<Graph>& _G, T a) : 
   356 //       EdgeMap(const RevGraphWrapper<Graph>& _G, T a) : 
   488 // 	Graph::EdgeMap<T>(_G.getGraph(), a) { }
 
   357 // 	Graph::EdgeMap<T>(_G.getGraph(), a) { }
 
   489 //     };
 
   358 //     };
 
   490 //   };
 
   359 //   };
 
   491 
   360 
   492 //   template<typename /*Graph*/GraphWrapper
 
   361 
   493 //   /*=typename GraphWrapperSkeleton< TrivGraphWrapper<Graph>*/ >
 
   362   template<typename Graph>
 
   494 //   class RevGraphWrapper : 
   363   class RevGraphWrapper : public GraphWrapper<Graph> {
 
   495 //     public GraphWrapper/*GraphWrapperSkeleton< TrivGraphWrapper<Graph> >*/ {
 
       
   496 //   protected:
 
       
   497 //     //Graph* graph;
 
       
   498     
       
   499 //   public:
 
       
   500 //     //typedef Graph BaseGraph;
 
       
   501 
       
   502 //     //typedef typename Graph::Node Node;    
       
   503 //     //typedef typename Graph::NodeIt NodeIt;
 
       
   504   
       
   505 //     //typedef typename Graph::Edge Edge;
 
       
   506 //     typedef typename GraphWrapper/*typename GraphWrapperSkeleton< TrivGraphWrapper<Graph> >*/::OutEdgeIt InEdgeIt;
 
       
   507 //     typedef typename GraphWrapper/*typename GraphWrapperSkeleton< TrivGraphWrapper<Graph> >*/::InEdgeIt OutEdgeIt;
 
       
   508 //     //typedef typename Graph::SymEdgeIt SymEdgeIt;
 
       
   509 //     //typedef typename Graph::EdgeIt EdgeIt;
 
       
   510 
       
   511 //     //RevGraphWrapper() : graph(0) { }
 
       
   512 //     RevGraphWrapper(GraphWrapper _gw/*BaseGraph& _graph*/) : GraphWrapper/*GraphWrapperSkeleton< TrivGraphWrapper<Graph> >*/(_gw/*TrivGraphWrapper<Graph>(_graph)*/) { }
 
       
   513     
       
   514 //     //void setGraph(Graph& _graph) { graph = &_graph; }
 
       
   515 //     //Graph& getGraph() const { return (*graph); }
 
       
   516     
       
   517 //     //template<typename I> I& first(I& i) const { return graph->first(i); }
 
       
   518 //     //template<typename I, typename P> I& first(I& i, const P& p) const { 
       
   519 //     //  return graph->first(i, p); }
 
       
   520 
       
   521 //     //template<typename I> I getNext(const I& i) const { 
       
   522 //     //  return graph->getNext(i); }
 
       
   523 //     //template<typename I> I& next(I &i) const { return graph->next(i); }    
       
   524 
       
   525 //     //template< typename It > It first() const { 
       
   526 //     //  It e; first(e); return e; }
 
       
   527 
       
   528 //     //template< typename It > It first(const Node& v) const { 
       
   529 //     //  It e; first(e, v); return e; }
 
       
   530 
       
   531 //     //Node head(const Edge& e) const { return graph->tail(e); }
 
       
   532 //     //Node tail(const Edge& e) const { return graph->head(e); }
 
       
   533   
       
   534 //     //template<typename I> bool valid(const I& i) const 
       
   535 //     //  { return graph->valid(i); }
 
       
   536   
       
   537 //     //template<typename I> void setInvalid(const I &i);
 
       
   538 //     //{ return graph->setInvalid(i); }
 
       
   539   
       
   540 //     //template<typename I> Node aNode(const I& e) const { 
       
   541 //     //  return graph->aNode(e); }
 
       
   542 //     //template<typename I> Node bNode(const I& e) const { 
       
   543 //     //  return graph->bNode(e); }
 
       
   544 
       
   545 //     //Node addNode() const { return graph->addNode(); }
 
       
   546 //     //Edge addEdge(const Node& tail, const Node& head) const { 
       
   547 //     //  return graph->addEdge(tail, head); }
 
       
   548   
       
   549 //     //int nodeNum() const { return graph->nodeNum(); }
 
       
   550 //     //int edgeNum() const { return graph->edgeNum(); }
 
       
   551   
       
   552 //     //template<typename I> void erase(const I& i) const { graph->erase(i); }
 
       
   553   
       
   554 //     //void clear() const { graph->clear(); }
 
       
   555 
       
   556 //     template<typename T> class NodeMap : 
       
   557 //       public GraphWrapper/*Skeleton< TrivGraphWrapper<Graph> >*/::NodeMap<T> 
       
   558 //     { 
       
   559 //     public:
 
       
   560 //       NodeMap(const RevGraphWrapper<GraphWrapper>& _gw) : 
       
   561 // 	GraphWrapper/*Skeleton< TrivGraphWrapper<Graph> >*/::NodeMap<T>(_gw) { }
 
       
   562 //       NodeMap(const RevGraphWrapper<GraphWrapper>& _gw, T a) : 
       
   563 // 	GraphWrapper/*Skeleton< TrivGraphWrapper<Graph> >*/::NodeMap<T>(_gw, a) { }
 
       
   564 //     };
 
       
   565     
       
   566 //     template<typename T> class EdgeMap : 
       
   567 //       public GraphWrapper/*Skeleton< TrivGraphWrapper<Graph> >*/::EdgeMap<T> { 
       
   568 //     public:
 
       
   569 //       EdgeMap(const RevGraphWrapper<GraphWrapper>& _gw) : 
       
   570 // 	GraphWrapper/*Skeleton< TrivGraphWrapper<Graph> >*/::EdgeMap<T>(_gw) { }
 
       
   571 //       EdgeMap(const RevGraphWrapper<GraphWrapper>& _gw, T a) : 
       
   572 // 	GraphWrapper/*Skeleton< TrivGraphWrapper<Graph> >*/::EdgeMap<T>(_gw, a) { }
 
       
   573 //     };
 
       
   574 //   };
 
       
   575 
       
   576   template<typename GraphWrapper>
 
       
   577   class RevGraphWrapper : public GraphWrapperSkeleton1<GraphWrapper> {
 
       
   578   public:
 
   364   public:
 
   579     typedef typename GraphWrapperSkeleton1<GraphWrapper>::Node Node;
 
   365     typedef typename GraphWrapper<Graph>::Node Node;
 
   580     typedef typename GraphWrapperSkeleton1<GraphWrapper>::Edge Edge;
 
   366     typedef typename GraphWrapper<Graph>::Edge Edge;
 
   581     //FIXME 
   367     //FIXME 
   582     //If GraphWrapper::OutEdgeIt is not defined
 
   368     //If Graph::OutEdgeIt is not defined
 
   583     //and we do not want to use RevGraphWrapper::InEdgeIt,
 
   369     //and we do not want to use RevGraphWrapper::InEdgeIt,
 
   584     //this won't work, because of typedef
 
   370     //this won't work, because of typedef
 
   585     //OR
 
   371     //OR
 
   586     //graphs have to define their non-existing iterators to void
 
   372     //graphs have to define their non-existing iterators to void
 
   587     //Unfortunately all the typedefs are instantiated in templates, 
   373     //Unfortunately all the typedefs are instantiated in templates, 
   588     //unlike other stuff
 
   374     //unlike other stuff
 
   589     typedef typename GraphWrapperSkeleton1<GraphWrapper>::OutEdgeIt InEdgeIt;
 
   375     typedef typename GraphWrapper<Graph>::OutEdgeIt InEdgeIt;
 
   590     typedef typename GraphWrapperSkeleton1<GraphWrapper>::InEdgeIt OutEdgeIt;
 
   376     typedef typename GraphWrapper<Graph>::InEdgeIt OutEdgeIt;
 
   591 
   377 
   592     RevGraphWrapper(GraphWrapper& _gw) : 
   378 //     RevGraphWrapper() : GraphWrapper<Graph>() { }
 
   593       GraphWrapperSkeleton1<GraphWrapper>(_gw) { }  
   379     RevGraphWrapper(Graph& _graph) : GraphWrapper<Graph>(_graph) { }  
   594 
   380 
   595     Node head(const Edge& e) const 
   381     Node head(const Edge& e) const 
   596       { return GraphWrapperSkeleton1<GraphWrapper>::tail(e); }
 
   382       { return GraphWrapper<Graph>::tail(e); }
 
   597     Node tail(const Edge& e) const 
   383     Node tail(const Edge& e) const 
   598       { return GraphWrapperSkeleton1<GraphWrapper>::head(e); }
 
   384       { return GraphWrapper<Graph>::head(e); }
 
   599   };
 
   385   };
 
   600 
   386 
   601   //Subgraph on the same node-set and partial edge-set
 
   387   //Subgraph on the same node-set and partial edge-set
 
   602   template<typename GraphWrapper, typename EdgeFilterMap>
 
   388   template<typename Graph, typename EdgeFilterMap>
 
   603   class SubGraphWrapper : public GraphWrapperSkeleton1<GraphWrapper> {
 
   389   class SubGraphWrapper : public GraphWrapper<Graph> {
 
   604   protected:
 
   390   protected:
 
   605     EdgeFilterMap* filter_map;
 
   391     EdgeFilterMap* filter_map;
 
   606   public:
 
   392   public:
 
   607     typedef typename GraphWrapperSkeleton1<GraphWrapper>::Node Node;
 
   393     typedef typename GraphWrapper<Graph>::Node Node;
 
   608     typedef typename GraphWrapperSkeleton1<GraphWrapper>::NodeIt NodeIt;
 
   394     typedef typename GraphWrapper<Graph>::NodeIt NodeIt;
 
   609     typedef typename GraphWrapperSkeleton1<GraphWrapper>::Edge Edge;
 
   395     typedef typename GraphWrapper<Graph>::Edge Edge;
 
   610     typedef typename GraphWrapperSkeleton1<GraphWrapper>::EdgeIt EdgeIt;
 
   396     typedef typename GraphWrapper<Graph>::EdgeIt EdgeIt;
 
   611     typedef typename GraphWrapperSkeleton1<GraphWrapper>::InEdgeIt InEdgeIt;
 
   397     typedef typename GraphWrapper<Graph>::InEdgeIt InEdgeIt;
 
   612     typedef typename GraphWrapperSkeleton1<GraphWrapper>::OutEdgeIt OutEdgeIt;
 
   398     typedef typename GraphWrapper<Graph>::OutEdgeIt OutEdgeIt;
 
   613 
   399 
   614     SubGraphWrapper(GraphWrapper& _gw, EdgeFilterMap& _filter_map) : 
   400 //     SubGraphWrapper() : GraphWrapper<Graph>(), filter_map(0) { }
 
   615       GraphWrapperSkeleton1<GraphWrapper>(_gw), filter_map(&_filter_map) { }  
   401     SubGraphWrapper(Graph& _graph, EdgeFilterMap& _filter_map) : 
       
   402       GraphWrapper<Graph>(_graph), filter_map(&_filter_map) { }  
   616 
   403 
   617     template<typename I> I& first(I& i) const { 
   404     template<typename I> I& first(I& i) const { 
   618       g->first(i); 
   405       graph->first(i); 
   619       while (g->valid(i) && !filter_map->get(i)) { g->next(i); }
 
   406       while (graph->valid(i) && !filter_map->get(i)) { graph->next(i); }
 
   620       return i;
 
   407       return i;
 
   621     }
 
   408     }
 
   622     template<typename I, typename P> I& first(I& i, const P& p) const { 
   409     template<typename I, typename P> I& first(I& i, const P& p) const { 
   623       g->first(i, p); 
   410       graph->first(i, p); 
   624       while (g->valid(i) && !filter_map->get(i)) { g->next(i); }
 
   411       while (graph->valid(i) && !filter_map->get(i)) { graph->next(i); }
 
   625       return i;
 
   412       return i;
 
   626     }
 
   413     }
 
   627     
   414     
   628     //template<typename I> I getNext(const I& i) const { 
   415     //template<typename I> I getNext(const I& i) const { 
   629     //  return gw.getNext(i); 
   416     //  return gw.getNext(i); 
   630     //}
 
   417     //}
 
   631     template<typename I> I& next(I &i) const { 
   418     template<typename I> I& next(I &i) const { 
   632       g->next(i); 
   419       graph->next(i); 
   633       while (g->valid(i) && !filter_map->get(i)) { g->next(i); }
 
   420       while (graph->valid(i) && !filter_map->get(i)) { graph->next(i); }
 
   634       return i;
 
   421       return i;
 
   635     }
 
   422     }
 
   636     
   423     
   637     template< typename It > It first() const { 
   424     template< typename It > It first() const { 
   638       It e; this->first(e); return e; }
 
   425       It e; this->first(e); return e; }
 
   799 // 	GraphWrapper::EdgeMap<T>(_G.gw, a) { }
 
   586 // 	GraphWrapper::EdgeMap<T>(_G.gw, a) { }
 
   800 //     };
 
   587 //     };
 
   801 //   };
 
   588 //   };
 
   802 
   589 
   803 
   590 
   804   template<typename GraphWrapper>
 
   591   template<typename Graph>
 
   805   class UndirGraphWrapper : public GraphWrapperSkeleton1<GraphWrapper> {
 
   592   class UndirGraphWrapper : public GraphWrapper<Graph> {
 
   806   protected:
 
   593   protected:
 
   807 //    GraphWrapper gw;
 
   594     typedef typename Graph::Edge GraphEdge;
 
   808 
   595     typedef typename Graph::OutEdgeIt GraphOutEdgeIt;
 
       
   596     typedef typename Graph::InEdgeIt GraphInEdgeIt;    
   809   public:
 
   597   public:
 
   810     //typedef GraphWrapper BaseGraph;
 
   598     typedef typename GraphWrapper<Graph>::Node Node;
 
   811 
   599     typedef typename GraphWrapper<Graph>::NodeIt NodeIt;
 
   812     typedef typename GraphWrapperSkeleton1<GraphWrapper>::Node Node;
 
   600 
   813     typedef typename GraphWrapperSkeleton1<GraphWrapper>::NodeIt NodeIt;
 
   601 //     UndirGraphWrapper() : GraphWrapper<Graph>() { }
 
   814 
   602     UndirGraphWrapper(Graph& _graph) : GraphWrapper<Graph>(_graph) { }  
   815     //private:
 
   603 
   816     //FIXME ezeknek valojaban a GraphWrapper megfelelo dolgai kellene hogy 
       
   817     //legyenek, at kell irni
 
       
   818     typedef typename /*GraphWrapperSkeleton<GraphWrapper>*/
 
       
   819     GraphWrapper::Edge GraphEdge;
 
       
   820     typedef typename /*GraphWrapperSkeleton<GraphWrapper>*/ 
       
   821     GraphWrapper::OutEdgeIt GraphOutEdgeIt;
 
       
   822     typedef typename /*GraphWrapperSkeleton<GraphWrapper>*/ 
       
   823     GraphWrapper::InEdgeIt GraphInEdgeIt;
 
       
   824     //public:
 
       
   825 
       
   826     //UndirGraphWrapper() : graph(0) { }
 
       
   827     UndirGraphWrapper(GraphWrapper& _gw) : 
       
   828       GraphWrapperSkeleton1<GraphWrapper>(_gw) { }  
       
   829 
       
   830     //UndirGraphWrapper(GraphWrapper _gw) : gw(_gw) { }
 
       
   831 
       
   832     //void setGraph(Graph& _graph) { graph = &_graph; }
 
       
   833     //Graph& getGraph() const { return (*graph); }
 
       
   834   
       
   835     class Edge {
 
   604     class Edge {
 
   836       friend class UndirGraphWrapper<GraphWrapper>;
 
   605       friend class UndirGraphWrapper<Graph>;
 
   837     protected:
 
   606     protected:
 
   838       bool out_or_in; //true iff out
 
   607       bool out_or_in; //true iff out
 
   839       GraphOutEdgeIt out;
 
   608       GraphOutEdgeIt out;
 
   840       GraphInEdgeIt in;
 
   609       GraphInEdgeIt in;
 
   841     public:
 
   610     public:
 
   864 	//return (u.out_or_in || u.in!=v.in);
 
   633 	//return (u.out_or_in || u.in!=v.in);
 
   865       } 
   634       } 
   866     };
 
   635     };
 
   867 
   636 
   868     class OutEdgeIt : public Edge {
 
   637     class OutEdgeIt : public Edge {
 
   869       friend class UndirGraphWrapper<GraphWrapper>;
 
   638       friend class UndirGraphWrapper<Graph>;
 
   870     public:
 
   639     public:
 
   871       OutEdgeIt() : Edge() { }
 
   640       OutEdgeIt() : Edge() { }
 
   872       OutEdgeIt(const Invalid& i) : Edge(i) { }
 
   641       OutEdgeIt(const Invalid& i) : Edge(i) { }
 
   873       OutEdgeIt(const UndirGraphWrapper<GraphWrapper>& _G, const Node& n) 
   642       OutEdgeIt(const UndirGraphWrapper<Graph>& _G, const Node& n) 
   874 	: Edge() { 
   643 	: Edge() { 
   875 	out_or_in=true; _G.g->first(out, n);
 
   644 	out_or_in=true; _G.graph->first(out, n);
 
   876 	if (!(_G.g->valid(out))) { out_or_in=false; _G.g->first(in, n);	}
 
   645 	if (!(_G.graph->valid(out))) { out_or_in=false; _G.graph->first(in, n);	}
 
   877       }
 
   646       }
 
   878     };
 
   647     };
 
   879 
   648 
   880     typedef OutEdgeIt InEdgeIt; 
   649     typedef OutEdgeIt InEdgeIt; 
   881 
   650 
   882     class EdgeIt : public Edge {
 
   651     class EdgeIt : public Edge {
 
   883       friend class UndirGraphWrapper<GraphWrapper>;
 
   652       friend class UndirGraphWrapper<Graph>;
 
   884     protected:
 
   653     protected:
 
   885       NodeIt v;
 
   654       NodeIt v;
 
   886     public:
 
   655     public:
 
   887       EdgeIt() : Edge() { }
 
   656       EdgeIt() : Edge() { }
 
   888       EdgeIt(const Invalid& i) : Edge(i) { }
 
   657       EdgeIt(const Invalid& i) : Edge(i) { }
 
   889       EdgeIt(const UndirGraphWrapper<GraphWrapper>& _G) 
   658       EdgeIt(const UndirGraphWrapper<Graph>& _G) 
   890 	: Edge() { 
   659 	: Edge() { 
   891 	out_or_in=true;
 
   660 	out_or_in=true;
 
   892 	//Node v;
 
   661 	//Node v;
 
   893 	_G.first(v);
 
   662 	_G.first(v);
 
   894 	if (_G.valid(v)) _G.g->first(out); else out=INVALID;
 
   663 	if (_G.valid(v)) _G.graph->first(out); else out=INVALID;
 
   895 	while (_G.valid(v) && !_G.g->valid(out)) { 
   664 	while (_G.valid(v) && !_G.graph->valid(out)) { 
   896 	  _G.g->next(v); 
   665 	  _G.graph->next(v); 
   897 	  if (_G.valid(v)) _G.g->first(out); 
   666 	  if (_G.valid(v)) _G.graph->first(out); 
   898 	}
 
   667 	}
 
   899       }
 
   668       }
 
   900     };
 
   669     };
 
   901 
   670 
   902     OutEdgeIt& first(OutEdgeIt& e, const Node& n) const {
 
   671     OutEdgeIt& first(OutEdgeIt& e, const Node& n) const {
 
   903       e.out_or_in=true; g->first(e.out, n);
 
   672       e.out_or_in=true; graph->first(e.out, n);
 
   904       if (!(g->valid(e.out))) { e.out_or_in=false; g->first(e.in, n); }
 
   673       if (!(graph->valid(e.out))) { e.out_or_in=false; graph->first(e.in, n); }
 
   905       return e;
 
   674       return e;
 
   906     }
 
   675     }
 
   907 
   676 
   908     EdgeIt& first(EdgeIt& e) const {
 
   677     EdgeIt& first(EdgeIt& e) const {
 
   909       e.out_or_in=true;
 
   678       e.out_or_in=true;
 
   910       //NodeIt v;
 
   679       //NodeIt v;
 
   911       first(e.v);
 
   680       first(e.v);
 
   912       if (valid(e.v)) g->first(e.out, e.v); else e.out=INVALID;
 
   681       if (valid(e.v)) graph->first(e.out, e.v); else e.out=INVALID;
 
   913       while (valid(e.v) && !g->valid(e.out)) { 
   682       while (valid(e.v) && !graph->valid(e.out)) { 
   914 	g->next(e.v); 
   683 	graph->next(e.v); 
   915 	if (valid(e.v)) g->first(e.out, e.v); 
   684 	if (valid(e.v)) graph->first(e.out, e.v); 
   916       }
 
   685       }
 
   917       return e;
 
   686       return e;
 
   918     }
 
   687     }
 
   919 
   688 
   920     template<typename I> I& first(I& i) const { g->first(i); return i; }
 
   689     template<typename I> I& first(I& i) const { graph->first(i); return i; }
 
   921     template<typename I, typename P> I& first(I& i, const P& p) const { 
   690     template<typename I, typename P> I& first(I& i, const P& p) const { 
   922       g->first(i, p); return i; }
 
   691       graph->first(i, p); return i; }
 
   923 
   692 
   924     OutEdgeIt& next(OutEdgeIt& e) const {
 
   693     OutEdgeIt& next(OutEdgeIt& e) const {
 
   925       if (e.out_or_in) {
 
   694       if (e.out_or_in) {
 
   926 	Node n=g->tail(e.out);
 
   695 	Node n=graph->tail(e.out);
 
   927 	g->next(e.out);
 
   696 	graph->next(e.out);
 
   928 	if (!g->valid(e.out)) { e.out_or_in=false; g->first(e.in, n); }
 
   697 	if (!graph->valid(e.out)) { e.out_or_in=false; graph->first(e.in, n); }
 
   929       } else {
 
   698       } else {
 
   930 	g->next(e.in);
 
   699 	graph->next(e.in);
 
   931       }
 
   700       }
 
   932       return e;
 
   701       return e;
 
   933     }
 
   702     }
 
   934 
   703 
   935     EdgeIt& next(EdgeIt& e) const {
 
   704     EdgeIt& next(EdgeIt& e) const {
 
   936       //NodeIt v=tail(e);
 
   705       //NodeIt v=tail(e);
 
   937       g->next(e.out);
 
   706       graph->next(e.out);
 
   938       while (valid(e.v) && !g->valid(e.out)) { 
   707       while (valid(e.v) && !graph->valid(e.out)) { 
   939 	next(e.v); 
   708 	next(e.v); 
   940 	if (valid(e.v)) g->first(e.out, e.v); 
   709 	if (valid(e.v)) graph->first(e.out, e.v); 
   941       }
 
   710       }
 
   942       return e;
 
   711       return e;
 
   943     }
 
   712     }
 
   944 
   713 
   945     template<typename I> I& next(I &i) const { return g->next(i); }    
   714     template<typename I> I& next(I &i) const { return graph->next(i); }    
   946 //    template<typename I> I getNext(const I& i) const { return gw.getNext(i); }
 
   715 //    template<typename I> I getNext(const I& i) const { return gw.getNext(i); }
 
   947 
   716 
   948     template< typename It > It first() const { 
   717     template< typename It > It first() const { 
   949       It e; first(e); return e; }
 
   718       It e; this->first(e); return e; }
 
   950 
   719 
   951     template< typename It > It first(const Node& v) const { 
   720     template< typename It > It first(const Node& v) const { 
   952       It e; first(e, v); return e; }
 
   721       It e; this->first(e, v); return e; }
 
   953 
   722 
   954 //    Node head(const Edge& e) const { return gw.head(e); }
 
   723 //    Node head(const Edge& e) const { return gw.head(e); }
 
   955 //    Node tail(const Edge& e) const { return gw.tail(e); }
 
   724 //    Node tail(const Edge& e) const { return gw.tail(e); }
 
   956 
   725 
   957 //    template<typename I> bool valid(const I& i) const 
   726 //    template<typename I> bool valid(const I& i) const 
   964 //       return graph->aNode(e); }
 
   733 //       return graph->aNode(e); }
 
   965 //     template<typename I> Node bNode(const I& e) const { 
   734 //     template<typename I> Node bNode(const I& e) const { 
   966 //       return graph->bNode(e); }
 
   735 //       return graph->bNode(e); }
 
   967 
   736 
   968     Node aNode(const OutEdgeIt& e) const { 
   737     Node aNode(const OutEdgeIt& e) const { 
   969       if (e.out_or_in) return g->tail(e); else return g->head(e); }
 
   738       if (e.out_or_in) return graph->tail(e); else return graph->head(e); }
 
   970     Node bNode(const OutEdgeIt& e) const { 
   739     Node bNode(const OutEdgeIt& e) const { 
   971       if (e.out_or_in) return g->head(e); else return g->tail(e); }
 
   740       if (e.out_or_in) return graph->head(e); else return graph->tail(e); }
 
   972   
   741   
   973 //    Node addNode() const { return gw.addNode(); }
 
   742 //    Node addNode() const { return gw.addNode(); }
 
   974 
   743 
   975 // FIXME: ez igy nem jo, mert nem
 
   744 // FIXME: ez igy nem jo, mert nem
 
   976 //    Edge addEdge(const Node& tail, const Node& head) const { 
   745 //    Edge addEdge(const Node& tail, const Node& head) const { 
   978   
   747   
   979 //    template<typename I> void erase(const I& i) const { gw.erase(i); }
 
   748 //    template<typename I> void erase(const I& i) const { gw.erase(i); }
 
   980   
   749   
   981 //    void clear() const { gw.clear(); }
 
   750 //    void clear() const { gw.clear(); }
 
   982     
   751     
   983 //     template<typename T> class NodeMap : public GraphWrapper::NodeMap<T> { 
   752 //     template<typename T> class NodeMap : public Graph::NodeMap<T> { 
   984 //     public:
 
   753 //     public:
 
   985 //       NodeMap(const UndirGraphWrapper<GraphWrapper>& _G) : 
   754 //       NodeMap(const UndirGraphWrapper<Graph>& _G) : 
   986 // 	GraphWrapper::NodeMap<T>(_G.gw) { }
 
   755 // 	Graph::NodeMap<T>(_G.gw) { }
 
   987 //       NodeMap(const UndirGraphWrapper<GraphWrapper>& _G, T a) : 
   756 //       NodeMap(const UndirGraphWrapper<Graph>& _G, T a) : 
   988 // 	GraphWrapper::NodeMap<T>(_G.gw, a) { }
 
   757 // 	Graph::NodeMap<T>(_G.gw, a) { }
 
   989 //     };
 
   758 //     };
 
   990 
   759 
   991 //     template<typename T> class EdgeMap : 
   760 //     template<typename T> class EdgeMap : 
   992 //       public GraphWrapperSkeleton<GraphWrapper>::EdgeMap<T> { 
   761 //       public GraphWrapperSkeleton<Graph>::EdgeMap<T> { 
   993 //     public:
 
   762 //     public:
 
   994 //       EdgeMap(const UndirGraphWrapper<GraphWrapper>& _G) : 
   763 //       EdgeMap(const UndirGraphWrapper<Graph>& _G) : 
   995 // 	GraphWrapperSkeleton<GraphWrapper>::EdgeMap<T>(_G.gw) { }
 
   764 // 	GraphWrapperSkeleton<Graph>::EdgeMap<T>(_G.gw) { }
 
   996 //       EdgeMap(const UndirGraphWrapper<GraphWrapper>& _G, T a) : 
   765 //       EdgeMap(const UndirGraphWrapper<Graph>& _G, T a) : 
   997 // 	GraphWrapper::EdgeMap<T>(_G.gw, a) { }
 
   766 // 	Graph::EdgeMap<T>(_G.gw, a) { }
 
   998 //     };
 
   767 //     };
 
   999    };
 
   768    };
 
  1000 
   769 
  1001 
   770 
  1002 
   771 
  1069 //     //SymGraphWrapper() : graph(0) { }
 
   838 //     //SymGraphWrapper() : graph(0) { }
 
  1070 //     SymGraphWrapper(Graph& _graph) : graph(&_graph) { }
 
   839 //     SymGraphWrapper(Graph& _graph) : graph(&_graph) { }
 
  1071 //   };
 
   840 //   };
 
  1072 
   841 
  1073 
   842 
  1074   template<typename GraphWrapper, typename Number, typename FlowMap, typename CapacityMap>
 
   843   template<typename Graph, typename Number, typename FlowMap, typename CapacityMap>
 
  1075   class ResGraphWrapper : public GraphWrapperSkeleton1<GraphWrapper>{
 
   844   class ResGraphWrapper : public GraphWrapper<Graph>{
 
  1076   public:
 
   845   public:
 
  1077     //typedef Graph BaseGraph;
 
   846     typedef typename GraphWrapper<Graph>::Node Node;
 
  1078     //typedef TrivGraphWrapper<const Graph> GraphWrapper;
 
   847     typedef typename GraphWrapper<Graph>::NodeIt NodeIt;
 
  1079     typedef typename GraphWrapperSkeleton1<GraphWrapper>::Node Node;
 
       
  1080     typedef typename GraphWrapperSkeleton1<GraphWrapper>::NodeIt NodeIt;
 
       
  1081   private:
 
       
  1082     typedef typename /*GraphWrapperSkeleton<GraphWrapper>*/
 
       
  1083     GraphWrapper::OutEdgeIt OldOutEdgeIt;
 
       
  1084     typedef typename /*GraphWrapperSkeleton<GraphWrapper>*/
 
       
  1085     GraphWrapper::InEdgeIt OldInEdgeIt;
 
       
  1086   protected:
 
   848   protected:
 
  1087     //const Graph* graph;
 
   849     typedef typename Graph::OutEdgeIt OldOutEdgeIt;
 
  1088     //GraphWrapper gw;
 
   850     typedef typename Graph::InEdgeIt OldInEdgeIt;
 
  1089     FlowMap* flow;
 
   851     FlowMap* flow;
 
  1090     const CapacityMap* capacity;
 
   852     const CapacityMap* capacity;
 
  1091   public:
 
   853   public:
 
  1092 
   854 
  1093     ResGraphWrapper(GraphWrapper& _gw, FlowMap& _flow, 
   855     ResGraphWrapper(Graph& _graph, FlowMap& _flow, 
  1094 		    const CapacityMap& _capacity) : 
   856 		    const CapacityMap& _capacity) : 
  1095       GraphWrapperSkeleton1<GraphWrapper>(_gw), 
   857       GraphWrapper<Graph>(_graph), flow(&_flow), capacity(&_capacity) { }
 
  1096       flow(&_flow), capacity(&_capacity) { }
 
       
  1097 
       
  1098     //void setGraph(const Graph& _graph) { graph = &_graph; }
 
       
  1099     //const Graph& getGraph() const { return (*graph); }
 
       
  1100 
   858 
  1101     class Edge; 
   859     class Edge; 
  1102     class OutEdgeIt; 
   860     class OutEdgeIt; 
  1103     friend class Edge; 
   861     friend class Edge; 
  1104     friend class OutEdgeIt; 
   862     friend class OutEdgeIt; 
  1105 
   863 
  1106     class Edge {
 
   864     class Edge {
 
  1107       friend class ResGraphWrapper<GraphWrapper, Number, FlowMap, CapacityMap>;
 
   865       friend class ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>;
 
  1108     protected:
 
   866     protected:
 
  1109       bool out_or_in; //true, iff out
 
   867       bool out_or_in; //true, iff out
 
  1110       OldOutEdgeIt out;
 
   868       OldOutEdgeIt out;
 
  1111       OldInEdgeIt in;
 
   869       OldInEdgeIt in;
 
  1112     public:
 
   870     public:
 
  1128       } 
   886       } 
  1129     };
 
   887     };
 
  1130 
   888 
  1131 
   889 
  1132     class OutEdgeIt : public Edge {
 
   890     class OutEdgeIt : public Edge {
 
  1133       friend class ResGraphWrapper<GraphWrapper, Number, FlowMap, CapacityMap>;
 
   891       friend class ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>;
 
  1134     public:
 
   892     public:
 
  1135       OutEdgeIt() { }
 
   893       OutEdgeIt() { }
 
  1136       //FIXME
 
   894       //FIXME
 
  1137       OutEdgeIt(const Edge& e) : Edge(e) { }
 
   895       OutEdgeIt(const Edge& e) : Edge(e) { }
 
  1138       OutEdgeIt(const Invalid& i) : Edge(i) { }
 
   896       OutEdgeIt(const Invalid& i) : Edge(i) { }
 
  1139     protected:
 
   897     protected:
 
  1140       OutEdgeIt(const ResGraphWrapper<GraphWrapper, Number, FlowMap, CapacityMap>& resG, Node v) : Edge() { 
   898       OutEdgeIt(const ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>& resG, Node v) : Edge() { 
  1141 	resG.g->first(out, v);
 
   899 	resG.graph->first(out, v);
 
  1142 	while( resG.g->valid(out) && !(resG.resCap(out)>0) ) { resG.g->next(out); }
 
   900 	while( resG.graph->valid(out) && !(resG.resCap(out)>0) ) { resG.graph->next(out); }
 
  1143 	if (!resG.g->valid(out)) {
 
   901 	if (!resG.graph->valid(out)) {
 
  1144 	  out_or_in=0;
 
   902 	  out_or_in=0;
 
  1145 	  resG.g->first(in, v);
 
   903 	  resG.graph->first(in, v);
 
  1146 	  while( resG.g->valid(in) && !(resG.resCap(in)>0) ) { resG.g->next(in); }
 
   904 	  while( resG.graph->valid(in) && !(resG.resCap(in)>0) ) { resG.graph->next(in); }
 
  1147 	}
 
   905 	}
 
  1148       }
 
   906       }
 
  1149 //     public:
 
   907 //     public:
 
  1150 //       OutEdgeIt& operator++() { 
   908 //       OutEdgeIt& operator++() { 
  1151 // 	if (out_or_in) {
 
   909 // 	if (out_or_in) {
 
  1167 
   925 
  1168     //FIXME This is just for having InEdgeIt
 
   926     //FIXME This is just for having InEdgeIt
 
  1169     typedef void InEdgeIt;
 
   927     typedef void InEdgeIt;
 
  1170 
   928 
  1171     class EdgeIt : public Edge {
 
   929     class EdgeIt : public Edge {
 
  1172       friend class ResGraphWrapper<GraphWrapper, Number, FlowMap, CapacityMap>;
 
   930       friend class ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>;
 
  1173       NodeIt v; 
   931       NodeIt v; 
  1174     public:
 
   932     public:
 
  1175       EdgeIt() { }
 
   933       EdgeIt() { }
 
  1176       //EdgeIt(const EdgeIt& e) : Edge(e), v(e.v) { }
 
   934       //EdgeIt(const EdgeIt& e) : Edge(e), v(e.v) { }
 
  1177       EdgeIt(const Invalid& i) : Edge(i) { }
 
   935       EdgeIt(const Invalid& i) : Edge(i) { }
 
  1178       EdgeIt(const ResGraphWrapper<GraphWrapper, Number, FlowMap, CapacityMap>& resG) : Edge() { 
   936       EdgeIt(const ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>& resG) : Edge() { 
  1179 	resG.g->first(v);
 
   937 	resG.graph->first(v);
 
  1180 	if (resG.g->valid(v)) resG.g->first(out, v); else out=INVALID;
 
   938 	if (resG.graph->valid(v)) resG.graph->first(out, v); else out=INVALID;
 
  1181 	while (resG.g->valid(out) && !(resG.resCap(out)>0) ) { resG.g->next(out); }
 
   939 	while (resG.graph->valid(out) && !(resG.resCap(out)>0) ) { resG.graph->next(out); }
 
  1182 	while (resG.g->valid(v) && !resG.g->valid(out)) { 
   940 	while (resG.graph->valid(v) && !resG.graph->valid(out)) { 
  1183 	  resG.g->next(v); 
   941 	  resG.graph->next(v); 
  1184 	  if (resG.g->valid(v)) resG.g->first(out, v); 
   942 	  if (resG.graph->valid(v)) resG.graph->first(out, v); 
  1185 	  while (resG.g->valid(out) && !(resG.resCap(out)>0) ) { resG.g->next(out); }
 
   943 	  while (resG.graph->valid(out) && !(resG.resCap(out)>0) ) { resG.graph->next(out); }
 
  1186 	}
 
   944 	}
 
  1187 	if (!resG.g->valid(out)) {
 
   945 	if (!resG.graph->valid(out)) {
 
  1188 	  out_or_in=0;
 
   946 	  out_or_in=0;
 
  1189 	  resG.g->first(v);
 
   947 	  resG.graph->first(v);
 
  1190 	  if (resG.g->valid(v)) resG.g->first(in, v); else in=INVALID;
 
   948 	  if (resG.graph->valid(v)) resG.graph->first(in, v); else in=INVALID;
 
  1191 	  while (resG.g->valid(in) && !(resG.resCap(in)>0) ) { resG.g->next(in); }
 
   949 	  while (resG.graph->valid(in) && !(resG.resCap(in)>0) ) { resG.graph->next(in); }
 
  1192 	  while (resG.g->valid(v) && !resG.g->valid(in)) { 
   950 	  while (resG.graph->valid(v) && !resG.graph->valid(in)) { 
  1193 	    resG.g->next(v); 
   951 	    resG.graph->next(v); 
  1194 	    if (resG.g->valid(v)) resG.g->first(in, v); 
   952 	    if (resG.graph->valid(v)) resG.graph->first(in, v); 
  1195 	    while (resG.g->valid(in) && !(resG.resCap(in)>0) ) { resG.g->next(in); }
 
   953 	    while (resG.graph->valid(in) && !(resG.resCap(in)>0) ) { resG.graph->next(in); }
 
  1196 	  }
 
   954 	  }
 
  1197 	}
 
   955 	}
 
  1198       }
 
   956       }
 
  1199 //       EdgeIt& operator++() { 
   957 //       EdgeIt& operator++() { 
  1200 // 	if (out_or_in) {
 
   958 // 	if (out_or_in) {
 
  1227 // 	}
 
   985 // 	}
 
  1228 // 	return *this;
 
   986 // 	return *this;
 
  1229 //       }
 
   987 //       }
 
  1230     };
 
   988     };
 
  1231 
   989 
  1232     NodeIt& first(NodeIt& v) const { g->first(v); return v; }
 
   990     NodeIt& first(NodeIt& v) const { graph->first(v); return v; }
 
  1233     OutEdgeIt& first(OutEdgeIt& e, Node v) const { 
   991     OutEdgeIt& first(OutEdgeIt& e, Node v) const { 
  1234       e=OutEdgeIt(*this, v); 
   992       e=OutEdgeIt(*this, v); 
  1235       return e;
 
   993       return e;
 
  1236     }
 
   994     }
 
  1237     EdgeIt& first(EdgeIt& e) const { 
   995     EdgeIt& first(EdgeIt& e) const { 
  1238       e=EdgeIt(*this); 
   996       e=EdgeIt(*this); 
  1239       return e;
 
   997       return e;
 
  1240     }
 
   998     }
 
  1241    
   999    
  1242     NodeIt& next(NodeIt& n) const { return g->next(n); }
 
  1000     NodeIt& next(NodeIt& n) const { return graph->next(n); }
 
  1243 
  1001 
  1244     OutEdgeIt& next(OutEdgeIt& e) const { 
  1002     OutEdgeIt& next(OutEdgeIt& e) const { 
  1245       if (e.out_or_in) {
 
  1003       if (e.out_or_in) {
 
  1246 	Node v=g->aNode(e.out);
 
  1004 	Node v=graph->aNode(e.out);
 
  1247 	g->next(e.out);
 
  1005 	graph->next(e.out);
 
  1248 	while( g->valid(e.out) && !(resCap(e.out)>0) ) { g->next(e.out); }
 
  1006 	while( graph->valid(e.out) && !(resCap(e.out)>0) ) { graph->next(e.out); }
 
  1249 	if (!g->valid(e.out)) {
 
  1007 	if (!graph->valid(e.out)) {
 
  1250 	  e.out_or_in=0;
 
  1008 	  e.out_or_in=0;
 
  1251 	  g->first(e.in, v); 
  1009 	  graph->first(e.in, v); 
  1252 	  while( g->valid(e.in) && !(resCap(e.in)>0) ) { g->next(e.in); }
 
  1010 	  while( graph->valid(e.in) && !(resCap(e.in)>0) ) { graph->next(e.in); }
 
  1253 	}
 
  1011 	}
 
  1254       } else {
 
  1012       } else {
 
  1255 	g->next(e.in);
 
  1013 	graph->next(e.in);
 
  1256 	while( g->valid(e.in) && !(resCap(e.in)>0) ) { g->next(e.in); } 
  1014 	while( graph->valid(e.in) && !(resCap(e.in)>0) ) { graph->next(e.in); } 
  1257       }
 
  1015       }
 
  1258       return e;
 
  1016       return e;
 
  1259     }
 
  1017     }
 
  1260 
  1018 
  1261     EdgeIt& next(EdgeIt& e) const { 
  1019     EdgeIt& next(EdgeIt& e) const { 
  1262       if (e.out_or_in) {
 
  1020       if (e.out_or_in) {
 
  1263 	g->next(e.out);
 
  1021 	graph->next(e.out);
 
  1264 	while (g->valid(e.out) && !(resCap(e.out)>0) ) { g->next(e.out); }
 
  1022 	while (graph->valid(e.out) && !(resCap(e.out)>0) ) { graph->next(e.out); }
 
  1265 	  while (g->valid(e.v) && !g->valid(e.out)) { 
  1023 	  while (graph->valid(e.v) && !graph->valid(e.out)) { 
  1266 	    g->next(e.v); 
  1024 	    graph->next(e.v); 
  1267 	    if (g->valid(e.v)) g->first(e.out, e.v); 
  1025 	    if (graph->valid(e.v)) graph->first(e.out, e.v); 
  1268 	    while (g->valid(e.out) && !(resCap(e.out)>0) ) { g->next(e.out); }
 
  1026 	    while (graph->valid(e.out) && !(resCap(e.out)>0) ) { graph->next(e.out); }
 
  1269 	  }
 
  1027 	  }
 
  1270 	  if (!g->valid(e.out)) {
 
  1028 	  if (!graph->valid(e.out)) {
 
  1271 	    e.out_or_in=0;
 
  1029 	    e.out_or_in=0;
 
  1272 	    g->first(e.v);
 
  1030 	    graph->first(e.v);
 
  1273 	    if (g->valid(e.v)) g->first(e.in, e.v); else e.in=INVALID;
 
  1031 	    if (graph->valid(e.v)) graph->first(e.in, e.v); else e.in=INVALID;
 
  1274 	    while (g->valid(e.in) && !(resCap(e.in)>0) ) { g->next(e.in); }
 
  1032 	    while (graph->valid(e.in) && !(resCap(e.in)>0) ) { graph->next(e.in); }
 
  1275 	    while (g->valid(e.v) && !g->valid(e.in)) { 
  1033 	    while (graph->valid(e.v) && !graph->valid(e.in)) { 
  1276 	      g->next(e.v); 
  1034 	      graph->next(e.v); 
  1277 	      if (g->valid(e.v)) g->first(e.in, e.v); 
  1035 	      if (graph->valid(e.v)) graph->first(e.in, e.v); 
  1278 	      while (g->valid(e.in) && !(resCap(e.in)>0) ) { g->next(e.in); }
 
  1036 	      while (graph->valid(e.in) && !(resCap(e.in)>0) ) { graph->next(e.in); }
 
  1279 	    }  
  1037 	    }  
  1280 	  }
 
  1038 	  }
 
  1281 	} else {
 
  1039 	} else {
 
  1282 	  g->next(e.in);
 
  1040 	  graph->next(e.in);
 
  1283 	  while (g->valid(e.in) && !(resCap(e.in)>0) ) { g->next(e.in); }
 
  1041 	  while (graph->valid(e.in) && !(resCap(e.in)>0) ) { graph->next(e.in); }
 
  1284 	  while (g->valid(e.v) && !g->valid(e.in)) { 
  1042 	  while (graph->valid(e.v) && !graph->valid(e.in)) { 
  1285 	    g->next(e.v); 
  1043 	    graph->next(e.v); 
  1286 	    if (g->valid(e.v)) g->first(e.in, e.v); 
  1044 	    if (graph->valid(e.v)) graph->first(e.in, e.v); 
  1287 	    while (g->valid(e.in) && !(resCap(e.in)>0) ) { g->next(e.in); }
 
  1045 	    while (graph->valid(e.in) && !(resCap(e.in)>0) ) { graph->next(e.in); }
 
  1288 	  }
 
  1046 	  }
 
  1289 	}
 
  1047 	}
 
  1290 	return e;
 
  1048 	return e;
 
  1291       }
 
  1049       }
 
  1292     
  1050     
  1304       first(e, v);
 
  1062       first(e, v);
 
  1305       return e; 
  1063       return e; 
  1306     }
 
  1064     }
 
  1307 
  1065 
  1308     Node tail(Edge e) const { 
  1066     Node tail(Edge e) const { 
  1309       return ((e.out_or_in) ? g->aNode(e.out) : g->aNode(e.in)); }
 
  1067       return ((e.out_or_in) ? graph->aNode(e.out) : graph->aNode(e.in)); }
 
  1310     Node head(Edge e) const { 
  1068     Node head(Edge e) const { 
  1311       return ((e.out_or_in) ? g->bNode(e.out) : g->bNode(e.in)); }
 
  1069       return ((e.out_or_in) ? graph->bNode(e.out) : graph->bNode(e.in)); }
 
  1312 
  1070 
  1313     Node aNode(OutEdgeIt e) const { 
  1071     Node aNode(OutEdgeIt e) const { 
  1314       return ((e.out_or_in) ? g->aNode(e.out) : g->aNode(e.in)); }
 
  1072       return ((e.out_or_in) ? graph->aNode(e.out) : graph->aNode(e.in)); }
 
  1315     Node bNode(OutEdgeIt e) const { 
  1073     Node bNode(OutEdgeIt e) const { 
  1316       return ((e.out_or_in) ? g->bNode(e.out) : g->bNode(e.in)); }
 
  1074       return ((e.out_or_in) ? graph->bNode(e.out) : graph->bNode(e.in)); }
 
  1317 
  1075 
  1318     int nodeNum() const { return g->nodeNum(); }
 
  1076     int nodeNum() const { return graph->nodeNum(); }
 
  1319     //FIXME
 
  1077     //FIXME
 
  1320     //int edgeNum() const { return g->edgeNum(); }
 
  1078     //int edgeNum() const { return graph->edgeNum(); }
 
  1321 
  1079 
  1322 
  1080 
  1323     int id(Node v) const { return g->id(v); }
 
  1081     int id(Node v) const { return graph->id(v); }
 
  1324 
  1082 
  1325     bool valid(Node n) const { return g->valid(n); }
 
  1083     bool valid(Node n) const { return graph->valid(n); }
 
  1326     bool valid(Edge e) const { 
  1084     bool valid(Edge e) const { 
  1327       return e.out_or_in ? g->valid(e.out) : g->valid(e.in); }
 
  1085       return e.out_or_in ? graph->valid(e.out) : graph->valid(e.in); }
 
  1328 
  1086 
  1329     void augment(const Edge& e, Number a) const {
 
  1087     void augment(const Edge& e, Number a) const {
 
  1330       if (e.out_or_in)  
  1088       if (e.out_or_in)  
  1331 	flow->set(e.out, flow->get(e.out)+a);
 
  1089 	flow->set(e.out, flow->get(e.out)+a);
 
  1332       else  
  1090       else  
  1346     
  1104     
  1347     Number resCap(OldInEdgeIt in) const { 
  1105     Number resCap(OldInEdgeIt in) const { 
  1348       return (flow->get(in)); 
  1106       return (flow->get(in)); 
  1349     }
 
  1107     }
 
  1350 
  1108 
  1351 //     template<typename T> class NodeMap : public GraphWrapper::NodeMap<T> { 
  1109 //     template<typename T> class NodeMap : public Graph::NodeMap<T> { 
  1352 //     public:
 
  1110 //     public:
 
  1353 //       NodeMap(const ResGraphWrapper<GraphWrapper, Number, FlowMap, CapacityMap>& _G) 
  1111 //       NodeMap(const ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>& _G) 
  1354 // 	: GraphWrapper::NodeMap<T>(_G.gw) { }
 
  1112 // 	: Graph::NodeMap<T>(_G.gw) { }
 
  1355 //       NodeMap(const ResGraphWrapper<GraphWrapper, Number, FlowMap, CapacityMap>& _G, 
  1113 //       NodeMap(const ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>& _G, 
  1356 // 	      T a) : GraphWrapper::NodeMap<T>(_G.gw, a) { }
 
  1114 // 	      T a) : Graph::NodeMap<T>(_G.gw, a) { }
 
  1357 //     };
 
  1115 //     };
 
  1358 
  1116 
  1359 //     template <typename T>
 
  1117 //     template <typename T>
 
  1360 //     class NodeMap {
 
  1118 //     class NodeMap {
 
  1361 //       typename Graph::NodeMap<T> node_map; 
  1119 //       typename Graph::NodeMap<T> node_map; 
  1366 //       T get(Node nit) const { return node_map.get(nit); }
 
  1124 //       T get(Node nit) const { return node_map.get(nit); }
 
  1367 //     };
 
  1125 //     };
 
  1368 
  1126 
  1369     template <typename T>
 
  1127     template <typename T>
 
  1370     class EdgeMap {
 
  1128     class EdgeMap {
 
  1371       typename GraphWrapper::EdgeMap<T> forward_map, backward_map; 
  1129       typename Graph::EdgeMap<T> forward_map, backward_map; 
  1372     public:
 
  1130     public:
 
  1373       EdgeMap(const ResGraphWrapper<GraphWrapper, Number, FlowMap, CapacityMap>& _G) : forward_map(_G.gw), backward_map(_G.gw) { }
 
  1131       EdgeMap(const ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>& _G) : forward_map(*(_G.graph)), backward_map(*(_G.graph)) { }
 
  1374       EdgeMap(const ResGraphWrapper<GraphWrapper, Number, FlowMap, CapacityMap>& _G, T a) : forward_map(_G.gw, a), backward_map(_G.gw, a) { }
 
  1132       EdgeMap(const ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>& _G, T a) : forward_map(*(_G.graph), a), backward_map(*(_G.graph), a) { }
 
  1375       void set(Edge e, T a) { 
  1133       void set(Edge e, T a) { 
  1376 	if (e.out_or_in) 
  1134 	if (e.out_or_in) 
  1377 	  forward_map.set(e.out, a); 
  1135 	  forward_map.set(e.out, a); 
  1378 	else 
  1136 	else 
  1379 	  backward_map.set(e.in, a); 
  1137 	  backward_map.set(e.in, a); 
  1385 	  return backward_map.get(e.in); 
  1143 	  return backward_map.get(e.in); 
  1386       }
 
  1144       }
 
  1387     };
 
  1145     };
 
  1388   };
 
  1146   };
 
  1389 
  1147 
  1390   //Subgraph on the same node-set and partial edge-set
 
  1148   //ErasingFirstGraphWrapper for blocking flows
 
  1391   template<typename GraphWrapper, typename FirstOutEdgesMap>
 
  1149   template<typename Graph, typename FirstOutEdgesMap>
 
  1392   class ErasingFirstGraphWrapper : public GraphWrapperSkeleton1<GraphWrapper> {
 
  1150   class ErasingFirstGraphWrapper : public GraphWrapper<Graph> {
 
  1393   protected:
 
  1151   protected:
 
  1394     FirstOutEdgesMap* first_out_edges;
 
  1152     FirstOutEdgesMap* first_out_edges;
 
  1395   public:
 
  1153   public:
 
  1396     typedef typename GraphWrapperSkeleton1<GraphWrapper>::Node Node;
 
  1154     typedef typename GraphWrapper<Graph>::Node Node;
 
  1397     typedef typename GraphWrapperSkeleton1<GraphWrapper>::NodeIt NodeIt;
 
  1155     typedef typename GraphWrapper<Graph>::NodeIt NodeIt;
 
  1398     typedef typename GraphWrapperSkeleton1<GraphWrapper>::Edge Edge;
 
  1156     typedef typename GraphWrapper<Graph>::Edge Edge;
 
  1399     typedef typename GraphWrapperSkeleton1<GraphWrapper>::EdgeIt EdgeIt;
 
  1157     typedef typename GraphWrapper<Graph>::EdgeIt EdgeIt;
 
  1400     typedef typename GraphWrapperSkeleton1<GraphWrapper>::InEdgeIt InEdgeIt;
 
  1158     typedef typename GraphWrapper<Graph>::InEdgeIt InEdgeIt;
 
  1401     typedef typename GraphWrapperSkeleton1<GraphWrapper>::OutEdgeIt OutEdgeIt;
 
  1159     typedef typename GraphWrapper<Graph>::OutEdgeIt OutEdgeIt;
 
  1402 
  1160 
  1403     ErasingFirstGraphWrapper(GraphWrapper& _gw, FirstOutEdgesMap& _first_out_edges) : 
  1161     ErasingFirstGraphWrapper(Graph& _graph, 
  1404       GraphWrapperSkeleton1<GraphWrapper>(_gw), first_out_edges(&_first_out_edges) { }  
  1162 			     FirstOutEdgesMap& _first_out_edges) : 
       
  1163       GraphWrapper<Graph>(_graph), first_out_edges(&_first_out_edges) { }  
  1405 
  1164 
  1406     template<typename I> I& first(I& i) const { 
  1165     template<typename I> I& first(I& i) const { 
  1407       g->first(i); 
  1166       graph->first(i); 
  1408       //while (gw.valid(i) && !filter_map->get(i)) { gw.next(i); }
 
       
  1409       return i;
 
  1167       return i;
 
  1410     }
 
  1168     }
 
  1411     OutEdgeIt& first(OutEdgeIt& e, const Node& n) const {
 
  1169     OutEdgeIt& first(OutEdgeIt& e, const Node& n) const {
 
  1412       e=first_out_edges->get(n);
 
  1170       e=first_out_edges->get(n);
 
  1413       return e;
 
  1171       return e;
 
  1414     }
 
  1172     }
 
  1415     template<typename I, typename P> I& first(I& i, const P& p) const { 
  1173     template<typename I, typename P> I& first(I& i, const P& p) const { 
  1416       g->first(i, p); 
  1174       graph->first(i, p); 
  1417       //while (gw.valid(i) && !filter_map->get(i)) { gw.next(i); }
 
       
  1418       return i;
 
  1175       return i;
 
  1419     }
 
  1176     }
 
  1420     
  1177     
  1421     //template<typename I> I getNext(const I& i) const { 
  1178     //template<typename I> I getNext(const I& i) const { 
  1422     //  return gw.getNext(i); 
  1179     //  return gw.getNext(i); 
  1423     //}
 
  1180     //}
 
  1424     template<typename I> I& next(I &i) const { 
  1181     template<typename I> I& next(I &i) const { 
  1425       g->next(i); 
  1182       graph->next(i); 
  1426       //while (gw.valid(i) && !filter_map->get(i)) { gw.next(i); }
 
       
  1427       return i;
 
  1183       return i;
 
  1428     }
 
  1184     }
 
  1429     
  1185     
  1430     template< typename It > It first() const { 
  1186     template< typename It > It first() const { 
  1431       It e; this->first(e); return e; }
 
  1187       It e; this->first(e); return e; }
 
  1437       OutEdgeIt f=e;
 
  1193       OutEdgeIt f=e;
 
  1438       this->next(f);
 
  1194       this->next(f);
 
  1439       first_out_edges->set(this->tail(e), f);
 
  1195       first_out_edges->set(this->tail(e), f);
 
  1440     }
 
  1196     }
 
  1441   };
 
  1197   };
 
  1442 
       
  1443 //   template<typename Graph, typename Number, typename FlowMap, typename CapacityMap>
 
       
  1444 //   class ErasingResGraphWrapper : public ResGraphWrapper<Graph, Number, FlowMap, CapacityMap> {
 
       
  1445 //   protected:
 
       
  1446 //     ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::NodeMap<typename ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::OutEdgeIt> first_out_edges;
 
       
  1447 //     //ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::NodeMap<int> dist;
 
       
  1448 //   public:
 
       
  1449 //     ErasingResGraphWrapper(const Graph& _G, FlowMap& _flow, 
       
  1450 // 			   const CapacityMap& _capacity) : 
       
  1451 //       ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>(_G, _flow, _capacity), 
       
  1452 //       first_out_edges(*this) /*, dist(*this)*/ { 
       
  1453 //       for(NodeIt n=this->template first<NodeIt>(); this->valid(n); this->next(n)) {
 
       
  1454 // 	OutEdgeIt e;
 
       
  1455 // 	ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::first(e, n);
 
       
  1456 // 	first_out_edges.set(n, e);
 
       
  1457 //       }
 
       
  1458 //     }
 
       
  1459 
       
  1460 //     //void setGraph(Graph& _graph) { graph = &_graph; }
 
       
  1461 //     //Graph& getGraph() const { return (*graph); }
 
       
  1462   
       
  1463 //     //TrivGraphWrapper() : graph(0) { }
 
       
  1464 //     //ErasingResGraphWrapper(Graph& _graph) : graph(&_graph) { }
 
       
  1465 
       
  1466 //     //typedef Graph BaseGraph;
 
       
  1467 
       
  1468 //     //typedef typename Graph::Node Node;
 
       
  1469 //     //typedef typename Graph::NodeIt NodeIt;
 
       
  1470 
       
  1471 //     //typedef typename Graph::Edge Edge;
 
       
  1472 //     //typedef typename Graph::OutEdgeIt OutEdgeIt;
 
       
  1473 //     //typedef typename Graph::InEdgeIt InEdgeIt;
 
       
  1474 //     //typedef typename Graph::SymEdgeIt SymEdgeIt;
 
       
  1475 //     //typedef typename Graph::EdgeIt EdgeIt;
 
       
  1476 
       
  1477 //     typedef typename ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::Node Node;
 
       
  1478 //     typedef typename ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::NodeIt NodeIt;
 
       
  1479 
       
  1480 //     typedef typename ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::Edge Edge;
 
       
  1481 //     typedef typename ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::OutEdgeIt OutEdgeIt;
 
       
  1482 //     //typedef typename ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::InEdgeIt InEdgeIt;
 
       
  1483 //     //typedef typename Graph::SymEdgeIt SymEdgeIt;
 
       
  1484 //     //typedef typename ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::EdgeIt EdgeIt;
 
       
  1485 
       
  1486 //     NodeIt& first(NodeIt& n) const { 
       
  1487 //       return ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::first(n);
 
       
  1488 //     }
 
       
  1489 
       
  1490 //     OutEdgeIt& first(OutEdgeIt& e, const Node& n) const { 
       
  1491 //       e=first_out_edges.get(n);
 
       
  1492 //       return e;
 
       
  1493 //     }
 
       
  1494     
       
  1495 //     //ROSSZ template<typename I> I& first(I& i) const { return first(i); }
 
       
  1496 //     //ROSSZ template<typename I, typename P> I& first(I& i, const P& p) const { 
       
  1497 //     //  return first(i, p); }
 
       
  1498     
       
  1499 //     //template<typename I> I getNext(const I& i) const { 
       
  1500 //     //  return gw.getNext(i); }
 
       
  1501 //     //template<typename I> I& next(I &i) const { return gw.next(i); }    
       
  1502 
       
  1503 //     template< typename It > It first() const { 
       
  1504 //       It e; first(e); return e; }
 
       
  1505 
       
  1506 //     template< typename It > It first(const Node& v) const { 
       
  1507 //       It e; first(e, v); return e; }
 
       
  1508 
       
  1509 //     //Node head(const Edge& e) const { return gw.head(e); }
 
       
  1510 //     //Node tail(const Edge& e) const { return gw.tail(e); }
 
       
  1511 
       
  1512 //     //template<typename I> bool valid(const I& i) const 
       
  1513 //     //  { return gw.valid(i); }
 
       
  1514   
       
  1515 //     //int nodeNum() const { return gw.nodeNum(); }
 
       
  1516 //     //int edgeNum() const { return gw.edgeNum(); }
 
       
  1517   
       
  1518 //     //template<typename I> Node aNode(const I& e) const { 
       
  1519 //     //  return gw.aNode(e); }
 
       
  1520 //     //template<typename I> Node bNode(const I& e) const { 
       
  1521 //     //  return gw.bNode(e); }
 
       
  1522   
       
  1523 //     //Node addNode() const { return gw.addNode(); }
 
       
  1524 //     //Edge addEdge(const Node& tail, const Node& head) const { 
       
  1525 //     //  return gw.addEdge(tail, head); }
 
       
  1526   
       
  1527 //     //void erase(const OutEdgeIt& e) {
 
       
  1528 //     //  first_out_edge(this->tail(e))=e;
 
       
  1529 //     //}
 
       
  1530 //     void erase(const Edge& e) {
 
       
  1531 //       OutEdgeIt f(e);
 
       
  1532 //       next(f);
 
       
  1533 //       first_out_edges.set(this->tail(e), f);
 
       
  1534 //     }
 
       
  1535 //     //template<typename I> void erase(const I& i) const { gw.erase(i); }
 
       
  1536   
       
  1537 //     //void clear() const { gw.clear(); }
 
       
  1538     
       
  1539 //     template<typename T> class NodeMap : public ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::NodeMap<T> { 
       
  1540 //     public:
 
       
  1541 //       NodeMap(const ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>& _G) : 
       
  1542 // 	ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::NodeMap<T>(_G /*_G.getGraph()*/) { }
 
       
  1543 //       NodeMap(const ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>& _G, T a) : 
       
  1544 // 	ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::NodeMap<T>(_G /*_G.getGraph()*/, a) { }
 
       
  1545 //     };
 
       
  1546 
       
  1547 //     template<typename T> class EdgeMap : public ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::EdgeMap<T> { 
       
  1548 //     public:
 
       
  1549 //       EdgeMap(const ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>& _G) : 
       
  1550 // 	ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::EdgeMap<T>(_G /*_G.getGraph()*/) { }
 
       
  1551 //       EdgeMap(const ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>& _G, T a) : 
       
  1552 // 	ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::EdgeMap<T>(_G /*_G.getGraph()*/, a) { }
 
       
  1553 //     };
 
       
  1554 //   };
 
       
  1555 
       
  1556 //   template<typename GraphWrapper> 
       
  1557 //   class FilterGraphWrapper {
 
       
  1558 //   };
 
       
  1559 
       
  1560 //   template<typename Graph, typename Number, typename FlowMap, typename CapacityMap>
 
       
  1561 //   class FilterGraphWrapper<ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap> > : public ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap> {
 
       
  1562 
       
  1563 //     //Graph* graph;
 
       
  1564   
       
  1565 //   public:
 
       
  1566 //     //typedef Graph BaseGraph;
 
       
  1567 
       
  1568 //     typedef typename ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::Node Node;
 
       
  1569 //     typedef typename ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::NodeIt NodeIt;
 
       
  1570 
       
  1571 //     typedef typename ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::Edge Edge;
 
       
  1572 //     typedef typename ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::OutEdgeIt OutEdgeIt;
 
       
  1573 //     //typedef typename ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::InEdgeIt InEdgeIt;
 
       
  1574 //     //typedef typename Graph::SymEdgeIt SymEdgeIt;
 
       
  1575 //     typedef typename ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::EdgeIt EdgeIt;
 
       
  1576 
       
  1577 //     //FilterGraphWrapper<Graph, Number, FlowMap, CapacityMap>::NodeMap<typename ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::OutEdgeIt> first_out_edges;
 
       
  1578     
       
  1579 //   public:
 
       
  1580 //     FilterGraphWrapper(const Graph& _G, FlowMap& _flow, 
       
  1581 // 			   const CapacityMap& _capacity) : 
       
  1582 //       ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>(_G, _flow, _capacity), dist(*this, gw.nodeNum()) { 
       
  1583 //     }
 
       
  1584 
       
  1585 //     OutEdgeIt& first(OutEdgeIt& e, const Node& n) const {
 
       
  1586 //       ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::first(e, n);
 
       
  1587 //       while (valid(e) && (dist.get(tail(e))/*+1!=*/>=dist.get(head(e)))) 
       
  1588 // 	ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::next(e);
 
       
  1589 //       return e;
 
       
  1590 //     }
 
       
  1591 
       
  1592 //     NodeIt& next(NodeIt& e) const {
 
       
  1593 //       return ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::next(e);
 
       
  1594 //     }
 
       
  1595 
       
  1596 //     OutEdgeIt& next(OutEdgeIt& e) const {
 
       
  1597 //       ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::next(e);
 
       
  1598 //       while (valid(e) && (dist.get(tail(e))/*+1!*/>=dist.get(head(e)))) 
       
  1599 // 	ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::next(e);
 
       
  1600 //       return e;
 
       
  1601 //     }
 
       
  1602 
       
  1603 //     NodeIt& first(NodeIt& n) const {
 
       
  1604 //       return ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::first(n);
 
       
  1605 //     }
 
       
  1606 
       
  1607 //     void erase(const Edge& e) {
 
       
  1608 //       OutEdgeIt f(e);
 
       
  1609 //       ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::next(f);
 
       
  1610 //       while (valid(f) && (dist.get(tail(f))/*+1!=*/>=dist.get(head(f)))) 
       
  1611 // 	ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::next(f);
 
       
  1612 //       first_out_edges.set(this->tail(e), f);
 
       
  1613 //     }
 
       
  1614 
       
  1615 //     //TrivGraphWrapper() : graph(0) { }
 
       
  1616 //     //TrivGraphWrapper(Graph& _graph) : graph(&_graph) { }
 
       
  1617 
       
  1618 //     //void setGraph(Graph& _graph) { graph = &_graph; }
 
       
  1619 //     //Graph& getGraph() const { return (*graph); }
 
       
  1620     
       
  1621 //     //template<typename I> I& first(I& i) const { return gw.first(i); }
 
       
  1622 //     //template<typename I, typename P> I& first(I& i, const P& p) const { 
       
  1623 //     //  return gw.first(i, p); }
 
       
  1624     
       
  1625 //     //template<typename I> I getNext(const I& i) const { 
       
  1626 //     //  return gw.getNext(i); }
 
       
  1627 //     //template<typename I> I& next(I &i) const { return gw.next(i); }    
       
  1628 
       
  1629 //     template< typename It > It first() const { 
       
  1630 //       It e; first(e); return e; }
 
       
  1631 
       
  1632 //     template< typename It > It first(const Node& v) const { 
       
  1633 //       It e; first(e, v); return e; }
 
       
  1634 
       
  1635 //     //Node head(const Edge& e) const { return gw.head(e); }
 
       
  1636 //     //Node tail(const Edge& e) const { return gw.tail(e); }
 
       
  1637 
       
  1638 //     //template<typename I> bool valid(const I& i) const 
       
  1639 //     //  { return gw.valid(i); }
 
       
  1640   
       
  1641 //     //template<typename I> void setInvalid(const I &i);
 
       
  1642 //     //{ return gw.setInvalid(i); }
 
       
  1643 
       
  1644 //     //int nodeNum() const { return gw.nodeNum(); }
 
       
  1645 //     //int edgeNum() const { return gw.edgeNum(); }
 
       
  1646   
       
  1647 //     //template<typename I> Node aNode(const I& e) const { 
       
  1648 //     //  return gw.aNode(e); }
 
       
  1649 //     //template<typename I> Node bNode(const I& e) const { 
       
  1650 //     //  return gw.bNode(e); }
 
       
  1651   
       
  1652 //     //Node addNode() const { return gw.addNode(); }
 
       
  1653 //     //Edge addEdge(const Node& tail, const Node& head) const { 
       
  1654 //     //  return gw.addEdge(tail, head); }
 
       
  1655   
       
  1656 //     //template<typename I> void erase(const I& i) const { gw.erase(i); }
 
       
  1657   
       
  1658 //     //void clear() const { gw.clear(); }
 
       
  1659     
       
  1660 //     template<typename T> class NodeMap : public ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::NodeMap<T> { 
       
  1661 //     public:
 
       
  1662 //       NodeMap(const FilterGraphWrapper<ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap> >& _G) : 
       
  1663 // 	ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::NodeMap<T>(_G /*_G.getGraph()*/) { }
 
       
  1664 //       NodeMap(const FilterGraphWrapper<ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap> >& _G, T a) : 
       
  1665 // 	ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::NodeMap<T>(_G /*_G.getGraph()*/, a) { }
 
       
  1666 //     };
 
       
  1667 
       
  1668 //     template<typename T> class EdgeMap : public ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::EdgeMap<T> { 
       
  1669 //     public:
 
       
  1670 //       EdgeMap(const FilterGraphWrapper<ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap> >& _G) : 
       
  1671 // 	ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::EdgeMap<T>(_G /*_G.getGraph()*/) { }
 
       
  1672 //       EdgeMap(const FilterGraphWrapper<ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap> >& _G, T a) : 
       
  1673 // 	ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::EdgeMap<T>(_G /*_G.getGraph()*/, a) { }
 
       
  1674 //     };
 
       
  1675 
       
  1676 //   public:
 
       
  1677 //     ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::NodeMap<int> dist;
 
       
  1678 
       
  1679 //   };
 
       
  1680 
       
  1681 
       
  1682 
  1198 
  1683 // // FIXME: comparison should be made better!!!
 
  1199 // // FIXME: comparison should be made better!!!
 
  1684 //   template<typename Graph, typename T, typename LowerMap, typename FlowMap, typename UpperMap>
 
  1200 //   template<typename Graph, typename T, typename LowerMap, typename FlowMap, typename UpperMap>
 
  1685 //   class ResGraphWrapper
 
  1201 //   class ResGraphWrapper
 
  1686 //   {
 
  1202 //   {
lemon-0.x