/* -*- C++ -*-

 * src/lemon/graph_utils.h - Part of LEMON, a generic C++ optimization library

 *

 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

 * (Egervary Combinatorial Optimization Research Group, 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 <lemon/invalid.h>

#include <lemon/utility.h>

///\ingroup gutils

///\file

///\brief Graph utilities.

///

///\todo Please

///revise the documentation.

///

namespace lemon {

/// \addtogroup gutils

/// @{

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

  ///

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

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

  /// it iterates on all of the items.

  template <typename Graph, typename ItemIt>

  inline int countItems(const Graph& g) {

    int num = 0;

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

      ++num;

    }

    return num;

  }

  // Node counting:

  template <typename Graph>

  inline

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

  _countNodes(const Graph &g) {

    return g.nodeNum();

  }

  template <typename Graph>

  inline int _countNodes(Wrap<Graph> w) {

    return countItems<Graph, typename Graph::NodeIt>(w.value);

  }

  /// \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 structure it is specialized to run in O(1).

  ///

  /// \todo refer how to specialize it

  template <typename Graph>

  inline int countNodes(const Graph& g) {

    return _countNodes<Graph>(g);

  }

  // Edge counting:

  template <typename Graph>

  inline

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

  _countEdges(const Graph &g) {

    return g.edgeNum();

  }

  template <typename Graph>

  inline int _countEdges(Wrap<Graph> w) {

    return countItems<Graph, typename Graph::EdgeIt>(w.value);

  }

  /// \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 structure it is specialized to run in O(1).

  template <typename Graph>

  inline int countEdges(const Graph& g) {

    return _countEdges<Graph>(g);

  }

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

  ///

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

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

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

  template <typename Graph>

  inline int countSymEdges(const Graph& _g) {

    return countItems<Graph, typename Graph::SymEdgeIt>(_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;

  }

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

  /// \todo We may want to use the \ref concept::GraphBase "GraphBase"

  /// interface here...

  /// \bug Untested ...

  template <typename Graph>

  typename Graph::Edge findEdge(const Graph &g,

		typename Graph::Node u, typename Graph::Node v,

		typename Graph::Edge prev = INVALID) 

  {

    typename Graph::OutEdgeIt e(g,prev);

    if(prev==INVALID) g.first(e,u);

    else ++e;

    while(e!=INVALID && g.source(e)!=v) ++e;

    return e;

  }

  ///\e

  ///\todo Please document.

  ///

  template <typename Graph>

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

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

  }

  ///\e

  ///\todo Please document.

  ///

  template <typename Graph>

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

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

  }

  // graph copy

  template <

    typename DestinationGraph, 

    typename SourceGraph, 

    typename NodeBijection>

  void copyNodes(DestinationGraph& _d, const SourceGraph& _s, 

		 NodeBijection& _nb) {    

    for (typename SourceGraph::NodeIt it(_s); it != INVALID; ++it) {

      _nb[it] = _d.addNode();

    }

  }

  template <

    typename DestinationGraph, 

    typename SourceGraph, 

    typename NodeBijection,

    typename EdgeBijection>

  void copyEdges(DestinationGraph& _d, const SourceGraph& _s,

		 const NodeBijection& _nb, EdgeBijection& _eb) {    

    for (typename SourceGraph::EdgeIt it(_s); it != INVALID; ++it) {

      _eb[it] = _d.addEdge(_nb[_s.source(it)], _nb[_s.target(it)]);

    }

  }

  template <

    typename DestinationGraph, 

    typename SourceGraph, 

    typename NodeBijection,

    typename EdgeBijection>

  void copyGraph(DestinationGraph& _d, const SourceGraph& _s, 

		 NodeBijection& _nb, EdgeBijection& _eb) {

    nodeCopy(_d, _s, _nb);

    edgeCopy(_d, _s, _nb, _eb);

  }

   template <

    typename _DestinationGraph, 

    typename _SourceGraph, 

    typename _NodeBijection 

    =typename _SourceGraph::template NodeMap<typename _DestinationGraph::Node>,

    typename _EdgeBijection 

    =typename _SourceGraph::template EdgeMap<typename _DestinationGraph::Edge>

   >

   class GraphCopy {

   public:

     typedef _DestinationGraph DestinationGraph;

     typedef _SourceGraph SourceGraph;

     typedef _NodeBijection NodeBijection;

     typedef _EdgeBijection EdgeBijection;

   protected:          

     NodeBijection node_bijection;

     EdgeBijection edge_bijection;     

   public:

     GraphCopy(DestinationGraph& _d, const SourceGraph& _s) {

       copyGraph(_d, _s, node_bijection, edge_bijection);

     }

     const NodeBijection& getNodeBijection() const {

       return node_bijection;

     }

     const EdgeBijection& getEdgeBijection() const {

       return edge_bijection;

     }

   };

/// @}

} //END OF NAMESPACE LEMON

#endif