RhodeCode

  inline typename Graph::Edge

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

            typename Graph::Edge p = INVALID) {

    return _core_bits::FindEdgeSelector<Graph>::find(g, u, v, p);

  }

  /// \brief Iterator for iterating on parallel edges connecting the same nodes.

  ///

  /// Iterator for iterating on parallel edges connecting the same nodes.

  /// It is a higher level interface for the findEdge() function. You can

  /// use it the following way:

  ///\code

  /// for (ConEdgeIt<Graph> it(g, u, v); it != INVALID; ++it) {

  ///   ...

  /// }

  ///\endcode

  ///

  ///\sa findEdge()

  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 that

    /// connects nodes \c u and \c v.

    }

    /// \brief Constructor.

    ///

    /// Construct a new ConEdgeIt that continues iterating from edge \c e.

    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++() {

      return *this;

    }

  private:

    const Graph& _graph;

  };

  ///Dynamic arc look-up between given endpoints.

  ///Using this class, you can find an arc in a digraph from a given

  ///source to a given target in amortized time <em>O</em>(log<em>d</em>),

  ///where <em>d</em> is the out-degree of the source node.

  ///

  ///It is possible to find \e all parallel arcs between two nodes with

  ///the \c operator() member.

  ///

  ///This is a dynamic data structure. Consider to use \ref ArcLookUp or

  ///\ref AllArcLookUp if your digraph is not changed so frequently.

  ///

  ///This class uses a self-adjusting binary search tree, the Splay tree

  ///of Sleator and Tarjan to guarantee the logarithmic amortized

  ///time bound for arc look-ups. This class also guarantees the

  ///optimal time bound in a constant factor for any distribution of

  ///queries.

  ///

  ///\tparam G The type of the underlying digraph.

  ///

  ///\sa ArcLookUp

  ///\sa AllArcLookUp

  template<class G>

  class DynArcLookUp

    : protected ItemSetTraits<G, typename G::Arc>::ItemNotifier::ObserverBase

  {

  public:

    typedef typename ItemSetTraits<G, typename G::Arc>

    ::ItemNotifier::ObserverBase Parent;