RhodeCode

      }

    };

    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

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