RhodeCode

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