put assert in header

Author: AlexanderSinn

Src/Base/AMReX_PODVector.H

@@ -259,9 +259,18 @@ namespace amrex
 
         void Initialize ();
 
-        std::size_t GetNewCapacity (std::size_t old_size, std::size_t old_capacity,
-                                    std::size_t new_size, GrowthStrategy strategy,
-                                    std::size_t sizeof_T);
+        std::size_t GetNewCapacityImp (std::size_t old_size, std::size_t old_capacity,
+                                       std::size_t new_size, GrowthStrategy strategy,
+                                       std::size_t sizeof_T);
+
+        inline std::size_t GetNewCapacity (std::size_t old_size, std::size_t old_capacity,
+                                           std::size_t new_size, GrowthStrategy strategy,
+                                           std::size_t sizeof_T) {
+            std::size_t new_capacity =
+                GetNewCapacityImp(old_size, old_capacity, new_size, strategy, sizeof_T);
+            AMREX_ALWAYS_ASSERT(new_capacity >= new_size);
+            return new_capacity;
+        }
     }
 
     template <class T, class Allocator = std::allocator<T> >

Src/Base/AMReX_PODVector.cpp

@@ -49,51 +49,44 @@ namespace amrex::VectorGrowthStrategy
         detail::ValidateUserInput();
     }
 
-    std::size_t GetNewCapacity ([[maybe_unused]] std::size_t old_size, std::size_t old_capacity,
-                                std::size_t new_size, amrex::GrowthStrategy strategy,
-                                std::size_t sizeof_T) {
-
-        std::size_t new_capacity = 0;
+    std::size_t GetNewCapacityImp ([[maybe_unused]] std::size_t old_size, std::size_t old_capacity,
+                                   std::size_t new_size, amrex::GrowthStrategy strategy,
+                                   std::size_t sizeof_T) {
 
         if (override_strategy != amrex::GrowthStrategy::Default) {
-            return GetNewCapacity(old_size, old_capacity, new_size, override_strategy, sizeof_T);
+            return GetNewCapacityImp(old_size, old_capacity, new_size, override_strategy, sizeof_T);
         }
 
         switch (strategy) {
             case GrowthStrategy::Default:
                 AMREX_ALWAYS_ASSERT_WITH_MESSAGE(default_strategy != GrowthStrategy::Default,
                     "Must set default growth strategy to something other than Default");
-                return GetNewCapacity(old_size, old_capacity, new_size, default_strategy, sizeof_T);
+                return GetNewCapacityImp(old_size, old_capacity, new_size,
+                                         default_strategy, sizeof_T);
             case GrowthStrategy::Exact:
                 if (new_size > old_capacity) {
-                    new_capacity = new_size;
+                    return new_size;
                 } else {
-                    new_capacity = old_capacity;
+                    return old_capacity;
                 }
-                break;
             case GrowthStrategy::Geometric:
                 if (new_size > old_capacity) {
                     const std::size_t min_capacity = std::max(64/sizeof_T, new_size);
                     Real const gf = GetGrowthFactor();
                     if (amrex::almostEqual(gf, Real(1.5))) {
-                        new_capacity = std::max((old_capacity*3+1)/2, min_capacity);
+                        return std::max((old_capacity*3+1)/2, min_capacity);
                     } else {
-                        new_capacity = std::max(std::size_t(gf*Real(old_capacity+1)), min_capacity);
+                        return std::max(std::size_t(gf*Real(old_capacity+1)), min_capacity);
                     }
                 } else {
-                    new_capacity = old_capacity;
+                    return old_capacity;
                 }
-                break;
             case GrowthStrategy::Poisson:
                 if (new_size > old_capacity) {
-                    new_capacity = new_size + static_cast<std::size_t>(3 * std::sqrt(new_size));
+                    return new_size + static_cast<std::size_t>(3 * std::sqrt(new_size));
                 } else {
-                    new_capacity = old_capacity;
+                    return old_capacity;
                 }
-                break;
         }
-
-        AMREX_ALWAYS_ASSERT(new_capacity >= new_size);
-        return new_capacity;
     }
 }