Changeset 2485:88aa7870756a in lemon-0.x

Timestamp:

10/02/07 14:34:43 (17 years ago)

Author:

Balazs Dezso

Branch:

default

Phase:

public

Convert:

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

Message:

New developers page
The participation period should be included

Bug fix in doc related to Graph concpets

Removing some todos!

Files:

• doc/Makefile.am (modified) (1 diff)
• doc/developers.dox (added)
• lemon/concepts/bpugraph.h (modified) (2 diffs)
• lemon/concepts/graph.h (modified) (2 diffs)
• lemon/concepts/graph_components.h (modified) (7 diffs)
• lemon/concepts/ugraph.h (modified) (2 diffs)
• lemon/graph_utils.h (modified) (69 diffs)

doc/Makefile.am

@@ -11 +11 @@
         doc/coding_style.dox \
         doc/developers_interface.dox \
+        doc/developres.dox \
         doc/dirs.dox \
         doc/getstart.dox \

lemon/concepts/bpugraph.h

@@ -34 +34 @@
   namespace concepts {
 
-    /// \addtogroup graph_concepts
-    /// @{
+    /// \ingroup graph_concepts
     ///
     /// \brief Class describing the concept of Bipartite Undirected Graphs.
@@ -999 +998 @@
     };
 
-
-    /// @}
-
   }
 

lemon/concepts/graph.h

@@ -33 +33 @@
   namespace concepts {
 
-    /// \addtogroup graph_concepts
-    /// @{
+    /// \ingroup graph_concepts
     ///
     /// \brief Class describing the concept of Directed Graphs.
@@ -447 +446 @@
     };
     
-    // @}
   } //namespace concepts  
 } //namespace lemon

lemon/concepts/graph_components.h

@@ -1483 +1483 @@
       template <typename _Value>
       class NodeMap : public GraphMap<Graph, Node, _Value> {
-      private:
-        NodeMap();
       public:
         typedef GraphMap<MappableGraphComponent, Node, _Value> Parent;
@@ -1491 +1489 @@
         ///
         /// Construct a new map for the graph.
-        /// \todo call the right parent class constructor
         explicit NodeMap(const MappableGraphComponent& graph) 
           : Parent(graph) {}
@@ -1523 +1520 @@
       template <typename _Value>
       class EdgeMap : public GraphMap<Graph, Edge, _Value> {
-      private:
-        EdgeMap();
       public:
         typedef GraphMap<MappableGraphComponent, Edge, _Value> Parent;
@@ -1531 +1526 @@
         ///
         /// Construct a new map for the graph.
-        /// \todo call the right parent class constructor
         explicit EdgeMap(const MappableGraphComponent& graph) 
           : Parent(graph) {}
@@ -1628 +1622 @@
         ///
         /// Construct a new map for the graph.
-        /// \todo call the right parent class constructor
         explicit UEdgeMap(const MappableUGraphComponent& graph) 
           : Parent(graph) {}
@@ -1713 +1706 @@
         ///
         /// Construct a new map for the graph.
-        /// \todo call the right parent class constructor
         explicit ANodeMap(const MappableBpUGraphComponent& graph) 
           : Parent(graph) {}
@@ -1751 +1743 @@
         ///
         /// Construct a new map for the graph.
-        /// \todo call the right parent class constructor
         explicit BNodeMap(const MappableBpUGraphComponent& graph) 
           : Parent(graph) {}

lemon/concepts/ugraph.h

@@ -31 +31 @@
   namespace concepts {
 
-    /// \addtogroup graph_concepts
-    /// @{
+    /// \ingroup graph_concepts
     ///
     /// \brief Class describing the concept of Undirected Graphs.
@@ -697 +696 @@
     };
 
-    /// @}
-
   }
 

lemon/graph_utils.h

@@ -147 +147 @@
   /// 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 +181 @@
   /// 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 +215 @@
   /// 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 +251 @@
   /// 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 +286 @@
   /// 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 +569 @@
   /// \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 +597 @@
     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 +603 @@
 
     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 +618 @@
 
     private:
-      TargetMap& _tmap;
-      const SourceMap& _map;
+      ToMap& _tmap;
+      const FromMap& _map;
     };
 
@@ -665 +674 @@
     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 +692 @@
       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 +701 @@
     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 +719 @@
       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 +728 @@
     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 +751 @@
       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 +767 @@
   /// 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 +788 @@
     /// \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 +811 @@
     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 +822 @@
     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 +830 @@
     ///
     /// 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 +844 @@
     /// 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 +854 @@
     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 +865 @@
     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 +873 @@
     ///
     /// 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 +887 @@
     /// 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 +896 @@
     /// 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 +911 @@
 
 
-    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 +932 @@
   /// 
   /// 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 +946 @@
   /// 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 +993 @@
     /// \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 +1019 @@
     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 +1030 @@
     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 +1038 @@
     ///
     /// 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 +1052 @@
     /// 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 +1062 @@
     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 +1073 @@
     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 +1081 @@
     ///
     /// 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 +1095 @@
     /// 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 +1105 @@
     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 +1116 @@
     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 +1124 @@
     ///
     /// 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 +1138 @@
     /// 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 +1147 @@
     /// 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 +1165 @@
   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 +1189 @@
   /// 
   /// 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 +1205 @@
   /// (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 +1244 @@
 
     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 +1271 @@
     /// \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 +1303 @@
     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 +1314 @@
     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 +1322 @@
     ///
     /// 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 +1337 @@
     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 +1348 @@
     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 +1356 @@
     ///
     /// 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 +1370 @@
     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 +1381 @@
     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 +1389 @@
     ///
     /// 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 +1403 @@
     /// 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 +1413 @@
     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 +1424 @@
     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 +1432 @@
     ///
     /// 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 +1446 @@
     /// 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 +1456 @@
     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 +1467 @@
     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 +1475 @@
     ///
     /// 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 +1489 @@
     /// 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 +1498 @@
     /// 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 +1524 @@
   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 +1554 @@
   /// 
   /// 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);
   }