Merge pull request #2506 from JanVogelsang/refactoring-casts

Modernize the codebase - convert C-style casts to static_casts

Author: jougs

libnestutil/numerics.cpp

@@ -92,7 +92,7 @@ const double numerics::nan = 0.0 / 0.0;
 long
 ld_round( double x )
 {
-  return ( long ) std::floor( x + 0.5 );
+  return static_cast< long >( std::floor( x + 0.5 ) );
 }
 
 double

libnestutil/stopwatch.h

@@ -71,12 +71,12 @@ class Stopwatch
 
   enum
   {
-    MICROSEC = ( timeunit_t ) 1,
-    MILLISEC = MICROSEC * ( timeunit_t ) 1000,
-    SECONDS = MILLISEC * ( timeunit_t ) 1000,
-    MINUTES = SECONDS * ( timeunit_t ) 60,
-    HOURS = MINUTES * ( timeunit_t ) 60,
-    DAYS = HOURS * ( timeunit_t ) 24
+    MICROSEC = static_cast< timeunit_t >( 1 ),
+    MILLISEC = MICROSEC * static_cast< timeunit_t >( 1000 ),
+    SECONDS = MILLISEC * static_cast< timeunit_t >( 1000 ),
+    MINUTES = SECONDS * static_cast< timeunit_t >( 60 ),
+    HOURS = MINUTES * static_cast< timeunit_t >( 60 ),
+    DAYS = HOURS * static_cast< timeunit_t >( 24 )
   };
 
   static bool correct_timeunit( timeunit_t t );
@@ -222,7 +222,7 @@ nest::Stopwatch::elapsed_timestamp() const
     return _end - _beg + _prev_elapsed;
   }
 #else
-  return ( timestamp_t ) 0;
+  return static_cast< timestamp_t >( 0 );
 #endif
 }
 

nestkernel/layer_impl.h

