Index: lemon/concepts/graph_components.h
===================================================================
--- lemon/concepts/graph_components.h	(revision 1217)
+++ lemon/concepts/graph_components.h	(revision 1257)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -19,5 +19,5 @@
 ///\ingroup graph_concepts
 ///\file
-///\brief The concepts of graph components.
+///\brief The concept of graph components.
 
 #ifndef LEMON_CONCEPTS_GRAPH_COMPONENTS_H
@@ -39,5 +39,5 @@
     /// \note This class is a template class so that we can use it to
     /// create graph skeleton classes. The reason for this is that \c Node
-    /// and \c Arc (or \c Edge) types should \e not derive from the same
+    /// and \c Arc (or \c Edge) types should \e not derive from the same 
     /// base class. For \c Node you should instantiate it with character
     /// \c 'n', for \c Arc with \c 'a' and for \c Edge with \c 'e'.
@@ -90,8 +90,8 @@
       ///
       /// This operator defines an ordering of the items.
-      /// It makes possible to use graph item types as key types in
+      /// It makes possible to use graph item types as key types in 
       /// associative containers (e.g. \c std::map).
       ///
-      /// \note This operator only has to define some strict ordering of
+      /// \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.
@@ -109,5 +109,5 @@
 
           bool b;
-          ignore_unused_variable_warning(b);
+          ::lemon::ignore_unused_variable_warning(b);
 
           b = (ia == ib) && (ia != ib);
@@ -126,5 +126,5 @@
     /// This class describes the base interface of directed graph types.
     /// All digraph %concepts have to conform to this class.
-    /// It just provides types for nodes and arcs and functions
+    /// It just provides types for nodes and arcs and functions 
     /// to get the source and the target nodes of arcs.
     class BaseDigraphComponent {
@@ -290,5 +290,5 @@
             ue = e;
             bool d = graph.direction(e);
-            ignore_unused_variable_warning(d);
+            ::lemon::ignore_unused_variable_warning(d);
           }
         }
@@ -296,170 +296,4 @@
         const _Graph& graph;
       Constraints() {}
