diff -r 87623302a68f -r d9650659a6ee src/work/marci/graph_wrapper.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/work/marci/graph_wrapper.h	Mon Feb 16 11:38:19 2004 +0000
@@ -0,0 +1,612 @@
+// -*-mode: c++; -*-
+#ifndef GRAPH_WRAPPER_H
+#define GRAPH_WRAPPER_H
+
+namespace marci {
+
+  template<typename Graph>
+  class TrivGraphWrapper {
+    Graph* graph;
+  
+  public:
+    typedef Graph BaseGraph;
+
+    typedef typename Graph::NodeIt NodeIt;
+    typedef typename Graph::EdgeIt EdgeIt;
+  
+    typedef typename Graph::EachNodeIt EachNodeIt;
+
+    typedef typename Graph::OutEdgeIt OutEdgeIt;
+    typedef typename Graph::InEdgeIt InEdgeIt;
+    typedef typename Graph::SymEdgeIt SymEdgeIt;
+    typedef typename Graph::EachEdgeIt EachEdgeIt;
+
+    int nodeNum() const { return graph->nodeNum(); }
+    int edgeNum() const { return graph->edgeNum(); }
+    
+    template<typename I> I& getFirst(I& i) const { return graph->getFirst(i); }
+    template<typename I, typename P> I& getFirst(I& i, const P& p) const { 
+      return graph->getFirst(i, p); }
+    //template<typename I> I next(const I i); { return graph->goNext(i); }
+    //template<typename I> I &goNext(I &i); { return graph->goNext(i); }
+
+    template< typename It > It first() const { 
+      It e; getFirst(e); return e; }
+
+    template< typename It > It first(NodeIt v) const { 
+      It e; getFirst(e, v); return e; }
+
+    NodeIt head(const EdgeIt& e) const { return graph->head(e); }
+    NodeIt tail(const EdgeIt& e) const { return graph->tail(e); }
+  
+    template<typename I> NodeIt aNode(const I& e) const { 
+      return graph->aNode(e); }
+    template<typename I> NodeIt bNode(const I& e) const { 
+      return graph->bNode(e); }
+  
+    //template<typename I> bool valid(const I& i) 
+    //{ return graph->valid(i); }
+  
+    //template<typename I> void setInvalid(const I &i);
+    //{ return graph->setInvalid(i); }
+  
+    NodeIt addNode() const { return graph->addNode(); }
+    EdgeIt addEdge(const NodeIt& tail, const NodeIt& head) const { 
+      return graph->addEdge(tail, head); }
+  
+    template<typename I> void erase(const I& i) const { graph->erase(i); }
+  
+    void clear() const { graph->clear(); }
+  
+    template<typename T> class NodeMap : public Graph::NodeMap<T> { 
+    public:
+      NodeMap(const Graph& _G) : Graph::NodeMap<T>(_G) { }
+      NodeMap(const Graph& _G, T a) : Graph::NodeMap<T>(_G, a) { }
+    };
+    template<typename T> class EdgeMap : public Graph::EdgeMap<T> { };
+  
+    void setGraph(Graph& _graph) { graph = &_graph; }
+    Graph& getGraph() { return (*graph); }
+  
+    //TrivGraphWrapper() : graph(0) { }
+    TrivGraphWrapper(Graph& _graph) : graph(&_graph) { }
+  };
+
+  template<typename Graph>
+  class ConstTrivGraphWrapper {
+    const Graph* graph;
+  
+  public:
+    typedef Graph BaseGraph;
+
+    typedef typename Graph::NodeIt NodeIt;
+    typedef typename Graph::EdgeIt EdgeIt;
+  
+    typedef typename Graph::EachNodeIt EachNodeIt;
+
+    typedef typename Graph::OutEdgeIt OutEdgeIt;
+    typedef typename Graph::InEdgeIt InEdgeIt;
+    typedef typename Graph::SymEdgeIt SymEdgeIt;
+    typedef typename Graph::EachEdgeIt EachEdgeIt;
+
+    int nodeNum() const { return graph->nodeNum(); }
+    int edgeNum() const { return graph->edgeNum(); }
+    
+    template<typename I> I& getFirst(I& i) const { return graph->getFirst(i); }
+    template<typename I, typename P> I& getFirst(I& i, const P& p) const { 
+      return graph->getFirst(i, p); }
+    //template<typename I> I next(const I i); { return graph->goNext(i); }
+    //template<typename I> I &goNext(I &i); { return graph->goNext(i); }
+
+    template< typename It > It first() const { 
+      It e; getFirst(e); return e; }
+
+    template< typename It > It first(NodeIt v) const { 
+      It e; getFirst(e, v); return e; }
+
+    NodeIt head(const EdgeIt& e) const { return graph->head(e); }
+    NodeIt tail(const EdgeIt& e) const { return graph->tail(e); }
+  
+    template<typename I> NodeIt aNode(const I& e) const { 
+      return graph->aNode(e); }
+    template<typename I> NodeIt bNode(const I& e) const { 
+      return graph->bNode(e); }
+  
+    //template<typename I> bool valid(const I& i) 
+    //{ return graph->valid(i); }
+  
+    //template<typename I> void setInvalid(const I &i);
+    //{ return graph->setInvalid(i); }
+  
+    NodeIt addNode() const { return graph->addNode(); }
+    EdgeIt addEdge(const NodeIt& tail, const NodeIt& head) const { 
+      return graph->addEdge(tail, head); }
+  
+    template<typename I> void erase(const I& i) const { graph->erase(i); }
+  
+    void clear() const { graph->clear(); }
+  
+    template<typename T> class NodeMap : public Graph::NodeMap<T> { 
+    public:
+      NodeMap(const Graph& _G) : Graph::NodeMap<T>(_G) { }
+      NodeMap(const Graph& _G, T a) : Graph::NodeMap<T>(_G, a) { }
+    };
+    template<typename T> class EdgeMap : public Graph::EdgeMap<T> { };
+  
+    void setGraph(const Graph& _graph) { graph = &_graph; }
+    const Graph& getGraph() { return (*graph); }
+  
+    //ConstTrivGraphWrapper() : graph(0) { }
+    ConstTrivGraphWrapper(const Graph& _graph) : graph(&_graph) { }
+  };
+
+
+  template<typename Graph>
+  class RevGraphWrapper
+  {
+    Graph* graph;
+  
+  public:
+    typedef Graph BaseGraph;
+
+    typedef typename Graph::NodeIt NodeIt;
+    typedef typename Graph::EdgeIt EdgeIt;
+  
+    typedef typename Graph::EachNodeIt EachNodeIt;
+  
+    typedef typename Graph::OutEdgeIt InEdgeIt;
+    typedef typename Graph::InEdgeIt OutEdgeIt;
+    typedef typename Graph::SymEdgeIt SymEdgeIt;
+    typedef typename Graph::EachEdgeIt EachEdgeIt;
+
+    int nodeNum() const { return graph->nodeNum(); }
+    int edgeNum() const { return graph->edgeNum(); }
+    
+    template<typename I> I& getFirst(I& i) const { return graph->getFirst(i); }
+    template<typename I, typename P> I& getFirst(I& i, const P& p) const { 
+      return graph->getFirst(i, p); }
+    //template<typename I> I next(const I i); { return graph->goNext(i); }
+    //template<typename I> I &goNext(I &i); { return graph->goNext(i); }
+
+    template< typename It > It first() const { 
+      It e; getFirst(e); return e; }
+
+    template< typename It > It first(NodeIt v) const { 
+      It e; getFirst(e, v); return e; }
+
+    NodeIt head(const EdgeIt& e) const { return graph->tail(e); }
+    NodeIt tail(const EdgeIt& e) const { return graph->head(e); }
+  
+    template<typename I> NodeIt aNode(const I& e) const { 
+      return graph->aNode(e); }
+    template<typename I> NodeIt bNode(const I& e) const { 
+      return graph->bNode(e); }
+  
+    //template<typename I> bool valid(const I i);
+    //{ return graph->valid(i); }
+  
+    //template<typename I> void setInvalid(const I &i);
+    //{ return graph->setInvalid(i); }
+  
+    NodeIt addNode() { return graph->addNode(); }
+    EdgeIt addEdge(const NodeIt& tail, const NodeIt& head) { 
+      return graph->addEdge(tail, head); }
+  
+    template<typename I> void erase(const I& i) { graph->erase(i); }
+  
+    void clear() { graph->clear(); }
+  
+    template<typename T> class NodeMap : public Graph::NodeMap<T> { };
+    template<typename T> class EdgeMap : public Graph::EdgeMap<T> { };
+  
+    void setGraph(Graph& _graph) { graph = &_graph; }
+    Graph& getGraph() { return (*graph); }
+
+    //RevGraphWrapper() : graph(0) { }
+    RevGraphWrapper(Graph& _graph) : graph(&_graph) { }
+  };
+
+  template<typename Graph>
+  class SymGraphWrapper
+  {
+    Graph* graph;
+  
+  public:
+    typedef Graph BaseGraph;
+
+    typedef typename Graph::NodeIt NodeIt;
+    typedef typename Graph::EdgeIt EdgeIt;
+  
+    typedef typename Graph::EachNodeIt EachNodeIt;
+    
+    //FIXME tag-ekkel megcsinalni, hogy abbol csinaljon
+    //iranyitatlant, ami van
+    //mert csak 1 dolgot lehet be typedef-elni
+    typedef typename Graph::OutEdgeIt SymEdgeIt;
+    //typedef typename Graph::InEdgeIt SymEdgeIt;
+    //typedef typename Graph::SymEdgeIt SymEdgeIt;
+    typedef typename Graph::EachEdgeIt EachEdgeIt;
+
+    int nodeNum() const { return graph->nodeNum(); }
+    int edgeNum() const { return graph->edgeNum(); }
+    
+    template<typename I> I& getFirst(I& i) const { return graph->getFirst(i); }
+    template<typename I, typename P> I& getFirst(I& i, const P& p) const { 
+      return graph->getFirst(i, p); }
+    //template<typename I> I next(const I i); { return graph->goNext(i); }
+    //template<typename I> I &goNext(I &i); { return graph->goNext(i); }
+
+    template< typename It > It first() const { 
+      It e; getFirst(e); return e; }
+
+    template< typename It > It first(NodeIt v) const { 
+      It e; getFirst(e, v); return e; }
+
+    NodeIt head(const EdgeIt& e) const { return graph->head(e); }
+    NodeIt tail(const EdgeIt& e) const { return graph->tail(e); }
+  
+    template<typename I> NodeIt aNode(const I& e) const { 
+      return graph->aNode(e); }
+    template<typename I> NodeIt bNode(const I& e) const { 
+      return graph->bNode(e); }
+  
+    //template<typename I> bool valid(const I i);
+    //{ return graph->valid(i); }
+  
+    //template<typename I> void setInvalid(const I &i);
+    //{ return graph->setInvalid(i); }
+  
+    NodeIt addNode() { return graph->addNode(); }
+    EdgeIt addEdge(const NodeIt& tail, const NodeIt& head) { 
+      return graph->addEdge(tail, head); }
+  
+    template<typename I> void erase(const I& i) { graph->erase(i); }
+  
+    void clear() { graph->clear(); }
+  
+    template<typename T> class NodeMap : public Graph::NodeMap<T> { };
+    template<typename T> class EdgeMap : public Graph::EdgeMap<T> { };
+  
+    void setGraph(Graph& _graph) { graph = &_graph; }
+    Graph& getGraph() { return (*graph); }
+
+    //SymGraphWrapper() : graph(0) { }
+    SymGraphWrapper(Graph& _graph) : graph(&_graph) { }
+  };
+
+
+// FIXME: comparison should be made better!!!
+  template<typename Graph, typename T, typename LowerMap, typename FlowMap, typename UpperMap>
+  class ResGraphWrapper
+  {
+    Graph* graph;
+  
+  public:
+    typedef Graph BaseGraph;
+
+    typedef typename Graph::NodeIt NodeIt;
+    typedef typename Graph::EdgeIt EdgeIt;
+  
+    typedef typename Graph::EachNodeIt EachNodeIt;
+   
+    class OutEdgeIt {
+    public:
+      //Graph::NodeIt n;
+      bool out_or_in;
+      typename Graph::OutEdgeIt o;
+      typename Graph::InEdgeIt i;   
+    };
+    class InEdgeIt {
+    public:
+      //Graph::NodeIt n;
+      bool out_or_in;
+      typename Graph::OutEdgeIt o;
+      typename Graph::InEdgeIt i;   
+    };
+    typedef typename Graph::SymEdgeIt SymEdgeIt;
+    typedef typename Graph::EachEdgeIt EachEdgeIt;
+
+    int nodeNum() const { return graph->nodeNum(); }
+    int edgeNum() const { return graph->edgeNum(); }
+
+    NodeIt& getFirst(NodeIt& n) const { return graph->getFirst(n); }
+
+    // EachEdge and SymEdge  is missing!!!!
+    // EdgeIt <-> In/OutEdgeIt conversion is missing!!!!
+
+    //FIXME
+    OutEdgeIt& getFirst(OutEdgeIt& e, const NodeIt& n) const 
+      {
+	e.n=n;
+	graph->getFirst(e.o,n);
+	while(graph->valid(e.o) && fmap.get(e.o)>=himap.get(e.o))
+	  graph->goNext(e.o);
+	if(!graph->valid(e.o)) {
+	  graph->getFirst(e.i,n);
+	  while(graph->valid(e.i) && fmap.get(e.i)<=lomap.get(e.i))
+	    graph->goNext(e.i);
+	}
+	return e;
+      }
+/*
+  OutEdgeIt &goNext(OutEdgeIt &e)
+  {
+  if(graph->valid(e.o)) {
+  while(graph->valid(e.o) && fmap.get(e.o)>=himap.get(e.o))
+  graph->goNext(e.o);
+  if(graph->valid(e.o)) return e;
+  else graph->getFirst(e.i,e.n);
+  }
+  else {
+  while(graph->valid(e.i) && fmap.get(e.i)<=lomap.get(e.i))
+  graph->goNext(e.i);
+  return e;
+  }
+  }
+  OutEdgeIt Next(const OutEdgeIt &e) {OutEdgeIt t(e); return goNext(t);}
+*/
+    //bool valid(const OutEdgeIt e) { return graph->valid(e.o)||graph->valid(e.i);}
+
+    //FIXME
+    InEdgeIt& getFirst(InEdgeIt& e, const NodeIt& n) const 
+      {
+	e.n=n;
+	graph->getFirst(e.i,n);
+	while(graph->valid(e.i) && fmap.get(e.i)>=himap.get(e.i))
+	  graph->goNext(e.i);
+	if(!graph->valid(e.i)) {
+	  graph->getFirst(e.o,n);
+	  while(graph->valid(e.o) && fmap.get(e.o)<=lomap.get(e.o))
+	    graph->goNext(e.o);
+	}
+	return e;
+      }
+/*
+  InEdgeIt &goNext(InEdgeIt &e)
+  {
+  if(graph->valid(e.i)) {
+  while(graph->valid(e.i) && fmap.get(e.i)>=himap.get(e.i))
+  graph->goNext(e.i);
+  if(graph->valid(e.i)) return e;
+  else graph->getFirst(e.o,e.n);
+  }
+  else {
+  while(graph->valid(e.o) && fmap.get(e.o)<=lomap.get(e.o))
+  graph->goNext(e.o);
+  return e;
+  }
+  }
+  InEdgeIt Next(const InEdgeIt &e) {InEdgeIt t(e); return goNext(t);}
+*/
+    //bool valid(const InEdgeIt e) { return graph->valid(e.i)||graph->valid(e.o);}
+
+    //template<typename I> I &goNext(I &i); { return graph->goNext(i); }
+    //template<typename I> I next(const I i); { return graph->goNext(i); }
+
+    template< typename It > It first() const { 
+      It e; getFirst(e); return e; }
+
+    template< typename It > It first(NodeIt v) const { 
+      It e; getFirst(e, v); return e; }
+
+    NodeIt head(const EdgeIt& e) const { return graph->head(e); }
+    NodeIt tail(const EdgeIt& e) const { return graph->tail(e); }
+  
+    template<typename I> NodeIt aNode(const I& e) const { 
+      return graph->aNode(e); }
+    template<typename I> NodeIt bNode(const I& e) const { 
+      return graph->bNode(e); }
+  
+    //template<typename I> bool valid(const I i);
+    //{ return graph->valid(i); }
+  
+    //template<typename I> void setInvalid(const I &i);
+    //{ return graph->setInvalid(i); }
+  
+    NodeIt addNode() { return graph->addNode(); }
+    EdgeIt addEdge(const NodeIt& tail, const NodeIt& head) { 
+      return graph->addEdge(tail, head); }
+  
+    template<typename I> void erase(const I& i) { graph->erase(i); }
+  
+    void clear() { graph->clear(); }
+  
+    template<typename S> class NodeMap : public Graph::NodeMap<S> { };
+    template<typename S> class EdgeMap : public Graph::EdgeMap<S> { };
+  
+    void setGraph(Graph& _graph) { graph = &_graph; }
+    Graph& getGraph() { return (*graph); }
+
+    //ResGraphWrapper() : graph(0) { }
+    ResGraphWrapper(Graph& _graph) : graph(&_graph) { }
+  };
+
+
+// FIXME: comparison should be made better!!!
+  template<typename Graph, typename T, typename LowerMap, typename FlowMap, typename UpperMap>
+  class ConstResGraphWrapper
+  {
+    const Graph* graph;
+    const LowerMap* low;
+    FlowMap* flow;
+    const UpperMap* up;
+  public:
+    typedef Graph BaseGraph;
+
+    typedef typename Graph::NodeIt NodeIt;
+    typedef typename Graph::EdgeIt EdgeIt;
+  
+    typedef typename Graph::EachNodeIt EachNodeIt;
+   
+    class OutEdgeIt {
+    public:
+      //Graph::NodeIt n;
+      bool out_or_in;
+      typename Graph::SymEdgeIt sym;
+    };
+    class InEdgeIt {
+    public:
+      //Graph::NodeIt n;
+      bool out_or_in;
+      typename Graph::OutEdgeIt sym;
+    };
+    //typedef typename Graph::SymEdgeIt SymEdgeIt;
+    //typedef typename Graph::EachEdgeIt EachEdgeIt;
+
+    int nodeNum() const { return graph->nodeNum(); }
+    //int edgeNum() const { return graph->edgeNum(); }
+
+    NodeIt& getFirst(NodeIt& n) const { return graph->getFirst(n); }
+
+    // EachEdge and SymEdge  is missing!!!!
+    // EdgeIt <-> In/OutEdgeIt conversion is missing!!!!
+
+    
+    //FIXME
+    OutEdgeIt& getFirst(OutEdgeIt& e, const NodeIt& n) const 
+      {
+	e.n=n;
+	graph->getFirst(e.o,n);
+	while(graph->valid(e.o) && fmap.get(e.o)>=himap.get(e.o))
+	  graph->goNext(e.o);
+	if(!graph->valid(e.o)) {
+	  graph->getFirst(e.i,n);
+	  while(graph->valid(e.i) && fmap.get(e.i)<=lomap.get(e.i))
+	    graph->goNext(e.i);
+	}
+	return e;
+      }
+/*
+  OutEdgeIt &goNext(OutEdgeIt &e)
+  {
+  if(graph->valid(e.o)) {
+  while(graph->valid(e.o) && fmap.get(e.o)>=himap.get(e.o))
+  graph->goNext(e.o);
+  if(graph->valid(e.o)) return e;
+  else graph->getFirst(e.i,e.n);
+  }
+  else {
+  while(graph->valid(e.i) && fmap.get(e.i)<=lomap.get(e.i))
+  graph->goNext(e.i);
+  return e;
+  }
+  }
+  OutEdgeIt Next(const OutEdgeIt &e) {OutEdgeIt t(e); return goNext(t);}
+*/
+    //bool valid(const OutEdgeIt e) { return graph->valid(e.o)||graph->valid(e.i);}
+
+    //FIXME
+    InEdgeIt& getFirst(InEdgeIt& e, const NodeIt& n) const 
+      {
+	e.n=n;
+	graph->getFirst(e.i,n);
+	while(graph->valid(e.i) && fmap.get(e.i)>=himap.get(e.i))
+	  graph->goNext(e.i);
+	if(!graph->valid(e.i)) {
+	  graph->getFirst(e.o,n);
+	  while(graph->valid(e.o) && fmap.get(e.o)<=lomap.get(e.o))
+	    graph->goNext(e.o);
+	}
+	return e;
+      }
+/*
+  InEdgeIt &goNext(InEdgeIt &e)
+  {
+  if(graph->valid(e.i)) {
+  while(graph->valid(e.i) && fmap.get(e.i)>=himap.get(e.i))
+  graph->goNext(e.i);
+  if(graph->valid(e.i)) return e;
+  else graph->getFirst(e.o,e.n);
+  }
+  else {
+  while(graph->valid(e.o) && fmap.get(e.o)<=lomap.get(e.o))
+  graph->goNext(e.o);
+  return e;
+  }
+  }
+  InEdgeIt Next(const InEdgeIt &e) {InEdgeIt t(e); return goNext(t);}
+*/
+    //bool valid(const InEdgeIt e) { return graph->valid(e.i)||graph->valid(e.o);}
+
+    //template<typename I> I &goNext(I &i); { return graph->goNext(i); }
+    //template<typename I> I next(const I i); { return graph->goNext(i); }
+
+    template< typename It > It first() const { 
+      It e; getFirst(e); return e; }
+
+    template< typename It > It first(NodeIt v) const { 
+      It e; getFirst(e, v); return e; }
+
+    NodeIt head(const EdgeIt& e) const { return graph->head(e); }
+    NodeIt tail(const EdgeIt& e) const { return graph->tail(e); }
+  
+    template<typename I> NodeIt aNode(const I& e) const { 
+      return graph->aNode(e); }
+    template<typename I> NodeIt bNode(const I& e) const { 
+      return graph->bNode(e); }
+  
+    //template<typename I> bool valid(const I i);
+    //{ return graph->valid(i); }
+  
+    //template<typename I> void setInvalid(const I &i);
+    //{ return graph->setInvalid(i); }
+  
+    NodeIt addNode() { return graph->addNode(); }
+    EdgeIt addEdge(const NodeIt& tail, const NodeIt& head) { 
+      return graph->addEdge(tail, head); }
+  
+    template<typename I> void erase(const I& i) { graph->erase(i); }
+  
+    void clear() { graph->clear(); }
+  
+    template<typename S> class NodeMap : public Graph::NodeMap<S> { };
+    template<typename S> class EdgeMap : public Graph::EdgeMap<S> { };
+  
+    void setGraph(const Graph& _graph) { graph = &_graph; }
+    const Graph& getGraph() { return (*graph); }
+
+    //ConstResGraphWrapper() : graph(0) { }
+    ConstResGraphWrapper(const Graph& _graph) : graph(&_graph) { }
+  };
+
+
+
+
+
+} //namespace marci
+
+#endif //GRAPH_WRAPPER_H
+
+
+//   NodeIt &getFirst(NodeIt &n) { return graph->getFirst(n); }
+//   InEdgeIt &getFirst(InEdgeIt &e,const NodeIt &n);
+//   { return graph->getFirst(e,n); }
+//   OutEdgeIt &getFirst(OutEdgeIt &e,const NodeIt &n);
+//   { return graph->getFirst(e,n); }
+//   SymEdgeIt &getFirst(SymEdgeIt &e,const NodeIt &n);
+//   { return graph->getFirst(e,n); }
+//   EachEdgeIt &getFirst(EachEdgeIt &e);
+//   { return graph->getFirst(e); }
+   
+//   NodeIt next(const NodeIt &n);
+//   { return graph->next(n); }
+//   InEdgeIt next(const InEdgeIt &e);
+//   { return graph->next(e); }
+//   OutEdgeIt next(const OutEdgeIt &e);
+//   { return graph->next(e); }
+//   SymEdgeIt next(const SymEdgeIt &e);
+//   { return graph->next(e); }
+//   EachEdgeIt next(const EachEdgeIt &e);
+//   { return graph->next(e); }
+ 
+//   NodeIt &goNext(NodeIt &n);
+//   { return graph->goNext(n); }
+//   InEdgeIt &goNext(InEdgeIt &e);
+//   { return graph->goNext(e); }
+//   OutEdgeIt &goNext(OutEdgeIt &e);
+//   { return graph->goNext(e); }
+//   SymEdgeIt &goNext(SymEdgeIt &e);
+//   { return graph->goNext(e); }
+//   EachEdgeIt &goNext(EachEdgeIt &e);
+//   { return graph->goNext(e); }
+