SQSClient.h

 
#pragma once
#include <aws/sqs/SQS_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/sqs/SQSServiceClientModel.h>
 
namespace Aws
{
namespace SQS
{
  class AWS_SQS_API SQSClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<SQSClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef SQSClientConfiguration ClientConfigurationType;
      typedef SQSEndpointProvider EndpointProviderType;
 
        SQSClient(const Aws::SQS::SQSClientConfiguration& clientConfiguration = Aws::SQS::SQSClientConfiguration(),
                  std::shared_ptr<SQSEndpointProviderBase> endpointProvider = nullptr);
 
        SQSClient(const Aws::Auth::AWSCredentials& credentials,
                  std::shared_ptr<SQSEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::SQS::SQSClientConfiguration& clientConfiguration = Aws::SQS::SQSClientConfiguration());
 
        SQSClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  std::shared_ptr<SQSEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::SQS::SQSClientConfiguration& clientConfiguration = Aws::SQS::SQSClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        SQSClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        SQSClient(const Aws::Auth::AWSCredentials& credentials,
                  const Aws::Client::ClientConfiguration& clientConfiguration);
 
        SQSClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~SQSClient();
 
        virtual Model::AddPermissionOutcome AddPermission(const Model::AddPermissionRequest& request) const;
 
        template<typename AddPermissionRequestT = Model::AddPermissionRequest>
        Model::AddPermissionOutcomeCallable AddPermissionCallable(const AddPermissionRequestT& request) const
        {
            return SubmitCallable(&SQSClient::AddPermission, request);
        }
 
        template<typename AddPermissionRequestT = Model::AddPermissionRequest>
        void AddPermissionAsync(const AddPermissionRequestT& request, const AddPermissionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SQSClient::AddPermission, request, handler, context);
        }
 
        virtual Model::CancelMessageMoveTaskOutcome CancelMessageMoveTask(const Model::CancelMessageMoveTaskRequest& request) const;
 
        template<typename CancelMessageMoveTaskRequestT = Model::CancelMessageMoveTaskRequest>
        Model::CancelMessageMoveTaskOutcomeCallable CancelMessageMoveTaskCallable(const CancelMessageMoveTaskRequestT& request) const
        {
            return SubmitCallable(&SQSClient::CancelMessageMoveTask, request);
        }
 