-      };
-
-    };
-
-    /// \brief Base skeleton class for undirected bipartite graphs.
-    ///
-    /// This class describes the base interface of undirected
-    /// bipartite graph types.  All bipartite graph %concepts have to
-    /// conform to this class.  It extends the interface of \ref
-    /// BaseGraphComponent with an \c Edge type and functions to get
-    /// the end nodes of edges, to convert from arcs to edges and to
-    /// get both direction of edges.
-    class BaseBpGraphComponent : public BaseGraphComponent {
-    public:
-
-      typedef BaseBpGraphComponent BpGraph;
-
-      typedef BaseDigraphComponent::Node Node;
-      typedef BaseDigraphComponent::Arc Arc;
-
-      /// \brief Class to represent red nodes.
-      ///
-      /// This class represents the red nodes of the graph. The red
-      /// nodes can also be used as normal nodes.
-      class RedNode : public Node {
-        typedef Node Parent;
-
-      public:
-        /// \brief Default constructor.
-        ///
-        /// Default constructor.
-        /// \warning The default constructor is not required to set
-        /// the item to some well-defined value. So you should consider it
-        /// as uninitialized.
-        RedNode() {}
-
-        /// \brief Copy constructor.
-        ///
-        /// Copy constructor.
-        RedNode(const RedNode &) : Parent() {}
-
-        /// \brief Constructor for conversion from \c INVALID.
-        ///
-        /// Constructor for conversion from \c INVALID.
-        /// It initializes the item to be invalid.
-        /// \sa Invalid for more details.
-        RedNode(Invalid) {}
-      };
-
-      /// \brief Class to represent blue nodes.
-      ///
-      /// This class represents the blue nodes of the graph. The blue
-      /// nodes can also be used as normal nodes.
-      class BlueNode : public Node {
-        typedef Node Parent;
-
-      public:
-        /// \brief Default constructor.
-        ///
-        /// Default constructor.
-        /// \warning The default constructor is not required to set
-        /// the item to some well-defined value. So you should consider it
-        /// as uninitialized.
-        BlueNode() {}
-
-        /// \brief Copy constructor.
-        ///
-        /// Copy constructor.
-        BlueNode(const BlueNode &) : Parent() {}
-
-        /// \brief Constructor for conversion from \c INVALID.
-        ///
-        /// Constructor for conversion from \c INVALID.
-        /// It initializes the item to be invalid.
-        /// \sa Invalid for more details.
-        BlueNode(Invalid) {}
-
-        /// \brief Constructor for conversion from a node.
-        ///
-        /// Constructor for conversion from a node. The conversion can
-        /// be invalid, since the Node can be member of the red
-        /// set.
-        BlueNode(const Node&) {}
-      };
-
-      /// \brief Gives back %true for red nodes.
-      ///
-      /// Gives back %true for red nodes.
-      bool red(const Node&) const { return true; }
-
-      /// \brief Gives back %true for blue nodes.
-      ///
-      /// Gives back %true for blue nodes.
-      bool blue(const Node&) const { return true; }
-
-      /// \brief Gives back the red end node of the edge.
-      /// 
-      /// Gives back the red end node of the edge.
-      RedNode redNode(const Edge&) const { return RedNode(); }
-
-      /// \brief Gives back the blue end node of the edge.
-      /// 
-      /// Gives back the blue end node of the edge.
-      BlueNode blueNode(const Edge&) const { return BlueNode(); }
-
-      /// \brief Converts the node to red node object.
-      ///
-      /// This function converts unsafely the node to red node
-      /// object. It should be called only if the node is from the red
-      /// partition or INVALID.
-      RedNode asRedNodeUnsafe(const Node&) const { return RedNode(); }
-
-      /// \brief Converts the node to blue node object.
-      ///
-      /// This function converts unsafely the node to blue node
-      /// object. It should be called only if the node is from the red
-      /// partition or INVALID.
-      BlueNode asBlueNodeUnsafe(const Node&) const { return BlueNode(); }
-
-      /// \brief Converts the node to red node object.
-      ///
-      /// This function converts safely the node to red node
-      /// object. If the node is not from the red partition, then it
-      /// returns INVALID.
-      RedNode asRedNode(const Node&) const { return RedNode(); }
-
-      /// \brief Converts the node to blue node object.
-      ///
-      /// This function converts unsafely the node to blue node
-      /// object. If the node is not from the blue partition, then it
-      /// returns INVALID.
-      BlueNode asBlueNode(const Node&) const { return BlueNode(); }
-
-      template <typename _BpGraph>
-      struct Constraints {
-        typedef typename _BpGraph::Node Node;
-        typedef typename _BpGraph::RedNode RedNode;
-        typedef typename _BpGraph::BlueNode BlueNode;
-        typedef typename _BpGraph::Arc Arc;
-        typedef typename _BpGraph::Edge Edge;
-
-        void constraints() {
-          checkConcept<BaseGraphComponent, _BpGraph>();
-          checkConcept<GraphItem<'n'>, RedNode>();
-          checkConcept<GraphItem<'n'>, BlueNode>();
-          {
-            Node n;
-            RedNode rn;
-            BlueNode bn;
-            Node rnan = rn;
-            Node bnan = bn;
-            Edge e;
-            bool b;
-            b = bpgraph.red(rnan);
-            b = bpgraph.blue(bnan);
-            rn = bpgraph.redNode(e);
-            bn = bpgraph.blueNode(e);
-            rn = bpgraph.asRedNodeUnsafe(rnan);
-            bn = bpgraph.asBlueNodeUnsafe(bnan);
-            rn = bpgraph.asRedNode(rnan);
-            bn = bpgraph.asBlueNode(bnan);
-            ignore_unused_variable_warning(b);
-          }
-        }
-
-        const _BpGraph& bpgraph;
       };
 
@@ -535,7 +369,7 @@
 
           nid = digraph.maxNodeId();
-          ignore_unused_variable_warning(nid);
+          ::lemon::ignore_unused_variable_warning(nid);
           eid = digraph.maxArcId();
-          ignore_unused_variable_warning(eid);
+          ::lemon::ignore_unused_variable_warning(eid);
         }
 
@@ -590,5 +424,5 @@
           edge = graph.edgeFromId(ueid);
           ueid = graph.maxEdgeId();
-          ignore_unused_variable_warning(ueid);
+          ::lemon::ignore_unused_variable_warning(ueid);
         }
 
@@ -598,71 +432,7 @@
     };
 
