RhodeCode

      template <typename _Graph>

      struct Constraints {

	void constraints() {

          checkConcept<Base, _Graph>();

	  typename _Graph::Node node;

	  graph.erase(node);

	}

	_Graph& graph;

      };

    };

#ifndef LEMON_DIJKSTRA_H

#define LEMON_DIJKSTRA_H

///\ingroup shortest_path

///\file

///\brief Dijkstra algorithm.

#include <lemon/bin_heap.h>

#include <lemon/bits/path_dump.h>

#include <lemon/bits/invalid.h>

#include <lemon/error.h>

#include <lemon/maps.h>

namespace lemon {

  /// \brief Default OperationTraits for the Dijkstra algorithm class.

  ///  

  /// It defines all computational operations and constants which are

  /// used in the Dijkstra algorithm.

      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 {

            g.nextInc(e, b);

          }

            g.nextInc(e, b);

          }

        } else {

          if (e == INVALID) {

            g.firstInc(e, b, u);

          } else {

            b = true;

            g.nextInc(e, b);

          }

            g.nextInc(e, b);

          }

        }

        return e;

      }

    };

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

  ///     e = findEdge(g,u,v,e)) {

  ///   ...

  /// }

  ///\endcode

  ///

  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 _graph_utils_bits::FindEdgeSelector<Graph>::find(g, u, v, p);

    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;

  };