lemon-0.x: comparison lemon/bfs.h

equal deleted inserted replaced

-:12be059e8bce
+:cb617e9cdb04
 ///is reached. If the target node is reachable from the processed
 ///node then the reached parameter will be set true. The reached
 ///parameter should be initially false.
 ///
 ///\param target The target node.
-///\retval reached Indicates that the target node is reached.
+///\retval reach Indicates that the target node is reached.
 ///\return The processed node.
 ///
 ///\warning The queue must not be empty!
-Node processNextNode(Node target, bool& reached)
+Node processNextNode(Node target, bool& reach)
 {
 if(_queue_tail==_queue_next_dist) {
 	_curr_dist++;
 	_queue_next_dist=_queue_head;
 }
 	if(!(*_reached)[m=G->target(e)]) {
 	  _queue[_queue_head++]=m;
 	  _reached->set(m,true);
 	  _pred->set(m,e);
 	  _dist->set(m,_curr_dist);
-reached = reached || (target == m);
+reach = reach || (target == m);
 	}
 return n;
 }
 ///Processes the next node.
 ///with true value is reachable from the processed node then the
 ///reached parameter will be set true. The reached parameter
 ///should be initially false.
 ///
 ///\param nm The nodemaps of possible targets.
-///\retval reached Indicates that one of the target nodes is reached.
+///\retval reach Indicates that one of the target nodes is reached.
 ///\return The processed node.
 ///
 ///\warning The queue must not be empty!
 template<class NM>
-Node processNextNode(const NM& nm, bool& reached)
+Node processNextNode(const NM& nm, bool& reach)
 {
 if(_queue_tail==_queue_next_dist) {
 	_curr_dist++;
 	_queue_next_dist=_queue_head;
 }
 	if(!(*_reached)[m=G->target(e)]) {
 	  _queue[_queue_head++]=m;
 	  _reached->set(m,true);
 	  _pred->set(m,e);
 	  _dist->set(m,_curr_dist);
-reached = reached || nm[m];
+reached = reach || nm[m];
 	}
 return n;
 }
 ///Next node to be processed.
 ///- The shortest path to \c  dest.
 ///- The distance of \c dest from the root(s).
 ///
 void start(Node dest)
 {
-bool reached = false;
+bool reach = false;
-while ( !emptyQueue() && !reached) processNextNode(dest, reached);
+while ( !emptyQueue() && !reach) processNextNode(dest, reach);
 }
 ///Executes the algorithm until a condition is met.
 ///Executes the algorithm until a condition is met.
 /// <tt>nm[v]</tt> true.
 ///\todo query the reached target
 template<class NM>
 void start(const NM &nm)
 {
-bool reached = false;
+bool reach = false;
-while ( !emptyQueue() && !reached) processNextNode(nm, reached);
+while ( !emptyQueue() && !reach) processNextNode(nm, reach);
 }
 ///Runs %BFS algorithm from node \c s.
 ///This method runs the %BFS algorithm from a root node \c s
 /// listed in the parameters list.
 /// Others are initiated to 0.
 /// \param g is the initial value of  \ref _g
 /// \param s is the initial value of  \ref _source
 BfsWizardBase(const GR &g, Node s=INVALID) :