-    /// \brief Skeleton class for \e idable undirected bipartite graphs.
-    ///
-    /// This class describes the interface of \e idable undirected
-    /// bipartite graphs. It extends \ref IDableGraphComponent with
-    /// the core ID functions of undirected bipartite graphs. Beside
-    /// the regular node ids, this class also provides ids within the
-    /// the red and blue sets of the nodes. This concept is part of
-    /// the BpGraph concept.
-    template <typename BAS = BaseBpGraphComponent>
-    class IDableBpGraphComponent : public IDableGraphComponent<BAS> {
-    public:
-
-      typedef BAS Base;
-      typedef IDableGraphComponent<BAS> Parent;
-      typedef typename Base::Node Node;
-      typedef typename Base::RedNode RedNode;
-      typedef typename Base::BlueNode BlueNode;
-
-      using Parent::id;
-
-      /// \brief Return a unique integer id for the given node in the red set.
-      ///
-      /// Return a unique integer id for the given node in the red set.
-      int id(const RedNode&) const { return -1; }
-
-      /// \brief Return a unique integer id for the given node in the blue set.
-      ///
-      /// Return a unique integer id for the given node in the blue set.
-      int id(const BlueNode&) const { return -1; }
-
-      /// \brief Return an integer greater or equal to the maximum
-      /// node id in the red set.
-      ///
-      /// Return an integer greater or equal to the maximum
-      /// node id in the red set.
-      int maxRedId() const { return -1; }
-
-      /// \brief Return an integer greater or equal to the maximum
-      /// node id in the blue set.
-      ///
-      /// Return an integer greater or equal to the maximum
-      /// node id in the blue set.
-      int maxBlueId() const { return -1; }
-
-      template <typename _BpGraph>
-      struct Constraints {
-
-        void constraints() {
-          checkConcept<IDableGraphComponent<Base>, _BpGraph>();
-          typename _BpGraph::Node node;
-          typename _BpGraph::RedNode red;
-          typename _BpGraph::BlueNode blue;
-          int rid = bpgraph.id(red);
-          int bid = bpgraph.id(blue);
-          rid = bpgraph.maxRedId();
-          bid = bpgraph.maxBlueId();
-          ignore_unused_variable_warning(rid);
-          ignore_unused_variable_warning(bid);
-        }
-
-        const _BpGraph& bpgraph;
-      };
-    };
-
     /// \brief Concept class for \c NodeIt, \c ArcIt and \c EdgeIt types.
     ///
-    /// This class describes the concept of \c NodeIt, \c ArcIt and
+    /// This class describes the concept of \c NodeIt, \c ArcIt and 
     /// \c EdgeIt subtypes of digraph and graph types.
     template <typename GR, typename Item>
@@ -704,5 +474,5 @@
       /// next item.
       GraphItemIt& operator++() { return *this; }
-
+ 
       /// \brief Equality operator
       ///
@@ -727,6 +497,6 @@
           _GraphItemIt it3 = it1;
           _GraphItemIt it4 = INVALID;
-          ignore_unused_variable_warning(it3);
-          ignore_unused_variable_warning(it4);
+          ::lemon::ignore_unused_variable_warning(it3);
+          ::lemon::ignore_unused_variable_warning(it4);
 
           it2 = ++it1;
@@ -742,13 +512,13 @@
     };
 
-    /// \brief Concept class for \c InArcIt, \c OutArcIt and
+    /// \brief Concept class for \c InArcIt, \c OutArcIt and 
     /// \c IncEdgeIt types.
     ///
-    /// This class describes the concept of \c InArcIt, \c OutArcIt
+    /// This class describes the concept of \c InArcIt, \c OutArcIt 
     /// and \c IncEdgeIt subtypes of digraph and graph types.
     ///
     /// \note Since these iterator classes do not inherit from the same
     /// base class, there is an additional template parameter (selector)
-    /// \c sel. For \c InArcIt you should instantiate it with character
+    /// \c sel. For \c InArcIt you should instantiate it with character 
     /// \c 'i', for \c OutArcIt with \c 'o' and for \c IncEdgeIt with \c 'e'.
     template <typename GR,
@@ -771,8 +541,8 @@
       GraphIncIt(const GraphIncIt& it) : Item(it) {}
 
-      /// \brief Constructor that sets the iterator to the first
+      /// \brief Constructor that sets the iterator to the first 
       /// incoming or outgoing arc.
       ///
-      /// Constructor that sets the iterator to the first arc
+      /// Constructor that sets the iterator to the first arc 
       /// incoming to or outgoing from the given node.
       explicit GraphIncIt(const GR&, const Base&) {}
@@ -818,6 +588,6 @@
           _GraphIncIt it3 = it1;
           _GraphIncIt it4 = INVALID;