        template<typename CancelMessageMoveTaskRequestT = Model::CancelMessageMoveTaskRequest>
        void CancelMessageMoveTaskAsync(const CancelMessageMoveTaskRequestT& request, const CancelMessageMoveTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SQSClient::CancelMessageMoveTask, request, handler, context);
        }
 
        virtual Model::ChangeMessageVisibilityOutcome ChangeMessageVisibility(const Model::ChangeMessageVisibilityRequest& request) const;
 
        template<typename ChangeMessageVisibilityRequestT = Model::ChangeMessageVisibilityRequest>
        Model::ChangeMessageVisibilityOutcomeCallable ChangeMessageVisibilityCallable(const ChangeMessageVisibilityRequestT& request) const
        {
            return SubmitCallable(&SQSClient::ChangeMessageVisibility, request);
        }
 
        template<typename ChangeMessageVisibilityRequestT = Model::ChangeMessageVisibilityRequest>
        void ChangeMessageVisibilityAsync(const ChangeMessageVisibilityRequestT& request, const ChangeMessageVisibilityResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SQSClient::ChangeMessageVisibility, request, handler, context);
        }
 
        virtual Model::ChangeMessageVisibilityBatchOutcome ChangeMessageVisibilityBatch(const Model::ChangeMessageVisibilityBatchRequest& request) const;
 
        template<typename ChangeMessageVisibilityBatchRequestT = Model::ChangeMessageVisibilityBatchRequest>
        Model::ChangeMessageVisibilityBatchOutcomeCallable ChangeMessageVisibilityBatchCallable(const ChangeMessageVisibilityBatchRequestT& request) const
        {
            return SubmitCallable(&SQSClient::ChangeMessageVisibilityBatch, request);
        }
 
        template<typename ChangeMessageVisibilityBatchRequestT = Model::ChangeMessageVisibilityBatchRequest>
        void ChangeMessageVisibilityBatchAsync(const ChangeMessageVisibilityBatchRequestT& request, const ChangeMessageVisibilityBatchResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SQSClient::ChangeMessageVisibilityBatch, request, handler, context);
        }
 
        virtual Model::CreateQueueOutcome CreateQueue(const Model::CreateQueueRequest& request) const;
 
        template<typename CreateQueueRequestT = Model::CreateQueueRequest>
        Model::CreateQueueOutcomeCallable CreateQueueCallable(const CreateQueueRequestT& request) const
        {
            return SubmitCallable(&SQSClient::CreateQueue, request);
        }
 
        template<typename CreateQueueRequestT = Model::CreateQueueRequest>
        void CreateQueueAsync(const CreateQueueRequestT& request, const CreateQueueResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SQSClient::CreateQueue, request, handler, context);
        }
 
        virtual Model::DeleteMessageOutcome DeleteMessage(const Model::DeleteMessageRequest& request) const;
 
        template<typename DeleteMessageRequestT = Model::DeleteMessageRequest>
        Model::DeleteMessageOutcomeCallable DeleteMessageCallable(const DeleteMessageRequestT& request) const
        {
            return SubmitCallable(&SQSClient::DeleteMessage, request);
        }
 
        template<typename DeleteMessageRequestT = Model::DeleteMessageRequest>
        void DeleteMessageAsync(const DeleteMessageRequestT& request, const DeleteMessageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SQSClient::DeleteMessage, request, handler, context);
        }
 
        virtual Model::DeleteMessageBatchOutcome DeleteMessageBatch(const Model::DeleteMessageBatchRequest& request) const;
 
        template<typename DeleteMessageBatchRequestT = Model::DeleteMessageBatchRequest>
        Model::DeleteMessageBatchOutcomeCallable DeleteMessageBatchCallable(const DeleteMessageBatchRequestT& request) const
        {
            return SubmitCallable(&SQSClient::DeleteMessageBatch, request);
        }
 
        template<typename DeleteMessageBatchRequestT = Model::DeleteMessageBatchRequest>
        void DeleteMessageBatchAsync(const DeleteMessageBatchRequestT& request, const DeleteMessageBatchResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SQSClient::DeleteMessageBatch, request, handler, context);
        }
 
        virtual Model::DeleteQueueOutcome DeleteQueue(const Model::DeleteQueueRequest& request) const;
 
        template<typename DeleteQueueRequestT = Model::DeleteQueueRequest>
        Model::DeleteQueueOutcomeCallable DeleteQueueCallable(const DeleteQueueRequestT& request) const
        {
            return SubmitCallable(&SQSClient::DeleteQueue, request);
        }
 
        template<typename DeleteQueueRequestT = Model::DeleteQueueRequest>
        void DeleteQueueAsync(const DeleteQueueRequestT& request, const DeleteQueueResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SQSClient::DeleteQueue, request, handler, context);
        }
 
        virtual Model::GetQueueAttributesOutcome GetQueueAttributes(const Model::GetQueueAttributesRequest& request) const;
 
        template<typename GetQueueAttributesRequestT = Model::GetQueueAttributesRequest>
        Model::GetQueueAttributesOutcomeCallable GetQueueAttributesCallable(const GetQueueAttributesRequestT& request) const
        {
            return SubmitCallable(&SQSClient::GetQueueAttributes, request);
        }
 
        template<typename GetQueueAttributesRequestT = Model::GetQueueAttributesRequest>
        void GetQueueAttributesAsync(const GetQueueAttributesRequestT& request, const GetQueueAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SQSClient::GetQueueAttributes, request, handler, context);
        }
 
        virtual Model::GetQueueUrlOutcome GetQueueUrl(const Model::GetQueueUrlRequest& request) const;
 
        template<typename GetQueueUrlRequestT = Model::GetQueueUrlRequest>
        Model::GetQueueUrlOutcomeCallable GetQueueUrlCallable(const GetQueueUrlRequestT& request) const
        {
            return SubmitCallable(&SQSClient::GetQueueUrl, request);
        }
 
        template<typename GetQueueUrlRequestT = Model::GetQueueUrlRequest>
        void GetQueueUrlAsync(const GetQueueUrlRequestT& request, const GetQueueUrlResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SQSClient::GetQueueUrl, request, handler, context);
        }
 
        virtual Model::ListDeadLetterSourceQueuesOutcome ListDeadLetterSourceQueues(const Model::ListDeadLetterSourceQueuesRequest& request) const;
 
        template<typename ListDeadLetterSourceQueuesRequestT = Model::ListDeadLetterSourceQueuesRequest>
        Model::ListDeadLetterSourceQueuesOutcomeCallable ListDeadLetterSourceQueuesCallable(const ListDeadLetterSourceQueuesRequestT& request) const
        {
            return SubmitCallable(&SQSClient::ListDeadLetterSourceQueues, request);
        }
 
        template<typename ListDeadLetterSourceQueuesRequestT = Model::ListDeadLetterSourceQueuesRequest>
        void ListDeadLetterSourceQueuesAsync(const ListDeadLetterSourceQueuesRequestT& request, const ListDeadLetterSourceQueuesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SQSClient::ListDeadLetterSourceQueues, request, handler, context);
        }
 
        virtual Model::ListMessageMoveTasksOutcome ListMessageMoveTasks(const Model::ListMessageMoveTasksRequest& request) const;
 
        template<typename ListMessageMoveTasksRequestT = Model::ListMessageMoveTasksRequest>
        Model::ListMessageMoveTasksOutcomeCallable ListMessageMoveTasksCallable(const ListMessageMoveTasksRequestT& request) const
        {
            return SubmitCallable(&SQSClient::ListMessageMoveTasks, request);
        }
 
        template<typename ListMessageMoveTasksRequestT = Model::ListMessageMoveTasksRequest>
        void ListMessageMoveTasksAsync(const ListMessageMoveTasksRequestT& request, const ListMessageMoveTasksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SQSClient::ListMessageMoveTasks, request, handler, context);
        }
 
        virtual Model::ListQueueTagsOutcome ListQueueTags(const Model::ListQueueTagsRequest& request) const;
 
        template<typename ListQueueTagsRequestT = Model::ListQueueTagsRequest>
        Model::ListQueueTagsOutcomeCallable ListQueueTagsCallable(const ListQueueTagsRequestT& request) const
        {
            return SubmitCallable(&SQSClient::ListQueueTags, request);
        }
 
        template<typename ListQueueTagsRequestT = Model::ListQueueTagsRequest>
        void ListQueueTagsAsync(const ListQueueTagsRequestT& request, const ListQueueTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SQSClient::ListQueueTags, request, handler, context);
        }
 
        virtual Model::ListQueuesOutcome ListQueues(const Model::ListQueuesRequest& request = {}) const;
 
        template<typename ListQueuesRequestT = Model::ListQueuesRequest>
        Model::ListQueuesOutcomeCallable ListQueuesCallable(const ListQueuesRequestT& request = {}) const
        {
            return SubmitCallable(&SQSClient::ListQueues, request);
        }
 
        template<typename ListQueuesRequestT = Model::ListQueuesRequest>
        void ListQueuesAsync(const ListQueuesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListQueuesRequestT& request = {}) const
        {
            return SubmitAsync(&SQSClient::ListQueues, request, handler, context);
        }
 
        virtual Model::PurgeQueueOutcome PurgeQueue(const Model::PurgeQueueRequest& request) const;
 
        template<typename PurgeQueueRequestT = Model::PurgeQueueRequest>
        Model::PurgeQueueOutcomeCallable PurgeQueueCallable(const PurgeQueueRequestT& request) const
        {
            return SubmitCallable(&SQSClient::PurgeQueue, request);
        }
 
        template<typename PurgeQueueRequestT = Model::PurgeQueueRequest>
        void PurgeQueueAsync(const PurgeQueueRequestT& request, const PurgeQueueResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SQSClient::PurgeQueue, request, handler, context);
        }
 
        virtual Model::ReceiveMessageOutcome ReceiveMessage(const Model::ReceiveMessageRequest& request) const;
 
        template<typename ReceiveMessageRequestT = Model::ReceiveMessageRequest>
        Model::ReceiveMessageOutcomeCallable ReceiveMessageCallable(const ReceiveMessageRequestT& request) const
        {
            return SubmitCallable(&SQSClient::ReceiveMessage, request);
        }
 
        template<typename ReceiveMessageRequestT = Model::ReceiveMessageRequest>
        void ReceiveMessageAsync(const ReceiveMessageRequestT& request, const ReceiveMessageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SQSClient::ReceiveMessage, request, handler, context);
        }
 
        virtual Model::RemovePermissionOutcome RemovePermission(const Model::RemovePermissionRequest& request) const;
 
        template<typename RemovePermissionRequestT = Model::RemovePermissionRequest>
        Model::RemovePermissionOutcomeCallable RemovePermissionCallable(const RemovePermissionRequestT& request) const
        {
            return SubmitCallable(&SQSClient::RemovePermission, request);
        }
 
        template<typename RemovePermissionRequestT = Model::RemovePermissionRequest>
        void RemovePermissionAsync(const RemovePermissionRequestT& request, const RemovePermissionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SQSClient::RemovePermission, request, handler, context);
        }
 
        virtual Model::SendMessageOutcome SendMessage(const Model::SendMessageRequest& request) const;
 
        template<typename SendMessageRequestT = Model::SendMessageRequest>
        Model::SendMessageOutcomeCallable SendMessageCallable(const SendMessageRequestT& request) const
        {
            return SubmitCallable(&SQSClient::SendMessage, request);
        }
 
        template<typename SendMessageRequestT = Model::SendMessageRequest>
        void SendMessageAsync(const SendMessageRequestT& request, const SendMessageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SQSClient::SendMessage, request, handler, context);
        }
 
        virtual Model::SendMessageBatchOutcome SendMessageBatch(const Model::SendMessageBatchRequest& request) const;
 
        template<typename SendMessageBatchRequestT = Model::SendMessageBatchRequest>
        Model::SendMessageBatchOutcomeCallable SendMessageBatchCallable(const SendMessageBatchRequestT& request) const
        {
            return SubmitCallable(&SQSClient::SendMessageBatch, request);
        }
 
        template<typename SendMessageBatchRequestT = Model::SendMessageBatchRequest>
        void SendMessageBatchAsync(const SendMessageBatchRequestT& request, const SendMessageBatchResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SQSClient::SendMessageBatch, request, handler, context);
        }
 
        virtual Model::SetQueueAttributesOutcome SetQueueAttributes(const Model::SetQueueAttributesRequest& request) const;
 
        template<typename SetQueueAttributesRequestT = Model::SetQueueAttributesRequest>
        Model::SetQueueAttributesOutcomeCallable SetQueueAttributesCallable(const SetQueueAttributesRequestT& request) const
        {
            return SubmitCallable(&SQSClient::SetQueueAttributes, request);
        }
 
        template<typename SetQueueAttributesRequestT = Model::SetQueueAttributesRequest>
        void SetQueueAttributesAsync(const SetQueueAttributesRequestT& request, const SetQueueAttributesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SQSClient::SetQueueAttributes, request, handler, context);
        }
 
        virtual Model::StartMessageMoveTaskOutcome StartMessageMoveTask(const Model::StartMessageMoveTaskRequest& request) const;
 
        template<typename StartMessageMoveTaskRequestT = Model::StartMessageMoveTaskRequest>
        Model::StartMessageMoveTaskOutcomeCallable StartMessageMoveTaskCallable(const StartMessageMoveTaskRequestT& request) const
        {
            return SubmitCallable(&SQSClient::StartMessageMoveTask, request);
        }
 
        template<typename StartMessageMoveTaskRequestT = Model::StartMessageMoveTaskRequest>
        void StartMessageMoveTaskAsync(const StartMessageMoveTaskRequestT& request, const StartMessageMoveTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SQSClient::StartMessageMoveTask, request, handler, context);
        }
 
        virtual Model::TagQueueOutcome TagQueue(const Model::TagQueueRequest& request) const;
 
        template<typename TagQueueRequestT = Model::TagQueueRequest>
        Model::TagQueueOutcomeCallable TagQueueCallable(const TagQueueRequestT& request) const
        {
            return SubmitCallable(&SQSClient::TagQueue, request);
        }
 
        template<typename TagQueueRequestT = Model::TagQueueRequest>
        void TagQueueAsync(const TagQueueRequestT& request, const TagQueueResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SQSClient::TagQueue, request, handler, context);
        }
 
        virtual Model::UntagQueueOutcome UntagQueue(const Model::UntagQueueRequest& request) const;
 
        template<typename UntagQueueRequestT = Model::UntagQueueRequest>
        Model::UntagQueueOutcomeCallable UntagQueueCallable(const UntagQueueRequestT& request) const
        {
            return SubmitCallable(&SQSClient::UntagQueue, request);
        }
 
        template<typename UntagQueueRequestT = Model::UntagQueueRequest>
        void UntagQueueAsync(const UntagQueueRequestT& request, const UntagQueueResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&SQSClient::UntagQueue, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<SQSEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<SQSClient>;
      void init(const SQSClientConfiguration& clientConfiguration);
 
      SQSClientConfiguration m_clientConfiguration;
      std::shared_ptr<SQSEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace SQS
} // namespace Aws