RhodeCode

        for (ItemIt it(digraph); it != INVALID; ++it) {

          _tmap.set(refMap[it], _map[it]);

        }

      }

    private:

      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) {}

      virtual void copy(const Digraph&, const RefMap& refMap) {

        _it = refMap[_item];

      }

    private:

      It& _it;

      Item _item;

    };

    template <typename Digraph, typename Item, typename RefMap, typename Ref>

    class RefCopy : public MapCopyBase<Digraph, Item, RefMap> {

    public:

      RefCopy(Ref& map) : _map(map) {}

      virtual void copy(const Digraph& digraph, const RefMap& refMap) {

        typedef typename ItemSetTraits<Digraph, Item>::ItemIt ItemIt;

        for (ItemIt it(digraph); it != INVALID; ++it) {

          _map.set(it, refMap[it]);

        }

      }

    private:

      Ref& _map;

    };

    template <typename Digraph, typename Item, typename RefMap, 

              typename CrossRef>

    class CrossRefCopy : public MapCopyBase<Digraph, Item, RefMap> {

    public:

      CrossRefCopy(CrossRef& cmap) : _cmap(cmap) {}

      virtual void copy(const Digraph& digraph, const RefMap& refMap) {

        typedef typename ItemSetTraits<Digraph, Item>::ItemIt ItemIt;

        for (ItemIt it(digraph); it != INVALID; ++it) {

          _cmap.set(refMap[it], it);

        }

      }

    private:

      CrossRef& _cmap;

    };

    template <typename Digraph, typename Enable = void>

    struct DigraphCopySelector {

      template <typename From, typename NodeRefMap, typename ArcRefMap>

      static void copy(Digraph &to, const From& from,

                       NodeRefMap& nodeRefMap, ArcRefMap& arcRefMap) {

        for (typename From::NodeIt it(from); it != INVALID; ++it) {

          nodeRefMap[it] = to.addNode();

        }

        for (typename From::ArcIt it(from); it != INVALID; ++it) {

          arcRefMap[it] = to.addArc(nodeRefMap[from.source(it)], 

                                          nodeRefMap[from.target(it)]);

        }

      }

    };

    template <typename Digraph>

    struct DigraphCopySelector<

      Digraph, 

      typename enable_if<typename Digraph::BuildTag, void>::type> 

    {

      template <typename From, typename NodeRefMap, typename ArcRefMap>

      static void copy(Digraph &to, const From& from,

                       NodeRefMap& nodeRefMap, ArcRefMap& arcRefMap) {

        to.build(from, nodeRefMap, arcRefMap);

      }

    };

    template <typename Graph, typename Enable = void>

    struct GraphCopySelector {

      template <typename From, typename NodeRefMap, typename EdgeRefMap>

      static void copy(Graph &to, const From& from,

                       NodeRefMap& nodeRefMap, EdgeRefMap& edgeRefMap) {

        for (typename From::NodeIt it(from); it != INVALID; ++it) {

          nodeRefMap[it] = to.addNode();

        }

        for (typename From::EdgeIt it(from); it != INVALID; ++it) {

        }

      }

    };

    template <typename Graph>

    struct GraphCopySelector<

      Graph, 

      typename enable_if<typename Graph::BuildTag, void>::type> 

    {

      template <typename From, typename NodeRefMap, typename EdgeRefMap>

      static void copy(Graph &to, const From& from,

                       NodeRefMap& nodeRefMap, EdgeRefMap& edgeRefMap) {

        to.build(from, nodeRefMap, edgeRefMap);

      }

    };

  }

  /// \brief Class to copy a digraph.

  ///

  /// Class to copy a digraph to another digraph (duplicate a digraph). The

  /// simplest way of using it is through the \c copyDigraph() function.

  ///

  /// This class not just make a copy of a graph, but it can create

  /// references and cross references between the nodes and arcs of

  /// the two graphs, it can copy maps for use with the newly created

  /// graph and copy nodes and arcs.

  ///

  /// To make a copy from a graph, first an instance of DigraphCopy

  /// should be created, then the data belongs to the graph should

  /// assigned to copy. In the end, the \c run() member should be

  /// called.

  ///

  /// The next code copies a graph with several data:

  ///\code

  ///  DigraphCopy<NewGraph, OrigGraph> dc(new_graph, orig_graph);

  ///  // create a reference for the nodes

  ///  OrigGraph::NodeMap<NewGraph::Node> nr(orig_graph);

  ///  dc.nodeRef(nr);

  ///  // create a cross reference (inverse) for the arcs

  ///  NewGraph::ArcMap<OrigGraph::Arc> acr(new_graph);

  ///  dc.arcCrossRef(acr);

  ///  // copy an arc map

  ///  OrigGraph::ArcMap<double> oamap(orig_graph);

  ///  NewGraph::ArcMap<double> namap(new_graph);

  ///  dc.arcMap(namap, oamap);

  ///  // copy a node

  ///  OrigGraph::Node on;

  ///  NewGraph::Node nn;

  ///  dc.node(nn, on);

  ///  // Executions of copy

  ///  dc.run();

  ///\endcode

  template <typename To, typename From>

  class DigraphCopy {

  private:

    typedef typename From::Node Node;

    typedef typename From::NodeIt NodeIt;

    typedef typename From::Arc Arc;

    typedef typename From::ArcIt ArcIt;

    typedef typename To::Node TNode;

    typedef typename To::Arc TArc;

    typedef typename From::template NodeMap<TNode> NodeRefMap;

    typedef typename From::template ArcMap<TArc> ArcRefMap;

  public: 

    /// \brief Constructor for the DigraphCopy.

    ///

    /// It copies the content of the \c _from digraph into the

    /// \c _to digraph.

    DigraphCopy(To& to, const From& from) 

      : _from(from), _to(to) {}

    /// \brief Destructor of the DigraphCopy

    ///

    /// Destructor of the DigraphCopy

    ~DigraphCopy() {

      for (int i = 0; i < int(_node_maps.size()); ++i) {

        delete _node_maps[i];

      }

      for (int i = 0; i < int(_arc_maps.size()); ++i) {

        delete _arc_maps[i];

      }

    }

    /// \brief Copies the node references into the given map.

    ///

    /// Copies the node references into the given map. The parameter

    /// should be a map, which key type is the Node type of the source

    const From& _from;

    To& _to;

    std::vector<_graph_utils_bits::MapCopyBase<From, Node, NodeRefMap>* > 

    _node_maps;

    std::vector<_graph_utils_bits::MapCopyBase<From, Arc, ArcRefMap>* > 

    _arc_maps;

  };

  /// \brief Copy a digraph to another digraph.

  ///

  /// Copy a digraph to another digraph. The complete usage of the

  /// function is detailed in the DigraphCopy class, but a short

  /// example shows a basic work:

  ///\code

  /// copyDigraph(trg, src).nodeRef(nr).arcCrossRef(ecr).run();

  ///\endcode

  /// 

  /// After the copy the \c nr map will contain the mapping from the

  /// nodes of the \c from digraph to the nodes of the \c to digraph and

  /// \c ecr will contain the mapping from the arcs of the \c to digraph

  /// to the arcs of the \c from digraph.

  ///

  /// \see DigraphCopy 

  template <typename To, typename From>

  DigraphCopy<To, From> copyDigraph(To& to, const From& from) {

    return DigraphCopy<To, From>(to, from);

  }

  /// \brief Class to copy a graph.

  ///

  /// Class to copy a graph to another graph (duplicate a graph). The

  /// simplest way of using it is through the \c copyGraph() function.

  ///

  /// This class not just make a copy of a graph, but it can create

  /// references and cross references between the nodes, edges and arcs of

  /// the two graphs, it can copy maps for use with the newly created

  /// graph and copy nodes, edges and arcs.

  ///

  /// To make a copy from a graph, first an instance of GraphCopy

  /// should be created, then the data belongs to the graph should

  /// assigned to copy. In the end, the \c run() member should be

  /// called.

  ///

  /// The next code copies a graph with several data:

  ///\code

  ///  GraphCopy<NewGraph, OrigGraph> dc(new_graph, orig_graph);

  ///  // create a reference for the nodes

  ///  OrigGraph::NodeMap<NewGraph::Node> nr(orig_graph);

  ///  dc.nodeRef(nr);

  ///  // create a cross reference (inverse) for the edges

  ///  NewGraph::EdgeMap<OrigGraph::Arc> ecr(new_graph);

  ///  dc.edgeCrossRef(ecr);

  ///  // copy an arc map

  ///  OrigGraph::ArcMap<double> oamap(orig_graph);

  ///  NewGraph::ArcMap<double> namap(new_graph);

  ///  dc.arcMap(namap, oamap);

  ///  // copy a node

  ///  OrigGraph::Node on;

  ///  NewGraph::Node nn;

  ///  dc.node(nn, on);

  ///  // Executions of copy

  ///  dc.run();

  ///\endcode

  template <typename To, typename From>

  class GraphCopy {

  private:

    typedef typename From::Node Node;

    typedef typename From::NodeIt NodeIt;

    typedef typename From::Arc Arc;

    typedef typename From::ArcIt ArcIt;

    typedef typename From::Edge Edge;

    typedef typename From::EdgeIt EdgeIt;

    typedef typename To::Node TNode;

    typedef typename To::Arc TArc;

    typedef typename To::Edge TEdge;

    typedef typename From::template NodeMap<TNode> NodeRefMap;

    typedef typename From::template EdgeMap<TEdge> EdgeRefMap;

    struct ArcRefMap {

      ArcRefMap(const To& to, const From& from,

		const EdgeRefMap& edge_ref, const NodeRefMap& node_ref) 

        : _to(to), _from(from), 

          _edge_ref(edge_ref), _node_ref(node_ref) {}

      typedef typename From::Arc Key;

      typedef typename To::Arc Value;

      Value operator[](const Key& key) const {

	return _to.direct(_edge_ref[key], forward); 

      }

      const To& _to;

      const From& _from;

      const EdgeRefMap& _edge_ref;

      const NodeRefMap& _node_ref;

    };

  public: 

    /// \brief Constructor for the GraphCopy.

    ///

    /// 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

    ///

    /// Destructor of the GraphCopy

    ~GraphCopy() {

      for (int i = 0; i < int(_node_maps.size()); ++i) {

        delete _node_maps[i];

      }

      for (int i = 0; i < int(_arc_maps.size()); ++i) {

        delete _arc_maps[i];

      }

      for (int i = 0; i < int(_edge_maps.size()); ++i) {

        delete _edge_maps[i];

      }

    }

    /// \brief Copies the node references into the given map.

    ///

    /// Copies the node references into the given map.

    template <typename NodeRef>

    GraphCopy& nodeRef(NodeRef& map) {

      _node_maps.push_back(new _graph_utils_bits::RefCopy<From, Node, 

			   NodeRefMap, NodeRef>(map));

      return *this;

    }

    /// \brief Copies the node cross references into the given map.

    ///

    ///  Copies the node cross references (reverse references) into

    ///  the given map.

    template <typename NodeCrossRef>

    GraphCopy& nodeCrossRef(NodeCrossRef& map) {

      _node_maps.push_back(new _graph_utils_bits::CrossRefCopy<From, Node,

			   NodeRefMap, NodeCrossRef>(map));

      return *this;

    }

    /// \brief Make copy of the given map.

    ///

    /// Makes copy of the given map for the newly created graph. 

    /// 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 ToMap, typename FromMap>

    GraphCopy& nodeMap(ToMap& tmap, const FromMap& map) {

      _node_maps.push_back(new _graph_utils_bits::MapCopy<From, Node, 

			   NodeRefMap, ToMap, FromMap>(tmap, map));

      return *this;

    }

    /// \brief Make a copy of the given node.

    ///

    /// Make a copy of the given node.

    GraphCopy& node(TNode& tnode, const Node& snode) {

      _node_maps.push_back(new _graph_utils_bits::ItemCopy<From, Node, 

			   NodeRefMap, TNode>(tnode, snode));

      return *this;

    }

    /// \brief Copies the arc references into the given map.

    ///

    /// Copies the arc references into the given map.

    template <typename ArcRef>

    GraphCopy& arcRef(ArcRef& map) {

      _arc_maps.push_back(new _graph_utils_bits::RefCopy<From, Arc, 

			  ArcRefMap, ArcRef>(map));

      return *this;

    }

    /// \brief Copies the arc cross references into the given map.

    ///

    ///  Copies the arc cross references (reverse references) into

    ///  the given map.

    template <typename ArcCrossRef>

    GraphCopy& arcCrossRef(ArcCrossRef& map) {

      _arc_maps.push_back(new _graph_utils_bits::CrossRefCopy<From, Arc,