RhodeCode

      static Edge find(const Graph &g, Node u, Node v, Edge e) {

        bool b;

        if (u != v) {

          if (e == INVALID) {

            g.firstInc(e, b, u);

          } else {

            b = g.u(e) == u;

            g.nextInc(e, b);

          }

          while (e != INVALID && (b ? g.v(e) : g.u(e)) != v) {

            g.nextInc(e, b);

          }

        } else {

          if (e == INVALID) {

            g.firstInc(e, b, u);

          } else {

            b = true;

            g.nextInc(e, b);

          }

          while (e != INVALID && (!b || g.v(e) != v)) {

            g.nextInc(e, b);

          }

        }

        return e;

      }

    };

    template <typename Graph>

    struct FindEdgeSelector<

      Graph,

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

    {

      typedef typename Graph::Node Node;

      typedef typename Graph::Edge Edge;

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

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

      }

    };

  }

  /// \brief Find an edge between two nodes of a graph.

  ///

  /// This function finds an edge from node \c u to node \c v in graph \c g.

  /// If node \c u and node \c v is equal then each loop edge

  /// will be enumerated once.

  ///

  /// 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 between \c u and \c v

  /// as it follows.

  ///\code

  /// for(Edge e = findEdge(g,u,v); e != INVALID; e = findEdge(g,u,v,e)) {

  ///   ...

  /// }

  ///\endcode

  ///

  /// \note \ref ConEdgeIt provides iterator interface for the same

  /// functionality.

  ///

  ///\sa ConEdgeIt

  template <typename Graph>

  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;

    TEMPLATE_DIGRAPH_TYPEDEFS(G);

    typedef G Digraph;

  protected:

    class AutoNodeMap : public ItemSetTraits<G, Node>::template Map<Arc>::Type {

    public:

      typedef typename ItemSetTraits<G, Node>::template Map<Arc>::Type Parent;

      AutoNodeMap(const G& digraph) : Parent(digraph, INVALID) {}

      virtual void add(const Node& node) {

        Parent::add(node);

        Parent::set(node, INVALID);

      }

      virtual void add(const std::vector<Node>& nodes) {

        Parent::add(nodes);

        for (int i = 0; i < int(nodes.size()); ++i) {

          Parent::set(nodes[i], INVALID);

        }

      }

      virtual void build() {

        Parent::build();

        Node it;

        typename Parent::Notifier* nf = Parent::notifier();

        for (nf->first(it); it != INVALID; nf->next(it)) {

          Parent::set(it, INVALID);

        }

      }

    };

    const Digraph &_g;

    AutoNodeMap _head;

    typename Digraph::template ArcMap<Arc> _parent;

    typename Digraph::template ArcMap<Arc> _left;

    typename Digraph::template ArcMap<Arc> _right;

    class ArcLess {

      const Digraph &g;

    public:

      ArcLess(const Digraph &_g) : g(_g) {}

      bool operator()(Arc a,Arc b) const

      {

        return g.target(a)<g.target(b);

      }

    };

  public:

    ///Constructor

    ///Constructor.

    ///

    ///It builds up the search database.

    DynArcLookUp(const Digraph &g)

      : _g(g),_head(g),_parent(g),_left(g),_right(g)

    {

      Parent::attach(_g.notifier(typename Digraph::Arc()));

      refresh();

    }