Index: lemon/concepts/bpugraph.h
===================================================================
--- lemon/concepts/bpugraph.h	(revision 2474)
+++ lemon/concepts/bpugraph.h	(revision 2485)
@@ -34,6 +34,5 @@
   namespace concepts {
 
-    /// \addtogroup graph_concepts
-    /// @{
+    /// \ingroup graph_concepts
     ///
     /// \brief Class describing the concept of Bipartite Undirected Graphs.
@@ -999,7 +998,4 @@
     };
 
-
-    /// @}
-
   }
 
Index: lemon/concepts/graph.h
===================================================================
--- lemon/concepts/graph.h	(revision 2474)
+++ lemon/concepts/graph.h	(revision 2485)
@@ -33,6 +33,5 @@
   namespace concepts {
 
-    /// \addtogroup graph_concepts
-    /// @{
+    /// \ingroup graph_concepts
     ///
     /// \brief Class describing the concept of Directed Graphs.
@@ -447,5 +446,4 @@
     };
     
-    // @}
   } //namespace concepts  
 } //namespace lemon
Index: lemon/concepts/graph_components.h
===================================================================
--- lemon/concepts/graph_components.h	(revision 2474)
+++ lemon/concepts/graph_components.h	(revision 2485)
@@ -1483,6 +1483,4 @@
       template <typename _Value>
       class NodeMap : public GraphMap<Graph, Node, _Value> {
-      private:
-	NodeMap();
       public:
         typedef GraphMap<MappableGraphComponent, Node, _Value> Parent;
@@ -1491,5 +1489,4 @@
 	///
 	/// Construct a new map for the graph.
-	/// \todo call the right parent class constructor
 	explicit NodeMap(const MappableGraphComponent& graph) 
           : Parent(graph) {}
@@ -1523,6 +1520,4 @@
       template <typename _Value>
       class EdgeMap : public GraphMap<Graph, Edge, _Value> {
-      private:
-	EdgeMap();
       public:
         typedef GraphMap<MappableGraphComponent, Edge, _Value> Parent;
@@ -1531,5 +1526,4 @@
 	///
 	/// Construct a new map for the graph.
-	/// \todo call the right parent class constructor
 	explicit EdgeMap(const MappableGraphComponent& graph) 
           : Parent(graph) {}
@@ -1628,5 +1622,4 @@
 	///
 	/// Construct a new map for the graph.
-	/// \todo call the right parent class constructor
 	explicit UEdgeMap(const MappableUGraphComponent& graph) 
           : Parent(graph) {}
@@ -1713,5 +1706,4 @@
 	///
 	/// Construct a new map for the graph.
-	/// \todo call the right parent class constructor
 	explicit ANodeMap(const MappableBpUGraphComponent& graph) 
           : Parent(graph) {}
@@ -1751,5 +1743,4 @@
 	///
 	/// Construct a new map for the graph.
-	/// \todo call the right parent class constructor
 	explicit BNodeMap(const MappableBpUGraphComponent& graph) 
           : Parent(graph) {}
Index: lemon/concepts/ugraph.h
===================================================================
--- lemon/concepts/ugraph.h	(revision 2474)
+++ lemon/concepts/ugraph.h	(revision 2485)
@@ -31,6 +31,5 @@
   namespace concepts {
 
-    /// \addtogroup graph_concepts
-    /// @{
+    /// \ingroup graph_concepts
     ///
     /// \brief Class describing the concept of Undirected Graphs.
@@ -697,6 +696,4 @@
     };
 
-    /// @}
-
   }
 
Index: lemon/graph_utils.h
===================================================================
--- lemon/graph_utils.h	(revision 2476)
+++ lemon/graph_utils.h	(revision 2485)
@@ -147,6 +147,7 @@
   /// graph structures it is specialized to run in O(1).
   ///
-  /// \todo Refer how to specialize it.
-
+  /// If the graph contains a \e nodeNum() member function and a 
+  /// \e NodeNumTag tag then this function calls directly the member
+  /// function to query the cardinality of the node set.
   template <typename Graph>
   inline int countNodes(const Graph& g) {
@@ -180,6 +181,7 @@
   /// graph structures it is specialized to run in O(1).
   ///
-  /// \todo Refer how to specialize it.
-
+  /// If the graph contains an \e aNodeNum() member function and a 
+  /// \e NodeNumTag tag then this function calls directly the member
+  /// function to query the cardinality of the A-node set.
   template <typename Graph>
   inline int countANodes(const Graph& g) {
@@ -213,6 +215,7 @@
   /// graph structures it is specialized to run in O(1).
   ///
-  /// \todo Refer how to specialize it.
-
+  /// If the graph contains a \e bNodeNum() member function and a 
+  /// \e NodeNumTag tag then this function calls directly the member
+  /// function to query the cardinality of the B-node set.
   template <typename Graph>
   inline int countBNodes(const Graph& g) {
@@ -248,5 +251,8 @@
   /// The complexity of the function is O(e) but for some
   /// graph structures it is specialized to run in O(1).
-
+  ///
+  /// If the graph contains a \e edgeNum() member function and a 
+  /// \e EdgeNumTag tag then this function calls directly the member
+  /// function to query the cardinality of the edge set.
   template <typename Graph>
   inline int countEdges(const Graph& g) {
@@ -280,5 +286,8 @@
   /// The complexity of the function is O(e) but for some
   /// graph structures it is specialized to run in O(1).
-
+  ///
+  /// If the graph contains a \e uEdgeNum() member function and a 
+  /// \e EdgeNumTag tag then this function calls directly the member
+  /// function to query the cardinality of the undirected edge set.
   template <typename Graph>
   inline int countUEdges(const Graph& g) {
@@ -560,24 +569,24 @@
   /// \brief Copy a map.
   ///
-  /// This function copies the \c source map to the \c target map. It uses the
+  /// This function copies the \c from map to the \c to map. It uses the
   /// given iterator to iterate on the data structure and it uses the \c ref
-  /// mapping to convert the source's keys to the target's keys.
-  template <typename Target, typename Source, 
+  /// mapping to convert the from's keys to the to's keys.
+  template <typename To, typename From, 
 	    typename ItemIt, typename Ref>	    
-  void copyMap(Target& target, const Source& source, 
+  void copyMap(To& to, const From& from, 
 	       ItemIt it, const Ref& ref) {
     for (; it != INVALID; ++it) {
-      target[ref[it]] = source[it];
-    }
-  }
-
-  /// \brief Copy the source map to the target map.
-  ///
-  /// Copy the \c source map to the \c target map. It uses the given iterator
+      to[ref[it]] = from[it];
+    }
+  }
+
+  /// \brief Copy the from map to the to map.
+  ///
+  /// Copy the \c from map to the \c to map. It uses the given iterator
   /// to iterate on the data structure.
-  template <typename Target, typename Source, typename ItemIt>	    
-  void copyMap(Target& target, const Source& source, ItemIt it) {
+  template <typename To, typename From, typename ItemIt>	    
+  void copyMap(To& to, const From& from, ItemIt it) {
     for (; it != INVALID; ++it) {
-      target[it] = source[it];
+      to[it] = from[it];
     }
   }
@@ -588,5 +597,5 @@
     class MapCopyBase {
     public:
-      virtual void copy(const Graph& source, const RefMap& refMap) = 0;
+      virtual void copy(const Graph& from, const RefMap& refMap) = 0;
       
       virtual ~MapCopyBase() {}
@@ -594,9 +603,9 @@
 
     template <typename Graph, typename Item, typename RefMap, 
-              typename TargetMap, typename SourceMap>
+              typename ToMap, typename FromMap>
     class MapCopy : public MapCopyBase<Graph, Item, RefMap> {
     public:
 
-      MapCopy(TargetMap& tmap, const SourceMap& map) 
+      MapCopy(ToMap& tmap, const FromMap& map) 
         : _tmap(tmap), _map(map) {}
       
@@ -609,6 +618,6 @@
 
     private:
-      TargetMap& _tmap;
-      const SourceMap& _map;
+      ToMap& _tmap;
+      const FromMap& _map;
     };
 
@@ -665,13 +674,13 @@
     template <typename Graph, typename Enable = void>
     struct GraphCopySelector {
-      template <typename Source, typename NodeRefMap, typename EdgeRefMap>
-      static void copy(Graph &target, const Source& source,
+      template <typename From, typename NodeRefMap, typename EdgeRefMap>
+      static void copy(Graph &to, const From& from,
                        NodeRefMap& nodeRefMap, EdgeRefMap& edgeRefMap) {
-        for (typename Source::NodeIt it(source); it != INVALID; ++it) {
-          nodeRefMap[it] = target.addNode();
+        for (typename From::NodeIt it(from); it != INVALID; ++it) {
+          nodeRefMap[it] = to.addNode();
         }
-        for (typename Source::EdgeIt it(source); it != INVALID; ++it) {
-          edgeRefMap[it] = target.addEdge(nodeRefMap[source.source(it)], 
-                                          nodeRefMap[source.target(it)]);
+        for (typename From::EdgeIt it(from); it != INVALID; ++it) {
+          edgeRefMap[it] = to.addEdge(nodeRefMap[from.source(it)], 
+                                          nodeRefMap[from.target(it)]);
         }
       }
@@ -683,8 +692,8 @@
       typename enable_if<typename Graph::BuildTag, void>::type> 
     {
-      template <typename Source, typename NodeRefMap, typename EdgeRefMap>
-      static void copy(Graph &target, const Source& source,
+      template <typename From, typename NodeRefMap, typename EdgeRefMap>
+      static void copy(Graph &to, const From& from,
                        NodeRefMap& nodeRefMap, EdgeRefMap& edgeRefMap) {
-        target.build(source, nodeRefMap, edgeRefMap);
+        to.build(from, nodeRefMap, edgeRefMap);
       }
     };
@@ -692,13 +701,13 @@
     template <typename UGraph, typename Enable = void>
     struct UGraphCopySelector {
-      template <typename Source, typename NodeRefMap, typename UEdgeRefMap>
-      static void copy(UGraph &target, const Source& source,
+      template <typename From, typename NodeRefMap, typename UEdgeRefMap>
+      static void copy(UGraph &to, const From& from,
                        NodeRefMap& nodeRefMap, UEdgeRefMap& uEdgeRefMap) {
-        for (typename Source::NodeIt it(source); it != INVALID; ++it) {
-          nodeRefMap[it] = target.addNode();
+        for (typename From::NodeIt it(from); it != INVALID; ++it) {
+          nodeRefMap[it] = to.addNode();
         }
-        for (typename Source::UEdgeIt it(source); it != INVALID; ++it) {
-          uEdgeRefMap[it] = target.addEdge(nodeRefMap[source.source(it)], 
-                                          nodeRefMap[source.target(it)]);
+        for (typename From::UEdgeIt it(from); it != INVALID; ++it) {
+          uEdgeRefMap[it] = to.addEdge(nodeRefMap[from.source(it)], 
+				       nodeRefMap[from.target(it)]);
         }
       }
@@ -710,8 +719,8 @@
       typename enable_if<typename UGraph::BuildTag, void>::type> 
     {
-      template <typename Source, typename NodeRefMap, typename UEdgeRefMap>
-      static void copy(UGraph &target, const Source& source,
+      template <typename From, typename NodeRefMap, typename UEdgeRefMap>
+      static void copy(UGraph &to, const From& from,
                        NodeRefMap& nodeRefMap, UEdgeRefMap& uEdgeRefMap) {
-        target.build(source, nodeRefMap, uEdgeRefMap);
+        to.build(from, nodeRefMap, uEdgeRefMap);
       }
     };
@@ -719,18 +728,18 @@
     template <typename BpUGraph, typename Enable = void>
     struct BpUGraphCopySelector {
-      template <typename Source, typename ANodeRefMap, 
+      template <typename From, typename ANodeRefMap, 
                 typename BNodeRefMap, typename UEdgeRefMap>
-      static void copy(BpUGraph &target, const Source& source,
+      static void copy(BpUGraph &to, const From& from,
                        ANodeRefMap& aNodeRefMap, BNodeRefMap& bNodeRefMap,
                        UEdgeRefMap& uEdgeRefMap) {
-        for (typename Source::ANodeIt it(source); it != INVALID; ++it) {
-          aNodeRefMap[it] = target.addANode();
+        for (typename From::ANodeIt it(from); it != INVALID; ++it) {
+          aNodeRefMap[it] = to.addANode();
         }
-        for (typename Source::BNodeIt it(source); it != INVALID; ++it) {
-          bNodeRefMap[it] = target.addBNode();
+        for (typename From::BNodeIt it(from); it != INVALID; ++it) {
+          bNodeRefMap[it] = to.addBNode();
         }
-        for (typename Source::UEdgeIt it(source); it != INVALID; ++it) {
-          uEdgeRefMap[it] = target.addEdge(aNodeRefMap[source.aNode(it)], 
-                                           bNodeRefMap[source.bNode(it)]);
+        for (typename From::UEdgeIt it(from); it != INVALID; ++it) {
+          uEdgeRefMap[it] = to.addEdge(aNodeRefMap[from.aNode(it)], 
+                                           bNodeRefMap[from.bNode(it)]);
         }
       }
@@ -742,10 +751,10 @@
       typename enable_if<typename BpUGraph::BuildTag, void>::type> 
     {
-      template <typename Source, typename ANodeRefMap, 
+      template <typename From, typename ANodeRefMap, 
                 typename BNodeRefMap, typename UEdgeRefMap>
-      static void copy(BpUGraph &target, const Source& source,
+      static void copy(BpUGraph &to, const From& from,
                        ANodeRefMap& aNodeRefMap, BNodeRefMap& bNodeRefMap,
                        UEdgeRefMap& uEdgeRefMap) {
-        target.build(source, aNodeRefMap, bNodeRefMap, uEdgeRefMap);
+        to.build(from, aNodeRefMap, bNodeRefMap, uEdgeRefMap);
       }
     };
@@ -758,18 +767,18 @@
   /// Class to copy a graph to another graph (duplicate a graph). The
   /// simplest way of using it is through the \c copyGraph() function.
-  template <typename Target, typename Source>
+  template <typename To, typename From>
   class GraphCopy {
   private:
 
-    typedef typename Source::Node Node;
-    typedef typename Source::NodeIt NodeIt;
-    typedef typename Source::Edge Edge;
-    typedef typename Source::EdgeIt EdgeIt;
-
-    typedef typename Target::Node TNode;
-    typedef typename Target::Edge TEdge;
-
-    typedef typename Source::template NodeMap<TNode> NodeRefMap;
-    typedef typename Source::template EdgeMap<TEdge> EdgeRefMap;
+    typedef typename From::Node Node;
+    typedef typename From::NodeIt NodeIt;
+    typedef typename From::Edge Edge;
+    typedef typename From::EdgeIt EdgeIt;
+
+    typedef typename To::Node TNode;
+    typedef typename To::Edge TEdge;
+
+    typedef typename From::template NodeMap<TNode> NodeRefMap;
+    typedef typename From::template EdgeMap<TEdge> EdgeRefMap;
     
     
@@ -779,8 +788,8 @@
     /// \brief Constructor for the GraphCopy.
     ///
-    /// It copies the content of the \c _source graph into the
-    /// \c _target graph.
-    GraphCopy(Target& _target, const Source& _source) 
-      : source(_source), target(_target) {}
+    /// It copies the content of the \c _from graph into the
+    /// \c _to graph.
+    GraphCopy(To& _to, const From& _from) 
+      : from(_from), to(_to) {}
 
     /// \brief Destructor of the GraphCopy
@@ -802,5 +811,5 @@
     template <typename NodeRef>
     GraphCopy& nodeRef(NodeRef& map) {
-      nodeMapCopies.push_back(new _graph_utils_bits::RefCopy<Source, Node, 
+      nodeMapCopies.push_back(new _graph_utils_bits::RefCopy<From, Node, 
                               NodeRefMap, NodeRef>(map));
       return *this;
@@ -813,5 +822,5 @@
     template <typename NodeCrossRef>
     GraphCopy& nodeCrossRef(NodeCrossRef& map) {
-      nodeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<Source, Node,
+      nodeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<From, Node,
                               NodeRefMap, NodeCrossRef>(map));
       return *this;
@@ -821,11 +830,11 @@
     ///
     /// Makes copy of the given map for the newly created graph. 
-    /// The new map's key type is the target graph's node type,
-    /// and the copied map's key type is the source graph's node
+    /// The new map's key type is the to graph's node type,
+    /// and the copied map's key type is the from graph's node
     /// type.  
-    template <typename TargetMap, typename SourceMap>
-    GraphCopy& nodeMap(TargetMap& tmap, const SourceMap& map) {
-      nodeMapCopies.push_back(new _graph_utils_bits::MapCopy<Source, Node, 
-                              NodeRefMap, TargetMap, SourceMap>(tmap, map));
+    template <typename ToMap, typename FromMap>
+    GraphCopy& nodeMap(ToMap& tmap, const FromMap& map) {
+      nodeMapCopies.push_back(new _graph_utils_bits::MapCopy<From, Node, 
+                              NodeRefMap, ToMap, FromMap>(tmap, map));
       return *this;
     }
@@ -835,5 +844,5 @@
     /// Make a copy of the given node.
     GraphCopy& node(TNode& tnode, const Node& snode) {
-      nodeMapCopies.push_back(new _graph_utils_bits::ItemCopy<Source, Node, 
+      nodeMapCopies.push_back(new _graph_utils_bits::ItemCopy<From, Node, 
                               NodeRefMap, TNode>(tnode, snode));
       return *this;
@@ -845,5 +854,5 @@
     template <typename EdgeRef>
     GraphCopy& edgeRef(EdgeRef& map) {
-      edgeMapCopies.push_back(new _graph_utils_bits::RefCopy<Source, Edge, 
+      edgeMapCopies.push_back(new _graph_utils_bits::RefCopy<From, Edge, 
                               EdgeRefMap, EdgeRef>(map));
       return *this;
@@ -856,5 +865,5 @@
     template <typename EdgeCrossRef>
     GraphCopy& edgeCrossRef(EdgeCrossRef& map) {
-      edgeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<Source, Edge,
+      edgeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<From, Edge,
                               EdgeRefMap, EdgeCrossRef>(map));
       return *this;
@@ -864,11 +873,11 @@
     ///
     /// Makes copy of the given map for the newly created graph. 
-    /// The new map's key type is the target graph's edge type,
-    /// and the copied map's key type is the source graph's edge
+    /// The new map's key type is the to graph's edge type,
+    /// and the copied map's key type is the from graph's edge
     /// type.  
-    template <typename TargetMap, typename SourceMap>
-    GraphCopy& edgeMap(TargetMap& tmap, const SourceMap& map) {
-      edgeMapCopies.push_back(new _graph_utils_bits::MapCopy<Source, Edge, 
-                              EdgeRefMap, TargetMap, SourceMap>(tmap, map));
+    template <typename ToMap, typename FromMap>
+    GraphCopy& edgeMap(ToMap& tmap, const FromMap& map) {
+      edgeMapCopies.push_back(new _graph_utils_bits::MapCopy<From, Edge, 
+                              EdgeRefMap, ToMap, FromMap>(tmap, map));
       return *this;
     }
@@ -878,5 +887,5 @@
     /// Make a copy of the given edge.
     GraphCopy& edge(TEdge& tedge, const Edge& sedge) {
-      edgeMapCopies.push_back(new _graph_utils_bits::ItemCopy<Source, Edge, 
+      edgeMapCopies.push_back(new _graph_utils_bits::ItemCopy<From, Edge, 
                               EdgeRefMap, TEdge>(tedge, sedge));
       return *this;
@@ -887,13 +896,13 @@
     /// Executes the copies.
     void run() {
-      NodeRefMap nodeRefMap(source);
-      EdgeRefMap edgeRefMap(source);
-      _graph_utils_bits::GraphCopySelector<Target>::
-        copy(target, source, nodeRefMap, edgeRefMap);
+      NodeRefMap nodeRefMap(from);
+      EdgeRefMap edgeRefMap(from);
+      _graph_utils_bits::GraphCopySelector<To>::
+        copy(to, from, nodeRefMap, edgeRefMap);
       for (int i = 0; i < int(nodeMapCopies.size()); ++i) {
-        nodeMapCopies[i]->copy(source, nodeRefMap);
+        nodeMapCopies[i]->copy(from, nodeRefMap);
       }
       for (int i = 0; i < int(edgeMapCopies.size()); ++i) {
-        edgeMapCopies[i]->copy(source, edgeRefMap);
+        edgeMapCopies[i]->copy(from, edgeRefMap);
       }      
     }
@@ -902,11 +911,11 @@
 
 
-    const Source& source;
-    Target& target;
-
-    std::vector<_graph_utils_bits::MapCopyBase<Source, Node, NodeRefMap>* > 
+    const From& from;
+    To& to;
+
+    std::vector<_graph_utils_bits::MapCopyBase<From, Node, NodeRefMap>* > 
     nodeMapCopies;
 
-    std::vector<_graph_utils_bits::MapCopyBase<Source, Edge, EdgeRefMap>* > 
+    std::vector<_graph_utils_bits::MapCopyBase<From, Edge, EdgeRefMap>* > 
     edgeMapCopies;
 
@@ -923,12 +932,12 @@
   /// 
   /// After the copy the \c nr map will contain the mapping from the
-  /// source graph's nodes to the target graph's nodes and the \c ecr will
-  /// contain the mapping from the target graph's edges to the source's
+  /// from graph's nodes to the to graph's nodes and the \c ecr will
+  /// contain the mapping from the to graph's edges to the from's
   /// edges.
   ///
   /// \see GraphCopy 
-  template <typename Target, typename Source>
-  GraphCopy<Target, Source> copyGraph(Target& target, const Source& source) {
-    return GraphCopy<Target, Source>(target, source);
+  template <typename To, typename From>
+  GraphCopy<To, From> copyGraph(To& to, const From& from) {
+    return GraphCopy<To, From>(to, from);
   }
 
@@ -937,41 +946,41 @@
   /// Class to copy an undirected graph to another graph (duplicate a graph).
   /// The simplest way of using it is through the \c copyUGraph() function.
-  template <typename Target, typename Source>
+  template <typename To, typename From>
   class UGraphCopy {
   private:
 
-    typedef typename Source::Node Node;
-    typedef typename Source::NodeIt NodeIt;
-    typedef typename Source::Edge Edge;
-    typedef typename Source::EdgeIt EdgeIt;
-    typedef typename Source::UEdge UEdge;
-    typedef typename Source::UEdgeIt UEdgeIt;
-
-    typedef typename Target::Node TNode;
-    typedef typename Target::Edge TEdge;
-    typedef typename Target::UEdge TUEdge;
-
-    typedef typename Source::template NodeMap<TNode> NodeRefMap;
-    typedef typename Source::template UEdgeMap<TUEdge> UEdgeRefMap;
+    typedef typename From::Node Node;
+    typedef typename From::NodeIt NodeIt;
+    typedef typename From::Edge Edge;
+    typedef typename From::EdgeIt EdgeIt;
+    typedef typename From::UEdge UEdge;
+    typedef typename From::UEdgeIt UEdgeIt;
+
+    typedef typename To::Node TNode;
+    typedef typename To::Edge TEdge;
+    typedef typename To::UEdge TUEdge;
+
+    typedef typename From::template NodeMap<TNode> NodeRefMap;
+    typedef typename From::template UEdgeMap<TUEdge> UEdgeRefMap;
 
     struct EdgeRefMap {
-      EdgeRefMap(const Target& _target, const Source& _source,
+      EdgeRefMap(const To& _to, const From& _from,
                  const UEdgeRefMap& _uedge_ref, const NodeRefMap& _node_ref) 
-        : target(_target), source(_source), 
+        : to(_to), from(_from), 
           uedge_ref(_uedge_ref), node_ref(_node_ref) {}
 
-      typedef typename Source::Edge Key;
-      typedef typename Target::Edge Value;
+      typedef typename From::Edge Key;
+      typedef typename To::Edge Value;
 
       Value operator[](const Key& key) const {
         bool forward = 
-          (source.direction(key) == 
-           (node_ref[source.source(static_cast<const UEdge&>(key))] == 
-            target.source(uedge_ref[static_cast<const UEdge&>(key)])));
-	return target.direct(uedge_ref[key], forward); 
+          (from.direction(key) == 
+           (node_ref[from.source(static_cast<const UEdge&>(key))] == 
+            to.source(uedge_ref[static_cast<const UEdge&>(key)])));
+	return to.direct(uedge_ref[key], forward); 
       }
       
-      const Target& target;
-      const Source& source;
+      const To& to;
+      const From& from;
       const UEdgeRefMap& uedge_ref;
       const NodeRefMap& node_ref;
@@ -984,8 +993,8 @@
     /// \brief Constructor for the GraphCopy.
     ///
-    /// It copies the content of the \c _source graph into the
-    /// \c _target graph.
-    UGraphCopy(Target& _target, const Source& _source) 
-      : source(_source), target(_target) {}
+    /// It copies the content of the \c _from graph into the
+    /// \c _to graph.
+    UGraphCopy(To& _to, const From& _from) 
+      : from(_from), to(_to) {}
 
     /// \brief Destructor of the GraphCopy
@@ -1010,5 +1019,5 @@
     template <typename NodeRef>
     UGraphCopy& nodeRef(NodeRef& map) {
-      nodeMapCopies.push_back(new _graph_utils_bits::RefCopy<Source, Node, 
+      nodeMapCopies.push_back(new _graph_utils_bits::RefCopy<From, Node, 
                               NodeRefMap, NodeRef>(map));
       return *this;
@@ -1021,5 +1030,5 @@
     template <typename NodeCrossRef>
     UGraphCopy& nodeCrossRef(NodeCrossRef& map) {
-      nodeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<Source, Node,
+      nodeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<From, Node,
                               NodeRefMap, NodeCrossRef>(map));
       return *this;
@@ -1029,11 +1038,11 @@
     ///
     /// Makes copy of the given map for the newly created graph. 
-    /// The new map's key type is the target graph's node type,
-    /// and the copied map's key type is the source graph's node
+    /// The new map's key type is the to graph's node type,
+    /// and the copied map's key type is the from graph's node
     /// type.  
-    template <typename TargetMap, typename SourceMap>
-    UGraphCopy& nodeMap(TargetMap& tmap, const SourceMap& map) {
-      nodeMapCopies.push_back(new _graph_utils_bits::MapCopy<Source, Node, 
-                              NodeRefMap, TargetMap, SourceMap>(tmap, map));
+    template <typename ToMap, typename FromMap>
+    UGraphCopy& nodeMap(ToMap& tmap, const FromMap& map) {
+      nodeMapCopies.push_back(new _graph_utils_bits::MapCopy<From, Node, 
+                              NodeRefMap, ToMap, FromMap>(tmap, map));
       return *this;
     }
@@ -1043,5 +1052,5 @@
     /// Make a copy of the given node.
     UGraphCopy& node(TNode& tnode, const Node& snode) {
-      nodeMapCopies.push_back(new _graph_utils_bits::ItemCopy<Source, Node, 
+      nodeMapCopies.push_back(new _graph_utils_bits::ItemCopy<From, Node, 
                               NodeRefMap, TNode>(tnode, snode));
       return *this;
@@ -1053,5 +1062,5 @@
     template <typename EdgeRef>
     UGraphCopy& edgeRef(EdgeRef& map) {
-      edgeMapCopies.push_back(new _graph_utils_bits::RefCopy<Source, Edge, 
+      edgeMapCopies.push_back(new _graph_utils_bits::RefCopy<From, Edge, 
                               EdgeRefMap, EdgeRef>(map));
       return *this;
@@ -1064,5 +1073,5 @@
     template <typename EdgeCrossRef>
     UGraphCopy& edgeCrossRef(EdgeCrossRef& map) {
-      edgeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<Source, Edge,
+      edgeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<From, Edge,
                               EdgeRefMap, EdgeCrossRef>(map));
       return *this;
@@ -1072,11 +1081,11 @@
     ///
     /// Makes copy of the given map for the newly created graph. 
-    /// The new map's key type is the target graph's edge type,
-    /// and the copied map's key type is the source graph's edge
+    /// The new map's key type is the to graph's edge type,
+    /// and the copied map's key type is the from graph's edge
     /// type.  
-    template <typename TargetMap, typename SourceMap>
-    UGraphCopy& edgeMap(TargetMap& tmap, const SourceMap& map) {
-      edgeMapCopies.push_back(new _graph_utils_bits::MapCopy<Source, Edge, 
-                              EdgeRefMap, TargetMap, SourceMap>(tmap, map));
+    template <typename ToMap, typename FromMap>
+    UGraphCopy& edgeMap(ToMap& tmap, const FromMap& map) {
+      edgeMapCopies.push_back(new _graph_utils_bits::MapCopy<From, Edge, 
+                              EdgeRefMap, ToMap, FromMap>(tmap, map));
       return *this;
     }
@@ -1086,5 +1095,5 @@
     /// Make a copy of the given edge.
     UGraphCopy& edge(TEdge& tedge, const Edge& sedge) {
-      edgeMapCopies.push_back(new _graph_utils_bits::ItemCopy<Source, Edge, 
+      edgeMapCopies.push_back(new _graph_utils_bits::ItemCopy<From, Edge, 
                               EdgeRefMap, TEdge>(tedge, sedge));
       return *this;
@@ -1096,5 +1105,5 @@
     template <typename UEdgeRef>
     UGraphCopy& uEdgeRef(UEdgeRef& map) {
-      uEdgeMapCopies.push_back(new _graph_utils_bits::RefCopy<Source, UEdge, 
+      uEdgeMapCopies.push_back(new _graph_utils_bits::RefCopy<From, UEdge, 
                                UEdgeRefMap, UEdgeRef>(map));
       return *this;
@@ -1107,5 +1116,5 @@
     template <typename UEdgeCrossRef>
     UGraphCopy& uEdgeCrossRef(UEdgeCrossRef& map) {
-      uEdgeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<Source, 
+      uEdgeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<From, 
                                UEdge, UEdgeRefMap, UEdgeCrossRef>(map));
       return *this;
@@ -1115,11 +1124,11 @@
     ///
     /// Makes copy of the given map for the newly created graph. 
-    /// The new map's key type is the target graph's undirected edge type,
-    /// and the copied map's key type is the source graph's undirected edge
+    /// The new map's key type is the to graph's undirected edge type,
+    /// and the copied map's key type is the from graph's undirected edge
     /// type.  
-    template <typename TargetMap, typename SourceMap>
-    UGraphCopy& uEdgeMap(TargetMap& tmap, const SourceMap& map) {
-      uEdgeMapCopies.push_back(new _graph_utils_bits::MapCopy<Source, UEdge, 
-                               UEdgeRefMap, TargetMap, SourceMap>(tmap, map));
+    template <typename ToMap, typename FromMap>
+    UGraphCopy& uEdgeMap(ToMap& tmap, const FromMap& map) {
+      uEdgeMapCopies.push_back(new _graph_utils_bits::MapCopy<From, UEdge, 
+                               UEdgeRefMap, ToMap, FromMap>(tmap, map));
       return *this;
     }
@@ -1129,5 +1138,5 @@
     /// Make a copy of the given undirected edge.
     UGraphCopy& uEdge(TUEdge& tuedge, const UEdge& suedge) {
-      uEdgeMapCopies.push_back(new _graph_utils_bits::ItemCopy<Source, UEdge, 
+      uEdgeMapCopies.push_back(new _graph_utils_bits::ItemCopy<From, UEdge, 
                                UEdgeRefMap, TUEdge>(tuedge, suedge));
       return *this;
@@ -1138,17 +1147,17 @@
     /// Executes the copies.
     void run() {
-      NodeRefMap nodeRefMap(source);
-      UEdgeRefMap uEdgeRefMap(source);
-      EdgeRefMap edgeRefMap(target, source, uEdgeRefMap, nodeRefMap);
-      _graph_utils_bits::UGraphCopySelector<Target>::
-        copy(target, source, nodeRefMap, uEdgeRefMap);
+      NodeRefMap nodeRefMap(from);
+      UEdgeRefMap uEdgeRefMap(from);
+      EdgeRefMap edgeRefMap(to, from, uEdgeRefMap, nodeRefMap);
+      _graph_utils_bits::UGraphCopySelector<To>::
+        copy(to, from, nodeRefMap, uEdgeRefMap);
       for (int i = 0; i < int(nodeMapCopies.size()); ++i) {
-        nodeMapCopies[i]->copy(source, nodeRefMap);
+        nodeMapCopies[i]->copy(from, nodeRefMap);
       }
       for (int i = 0; i < int(uEdgeMapCopies.size()); ++i) {
-        uEdgeMapCopies[i]->copy(source, uEdgeRefMap);
+        uEdgeMapCopies[i]->copy(from, uEdgeRefMap);
       }
       for (int i = 0; i < int(edgeMapCopies.size()); ++i) {
-        edgeMapCopies[i]->copy(source, edgeRefMap);
+        edgeMapCopies[i]->copy(from, edgeRefMap);
       }
     }
@@ -1156,14 +1165,14 @@
   private:
     
-    const Source& source;
-    Target& target;
-
-    std::vector<_graph_utils_bits::MapCopyBase<Source, Node, NodeRefMap>* > 
+    const From& from;
+    To& to;
+
+    std::vector<_graph_utils_bits::MapCopyBase<From, Node, NodeRefMap>* > 
     nodeMapCopies;
 
-    std::vector<_graph_utils_bits::MapCopyBase<Source, Edge, EdgeRefMap>* > 
+    std::vector<_graph_utils_bits::MapCopyBase<From, Edge, EdgeRefMap>* > 
     edgeMapCopies;
 
-    std::vector<_graph_utils_bits::MapCopyBase<Source, UEdge, UEdgeRefMap>* > 
+    std::vector<_graph_utils_bits::MapCopyBase<From, UEdge, UEdgeRefMap>* > 
     uEdgeMapCopies;
 
@@ -1180,13 +1189,13 @@
   /// 
   /// After the copy the \c nr map will contain the mapping from the
-  /// source graph's nodes to the target graph's nodes and the \c ecr will
-  /// contain the mapping from the target graph's edges to the source's
+  /// from graph's nodes to the to graph's nodes and the \c ecr will
+  /// contain the mapping from the to graph's edges to the from's
   /// edges.
   ///
   /// \see UGraphCopy 
-  template <typename Target, typename Source>
-  UGraphCopy<Target, Source> 
-  copyUGraph(Target& target, const Source& source) {
-    return UGraphCopy<Target, Source>(target, source);
+  template <typename To, typename From>
+  UGraphCopy<To, From> 
+  copyUGraph(To& to, const From& from) {
+    return UGraphCopy<To, From>(to, from);
   }
 
@@ -1196,38 +1205,38 @@
   /// (duplicate a graph).  The simplest way of using it is through
   /// the \c copyBpUGraph() function.
-  template <typename Target, typename Source>
+  template <typename To, typename From>
   class BpUGraphCopy {
   private:
 
-    typedef typename Source::Node Node;
-    typedef typename Source::ANode ANode;
-    typedef typename Source::BNode BNode;
-    typedef typename Source::NodeIt NodeIt;
-    typedef typename Source::Edge Edge;
-    typedef typename Source::EdgeIt EdgeIt;
-    typedef typename Source::UEdge UEdge;
-    typedef typename Source::UEdgeIt UEdgeIt;
-
-    typedef typename Target::Node TNode;
-    typedef typename Target::Edge TEdge;
-    typedef typename Target::UEdge TUEdge;
-
-    typedef typename Source::template ANodeMap<TNode> ANodeRefMap;
-    typedef typename Source::template BNodeMap<TNode> BNodeRefMap;
-    typedef typename Source::template UEdgeMap<TUEdge> UEdgeRefMap;
+    typedef typename From::Node Node;
+    typedef typename From::ANode ANode;
+    typedef typename From::BNode BNode;
+    typedef typename From::NodeIt NodeIt;
+    typedef typename From::Edge Edge;
+    typedef typename From::EdgeIt EdgeIt;
+    typedef typename From::UEdge UEdge;
+    typedef typename From::UEdgeIt UEdgeIt;
+
+    typedef typename To::Node TNode;
+    typedef typename To::Edge TEdge;
+    typedef typename To::UEdge TUEdge;
+
+    typedef typename From::template ANodeMap<TNode> ANodeRefMap;
+    typedef typename From::template BNodeMap<TNode> BNodeRefMap;
+    typedef typename From::template UEdgeMap<TUEdge> UEdgeRefMap;
 
     struct NodeRefMap {
-      NodeRefMap(const Source& _source, const ANodeRefMap& _anode_ref,
+      NodeRefMap(const From& _from, const ANodeRefMap& _anode_ref,
                  const BNodeRefMap& _bnode_ref)
-        : source(_source), anode_ref(_anode_ref), bnode_ref(_bnode_ref) {}
-
-      typedef typename Source::Node Key;
-      typedef typename Target::Node Value;
+        : from(_from), anode_ref(_anode_ref), bnode_ref(_bnode_ref) {}
+
+      typedef typename From::Node Key;
+      typedef typename To::Node Value;
 
       Value operator[](const Key& key) const {
-	return source.aNode(key) ? anode_ref[key] : bnode_ref[key]; 
+	return from.aNode(key) ? anode_ref[key] : bnode_ref[key]; 
       }
       
-      const Source& source;
+      const From& from;
       const ANodeRefMap& anode_ref;
       const BNodeRefMap& bnode_ref;
@@ -1235,22 +1244,22 @@
 
     struct EdgeRefMap {
-      EdgeRefMap(const Target& _target, const Source& _source,
+      EdgeRefMap(const To& _to, const From& _from,
                  const UEdgeRefMap& _uedge_ref, const NodeRefMap& _node_ref) 
-        : target(_target), source(_source), 
+        : to(_to), from(_from), 
           uedge_ref(_uedge_ref), node_ref(_node_ref) {}
 
-      typedef typename Source::Edge Key;
-      typedef typename Target::Edge Value;
+      typedef typename From::Edge Key;
+      typedef typename To::Edge Value;
 
       Value operator[](const Key& key) const {
         bool forward = 
-          (source.direction(key) == 
-           (node_ref[source.source(static_cast<const UEdge&>(key))] == 
-            target.source(uedge_ref[static_cast<const UEdge&>(key)])));
-	return target.direct(uedge_ref[key], forward); 
+          (from.direction(key) == 
+           (node_ref[from.source(static_cast<const UEdge&>(key))] == 
+            to.source(uedge_ref[static_cast<const UEdge&>(key)])));
+	return to.direct(uedge_ref[key], forward); 
       }
       
-      const Target& target;
-      const Source& source;
+      const To& to;
+      const From& from;
       const UEdgeRefMap& uedge_ref;
       const NodeRefMap& node_ref;
@@ -1262,8 +1271,8 @@
     /// \brief Constructor for the GraphCopy.
     ///
-    /// It copies the content of the \c _source graph into the
-    /// \c _target graph.
-    BpUGraphCopy(Target& _target, const Source& _source) 
-      : source(_source), target(_target) {}
+    /// It copies the content of the \c _from graph into the
+    /// \c _to graph.
+    BpUGraphCopy(To& _to, const From& _from) 
+      : from(_from), to(_to) {}
 
     /// \brief Destructor of the GraphCopy
@@ -1294,5 +1303,5 @@
     template <typename ANodeRef>
     BpUGraphCopy& aNodeRef(ANodeRef& map) {
-      aNodeMapCopies.push_back(new _graph_utils_bits::RefCopy<Source, ANode, 
+      aNodeMapCopies.push_back(new _graph_utils_bits::RefCopy<From, ANode, 
                                ANodeRefMap, ANodeRef>(map));
       return *this;
@@ -1305,5 +1314,5 @@
     template <typename ANodeCrossRef>
     BpUGraphCopy& aNodeCrossRef(ANodeCrossRef& map) {
-      aNodeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<Source, 
+      aNodeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<From, 
                                ANode, ANodeRefMap, ANodeCrossRef>(map));
       return *this;
@@ -1313,11 +1322,11 @@
     ///
     /// Makes copy of the given map for the newly created graph. 
-    /// The new map's key type is the target graph's node type,
-    /// and the copied map's key type is the source graph's node
+    /// The new map's key type is the to graph's node type,
+    /// and the copied map's key type is the from graph's node
     /// type.  
-    template <typename TargetMap, typename SourceMap>
-    BpUGraphCopy& aNodeMap(TargetMap& tmap, const SourceMap& map) {
-      aNodeMapCopies.push_back(new _graph_utils_bits::MapCopy<Source, ANode, 
-                               ANodeRefMap, TargetMap, SourceMap>(tmap, map));
+    template <typename ToMap, typename FromMap>
+    BpUGraphCopy& aNodeMap(ToMap& tmap, const FromMap& map) {
+      aNodeMapCopies.push_back(new _graph_utils_bits::MapCopy<From, ANode, 
+                               ANodeRefMap, ToMap, FromMap>(tmap, map));
       return *this;
     }
@@ -1328,5 +1337,5 @@
     template <typename BNodeRef>
     BpUGraphCopy& bNodeRef(BNodeRef& map) {
-      bNodeMapCopies.push_back(new _graph_utils_bits::RefCopy<Source, BNode, 
+      bNodeMapCopies.push_back(new _graph_utils_bits::RefCopy<From, BNode, 
                                BNodeRefMap, BNodeRef>(map));
       return *this;
@@ -1339,5 +1348,5 @@
     template <typename BNodeCrossRef>
     BpUGraphCopy& bNodeCrossRef(BNodeCrossRef& map) {
-      bNodeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<Source, 
+      bNodeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<From, 
                               BNode, BNodeRefMap, BNodeCrossRef>(map));
       return *this;
@@ -1347,11 +1356,11 @@
     ///
     /// Makes copy of the given map for the newly created graph. 
-    /// The new map's key type is the target graph's node type,
-    /// and the copied map's key type is the source graph's node
+    /// The new map's key type is the to graph's node type,
+    /// and the copied map's key type is the from graph's node
     /// type.  
-    template <typename TargetMap, typename SourceMap>
-    BpUGraphCopy& bNodeMap(TargetMap& tmap, const SourceMap& map) {
-      bNodeMapCopies.push_back(new _graph_utils_bits::MapCopy<Source, BNode, 
-                               BNodeRefMap, TargetMap, SourceMap>(tmap, map));
+    template <typename ToMap, typename FromMap>
+    BpUGraphCopy& bNodeMap(ToMap& tmap, const FromMap& map) {
+      bNodeMapCopies.push_back(new _graph_utils_bits::MapCopy<From, BNode, 
+                               BNodeRefMap, ToMap, FromMap>(tmap, map));
       return *this;
     }
@@ -1361,5 +1370,5 @@
     template <typename NodeRef>
     BpUGraphCopy& nodeRef(NodeRef& map) {
-      nodeMapCopies.push_back(new _graph_utils_bits::RefCopy<Source, Node, 
+      nodeMapCopies.push_back(new _graph_utils_bits::RefCopy<From, Node, 
                               NodeRefMap, NodeRef>(map));
       return *this;
@@ -1372,5 +1381,5 @@
     template <typename NodeCrossRef>
     BpUGraphCopy& nodeCrossRef(NodeCrossRef& map) {
-      nodeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<Source, Node,
+      nodeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<From, Node,
                               NodeRefMap, NodeCrossRef>(map));
       return *this;
@@ -1380,11 +1389,11 @@
     ///
     /// Makes copy of the given map for the newly created graph. 
-    /// The new map's key type is the target graph's node type,
-    /// and the copied map's key type is the source graph's node
+    /// The new map's key type is the to graph's node type,
+    /// and the copied map's key type is the from graph's node
     /// type.  
-    template <typename TargetMap, typename SourceMap>
-    BpUGraphCopy& nodeMap(TargetMap& tmap, const SourceMap& map) {
-      nodeMapCopies.push_back(new _graph_utils_bits::MapCopy<Source, Node, 
-                              NodeRefMap, TargetMap, SourceMap>(tmap, map));
+    template <typename ToMap, typename FromMap>
+    BpUGraphCopy& nodeMap(ToMap& tmap, const FromMap& map) {
+      nodeMapCopies.push_back(new _graph_utils_bits::MapCopy<From, Node, 
+                              NodeRefMap, ToMap, FromMap>(tmap, map));
       return *this;
     }
@@ -1394,5 +1403,5 @@
     /// Make a copy of the given node.
     BpUGraphCopy& node(TNode& tnode, const Node& snode) {
-      nodeMapCopies.push_back(new _graph_utils_bits::ItemCopy<Source, Node, 
+      nodeMapCopies.push_back(new _graph_utils_bits::ItemCopy<From, Node, 
                               NodeRefMap, TNode>(tnode, snode));
       return *this;
@@ -1404,5 +1413,5 @@
     template <typename EdgeRef>
     BpUGraphCopy& edgeRef(EdgeRef& map) {
-      edgeMapCopies.push_back(new _graph_utils_bits::RefCopy<Source, Edge, 
+      edgeMapCopies.push_back(new _graph_utils_bits::RefCopy<From, Edge, 
                               EdgeRefMap, EdgeRef>(map));
       return *this;
@@ -1415,5 +1424,5 @@
     template <typename EdgeCrossRef>
     BpUGraphCopy& edgeCrossRef(EdgeCrossRef& map) {
-      edgeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<Source, Edge,
+      edgeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<From, Edge,
                               EdgeRefMap, EdgeCrossRef>(map));
       return *this;
@@ -1423,11 +1432,11 @@
     ///
     /// Makes copy of the given map for the newly created graph. 
-    /// The new map's key type is the target graph's edge type,
-    /// and the copied map's key type is the source graph's edge
+    /// The new map's key type is the to graph's edge type,
+    /// and the copied map's key type is the from graph's edge
     /// type.  
-    template <typename TargetMap, typename SourceMap>
-    BpUGraphCopy& edgeMap(TargetMap& tmap, const SourceMap& map) {
-      edgeMapCopies.push_back(new _graph_utils_bits::MapCopy<Source, Edge, 
-                              EdgeRefMap, TargetMap, SourceMap>(tmap, map));
+    template <typename ToMap, typename FromMap>
+    BpUGraphCopy& edgeMap(ToMap& tmap, const FromMap& map) {
+      edgeMapCopies.push_back(new _graph_utils_bits::MapCopy<From, Edge, 
+                              EdgeRefMap, ToMap, FromMap>(tmap, map));
       return *this;
     }
@@ -1437,5 +1446,5 @@
     /// Make a copy of the given edge.
     BpUGraphCopy& edge(TEdge& tedge, const Edge& sedge) {
-      edgeMapCopies.push_back(new _graph_utils_bits::ItemCopy<Source, Edge, 
+      edgeMapCopies.push_back(new _graph_utils_bits::ItemCopy<From, Edge, 
                               EdgeRefMap, TEdge>(tedge, sedge));
       return *this;
@@ -1447,5 +1456,5 @@
     template <typename UEdgeRef>
     BpUGraphCopy& uEdgeRef(UEdgeRef& map) {
-      uEdgeMapCopies.push_back(new _graph_utils_bits::RefCopy<Source, UEdge, 
+      uEdgeMapCopies.push_back(new _graph_utils_bits::RefCopy<From, UEdge, 
                                UEdgeRefMap, UEdgeRef>(map));
       return *this;
@@ -1458,5 +1467,5 @@
     template <typename UEdgeCrossRef>
     BpUGraphCopy& uEdgeCrossRef(UEdgeCrossRef& map) {
-      uEdgeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<Source, 
+      uEdgeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<From, 
                                UEdge, UEdgeRefMap, UEdgeCrossRef>(map));
       return *this;
@@ -1466,11 +1475,11 @@
     ///
     /// Makes copy of the given map for the newly created graph. 
-    /// The new map's key type is the target graph's undirected edge type,
-    /// and the copied map's key type is the source graph's undirected edge
+    /// The new map's key type is the to graph's undirected edge type,
+    /// and the copied map's key type is the from graph's undirected edge
     /// type.  
-    template <typename TargetMap, typename SourceMap>
-    BpUGraphCopy& uEdgeMap(TargetMap& tmap, const SourceMap& map) {
-      uEdgeMapCopies.push_back(new _graph_utils_bits::MapCopy<Source, UEdge, 
-                               UEdgeRefMap, TargetMap, SourceMap>(tmap, map));
+    template <typename ToMap, typename FromMap>
+    BpUGraphCopy& uEdgeMap(ToMap& tmap, const FromMap& map) {
+      uEdgeMapCopies.push_back(new _graph_utils_bits::MapCopy<From, UEdge, 
+                               UEdgeRefMap, ToMap, FromMap>(tmap, map));
       return *this;
     }
@@ -1480,5 +1489,5 @@
     /// Make a copy of the given undirected edge.
     BpUGraphCopy& uEdge(TUEdge& tuedge, const UEdge& suedge) {
-      uEdgeMapCopies.push_back(new _graph_utils_bits::ItemCopy<Source, UEdge, 
+      uEdgeMapCopies.push_back(new _graph_utils_bits::ItemCopy<From, UEdge, 
                                UEdgeRefMap, TUEdge>(tuedge, suedge));
       return *this;
@@ -1489,25 +1498,25 @@
     /// Executes the copies.
     void run() {
-      ANodeRefMap aNodeRefMap(source);
-      BNodeRefMap bNodeRefMap(source);
-      NodeRefMap nodeRefMap(source, aNodeRefMap, bNodeRefMap);
-      UEdgeRefMap uEdgeRefMap(source);
-      EdgeRefMap edgeRefMap(target, source, uEdgeRefMap, nodeRefMap);
-      _graph_utils_bits::BpUGraphCopySelector<Target>::
-        copy(target, source, aNodeRefMap, bNodeRefMap, uEdgeRefMap);
+      ANodeRefMap aNodeRefMap(from);
+      BNodeRefMap bNodeRefMap(from);
+      NodeRefMap nodeRefMap(from, aNodeRefMap, bNodeRefMap);
+      UEdgeRefMap uEdgeRefMap(from);
+      EdgeRefMap edgeRefMap(to, from, uEdgeRefMap, nodeRefMap);
+      _graph_utils_bits::BpUGraphCopySelector<To>::
+        copy(to, from, aNodeRefMap, bNodeRefMap, uEdgeRefMap);
       for (int i = 0; i < int(aNodeMapCopies.size()); ++i) {
-        aNodeMapCopies[i]->copy(source, aNodeRefMap);
+        aNodeMapCopies[i]->copy(from, aNodeRefMap);
       }
       for (int i = 0; i < int(bNodeMapCopies.size()); ++i) {
-        bNodeMapCopies[i]->copy(source, bNodeRefMap);
+        bNodeMapCopies[i]->copy(from, bNodeRefMap);
       }
       for (int i = 0; i < int(nodeMapCopies.size()); ++i) {
-        nodeMapCopies[i]->copy(source, nodeRefMap);
+        nodeMapCopies[i]->copy(from, nodeRefMap);
       }
       for (int i = 0; i < int(uEdgeMapCopies.size()); ++i) {
-        uEdgeMapCopies[i]->copy(source, uEdgeRefMap);
+        uEdgeMapCopies[i]->copy(from, uEdgeRefMap);
       }
       for (int i = 0; i < int(edgeMapCopies.size()); ++i) {
-        edgeMapCopies[i]->copy(source, edgeRefMap);
+        edgeMapCopies[i]->copy(from, edgeRefMap);
       }
     }
@@ -1515,20 +1524,20 @@
   private:
     
-    const Source& source;
-    Target& target;
-
-    std::vector<_graph_utils_bits::MapCopyBase<Source, ANode, ANodeRefMap>* > 
+    const From& from;
+    To& to;
+
+    std::vector<_graph_utils_bits::MapCopyBase<From, ANode, ANodeRefMap>* > 
     aNodeMapCopies;
 
-    std::vector<_graph_utils_bits::MapCopyBase<Source, BNode, BNodeRefMap>* > 
+    std::vector<_graph_utils_bits::MapCopyBase<From, BNode, BNodeRefMap>* > 
     bNodeMapCopies;
 
-    std::vector<_graph_utils_bits::MapCopyBase<Source, Node, NodeRefMap>* > 
+    std::vector<_graph_utils_bits::MapCopyBase<From, Node, NodeRefMap>* > 
     nodeMapCopies;
 
-    std::vector<_graph_utils_bits::MapCopyBase<Source, Edge, EdgeRefMap>* > 
+    std::vector<_graph_utils_bits::MapCopyBase<From, Edge, EdgeRefMap>* > 
     edgeMapCopies;
 
-    std::vector<_graph_utils_bits::MapCopyBase<Source, UEdge, UEdgeRefMap>* > 
+    std::vector<_graph_utils_bits::MapCopyBase<From, UEdge, UEdgeRefMap>* > 
     uEdgeMapCopies;
 
@@ -1545,13 +1554,13 @@
   /// 
   /// After the copy the \c nr map will contain the mapping from the
-  /// source graph's nodes to the target graph's nodes and the \c ecr will
-  /// contain the mapping from the target graph's edges to the source's
+  /// from graph's nodes to the to graph's nodes and the \c ecr will
+  /// contain the mapping from the to graph's edges to the from's
   /// edges.
   ///
   /// \see BpUGraphCopy
-  template <typename Target, typename Source>
-  BpUGraphCopy<Target, Source> 
-  copyBpUGraph(Target& target, const Source& source) {
-    return BpUGraphCopy<Target, Source>(target, source);
+  template <typename To, typename From>
+  BpUGraphCopy<To, From> 
+  copyBpUGraph(To& to, const From& from) {
+    return BpUGraphCopy<To, From>(to, from);
   }
 