-          ignore_unused_variable_warning(it3);
-          ignore_unused_variable_warning(it4);
+          ::lemon::ignore_unused_variable_warning(it3);
+          ::lemon::ignore_unused_variable_warning(it4);
 
           it2 = ++it1;
@@ -876,13 +646,13 @@
       void next(Arc&) const {}
 
-      /// \brief Return the first arc incoming to the given node.
-      ///
-      /// This function gives back the first arc incoming to the
+      /// \brief Return the first arc incomming to the given node.
+      ///
+      /// This function gives back the first arc incomming to the
       /// given node.
       void firstIn(Arc&, const Node&) const {}
 
-      /// \brief Return the next arc incoming to the given node.
-      ///
-      /// This function gives back the next arc incoming to the
+      /// \brief Return the next arc incomming to the given node.
+      ///
+      /// This function gives back the next arc incomming to the
       /// given node.
       void nextIn(Arc&) const {}
@@ -1001,5 +771,5 @@
             n = digraph.baseNode(oait);
             n = digraph.runningNode(oait);
-            ignore_unused_variable_warning(n);
+            ::lemon::ignore_unused_variable_warning(n);
           }
         }
@@ -1049,7 +819,7 @@
       /// \brief Return the first edge incident to the given node.
       ///
-      /// This function gives back the first edge incident to the given
+      /// This function gives back the first edge incident to the given 
       /// node. The bool parameter gives back the direction for which the
-      /// source node of the directed arc representing the edge is the
+      /// source node of the directed arc representing the edge is the 
       /// given node.
       void firstInc(Edge&, bool&, const Node&) const {}
@@ -1058,5 +828,5 @@
       /// given node.
       ///
-      /// This function gives back the next edge incident to the given
+      /// This function gives back the next edge incident to the given 
       /// node. The bool parameter should be used as \c firstInc() use it.
       void nextInc(Edge&, bool&) const {}
@@ -1135,95 +905,4 @@
     };
 
-    /// \brief Skeleton class for iterable undirected bipartite graphs.
-    ///
-    /// This class describes the interface of iterable undirected
-    /// bipartite graphs. It extends \ref IterableGraphComponent with
-    /// the core iterable interface of undirected bipartite graphs.
-    /// This concept is part of the BpGraph concept.
-    template <typename BAS = BaseBpGraphComponent>
-    class IterableBpGraphComponent : public IterableGraphComponent<BAS> {
-    public:
-
-      typedef BAS Base;
-      typedef typename Base::Node Node;
-      typedef typename Base::RedNode RedNode;
-      typedef typename Base::BlueNode BlueNode;
-      typedef typename Base::Arc Arc;
-      typedef typename Base::Edge Edge;
-      
-      typedef IterableBpGraphComponent BpGraph;
-
-      using IterableGraphComponent<BAS>::first;
-      using IterableGraphComponent<BAS>::next;
-
-      /// \name Base Iteration
-      ///
-      /// This interface provides functions for iteration on red and blue nodes.
-      ///
-      /// @{
-
-      /// \brief Return the first red node.
-      ///
-      /// This function gives back the first red node in the iteration order.
-      void first(RedNode&) const {}
-
-      /// \brief Return the next red node.
-      ///
-      /// This function gives back the next red node in the iteration order.
-      void next(RedNode&) const {}
-
-      /// \brief Return the first blue node.
-      ///
-      /// This function gives back the first blue node in the iteration order.
-      void first(BlueNode&) const {}
-
-      /// \brief Return the next blue node.
-      ///
-      /// This function gives back the next blue node in the iteration order.
-      void next(BlueNode&) const {}
-
-
-      /// @}
-
-      /// \name Class Based Iteration
-      ///
-      /// This interface provides iterator classes for red and blue nodes.
-      ///
-      /// @{
-
-      /// \brief This iterator goes through each red node.
-      ///
-      /// This iterator goes through each red node.
-      typedef GraphItemIt<BpGraph, RedNode> RedNodeIt;
-
-      /// \brief This iterator goes through each blue node.
-      ///
-      /// This iterator goes through each blue node.
-      typedef GraphItemIt<BpGraph, BlueNode> BlueNodeIt;
-
-      /// @}
-
-      template <typename _BpGraph>
-      struct Constraints {
-        void constraints() {
-          checkConcept<IterableGraphComponent<Base>, _BpGraph>();
-
-          typename _BpGraph::RedNode rn(INVALID);
-          bpgraph.first(rn);
-          bpgraph.next(rn); 
-          typename _BpGraph::BlueNode bn(INVALID);
-          bpgraph.first(bn);
-          bpgraph.next(bn);
-
-          checkConcept<GraphItemIt<_BpGraph, typename _BpGraph::RedNode>,
-            typename _BpGraph::RedNodeIt>();
-          checkConcept<GraphItemIt<_BpGraph, typename _BpGraph::BlueNode>,
-            typename _BpGraph::BlueNodeIt>();
-        }
-
-        const _BpGraph& bpgraph;
-      };
-    };
-
     /// \brief Skeleton class for alterable directed graphs.
     ///
