Changeset 1021:fd1d073b6557 in lemon-0.x for src/lemon/concept/graph_component.h

Timestamp:

11/25/04 15:48:24 (19 years ago)

Author:

Mihaly Barasz

Branch:

default

Phase:

public

Convert:

svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@1411

Message:

Advances in UndirGraph?.

• IterableExtender? is complete

File:

• src/lemon/concept/graph_component.h (modified) (5 diffs)

src/lemon/concept/graph_component.h

@@ -506 +506 @@
     /// InEdgeIt you should instantiate it with character 'i' and for 
     /// OutEdgeIt with 'o'.
-    /// \todo check the name of the concept GraphIncEdgeIterator
-    template <typename _Graph, char _selector>
-    class GraphIncEdgeIterator : public _Graph::Edge {
+    /// \todo Is this a good name for this concept?
+    template <typename Graph,
+              typename Edge = typename Graph::Edge,
+              char _selector = '0'>
+    class GraphIncIterator : public Edge {
     public:
       /// Default constructor.
@@ -514 +516 @@
       /// @warning The default constructor sets the iterator
       /// to an undefined value.
-      GraphIncEdgeIterator() {}
+      GraphIncIterator() {}
       /// Copy constructor.
       
       /// Copy constructor.
       ///
-      GraphIncEdgeIterator(GraphIncEdgeIterator const&) {}
+      GraphIncIterator(GraphIncIterator const&) {}
       /// Sets the iterator to the first edge incoming into or outgoing from the node.
       
       /// Sets the iterator to the first edge incoming into or outgoing from the node.
       ///
-      explicit GraphIncEdgeIterator(const _Graph&, const typename _Graph::Node&) {}
+      explicit GraphIncIterator(const Graph&, const typename Graph::Node&) {}
       /// Invalid constructor \& conversion.
 
       /// This constructor initializes the item to be invalid.
       /// \sa Invalid for more details.
-      GraphIncEdgeIterator(Invalid) {}
+      GraphIncIterator(Invalid) {}
       /// Assign operator for nodes.
 
       /// The nodes are assignable. 
       ///
-      GraphIncEdgeIterator& operator=(GraphIncEdgeIterator const&) { return *this; }      
+      GraphIncIterator& operator=(GraphIncIterator const&) { return *this; }      
       /// Next edge.
 
       /// Assign the iterator to the next node.
       ///
-      GraphIncEdgeIterator& operator++() { return *this; }
+      GraphIncIterator& operator++() { return *this; }
+
       //        Node operator*() const { return INVALID; }
+
       /// Equality operator
 
       /// Two iterators are equal if and only if they point to the
       /// same object or both are invalid.
-      bool operator==(const GraphIncEdgeIterator&) const { return true;}
+      bool operator==(const GraphIncIterator&) const { return true;}
+
       /// Inequality operator
         
       /// \sa operator==(Node n)
       ///
-      bool operator!=(const GraphIncEdgeIterator&) const { return true;}
-
-      template <typename _GraphIncEdgeIterator>
-      struct Constraints {
-        typedef typename _Graph::Node Node;
-        typedef typename _Graph::Edge Edge;
-        void constraints() {
-          checkConcept<GraphItem<'e'>, _GraphIncEdgeIterator>();
-          _GraphIncEdgeIterator it1(graph, node);
+      bool operator!=(const GraphIncIterator&) const { return true;}
+
+      template <typename _GraphIncIterator>
+      struct Constraints {
+        typedef typename Graph::Node Node;
+        void constraints() {
+          checkConcept<GraphItem<'e'>, _GraphIncIterator>();
+          _GraphIncIterator it1(graph, node);
           /// \todo Do we need OutEdgeIt(Edge) kind of constructor?
-          //    _GraphIncEdgeIterator it2(edge);
-          _GraphIncEdgeIterator it2;
+          //    _GraphIncIterator it2(edge);
+          _GraphIncIterator it2;
 
           it2 = ++it1;
@@ -572 +576 @@
         Edge& edge;
         Node& node;
-        _Graph& graph;
-      };
-    };
+        Graph& graph;
+      };
+    };
+
+
     /// An empty iterable base graph class.
   
@@ -603 +609 @@
       /// This iterator goes trough the \e inccoming edges of a certain node
       /// of a graph.
-      typedef GraphIncEdgeIterator<Graph, 'i'> InEdgeIt;
+      typedef GraphIncIterator<Graph, Edge, 'i'> InEdgeIt;
       /// This iterator goes trough the outgoing edges of a node.
 
       /// This iterator goes trough the \e outgoing edges of a certain node
       /// of a graph.
-      typedef GraphIncEdgeIterator<Graph, 'o'> OutEdgeIt;
+      typedef GraphIncIterator<Graph, Edge, 'o'> OutEdgeIt;
     };
     
@@ -618 +624 @@
         checkConcept<GraphIterator<_Graph, typename _Graph::Edge>, typename _Graph::EdgeIt >();
         checkConcept<GraphIterator<_Graph, typename _Graph::Node>, typename _Graph::NodeIt >();
-        checkConcept<GraphIncEdgeIterator<_Graph, 'i'>, typename _Graph::InEdgeIt >();
-        checkConcept<GraphIncEdgeIterator<_Graph, 'o'>, typename _Graph::OutEdgeIt >();
+        checkConcept<GraphIncIterator<_Graph>, typename _Graph::InEdgeIt >();
+        checkConcept<GraphIncIterator<_Graph>, typename _Graph::OutEdgeIt >();
       }
     };