-_g((void *)&g), _reached(0), _processed(0), _pred(0),
+_g(reinterpret_cast<void*>(const_cast<GR*>(&g))),
-_dist(0), _source(s) {}
+_reached(0), _processed(0), _pred(0), _dist(0), _source(s) {}
 };
 /// A class to make the usage of Bfs algorithm easier
 ///Runs Bfs algorithm from a given node.
 ///The node can be given by the \ref source function.
 void run()
 {
 if(Base::_source==INVALID) throw UninitializedParameter();
-Bfs<Graph,TR> alg(*(Graph*)Base::_g);
+Bfs<Graph,TR> alg(*reinterpret_cast<const Graph*>(Base::_g));
 if(Base::_reached)
-	alg.reachedMap(*(ReachedMap*)Base::_reached);
+	alg.reachedMap(*reinterpret_cast<ReachedMap*>(Base::_reached));
-if(Base::_processed) alg.processedMap(*(ProcessedMap*)Base::_processed);
+if(Base::_processed)
-if(Base::_pred) alg.predMap(*(PredMap*)Base::_pred);
+alg.processedMap(*reinterpret_cast<ProcessedMap*>(Base::_processed));
-if(Base::_dist) alg.distMap(*(DistMap*)Base::_dist);
+if(Base::_pred)
+alg.predMap(*reinterpret_cast<PredMap*>(Base::_pred));
+if(Base::_dist)
+alg.distMap(*reinterpret_cast<DistMap*>(Base::_dist));
 alg.run(Base::_source);
 }
 ///Runs Bfs algorithm from the given node.
 ///function for setting PredMap
 ///
 template<class T>
 BfsWizard<DefPredMapBase<T> > predMap(const T &t)
 {
-Base::_pred=(void *)&t;
+Base::_pred=reinterpret_cast<void*>(const_cast<T*>(&t));
 return BfsWizard<DefPredMapBase<T> >(*this);
 }
 template<class T>
 ///function for setting ReachedMap
 ///
 template<class T>
 BfsWizard<DefReachedMapBase<T> > reachedMap(const T &t)
 {
-Base::_pred=(void *)&t;
+Base::_pred=reinterpret_cast<void*>(const_cast<T*>(&t));
 return BfsWizard<DefReachedMapBase<T> >(*this);
 }
 template<class T>
 ///function for setting ProcessedMap
 ///
 template<class T>
 BfsWizard<DefProcessedMapBase<T> > processedMap(const T &t)
 {
-Base::_pred=(void *)&t;
+Base::_pred=reinterpret_cast<void*>(const_cast<T*>(&t));
 return BfsWizard<DefProcessedMapBase<T> >(*this);
 }
 template<class T>
 ///function for setting DistMap type
 ///
 template<class T>
 BfsWizard<DefDistMapBase<T> > distMap(const T &t)
 {
-Base::_dist=(void *)&t;
+Base::_dist=reinterpret_cast<void*>(const_cast<T*>(&t));
 return BfsWizard<DefDistMapBase<T> >(*this);
 }
 /// Sets the source node, from which the Bfs algorithm runs.
 /// is reached. If the target node is reachable from the processed
 /// node then the reached parameter will be set true. The reached
 /// parameter should be initially false.
 ///
 /// \param target The target node.
-/// \retval reached Indicates that the target node is reached.
+/// \retval reach Indicates that the target node is reached.
 /// \return The processed node.
 ///
 /// \warning The queue must not be empty!
-Node processNextNode(Node target, bool& reached) {
+Node processNextNode(Node target, bool& reach) {
 Node n = _list[++_list_front];
 _visitor->process(n);
 Edge e;
 for (_graph->firstOut(e, n); e != INVALID; _graph->nextOut(e)) {
 Node m = _graph->target(e);
 if (!(*_reached)[m]) {
 _visitor->discover(e);
 _visitor->reach(m);
 _reached->set(m, true);
 _list[++_list_back] = m;
-reached = reached || (target == m);
+reach = reach || (target == m);
 } else {
 _visitor->examine(e);
 }
 }
 return n;
 /// \retval reached Indicates that one of the target nodes is reached.
 /// \return The processed node.
 ///
 /// \warning The queue must not be empty!
 template <typename NM>
-Node processNextNode(const NM& nm, bool& reached) {
+Node processNextNode(const NM& nm, bool& reach) {
 Node n = _list[++_list_front];
 _visitor->process(n);
 Edge e;
 for (_graph->firstOut(e, n); e != INVALID; _graph->nextOut(e)) {
 Node m = _graph->target(e);
 if (!(*_reached)[m]) {
 _visitor->discover(e);
 _visitor->reach(m);
 _reached->set(m, true);
 _list[++_list_back] = m;
-reached = reached || nm[m];
+reach = reach || nm[m];
 } else {
 _visitor->examine(e);
 }
 }
 return n;
 /// Executes the algorithm until \c dest is reached.
 ///
 /// \pre init() must be called and at least one node should be added
 /// with addSource() before using this function.
 void start(Node dest) {
-bool reached = false;
+bool reach = false;
-while (!emptyQueue() && !reached) {
+while (!emptyQueue() && !reach) {
-	processNextNode(dest, reached);
+	processNextNode(dest, reach);
 }
 }
 /// \brief Executes the algorithm until a condition is met.
 ///
 ///\param nm must be a bool (or convertible) node map. The
 ///algorithm will stop when it reached a node \c v with
 /// <tt>nm[v]</tt> true.
 template <typename NM>
 void start(const NM &nm) {
-bool reached = false;
+bool reach = false;
-while (!emptyQueue() && !reached) {
+while (!emptyQueue() && !reach) {
-processNextNode(nm, reached);
+processNextNode(nm, reach);
 }
 }
 /// \brief Runs %BFSVisit algorithm from node \c s.
 ///

changeset 2386	81b47fc5c444
parent 2376	0ed45a6c74b1
child 2391	14a343be7a5a