Ticket #150: from-to_8ab073e5c4f9.patch

lemon/core.h

@@ -308 +308 @@
     };
 
     template <typename Digraph, typename Item, typename RefMap,
-              typename ToMap, typename FromMap>
+              typename FromMap, typename ToMap>
     class MapCopy : public MapCopyBase<Digraph, Item, RefMap> {
     public:
 
-      MapCopy(ToMap& tmap, const FromMap& map)
-        : _tmap(tmap), _map(map) {}
+      MapCopy(const FromMap& map, ToMap& tmap)
+        : _map(map), _tmap(tmap) {}
 
       virtual void copy(const Digraph& digraph, const RefMap& refMap) {
         typedef typename ItemSetTraits<Digraph, Item>::ItemIt ItemIt;
@@ -323 +323 @@
       }
 
     private:
+      const FromMap& _map;
       ToMap& _tmap;
-      const FromMap& _map;
     };
 
     template <typename Digraph, typename Item, typename RefMap, typename It>
     class ItemCopy : public MapCopyBase<Digraph, Item, RefMap> {
     public:
 
-      ItemCopy(It& it, const Item& item) : _it(it), _item(item) {}
+      ItemCopy(const Item& item, It& it) : _item(item), _it(it) {}
 
       virtual void copy(const Digraph&, const RefMap& refMap) {
         _it = refMap[_item];
       }
 
     private:
+      Item _item;
       It& _it;
-      Item _item;
     };
 
     template <typename Digraph, typename Item, typename RefMap, typename Ref>
