Changeset 2386:81b47fc5c444 in lemon-0.x for lemon/bellman_ford.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/bellman_ford.h (modified) (10 diffs)

lemon/bellman_ford.h

@@ -437 +437 @@
     /// paths.
     bool processNextRound() {
-      for (int i = 0; i < (int)_process.size(); ++i) {
+      for (int i = 0; i < int(_process.size()); ++i) {
         _mask->set(_process[i], false);
       }
       std::vector<Node> nextProcess;
       std::vector<Value> values(_process.size());
-      for (int i = 0; i < (int)_process.size(); ++i) {
+      for (int i = 0; i < int(_process.size()); ++i) {
         values[i] = (*_dist)[_process[i]];
       }
-      for (int i = 0; i < (int)_process.size(); ++i) {
+      for (int i = 0; i < int(_process.size()); ++i) {
         for (OutEdgeIt it(*graph, _process[i]); it != INVALID; ++it) {
           Node target = graph->target(it);
@@ -473 +473 @@
     /// \return %True when the algorithm have not found more shorter paths.
     bool processNextWeakRound() {
-      for (int i = 0; i < (int)_process.size(); ++i) {
+      for (int i = 0; i < int(_process.size()); ++i) {
         _mask->set(_process[i], false);
       }
       std::vector<Node> nextProcess;
-      for (int i = 0; i < (int)_process.size(); ++i) {
+      for (int i = 0; i < int(_process.size()); ++i) {
         for (OutEdgeIt it(*graph, _process[i]); it != INVALID; ++it) {
           Node target = graph->target(it);
@@ -646 +646 @@
 
       bool operator==(const ActiveIt& it) const { 
-        return (Node)(*this) == (Node)it; 
+        return static_cast<Node>(*this) == static_cast<Node>(it); 
       }
       bool operator!=(const ActiveIt& it) const { 
-        return (Node)(*this) != (Node)it; 
+        return static_cast<Node>(*this) != static_cast<Node>(it); 
       }
       bool operator<(const ActiveIt& it) const { 
-        return (Node)(*this) < (Node)it; 
+        return static_cast<Node>(*this) < static_cast<Node>(it); 
       }
       
@@ -866 +866 @@
                           const _LengthMap& length, 
                           Node source = INVALID) :
-      _graph((void *)&graph), _length((void *)&length), _pred(0),
-      _dist(0), _source(source) {}
+      _graph(reinterpret_cast<void*>(const_cast<_Graph*>(&graph))), 
+      _length(reinterpret_cast<void*>(const_cast<_LengthMap*>(&length))), 
+      _pred(0), _dist(0), _source(source) {}
 
   };
@@ -924 +925 @@
     /// These parameters will be the default values for the traits class.
     BellmanFordWizard(const Graph& graph, const LengthMap& length, 
-                      Node source = INVALID) 
-      : _Traits(graph, length, source) {}
+                      Node src = INVALID) 
+      : _Traits(graph, length, src) {}
 
     /// \brief Copy constructor
@@ -939 +940 @@
       if(Base::_source == INVALID) throw UninitializedParameter();
       BellmanFord<Graph,LengthMap,_Traits> 
-        bf(*(Graph*)Base::_graph, *(LengthMap*)Base::_length);
-      if (Base::_pred) bf.predMap(*(PredMap*)Base::_pred);
-      if (Base::_dist) bf.distMap(*(DistMap*)Base::_dist);
+        bf(*reinterpret_cast<const Graph*>(Base::_graph), 
+           *reinterpret_cast<const LengthMap*>(Base::_length));
+      if (Base::_pred) bf.predMap(*reinterpret_cast<PredMap*>(Base::_pred));
+      if (Base::_dist) bf.distMap(*reinterpret_cast<DistMap*>(Base::_dist));
       bf.run(Base::_source);
     }
@@ -949 +951 @@
     /// Runs BellmanFord algorithm from the given node.
     /// \param source is the given source.
-    void run(Node source) {
-      Base::_source = source;
+    void run(Node src) {
+      Base::_source = src;
       run();
     }
@@ -970 +972 @@
     BellmanFordWizard<DefPredMapBase<T> > predMap(const T &t) 
     {
-      Base::_pred=(void *)&t;
+      Base::_pred=reinterpret_cast<void*>(const_cast<T*>(&t));
       return BellmanFordWizard<DefPredMapBase<T> >(*this);
     }
@@ -989 +991 @@
     template<class T>
     BellmanFordWizard<DefDistMapBase<T> > distMap(const T &t) {
-      Base::_dist=(void *)&t;
+      Base::_dist=reinterpret_cast<void*>(const_cast<T*>(&t));
       return BellmanFordWizard<DefDistMapBase<T> >(*this);
     }
@@ -1014 +1016 @@
     /// Sets the source node, from which the BellmanFord algorithm runs.
     /// \param source is the source node.
-    BellmanFordWizard<_Traits>& source(Node source) {
-      Base::_source = source;
+    BellmanFordWizard<_Traits>& source(Node src) {
+      Base::_source = src;
       return *this;
     }