Index: lemon/bits/graph_extender.h
===================================================================
--- lemon/bits/graph_extender.h	(revision 1025)
+++ lemon/bits/graph_extender.h	(revision 1026)
@@ -914,20 +914,20 @@
     };
 
-    class RedIt : public RedNode {
+    class RedNodeIt : public RedNode {
       const BpGraph* _graph;
     public:
 
-      RedIt() {}
-
-      RedIt(Invalid i) : RedNode(i) { }
-
-      explicit RedIt(const BpGraph& graph) : _graph(&graph) {
+      RedNodeIt() {}
+
+      RedNodeIt(Invalid i) : RedNode(i) { }
+
+      explicit RedNodeIt(const BpGraph& graph) : _graph(&graph) {
         _graph->first(static_cast<RedNode&>(*this));
       }
 
-      RedIt(const BpGraph& graph, const RedNode& node)
+      RedNodeIt(const BpGraph& graph, const RedNode& node)
         : RedNode(node), _graph(&graph) {}
 
-      RedIt& operator++() {
+      RedNodeIt& operator++() {
         _graph->next(static_cast<RedNode&>(*this));
         return *this;
@@ -936,20 +936,20 @@
     };
 
-    class BlueIt : public BlueNode {
+    class BlueNodeIt : public BlueNode {
       const BpGraph* _graph;
     public:
 
-      BlueIt() {}
-
-      BlueIt(Invalid i) : BlueNode(i) { }
-
-      explicit BlueIt(const BpGraph& graph) : _graph(&graph) {
+      BlueNodeIt() {}
+
+      BlueNodeIt(Invalid i) : BlueNode(i) { }
+
+      explicit BlueNodeIt(const BpGraph& graph) : _graph(&graph) {
         _graph->first(static_cast<BlueNode&>(*this));
       }
 
-      BlueIt(const BpGraph& graph, const BlueNode& node)
+      BlueNodeIt(const BpGraph& graph, const BlueNode& node)
         : BlueNode(node), _graph(&graph) {}
 
-      BlueIt& operator++() {
+      BlueNodeIt& operator++() {
         _graph->next(static_cast<BlueNode&>(*this));
         return *this;
@@ -1145,21 +1145,21 @@
 
     template <typename _Value>
-    class RedMap
+    class RedNodeMap
       : public MapExtender<DefaultMap<BpGraph, RedNode, _Value> > {
       typedef MapExtender<DefaultMap<BpGraph, RedNode, _Value> > Parent;
 
     public:
-      explicit RedMap(const BpGraph& bpgraph)
+      explicit RedNodeMap(const BpGraph& bpgraph)
         : Parent(bpgraph) {}
-      RedMap(const BpGraph& bpgraph, const _Value& value)
+      RedNodeMap(const BpGraph& bpgraph, const _Value& value)
         : Parent(bpgraph, value) {}
 
     private:
-      RedMap& operator=(const RedMap& cmap) {
-        return operator=<RedMap>(cmap);
+      RedNodeMap& operator=(const RedNodeMap& cmap) {
+        return operator=<RedNodeMap>(cmap);
       }
 
       template <typename CMap>
-      RedMap& operator=(const CMap& cmap) {
+      RedNodeMap& operator=(const CMap& cmap) {
         Parent::operator=(cmap);
         return *this;
@@ -1169,21 +1169,21 @@
 
     template <typename _Value>
-    class BlueMap
+    class BlueNodeMap
       : public MapExtender<DefaultMap<BpGraph, BlueNode, _Value> > {
       typedef MapExtender<DefaultMap<BpGraph, BlueNode, _Value> > Parent;
 
     public:
-      explicit BlueMap(const BpGraph& bpgraph)
+      explicit BlueNodeMap(const BpGraph& bpgraph)
         : Parent(bpgraph) {}
-      BlueMap(const BpGraph& bpgraph, const _Value& value)
+      BlueNodeMap(const BpGraph& bpgraph, const _Value& value)
         : Parent(bpgraph, value) {}
 
     private:
-      BlueMap& operator=(const BlueMap& cmap) {
-        return operator=<BlueMap>(cmap);
+      BlueNodeMap& operator=(const BlueNodeMap& cmap) {
+        return operator=<BlueNodeMap>(cmap);
       }
 
       template <typename CMap>
-      BlueMap& operator=(const CMap& cmap) {
+      BlueNodeMap& operator=(const CMap& cmap) {
         Parent::operator=(cmap);
         return *this;
Index: lemon/bits/traits.h
===================================================================
--- lemon/bits/traits.h	(revision 1019)
+++ lemon/bits/traits.h	(revision 1026)
@@ -173,14 +173,14 @@
 
     typedef typename GR::RedNode Item;
-    typedef typename GR::RedIt ItemIt;
+    typedef typename GR::RedNodeIt ItemIt;
 
     typedef typename RedNodeNotifierIndicator<GR>::Type ItemNotifier;
 
     template <typename V>
-    class Map : public GR::template RedMap<V> {
-      typedef typename GR::template RedMap<V> Parent;
-
-    public:
-      typedef typename GR::template RedMap<V> Type;
+    class Map : public GR::template RedNodeMap<V> {
+      typedef typename GR::template RedNodeMap<V> Parent;
+
+    public:
+      typedef typename GR::template RedNodeMap<V> Type;
       typedef typename Parent::Value Value;
 
@@ -214,14 +214,14 @@
 
     typedef typename GR::BlueNode Item;
-    typedef typename GR::BlueIt ItemIt;
+    typedef typename GR::BlueNodeIt ItemIt;
 
     typedef typename BlueNodeNotifierIndicator<GR>::Type ItemNotifier;
 
     template <typename V>
-    class Map : public GR::template BlueMap<V> {
-      typedef typename GR::template BlueMap<V> Parent;
-
-    public:
-      typedef typename GR::template BlueMap<V> Type;
+    class Map : public GR::template BlueNodeMap<V> {
+      typedef typename GR::template BlueNodeMap<V> Parent;
+
+    public:
+      typedef typename GR::template BlueNodeMap<V> Type;
       typedef typename Parent::Value Value;
 
Index: lemon/concepts/bpgraph.h
===================================================================
--- lemon/concepts/bpgraph.h	(revision 1025)
+++ lemon/concepts/bpgraph.h	(revision 1026)
@@ -49,7 +49,7 @@
     /// "undirected graphs". Bipartite graphs provide a bipartition of
     /// the node set, namely a red and blue set of the nodes. The
-    /// nodes can be iterated with the RedIt and BlueIt in the two
-    /// node sets. With RedMap and BlueMap values can be assigned to
-    /// the nodes in the two sets.
+    /// nodes can be iterated with the RedNodeIt and BlueNodeIt in the
+    /// two node sets. With RedNodeMap and BlueNodeMap values can be
+    /// assigned to the nodes in the two sets.
     ///
     /// The edges of the graph cannot connect two nodes of the same
@@ -188,5 +188,5 @@
       /// for (BpGraph::RedNodeIt n(g); n!=INVALID; ++n) ++count;
       ///\endcode
-      class RedIt : public RedNode {
+      class RedNodeIt : public RedNode {
       public:
         /// Default constructor
@@ -194,30 +194,30 @@
         /// Default constructor.
         /// \warning It sets the iterator to an undefined value.
-        RedIt() { }
-        /// Copy constructor.
-
-        /// Copy constructor.
-        ///
-        RedIt(const RedIt& n) : RedNode(n) { }
+        RedNodeIt() { }
+        /// Copy constructor.
+
+        /// Copy constructor.
+        ///
+        RedNodeIt(const RedNodeIt& n) : RedNode(n) { }
         /// %Invalid constructor \& conversion.
 
         /// Initializes the iterator to be invalid.
         /// \sa Invalid for more details.
-        RedIt(Invalid) { }
+        RedNodeIt(Invalid) { }
         /// Sets the iterator to the first red node.
 
         /// Sets the iterator to the first red node of the given
         /// digraph.
-        explicit RedIt(const BpGraph&) { }
+        explicit RedNodeIt(const BpGraph&) { }
         /// Sets the iterator to the given red node.
 
         /// Sets the iterator to the given red node of the given
         /// digraph.
-        RedIt(const BpGraph&, const RedNode&) { }
+        RedNodeIt(const BpGraph&, const RedNode&) { }
         /// Next node.
 
         /// Assign the iterator to the next red node.
         ///
-        RedIt& operator++() { return *this; }
+        RedNodeIt& operator++() { return *this; }
       };
 
@@ -231,5 +231,5 @@
       /// for (BpGraph::BlueNodeIt n(g); n!=INVALID; ++n) ++count;
       ///\endcode
-      class BlueIt : public BlueNode {
+      class BlueNodeIt : public BlueNode {
       public:
         /// Default constructor
@@ -237,30 +237,30 @@
         /// Default constructor.
         /// \warning It sets the iterator to an undefined value.
-        BlueIt() { }
-        /// Copy constructor.
-
-        /// Copy constructor.
-        ///
-        BlueIt(const BlueIt& n) : BlueNode(n) { }
+        BlueNodeIt() { }
+        /// Copy constructor.
+
+        /// Copy constructor.
+        ///
+        BlueNodeIt(const BlueNodeIt& n) : BlueNode(n) { }
         /// %Invalid constructor \& conversion.
 
         /// Initializes the iterator to be invalid.
         /// \sa Invalid for more details.
-        BlueIt(Invalid) { }
+        BlueNodeIt(Invalid) { }
         /// Sets the iterator to the first blue node.
 
         /// Sets the iterator to the first blue node of the given
         /// digraph.
-        explicit BlueIt(const BpGraph&) { }
+        explicit BlueNodeIt(const BpGraph&) { }
         /// Sets the iterator to the given blue node.
 
         /// Sets the iterator to the given blue node of the given
         /// digraph.
-        BlueIt(const BpGraph&, const BlueNode&) { }
+        BlueNodeIt(const BpGraph&, const BlueNode&) { }
         /// Next node.
 
         /// Assign the iterator to the next blue node.
         ///
-        BlueIt& operator++() { return *this; }
+        BlueNodeIt& operator++() { return *this; }
       };
 
@@ -664,20 +664,20 @@
       /// It conforms to the ReferenceMap concept.
       template<class T>
-      class RedMap : public ReferenceMap<Node, T, T&, const T&>
+      class RedNodeMap : public ReferenceMap<Node, T, T&, const T&>
       {
       public:
 
         /// Constructor
-        explicit RedMap(const BpGraph&) { }
+        explicit RedNodeMap(const BpGraph&) { }
         /// Constructor with given initial value
-        RedMap(const BpGraph&, T) { }
+        RedNodeMap(const BpGraph&, T) { }
 
       private:
         ///Copy constructor
-        RedMap(const RedMap& nm) :
+        RedNodeMap(const RedNodeMap& nm) :
           ReferenceMap<Node, T, T&, const T&>(nm) { }
         ///Assignment operator
         template <typename CMap>
-        RedMap& operator=(const CMap&) {
+        RedNodeMap& operator=(const CMap&) {
           checkConcept<ReadMap<Node, T>, CMap>();
           return *this;
@@ -690,20 +690,20 @@
       /// It conforms to the ReferenceMap concept.
       template<class T>
-      class BlueMap : public ReferenceMap<Node, T, T&, const T&>
+      class BlueNodeMap : public ReferenceMap<Node, T, T&, const T&>
       {
       public:
 
         /// Constructor
-        explicit BlueMap(const BpGraph&) { }
+        explicit BlueNodeMap(const BpGraph&) { }
         /// Constructor with given initial value
-        BlueMap(const BpGraph&, T) { }
+        BlueNodeMap(const BpGraph&, T) { }
 
       private:
         ///Copy constructor
-        BlueMap(const BlueMap& nm) :
+        BlueNodeMap(const BlueNodeMap& nm) :
           ReferenceMap<Node, T, T&, const T&>(nm) { }
         ///Assignment operator
         template <typename CMap>
-        BlueMap& operator=(const CMap&) {
+        BlueNodeMap& operator=(const CMap&) {
           checkConcept<ReadMap<Node, T>, CMap>();
           return *this;
Index: lemon/concepts/graph_components.h
===================================================================
--- lemon/concepts/graph_components.h	(revision 1025)
+++ lemon/concepts/graph_components.h	(revision 1026)
@@ -1207,10 +1207,10 @@
       ///
       /// This iterator goes through each red node.
-      typedef GraphItemIt<BpGraph, RedNode> RedIt;
+      typedef GraphItemIt<BpGraph, RedNode> RedNodeIt;
 
       /// \brief This iterator goes through each blue node.
       ///
       /// This iterator goes through each blue node.
-      typedef GraphItemIt<BpGraph, BlueNode> BlueIt;
+      typedef GraphItemIt<BpGraph, BlueNode> BlueNodeIt;
 
       /// @}
@@ -1229,7 +1229,7 @@
 
           checkConcept<GraphItemIt<_BpGraph, typename _BpGraph::RedNode>,
-            typename _BpGraph::RedIt>();
+            typename _BpGraph::RedNodeIt>();
           checkConcept<GraphItemIt<_BpGraph, typename _BpGraph::BlueNode>,
-            typename _BpGraph::BlueIt>();
+            typename _BpGraph::BlueNodeIt>();
         }
 
@@ -1716,5 +1716,6 @@
     /// bipartite graphs.  It extends \ref MappableGraphComponent with
     /// the standard graph map class for red and blue nodes (\c
-    /// RedMap and BlueMap). This concept is part of the BpGraph concept.
+    /// RedNodeMap and BlueNodeMap). This concept is part of the
+    /// BpGraph concept.
     template <typename BAS = BaseBpGraphComponent>
     class MappableBpGraphComponent : public MappableGraphComponent<BAS>  {
@@ -1731,5 +1732,5 @@
       /// It conforms to the ReferenceMap concept.
       template <typename V>
-      class RedMap : public GraphMap<MappableBpGraphComponent, Node, V> {
+      class RedNodeMap : public GraphMap<MappableBpGraphComponent, Node, V> {
         typedef GraphMap<MappableBpGraphComponent, Node, V> Parent;
 
@@ -1738,5 +1739,5 @@
         ///
         /// Construct a new map for the graph.
-        explicit RedMap(const MappableBpGraphComponent& graph)
+        explicit RedNodeMap(const MappableBpGraphComponent& graph)
           : Parent(graph) {}
 
@@ -1744,5 +1745,5 @@
         ///
         /// Construct a new map for the graph and initalize the values.
-        RedMap(const MappableBpGraphComponent& graph, const V& value)
+        RedNodeMap(const MappableBpGraphComponent& graph, const V& value)
           : Parent(graph, value) {}
 
@@ -1751,5 +1752,5 @@
         ///
         /// Copy Constructor.
-        RedMap(const RedMap& nm) : Parent(nm) {}
+        RedNodeMap(const RedNodeMap& nm) : Parent(nm) {}
 
         /// \brief Assignment operator.
@@ -1757,5 +1758,5 @@
         /// Assignment operator.
         template <typename CMap>
-        RedMap& operator=(const CMap&) {
+        RedNodeMap& operator=(const CMap&) {
           checkConcept<ReadMap<Node, V>, CMap>();
           return *this;
@@ -1769,5 +1770,5 @@
       /// It conforms to the ReferenceMap concept.
       template <typename V>
-      class BlueMap : public GraphMap<MappableBpGraphComponent, Node, V> {
+      class BlueNodeMap : public GraphMap<MappableBpGraphComponent, Node, V> {
         typedef GraphMap<MappableBpGraphComponent, Node, V> Parent;
 
@@ -1776,5 +1777,5 @@
         ///
         /// Construct a new map for the graph.
-        explicit BlueMap(const MappableBpGraphComponent& graph)
+        explicit BlueNodeMap(const MappableBpGraphComponent& graph)
           : Parent(graph) {}
 
@@ -1782,5 +1783,5 @@
         ///
         /// Construct a new map for the graph and initalize the values.
-        BlueMap(const MappableBpGraphComponent& graph, const V& value)
+        BlueNodeMap(const MappableBpGraphComponent& graph, const V& value)
           : Parent(graph, value) {}
 
@@ -1789,5 +1790,5 @@
         ///
         /// Copy Constructor.
-        BlueMap(const BlueMap& nm) : Parent(nm) {}
+        BlueNodeMap(const BlueNodeMap& nm) : Parent(nm) {}
 
         /// \brief Assignment operator.
@@ -1795,5 +1796,5 @@
         /// Assignment operator.
         template <typename CMap>
-        BlueMap& operator=(const CMap&) {
+        BlueNodeMap& operator=(const CMap&) {
           checkConcept<ReadMap<Node, V>, CMap>();
           return *this;
@@ -1816,29 +1817,35 @@
 
           { // int map test
-            typedef typename _BpGraph::template RedMap<int> IntRedMap;
+            typedef typename _BpGraph::template RedNodeMap<int>
+              IntRedNodeMap;
             checkConcept<GraphMap<_BpGraph, typename _BpGraph::RedNode, int>,
-              IntRedMap >();
+              IntRedNodeMap >();
           } { // bool map test
-            typedef typename _BpGraph::template RedMap<bool> BoolRedMap;
+            typedef typename _BpGraph::template RedNodeMap<bool>
+              BoolRedNodeMap;
             checkConcept<GraphMap<_BpGraph, typename _BpGraph::RedNode, bool>,
-              BoolRedMap >();
+              BoolRedNodeMap >();
           } { // Dummy map test
-            typedef typename _BpGraph::template RedMap<Dummy> DummyRedMap;
+            typedef typename _BpGraph::template RedNodeMap<Dummy>
+              DummyRedNodeMap;
             checkConcept<GraphMap<_BpGraph, typename _BpGraph::RedNode, Dummy>,
-              DummyRedMap >();
+              DummyRedNodeMap >();
           }
 
           { // int map test
-            typedef typename _BpGraph::template BlueMap<int> IntBlueMap;
+            typedef typename _BpGraph::template BlueNodeMap<int>
+              IntBlueNodeMap;
             checkConcept<GraphMap<_BpGraph, typename _BpGraph::BlueNode, int>,
-              IntBlueMap >();
+              IntBlueNodeMap >();
           } { // bool map test
-            typedef typename _BpGraph::template BlueMap<bool> BoolBlueMap;
+            typedef typename _BpGraph::template BlueNodeMap<bool>
+              BoolBlueNodeMap;
             checkConcept<GraphMap<_BpGraph, typename _BpGraph::BlueNode, bool>,
-              BoolBlueMap >();
+              BoolBlueNodeMap >();
           } { // Dummy map test
-            typedef typename _BpGraph::template BlueMap<Dummy> DummyBlueMap;
+            typedef typename _BpGraph::template BlueNodeMap<Dummy>
+              DummyBlueNodeMap;
             checkConcept<GraphMap<_BpGraph, typename _BpGraph::BlueNode, Dummy>,
-              DummyBlueMap >();
+              DummyBlueNodeMap >();
           }
         }
Index: lemon/core.h
===================================================================
--- lemon/core.h	(revision 1025)
+++ lemon/core.h	(revision 1026)
@@ -151,8 +151,9 @@
   ///Create convenience typedefs for the bipartite graph types and iterators
 
-  ///This \c \#define creates the same convenient type definitions as defined
-  ///by \ref GRAPH_TYPEDEFS(BpGraph) and ten more, namely it creates
-  ///\c RedNode, \c RedIt, \c BoolRedMap, \c IntRedMap, \c DoubleRedMap,
-  ///\c BlueNode, \c BlueIt, \c BoolBlueMap, \c IntBlueMap, \c DoubleBlueMap.
+  ///This \c \#define creates the same convenient type definitions as
+  ///defined by \ref GRAPH_TYPEDEFS(BpGraph) and ten more, namely it
+  ///creates \c RedNode, \c RedNodeIt, \c BoolRedNodeMap,
+  ///\c IntRedNodeMap, \c DoubleRedNodeMap, \c BlueNode, \c BlueNodeIt,
+  ///\c BoolBlueNodeMap, \c IntBlueNodeMap, \c DoubleBlueNodeMap.
   ///
   ///\note If the graph type is a dependent type, ie. the graph type depend
@@ -162,13 +163,13 @@
   GRAPH_TYPEDEFS(BpGraph);                                              \
   typedef BpGraph::RedNode RedNode;                                     \
-  typedef BpGraph::RedIt RedIt;                                         \
-  typedef BpGraph::RedMap<bool> BoolRedMap;                             \
-  typedef BpGraph::RedMap<int> IntRedMap;                               \
-  typedef BpGraph::RedMap<double> DoubleRedMap;                         \
+  typedef BpGraph::RedNodeIt RedNodeIt;                                 \
+  typedef BpGraph::RedNodeMap<bool> BoolRedNodeMap;                     \
+  typedef BpGraph::RedNodeMap<int> IntRedNodeMap;                       \
+  typedef BpGraph::RedNodeMap<double> DoubleRedNodeMap;                 \
   typedef BpGraph::BlueNode BlueNode;                                   \
-  typedef BpGraph::BlueIt BlueIt;                                       \
-  typedef BpGraph::BlueMap<bool> BoolBlueMap;                           \
-  typedef BpGraph::BlueMap<int> IntBlueMap;                             \
-  typedef BpGraph::BlueMap<double> DoubleBlueMap
+  typedef BpGraph::BlueNodeIt BlueNodeIt;                               \
+  typedef BpGraph::BlueNodeMap<bool> BoolBlueNodeMap;                   \
+  typedef BpGraph::BlueNodeMap<int> IntBlueNodeMap;                     \
+  typedef BpGraph::BlueNodeMap<double> DoubleBlueNodeMap
 
   ///Create convenience typedefs for the bipartite graph types and iterators
@@ -178,16 +179,16 @@
   ///\note Use this macro, if the graph type is a dependent type,
   ///ie. the graph type depend on a template parameter.
-#define TEMPLATE_BPGRAPH_TYPEDEFS(BpGraph)                              \
-  TEMPLATE_GRAPH_TYPEDEFS(BpGraph);                                     \
-  typedef typename BpGraph::RedNode RedNode;                            \
-  typedef typename BpGraph::RedIt RedIt;                                \
-  typedef typename BpGraph::template RedMap<bool> BoolRedMap;           \
-  typedef typename BpGraph::template RedMap<int> IntRedMap;             \
-  typedef typename BpGraph::template RedMap<double> DoubleRedMap;       \
-  typedef typename BpGraph::BlueNode BlueNode;                          \
-  typedef typename BpGraph::BlueIt BlueIt;                              \
-  typedef typename BpGraph::template BlueMap<bool> BoolBlueMap;         \
-  typedef typename BpGraph::template BlueMap<int> IntBlueMap;           \
-  typedef typename BpGraph::template BlueMap<double> DoubleBlueMap
+#define TEMPLATE_BPGRAPH_TYPEDEFS(BpGraph)                                  \
+  TEMPLATE_GRAPH_TYPEDEFS(BpGraph);                                         \
+  typedef typename BpGraph::RedNode RedNode;                                \
+  typedef typename BpGraph::RedNodeIt RedNodeIt;                            \
+  typedef typename BpGraph::template RedNodeMap<bool> BoolRedNodeMap;       \
+  typedef typename BpGraph::template RedNodeMap<int> IntRedNodeMap;         \
+  typedef typename BpGraph::template RedNodeMap<double> DoubleRedNodeMap;   \
+  typedef typename BpGraph::BlueNode BlueNode;                              \
+  typedef typename BpGraph::BlueNodeIt BlueNodeIt;                          \
+  typedef typename BpGraph::template BlueNodeMap<bool> BoolBlueNodeMap;     \
+  typedef typename BpGraph::template BlueNodeMap<int> IntBlueNodeMap;       \
+  typedef typename BpGraph::template BlueNodeMap<double> DoubleBlueNodeMap
 
   /// \brief Function to count the items in a graph.
@@ -566,8 +567,8 @@
                        EdgeRefMap& edgeRefMap) {
         to.clear();
-        for (typename From::RedIt it(from); it != INVALID; ++it) {
+        for (typename From::RedNodeIt it(from); it != INVALID; ++it) {
           redNodeRefMap[it] = to.addRedNode();
         }
-        for (typename From::BlueIt it(from); it != INVALID; ++it) {
+        for (typename From::BlueNodeIt it(from); it != INVALID; ++it) {
           blueNodeRefMap[it] = to.addBlueNode();
         }
@@ -1165,8 +1166,8 @@
   ///  NewBpGraph::EdgeMap<OrigBpGraph::Edge> ecr(new_graph);
   ///  cg.edgeCrossRef(ecr);
-  ///  // Copy a red map
-  ///  OrigBpGraph::RedMap<double> ormap(orig_graph);
-  ///  NewBpGraph::RedMap<double> nrmap(new_graph);
-  ///  cg.edgeMap(ormap, nrmap);
+  ///  // Copy a red node map
+  ///  OrigBpGraph::RedNodeMap<double> ormap(orig_graph);
+  ///  NewBpGraph::RedNodeMap<double> nrmap(new_graph);
+  ///  cg.redNodeMap(ormap, nrmap);
   ///  // Copy a node
   ///  OrigBpGraph::Node on;
@@ -1195,6 +1196,6 @@
     typedef typename To::Edge TEdge;
 
-    typedef typename From::template RedMap<TRedNode> RedNodeRefMap;
-    typedef typename From::template BlueMap<TBlueNode> BlueNodeRefMap;
+    typedef typename From::template RedNodeMap<TRedNode> RedNodeRefMap;
+    typedef typename From::template BlueNodeMap<TBlueNode> BlueNodeRefMap;
     typedef typename From::template EdgeMap<TEdge> EdgeRefMap;
 
@@ -1353,5 +1354,5 @@
     /// graph.
     template <typename FromMap, typename ToMap>
-    BpGraphCopy& redMap(const FromMap& map, ToMap& tmap) {
+    BpGraphCopy& redNodeMap(const FromMap& map, ToMap& tmap) {
       _red_maps.push_back(new _core_bits::MapCopy<From, RedNode,
                           RedNodeRefMap, FromMap, ToMap>(map, tmap));
@@ -1404,5 +1405,5 @@
     /// graph.
     template <typename FromMap, typename ToMap>
-    BpGraphCopy& blueMap(const FromMap& map, ToMap& tmap) {
+    BpGraphCopy& blueNodeMap(const FromMap& map, ToMap& tmap) {
       _blue_maps.push_back(new _core_bits::MapCopy<From, BlueNode,
                            BlueNodeRefMap, FromMap, ToMap>(map, tmap));
Index: lemon/lgf_reader.h
===================================================================
--- lemon/lgf_reader.h	(revision 1024)
+++ lemon/lgf_reader.h	(revision 1026)
@@ -2149,5 +2149,5 @@
   /// sections can contain different set of maps.
   ///
-  /// The red and blue maps are read from the corresponding
+  /// The red and blue node maps are read from the corresponding
   /// sections. If a map is defined with the same name in both of
   /// these sections, then it can be read as a node map.
@@ -2338,7 +2338,7 @@
     }
 
-    /// Add a red map reading rule to the reader.
+    /// Add a red node map reading rule to the reader.
     template <typename Map>
-    BpGraphReader& redMap(const std::string& caption, Map& map) {
+    BpGraphReader& redNodeMap(const std::string& caption, Map& map) {
       checkConcept<concepts::WriteMap<Node, typename Map::Value>, Map>();
       _reader_bits::MapStorageBase<Node>* storage =
@@ -2348,11 +2348,11 @@
     }
 
-    /// \brief Red map reading rule
-    ///
-    /// Add a red map reading rule with specialized converter to the
-    /// reader.
+    /// \brief Red node map reading rule
+    ///
+    /// Add a red node map node reading rule with specialized converter to
+    /// the reader.
     template <typename Map, typename Converter>
-    BpGraphReader& redMap(const std::string& caption, Map& map,
-                          const Converter& converter = Converter()) {
+    BpGraphReader& redNodeMap(const std::string& caption, Map& map,
+                              const Converter& converter = Converter()) {
       checkConcept<concepts::WriteMap<Node, typename Map::Value>, Map>();
       _reader_bits::MapStorageBase<Node>* storage =
@@ -2362,7 +2362,7 @@
     }
 
-    /// Add a blue map reading rule to the reader.
+    /// Add a blue node map reading rule to the reader.
     template <typename Map>
-    BpGraphReader& blueMap(const std::string& caption, Map& map) {
+    BpGraphReader& blueNodeMap(const std::string& caption, Map& map) {
       checkConcept<concepts::WriteMap<Node, typename Map::Value>, Map>();
       _reader_bits::MapStorageBase<Node>* storage =
@@ -2372,11 +2372,11 @@
     }
 
-    /// \brief Blue map reading rule
-    ///
-    /// Add a blue map reading rule with specialized converter to the
-    /// reader.
+    /// \brief Blue node map reading rule
+    ///
+    /// Add a blue node map reading rule with specialized converter to
+    /// the reader.
     template <typename Map, typename Converter>
-    BpGraphReader& blueMap(const std::string& caption, Map& map,
-                           const Converter& converter = Converter()) {
+    BpGraphReader& blueNodeMap(const std::string& caption, Map& map,
+                               const Converter& converter = Converter()) {
       checkConcept<concepts::WriteMap<Node, typename Map::Value>, Map>();
       _reader_bits::MapStorageBase<Node>* storage =
@@ -2685,5 +2685,5 @@
           if (maps.find(map) != maps.end()) {
             std::ostringstream msg;
-            msg << "Multiple occurence of red map: " << map;
+            msg << "Multiple occurence of red node map: " << map;
             throw FormatError(msg.str());
           }
@@ -2778,5 +2778,5 @@
           if (maps.find(map) != maps.end()) {
             std::ostringstream msg;
-            msg << "Multiple occurence of blue map: " << map;
+            msg << "Multiple occurence of blue node map: " << map;
             throw FormatError(msg.str());
           }
Index: lemon/lgf_writer.h
===================================================================
--- lemon/lgf_writer.h	(revision 1024)
+++ lemon/lgf_writer.h	(revision 1026)
@@ -1630,5 +1630,5 @@
   /// sections can contain different set of maps.
   ///
-  /// The red and blue maps are written to the corresponding
+  /// The red and blue node maps are written to the corresponding
   /// sections. The node maps are written to both of these sections
   /// with the same map name.
@@ -1806,9 +1806,9 @@
     }
 
-    /// \brief Red map writing rule
-    ///
-    /// Add a red map writing rule to the writer.
+    /// \brief Red node map writing rule
+    ///
+    /// Add a red node map writing rule to the writer.
     template <typename Map>
-    BpGraphWriter& redMap(const std::string& caption, const Map& map) {
+    BpGraphWriter& redNodeMap(const std::string& caption, const Map& map) {
       checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
       _writer_bits::MapStorageBase<Node>* storage =
@@ -1818,11 +1818,11 @@
     }
 
-    /// \brief Red map writing rule
-    ///
-    /// Add a red map writing rule with specialized converter to the
+    /// \brief Red node map writing rule
+    ///
+    /// Add a red node map writing rule with specialized converter to the
     /// writer.
     template <typename Map, typename Converter>
-    BpGraphWriter& redMap(const std::string& caption, const Map& map,
-                          const Converter& converter = Converter()) {
+    BpGraphWriter& redNodeMap(const std::string& caption, const Map& map,
+                              const Converter& converter = Converter()) {
       checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
       _writer_bits::MapStorageBase<Node>* storage =
@@ -1832,9 +1832,9 @@
     }
 
-    /// \brief Blue map writing rule
-    ///
-    /// Add a blue map writing rule to the writer.
+    /// \brief Blue node map writing rule
+    ///
+    /// Add a blue node map writing rule to the writer.
     template <typename Map>
-    BpGraphWriter& blueMap(const std::string& caption, const Map& map) {
+    BpGraphWriter& blueNodeMap(const std::string& caption, const Map& map) {
       checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
       _writer_bits::MapStorageBase<Node>* storage =
@@ -1844,11 +1844,11 @@
     }
 
-    /// \brief Blue map writing rule
-    ///
-    /// Add a blue map writing rule with specialized converter to the
+    /// \brief Blue node map writing rule
+    ///
+    /// Add a blue node map writing rule with specialized converter to the
     /// writer.
     template <typename Map, typename Converter>
-    BpGraphWriter& blueMap(const std::string& caption, const Map& map,
-                           const Converter& converter = Converter()) {
+    BpGraphWriter& blueNodeMap(const std::string& caption, const Map& map,
+                               const Converter& converter = Converter()) {
       checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
       _writer_bits::MapStorageBase<Node>* storage =
@@ -2059,5 +2059,5 @@
 
       std::vector<Node> nodes;
-      for (RedIt n(_graph); n != INVALID; ++n) {
+      for (RedNodeIt n(_graph); n != INVALID; ++n) {
         nodes.push_back(n);
       }
@@ -2119,5 +2119,5 @@
 
       std::vector<Node> nodes;
-      for (BlueIt n(_graph); n != INVALID; ++n) {
+      for (BlueNodeIt n(_graph); n != INVALID; ++n) {
         nodes.push_back(n);
       }
Index: test/bpgraph_test.cc
===================================================================
--- test/bpgraph_test.cc	(revision 1025)
+++ test/bpgraph_test.cc	(revision 1026)
@@ -102,6 +102,6 @@
 
   checkGraphNodeMap(G);
-  checkGraphRedMap(G);
-  checkGraphBlueMap(G);
+  checkGraphRedNodeMap(G);
+  checkGraphBlueNodeMap(G);
   checkGraphArcMap(G);
   checkGraphEdgeMap(G);
@@ -261,6 +261,6 @@
 
   checkGraphNodeMap(G);
-  checkGraphRedMap(G);
-  checkGraphBlueMap(G);
+  checkGraphRedNodeMap(G);
+  checkGraphBlueNodeMap(G);
   checkGraphArcMap(G);
   checkGraphEdgeMap(G);
@@ -370,5 +370,5 @@
   checkGraphArcList(G, 2 * redNum * blueNum);
 
-  for (RedIt n(G); n != INVALID; ++n) {
+  for (RedNodeIt n(G); n != INVALID; ++n) {
     checkGraphOutArcList(G, n, blueNum);
     checkGraphInArcList(G, n, blueNum);
@@ -376,5 +376,5 @@
   }
 
-  for (BlueIt n(G); n != INVALID; ++n) {
+  for (BlueNodeIt n(G); n != INVALID; ++n) {
     checkGraphOutArcList(G, n, redNum);
     checkGraphInArcList(G, n, redNum);
@@ -394,6 +394,6 @@
 
   checkGraphNodeMap(G);
-  checkGraphRedMap(G);
-  checkGraphBlueMap(G);
+  checkGraphRedNodeMap(G);
+  checkGraphBlueNodeMap(G);
   checkGraphArcMap(G);
   checkGraphEdgeMap(G);
Index: test/graph_copy_test.cc
===================================================================
--- test/graph_copy_test.cc	(revision 1025)
+++ test/graph_copy_test.cc	(revision 1026)
@@ -217,6 +217,6 @@
   SmartBpGraph from;
   SmartBpGraph::NodeMap<int> fnm(from);
-  SmartBpGraph::RedMap<int> frnm(from);
-  SmartBpGraph::BlueMap<int> fbnm(from);
+  SmartBpGraph::RedNodeMap<int> frnm(from);
+  SmartBpGraph::BlueNodeMap<int> fbnm(from);
   SmartBpGraph::ArcMap<int> fam(from);
   SmartBpGraph::EdgeMap<int> fem(from);
@@ -262,6 +262,6 @@
   GR to;
   typename GR::template NodeMap<int> tnm(to);
-  typename GR::template RedMap<int> trnm(to);
-  typename GR::template BlueMap<int> tbnm(to);
+  typename GR::template RedNodeMap<int> trnm(to);
+  typename GR::template BlueNodeMap<int> tbnm(to);
   typename GR::template ArcMap<int> tam(to);
   typename GR::template EdgeMap<int> tem(to);
@@ -273,17 +273,18 @@
 
   SmartBpGraph::NodeMap<typename GR::Node> nr(from);
-  SmartBpGraph::RedMap<typename GR::RedNode> rnr(from);
-  SmartBpGraph::BlueMap<typename GR::BlueNode> bnr(from);
+  SmartBpGraph::RedNodeMap<typename GR::RedNode> rnr(from);
+  SmartBpGraph::BlueNodeMap<typename GR::BlueNode> bnr(from);
   SmartBpGraph::ArcMap<typename GR::Arc> ar(from);
   SmartBpGraph::EdgeMap<typename GR::Edge> er(from);
 
   typename GR::template NodeMap<SmartBpGraph::Node> ncr(to);
-  typename GR::template RedMap<SmartBpGraph::RedNode> rncr(to);
-  typename GR::template BlueMap<SmartBpGraph::BlueNode> bncr(to);
+  typename GR::template RedNodeMap<SmartBpGraph::RedNode> rncr(to);
+  typename GR::template BlueNodeMap<SmartBpGraph::BlueNode> bncr(to);
   typename GR::template ArcMap<SmartBpGraph::Arc> acr(to);
   typename GR::template EdgeMap<SmartBpGraph::Edge> ecr(to);
 
   bpGraphCopy(from, to).
-    nodeMap(fnm, tnm).redMap(frnm, trnm).blueMap(fbnm, tbnm).
+    nodeMap(fnm, tnm).
+    redNodeMap(frnm, trnm).blueNodeMap(fbnm, tbnm).
     arcMap(fam, tam).edgeMap(fem, tem).
     nodeRef(nr).redRef(rnr).blueRef(bnr).
@@ -305,5 +306,5 @@
   }
 
-  for (SmartBpGraph::RedIt it(from); it != INVALID; ++it) {
+  for (SmartBpGraph::RedNodeIt it(from); it != INVALID; ++it) {
     check(ncr[nr[it]] == it, "Wrong copy.");
     check(fnm[it] == tnm[nr[it]], "Wrong copy.");
@@ -314,5 +315,5 @@
   }
 
-  for (SmartBpGraph::BlueIt it(from); it != INVALID; ++it) {
+  for (SmartBpGraph::BlueNodeIt it(from); it != INVALID; ++it) {
     check(ncr[nr[it]] == it, "Wrong copy.");
     check(fnm[it] == tnm[nr[it]], "Wrong copy.");
@@ -344,9 +345,9 @@
     check(nr[ncr[it]] == it, "Wrong copy.");
   }
-  for (typename GR::RedIt it(to); it != INVALID; ++it) {
+  for (typename GR::RedNodeIt it(to); it != INVALID; ++it) {
     check(rncr[it] == ncr[it], "Wrong copy.");
     check(rnr[rncr[it]] == it, "Wrong copy.");
   }
-  for (typename GR::BlueIt it(to); it != INVALID; ++it) {
+  for (typename GR::BlueNodeIt it(to); it != INVALID; ++it) {
     check(bncr[it] == ncr[it], "Wrong copy.");
     check(bnr[bncr[it]] == it, "Wrong copy.");
Index: test/graph_test.h
===================================================================
--- test/graph_test.h	(revision 1025)
+++ test/graph_test.h	(revision 1026)
@@ -44,5 +44,5 @@
   void checkGraphRedNodeList(const Graph &G, int cnt)
   {
-    typename Graph::RedIt n(G);
+    typename Graph::RedNodeIt n(G);
     for(int i=0;i<cnt;i++) {
       check(n!=INVALID,"Wrong red Node list linking.");
@@ -66,5 +66,5 @@
   void checkGraphBlueNodeList(const Graph &G, int cnt)
   {
-    typename Graph::BlueIt n(G);
+    typename Graph::BlueNodeIt n(G);
     for(int i=0;i<cnt;i++) {
       check(n!=INVALID,"Wrong blue Node list linking.");
@@ -226,5 +226,5 @@
     typedef typename Graph::RedNode RedNode;
     std::set<int> values;
-    for (typename Graph::RedIt n(G); n != INVALID; ++n) {
+    for (typename Graph::RedNodeIt n(G); n != INVALID; ++n) {
       check(G.red(n), "Wrong partition");
       check(values.find(G.id(n)) == values.end(), "Wrong id");
@@ -239,5 +239,5 @@
     typedef typename Graph::BlueNode BlueNode;
     std::set<int> values;
-    for (typename Graph::BlueIt n(G); n != INVALID; ++n) {
+    for (typename Graph::BlueNodeIt n(G); n != INVALID; ++n) {
       check(G.blue(n), "Wrong partition");
       check(values.find(G.id(n)) == values.end(), "Wrong id");
@@ -305,15 +305,15 @@
 
   template <typename Graph>
-  void checkGraphRedMap(const Graph& G) {
+  void checkGraphRedNodeMap(const Graph& G) {
     typedef typename Graph::Node Node;
-    typedef typename Graph::RedIt RedIt;
-
-    typedef typename Graph::template RedMap<int> IntRedMap;
-    IntRedMap map(G, 42);
-    for (RedIt it(G); it != INVALID; ++it) {
+    typedef typename Graph::RedNodeIt RedNodeIt;
+
+    typedef typename Graph::template RedNodeMap<int> IntRedNodeMap;
+    IntRedNodeMap map(G, 42);
+    for (RedNodeIt it(G); it != INVALID; ++it) {
       check(map[it] == 42, "Wrong map constructor.");
     }
     int s = 0;
-    for (RedIt it(G); it != INVALID; ++it) {
+    for (RedNodeIt it(G); it != INVALID; ++it) {
       map[it] = 0;
       check(map[it] == 0, "Wrong operator[].");
@@ -323,5 +323,5 @@
     }
     s = s * (s - 1) / 2;
-    for (RedIt it(G); it != INVALID; ++it) {
+    for (RedNodeIt it(G); it != INVALID; ++it) {
       s -= map[it];
     }
@@ -335,15 +335,15 @@
 
   template <typename Graph>
-  void checkGraphBlueMap(const Graph& G) {
+  void checkGraphBlueNodeMap(const Graph& G) {
     typedef typename Graph::Node Node;
-    typedef typename Graph::BlueIt BlueIt;
-
-    typedef typename Graph::template BlueMap<int> IntBlueMap;
-    IntBlueMap map(G, 42);
-    for (BlueIt it(G); it != INVALID; ++it) {
+    typedef typename Graph::BlueNodeIt BlueNodeIt;
+
+    typedef typename Graph::template BlueNodeMap<int> IntBlueNodeMap;
+    IntBlueNodeMap map(G, 42);
+    for (BlueNodeIt it(G); it != INVALID; ++it) {
       check(map[it] == 42, "Wrong map constructor.");
     }
     int s = 0;
-    for (BlueIt it(G); it != INVALID; ++it) {
+    for (BlueNodeIt it(G); it != INVALID; ++it) {
       map[it] = 0;
       check(map[it] == 0, "Wrong operator[].");
@@ -353,5 +353,5 @@
     }
     s = s * (s - 1) / 2;
-    for (BlueIt it(G); it != INVALID; ++it) {
+    for (BlueNodeIt it(G); it != INVALID; ++it) {
       s -= map[it];
     }
