Changeset 2386:81b47fc5c444 in lemon-0.x for lemon/bfs.h

Timestamp:

03/02/07 19:04:28 (17 years ago)

Author:

Balazs Dezso

Branch:

default

Phase:

public

Convert:

svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@3217

Message:

Hard Warning checking

• based on the remark of the ZIB user
• we do not use -Winline

File:

• lemon/bfs.h (modified) (18 diffs)

lemon/bfs.h

@@ -489 +489 @@
     ///
     ///\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) {
@@ -508 +508 @@
           _pred->set(m,e);
           _dist->set(m,_curr_dist);
-          reached = reached || (target == m);
+          reach = reach || (target == m);
         }
       return n;
@@ -522 +522 @@
     ///
     ///\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) {
@@ -542 +542 @@
           _pred->set(m,e);
           _dist->set(m,_curr_dist);
-          reached = reached || nm[m];
+          reached = reach || nm[m];
         }
       return n;
@@ -605 +605 @@
     void start(Node dest)
     {
-      bool reached = false;
-      while ( !emptyQueue() && !reached) processNextNode(dest, reached);
+      bool reach = false;
+      while ( !emptyQueue() && !reach) processNextNode(dest, reach);
     }
     
@@ -623 +623 @@
     void start(const NM &nm)
     {
-      bool reached = false;
-      while ( !emptyQueue() && !reached) processNextNode(nm, reached);
+      bool reach = false;
+      while ( !emptyQueue() && !reach) processNextNode(nm, reach);
     }
     
@@ -883 +883 @@
     /// \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),
-      _dist(0), _source(s) {}
+      _g(reinterpret_cast<void*>(const_cast<GR*>(&g))), 
+      _reached(0), _processed(0), _pred(0), _dist(0), _source(s) {}
 
   };
@@ -958 +958 @@
     {
       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);
-      if(Base::_processed) alg.processedMap(*(ProcessedMap*)Base::_processed);
-      if(Base::_pred) alg.predMap(*(PredMap*)Base::_pred);
-      if(Base::_dist) alg.distMap(*(DistMap*)Base::_dist);
+        alg.reachedMap(*reinterpret_cast<ReachedMap*>(Base::_reached));
+      if(Base::_processed) 
+        alg.processedMap(*reinterpret_cast<ProcessedMap*>(Base::_processed));
+      if(Base::_pred) 
+        alg.predMap(*reinterpret_cast<PredMap*>(Base::_pred));
+      if(Base::_dist) 
+        alg.distMap(*reinterpret_cast<DistMap*>(Base::_dist));
       alg.run(Base::_source);
     }
@@ -993 +996 @@
     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);
     }
@@ -1014 +1017 @@
     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);
     }
@@ -1035 +1038 @@
     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);
     }
@@ -1056 +1059 @@
     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);
     }
@@ -1405 +1408 @@
     ///
     /// \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);
@@ -1420 +1423 @@
           _reached->set(m, true);
           _list[++_list_back] = m;
-          reached = reached || (target == m);
+          reach = reach || (target == m);
         } else {
           _visitor->examine(e);
@@ -1442 +1445 @@
     /// \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);
@@ -1453 +1456 @@
           _reached->set(m, true);
           _list[++_list_back] = m;
-          reached = reached || nm[m];
+          reach = reach || nm[m];
         } else {
           _visitor->examine(e);
@@ -1500 +1503 @@
     /// with addSource() before using this function.
     void start(Node dest) {
-      bool reached = false;
-      while (!emptyQueue() && !reached) { 
-        processNextNode(dest, reached);
+      bool reach = false;
+      while (!emptyQueue() && !reach) { 
+        processNextNode(dest, reach);
       }
     }
@@ -1518 +1521 @@
     template <typename NM>
     void start(const NM &nm) {
-      bool reached = false;
-      while (!emptyQueue() && !reached) {
-        processNextNode(nm, reached);
+      bool reach = false;
+      while (!emptyQueue() && !reach) {
+        processNextNode(nm, reach);
       }
     }