HttpClient.h

 
#pragma once
 
#include <aws/core/Core_EXPORTS.h>
 
#include <memory>
#include <atomic>
#include <mutex>
#include <condition_variable>
 
namespace Aws
{
    namespace Utils
    {
        namespace RateLimits
        {
            class RateLimiterInterface;
        } // namespace RateLimits
    } // namespace Utils
 
    namespace Http
    {
        class HttpRequest;
        class HttpResponse;
 
        class AWS_CORE_API HttpClient
        {
        public:
            HttpClient();
            virtual ~HttpClient() {}
 
            virtual std::shared_ptr<HttpResponse> MakeRequest(const std::shared_ptr<HttpRequest>& request,
                Aws::Utils::RateLimits::RateLimiterInterface* readLimiter = nullptr,
                Aws::Utils::RateLimits::RateLimiterInterface* writeLimiter = nullptr) const = 0;
 
            virtual bool SupportsChunkedTransferEncoding() const { return true; }
 
            virtual bool IsDefaultAwsHttpClient() const { return false; }
 
            void DisableRequestProcessing();
            void EnableRequestProcessing();
            bool IsRequestProcessingEnabled() const;
            void RetryRequestSleep(std::chrono::milliseconds sleepTime);
 
            bool ContinueRequest(const Aws::Http::HttpRequest&) const;
 
            explicit operator bool() const
            {
               return !m_bad;
            }
 
        protected:
            bool m_bad;
 
        private:
 
            std::atomic< bool > m_disableRequestProcessing;
            std::mutex m_requestProcessingSignalLock;
            std::condition_variable m_requestProcessingSignal;
        };
 
    } // namespace Http
} // namespace Aws