RhodeCode

      /// \brief Erase an arc from the graph.

      ///

      /// Erase an arc from the graph.

      ///

      void erase(const Edge&) {}

      template <typename _Graph>

      struct Constraints {

	void constraints() {

          checkConcept<Base, _Graph>();

	  typename _Graph::Node node;

	  graph.erase(node);

	}

	_Graph& graph;

      };

    };

    /// \brief An empty clearable base digraph class.

    ///

    /// This class provides beside the core digraph features core clear

    /// functions for the digraph structure. The main difference between

    /// the base and this interface is that the digraph alterations

    /// should handled already on this level.

 * This software is provided "AS IS" with no warranty of any kind,

 * express or implied, and with no claim as to its suitability for any

 * purpose.

 *

 */

#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.

  template <typename Value>

  struct DijkstraDefaultOperationTraits {

    /// \brief Gives back the zero value of the type.

    static Value zero() {

      return static_cast<Value>(0);

    }

  namespace _graph_utils_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 {

            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;

      }

    };

    template <typename Graph>

    struct FindEdgeSelector<

      Graph, 

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

    {

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

  }

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

  ///

  /// Iterator for iterating on edges connected the same nodes. It is 

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

    }

    /// \brief Constructor.

    ///

    /// Construct a new ConEdgeIt which continues the iterating from 

    /// the \c e edge.

    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;

  };

  namespace _graph_utils_bits {

    template <typename Digraph, typename Item, typename RefMap>

    class MapCopyBase {

    public:

      virtual void copy(const Digraph& from, const RefMap& refMap) = 0;