RhodeCode

    template <typename Graph>

    struct FindArcSelector<

      Graph,

      typename enable_if<typename Graph::FindArcTag, 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 Find an arc between two nodes of a digraph.

  ///

  /// This function finds an arc from node \c u to node \c v in the

  /// digraph \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

  ///

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

  /// functionality.

  ///

  ///\sa ConArcIt

  ///\sa ArcLookUp, AllArcLookUp, DynArcLookUp

  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 _core_bits::FindArcSelector<Graph>::find(g, u, v, prev);

  }

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

  ///

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

  /// a higher level interface for the \ref 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, AllArcLookUp, DynArcLookUp

  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.

    ///

    /// Construct a new ConArcIt iterating on the arcs that

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

    ConArcIt(const Graph& g, Node u, Node v) : _graph(g) {

      Parent::operator=(findArc(_graph, u, v));

    }

    /// \brief Constructor.

    ///

    /// Construct a new ConArcIt that continues the iterating from arc \c a.

    ConArcIt(const Graph& g, Arc a) : Parent(a), _graph(g) {}

    /// \brief Increment operator.

    ///

    /// It increments the iterator and gives back the next arc.

    ConArcIt& operator++() {

      Parent::operator=(findArc(_graph, _graph.source(*this),

                                _graph.target(*this), *this));

      return *this;

    }

  private:

    const Graph& _graph;

  };

  namespace _core_bits {

    template <typename Graph, typename Enable = void>

    struct FindEdgeSelector {

      typedef typename Graph::Node Node;

      typedef typename Graph::Edge Edge;

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

    }

  protected:

    virtual void add(const Arc& arc) {

      insert(arc);

    }

    virtual void add(const std::vector<Arc>& arcs) {

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

        insert(arcs[i]);

      }

    }

    virtual void erase(const Arc& arc) {

      remove(arc);

    }

    virtual void erase(const std::vector<Arc>& arcs) {

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

        remove(arcs[i]);

      }

    }

    virtual void build() {

      refresh();

    }

    virtual void clear() {

      for(NodeIt n(_g);n!=INVALID;++n) {

        _head.set(n, INVALID);

      }

    }

    void insert(Arc arc) {

      Node s = _g.source(arc);

      Node t = _g.target(arc);

      _left.set(arc, INVALID);

      _right.set(arc, INVALID);

      Arc e = _head[s];

      if (e == INVALID) {

        _head.set(s, arc);

        _parent.set(arc, INVALID);

        return;

      }

      while (true) {

        if (t < _g.target(e)) {

          if (_left[e] == INVALID) {

            _left.set(e, arc);

            _parent.set(arc, e);

            splay(arc);

            return;

          } else {

            e = _left[e];

          }

        } else {

          if (_right[e] == INVALID) {

            _right.set(e, arc);

            _parent.set(arc, e);

            splay(arc);

            return;

          } else {

            e = _right[e];

          }

        }

      }

    }

    void remove(Arc arc) {

      if (_left[arc] == INVALID) {

        if (_right[arc] != INVALID) {

          _parent.set(_right[arc], _parent[arc]);

        }

        if (_parent[arc] != INVALID) {

          if (_left[_parent[arc]] == arc) {

            _left.set(_parent[arc], _right[arc]);

          } else {

            _right.set(_parent[arc], _right[arc]);

          }

        } else {

          _head.set(_g.source(arc), _right[arc]);

        }

      } else if (_right[arc] == INVALID) {

        _parent.set(_left[arc], _parent[arc]);

        if (_parent[arc] != INVALID) {

          if (_left[_parent[arc]] == arc) {

            _left.set(_parent[arc], _left[arc]);

          } else {

            _right.set(_parent[arc], _left[arc]);

          }

        } else {

          _head.set(_g.source(arc), _left[arc]);

        }

      } else {

        Arc e = _left[arc];

        if (_right[e] != INVALID) {