Index: lemon/concept/bpugraph.h
===================================================================
--- lemon/concept/bpugraph.h	(revision 1911)
+++ lemon/concept/bpugraph.h	(revision 1933)
@@ -57,7 +57,9 @@
     ///
     /// The bipartite graph stores two types of nodes which are named
-    /// ANode and BNode. Even so the graph type does not contain ANode
-    /// and BNode classes, becaue the nodes can be accessed just with the
-    /// common Node class. 
+    /// ANode and BNode. The graph type contains two types ANode and BNode
+    /// which are inherited from Node type. Moreover they have
+    /// constructor which converts Node to either ANode or BNode when it is
+    /// possible. Therefor everywhere the Node type can be used instead of
+    /// ANode and BNode. So the usage of the ANode and BNode is suggested.  
     ///
     /// The iteration on the partition can be done with the ANodeIt and 
@@ -123,4 +125,118 @@
 
       };
+
+      /// \brief The base type of anode iterators, 
+      /// or in other words, the trivial anode iterator.
+      ///
+      /// This is the base type of each anode iterator,
+      /// thus each kind of anode iterator converts to this.
+      /// More precisely each kind of node iterator should be inherited 
+      /// from the trivial anode iterator. The ANode class should be used
+      /// only in special cases. Usually the Node type should be used insted
+      /// of it. 
+      class ANode {
+      public:
+        /// Default constructor
+
+        /// @warning The default constructor sets the iterator
+        /// to an undefined value.
+        ANode() { }
+        /// Copy constructor.
+
+        /// Copy constructor.
+        ///
+        ANode(const ANode&) { }
+
+        /// Construct the same node as ANode.
+
+        /// Construct the same node as ANode. It may throws assertion
+        /// when the given node is from the BNode set.
+        ANode(const Node&) { }
+
+        /// Invalid constructor \& conversion.
+
+        /// This constructor initializes the iterator to be invalid.
+        /// \sa Invalid for more details.
+        ANode(Invalid) { }
+        /// Equality operator
+
+        /// Two iterators are equal if and only if they point to the
+        /// same object or both are invalid.
+        bool operator==(ANode) const { return true; }
+
+        /// Inequality operator
+        
+        /// \sa operator==(ANode n)
+        ///
+        bool operator!=(ANode) const { return true; }
+
+	/// Artificial ordering operator.
+	
+	/// To allow the use of graph descriptors as key type in std::map or
+	/// similar associative container we require this.
+	///
+	/// \note This operator only have to define some strict ordering of
+	/// the items; this order has nothing to do with the iteration
+	/// ordering of the items.
+	bool operator<(ANode) const { return false; }
+
+      };
+
+      /// \brief The base type of bnode iterators, 
+      /// or in other words, the trivial bnode iterator.
+      ///
+      /// This is the base type of each anode iterator,
+      /// thus each kind of anode iterator converts to this.
+      /// More precisely each kind of node iterator should be inherited 
+      /// from the trivial anode iterator. The BNode class should be used
+      /// only in special cases. Usually the Node type should be used insted
+      /// of it. 
+      class BNode {
+      public:
+        /// Default constructor
+
+        /// @warning The default constructor sets the iterator
+        /// to an undefined value.
+        BNode() { }
+        /// Copy constructor.
+
+        /// Copy constructor.
+        ///
+        BNode(const BNode&) { }
+
+        /// Construct the same node as BNode.
+
+        /// Construct the same node as BNode. It may throws assertion
+        /// when the given node is from the ANode set.
+        BNode(const Node&) { }
+
+        /// Invalid constructor \& conversion.
+
+        /// This constructor initializes the iterator to be invalid.
+        /// \sa Invalid for more details.
+        BNode(Invalid) { }
+        /// Equality operator
+
+        /// Two iterators are equal if and only if they point to the
+        /// same object or both are invalid.
+        bool operator==(BNode) const { return true; }
+
+        /// Inequality operator
+        
+        /// \sa operator==(BNode n)
+        ///
+        bool operator!=(BNode) const { return true; }
+
+	/// Artificial ordering operator.
+	
+	/// To allow the use of graph descriptors as key type in std::map or
+	/// similar associative container we require this.
+	///
+	/// \note This operator only have to define some strict ordering of
+	/// the items; this order has nothing to do with the iteration
+	/// ordering of the items.
+	bool operator<(BNode) const { return false; }
+
+      };
     
       /// This iterator goes through each node.
@@ -178,5 +294,5 @@
       /// for (Graph::ANodeIt n(g); n!=INVALID; ++n) ++count;
       /// \endcode
-      class ANodeIt : public Node {
+      class ANodeIt : public ANode {
       public:
         /// Default constructor
@@ -223,5 +339,5 @@
       /// for (Graph::BNodeIt n(g); n!=INVALID; ++n) ++count;
       /// \endcode
-      class BNodeIt : public Node {
+      class BNodeIt : public BNode {
       public:
         /// Default constructor
