/* -*- C++ -*-

 *

 * This file is a part of LEMON, a generic C++ optimization library

 *

 * Copyright (C) 2003-2006

 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

 * (Egervary Research Group on Combinatorial Optimization, EGRES).

 *

 * Permission to use, modify and distribute this software is granted

 * provided that this copyright notice appears in all copies. For

 * precise terms see the accompanying LICENSE file.

 *

 * This software is provided "AS IS" with no warranty of any kind,

 * express or implied, and with no claim as to its suitability for any

 * purpose.

 *

 */

#ifndef LEMON_GRAPH_UTILS_H

#define LEMON_GRAPH_UTILS_H

#include <iterator>

#include <vector>

#include <map>

#include <cmath>

#include <algorithm>

#include <lemon/bits/invalid.h>

#include <lemon/bits/utility.h>

#include <lemon/maps.h>

#include <lemon/bits/traits.h>

#include <lemon/bits/alteration_notifier.h>

#include <lemon/bits/default_map.h>

///\ingroup gutils

///\file

///\brief Graph utilities.

///

///

namespace lemon {

  /// \addtogroup gutils

  /// @{

  ///Creates convenience typedefs for the graph types and iterators

  ///This \c \#define creates convenience typedefs for the following types

  ///of \c Graph: \c Node,  \c NodeIt, \c Edge, \c EdgeIt, \c InEdgeIt,

  ///\c OutEdgeIt

  ///\note If \c G it a template parameter, it should be used in this way.

  ///\code

  ///  GRAPH_TYPEDEFS(typename G)

  ///\endcode

  ///

  ///\warning There are no typedefs for the graph maps because of the lack of

  ///template typedefs in C++.

#define GRAPH_TYPEDEFS(Graph)				\

  typedef Graph::     Node      Node;			\

    typedef Graph::   NodeIt    NodeIt;			\

    typedef Graph::   Edge      Edge;			\

    typedef Graph::   EdgeIt    EdgeIt;			\

    typedef Graph:: InEdgeIt  InEdgeIt;			\

    typedef Graph::OutEdgeIt OutEdgeIt;			

  ///Creates convenience typedefs for the undirected graph types and iterators

  ///This \c \#define creates the same convenience typedefs as defined by

  ///\ref GRAPH_TYPEDEFS(Graph) and three more, namely it creates

  ///\c UEdge, \c UEdgeIt, \c IncEdgeIt,

  ///

  ///\note If \c G it a template parameter, it should be used in this way.

  ///\code

  ///  UGRAPH_TYPEDEFS(typename G)

  ///\endcode

  ///

  ///\warning There are no typedefs for the graph maps because of the lack of

  ///template typedefs in C++.

#define UGRAPH_TYPEDEFS(Graph)				\

  GRAPH_TYPEDEFS(Graph)						\

    typedef Graph:: UEdge   UEdge;			\

    typedef Graph:: UEdgeIt UEdgeIt;			\

    typedef Graph:: IncEdgeIt   IncEdgeIt;		       

  ///\brief Creates convenience typedefs for the bipartite undirected graph 

  ///types and iterators

  ///This \c \#define creates the same convenience typedefs as defined by

  ///\ref UGRAPH_TYPEDEFS(Graph) and two more, namely it creates

  ///\c ANodeIt, \c BNodeIt, 

  ///

  ///\note If \c G it a template parameter, it should be used in this way.

  ///\code

  ///  BPUGRAPH_TYPEDEFS(typename G)

  ///\endcode

  ///

  ///\warning There are no typedefs for the graph maps because of the lack of

  ///template typedefs in C++.

#define BPUGRAPH_TYPEDEFS(Graph)            \

  UGRAPH_TYPEDEFS(Graph)                    \

    typedef Graph::ANode ANode;             \

    typedef Graph::BNode BNode;             \

    typedef Graph::ANodeIt ANodeIt;	    \

    typedef Graph::BNodeIt BNodeIt;

  /// \brief Function to count the items in the graph.

  ///

  /// This function counts the items (nodes, edges etc) in the graph.

  /// The complexity of the function is O(n) because

  /// it iterates on all of the items.

  template <typename Graph, typename Item>

  inline int countItems(const Graph& g) {

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

    int num = 0;

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

      ++num;

    }

