SQSClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/sqs/SQSPaginationBase.h>
#include <aws/sqs/SQSServiceClientModel.h>
#include <aws/sqs/SQS_EXPORTS.h>
 
namespace Aws {
namespace SQS {
class AWS_SQS_API SQSClient : public Aws::Client::AWSJsonClient,
                              public Aws::Client::ClientWithAsyncTemplateMethods<SQSClient>,
                              public SQSPaginationBase<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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual 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