Ticket #96: dijk_work_e8e874ee792b.patch

lemon/concepts/path.h

@@ -66 +66 @@
 
       /// \brief Template assigment
       template <typename CPath>
-      Path& operator=(const CPath& cpath) {}
+      Path& operator=(const CPath& cpath) {
+        ignore_unused_variable_warning(cpath);
+        return *this;
+      }
 
       /// Length of the path ie. the number of arcs in the path.
       int length() const { return 0;}

lemon/dijkstra.h

@@ -30 +30 @@
 #include <lemon/core.h>
 #include <lemon/error.h>
 #include <lemon/maps.h>
+#include <lemon/path.h>
 
 namespace lemon {
 
@@ -987 +988 @@
     ///The type of the map that stores the predecessor
     ///arcs of the shortest paths.
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
-    typedef NullMap <typename Digraph::Node,typename Digraph::Arc> PredMap;
+    typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
     ///Instantiates a \ref PredMap.
 
     ///This function instantiates a \ref PredMap.
     ///\param g is the digraph, to which we would like to define the
     ///\ref PredMap.
     ///\todo The digraph alone may be insufficient to initialize
-#ifdef DOXYGEN
     static PredMap *createPredMap(const Digraph &g)
-#else
-    static PredMap *createPredMap(const Digraph &)
-#endif
     {
-      return new PredMap();
+      return new PredMap(g);
     }
 
     ///The type of the map that indicates which nodes are processed.
@@ -1030 +1027 @@
 
     ///The type of the map that stores the distances of the nodes.
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
-    typedef NullMap<typename Digraph::Node,Value> DistMap;
+    typedef typename Digraph::template NodeMap<typename LM::Value> DistMap;
     ///Instantiates a \ref DistMap.
 
     ///This function instantiates a \ref DistMap.
     ///\param g is the digraph, to which we would like to define
     ///the \ref DistMap
-#ifdef DOXYGEN
     static DistMap *createDistMap(const Digraph &g)
-#else
-    static DistMap *createDistMap(const Digraph &)
-#endif
     {
-      return new DistMap();
+      return new DistMap(g);
     }
+
+    ///The type of the shortest paths.
+
+    ///The type of the shortest paths.
+    ///It must meet the \ref concepts::Path "Path" concept.
+    typedef lemon::Path<Digraph> Path;
   };
 
   /// Default traits class used by \ref DijkstraWizard
@@ -1065 +1064 @@
 
     //Pointer to the digraph the algorithm runs on.
     void *_g;
-    //Pointer to the length map
+    //Pointer to the length map.
     void *_length;
     //Pointer to the map of processed nodes.
     void *_processed;
@@ -1073 +1072 @@
     void *_pred;
     //Pointer to the map of distances.
     void *_dist;
+    //Pointer to the shortest path to the target node.
+    void *_path;
+    //Pointer to the distance of the target node.
+    void *_di;
     //Pointer to the source node.
     Node _source;
+    //Pointer to the target node.
+    Node _target;
 
   public:
     /// Constructor.
@@ -1082 +1087 @@
     /// This constructor does not require parameters, therefore it initiates
     /// all of the attributes to default values (0, INVALID).
     DijkstraWizardBase() : _g(0), _length(0), _processed(0), _pred(0),
-                           _dist(0), _source(INVALID) {}
+                           _dist(0), _path(0), _di(0),
+                           _source(INVALID), _target(INVALID) {}
 
     /// Constructor.
 
@@ -1092 +1098 @@
     /// \param g The digraph the algorithm runs on.
     /// \param l The length map.
     /// \param s The source node.
-    DijkstraWizardBase(const GR &g,const LM &l, Node s=INVALID) :
+    /// \param t The optional target node.
+    DijkstraWizardBase(const GR &g,const LM &l, Node s, Node t=INVALID) :
       _g(reinterpret_cast<void*>(const_cast<GR*>(&g))),
       _length(reinterpret_cast<void*>(const_cast<LM*>(&l))),
-      _processed(0), _pred(0), _dist(0), _source(s) {}
+      _processed(0), _pred(0), _dist(0), _path(0), _di(0),
+      _source(s), _target(t) {}
 
   };
 
@@ -1144 +1152 @@
     typedef typename TR::DistMap DistMap;
     ///The type of the map that indicates which nodes are processed.
     typedef typename TR::ProcessedMap ProcessedMap;
+    ///The type of the shortest paths
+    typedef typename TR::Path Path;
     ///The heap type used by the dijkstra algorithm.
     typedef typename TR::Heap Heap;
 
@@ -1156 +1166 @@
 
     /// Constructor that requires parameters.
     /// These parameters will be the default values for the traits class.
-    DijkstraWizard(const Digraph &g,const LengthMap &l, Node s=INVALID) :
-      TR(g,l,s) {}
+    DijkstraWizard(const Digraph &g,const LengthMap &l,
+                   Node s, Node t=INVALID) :
+      TR(g,l,s,t) {}
 
     ///Copy constructor
     DijkstraWizard(const TR &b) : TR(b) {}
 
     ~DijkstraWizard() {}
 
-    ///Runs Dijkstra algorithm from a source node.
+    ///Runs Dijkstra algorithm from the given source node.
 