@@ -1251,12 +930,9 @@
       ArcNotifier;
 
-      mutable NodeNotifier node_notifier;
-      mutable ArcNotifier arc_notifier;
-
       /// \brief Return the node alteration notifier.
       ///
       /// This function gives back the node alteration notifier.
       NodeNotifier& notifier(Node) const {
-        return node_notifier;
+         return NodeNotifier();
       }
 
@@ -1265,5 +941,5 @@
       /// This function gives back the arc alteration notifier.
       ArcNotifier& notifier(Arc) const {
-        return arc_notifier;
+        return ArcNotifier();
       }
 
@@ -1278,6 +954,6 @@
             = digraph.notifier(typename _Digraph::Arc());
 
-          ignore_unused_variable_warning(nn);
-          ignore_unused_variable_warning(en);
+          ::lemon::ignore_unused_variable_warning(nn);
+          ::lemon::ignore_unused_variable_warning(en);
         }
 
@@ -1301,5 +977,4 @@
 
       typedef BAS Base;
-      typedef AlterableDigraphComponent<Base> Parent;
       typedef typename Base::Edge Edge;
 
@@ -1309,13 +984,9 @@
       EdgeNotifier;
 
-      mutable EdgeNotifier edge_notifier;
-
-      using Parent::notifier;
-
       /// \brief Return the edge alteration notifier.
       ///
       /// This function gives back the edge alteration notifier.
       EdgeNotifier& notifier(Edge) const {
-        return edge_notifier;
+        return EdgeNotifier();
       }
 
@@ -1326,5 +997,5 @@
           typename _Graph::EdgeNotifier& uen
             = graph.notifier(typename _Graph::Edge());
-          ignore_unused_variable_warning(uen);
+          ::lemon::ignore_unused_variable_warning(uen);
         }
 
@@ -1334,70 +1005,8 @@
     };
 
-    /// \brief Skeleton class for alterable undirected bipartite graphs.
-    ///
-    /// This class describes the interface of alterable undirected
-    /// bipartite graphs. It extends \ref AlterableGraphComponent with
-    /// the alteration notifier interface of bipartite graphs. It
-    /// implements an observer-notifier pattern for the red and blue
-    /// nodes. More obsevers can be registered into the notifier and
-    /// whenever an alteration occured in the graph all the observers
-    /// will be notified about it.
-    template <typename BAS = BaseBpGraphComponent>
-    class AlterableBpGraphComponent : public AlterableGraphComponent<BAS> {
-    public:
-
-      typedef BAS Base;
-      typedef AlterableGraphComponent<Base> Parent;
-      typedef typename Base::RedNode RedNode;
-      typedef typename Base::BlueNode BlueNode;
-
-
-      /// Red node alteration notifier class.
-      typedef AlterationNotifier<AlterableBpGraphComponent, RedNode>
-      RedNodeNotifier;
-
-      /// Blue node alteration notifier class.
-      typedef AlterationNotifier<AlterableBpGraphComponent, BlueNode>
-      BlueNodeNotifier;
-
-      mutable RedNodeNotifier red_node_notifier;
-      mutable BlueNodeNotifier blue_node_notifier;
-
-      using Parent::notifier;
-
-      /// \brief Return the red node alteration notifier.
-      ///
-      /// This function gives back the red node alteration notifier.
-      RedNodeNotifier& notifier(RedNode) const {
-        return red_node_notifier;
-      }
-
-      /// \brief Return the blue node alteration notifier.
-      ///
-      /// This function gives back the blue node alteration notifier.
-      BlueNodeNotifier& notifier(BlueNode) const {
-        return blue_node_notifier;
-      }
-
-      template <typename _BpGraph>
-      struct Constraints {
-        void constraints() {
-          checkConcept<AlterableGraphComponent<Base>, _BpGraph>();
-          typename _BpGraph::RedNodeNotifier& rnn
-            = bpgraph.notifier(typename _BpGraph::RedNode());
-          typename _BpGraph::BlueNodeNotifier& bnn
-            = bpgraph.notifier(typename _BpGraph::BlueNode());
-          ignore_unused_variable_warning(rnn);
-          ignore_unused_variable_warning(bnn);
-        }
-
-        const _BpGraph& bpgraph;
-      };
-    };
-
     /// \brief Concept class for standard graph maps.
     ///
     /// This class describes the concept of standard graph maps, i.e.
