# HG changeset patch
# User marci
# Date 1082137159 0
# Node ID 6046b1d0f2671370f286c76a9d30fff81f5157ef
# Parent  a2ce3c4780b7f31d4d3ba250b88879ca3c22a5cd
semmi

diff -r a2ce3c4780b7 -r 6046b1d0f267 src/work/marci/graph_wrapper.h
--- a/src/work/marci/graph_wrapper.h	Fri Apr 16 13:42:03 2004 +0000
+++ b/src/work/marci/graph_wrapper.h	Fri Apr 16 17:39:19 2004 +0000
@@ -852,6 +852,185 @@
     }
   };
 
+
+
+//   /// experimentral, do not try it.
+//   template<typename Graph>
+//   class stGraphWrapper : public GraphWrapper<Graph> {
+//   public:
+//     class Node;
+//     class NodeIt;
+//     class Edge;
+//     class OutEdgeIt;
+//     class InEdgeIt;
+//     class EdgeIt;
+
+//     const Node s;
+//     const Node t;
+
+//     stGraphWrapper(Graph& _graph) : GraphWrapper<Graph>(_graph), 
+// 				    s(INVALID, 1), t(INVALID, 2) { }
+
+//     class Node : public Graph::Node {
+//       friend class GraphWrapper<Graph>;
+//       friend class stGraphWrapper<Graph>;
+//     protected:
+//       int spec; //0 if real node, 1 iff s, 2 iff t
+//     public:
+//       Node() { }
+//       Node(const typename Graph::Node& _n, int _spec=0) : 
+// 	Graph::Node(_n), spec(_spec) { }
+//       Node(const Invalid& i) : Graph::Node(i), spec(2) { }
+//       //invalid: (invalid, 2);
+//     };
+
+//     class NodeIt { 
+//       friend class GraphWrapper<Graph>;
+//       friend class stGraphWrapper<Graph>;
+//       typename Graph::NodeIt n;
+//       int spec; 
+//      public:
+//       NodeIt() { }
+//       NodeIt(const typename Graph::NodeIt& _n, int _spec=0) : 
+// 	n(_n), spec(_spec) { }
+//       NodeIt(const Invalid& i) : n(i), spec(2) { }
+//       NodeIt(const GraphWrapper<Graph>& _G) : n(*(_G.graph)), spec(0) { 
+// 	if (!_G->valid(n)) spec=1;
+//       }
+//       operator Node() const { return Node(n, spec); }
+//     };
+// //    typedef typename Graph::Edge Edge;
+//     class Edge : public Graph::Edge {
+//       friend class GraphWrapper<Graph>;
+//       friend class stGraphWrapper<Graph>;
+//       Node tail_spec;
+//       Node head_spec;
+//     public:
+//       Edge() { }
+//       Edge(const typename Graph::Edge& _e) : 
+// 	Graph::Edge(_e), tail_spec(i, 0), head_spec(i, 0) { 
+// 	//a tail-t es a head-et real node-ra csinaljuk
+//       }
+//       Edge(const Invalid& i) : Graph::Edge(i), tail_spec(i), head_spec(i) { }
+//     };
+//     class OutEdgeIt { 
+//       friend class GraphWrapper<Graph>;
+//       friend class stGraphWrapper<Graph>;
+//       typename Graph::OutEdgeIt e;
+//       Node tail_spec;
+//       Node head_spec;
+//     public:
+//       OutEdgeIt() { }
+//       OutEdgeIt(const typename Graph::OutEdgeIt& _e) : 
+// 	e(_e), tail_spec(i, 0), head_spec(i, 0) { 
+// 	//a tail-t es a head-et real node-ra csinaljuk
+//       }
+//       OutEdgeIt(const Invalid& i) : e(i), tail_spec(i), head_spec(i) { }
+//       //invalid: (barmi, 0, 2)
+//       OutEdgeIt(const GraphWrapper<Graph>& _G, const Node& _n) {
+// 	switch (_n.spec) {
+// 	case 0 : 
+// 	  e=typename Graph::OutEdgeIt(*(_G.graph), typename Graph::Node(_n)); 
+// 	  _tail.spec=0;
+// 	  _head.spec=0;
+// 	  if (!_G.graph->valid(e)) spec=1;
+// 	  break;
+// 	case 1:
+// 	  e=INVALID;
+// 	  _tail.spec=1;
+// 	  _head(_G.graph->first(typename Graph::NodeIt()));
+// 	  if _head.spec==1
+// 	  break;
+// 	};
+	
+// 	  }
+//       operator Edge() const { return Edge(typename Graph::Edge(e)); }
+//     };
+//     class InEdgeIt { 
+//       friend class GraphWrapper<Graph>;
+//       typename Graph::InEdgeIt e;
+//     public:
+//       InEdgeIt() { }
+//       InEdgeIt(const typename Graph::InEdgeIt& _e) : e(_e) { }
+//       InEdgeIt(const Invalid& i) : e(i) { }
+//       InEdgeIt(const GraphWrapper<Graph>& _G, const Node& _n) : 
+// 	e(*(_G.graph), typename Graph::Node(_n)) { }
+//       operator Edge() const { return Edge(typename Graph::Edge(e)); }
+//     };
+//     //typedef typename Graph::SymEdgeIt SymEdgeIt;
+//     class EdgeIt { 
+//       friend class GraphWrapper<Graph>;
+//       typename Graph::EdgeIt e;
+//     public:
+//       EdgeIt() { }
+//       EdgeIt(const typename Graph::EdgeIt& _e) : e(_e) { }
+//       EdgeIt(const Invalid& i) : e(i) { }
+//       EdgeIt(const GraphWrapper<Graph>& _G) : e(*(_G.graph)) { }
+//       operator Edge() const { return Edge(typename Graph::Edge(e)); }
+//     };
+   
+//     NodeIt& first(NodeIt& i) const { 
+//       i=NodeIt(*this); return i;
+//     }
+//     OutEdgeIt& first(OutEdgeIt& i, const Node& p) const { 
+//       i=OutEdgeIt(*this, p); return i;
+//     }
+//     InEdgeIt& first(InEdgeIt& i, const Node& p) const { 
+//       i=InEdgeIt(*this, p); return i;
+//     }
+//     EdgeIt& first(EdgeIt& i) const { 
+//       i=EdgeIt(*this); return i;
+//     }
+
+//     NodeIt& next(NodeIt& i) const { graph->next(i.n); return i; }
+//     OutEdgeIt& next(OutEdgeIt& i) const { graph->next(i.e); return i; }
+//     InEdgeIt& next(InEdgeIt& i) const { graph->next(i.e); return i; }
+//     EdgeIt& next(EdgeIt& i) const { graph->next(i.e); return i; }    
+
+//     Node head(const Edge& e) const { 
+//       return Node(graph->head(static_cast<typename Graph::Edge>(e))); }
+//     Node tail(const Edge& e) const { 
+//       return Node(graph->tail(static_cast<typename Graph::Edge>(e))); }
+
+//     bool valid(const Node& n) const { 
+//       return graph->valid(static_cast<typename Graph::Node>(n)); }
+//     bool valid(const Edge& e) const { 
+//       return graph->valid(static_cast<typename Graph::Edge>(e)); }
+
+//     int nodeNum() const { return graph->nodeNum(); }
+//     int edgeNum() const { return graph->edgeNum(); }
+  
+//     Node aNode(const OutEdgeIt& e) const { return Node(graph->aNode(e.e)); }
+//     Node aNode(const InEdgeIt& e) const { return Node(graph->aNode(e.e)); }
+//     Node bNode(const OutEdgeIt& e) const { return Node(graph->bNode(e.e)); }
+//     Node bNode(const InEdgeIt& e) const { return Node(graph->bNode(e.e)); }
+  
+//     Node addNode() const { return Node(graph->addNode()); }
+//     Edge addEdge(const Node& tail, const Node& head) const { 
+//       return Edge(graph->addEdge(tail, head)); }
+
+//     void erase(const Node& i) const { graph->erase(i); }
+//     void erase(const Edge& i) const { graph->erase(i); }
+  
+//     void clear() const { graph->clear(); }
+    
+//     template<typename T> class NodeMap : public Graph::NodeMap<T> { 
+//     public:
+//       NodeMap(const GraphWrapper<Graph>& _G) :  
+// 	Graph::NodeMap<T>(*(_G.graph)) { }
+//       NodeMap(const GraphWrapper<Graph>& _G, T a) : 
+// 	Graph::NodeMap<T>(*(_G.graph), a) { }
+//     };
+
+//     template<typename T> class EdgeMap : public Graph::EdgeMap<T> { 
+//     public:
+//       EdgeMap(const GraphWrapper<Graph>& _G) :  
+// 	Graph::EdgeMap<T>(*(_G.graph)) { }
+//       EdgeMap(const GraphWrapper<Graph>& _G, T a) : 
+// 	Graph::EdgeMap<T>(*(_G.graph), a) { }
+//     };
+//   };
+
 } //namespace hugo
 
 #endif //HUGO_GRAPH_WRAPPER_H