-    ///Runs Dijkstra algorithm from a source node.
-    ///The node can be given with the \ref source() function.
-    void run()
+    ///Runs Dijkstra algorithm from the given source node.
+    ///\param t The optional target node.
+    void run(Node t=INVALID)
     {
+      if(t!=INVALID) Base::_target=t;
       if(Base::_source==INVALID) throw UninitializedParameter();
       Dijkstra<Digraph,LengthMap,TR>
         dij(*reinterpret_cast<const Digraph*>(Base::_g),
@@ -1180 +1192 @@
         dij.predMap(*reinterpret_cast<PredMap*>(Base::_pred));
       if(Base::_dist)
         dij.distMap(*reinterpret_cast<DistMap*>(Base::_dist));
-      dij.run(Base::_source);
-    }
-
-    ///Runs Dijkstra algorithm from the given node.
-
-    ///Runs Dijkstra algorithm from the given node.
-    ///\param s is the given source.
-    void run(Node s)
-    {
-      Base::_source=s;
-      run();
-    }
-
-    /// Sets the source node, from which the Dijkstra algorithm runs.
-
-    /// Sets the source node, from which the Dijkstra algorithm runs.
-    /// \param s is the source node.
-    DijkstraWizard<TR> &source(Node s)
-    {
-      Base::_source=s;
-      return *this;
+      if(Base::_target!=INVALID) {
+        dij.run(Base::_source, Base::_target);
+        if (Base::_path)
+          *reinterpret_cast<Path*>(Base::_path) = dij.path(Base::_target);
+        if (Base::_di)
+          *reinterpret_cast<Value*>(Base::_di) = dij.dist(Base::_target);
+      } else {
+        dij.run(Base::_source);
+      }
     }
 
     template<class T>
@@ -1257 +1257 @@
       return DijkstraWizard<SetDistMapBase<T> >(*this);
     }
 
+    template<class T>
+    struct SetPathBase : public Base {
+      typedef T Path;
+      SetPathBase(const TR &b) : TR(b) {}
+    };
+    ///\brief \ref named-templ-param "Named parameter"
+    ///for getting the shortest path to the target node.
+    ///
+    ///\ref named-templ-param "Named parameter"
+    ///for getting the shortest path to the target node.
+    template<class T>
+    DijkstraWizard<SetPathBase<T> > path(const T &t)
+    {
+      Base::_path=reinterpret_cast<void*>(const_cast<T*>(&t));
+      return DijkstraWizard<SetPathBase<T> >(*this);
+    }
+
+    ///\brief \ref named-templ-param "Named parameter"
+    ///for getting the distance of the target node.
+    ///
+    ///\ref named-templ-param "Named parameter"
+    ///for getting the distance of the target node.
+    DijkstraWizard dist(const Value &d)
+    {
+      Base::_di=reinterpret_cast<void*>(const_cast<Value*>(&d));
+      return *this;
+    }
+
   };
 
   ///Function type interface for Dijkstra algorithm.
@@ -1278 +1306 @@
   ///\sa Dijkstra
   template<class GR, class LM>
   DijkstraWizard<DijkstraWizardBase<GR,LM> >
-  dijkstra(const GR &g,const LM &l,typename GR::Node s=INVALID)
+  dijkstra(const GR &g, const LM &l,
+           typename GR::Node s, typename GR::Node t=INVALID)
   {
-    return DijkstraWizard<DijkstraWizardBase<GR,LM> >(g,l,s);
+    return DijkstraWizard<DijkstraWizardBase<GR,LM> >(g,l,s,t);
   }
 
 } //END OF NAMESPACE LEMON

test/dijkstra_test.cc

@@ -92 +92 @@
 
   Digraph g;
   dijkstra(g,LengthMap(),Node()).run();
-  dijkstra(g,LengthMap()).source(Node()).run();
-  dijkstra(g,LengthMap())
-    .predMap(concepts::WriteMap<Node,Arc>())
-    .distMap(concepts::WriteMap<Node,VType>())
+  dijkstra(g,LengthMap(),Node())
+    .predMap(concepts::ReadWriteMap<Node,Arc>())
+    .distMap(concepts::ReadWriteMap<Node,VType>())
+    .processedMap(concepts::WriteMap<Node,bool>())
+    .run();
+  dijkstra(g,LengthMap(),Node(),Node())
+    .predMap(concepts::ReadWriteMap<Node,Arc>())
+    .distMap(concepts::ReadWriteMap<Node,VType>())
+    .processedMap(concepts::WriteMap<Node,bool>())
+    .path(concepts::Path<Digraph>()).dist(VType())
+    .run();
+  dijkstra(g,LengthMap(),Node())
+    .predMap(concepts::ReadWriteMap<Node,Arc>())
+    .distMap(concepts::ReadWriteMap<Node,VType>())
+    .processedMap(concepts::WriteMap<Node,bool>())
+    .path(concepts::Path<Digraph>()).dist(VType())
     .run(Node());
 }
 
@@ -152 +164 @@
 
   {
     NullMap<Node,Arc> myPredMap;
-    dijkstra(G,length).predMap(myPredMap).run(s);
+    dijkstra(G,length,s).predMap(myPredMap).run();
   }
 }