diff -r 289d80c33f04 -r 1a770e9f80b2 src/lemon/undir_graph_extender.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/lemon/undir_graph_extender.h	Fri Nov 05 00:31:49 2004 +0000
@@ -0,0 +1,193 @@
+/* -*- C++ -*-
+ *
+ * src/lemon/undir_graph_extender.h - Part of LEMON, a generic C++
+ * optimization library
+ *
+ * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi
+ * Kutatocsoport (Egervary Combinatorial Optimization Research Group,
+ * EGRES).
+ *
+ * Permission to use, modify and distribute this software is granted
+ * provided that this copyright notice appears in all copies. For
+ * precise terms see the accompanying LICENSE file.
+ *
+ * This software is provided "AS IS" with no warranty of any kind,
+ * express or implied, and with no claim as to its suitability for any
+ * purpose.
+ *
+ */
+
+#ifndef LEMON_UNDIR_GRAPH_EXTENDER_H
+#define LEMON_UNDIR_GRAPH_EXTENDER_H
+
+#include <lemon/invalid.h>
+
+namespace lemon {
+
+  template <typename _Base>
+  class UndirGraphExtender : public _Base {
+    typedef _Base Parent;
+    typedef UndirGraphExtender Graph;
+
+  public:
+
+    typedef typename Parent::Edge UndirEdge;
+    typedef typename Parent::Node Node;
+
+    class Edge : public UndirEdge {
+      friend class Graph;
+
+    protected:
+      // FIXME: Marci use opposite logic in his graph wrappers. It would
+      // be reasonable to syncronize...
+      bool forward;
+
+    public:
+      Edge() {}
+      /// Construct a direct edge from undirect edge and a direction.
+      Edge(const UndirEdge &ue, bool _forward) :
+	UndirEdge(ue), forward(_forward) {}
+      /// Invalid edge constructor
+      Edge(Invalid i) : UndirEdge(i), forward(false) {}
+
+      bool operator==(const Edge &that) const {
+	return forward==that.forward && UndirEdge(*this)==UndirEdge(that);
+      }
+      bool operator!=(const Edge &that) const {
+	return forward!=that.forward || UndirEdge(*this)!=UndirEdge(that);
+      }
+      bool operator<(const Edge &that) const {
+	return forward<that.forward ||
+	  (!(that.forward<forward) && UndirEdge(*this)<UndirEdge(that));
+      }
+    };
+
+
+    /// \brief Returns the Edge of opposite direction.
+    ///
+    /// \bug Is this a good name for this? Or "reverse" is better?
+    Edge opposite(const Edge &e) const {
+      return Edge(e,!e.forward);
+    }
+
+    /// Tail of the given Edge.
+    Node tail(const Edge &e) const {
+      return e.forward ? Parent::tail(e) : Parent::head(e);
+    }
+
+    /// \todo Shouldn't the "tail" of an undirected edge be called "aNode"
+    /// or something???
+    using Parent::tail;
+
+    /// Head of the given Edge.
+    Node head(const Edge &e) const {
+      return e.forward ? Parent::head(e) : Parent::tail(e);
+    }
+
+    /// \todo Shouldn't the "head" of an undirected edge be called "bNode"
+    /// or something???
+    using Parent::head;
+
+    /// Returns whether the given directed edge is same orientation as the
+    /// corresponding undirected edge.
+    ///
+    /// \todo reference to the corresponding point of the undirected graph
+    /// concept. "What does the direction of an undirected edge mean?"
+    bool forward(const Edge &e) const { return e.forward; }
+
+    Node oppsiteNode(const Node &n, const Edge &e) const {
+      if( n == Parent::tail(e))
+	return Parent::head(e);
+      else if( n == Parent::head(e))
+	return Parent::tail(e);
+      else
+	return INVALID;
+    }
+
+
+    using Parent::first;
+    void first(Edge &e) const {
+      Parent::first(e);
+      e.forward=true;
+    }
+
+    using Parent::next;
+    void next(Edge &e) const {
+      if( e.forward ) {
+	e.forward = false;
+      }
+      else {
+	Parent::next(e);
+	e.forward = true;
+      }
+    }
+
+    void firstOut(Edge &e, const Node &n) const {
+      Parent::firstOut(e,n);
+      if( UndirEdge(e) != INVALID ) {
+	e.forward = true;
+      }
+      else {
+	Parent::firstIn(e,n);
+	e.forward = false;
+      }
+    }
+    void firstIn(Edge &e, const Node &n) const {
+      Parent::firstIn(e,n);
+      if( UndirEdge(e) != INVALID ) {
+	e.forward = true;
+      }
+      else {
+	Parent::firstOut(e,n);
+	e.forward = false;
+      }
+    }
+
+    void nextOut(Edge &e) const {
+      if( e.forward ) {
+	Parent::nextOut(e);
+	if( UndirEdge(e) == INVALID ) {
+	  Parent::firstIn(e, Parent::tail(e));
+	  e.forward = false;
+	}
+      }
+      else {
+	Parent::nextIn(e);
+      }
+    }
+    void nextIn(Edge &e) const {
+      if( e.forward ) {
+	Parent::nextIn(e);
+	if( UndirEdge(e) == INVALID ) {
+	  Parent::firstOut(e, Parent::head(e));
+	  e.forward = false;
+	}
+      }
+      else {
+	Parent::nextOut(e);
+      }
+    }
+
+    // Miscellaneous stuff:
+
+    /// \todo these methods (id, maxEdgeId) should be moved into separate
+    /// Extender
+
+    using Parent::id;
+
+    int id(const Edge &e) const {
+      return 2*Parent::id(e) + int(e.forward);
+    }
+
+    int maxEdgeId() const {
+      return 2*Parent::maxEdgeId() + 1;
+    }
+    int maxUndirEdgeId() const {
+      return Parent::maxEdgeId();
+    }
+
+  };
+
+}
+
+#endif // LEMON_UNDIR_GRAPH_EXTENDER_H