moved function to header

Author: kai-ion

src/aws-cpp-sdk-core/include/aws/core/internal/RetryStrategyImpl.h

@@ -15,16 +15,51 @@ namespace Aws
 {
     namespace Client
     {
+        static const int THROTTLE_BASED_RETRY_COST = 14;
+        static const int THROTTLE_BASED_THROTTLING_COST = 5;
+        static const int THROTTLE_BASED_INITIAL_TOKENS = 500;
+
         class AWS_CORE_LOCAL ThrottleBasedRetryQuotaContainer : public RetryQuotaContainer
         {
         public:
-            ThrottleBasedRetryQuotaContainer(int retryCost = 14, int throttlingRetryCost = 5);
+            ThrottleBasedRetryQuotaContainer(int retryCost = THROTTLE_BASED_RETRY_COST, int throttlingRetryCost = THROTTLE_BASED_THROTTLING_COST)
+                : m_retryQuota(THROTTLE_BASED_INITIAL_TOKENS), m_retryCost(retryCost), m_throttlingRetryCost(throttlingRetryCost) {}
+
             virtual ~ThrottleBasedRetryQuotaContainer() = default;
-            virtual bool AcquireRetryQuota(int capacityAmount) override;
-            virtual bool AcquireRetryQuota(const AWSError<CoreErrors>& error) override;
-            virtual void ReleaseRetryQuota(int capacityAmount) override;
-            virtual void ReleaseRetryQuota(const AWSError<CoreErrors>& lastError) override;
-            virtual int GetRetryQuota() const override { return m_retryQuota; }
+
+            bool AcquireRetryQuota(int capacityAmount) override
+            {
+                Aws::Utils::Threading::WriterLockGuard guard(m_retryQuotaLock);
+                if (capacityAmount > m_retryQuota)
+                {
+                    return false;
+                }
+                else
+                {
+                    m_retryQuota -= capacityAmount;
+                    return true;
+                }
+            }
+
+            bool AcquireRetryQuota(const AWSError<CoreErrors>& error) override
+            {
+                int capacityAmount = error.ShouldThrottle() ? m_throttlingRetryCost : m_retryCost;
+                return AcquireRetryQuota(capacityAmount);
+            }
+
+            void ReleaseRetryQuota(int capacityAmount) override
+            {
+                Aws::Utils::Threading::WriterLockGuard guard(m_retryQuotaLock);
+                m_retryQuota = (std::min)(m_retryQuota + capacityAmount, THROTTLE_BASED_INITIAL_TOKENS);
+            }
+
+            void ReleaseRetryQuota(const AWSError<CoreErrors>& error) override
+            {
+                int capacityAmount = error.ShouldThrottle() ? m_throttlingRetryCost : m_retryCost;
+                ReleaseRetryQuota(capacityAmount);
+            }
+
+            int GetRetryQuota() const override { return m_retryQuota; }
 
         private:
             mutable Aws::Utils::Threading::ReaderWriterLock m_retryQuotaLock;

src/aws-cpp-sdk-core/source/client/ClientConfiguration.cpp

@@ -562,6 +562,7 @@ std::shared_ptr<RetryStrategy> InitRetryStrategy(int maxAttempts, Aws::String re
     {
         if (maxAttempts < 0)
         {
+            // negative value set above force usage of default max attempts
             retryStrategy = Aws::MakeShared<StandardRetryStrategy>(CLIENT_CONFIG_TAG);
         }
         else
@@ -573,6 +574,7 @@ std::shared_ptr<RetryStrategy> InitRetryStrategy(int maxAttempts, Aws::String re
     {
         if (maxAttempts < 0)
         {
+            // negative value set above force usage of default max attempts
             retryStrategy = Aws::MakeShared<AdaptiveRetryStrategy>(CLIENT_CONFIG_TAG);
         }
         else

src/aws-cpp-sdk-core/source/client/RetryStrategy.cpp

@@ -44,8 +44,8 @@ namespace Aws
             long CalculateDelay(const AWSError<CoreErrors>& error, long attemptedRetries) const override
             {
                 double x = error.ShouldThrottle() ? 1.0 : 0.05;
-                double exponentialPart = x * static_cast<double>(1L << std::min(attemptedRetries, 30L));
-                double cappedPart = std::min(exponentialPart, 20.0);
+                double exponentialPart = x * static_cast<double>(1L << (std::min)(attemptedRetries, 30L));
+                double cappedPart = (std::min)(exponentialPart, 20.0);
 
                 double b = static_cast<double>(Aws::Utils::GetRandomValue() % 10000) / 10000.0;
                 double t_i = b * cappedPart;
@@ -55,7 +55,7 @@ namespace Aws
                 if (it != headers.end())
                 {
                     double headerSec = static_cast<double>(Aws::Utils::StringUtils::ConvertToInt64(it->second.c_str())) / 1000.0;
-                    double clamped = std::max(t_i, std::min(headerSec, 5.0 + t_i));
+                    double clamped = (std::max)(t_i, (std::min)(headerSec, 5.0 + t_i));
                     return static_cast<long>(clamped * 1000.0);
                 }
 
@@ -160,41 +160,5 @@ namespace Aws
             ReleaseRetryQuota(capacityAmount);
         }
 
-        ThrottleBasedRetryQuotaContainer::ThrottleBasedRetryQuotaContainer(int retryCost, int throttlingRetryCost)
-            : m_retryQuota(INITIAL_RETRY_TOKENS), m_retryCost(retryCost), m_throttlingRetryCost(throttlingRetryCost)
-        {}
-
-        bool ThrottleBasedRetryQuotaContainer::AcquireRetryQuota(int capacityAmount)
-        {
-            WriterLockGuard guard(m_retryQuotaLock);
-
-            if (capacityAmount > m_retryQuota)
-            {
-                return false;
-            }
-            else
-            {
-                m_retryQuota -= capacityAmount;
-                return true;
-            }
-        }
-
-        bool ThrottleBasedRetryQuotaContainer::AcquireRetryQuota(const AWSError<CoreErrors>& error)
-        {
-            int capacityAmount = error.ShouldThrottle() ? m_throttlingRetryCost : m_retryCost;
-            return AcquireRetryQuota(capacityAmount);
-        }
-
-        void ThrottleBasedRetryQuotaContainer::ReleaseRetryQuota(int capacityAmount)
-        {
-            WriterLockGuard guard(m_retryQuotaLock);
-            m_retryQuota = (std::min)(m_retryQuota + capacityAmount, INITIAL_RETRY_TOKENS);
-        }
-
-        void ThrottleBasedRetryQuotaContainer::ReleaseRetryQuota(const AWSError<CoreErrors>& error)
-        {
-            int capacityAmount = error.ShouldThrottle() ? m_throttlingRetryCost : m_retryCost;
-            ReleaseRetryQuota(capacityAmount);
-        }
     }
 }