RhodeCode

/* -*- C++ -*-

 *

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

 *

 * Copyright (C) 2003-2008

 * 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

  /// @{

  namespace _graph_utils_bits {

    template <typename Graph>

    struct Node { typedef typename Graph::Node type; };

    template <typename Graph>

    struct NodeIt { typedef typename Graph::NodeIt type; };

    template <typename Graph>

    struct Arc { typedef typename Graph::Arc type; };

    template <typename Graph>

    struct ArcIt { typedef typename Graph::ArcIt type; };

    template <typename Graph>

    struct Edge { typedef typename Graph::Edge type; };

    template <typename Graph>

    struct EdgeIt { typedef typename Graph::EdgeIt type; };

    template <typename Graph>

    struct OutArcIt { typedef typename Graph::OutArcIt type; };

    template <typename Graph>

    struct InArcIt { typedef typename Graph::InArcIt type; };

    template <typename Graph>

    struct IncEdgeIt { typedef typename Graph::IncEdgeIt type; };

    template <typename Graph>

    struct BoolNodeMap { 

      typedef typename Graph::template NodeMap<bool> type; 

    };

    template <typename Graph>

    struct IntNodeMap { 

      typedef typename Graph::template NodeMap<int> type; 

    };

    template <typename Graph>

    struct DoubleNodeMap { 

      typedef typename Graph::template NodeMap<double> type; 

    };

    template <typename Graph>

    struct BoolArcMap { 

      typedef typename Graph::template ArcMap<bool> type; 

    };

    template <typename Graph>

    struct IntArcMap { 

      typedef typename Graph::template ArcMap<int> type; 

    };

    template <typename Graph>

    struct DoubleArcMap { 

      typedef typename Graph::template ArcMap<double> type; 

    };

    template <typename Graph>

    struct BoolEdgeMap { 

      typedef typename Graph::template EdgeMap<bool> type; 

    };

    template <typename Graph>

    struct IntEdgeMap { 

      typedef typename Graph::template EdgeMap<int> type; 

    };

    template <typename Graph>

    struct DoubleEdgeMap { 

      typedef typename Graph::template EdgeMap<double> type; 

    };

  }

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

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

  ///of \c Digraph: \c Node,  \c NodeIt, \c Arc, \c ArcIt, \c InArcIt,

  ///\c OutArcIt, \c BoolNodeMap, \c IntNodeMap, \c DoubleNodeMap, 

  ///\c BoolArcMap, \c IntArcMap, \c DoubleArcMap. 

#define DIGRAPH_TYPEDEFS(Digraph)					\

  typedef typename ::lemon::_graph_utils_bits::				\

  Node<Digraph>::type Node;						\

  typedef typename ::lemon::_graph_utils_bits::				\

  NodeIt<Digraph>::type	NodeIt;						\

  typedef typename ::lemon::_graph_utils_bits::				\

  Arc<Digraph>::type Arc;						\

  typedef typename ::lemon::_graph_utils_bits::				\

  ArcIt<Digraph>::type ArcIt;						\

  typedef typename ::lemon::_graph_utils_bits::				\

  OutArcIt<Digraph>::type OutArcIt;					\

  typedef typename ::lemon::_graph_utils_bits::				\

  InArcIt<Digraph>::type InArcIt;					\

  typedef typename ::lemon::_graph_utils_bits::				\

  BoolNodeMap<Digraph>::type BoolNodeMap;				\

  typedef typename ::lemon::_graph_utils_bits::				\

  IntNodeMap<Digraph>::type IntNodeMap;					\

  typedef typename ::lemon::_graph_utils_bits::				\

  DoubleNodeMap<Digraph>::type DoubleNodeMap;				\

  typedef typename ::lemon::_graph_utils_bits::				\

  BoolArcMap<Digraph>::type BoolArcMap;					\

  typedef typename ::lemon::_graph_utils_bits::				\

  IntArcMap<Digraph>::type IntArcMap;					\

  typedef typename ::lemon::_graph_utils_bits::				\

  DoubleArcMap<Digraph>::type DoubleArcMap

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

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

  ///by \ref DIGRAPH_TYPEDEFS(Graph) and six more, namely it creates

  ///\c Edge, \c EdgeIt, \c IncEdgeIt, \c BoolEdgeMap, \c IntEdgeMap,

  ///\c DoubleEdgeMap.

#define GRAPH_TYPEDEFS(Graph)						\

  DIGRAPH_TYPEDEFS(Graph);						\

  typedef typename ::lemon::_graph_utils_bits::				\

  Edge<Graph>::type Edge;						\

  typedef typename ::lemon::_graph_utils_bits::				\

  EdgeIt<Graph>::type EdgeIt;						\

  typedef typename ::lemon::_graph_utils_bits::				\

  typedef typename ::lemon::_graph_utils_bits::				\

  BoolEdgeMap<Graph>::type BoolEdgeMap;					\

  typedef typename ::lemon::_graph_utils_bits::				\

  IntEdgeMap<Graph>::type IntEdgeMap;					\

  typedef typename ::lemon::_graph_utils_bits::				\

  DoubleEdgeMap<Graph>::type DoubleEdgeMap

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

  ///

  /// This function counts the items (nodes, arcs 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).

  ///

  /// If the graph contains a \e nodeNum() member function and a 

  /// \e NodeNumTag tag then this function calls directly the member

  /// function to query the cardinality of the node set.

  template <typename Graph>

  inline int countNodes(const Graph& g) {

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

  }

  // Arc counting:

  namespace _graph_utils_bits {

    template <typename Graph, typename Enable = void>

    struct CountArcsSelector {

      static int count(const Graph &g) {

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

      }

    };

    template <typename Graph>

    struct CountArcsSelector<

      Graph, 

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

    {

      static int count(const Graph &g) {

        return g.arcNum();

      }

    };    

  }

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

  ///

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

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

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

  ///

  /// If the graph contains a \e arcNum() member function and a 

  /// \e EdgeNumTag tag then this function calls directly the member

  /// function to query the cardinality of the arc set.

  template <typename Graph>

  inline int countArcs(const Graph& g) {

    return _graph_utils_bits::CountArcsSelector<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(m) but for some

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

  ///

  /// If the graph contains a \e edgeNum() member function and a 

  /// \e EdgeNumTag tag then this function calls directly the member

  /// function to query the cardinality of the edge set.

  template <typename Graph>

  inline int countEdges(const Graph& g) {

    return _graph_utils_bits::CountEdgesSelector<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-arcs from node \c n.

  ///

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

  /// in the graph.  

  template <typename Graph>

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

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

  }

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

  ///

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

  /// in the graph.  

  template <typename Graph>

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

    return countNodeDegree<Graph, typename Graph::InArcIt>(_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 FindArcSelector {

      typedef typename Graph::Node Node;

      typedef typename Graph::Arc Arc;

      static Arc find(const Graph &g, Node u, Node v, Arc 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 FindArcSelector<

      Graph, 

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

    {

      typedef typename Graph::Node Node;

      typedef typename Graph::Arc Arc;

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

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

      }

    };    

  }

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

  ///

  /// Finds an arc 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 arc from \c u to \c v. Otherwise it looks for

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

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

  ///

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

  ///\code

  /// for(Arc e=findArc(g,u,v);e!=INVALID;e=findArc(g,u,v,e)) {

  ///   ...

  /// }

  ///\endcode

  ///

  ///\sa ArcLookUp

  ///\sa AllArcLookUp

  ///\sa DynArcLookUp

  ///\sa ConArcIt

  template <typename Graph>

  inline typename Graph::Arc 

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

           typename Graph::Arc prev = INVALID) {

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

  }

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

  ///

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

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

  /// use it the following way:

  ///\code

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

  ///   ...

  /// }

  ///\endcode

  /// 

  ///\sa findArc()

  ///\sa ArcLookUp

  ///\sa AllArcLookUp

  ///\sa DynArcLookUp

  ///

  /// \author Balazs Dezso 

  template <typename _Graph>

  class ConArcIt : public _Graph::Arc {

  public:

    typedef _Graph Graph;

    typedef typename Graph::Arc Parent;

    typedef typename Graph::Arc Arc;

    typedef typename Graph::Node Node;

    /// \brief Constructor.

    ///