@@ -382,7 +382,7 @@ MaskedLayer< D >::check_mask_( Layer< D >& layer, bool allow_oversized )
       for ( int i = 0; i < D; ++i )
       {
         oversize |= layer.get_periodic_mask()[ i ]
-          and ( grid_mask.get_lower_right()[ i ] - grid_mask.get_upper_left()[ i ] ) > ( int ) dims[ i ];
+          and ( grid_mask.get_lower_right()[ i ] - grid_mask.get_upper_left()[ i ] ) > static_cast< int >( dims[ i ] );
       }
       if ( oversize )
       {

nestkernel/model.cpp

@@ -69,7 +69,7 @@ Model::set_threads_( size_t t )
 void
 Model::reserve_additional( size_t t, size_t n )
 {
-  assert( ( size_t ) t < memory_.size() );
+  assert( t < memory_.size() );
   memory_[ t ].reserve( n );
 }
 

nestkernel/model.h

@@ -255,7 +255,7 @@ class Model
 inline Node*
 Model::create( size_t t )
 {
-  assert( ( size_t ) t < memory_.size() );
+  assert( t < memory_.size() );
   Node* n = create_();
   memory_[ t ].emplace_back( n );
   return n;

nestkernel/model_manager.cpp

@@ -366,7 +366,7 @@ size_t
 ModelManager::get_node_model_id( const Name name ) const
 {
   const Name model_name( name );
-  for ( int i = 0; i < ( int ) node_models_.size(); ++i )
+  for ( int i = 0; i < static_cast< int >( node_models_.size() ); ++i )
   {
     assert( node_models_[ i ] );
     if ( model_name == node_models_[ i ]->get_name() )

nestkernel/ring_buffer.h

@@ -169,8 +169,8 @@ RingBuffer::set_value( const long offs, const double v )
 inline double
 RingBuffer::get_value( const long offs )
 {
-  assert( 0 <= offs and ( size_t ) offs < buffer_.size() );
-  assert( ( long ) offs < kernel().connection_manager.get_min_delay() );
+  assert( 0 <= offs and static_cast< size_t >( offs ) < buffer_.size() );
+  assert( offs < kernel().connection_manager.get_min_delay() );
 
   // offs == 0 is beginning of slice, but we have to
   // take modulo into account when indexing
@@ -183,8 +183,8 @@ RingBuffer::get_value( const long offs )
 inline double
 RingBuffer::get_value_wfr_update( const long offs )
 {
-  assert( 0 <= offs and ( size_t ) offs < buffer_.size() );
-  assert( ( long ) offs < kernel().connection_manager.get_min_delay() );
+  assert( 0 <= offs and static_cast< size_t >( offs ) < buffer_.size() );
+  assert( offs < kernel().connection_manager.get_min_delay() );
 
   // offs == 0 is beginning of slice, but we have to
   // take modulo into account when indexing
@@ -198,7 +198,7 @@ RingBuffer::get_index_( const long d ) const
 {
   const long idx = kernel().event_delivery_manager.get_modulo( d );
   assert( 0 <= idx );
-  assert( ( size_t ) idx < buffer_.size() );
+  assert( static_cast< size_t >( idx ) < buffer_.size() );
   return idx;
 }
 
@@ -258,15 +258,15 @@ class MultRBuffer
 inline void
 MultRBuffer::add_value( const long offs, const double v )
 {
-  assert( 0 <= offs and ( size_t ) offs < buffer_.size() );
+  assert( 0 <= offs and static_cast< size_t >( offs ) < buffer_.size() );
   buffer_[ get_index_( offs ) ] *= v;
 }
 
 inline double
 MultRBuffer::get_value( const long offs )
 {
-  assert( 0 <= offs and ( size_t ) offs < buffer_.size() );
-  assert( ( long ) offs < kernel().connection_manager.get_min_delay() );
+  assert( 0 <= offs and static_cast< size_t >( offs ) < buffer_.size() );
+  assert( offs < kernel().connection_manager.get_min_delay() );
 
   // offs == 0 is beginning of slice, but we have to
   // take modulo into account when indexing
@@ -280,7 +280,7 @@ inline size_t
 MultRBuffer::get_index_( const long d ) const
 {
   const long idx = kernel().event_delivery_manager.get_modulo( d );
-  assert( 0 <= idx and ( size_t ) idx < buffer_.size() );
+  assert( 0 <= idx and static_cast< size_t >( idx ) < buffer_.size() );
   return idx;
 }
 
@@ -346,8 +346,8 @@ ListRingBuffer::append_value( const long offs, const double v )
 inline std::list< double >&
 ListRingBuffer::get_list( const long offs )
 {
-  assert( 0 <= offs and ( size_t ) offs < buffer_.size() );
-  assert( ( long ) offs < kernel().connection_manager.get_min_delay() );
+  assert( 0 <= offs and static_cast< size_t >( offs ) < buffer_.size() );
+  assert( offs < kernel().connection_manager.get_min_delay() );
 
   // offs == 0 is beginning of slice, but we have to
   // take modulo into account when indexing
@@ -360,7 +360,7 @@ ListRingBuffer::get_index_( const long d ) const
 {
   const long idx = kernel().event_delivery_manager.get_modulo( d );
   assert( 0 <= idx );
-  assert( ( size_t ) idx < buffer_.size() );
+  assert( static_cast< size_t >( idx ) < buffer_.size() );
   return idx;
 }
 

nestkernel/simulation_manager.cpp

@@ -1080,7 +1080,7 @@ nest::SimulationManager::advance_time_()
   to_do_ -= to_step_ - from_step_;
 
   // advance clock, update modulos, slice counter only if slice completed
-  if ( ( long ) to_step_ == kernel().connection_manager.get_min_delay() )
+  if ( to_step_ == kernel().connection_manager.get_min_delay() )
   {
     clock_ += Time::step( kernel().connection_manager.get_min_delay() );
     ++slice_;
@@ -1094,7 +1094,7 @@ nest::SimulationManager::advance_time_()
 
   long end_sim = from_step_ + to_do_;
 
-  if ( kernel().connection_manager.get_min_delay() < ( long ) end_sim )
+  if ( kernel().connection_manager.get_min_delay() < end_sim )
   {
     // update to end of time slice
     to_step_ = kernel().connection_manager.get_min_delay();
@@ -1104,7 +1104,7 @@ nest::SimulationManager::advance_time_()
     to_step_ = end_sim; // update to end of simulation time
   }
 
-  assert( to_step_ - from_step_ <= ( long ) kernel().connection_manager.get_min_delay() );
+  assert( to_step_ - from_step_ <= kernel().connection_manager.get_min_delay() );
 }
 
 void

nestkernel/slice_ring_buffer.h

@@ -159,7 +159,7 @@ inline void
 SliceRingBuffer::add_spike( const long rel_delivery, const long stamp, const double ps_offset, const double weight )
 {
   const long idx = kernel().event_delivery_manager.get_slice_modulo( rel_delivery );
-  assert( ( size_t ) idx < queue_.size() );
+  assert( static_cast< size_t >( idx ) < queue_.size() );
   assert( ps_offset >= 0 );
 
   queue_[ idx ].push_back( SpikeInfo( stamp, ps_offset, weight ) );

sli/interpret.cc

@@ -987,7 +987,7 @@ SLIInterpreter::stack_backtrace( int n )
 {
   for ( int p = n - 1; p >= 0; --p )
   {
-    if ( ( size_t ) p > EStack.load() )
+    if ( static_cast< size_t >( p ) > EStack.load() )
     {
       continue;
     }