-    /// the \c NodeMap, \c ArcMap and \c EdgeMap subtypes of digraph and
+    /// the \c NodeMap, \c ArcMap and \c EdgeMap subtypes of digraph and 
     /// graph types, which can be used for associating data to graph items.
     /// The standard graph maps must conform to the ReferenceMap concept.
@@ -1454,5 +1063,5 @@
           _Map m1(g);
           _Map m2(g,t);
-
+          
           // Copy constructor
           // _Map m3(m);
@@ -1462,7 +1071,7 @@
           // m3 = cmap;
 
-          ignore_unused_variable_warning(m1);
-          ignore_unused_variable_warning(m2);
-          // ignore_unused_variable_warning(m3);
+          ::lemon::ignore_unused_variable_warning(m1);
+          ::lemon::ignore_unused_variable_warning(m2);
+          // ::lemon::ignore_unused_variable_warning(m3);
         }
 
@@ -1478,5 +1087,5 @@
     ///
     /// This class describes the interface of mappable directed graphs.
-    /// It extends \ref BaseDigraphComponent with the standard digraph
+    /// It extends \ref BaseDigraphComponent with the standard digraph 
     /// map classes, namely \c NodeMap and \c ArcMap.
     /// This concept is part of the Digraph concept.
@@ -1616,5 +1225,5 @@
     ///
     /// This class describes the interface of mappable undirected graphs.
-    /// It extends \ref MappableDigraphComponent with the standard graph
+    /// It extends \ref MappableDigraphComponent with the standard graph 
     /// map class for edges (\c EdgeMap).
     /// This concept is part of the Graph concept.
@@ -1699,152 +1308,8 @@
     };
 