@@ -380 +380 @@
     template <typename Digraph, typename Enable = void>
     struct CopyDigraphSelector {
       template <typename From, typename NodeRefMap, typename ArcRefMap>
-      static void copy(Digraph &to, const From& from,
+      static void copy(const From& from, Digraph &to,
                        NodeRefMap& nodeRefMap, ArcRefMap& arcRefMap) {
         for (typename From::NodeIt it(from); it != INVALID; ++it) {
           nodeRefMap[it] = to.addNode();
@@ -398 +398 @@
       typename enable_if<typename Digraph::BuildTag, void>::type>
     {
       template <typename From, typename NodeRefMap, typename ArcRefMap>
-      static void copy(Digraph &to, const From& from,
+      static void copy(const From& from, Digraph &to,
                        NodeRefMap& nodeRefMap, ArcRefMap& arcRefMap) {
         to.build(from, nodeRefMap, arcRefMap);
       }
@@ -407 +407 @@
     template <typename Graph, typename Enable = void>
     struct CopyGraphSelector {
       template <typename From, typename NodeRefMap, typename EdgeRefMap>
-      static void copy(Graph &to, const From& from,
+      static void copy(const From& from, Graph &to,
                        NodeRefMap& nodeRefMap, EdgeRefMap& edgeRefMap) {
         for (typename From::NodeIt it(from); it != INVALID; ++it) {
           nodeRefMap[it] = to.addNode();
@@ -425 +425 @@
       typename enable_if<typename Graph::BuildTag, void>::type>
     {
       template <typename From, typename NodeRefMap, typename EdgeRefMap>
-      static void copy(Graph &to, const From& from,
+      static void copy(const From& from, Graph &to,
                        NodeRefMap& nodeRefMap, EdgeRefMap& edgeRefMap) {
         to.build(from, nodeRefMap, edgeRefMap);
       }
@@ -450 +450 @@
   ///
   /// The next code copies a digraph with several data:
   ///\code
-  ///  CopyDigraph<NewGraph, OrigGraph> cg(new_graph, orig_graph);
+  ///  CopyDigraph<OrigGraph, NewGraph> cg(orig_graph, new_graph);
   ///  // Create references for the nodes
   ///  OrigGraph::NodeMap<NewGraph::Node> nr(orig_graph);
   ///  cg.nodeRef(nr);
@@ -460 +460 @@
   ///  // Copy an arc map
   ///  OrigGraph::ArcMap<double> oamap(orig_graph);
   ///  NewGraph::ArcMap<double> namap(new_graph);
-  ///  cg.arcMap(namap, oamap);
+  ///  cg.arcMap(oamap, namap);
   ///  // Copy a node
   ///  OrigGraph::Node on;
   ///  NewGraph::Node nn;
-  ///  cg.node(nn, on);
+  ///  cg.node(on, nn);
   ///  // Execute copying
   ///  cg.run();
   ///\endcode
-  template <typename To, typename From>
+  template <typename From, typename To>
   class CopyDigraph {
   private:
 
@@ -489 +489 @@
     ///
     /// Constructor of CopyDigraph for copying the content of the
     /// \c from digraph into the \c to digraph.
-    CopyDigraph(To& to, const From& from)
+    CopyDigraph(const From& from, To& to)
       : _from(from), _to(to) {}
 
     /// \brief Destructor of CopyDigraph
@@ -538 +538 @@
     /// The key type of the new map \c tmap should be the Node type of the
     /// destination digraph, and the key type of the original map \c map
     /// should be the Node type of the source digraph.
-    template <typename ToMap, typename FromMap>
-    CopyDigraph& nodeMap(ToMap& tmap, const FromMap& map) {
+    template <typename FromMap, typename ToMap>
+    CopyDigraph& nodeMap(const FromMap& map, ToMap& tmap) {
       _node_maps.push_back(new _core_bits::MapCopy<From, Node,
-                           NodeRefMap, ToMap, FromMap>(tmap, map));
+                           NodeRefMap, FromMap, ToMap>(map, tmap));
       return *this;
     }
 
     /// \brief Make a copy of the given node.
     ///
     /// This function makes a copy of the given node.
-    CopyDigraph& node(TNode& tnode, const Node& node) {
+    CopyDigraph& node(const Node& node, TNode& tnode) {
       _node_maps.push_back(new _core_bits::ItemCopy<From, Node,
-                           NodeRefMap, TNode>(tnode, node));
+                           NodeRefMap, TNode>(node, tnode));
       return *this;
     }
 
@@ -587 +587 @@
     /// The key type of the new map \c tmap should be the Arc type of the
     /// destination digraph, and the key type of the original map \c map
     /// should be the Arc type of the source digraph.
-    template <typename ToMap, typename FromMap>
-    CopyDigraph& arcMap(ToMap& tmap, const FromMap& map) {
+    template <typename FromMap, typename ToMap>
+    CopyDigraph& arcMap(const FromMap& map, ToMap& tmap) {
       _arc_maps.push_back(new _core_bits::MapCopy<From, Arc,
-                          ArcRefMap, ToMap, FromMap>(tmap, map));
+                          ArcRefMap, FromMap, ToMap>(map, tmap));
       return *this;
     }
 
     /// \brief Make a copy of the given arc.
     ///
     /// This function makes a copy of the given arc.
-    CopyDigraph& arc(TArc& tarc, const Arc& arc) {
+    CopyDigraph& arc(const Arc& arc, TArc& tarc) {
       _arc_maps.push_back(new _core_bits::ItemCopy<From, Arc,
-                          ArcRefMap, TArc>(tarc, arc));
+                          ArcRefMap, TArc>(arc, tarc));
       return *this;
     }
 
@@ -611 +611 @@
       NodeRefMap nodeRefMap(_from);
       ArcRefMap arcRefMap(_from);
       _core_bits::CopyDigraphSelector<To>::
-        copy(_to, _from, nodeRefMap, arcRefMap);
+        copy(_from, _to, nodeRefMap, arcRefMap);
       for (int i = 0; i < int(_node_maps.size()); ++i) {
         _node_maps[i]->copy(_from, nodeRefMap);
       }
@@ -639 +639 @@
   /// The complete usage of it is detailed in the CopyDigraph class, but
   /// a short example shows a basic work:
   ///\code
-  /// copyDigraph(trg, src).nodeRef(nr).arcCrossRef(acr).run();
+  /// copyDigraph(src, trg).nodeRef(nr).arcCrossRef(acr).run();
   ///\endcode
   ///
   /// After the copy the \c nr map will contain the mapping from the
@@ -648 +648 @@
   /// to the arcs of the \c from digraph.
   ///
   /// \see CopyDigraph
-  template <typename To, typename From>
-  CopyDigraph<To, From> copyDigraph(To& to, const From& from) {
-    return CopyDigraph<To, From>(to, from);
+  template <typename From, typename To>
+  CopyDigraph<From, To> copyDigraph(const From& from, To& to) {
+    return CopyDigraph<From, To>(from, to);
   }
 
   /// \brief Class to copy a graph.
@@ -670 +670 @@
   ///
   /// The next code copies a graph with several data:
   ///\code
-  ///  CopyGraph<NewGraph, OrigGraph> cg(new_graph, orig_graph);
+  ///  CopyGraph<OrigGraph, NewGraph> cg(orig_graph, new_graph);
   ///  // Create references for the nodes
   ///  OrigGraph::NodeMap<NewGraph::Node> nr(orig_graph);
   ///  cg.nodeRef(nr);
@@ -680 +680 @@
   ///  // Copy an edge map
   ///  OrigGraph::EdgeMap<double> oemap(orig_graph);
   ///  NewGraph::EdgeMap<double> nemap(new_graph);
-  ///  cg.edgeMap(nemap, oemap);
+  ///  cg.edgeMap(oemap, nemap);
   ///  // Copy a node
   ///  OrigGraph::Node on;
   ///  NewGraph::Node nn;
-  ///  cg.node(nn, on);
+  ///  cg.node(on, nn);
   ///  // Execute copying
   ///  cg.run();
   ///\endcode
-  template <typename To, typename From>
+  template <typename From, typename To>
   class CopyGraph {
   private:
 
@@ -707 +707 @@
     typedef typename From::template EdgeMap<TEdge> EdgeRefMap;
 
     struct ArcRefMap {
-      ArcRefMap(const To& to, const From& from,
+      ArcRefMap(const From& from, const To& to,
                 const EdgeRefMap& edge_ref, const NodeRefMap& node_ref)
-        : _to(to), _from(from),
+        : _from(from), _to(to),
           _edge_ref(edge_ref), _node_ref(node_ref) {}
 
       typedef typename From::Arc Key;
@@ -723 +723 @@
         return _to.direct(_edge_ref[key], forward);
       }
 
+      const From& _from;
       const To& _to;
-      const From& _from;
       const EdgeRefMap& _edge_ref;
       const NodeRefMap& _node_ref;
     };
@@ -735 +735 @@
     ///
     /// Constructor of CopyGraph for copying the content of the
     /// \c from graph into the \c to graph.
-    CopyGraph(To& to, const From& from)
+    CopyGraph(const From& from, To& to)
       : _from(from), _to(to) {}
 
     /// \brief Destructor of CopyGraph
@@ -786 +786 @@
     /// The key type of the new map \c tmap should be the Node type of the
     /// destination graph, and the key type of the original map \c map
     /// should be the Node type of the source graph.
-    template <typename ToMap, typename FromMap>
-    CopyGraph& nodeMap(ToMap& tmap, const FromMap& map) {
+    template <typename FromMap, typename ToMap>
+    CopyGraph& nodeMap(const FromMap& map, ToMap& tmap) {
       _node_maps.push_back(new _core_bits::MapCopy<From, Node,
-                           NodeRefMap, ToMap, FromMap>(tmap, map));
+                           NodeRefMap, FromMap, ToMap>(map, tmap));
       return *this;
     }
 
     /// \brief Make a copy of the given node.
     ///
     /// This function makes a copy of the given node.
-    CopyGraph& node(TNode& tnode, const Node& node) {
+    CopyGraph& node(const Node& node, TNode& tnode) {
       _node_maps.push_back(new _core_bits::ItemCopy<From, Node,
-                           NodeRefMap, TNode>(tnode, node));
+                           NodeRefMap, TNode>(node, tnode));
       return *this;
     }
 
@@ -835 +835 @@
     /// The key type of the new map \c tmap should be the Arc type of the
     /// destination graph, and the key type of the original map \c map
     /// should be the Arc type of the source graph.
-    template <typename ToMap, typename FromMap>
-    CopyGraph& arcMap(ToMap& tmap, const FromMap& map) {
+    template <typename FromMap, typename ToMap>
+    CopyGraph& arcMap(const FromMap& map, ToMap& tmap) {
       _arc_maps.push_back(new _core_bits::MapCopy<From, Arc,
-                          ArcRefMap, ToMap, FromMap>(tmap, map));
+                          ArcRefMap, FromMap, ToMap>(map, tmap));
       return *this;
     }
 
     /// \brief Make a copy of the given arc.
     ///
     /// This function makes a copy of the given arc.
-    CopyGraph& arc(TArc& tarc, const Arc& arc) {
+    CopyGraph& arc(const Arc& arc, TArc& tarc) {
       _arc_maps.push_back(new _core_bits::ItemCopy<From, Arc,
-                          ArcRefMap, TArc>(tarc, arc));
+                          ArcRefMap, TArc>(arc, tarc));
       return *this;
     }
 
@@ -884 +884 @@
     /// The key type of the new map \c tmap should be the Edge type of the
     /// destination graph, and the key type of the original map \c map
     /// should be the Edge type of the source graph.
-    template <typename ToMap, typename FromMap>
-    CopyGraph& edgeMap(ToMap& tmap, const FromMap& map) {
+    template <typename FromMap, typename ToMap>
+    CopyGraph& edgeMap(const FromMap& map, ToMap& tmap) {
       _edge_maps.push_back(new _core_bits::MapCopy<From, Edge,
-                           EdgeRefMap, ToMap, FromMap>(tmap, map));
+                           EdgeRefMap, FromMap, ToMap>(map, tmap));
       return *this;
     }
 
     /// \brief Make a copy of the given edge.
     ///
     /// This function makes a copy of the given edge.
-    CopyGraph& edge(TEdge& tedge, const Edge& edge) {
+    CopyGraph& edge(const Edge& edge, TEdge& tedge) {
       _edge_maps.push_back(new _core_bits::ItemCopy<From, Edge,
-                           EdgeRefMap, TEdge>(tedge, edge));
+                           EdgeRefMap, TEdge>(edge, tedge));
       return *this;
     }
 
@@ -907 +907 @@
     void run() {
       NodeRefMap nodeRefMap(_from);
       EdgeRefMap edgeRefMap(_from);
-      ArcRefMap arcRefMap(_to, _from, edgeRefMap, nodeRefMap);
+      ArcRefMap arcRefMap(_from, _to, edgeRefMap, nodeRefMap);
       _core_bits::CopyGraphSelector<To>::
-        copy(_to, _from, nodeRefMap, edgeRefMap);
+        copy(_from, _to, nodeRefMap, edgeRefMap);
       for (int i = 0; i < int(_node_maps.size()); ++i) {
         _node_maps[i]->copy(_from, nodeRefMap);
       }
@@ -943 +943 @@
   /// The complete usage of it is detailed in the CopyGraph class,
   /// but a short example shows a basic work:
   ///\code
-  /// copyGraph(trg, src).nodeRef(nr).edgeCrossRef(ecr).run();
+  /// copyGraph(src, trg).nodeRef(nr).edgeCrossRef(ecr).run();
   ///\endcode
   ///
   /// After the copy the \c nr map will contain the mapping from the
@@ -952 +952 @@
   /// to the edges of the \c from graph.
   ///
   /// \see CopyGraph
-  template <typename To, typename From>
-  CopyGraph<To, From>
-  copyGraph(To& to, const From& from) {
-    return CopyGraph<To, From>(to, from);
+  template <typename From, typename To>
+  CopyGraph<From, To>
+  copyGraph(const From& from, To& to) {
+    return CopyGraph<From, To>(from, to);
   }
 
   namespace _core_bits {

test/graph_copy_test.cc

@@ -63 +63 @@
   ListDigraph::NodeMap<SmartDigraph::Node> ncr(to);
   ListDigraph::ArcMap<SmartDigraph::Arc> ecr(to);
 
-  CopyDigraph<ListDigraph, SmartDigraph>(to, from).
-    nodeMap(tnm, fnm).arcMap(tam, fam).
+  copyDigraph(from, to).
+    nodeMap(fnm, tnm).arcMap(fam, tam).
     nodeRef(nr).arcRef(er).
     nodeCrossRef(ncr).arcCrossRef(ecr).
-    node(tn, fn).arc(ta, fa).run();
+    node(fn, tn).arc(fa, ta).run();
 
   for (SmartDigraph::NodeIt it(from); it != INVALID; ++it) {
     check(ncr[nr[it]] == it, "Wrong copy.");
@@ -138 +138 @@
   ListGraph::ArcMap<SmartGraph::Arc> acr(to);
   ListGraph::EdgeMap<SmartGraph::Edge> ecr(to);
 
-  CopyGraph<ListGraph, SmartGraph>(to, from).
-    nodeMap(tnm, fnm).arcMap(tam, fam).edgeMap(tem, fem).
+  copyGraph(from, to).
+    nodeMap(fnm, tnm).arcMap(fam, tam).edgeMap(fem, tem).
     nodeRef(nr).arcRef(ar).edgeRef(er).
     nodeCrossRef(ncr).arcCrossRef(acr).edgeCrossRef(ecr).
-    node(tn, fn).arc(ta, fa).edge(te, fe).run();
+    node(fn, tn).arc(fa, ta).edge(fe, te).run();
 
   for (SmartGraph::NodeIt it(from); it != INVALID; ++it) {
     check(ncr[nr[it]] == it, "Wrong copy.");