Better resizing of char_vector in edge cases

Author: gershnik

lib/inc/sys_string/impl/util/char_vector.h

@@ -183,25 +183,28 @@ namespace sysstr::util
         }
 
     private:
+        
 
         void grow()
         {
             if (this->m_size < this->capacity())
                 return;
-            
+
             size_type desired;
-        
-            if (this->capacity() == 0)
+            if (this->capacity() < growth_increment) {
                 desired = growth_increment;
-            else if (this->capacity() / growth_div_factor < this->max_size() / growth_mul_factor)
-                desired = (this->capacity() * growth_mul_factor) / growth_div_factor;
-            else if (this->capacity() < this->max_size() - growth_increment)
-                desired = this->capacity() + growth_increment;
-            else if (this->capacity() == this->max_size())
-                throw std::bad_alloc();
-            else
-                desired = this->max_size();
-        
+            } else {
+                desired = util::saturated_mul_div(this->capacity(), growth_mul_factor, growth_div_factor);
+                if (desired == this->capacity() || desired >= this->max_size()) {
+                    if (this->capacity() < this->max_size() - growth_increment)
+                        desired = this->capacity() + growth_increment;
+                    else if (this->capacity() == this->max_size())
+                        throw std::bad_alloc();
+                    else
+                        desired = this->max_size();
+                }
+            }
+
             this->m_storage.reallocate(desired, this->m_size);
         }
 

lib/inc/sys_string/impl/util/util.h

@@ -108,6 +108,28 @@ namespace sysstr::util
 
     #endif
 
+    template<std::unsigned_integral T>
+    constexpr T saturated_mul_div(T val, std::convertible_to<T> auto numerator, std::convertible_to<T> auto denominator) {
+        T num = T(numerator);
+        T denom = T(denominator);
+        T whole = num / denom;
+        num = num % denom;
+
+        T quot = val / denom;
+        T rem = val % denom;
+        T increment = quot * num;
+
+        T extra = rem * num;
+        quot = extra / denom;
+        rem = extra % denom;
+        increment += quot;
+        increment += (2 * rem >= denom);
+
+        if (whole && (std::numeric_limits<T>::max() - increment) / whole < val)
+            return std::numeric_limits<T>::max();
+        return val * whole + increment;
+    }
+
 }
 
 #endif