-    /// \brief Skeleton class for mappable undirected bipartite graphs.
-    ///
-    /// This class describes the interface of mappable undirected
-    /// bipartite graphs.  It extends \ref MappableGraphComponent with
-    /// the standard graph map class for red and blue nodes (\c
-    /// RedNodeMap and BlueNodeMap). This concept is part of the
-    /// BpGraph concept.
-    template <typename BAS = BaseBpGraphComponent>
-    class MappableBpGraphComponent : public MappableGraphComponent<BAS>  {
-    public:
-
-      typedef BAS Base;
-      typedef typename Base::Node Node;
-
-      typedef MappableBpGraphComponent BpGraph;
-
-      /// \brief Standard graph map for the red nodes.
-      ///
-      /// Standard graph map for the red nodes.
-      /// It conforms to the ReferenceMap concept.
-      template <typename V>
-      class RedNodeMap : public GraphMap<MappableBpGraphComponent, Node, V> {
-        typedef GraphMap<MappableBpGraphComponent, Node, V> Parent;
-
-      public:
-        /// \brief Construct a new map.
-        ///
-        /// Construct a new map for the graph.
-        explicit RedNodeMap(const MappableBpGraphComponent& graph)
-          : Parent(graph) {}
-
-        /// \brief Construct a new map with default value.
-        ///
-        /// Construct a new map for the graph and initalize the values.
-        RedNodeMap(const MappableBpGraphComponent& graph, const V& value)
-          : Parent(graph, value) {}
-
-      private:
-        /// \brief Copy constructor.
-        ///
-        /// Copy Constructor.
-        RedNodeMap(const RedNodeMap& nm) : Parent(nm) {}
-
-        /// \brief Assignment operator.
-        ///
-        /// Assignment operator.
-        template <typename CMap>
-        RedNodeMap& operator=(const CMap&) {
-          checkConcept<ReadMap<Node, V>, CMap>();
-          return *this;
-        }
-
-      };
-
-      /// \brief Standard graph map for the blue nodes.
-      ///
-      /// Standard graph map for the blue nodes.
-      /// It conforms to the ReferenceMap concept.
-      template <typename V>
-      class BlueNodeMap : public GraphMap<MappableBpGraphComponent, Node, V> {
-        typedef GraphMap<MappableBpGraphComponent, Node, V> Parent;
-
-      public:
-        /// \brief Construct a new map.
-        ///
-        /// Construct a new map for the graph.
-        explicit BlueNodeMap(const MappableBpGraphComponent& graph)
-          : Parent(graph) {}
-
-        /// \brief Construct a new map with default value.
-        ///
-        /// Construct a new map for the graph and initalize the values.
-        BlueNodeMap(const MappableBpGraphComponent& graph, const V& value)
-          : Parent(graph, value) {}
-
-      private:
-        /// \brief Copy constructor.
-        ///
-        /// Copy Constructor.
-        BlueNodeMap(const BlueNodeMap& nm) : Parent(nm) {}
-
-        /// \brief Assignment operator.
-        ///
-        /// Assignment operator.
-        template <typename CMap>
-        BlueNodeMap& operator=(const CMap&) {
-          checkConcept<ReadMap<Node, V>, CMap>();
-          return *this;
-        }
-
-      };
-
-
-      template <typename _BpGraph>
-      struct Constraints {
-
-        struct Dummy {
-          int value;
-          Dummy() : value(0) {}
-          Dummy(int _v) : value(_v) {}
-        };
-
-        void constraints() {
-          checkConcept<MappableGraphComponent<Base>, _BpGraph>();
-
-          { // int map test
-            typedef typename _BpGraph::template RedNodeMap<int>
-              IntRedNodeMap;
-            checkConcept<GraphMap<_BpGraph, typename _BpGraph::RedNode, int>,
-              IntRedNodeMap >();
-          } { // bool map test
-            typedef typename _BpGraph::template RedNodeMap<bool>
-              BoolRedNodeMap;
-            checkConcept<GraphMap<_BpGraph, typename _BpGraph::RedNode, bool>,
-              BoolRedNodeMap >();
-          } { // Dummy map test
-            typedef typename _BpGraph::template RedNodeMap<Dummy>
-              DummyRedNodeMap;
-            checkConcept<GraphMap<_BpGraph, typename _BpGraph::RedNode, Dummy>,
-              DummyRedNodeMap >();
-          }
-
-          { // int map test
-            typedef typename _BpGraph::template BlueNodeMap<int>
-              IntBlueNodeMap;
-            checkConcept<GraphMap<_BpGraph, typename _BpGraph::BlueNode, int>,
-              IntBlueNodeMap >();
-          } { // bool map test
-            typedef typename _BpGraph::template BlueNodeMap<bool>
-              BoolBlueNodeMap;
-            checkConcept<GraphMap<_BpGraph, typename _BpGraph::BlueNode, bool>,
-              BoolBlueNodeMap >();
-          } { // Dummy map test
-            typedef typename _BpGraph::template BlueNodeMap<Dummy>
-              DummyBlueNodeMap;
-            checkConcept<GraphMap<_BpGraph, typename _BpGraph::BlueNode, Dummy>,
-              DummyBlueNodeMap >();
-          }
-        }
-
-        const _BpGraph& bpgraph;
-      };
-    };
-
     /// \brief Skeleton class for extendable directed graphs.
     ///
     /// This class describes the interface of extendable directed graphs.
-    /// It extends \ref BaseDigraphComponent with functions for adding
+    /// It extends \ref BaseDigraphComponent with functions for adding 
     /// nodes and arcs to the digraph.
     /// This concept requires \ref AlterableDigraphComponent.
@@ -1891,5 +1356,5 @@
     ///
     /// This class describes the interface of extendable undirected graphs.
-    /// It extends \ref BaseGraphComponent with functions for adding
+    /// It extends \ref BaseGraphComponent with functions for adding 
     /// nodes and edges to the graph.
     /// This concept requires \ref AlterableGraphComponent.
@@ -1933,67 +1398,8 @@
     };
 