    return num;

  }

  // Node counting:

  namespace _graph_utils_bits {

    template <typename Graph, typename Enable = void>

    struct CountNodesSelector {

      static int count(const Graph &g) {

        return countItems<Graph, typename Graph::Node>(g);

      }

    };

    template <typename Graph>

    struct CountNodesSelector<

      Graph, typename 

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

    {

      static int count(const Graph &g) {

        return g.nodeNum();

      }

    };    

  }

  /// \brief Function to count the nodes in the graph.

  ///

  /// This function counts the nodes in the graph.

  /// The complexity of the function is O(n) but for some

  /// graph structures it is specialized to run in O(1).

  ///

  /// \todo refer how to specialize it

  template <typename Graph>

  inline int countNodes(const Graph& g) {

    return _graph_utils_bits::CountNodesSelector<Graph>::count(g);

  }

  namespace _graph_utils_bits {

    template <typename Graph, typename Enable = void>

    struct CountANodesSelector {

      static int count(const Graph &g) {

        return countItems<Graph, typename Graph::ANode>(g);

      }

    };

    template <typename Graph>

    struct CountANodesSelector<

      Graph, typename 

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

    {

      static int count(const Graph &g) {

        return g.aNodeNum();

      }

    };    

  }

  /// \brief Function to count the anodes in the graph.

  ///

  /// This function counts the anodes in the graph.

  /// The complexity of the function is O(an) but for some

  /// graph structures it is specialized to run in O(1).

  ///

  /// \todo refer how to specialize it

  template <typename Graph>

  inline int countANodes(const Graph& g) {

    return _graph_utils_bits::CountANodesSelector<Graph>::count(g);

  }

  namespace _graph_utils_bits {

    template <typename Graph, typename Enable = void>

    struct CountBNodesSelector {

      static int count(const Graph &g) {

        return countItems<Graph, typename Graph::BNode>(g);

      }

    };

    template <typename Graph>

    struct CountBNodesSelector<

      Graph, typename 

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

    {

      static int count(const Graph &g) {

        return g.bNodeNum();

      }

    };    

  }

  /// \brief Function to count the bnodes in the graph.

  ///

  /// This function counts the bnodes in the graph.

  /// The complexity of the function is O(bn) but for some

  /// graph structures it is specialized to run in O(1).

  ///

  /// \todo refer how to specialize it

  template <typename Graph>

  inline int countBNodes(const Graph& g) {

    return _graph_utils_bits::CountBNodesSelector<Graph>::count(g);

  }

  // Edge counting:

  namespace _graph_utils_bits {

    template <typename Graph, typename Enable = void>

    struct CountEdgesSelector {

      static int count(const Graph &g) {

        return countItems<Graph, typename Graph::Edge>(g);

      }

    };

    template <typename Graph>

    struct CountEdgesSelector<

      Graph, 

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

    {

      static int count(const Graph &g) {

        return g.edgeNum();

      }

    };    

  }

  /// \brief Function to count the edges in the graph.

  ///

  /// This function counts the edges in the graph.

  /// The complexity of the function is O(e) but for some

  /// graph structures it is specialized to run in O(1).

  template <typename Graph>

  inline int countEdges(const Graph& g) {

    return _graph_utils_bits::CountEdgesSelector<Graph>::count(g);

  }

  // Undirected edge counting:

  namespace _graph_utils_bits {

    template <typename Graph, typename Enable = void>

    struct CountUEdgesSelector {

      static int count(const Graph &g) {

        return countItems<Graph, typename Graph::UEdge>(g);

      }

    };

    template <typename Graph>

    struct CountUEdgesSelector<

      Graph, 

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

    {

      static int count(const Graph &g) {

        return g.uEdgeNum();

      }

    };    

  }

  /// \brief Function to count the undirected edges in the graph.

  ///

  /// This function counts the undirected edges in the graph.

  /// The complexity of the function is O(e) but for some

  /// graph structures it is specialized to run in O(1).

  template <typename Graph>

  inline int countUEdges(const Graph& g) {

    return _graph_utils_bits::CountUEdgesSelector<Graph>::count(g);

  }

  template <typename Graph, typename DegIt>

  inline int countNodeDegree(const Graph& _g, const typename Graph::Node& _n) {

    int num = 0;

    for (DegIt it(_g, _n); it != INVALID; ++it) {

      ++num;

    }

    return num;

  }

  /// \brief Function to count the number of the out-edges from node \c n.

  ///

  /// This function counts the number of the out-edges from node \c n

  /// in the graph.  

  template <typename Graph>

  inline int countOutEdges(const Graph& _g,  const typename Graph::Node& _n) {

    return countNodeDegree<Graph, typename Graph::OutEdgeIt>(_g, _n);

  }

  /// \brief Function to count the number of the in-edges to node \c n.

  ///

  /// This function counts the number of the in-edges to node \c n

  /// in the graph.  

  template <typename Graph>

  inline int countInEdges(const Graph& _g,  const typename Graph::Node& _n) {

    return countNodeDegree<Graph, typename Graph::InEdgeIt>(_g, _n);

  }

  /// \brief Function to count the number of the inc-edges to node \c n.

  ///

  /// This function counts the number of the inc-edges to node \c n

  /// in the graph.  

  template <typename Graph>

  inline int countIncEdges(const Graph& _g,  const typename Graph::Node& _n) {

    return countNodeDegree<Graph, typename Graph::IncEdgeIt>(_g, _n);

  }

  namespace _graph_utils_bits {

    template <typename Graph, typename Enable = void>

    struct FindEdgeSelector {

      typedef typename Graph::Node Node;

      typedef typename Graph::Edge Edge;

      static Edge find(const Graph &g, Node u, Node v, Edge e) {

        if (e == INVALID) {

          g.firstOut(e, u);

        } else {

          g.nextOut(e);

        }

        while (e != INVALID && g.target(e) != v) {

          g.nextOut(e);

        }

        return e;

      }

    };

    template <typename Graph>

    struct FindEdgeSelector<

      Graph, 

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

    {

      typedef typename Graph::Node Node;

      typedef typename Graph::Edge Edge;

      static Edge find(const Graph &g, Node u, Node v, Edge prev) {

        return g.findEdge(u, v, prev);

      }

    };    

  }

  /// \brief Finds an edge between two nodes of a graph.

  ///

  /// Finds an edge from node \c u to node \c v in graph \c g.

  ///

  /// If \c prev is \ref INVALID (this is the default value), then

  /// it finds the first edge from \c u to \c v. Otherwise it looks for

  /// the next edge from \c u to \c v after \c prev.

  /// \return The found edge or \ref INVALID if there is no such an edge.

  ///

  /// Thus you can iterate through each edge from \c u to \c v as it follows.

  ///\code

  /// for(Edge e=findEdge(g,u,v);e!=INVALID;e=findEdge(g,u,v,e)) {

  ///   ...

  /// }

  ///\endcode

  ///

  ///\sa EdgeLookUp

  ///\se AllEdgeLookup

  ///\sa ConEdgeIt

  template <typename Graph>

  inline typename Graph::Edge 

  findEdge(const Graph &g, typename Graph::Node u, typename Graph::Node v,

           typename Graph::Edge prev = INVALID) {

    return _graph_utils_bits::FindEdgeSelector<Graph>::find(g, u, v, prev);

  }

  /// \brief Iterator for iterating on edges connected the same nodes.

  ///

  /// Iterator for iterating on edges connected the same nodes. It is 

  /// higher level interface for the findEdge() function. You can

  /// use it the following way:

  ///\code

  /// for (ConEdgeIt<Graph> it(g, src, trg); it != INVALID; ++it) {

  ///   ...

  /// }

  ///\endcode

  /// 

  ///\sa findEdge()

  ///\sa EdgeLookUp

  ///\sa AllEdgeLookup

  ///

  /// \author Balazs Dezso 

  template <typename _Graph>

  class ConEdgeIt : public _Graph::Edge {

  public:

    typedef _Graph Graph;

    typedef typename Graph::Edge Parent;

    typedef typename Graph::Edge Edge;

    typedef typename Graph::Node Node;

    /// \brief Constructor.

    ///

    /// Construct a new ConEdgeIt iterating on the edges which

    /// connects the \c u and \c v node.

    ConEdgeIt(const Graph& g, Node u, Node v) : graph(g) {

      Parent::operator=(findEdge(graph, u, v));

    }

    /// \brief Constructor.

    ///

    /// Construct a new ConEdgeIt which continues the iterating from 

    /// the \c e edge.

    ConEdgeIt(const Graph& g, Edge e) : Parent(e), graph(g) {}

    /// \brief Increment operator.

    ///

    /// It increments the iterator and gives back the next edge.

    ConEdgeIt& operator++() {

      Parent::operator=(findEdge(graph, graph.source(*this), 

				 graph.target(*this), *this));

      return *this;

    }

  private:

    const Graph& graph;

  };

  namespace _graph_utils_bits {

    template <typename Graph, typename Enable = void>

    struct FindUEdgeSelector {

      typedef typename Graph::Node Node;

      typedef typename Graph::UEdge UEdge;

      static UEdge find(const Graph &g, Node u, Node v, UEdge e) {

        bool b;

        if (u != v) {

          if (e == INVALID) {

            g.firstInc(e, b, u);

          } else {

            b = g.source(e) == u;

            g.nextInc(e, b);

          }

          while (e != INVALID && (b ? g.target(e) : g.source(e)) != v) {

            g.nextInc(e, b);

          }

        } else {

          if (e == INVALID) {

            g.firstInc(e, b, u);

          } else {

            b = true;

            g.nextInc(e, b);

          }

          while (e != INVALID && (!b || g.target(e) != v)) {

            g.nextInc(e, b);

          }

        }

        return e;

      }

    };

    template <typename Graph>

    struct FindUEdgeSelector<

      Graph, 

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

    {

      typedef typename Graph::Node Node;

      typedef typename Graph::UEdge UEdge;

      static UEdge find(const Graph &g, Node u, Node v, UEdge prev) {

        return g.findUEdge(u, v, prev);

      }

    };    

  }

  /// \brief Finds an uedge between two nodes of a graph.

  ///

  /// Finds an uedge from node \c u to node \c v in graph \c g.

  /// If the node \c u and node \c v is equal then each loop edge

  /// will be enumerated.

  ///

  /// If \c prev is \ref INVALID (this is the default value), then

  /// it finds the first edge from \c u to \c v. Otherwise it looks for

  /// the next edge from \c u to \c v after \c prev.

  /// \return The found edge or \ref INVALID if there is no such an edge.

  ///

  /// Thus you can iterate through each edge from \c u to \c v as it follows.

  ///\code

  /// for(UEdge e = findUEdge(g,u,v); e != INVALID; 

  ///     e = findUEdge(g,u,v,e)) {

  ///   ...

  /// }

  ///\endcode

  ///

  ///\sa ConEdgeIt

  template <typename Graph>

  inline typename Graph::UEdge 

  findUEdge(const Graph &g, typename Graph::Node u, typename Graph::Node v,

            typename Graph::UEdge p = INVALID) {

    return _graph_utils_bits::FindUEdgeSelector<Graph>::find(g, u, v, p);

  }

  /// \brief Iterator for iterating on uedges connected the same nodes.

  ///

  /// Iterator for iterating on uedges connected the same nodes. It is 

  /// higher level interface for the findUEdge() function. You can

  /// use it the following way:

  ///\code

  /// for (ConUEdgeIt<Graph> it(g, src, trg); it != INVALID; ++it) {

  ///   ...

  /// }

  ///\endcode

  ///

  ///\sa findUEdge()

  ///

  /// \author Balazs Dezso 

  template <typename _Graph>

  class ConUEdgeIt : public _Graph::UEdge {

  public:

    typedef _Graph Graph;

    typedef typename Graph::UEdge Parent;

    typedef typename Graph::UEdge UEdge;

    typedef typename Graph::Node Node;

    /// \brief Constructor.

    ///

    /// Construct a new ConUEdgeIt iterating on the edges which

    /// connects the \c u and \c v node.

    ConUEdgeIt(const Graph& g, Node u, Node v) : graph(g) {

      Parent::operator=(findUEdge(graph, u, v));

    }

    /// \brief Constructor.

    ///

    /// Construct a new ConUEdgeIt which continues the iterating from 

    /// the \c e edge.

    ConUEdgeIt(const Graph& g, UEdge e) : Parent(e), graph(g) {}

    /// \brief Increment operator.

    ///

    /// It increments the iterator and gives back the next edge.

    ConUEdgeIt& operator++() {

      Parent::operator=(findUEdge(graph, graph.source(*this), 

				      graph.target(*this), *this));

      return *this;

    }

  private:

    const Graph& graph;

  };

  /// \brief Copy a map.

  ///

  /// This function copies the \c source map to the \c target 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, 

	    typename ItemIt, typename Ref>	    

  void copyMap(Target& target, const Source& source, 

	       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 iterate on the data structure.

  template <typename Target, typename Source, typename ItemIt>	    

  void copyMap(Target& target, const Source& source, ItemIt it) {

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

      target[it] = source[it];

    }

  }

  namespace _graph_utils_bits {

    template <typename Graph, typename Item, typename RefMap>

    class MapCopyBase {

    public:

      virtual void copy(const Graph& source, const RefMap& refMap) = 0;

      virtual ~MapCopyBase() {}

    };

    template <typename Graph, typename Item, typename RefMap, 

              typename TargetMap, typename SourceMap>

    class MapCopy : public MapCopyBase<Graph, Item, RefMap> {

    public:

      MapCopy(TargetMap& tmap, const SourceMap& map) 

        : _tmap(tmap), _map(map) {}

      virtual void copy(const Graph& graph, const RefMap& refMap) {

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

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

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

        }

      }

    private:

      TargetMap& _tmap;

      const SourceMap& _map;

    };

    template <typename Graph, typename Item, typename RefMap, typename It>

    class ItemCopy : public MapCopyBase<Graph, Item, RefMap> {

    public:

      ItemCopy(It& it, const Item& item) : _it(it), _item(item) {}

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

        _it = refMap[_item];

      }

    private:

      It& _it;

      Item _item;

    };

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

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

    public:

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

      virtual void copy(const Graph& graph, const RefMap& refMap) {

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

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

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

        }

      }

    private:

      Ref& _map;

    };

    template <typename Graph, typename Item, typename RefMap, 

              typename CrossRef>

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

    public:

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

      virtual void copy(const Graph& graph, const RefMap& refMap) {

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

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

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

        }

      }

    private:

      CrossRef& _cmap;

    };

    template <typename Graph, typename Enable = void>

    struct GraphCopySelector {

      template <typename Source, typename NodeRefMap, typename EdgeRefMap>

      static void copy(Graph &target, const Source& source,

                       NodeRefMap& nodeRefMap, EdgeRefMap& edgeRefMap) {

        for (typename Source::NodeIt it(source); it != INVALID; ++it) {

          nodeRefMap[it] = target.addNode();

        }

        for (typename Source::EdgeIt it(source); it != INVALID; ++it) {

          edgeRefMap[it] = target.addEdge(nodeRefMap[source.source(it)], 

                                          nodeRefMap[source.target(it)]);

        }

      }

    };

    template <typename Graph>

    struct GraphCopySelector<

      Graph, 

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

    {

      template <typename Source, typename NodeRefMap, typename EdgeRefMap>

      static void copy(Graph &target, const Source& source,

                       NodeRefMap& nodeRefMap, EdgeRefMap& edgeRefMap) {

        target.build(source, nodeRefMap, edgeRefMap);

      }

    };

    template <typename UGraph, typename Enable = void>

    struct UGraphCopySelector {

      template <typename Source, typename NodeRefMap, typename UEdgeRefMap>

      static void copy(UGraph &target, const Source& source,

                       NodeRefMap& nodeRefMap, UEdgeRefMap& uEdgeRefMap) {

        for (typename Source::NodeIt it(source); it != INVALID; ++it) {

          nodeRefMap[it] = target.addNode();

        }

        for (typename Source::UEdgeIt it(source); it != INVALID; ++it) {

          uEdgeRefMap[it] = target.addEdge(nodeRefMap[source.source(it)], 

                                          nodeRefMap[source.target(it)]);

        }

      }

    };

    template <typename UGraph>

    struct UGraphCopySelector<

      UGraph, 

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

    {

      template <typename Source, typename NodeRefMap, typename UEdgeRefMap>

      static void copy(UGraph &target, const Source& source,

                       NodeRefMap& nodeRefMap, UEdgeRefMap& uEdgeRefMap) {

        target.build(source, nodeRefMap, uEdgeRefMap);

      }

    };

    template <typename BpUGraph, typename Enable = void>

    struct BpUGraphCopySelector {

      template <typename Source, typename ANodeRefMap, 

                typename BNodeRefMap, typename UEdgeRefMap>

      static void copy(BpUGraph &target, const Source& source,

                       ANodeRefMap& aNodeRefMap, BNodeRefMap& bNodeRefMap,

                       UEdgeRefMap& uEdgeRefMap) {

        for (typename Source::ANodeIt it(source); it != INVALID; ++it) {

          aNodeRefMap[it] = target.addANode();

        }

        for (typename Source::BNodeIt it(source); it != INVALID; ++it) {

          bNodeRefMap[it] = target.addBNode();

        }

        for (typename Source::UEdgeIt it(source); it != INVALID; ++it) {

          uEdgeRefMap[it] = target.addEdge(aNodeRefMap[source.aNode(it)], 

                                           bNodeRefMap[source.bNode(it)]);

        }

      }

    };

    template <typename BpUGraph>

    struct BpUGraphCopySelector<

      BpUGraph, 

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

    {

      template <typename Source, typename ANodeRefMap, 

                typename BNodeRefMap, typename UEdgeRefMap>

      static void copy(BpUGraph &target, const Source& source,

                       ANodeRefMap& aNodeRefMap, BNodeRefMap& bNodeRefMap,

                       UEdgeRefMap& uEdgeRefMap) {

        target.build(source, aNodeRefMap, bNodeRefMap, uEdgeRefMap);

      }

    };

  }

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

  template <typename Target, typename Source>

  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;

  public: 

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

    /// \brief Destructor of the GraphCopy

    ///

    /// Destructor of the GraphCopy

    ~GraphCopy() {

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

        delete nodeMapCopies[i];

      }

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

        delete edgeMapCopies[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) {

      nodeMapCopies.push_back(new _graph_utils_bits::RefCopy<Source, 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) {

      nodeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<Source, 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 target graph's node type,

    /// and the copied map's key type is the source 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));

      return *this;

    }

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

    ///

    /// Make a copy of the given node.

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

      nodeMapCopies.push_back(new _graph_utils_bits::ItemCopy<Source, Node, 

                              NodeRefMap, TNode>(tnode, node));

      return *this;

    }

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

    ///

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

    template <typename EdgeRef>

    GraphCopy& edgeRef(EdgeRef& map) {

      edgeMapCopies.push_back(new _graph_utils_bits::RefCopy<Source, Edge, 

                              EdgeRefMap, EdgeRef>(map));

      return *this;

    }

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

    ///

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

    ///  the given map.

    template <typename EdgeCrossRef>

    GraphCopy& edgeCrossRef(EdgeCrossRef& map) {

      edgeMapCopies.push_back(new _graph_utils_bits::CrossRefCopy<Source, Edge,

                              EdgeRefMap, EdgeCrossRef>(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 target graph's edge type,

    /// and the copied map's key type is the source 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));

      return *this;

    }

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

    ///

    /// Make a copy of the given edge.

    GraphCopy& edge(TEdge& tedge, const Edge& edge) {

      edgeMapCopies.push_back(new _graph_utils_bits::ItemCopy<Source, Edge, 

                              EdgeRefMap, TEdge>(tedge, edge));

      return *this;

    }

    /// \brief Executes the copies.

    ///

    /// Executes the copies.

    void run() {

      NodeRefMap nodeRefMap(source);

      EdgeRefMap edgeRefMap(source);

      _graph_utils_bits::GraphCopySelector<Target>::

        copy(target, source, nodeRefMap, edgeRefMap);

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

        nodeMapCopies[i]->copy(source, nodeRefMap);

      }

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

        edgeMapCopies[i]->copy(source, edgeRefMap);

      }      

    }

  protected:

    const Source& source;

    Target& target;

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

    nodeMapCopies;

    std::vector<_graph_utils_bits::MapCopyBase<Source, Edge, EdgeRefMap>* > 

    edgeMapCopies;

  };

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

  ///

  /// Copy a graph to another graph.

  /// The usage of the function:

  /// 

  ///\code

  /// copyGraph(trg, src).nodeRef(nr).edgeCrossRef(ecr).run();

  ///\endcode

  /// 

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

  /// edges.

  ///

  /// \see GraphCopy 

  template <typename Target, typename Source>

  GraphCopy<Target, Source> copyGraph(Target& target, const Source& source) {

    return GraphCopy<Target, Source>(target, source);

  }

  /// \brief Class to copy an undirected graph.

  ///

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

  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;

    struct EdgeRefMap {

      EdgeRefMap(const Target& _target, const Source& _source,

                 const UEdgeRefMap& _uedge_ref, const NodeRefMap& _node_ref) 

        : target(_target), source(_source), 

          uedge_ref(_uedge_ref), node_ref(_node_ref) {}

      typedef typename Source::Edge Key;

      typedef typename Target::Edge Value;

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

        bool forward = (source.direction(key) == 

                        (node_ref[source.source((UEdge)key)] == 

                         target.source(uedge_ref[(UEdge)key])));

	return target.direct(uedge_ref[key], forward); 

      }

      const Target& target;

      const Source& source;

      const UEdgeRefMap& uedge_ref;

      const NodeRefMap& node_ref;

    };

  public: 

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

    /// \brief Destructor of the GraphCopy