lemon-0.x: comparison src/work/alpar/dijkstra.h

equal deleted inserted replaced

-:78a8852fb663
+:ee45c3a48a92
 #else
 template <typename GR=ListGraph,
 	    typename LM=typename GR::template EdgeMap<int>,
 	    typename TR=DijkstraDefaultTraits<GR,LM> >
 #endif
-class Dijkstra{
+class Dijkstra {
 public:
 typedef TR Traits;
 ///The type of the underlying graph.
 typedef typename TR::Graph Graph;
 ///\e
 	distance = Traits::createDistMap(*G);
 }
 }
 public :
 template <class T>
-struct SetPredMapTraits : public Traits {
+struct DefPredMapTraits : public Traits {
 typedef T PredMap;
 ///\todo An exception should be thrown.
 ///
 static PredMap *createPredMap(const Graph &G)
 {
 ///\ref named-templ-param "Named parameter" for setting PredMap type
 ///\ref named-templ-param "Named parameter" for setting PredMap type
 ///
 template <class T>
-class SetPredMap : public Dijkstra< Graph,
+class DefPredMap : public Dijkstra< Graph,
 					LengthMap,
-					SetPredMapTraits<T> > { };
+					DefPredMapTraits<T> > { };
 template <class T>
-struct SetPredNodeMapTraits : public Traits {
+struct DefPredNodeMapTraits : public Traits {
 typedef T PredNodeMap;
 ///\todo An exception should be thrown.
 ///
 static PredNodeMap *createPredNodeMap(const Graph &G)
 {
 ///\ref named-templ-param "Named parameter" for setting PredNodeMap type
 ///\ref named-templ-param "Named parameter" for setting PredNodeMap type
 ///
 template <class T>
-class SetPredNodeMap : public Dijkstra< Graph,
+class DefPredNodeMap : public Dijkstra< Graph,
 					    LengthMap,
-					    SetPredNodeMapTraits<T> > { };
+					    DefPredNodeMapTraits<T> > { };
 template <class T>
-struct SetDistMapTraits : public Traits {
+struct DefDistMapTraits : public Traits {
 typedef T DistMap;
 ///\todo An exception should be thrown.
 ///
 static DistMap *createDistMap(const Graph &G)
 {
 ///\ref named-templ-param "Named parameter" for setting DistMap type
 ///\ref named-templ-param "Named parameter" for setting DistMap type
 ///
 template <class T>
-class SetDistMap : public Dijkstra< Graph,
+class DefDistMap : public Dijkstra< Graph,
 					LengthMap,
-					SetDistMapTraits<T> > { };
+					DefDistMapTraits<T> > { };
 ///Constructor.
 ///\param _G the graph the algorithm will run on.
 ///\param _length the length map used by the algorithm.
 ///Sets the length map.
 ///Sets the length map.
 ///\return <tt> (*this) </tt>
-Dijkstra &setLengthMap(const LengthMap &m)
+Dijkstra &lengthMap(const LengthMap &m)
 {
 length = &m;
 return *this;
 }
 ///Sets the map storing the predecessor edges.
 ///If you don't use this function before calling \ref run(),
 ///it will allocate one. The destuctor deallocates this
 ///automatically allocated map, of course.
 ///\return <tt> (*this) </tt>
-Dijkstra &setPredMap(PredMap &m)
+Dijkstra &predMap(PredMap &m)
 {
 if(local_predecessor) {
 	delete predecessor;
 	local_predecessor=false;
 }
 ///Sets the map storing the predecessor nodes.
 ///If you don't use this function before calling \ref run(),
 ///it will allocate one. The destuctor deallocates this
 ///automatically allocated map, of course.
 ///\return <tt> (*this) </tt>
-Dijkstra &setPredNodeMap(PredNodeMap &m)
+Dijkstra &predNodeMap(PredNodeMap &m)
 {
 if(local_pred_node) {
 	delete pred_node;
 	local_pred_node=false;
 }
 ///Sets the map storing the distances calculated by the algorithm.
 ///If you don't use this function before calling \ref run(),
 ///it will allocate one. The destuctor deallocates this
 ///automatically allocated map, of course.
 ///\return <tt> (*this) </tt>
-Dijkstra &setDistMap(DistMap &m)
+Dijkstra &distMap(DistMap &m)
 {
 if(local_distance) {
 	delete distance;
 	local_distance=false;
 }
 ///
 bool reached(Node v) { return v==source || (*predecessor)[v]!=INVALID; }
 };
+template<class GR,class LM>
+class DijkstraWizardBase : public DijkstraDefaultTraits<GR,LM>
+{
+typedef DijkstraDefaultTraits<GR,LM> Base;
+protected:
+/// Pointer to the underlying graph.
+void *_g;
+/// Pointer to the length map
+void *_length;
+///Pointer to the map of predecessors edges.
+void *_pred;
+///Pointer to the map of predecessors nodes.
+void *_predNode;
+///Pointer to the map of distances.
+void *_dist;
+///Pointer to the source node.
+void *_source;
+typedef typename Base::Graph::Node Node;
+public:
+DijkstraWizardBase() : _g(0), _length(0), _pred(0), _predNode(0),
+		       _dist(0), _source(INVALID) {}
+DijkstraWizardBase(const GR &g,const LM &l, Node s=INVALID) :
+_g((void *)&g), _length((void *)&l), _pred(0), _predNode(0),
+		  _dist(0), _source((void *)&s) {}
+};
 ///\e
 ///\e
 ///
 template<class TR>
-class _Dijkstra
+class DijkstraWizard : public TR
 {
-typedef TR Traits;
+typedef TR Base;
 ///The type of the underlying graph.
 typedef typename TR::Graph Graph;
 ///\e
 typedef typename Graph::Node Node;
 ///The type of the map that stores the dists of the nodes.
 typedef typename TR::DistMap DistMap;
 ///The heap type used by the dijkstra algorithm.
 typedef typename TR::Heap Heap;
-/// Pointer to the underlying graph.
-const Graph *G;
-/// Pointer to the length map
-const LengthMap *length;
-///Pointer to the map of predecessors edges.
-PredMap *predecessor;
-///Pointer to the map of predecessors nodes.
-PredNodeMap *pred_node;
-///Pointer to the map of distances.
-DistMap *distance;
-Node source;
 public:
-_Dijkstra() : G(0), length(0), predecessor(0), pred_node(0),
+DijkstraWizard() : TR() {}
-		  distance(0), source(INVALID) {}
+DijkstraWizard(const Graph &g,const LengthMap &l, Node s=INVALID) :
-_Dijkstra(const Graph &g,const LengthMap &l, Node s) :
+TR(g,l,s) {}
-G(&g), length(&l), predecessor(0), pred_node(0),
-		  distance(0), source(s) {}
+DijkstraWizard(const TR &b) : TR(b) {}
-~_Dijkstra()
+~DijkstraWizard() {}
-{
-Dijkstra<Graph,LengthMap,TR> Dij(*G,*length);
+///\e
-if(predecessor) Dij.setPredMap(*predecessor);
+void run()
-if(pred_node) Dij.setPredNodeMap(*pred_node);
+{
-if(distance) Dij.setDistMap(*distance);
+Dijkstra<Graph,LengthMap,TR> Dij(*(Graph*)_g,*(LengthMap*)_length);
-Dij.run(source);
+if(_pred) Dij.predMap(*(PredMap*)_pred);
+if(_predNode) Dij.predNodeMap(*(PredNodeMap*)_predNode);
+if(_dist) Dij.distMap(*(DistMap*)_dist);
+Dij.run(*(Node*)_source);
+}
+///\e
+void run(Node s)
+{
+_source=(void *)&s;
+run();
 }
 template<class T>
-struct SetPredMapTraits : public Traits {typedef T PredMap;};
+struct DefPredMapBase : public Base {
+typedef T PredMap;
+static PredMap *createPredMap(const Graph &G) {};
+};
 ///\e
 template<class T>
-_Dijkstra<SetPredMapTraits<T> > setPredMap(const T &t)
+DijkstraWizard<DefPredMapBase<T> > predMap(const T &t)
 {
-_Dijkstra<SetPredMapTraits<T> > r;
+_pred=(void *)&t;
-r.G=G;
+return DijkstraWizard<DefPredMapBase<T> >(*this);
-r.length=length;
+}
-r.predecessor=&t;
-r.pred_node=pred_node;
-r.distance=distance;
-r.source=source;
-return r;
-}
 template<class T>
-struct SetPredNodeMapTraits :public Traits {typedef T PredNodeMap;};
+struct DefPredNodeMapBase : public Base {
+typedef T PredNodeMap;
+static PredNodeMap *createPredNodeMap(const Graph &G) {};
+};
 ///\e
 template<class T>
-_Dijkstra<SetPredNodeMapTraits<T> > setPredNodeMap(const T &t)
+DijkstraWizard<DefPredNodeMapBase<T> > predNodeMap(const T &t)
 {
-_Dijkstra<SetPredNodeMapTraits<T> > r;
+_predNode=(void *)&t;
-r.G=G;
+return DijkstraWizard<DefPredNodeMapBase<T> >(*this);
-r.length=length;
+}
-r.predecessor=predecessor;
-r.pred_node=&t;
-r.distance=distance;
-r.source=source;
-return r;
-}
 template<class T>
-struct SetDistMapTraits : public Traits {typedef T DistMap;};
+struct DefDistMapBase : public Base {
+typedef T DistMap;
+static DistMap *createDistMap(const Graph &G) {};
+};
 ///\e
 template<class T>
-_Dijkstra<SetDistMapTraits<T> > setDistMap(const T &t)
+DijkstraWizard<DefDistMapBase<T> > distMap(const T &t)
 {
-_Dijkstra<SetPredMapTraits<T> > r;
+_dist=(void *)&t;
-r.G=G;
+return DijkstraWizard<DefDistMapBase<T> >(*this);
-r.length=length;
+}
-r.predecessor=predecessor;
-r.pred_node=pred_node;
+///\e
-r.distance=&t;
+DijkstraWizard<TR> &setSource(Node s)
-r.source=source;
+{
-return r;
+source=(void *)&s;
-}
-///\e
-_Dijkstra<TR> &setSource(Node s)
-{
-source=s;
 return *this;
 }
 };
 ///\e
 ///\todo Please document...
 ///
 template<class GR, class LM>
-_Dijkstra<DijkstraDefaultTraits<GR,LM> >
+DijkstraWizard<DijkstraWizardBase<GR,LM> >
-dijkstra(const GR &g,const LM &l,typename GR::Node s)
+dijkstra(const GR &g,const LM &l,typename GR::Node s=INVALID)
 {
-return _Dijkstra<DijkstraDefaultTraits<GR,LM> >(g,l,s);
+return DijkstraWizard<DijkstraWizardBase<GR,LM> >(g,l,s);
 }
 /// @}
 } //END OF NAMESPACE LEMON

changeset 1116	f97e1cbbd453
parent 1043	52a2201a88e9
child 1117	5767cc417f62