RhodeCode

    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>