-    /// \brief Skeleton class for extendable undirected bipartite graphs.
-    ///
-    /// This class describes the interface of extendable undirected
-    /// bipartite graphs. It extends \ref BaseGraphComponent with
-    /// functions for adding nodes and edges to the graph. This
-    /// concept requires \ref AlterableBpGraphComponent.
-    template <typename BAS = BaseBpGraphComponent>
-    class ExtendableBpGraphComponent : public BAS {
-    public:
-
-      typedef BAS Base;
-      typedef typename Base::Node Node;
-      typedef typename Base::RedNode RedNode;
-      typedef typename Base::BlueNode BlueNode;
-      typedef typename Base::Edge Edge;
-
-      /// \brief Add a new red node to the digraph.
-      ///
-      /// This function adds a red new node to the digraph.
-      RedNode addRedNode() {
-        return INVALID;
-      }
-
-      /// \brief Add a new blue node to the digraph.
-      ///
-      /// This function adds a blue new node to the digraph.
-      BlueNode addBlueNode() {
-        return INVALID;
-      }
-
-      /// \brief Add a new edge connecting the given two nodes.
-      ///
-      /// This function adds a new edge connecting the given two nodes
-      /// of the graph. The first node has to be a red node, and the
-      /// second one a blue node.
-      Edge addEdge(const RedNode&, const BlueNode&) {
-        return INVALID;
-      }
-      Edge addEdge(const BlueNode&, const RedNode&) {
-        return INVALID;
-      }
-
-      template <typename _BpGraph>
-      struct Constraints {
-        void constraints() {
-          checkConcept<Base, _BpGraph>();
-          typename _BpGraph::RedNode red_node;
-          typename _BpGraph::BlueNode blue_node;
-          red_node = bpgraph.addRedNode();
-          blue_node = bpgraph.addBlueNode();
-          typename _BpGraph::Edge edge;
-          edge = bpgraph.addEdge(red_node, blue_node);
-          edge = bpgraph.addEdge(blue_node, red_node);
-        }
-
-        _BpGraph& bpgraph;
-      };
-    };
-
     /// \brief Skeleton class for erasable directed graphs.
     ///
     /// This class describes the interface of erasable directed graphs.
-    /// It extends \ref BaseDigraphComponent with functions for removing
+    /// It extends \ref BaseDigraphComponent with functions for removing 
     /// nodes and arcs from the digraph.
     /// This concept requires \ref AlterableDigraphComponent.
@@ -2008,5 +1414,5 @@
       /// \brief Erase a node from the digraph.
       ///
-      /// This function erases the given node from the digraph and all arcs
+      /// This function erases the given node from the digraph and all arcs 
       /// connected to the node.
       void erase(const Node&) {}
@@ -2035,5 +1441,5 @@
     ///
     /// This class describes the interface of erasable undirected graphs.
-    /// It extends \ref BaseGraphComponent with functions for removing
+    /// It extends \ref BaseGraphComponent with functions for removing 
     /// nodes and edges from the graph.
     /// This concept requires \ref AlterableGraphComponent.
@@ -2071,13 +1477,4 @@
       };
     };
-
-    /// \brief Skeleton class for erasable undirected graphs.
-    ///
-    /// This class describes the interface of erasable undirected
-    /// bipartite graphs. It extends \ref BaseBpGraphComponent with
-    /// functions for removing nodes and edges from the graph. This
-    /// concept requires \ref AlterableBpGraphComponent.
-    template <typename BAS = BaseBpGraphComponent>
-    class ErasableBpGraphComponent : public ErasableGraphComponent<BAS> {};
 
     /// \brief Skeleton class for clearable directed graphs.
@@ -2117,14 +1514,25 @@
     /// This concept requires \ref AlterableGraphComponent.
     template <typename BAS = BaseGraphComponent>
-    class ClearableGraphComponent : public ClearableDigraphComponent<BAS> {};
-
-    /// \brief Skeleton class for clearable undirected biparite graphs.
-    ///
-    /// This class describes the interface of clearable undirected
-    /// bipartite graphs. It extends \ref BaseBpGraphComponent with a
-    /// function for clearing the graph.  This concept requires \ref
-    /// AlterableBpGraphComponent.
-    template <typename BAS = BaseBpGraphComponent>
-    class ClearableBpGraphComponent : public ClearableGraphComponent<BAS> {};
+    class ClearableGraphComponent : public ClearableDigraphComponent<BAS> {
+    public:
+
+      typedef BAS Base;
+
+      /// \brief Erase all nodes and edges from the graph.
+      ///
+      /// This function erases all nodes and edges from the graph.
+      void clear() {}
+
+      template <typename _Graph>
+      struct Constraints {
+        void constraints() {
+          checkConcept<Base, _Graph>();
+          graph.clear();
+        }
+
+        _Graph& graph;
+        Constraints() {}
+      };
+    };
 
   }
