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

//     typedef Graph::template UEdgeMap<bool> BoolUEdgeMap;	 

//     typedef Graph::template UEdgeMap<int> IntUEdgeMap;

//     typedef Graph::template UEdgeMap<double> DoubleUEdgeMap;

  ///\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::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.nodeNum();

      }

    };    

  }

  /// \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.nodeNum();

      }

    };    

  }

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

  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

  ///

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

  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

  ///

  /// \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];

    }

  }

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

  public: 

    typedef typename Source::Node Node;

    typedef typename Source::NodeIt NodeIt;

    typedef typename Source::Edge Edge;

    typedef typename Source::EdgeIt EdgeIt;

    typedef typename Source::template NodeMap<typename Target::Node>NodeRefMap;

    typedef typename Source::template EdgeMap<typename Target::Edge>EdgeRefMap;

    /// \brief Constructor for the GraphCopy.

    ///

    /// It copies the content of the \c _source graph into the

    /// \c _target graph. It creates also two references, one beetween

    /// the two nodeset and one beetween the two edgesets.

    GraphCopy(Target& _target, const Source& _source) 

      : source(_source), target(_target), 

	nodeRefMap(_source), edgeRefMap(_source) {

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

	nodeRefMap[it] = target.addNode();

      }

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

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

					nodeRefMap[source.target(it)]);

      }

    }

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

    ///

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

    template <typename NodeRef>

    const GraphCopy& nodeRef(NodeRef& map) const {

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

	map.set(it, nodeRefMap[it]);

      }

      return *this;

    }

    /// \brief Reverse and copies the node references into the given map.

    ///

    /// Reverse and copies the node references into the given map.

    template <typename NodeRef>

    const GraphCopy& nodeCrossRef(NodeRef& map) const {

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

	map.set(nodeRefMap[it], it);

      }

      return *this;

    }

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

    ///

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

    template <typename EdgeRef>

    const GraphCopy& edgeRef(EdgeRef& map) const {

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

	map.set(it, edgeRefMap[it]);

      }

      return *this;

    }

    /// \brief Reverse and copies the edge references into the given map.

    ///

    /// Reverse and copies the edge references into the given map.

    template <typename EdgeRef>

    const GraphCopy& edgeCrossRef(EdgeRef& map) const {

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

	map.set(edgeRefMap[it], it);

      }

      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>

    const GraphCopy& nodeMap(TargetMap& tMap, const SourceMap& sMap) const {

      copyMap(tMap, sMap, NodeIt(source), nodeRefMap);

      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>

    const GraphCopy& edgeMap(TargetMap& tMap, const SourceMap& sMap) const {

      copyMap(tMap, sMap, EdgeIt(source), edgeRefMap);

      return *this;

    }

    /// \brief Gives back the stored node references.

    ///

    /// Gives back the stored node references.

    const NodeRefMap& nodeRef() const {

      return nodeRefMap;

    }

    /// \brief Gives back the stored edge references.

    ///

    /// Gives back the stored edge references.

    const EdgeRefMap& edgeRef() const {

      return edgeRefMap;

    }

    void run() const {}

  private:

    const Source& source;

    Target& target;

    NodeRefMap nodeRefMap;

    EdgeRefMap edgeRefMap;

  };

  /// \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);

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

  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 {

  public: 

    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 Source::

    template NodeMap<typename Target::Node> NodeRefMap;

    typedef typename Source::

    template UEdgeMap<typename Target::UEdge> UEdgeRefMap;

  private:

    struct EdgeRefMap {

      EdgeRefMap(UGraphCopy& _gc) : gc(_gc) {}

      typedef typename Source::Edge Key;

      typedef typename Target::Edge Value;

      Value operator[](const Key& key) {

	return gc.target.direct(gc.uEdgeRef[key], 

				gc.target.direction(key));

      }

      UGraphCopy& gc;

    };

  public:

    /// \brief Constructor for the UGraphCopy.

    ///

    /// It copies the content of the \c _source graph into the

    /// \c _target graph. It creates also two references, one beetween

    /// the two nodeset and one beetween the two edgesets.

    UGraphCopy(Target& _target, const Source& _source) 

      : source(_source), target(_target), 

	nodeRefMap(_source), edgeRefMap(*this), uEdgeRefMap(_source) {

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

	nodeRefMap[it] = target.addNode();

      }

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

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

					nodeRefMap[source.target(it)]);

      }

    }

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

    ///

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

    template <typename NodeRef>

    const UGraphCopy& nodeRef(NodeRef& map) const {

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

	map.set(it, nodeRefMap[it]);

      }

      return *this;

    }

    /// \brief Reverse and copies the node references into the given map.

    ///

    /// Reverse and copies the node references into the given map.

    template <typename NodeRef>

    const UGraphCopy& nodeCrossRef(NodeRef& map) const {

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

	map.set(nodeRefMap[it], it);

      }

      return *this;

    }

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

    ///

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

    template <typename EdgeRef>

    const UGraphCopy& edgeRef(EdgeRef& map) const {

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

	map.set(edgeRefMap[it], it);

      }

      return *this;

    }

    /// \brief Reverse and copies the undirected edge references into the 

    /// given map.

    ///

    /// Reverse and copies the undirected edge references into the given map.

    template <typename EdgeRef>

    const UGraphCopy& edgeCrossRef(EdgeRef& map) const {

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

	map.set(it, edgeRefMap[it]);

      }

      return *this;

    }

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

    ///

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

    template <typename EdgeRef>

    const UGraphCopy& uEdgeRef(EdgeRef& map) const {

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

	map.set(it, uEdgeRefMap[it]);

      }

      return *this;

    }

    /// \brief Reverse and copies the undirected edge references into the 

    /// given map.

    ///

    /// Reverse and copies the undirected edge references into the given map.

    template <typename EdgeRef>

    const UGraphCopy& uEdgeCrossRef(EdgeRef& map) const {

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

	map.set(uEdgeRefMap[it], it);

      }

      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>

    const UGraphCopy& nodeMap(TargetMap& tMap, 

				  const SourceMap& sMap) const {

      copyMap(tMap, sMap, NodeIt(source), nodeRefMap);

      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>

    const UGraphCopy& edgeMap(TargetMap& tMap, 

				  const SourceMap& sMap) const {

      copyMap(tMap, sMap, EdgeIt(source), edgeRefMap);

      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>

    const UGraphCopy& uEdgeMap(TargetMap& tMap, 

				  const SourceMap& sMap) const {

      copyMap(tMap, sMap, UEdgeIt(source), uEdgeRefMap);

      return *this;

    }

    /// \brief Gives back the stored node references.

    ///

    /// Gives back the stored node references.

    const NodeRefMap& nodeRef() const {

      return nodeRefMap;

    }

    /// \brief Gives back the stored edge references.

    ///

    /// Gives back the stored edge references.

    const EdgeRefMap& edgeRef() const {

      return edgeRefMap;

    }

    /// \brief Gives back the stored uedge references.

    ///

    /// Gives back the stored uedge references.

    const UEdgeRefMap& uEdgeRef() const {

      return uEdgeRefMap;

    }

    void run() const {}

  private:

    const Source& source;

    Target& target;

    NodeRefMap nodeRefMap;

    EdgeRefMap edgeRefMap;

    UEdgeRefMap uEdgeRefMap;

  };

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

  ///

  /// Copy a graph to another graph.

  /// The usage of the function:

  /// 

  ///\code

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

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

  template <typename Target, typename Source>

  UGraphCopy<Target, Source> 

  copyUGraph(Target& target, const Source& source) {

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

  }

  /// @}

  /// \addtogroup graph_maps

  /// @{

  /// Provides an immutable and unique id for each item in the graph.

  /// The IdMap class provides a unique and immutable id for each item of the

  /// same type (e.g. node) in the graph. This id is <ul><li>\b unique:

  /// different items (nodes) get different ids <li>\b immutable: the id of an

  /// item (node) does not change (even if you delete other nodes).  </ul>

  /// Through this map you get access (i.e. can read) the inner id values of

  /// the items stored in the graph. This map can be inverted with its member

  /// class \c InverseMap.

  ///

  template <typename _Graph, typename _Item>

  class IdMap {

  public:

    typedef _Graph Graph;

    typedef int Value;

    typedef _Item Item;

    typedef _Item Key;

    /// \brief Constructor.

    ///

    /// Constructor for creating id map.

    IdMap(const Graph& _graph) : graph(&_graph) {}

    /// \brief Gives back the \e id of the item.

    ///

    /// Gives back the immutable and unique \e id of the map.

    int operator[](const Item& item) const { return graph->id(item);}

  private:

    const Graph* graph;

  public:

    /// \brief The class represents the inverse of its owner (IdMap).

    ///

    /// The class represents the inverse of its owner (IdMap).

    /// \see inverse()

    class InverseMap {

    public:

      /// \brief Constructor.

      ///

      /// Constructor for creating an id-to-item map.

      InverseMap(const Graph& _graph) : graph(&_graph) {}

      /// \brief Constructor.

      ///

      /// Constructor for creating an id-to-item map.

      InverseMap(const IdMap& idMap) : graph(idMap.graph) {}

      /// \brief Gives back the given item from its id.

      ///

      /// Gives back the given item from its id.

      ///