1 /*
2  * Copyright 2015-2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
3  * 
4  * Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with
5  * the License. A copy of the License is located at
6  * 
7  * http://aws.amazon.com/apache2.0
8  * 
9  * or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
10  * CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions
11  * and limitations under the License.
12  */
13 package com.amazonaws.services.sqs;
14
15 import static java.util.concurrent.Executors.newFixedThreadPool;
16
17 import javax.annotation.Generated;
18
19 import com.amazonaws.services.sqs.model.*;
20 import com.amazonaws.client.AwsAsyncClientParams;
21 import com.amazonaws.annotation.ThreadSafe;
22 import com.amazonaws.ClientConfiguration;
23 import com.amazonaws.auth.AWSCredentials;
24 import com.amazonaws.auth.AWSCredentialsProvider;
25 import java.util.concurrent.ExecutorService;
26 import com.amazonaws.auth.DefaultAWSCredentialsProviderChain;
27
28 /**
29  * Client for accessing Amazon SQS asynchronously. Each asynchronous method will return a Java Future object
30  * representing the asynchronous operation; overloads which accept an {@code AsyncHandler} can be used to receive
31  * notification when an asynchronous operation completes.
32  * <p>
33  * <p>
34  * Welcome to the <i>Amazon Simple Queue Service API Reference</i>.
35  * </p>
36  * <p>
37  * Amazon Simple Queue Service (Amazon SQS) is a reliable, highly-scalable hosted queue for storing messages as they
38  * travel between applications or microservices. Amazon SQS moves data between distributed application components and
39  * helps you decouple these components.
40  * </p>
41  * <p>
42  * You can use <a href="http://aws.amazon.com/tools/#sdk">AWS SDKs</a> to access Amazon SQS using your favorite
43  * programming language. The SDKs perform tasks such as the following automatically:
44  * </p>
45  * <ul>
46  * <li>
47  * <p>
48  * Cryptographically sign your service requests
49  * </p>
50  * </li>
51  * <li>
52  * <p>
53  * Retry requests
54  * </p>
55  * </li>
56  * <li>
57  * <p>
58  * Handle error responses
59  * </p>
60  * </li>
61  * </ul>
62  * <p>
63  * <b>Additional Information</b>
64  * </p>
65  * <ul>
66  * <li>
67  * <p>
68  * <a href="http://aws.amazon.com/sqs/">Amazon SQS Product Page</a>
69  * </p>
70  * </li>
71  * <li>
72  * <p>
73  * <i>Amazon Simple Queue Service Developer Guide</i>
74  * </p>
75  * <ul>
76  * <li>
77  * <p>
78  * <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-making-api-requests.html">
79  * Making API Requests</a>
80  * </p>
81  * </li>
82  * <li>
83  * <p>
84  * <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-message-attributes.html">
85  * Amazon SQS Message Attributes</a>
86  * </p>
87  * </li>
88  * <li>
89  * <p>
90  * <a href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-dead-letter-queues.html">
91  * Amazon SQS Dead-Letter Queues</a>
92  * </p>
93  * </li>
94  * </ul>
95  * </li>
96  * <li>
97  * <p>
98  * <a href="http://docs.aws.amazon.com/cli/latest/reference/sqs/index.html">Amazon SQS in the <i>AWS CLI Command
99  * Reference</i> </a>
100  * </p>
101  * </li>
102  * <li>
103  * <p>
104  * <i>Amazon Web Services General Reference</i>
105  * </p>
106  * <ul>
107  * <li>
108  * <p>
109  * <a href="https://docs.aws.amazon.com/general/latest/gr/rande.html#sqs_region">Regions and Endpoints</a>
110  * </p>
111  * </li>
112  * </ul>
113  * </li>
114  * </ul>
115  */
116 @ThreadSafe
117 @Generated("com.amazonaws:aws-java-sdk-code-generator")
118 public class AmazonSQSAsyncClient extends AmazonSQSClient implements AmazonSQSAsync {
119
120     private static final int DEFAULT_THREAD_POOL_SIZE = 50;
121
122     private final java.util.concurrent.ExecutorService executorService;
123
124     /**
125      * Constructs a new asynchronous client to invoke service methods on Amazon SQS. A credentials provider chain will
126      * be used that searches for credentials in this order:
127      * <ul>
128      * <li>Environment Variables - AWS_ACCESS_KEY_ID and AWS_SECRET_KEY</li>
129      * <li>Java System Properties - aws.accessKeyId and aws.secretKey</li>
130      * <li>Credential profiles file at the default location (~/.aws/credentials) shared by all AWS SDKs and the AWS CLI</li>
131      * <li>Instance profile credentials delivered through the Amazon EC2 metadata service</li>
132      * </ul>
133      * <p>
134      * Asynchronous methods are delegated to a fixed-size thread pool containing 50 threads (to match the default
135      * maximum number of concurrent connections to the service).
136      *
137      * @see com.amazonaws.auth.DefaultAWSCredentialsProviderChain
138      * @see java.util.concurrent.Executors#newFixedThreadPool(int)
139      * @deprecated use {@link AmazonSQSAsyncClientBuilder#defaultClient()}
140      */
141     @Deprecated
142     public AmazonSQSAsyncClient() {
143         this(DefaultAWSCredentialsProviderChain.getInstance());
144     }
145
146     /**
147      * Constructs a new asynchronous client to invoke service methods on Amazon SQS. A credentials provider chain will
148      * be used that searches for credentials in this order:
149      * <ul>
150      * <li>Environment Variables - AWS_ACCESS_KEY_ID and AWS_SECRET_KEY</li>
151      * <li>Java System Properties - aws.accessKeyId and aws.secretKey</li>
152      * <li>Credential profiles file at the default location (~/.aws/credentials) shared by all AWS SDKs and the AWS CLI</li>
153      * <li>Instance profile credentials delivered through the Amazon EC2 metadata service</li>
154      * </ul>
155      * <p>
156      * Asynchronous methods are delegated to a fixed-size thread pool containing a number of threads equal to the
157      * maximum number of concurrent connections configured via {@code ClientConfiguration.getMaxConnections()}.
158      *
159      * @param clientConfiguration
160      *        The client configuration options controlling how this client connects to Amazon SQS (ex: proxy settings,
161      *        retry counts, etc).
162      *
163      * @see com.amazonaws.auth.DefaultAWSCredentialsProviderChain
164      * @see java.util.concurrent.Executors#newFixedThreadPool(int)
165      * @deprecated use {@link AmazonSQSAsyncClientBuilder#withClientConfiguration(ClientConfiguration)}
166      */
167     @Deprecated
168     public AmazonSQSAsyncClient(ClientConfiguration clientConfiguration) {
169         this(DefaultAWSCredentialsProviderChain.getInstance(), clientConfiguration, newFixedThreadPool(clientConfiguration.getMaxConnections()));
170     }
171
172     /**
173      * Constructs a new asynchronous client to invoke service methods on Amazon SQS using the specified AWS account
174      * credentials.
175      * <p>
176      * Asynchronous methods are delegated to a fixed-size thread pool containing 50 threads (to match the default
177      * maximum number of concurrent connections to the service).
178      *
179      * @param awsCredentials
180      *        The AWS credentials (access key ID and secret key) to use when authenticating with AWS services.
181      * @see java.util.concurrent.Executors#newFixedThreadPool(int)
182      * @deprecated use {@link AmazonSQSAsyncClientBuilder#withCredentials(AWSCredentialsProvider)}
183      */
184     @Deprecated
185     public AmazonSQSAsyncClient(AWSCredentials awsCredentials) {
186         this(awsCredentials, newFixedThreadPool(DEFAULT_THREAD_POOL_SIZE));
187     }
188
189     /**
190      * Constructs a new asynchronous client to invoke service methods on Amazon SQS using the specified AWS account
191      * credentials and executor service. Default client settings will be used.
192      *
193      * @param awsCredentials
194      *        The AWS credentials (access key ID and secret key) to use when authenticating with AWS services.
195      * @param executorService
196      *        The executor service by which all asynchronous requests will be executed.
197      * @deprecated use {@link AmazonSQSAsyncClientBuilder#withCredentials(AWSCredentialsProvider)} and
198      *             {@link AmazonSQSAsyncClientBuilder#withExecutorFactory(com.amazonaws.client.builder.ExecutorFactory)}
199      */
200     @Deprecated
201     public AmazonSQSAsyncClient(AWSCredentials awsCredentials, ExecutorService executorService) {
202
203         this(awsCredentials, configFactory.getConfig(), executorService);
204     }
205
206     /**
207      * Constructs a new asynchronous client to invoke service methods on Amazon SQS using the specified AWS account
208      * credentials, executor service, and client configuration options.
209      *
210      * @param awsCredentials
211      *        The AWS credentials (access key ID and secret key) to use when authenticating with AWS services.
212      * @param clientConfiguration
213      *        Client configuration options (ex: max retry limit, proxy settings, etc).
214      * @param executorService
215      *        The executor service by which all asynchronous requests will be executed.
216      * @deprecated use {@link AmazonSQSAsyncClientBuilder#withCredentials(AWSCredentialsProvider)} and
217      *             {@link AmazonSQSAsyncClientBuilder#withClientConfiguration(ClientConfiguration)} and
218      *             {@link AmazonSQSAsyncClientBuilder#withExecutorFactory(com.amazonaws.client.builder.ExecutorFactory)}
219      */
220     @Deprecated
221     public AmazonSQSAsyncClient(AWSCredentials awsCredentials, ClientConfiguration clientConfiguration, ExecutorService executorService) {
222         super(awsCredentials, clientConfiguration);
223         this.executorService = executorService;
224     }
225
226     /**
227      * Constructs a new asynchronous client to invoke service methods on Amazon SQS using the specified AWS account
228      * credentials provider. Default client settings will be used.
229      * <p>
230      * Asynchronous methods are delegated to a fixed-size thread pool containing 50 threads (to match the default
231      * maximum number of concurrent connections to the service).
232      *
233      * @param awsCredentialsProvider
234      *        The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
235      * @see java.util.concurrent.Executors#newFixedThreadPool(int)
236      * @deprecated use {@link AmazonSQSAsyncClientBuilder#withCredentials(AWSCredentialsProvider)}
237      */
238     @Deprecated
239     public AmazonSQSAsyncClient(AWSCredentialsProvider awsCredentialsProvider) {
240         this(awsCredentialsProvider, newFixedThreadPool(DEFAULT_THREAD_POOL_SIZE));
241     }
242
243     /**
244      * Constructs a new asynchronous client to invoke service methods on Amazon SQS using the provided AWS account
245      * credentials provider and client configuration options.
246      * <p>
247      * Asynchronous methods are delegated to a fixed-size thread pool containing a number of threads equal to the
248      * maximum number of concurrent connections configured via {@code ClientConfiguration.getMaxConnections()}.
249      *
250      * @param awsCredentialsProvider
251      *        The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
252      * @param clientConfiguration
253      *        Client configuration options (ex: max retry limit, proxy settings, etc).
254      *
255      * @see com.amazonaws.auth.DefaultAWSCredentialsProviderChain
256      * @see java.util.concurrent.Executors#newFixedThreadPool(int)
257      * @deprecated use {@link AmazonSQSAsyncClientBuilder#withCredentials(AWSCredentialsProvider)} and
258      *             {@link AmazonSQSAsyncClientBuilder#withClientConfiguration(ClientConfiguration)}
259      */
260     @Deprecated
261     public AmazonSQSAsyncClient(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration) {
262         this(awsCredentialsProvider, clientConfiguration, newFixedThreadPool(clientConfiguration.getMaxConnections()));
263     }
264
265     /**
266      * Constructs a new asynchronous client to invoke service methods on Amazon SQS using the specified AWS account
267      * credentials provider and executor service. Default client settings will be used.
268      *
269      * @param awsCredentialsProvider
270      *        The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
271      * @param executorService
272      *        The executor service by which all asynchronous requests will be executed.
273      * @deprecated use {@link AmazonSQSAsyncClientBuilder#withCredentials(AWSCredentialsProvider)} and
274      *             {@link AmazonSQSAsyncClientBuilder#withExecutorFactory(com.amazonaws.client.builder.ExecutorFactory)}
275      */
276     @Deprecated
277     public AmazonSQSAsyncClient(AWSCredentialsProvider awsCredentialsProvider, ExecutorService executorService) {
278         this(awsCredentialsProvider, configFactory.getConfig(), executorService);
279     }
280
281     /**
282      * Constructs a new asynchronous client to invoke service methods on Amazon SQS using the specified AWS account
283      * credentials provider, executor service, and client configuration options.
284      *
285      * @param awsCredentialsProvider
286      *        The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
287      * @param clientConfiguration
288      *        Client configuration options (ex: max retry limit, proxy settings, etc).
289      * @param executorService
290      *        The executor service by which all asynchronous requests will be executed.
291      * @deprecated use {@link AmazonSQSAsyncClientBuilder#withCredentials(AWSCredentialsProvider)} and
292      *             {@link AmazonSQSAsyncClientBuilder#withClientConfiguration(ClientConfiguration)} and
293      *             {@link AmazonSQSAsyncClientBuilder#withExecutorFactory(com.amazonaws.client.builder.ExecutorFactory)}
294      */
295     @Deprecated
296     public AmazonSQSAsyncClient(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration, ExecutorService executorService) {
297         super(awsCredentialsProvider, clientConfiguration);
298         this.executorService = executorService;
299     }
300
301     public static AmazonSQSAsyncClientBuilder asyncBuilder() {
302         return AmazonSQSAsyncClientBuilder.standard();
303     }
304
305     /**
306      * Constructs a new asynchronous client to invoke service methods on Amazon SQS using the specified parameters.
307      *
308      * @param asyncClientParams
309      *        Object providing client parameters.
310      */
311     AmazonSQSAsyncClient(AwsAsyncClientParams asyncClientParams) {
312         this(asyncClientParams, false);
313     }
314
315     /**
316      * Constructs a new asynchronous client to invoke service methods on Amazon SQS using the specified parameters.
317      *
318      * @param asyncClientParams
319      *        Object providing client parameters.
320      * @param endpointDiscoveryEnabled
321      *        true will enable endpoint discovery if the service supports it.
322      */
323     AmazonSQSAsyncClient(AwsAsyncClientParams asyncClientParams, boolean endpointDiscoveryEnabled) {
324         super(asyncClientParams, endpointDiscoveryEnabled);
325         this.executorService = asyncClientParams.getExecutor();
326     }
327
328     /**
329      * Returns the executor service used by this client to execute async requests.
330      *
331      * @return The executor service used by this client to execute async requests.
332      */
333     public ExecutorService getExecutorService() {
334         return executorService;
335     }
336
337     @Override
338     public java.util.concurrent.Future<AddPermissionResult> addPermissionAsync(AddPermissionRequest request) {
339
340         return addPermissionAsync(request, null);
341     }
342
343     @Override
344     public java.util.concurrent.Future<AddPermissionResult> addPermissionAsync(final AddPermissionRequest request,
345             final com.amazonaws.handlers.AsyncHandler<AddPermissionRequest, AddPermissionResult> asyncHandler) {
346         final AddPermissionRequest finalRequest = beforeClientExecution(request);
347
348         return executorService.submit(new java.util.concurrent.Callable<AddPermissionResult>() {
349             @Override
350             public AddPermissionResult call() throws Exception {
351                 AddPermissionResult result = null;
352
353                 try {
354                     result = executeAddPermission(finalRequest);
355                 } catch (Exception ex) {
356                     if (asyncHandler != null) {
357                         asyncHandler.onError(ex);
358                     }
359                     throw ex;
360                 }
361
362                 if (asyncHandler != null) {
363                     asyncHandler.onSuccess(finalRequest, result);
364                 }
365                 return result;
366             }
367         });
368     }
369
370     /**
371      * Simplified method form for invoking the AddPermission operation.
372      *
373      * @see #addPermissionAsync(AddPermissionRequest)
374      */
375     @Override
376     public java.util.concurrent.Future<AddPermissionResult> addPermissionAsync(String queueUrl, String label, java.util.List<String> aWSAccountIds,
377             java.util.List<String> actions) {
378
379         return addPermissionAsync(new AddPermissionRequest().withQueueUrl(queueUrl).withLabel(label).withAWSAccountIds(aWSAccountIds).withActions(actions));
380     }
381
382     /**
383      * Simplified method form for invoking the AddPermission operation with an AsyncHandler.
384      *
385      * @see #addPermissionAsync(AddPermissionRequest, com.amazonaws.handlers.AsyncHandler)
386      */
387     @Override
388     public java.util.concurrent.Future<AddPermissionResult> addPermissionAsync(String queueUrl, String label, java.util.List<String> aWSAccountIds,
389             java.util.List<String> actions, com.amazonaws.handlers.AsyncHandler<AddPermissionRequest, AddPermissionResult> asyncHandler) {
390
391         return addPermissionAsync(new AddPermissionRequest().withQueueUrl(queueUrl).withLabel(label).withAWSAccountIds(aWSAccountIds).withActions(actions),
392                 asyncHandler);
393     }
394
395     @Override
396     public java.util.concurrent.Future<ChangeMessageVisibilityResult> changeMessageVisibilityAsync(ChangeMessageVisibilityRequest request) {
397
398         return changeMessageVisibilityAsync(request, null);
399     }
400
401     @Override
402     public java.util.concurrent.Future<ChangeMessageVisibilityResult> changeMessageVisibilityAsync(final ChangeMessageVisibilityRequest request,
403             final com.amazonaws.handlers.AsyncHandler<ChangeMessageVisibilityRequest, ChangeMessageVisibilityResult> asyncHandler) {
404         final ChangeMessageVisibilityRequest finalRequest = beforeClientExecution(request);
405
406         return executorService.submit(new java.util.concurrent.Callable<ChangeMessageVisibilityResult>() {
407             @Override
408             public ChangeMessageVisibilityResult call() throws Exception {
409                 ChangeMessageVisibilityResult result = null;
410
411                 try {
412                     result = executeChangeMessageVisibility(finalRequest);
413                 } catch (Exception ex) {
414                     if (asyncHandler != null) {
415                         asyncHandler.onError(ex);
416                     }
417                     throw ex;
418                 }
419
420                 if (asyncHandler != null) {
421                     asyncHandler.onSuccess(finalRequest, result);
422                 }
423                 return result;
424             }
425         });
426     }
427
428     /**
429      * Simplified method form for invoking the ChangeMessageVisibility operation.
430      *
431      * @see #changeMessageVisibilityAsync(ChangeMessageVisibilityRequest)
432      */
433     @Override
434     public java.util.concurrent.Future<ChangeMessageVisibilityResult> changeMessageVisibilityAsync(String queueUrl, String receiptHandle,
435             Integer visibilityTimeout) {
436
437         return changeMessageVisibilityAsync(new ChangeMessageVisibilityRequest().withQueueUrl(queueUrl).withReceiptHandle(receiptHandle)
438                 .withVisibilityTimeout(visibilityTimeout));
439     }
440
441     /**
442      * Simplified method form for invoking the ChangeMessageVisibility operation with an AsyncHandler.
443      *
444      * @see #changeMessageVisibilityAsync(ChangeMessageVisibilityRequest, com.amazonaws.handlers.AsyncHandler)
445      */
446     @Override
447     public java.util.concurrent.Future<ChangeMessageVisibilityResult> changeMessageVisibilityAsync(String queueUrl, String receiptHandle,
448             Integer visibilityTimeout, com.amazonaws.handlers.AsyncHandler<ChangeMessageVisibilityRequest, ChangeMessageVisibilityResult> asyncHandler) {
449
450         return changeMessageVisibilityAsync(
451                 new ChangeMessageVisibilityRequest().withQueueUrl(queueUrl).withReceiptHandle(receiptHandle).withVisibilityTimeout(visibilityTimeout),
452                 asyncHandler);
453     }
454
455     @Override
456     public java.util.concurrent.Future<ChangeMessageVisibilityBatchResult> changeMessageVisibilityBatchAsync(ChangeMessageVisibilityBatchRequest request) {
457
458         return changeMessageVisibilityBatchAsync(request, null);
459     }
460
461     @Override
462     public java.util.concurrent.Future<ChangeMessageVisibilityBatchResult> changeMessageVisibilityBatchAsync(final ChangeMessageVisibilityBatchRequest request,
463             final com.amazonaws.handlers.AsyncHandler<ChangeMessageVisibilityBatchRequest, ChangeMessageVisibilityBatchResult> asyncHandler) {
464         final ChangeMessageVisibilityBatchRequest finalRequest = beforeClientExecution(request);
465
466         return executorService.submit(new java.util.concurrent.Callable<ChangeMessageVisibilityBatchResult>() {
467             @Override
468             public ChangeMessageVisibilityBatchResult call() throws Exception {
469                 ChangeMessageVisibilityBatchResult result = null;
470
471                 try {
472                     result = executeChangeMessageVisibilityBatch(finalRequest);
473                 } catch (Exception ex) {
474                     if (asyncHandler != null) {
475                         asyncHandler.onError(ex);
476                     }
477                     throw ex;
478                 }
479
480                 if (asyncHandler != null) {
481                     asyncHandler.onSuccess(finalRequest, result);
482                 }
483                 return result;
484             }
485         });
486     }
487
488     /**
489      * Simplified method form for invoking the ChangeMessageVisibilityBatch operation.
490      *
491      * @see #changeMessageVisibilityBatchAsync(ChangeMessageVisibilityBatchRequest)
492      */
493     @Override
494     public java.util.concurrent.Future<ChangeMessageVisibilityBatchResult> changeMessageVisibilityBatchAsync(String queueUrl,
495             java.util.List<ChangeMessageVisibilityBatchRequestEntry> entries) {
496
497         return changeMessageVisibilityBatchAsync(new ChangeMessageVisibilityBatchRequest().withQueueUrl(queueUrl).withEntries(entries));
498     }
499
500     /**
501      * Simplified method form for invoking the ChangeMessageVisibilityBatch operation with an AsyncHandler.
502      *
503      * @see #changeMessageVisibilityBatchAsync(ChangeMessageVisibilityBatchRequest, com.amazonaws.handlers.AsyncHandler)
504      */
505     @Override
506     public java.util.concurrent.Future<ChangeMessageVisibilityBatchResult> changeMessageVisibilityBatchAsync(String queueUrl,
507             java.util.List<ChangeMessageVisibilityBatchRequestEntry> entries,
508             com.amazonaws.handlers.AsyncHandler<ChangeMessageVisibilityBatchRequest, ChangeMessageVisibilityBatchResult> asyncHandler) {
509
510         return changeMessageVisibilityBatchAsync(new ChangeMessageVisibilityBatchRequest().withQueueUrl(queueUrl).withEntries(entries), asyncHandler);
511     }
512
513     @Override
514     public java.util.concurrent.Future<CreateQueueResult> createQueueAsync(CreateQueueRequest request) {
515
516         return createQueueAsync(request, null);
517     }
518
519     @Override
520     public java.util.concurrent.Future<CreateQueueResult> createQueueAsync(final CreateQueueRequest request,
521             final com.amazonaws.handlers.AsyncHandler<CreateQueueRequest, CreateQueueResult> asyncHandler) {
522         final CreateQueueRequest finalRequest = beforeClientExecution(request);
523
524         return executorService.submit(new java.util.concurrent.Callable<CreateQueueResult>() {
525             @Override
526             public CreateQueueResult call() throws Exception {
527                 CreateQueueResult result = null;
528
529                 try {
530                     result = executeCreateQueue(finalRequest);
531                 } catch (Exception ex) {
532                     if (asyncHandler != null) {
533                         asyncHandler.onError(ex);
534                     }
535                     throw ex;
536                 }
537
538                 if (asyncHandler != null) {
539                     asyncHandler.onSuccess(finalRequest, result);
540                 }
541                 return result;
542             }
543         });
544     }
545
546     /**
547      * Simplified method form for invoking the CreateQueue operation.
548      *
549      * @see #createQueueAsync(CreateQueueRequest)
550      */
551     @Override
552     public java.util.concurrent.Future<CreateQueueResult> createQueueAsync(String queueName) {
553
554         return createQueueAsync(new CreateQueueRequest().withQueueName(queueName));
555     }
556
557     /**
558      * Simplified method form for invoking the CreateQueue operation with an AsyncHandler.
559      *
560      * @see #createQueueAsync(CreateQueueRequest, com.amazonaws.handlers.AsyncHandler)
561      */
562     @Override
563     public java.util.concurrent.Future<CreateQueueResult> createQueueAsync(String queueName,
564             com.amazonaws.handlers.AsyncHandler<CreateQueueRequest, CreateQueueResult> asyncHandler) {
565
566         return createQueueAsync(new CreateQueueRequest().withQueueName(queueName), asyncHandler);
567     }
568
569     @Override
570     public java.util.concurrent.Future<DeleteMessageResult> deleteMessageAsync(DeleteMessageRequest request) {
571
572         return deleteMessageAsync(request, null);
573     }
574
575     @Override
576     public java.util.concurrent.Future<DeleteMessageResult> deleteMessageAsync(final DeleteMessageRequest request,
577             final com.amazonaws.handlers.AsyncHandler<DeleteMessageRequest, DeleteMessageResult> asyncHandler) {
578         final DeleteMessageRequest finalRequest = beforeClientExecution(request);
579
580         return executorService.submit(new java.util.concurrent.Callable<DeleteMessageResult>() {
581             @Override
582             public DeleteMessageResult call() throws Exception {
583                 DeleteMessageResult result = null;
584
585                 try {
586                     result = executeDeleteMessage(finalRequest);
587                 } catch (Exception ex) {
588                     if (asyncHandler != null) {
589                         asyncHandler.onError(ex);
590                     }
591                     throw ex;
592                 }
593
594                 if (asyncHandler != null) {
595                     asyncHandler.onSuccess(finalRequest, result);
596                 }
597                 return result;
598             }
599         });
600     }
601
602     /**
603      * Simplified method form for invoking the DeleteMessage operation.
604      *
605      * @see #deleteMessageAsync(DeleteMessageRequest)
606      */
607     @Override
608     public java.util.concurrent.Future<DeleteMessageResult> deleteMessageAsync(String queueUrl, String receiptHandle) {
609
610         return deleteMessageAsync(new DeleteMessageRequest().withQueueUrl(queueUrl).withReceiptHandle(receiptHandle));
611     }
612
613     /**
614      * Simplified method form for invoking the DeleteMessage operation with an AsyncHandler.
615      *
616      * @see #deleteMessageAsync(DeleteMessageRequest, com.amazonaws.handlers.AsyncHandler)
617      */
618     @Override
619     public java.util.concurrent.Future<DeleteMessageResult> deleteMessageAsync(String queueUrl, String receiptHandle,
620             com.amazonaws.handlers.AsyncHandler<DeleteMessageRequest, DeleteMessageResult> asyncHandler) {
621
622         return deleteMessageAsync(new DeleteMessageRequest().withQueueUrl(queueUrl).withReceiptHandle(receiptHandle), asyncHandler);
623     }
624
625     @Override
626     public java.util.concurrent.Future<DeleteMessageBatchResult> deleteMessageBatchAsync(DeleteMessageBatchRequest request) {
627
628         return deleteMessageBatchAsync(request, null);
629     }
630
631     @Override
632     public java.util.concurrent.Future<DeleteMessageBatchResult> deleteMessageBatchAsync(final DeleteMessageBatchRequest request,
633             final com.amazonaws.handlers.AsyncHandler<DeleteMessageBatchRequest, DeleteMessageBatchResult> asyncHandler) {
634         final DeleteMessageBatchRequest finalRequest = beforeClientExecution(request);
635
636         return executorService.submit(new java.util.concurrent.Callable<DeleteMessageBatchResult>() {
637             @Override
638             public DeleteMessageBatchResult call() throws Exception {
639                 DeleteMessageBatchResult result = null;
640
641                 try {
642                     result = executeDeleteMessageBatch(finalRequest);
643                 } catch (Exception ex) {
644                     if (asyncHandler != null) {
645                         asyncHandler.onError(ex);
646                     }
647                     throw ex;
648                 }
649
650                 if (asyncHandler != null) {
651                     asyncHandler.onSuccess(finalRequest, result);
652                 }
653                 return result;
654             }
655         });
656     }
657
658     /**
659      * Simplified method form for invoking the DeleteMessageBatch operation.
660      *
661      * @see #deleteMessageBatchAsync(DeleteMessageBatchRequest)
662      */
663     @Override
664     public java.util.concurrent.Future<DeleteMessageBatchResult> deleteMessageBatchAsync(String queueUrl, java.util.List<DeleteMessageBatchRequestEntry> entries) {
665
666         return deleteMessageBatchAsync(new DeleteMessageBatchRequest().withQueueUrl(queueUrl).withEntries(entries));
667     }
668
669     /**
670      * Simplified method form for invoking the DeleteMessageBatch operation with an AsyncHandler.
671      *
672      * @see #deleteMessageBatchAsync(DeleteMessageBatchRequest, com.amazonaws.handlers.AsyncHandler)
673      */
674     @Override
675     public java.util.concurrent.Future<DeleteMessageBatchResult> deleteMessageBatchAsync(String queueUrl,
676             java.util.List<DeleteMessageBatchRequestEntry> entries,
677             com.amazonaws.handlers.AsyncHandler<DeleteMessageBatchRequest, DeleteMessageBatchResult> asyncHandler) {
678
679         return deleteMessageBatchAsync(new DeleteMessageBatchRequest().withQueueUrl(queueUrl).withEntries(entries), asyncHandler);
680     }
681
682     @Override
683     public java.util.concurrent.Future<DeleteQueueResult> deleteQueueAsync(DeleteQueueRequest request) {
684
685         return deleteQueueAsync(request, null);
686     }
687
688     @Override
689     public java.util.concurrent.Future<DeleteQueueResult> deleteQueueAsync(final DeleteQueueRequest request,
690             final com.amazonaws.handlers.AsyncHandler<DeleteQueueRequest, DeleteQueueResult> asyncHandler) {
691         final DeleteQueueRequest finalRequest = beforeClientExecution(request);
692
693         return executorService.submit(new java.util.concurrent.Callable<DeleteQueueResult>() {
694             @Override
695             public DeleteQueueResult call() throws Exception {
696                 DeleteQueueResult result = null;
697
698                 try {
699                     result = executeDeleteQueue(finalRequest);
700                 } catch (Exception ex) {
701                     if (asyncHandler != null) {
702                         asyncHandler.onError(ex);
703                     }
704                     throw ex;
705                 }
706
707                 if (asyncHandler != null) {
708                     asyncHandler.onSuccess(finalRequest, result);
709                 }
710                 return result;
711             }
712         });
713     }
714
715     /**
716      * Simplified method form for invoking the DeleteQueue operation.
717      *
718      * @see #deleteQueueAsync(DeleteQueueRequest)
719      */
720     @Override
721     public java.util.concurrent.Future<DeleteQueueResult> deleteQueueAsync(String queueUrl) {
722
723         return deleteQueueAsync(new DeleteQueueRequest().withQueueUrl(queueUrl));
724     }
725
726     /**
727      * Simplified method form for invoking the DeleteQueue operation with an AsyncHandler.
728      *
729      * @see #deleteQueueAsync(DeleteQueueRequest, com.amazonaws.handlers.AsyncHandler)
730      */
731     @Override
732     public java.util.concurrent.Future<DeleteQueueResult> deleteQueueAsync(String queueUrl,
733             com.amazonaws.handlers.AsyncHandler<DeleteQueueRequest, DeleteQueueResult> asyncHandler) {
734
735         return deleteQueueAsync(new DeleteQueueRequest().withQueueUrl(queueUrl), asyncHandler);
736     }
737
738     @Override
739     public java.util.concurrent.Future<GetQueueAttributesResult> getQueueAttributesAsync(GetQueueAttributesRequest request) {
740
741         return getQueueAttributesAsync(request, null);
742     }
743
744     @Override
745     public java.util.concurrent.Future<GetQueueAttributesResult> getQueueAttributesAsync(final GetQueueAttributesRequest request,
746             final com.amazonaws.handlers.AsyncHandler<GetQueueAttributesRequest, GetQueueAttributesResult> asyncHandler) {
747         final GetQueueAttributesRequest finalRequest = beforeClientExecution(request);
748
749         return executorService.submit(new java.util.concurrent.Callable<GetQueueAttributesResult>() {
750             @Override
751             public GetQueueAttributesResult call() throws Exception {
752                 GetQueueAttributesResult result = null;
753
754                 try {
755                     result = executeGetQueueAttributes(finalRequest);
756                 } catch (Exception ex) {
757                     if (asyncHandler != null) {
758                         asyncHandler.onError(ex);
759                     }
760                     throw ex;
761                 }
762
763                 if (asyncHandler != null) {
764                     asyncHandler.onSuccess(finalRequest, result);
765                 }
766                 return result;
767             }
768         });
769     }
770
771     /**
772      * Simplified method form for invoking the GetQueueAttributes operation.
773      *
774      * @see #getQueueAttributesAsync(GetQueueAttributesRequest)
775      */
776     @Override
777     public java.util.concurrent.Future<GetQueueAttributesResult> getQueueAttributesAsync(String queueUrl, java.util.List<String> attributeNames) {
778
779         return getQueueAttributesAsync(new GetQueueAttributesRequest().withQueueUrl(queueUrl).withAttributeNames(attributeNames));
780     }
781
782     /**
783      * Simplified method form for invoking the GetQueueAttributes operation with an AsyncHandler.
784      *
785      * @see #getQueueAttributesAsync(GetQueueAttributesRequest, com.amazonaws.handlers.AsyncHandler)
786      */
787     @Override
788     public java.util.concurrent.Future<GetQueueAttributesResult> getQueueAttributesAsync(String queueUrl, java.util.List<String> attributeNames,
789             com.amazonaws.handlers.AsyncHandler<GetQueueAttributesRequest, GetQueueAttributesResult> asyncHandler) {
790
791         return getQueueAttributesAsync(new GetQueueAttributesRequest().withQueueUrl(queueUrl).withAttributeNames(attributeNames), asyncHandler);
792     }
793
794     @Override
795     public java.util.concurrent.Future<GetQueueUrlResult> getQueueUrlAsync(GetQueueUrlRequest request) {
796
797         return getQueueUrlAsync(request, null);
798     }
799
800     @Override
801     public java.util.concurrent.Future<GetQueueUrlResult> getQueueUrlAsync(final GetQueueUrlRequest request,
802             final com.amazonaws.handlers.AsyncHandler<GetQueueUrlRequest, GetQueueUrlResult> asyncHandler) {
803         final GetQueueUrlRequest finalRequest = beforeClientExecution(request);
804
805         return executorService.submit(new java.util.concurrent.Callable<GetQueueUrlResult>() {
806             @Override
807             public GetQueueUrlResult call() throws Exception {
808                 GetQueueUrlResult result = null;
809
810                 try {
811                     result = executeGetQueueUrl(finalRequest);
812                 } catch (Exception ex) {
813                     if (asyncHandler != null) {
814                         asyncHandler.onError(ex);
815                     }
816                     throw ex;
817                 }
818
819                 if (asyncHandler != null) {
820                     asyncHandler.onSuccess(finalRequest, result);
821                 }
822                 return result;
823             }
824         });
825     }
826
827     /**
828      * Simplified method form for invoking the GetQueueUrl operation.
829      *
830      * @see #getQueueUrlAsync(GetQueueUrlRequest)
831      */
832     @Override
833     public java.util.concurrent.Future<GetQueueUrlResult> getQueueUrlAsync(String queueName) {
834
835         return getQueueUrlAsync(new GetQueueUrlRequest().withQueueName(queueName));
836     }
837
838     /**
839      * Simplified method form for invoking the GetQueueUrl operation with an AsyncHandler.
840      *
841      * @see #getQueueUrlAsync(GetQueueUrlRequest, com.amazonaws.handlers.AsyncHandler)
842      */
843     @Override
844     public java.util.concurrent.Future<GetQueueUrlResult> getQueueUrlAsync(String queueName,
845             com.amazonaws.handlers.AsyncHandler<GetQueueUrlRequest, GetQueueUrlResult> asyncHandler) {
846
847         return getQueueUrlAsync(new GetQueueUrlRequest().withQueueName(queueName), asyncHandler);
848     }
849
850     @Override
851     public java.util.concurrent.Future<ListDeadLetterSourceQueuesResult> listDeadLetterSourceQueuesAsync(ListDeadLetterSourceQueuesRequest request) {
852
853         return listDeadLetterSourceQueuesAsync(request, null);
854     }
855
856     @Override
857     public java.util.concurrent.Future<ListDeadLetterSourceQueuesResult> listDeadLetterSourceQueuesAsync(final ListDeadLetterSourceQueuesRequest request,
858             final com.amazonaws.handlers.AsyncHandler<ListDeadLetterSourceQueuesRequest, ListDeadLetterSourceQueuesResult> asyncHandler) {
859         final ListDeadLetterSourceQueuesRequest finalRequest = beforeClientExecution(request);
860
861         return executorService.submit(new java.util.concurrent.Callable<ListDeadLetterSourceQueuesResult>() {
862             @Override
863             public ListDeadLetterSourceQueuesResult call() throws Exception {
864                 ListDeadLetterSourceQueuesResult result = null;
865
866                 try {
867                     result = executeListDeadLetterSourceQueues(finalRequest);
868                 } catch (Exception ex) {
869                     if (asyncHandler != null) {
870                         asyncHandler.onError(ex);
871                     }
872                     throw ex;
873                 }
874
875                 if (asyncHandler != null) {
876                     asyncHandler.onSuccess(finalRequest, result);
877                 }
878                 return result;
879             }
880         });
881     }
882
883     @Override
884     public java.util.concurrent.Future<ListQueueTagsResult> listQueueTagsAsync(ListQueueTagsRequest request) {
885
886         return listQueueTagsAsync(request, null);
887     }
888
889     @Override
890     public java.util.concurrent.Future<ListQueueTagsResult> listQueueTagsAsync(final ListQueueTagsRequest request,
891             final com.amazonaws.handlers.AsyncHandler<ListQueueTagsRequest, ListQueueTagsResult> asyncHandler) {
892         final ListQueueTagsRequest finalRequest = beforeClientExecution(request);
893
894         return executorService.submit(new java.util.concurrent.Callable<ListQueueTagsResult>() {
895             @Override
896             public ListQueueTagsResult call() throws Exception {
897                 ListQueueTagsResult result = null;
898
899                 try {
900                     result = executeListQueueTags(finalRequest);
901                 } catch (Exception ex) {
902                     if (asyncHandler != null) {
903                         asyncHandler.onError(ex);
904                     }
905                     throw ex;
906                 }
907
908                 if (asyncHandler != null) {
909                     asyncHandler.onSuccess(finalRequest, result);
910                 }
911                 return result;
912             }
913         });
914     }
915
916     /**
917      * Simplified method form for invoking the ListQueueTags operation.
918      *
919      * @see #listQueueTagsAsync(ListQueueTagsRequest)
920      */
921     @Override
922     public java.util.concurrent.Future<ListQueueTagsResult> listQueueTagsAsync(String queueUrl) {
923
924         return listQueueTagsAsync(new ListQueueTagsRequest().withQueueUrl(queueUrl));
925     }
926
927     /**
928      * Simplified method form for invoking the ListQueueTags operation with an AsyncHandler.
929      *
930      * @see #listQueueTagsAsync(ListQueueTagsRequest, com.amazonaws.handlers.AsyncHandler)
931      */
932     @Override
933     public java.util.concurrent.Future<ListQueueTagsResult> listQueueTagsAsync(String queueUrl,
934             com.amazonaws.handlers.AsyncHandler<ListQueueTagsRequest, ListQueueTagsResult> asyncHandler) {
935
936         return listQueueTagsAsync(new ListQueueTagsRequest().withQueueUrl(queueUrl), asyncHandler);
937     }
938
939     @Override
940     public java.util.concurrent.Future<ListQueuesResult> listQueuesAsync(ListQueuesRequest request) {
941
942         return listQueuesAsync(request, null);
943     }
944
945     @Override
946     public java.util.concurrent.Future<ListQueuesResult> listQueuesAsync(final ListQueuesRequest request,
947             final com.amazonaws.handlers.AsyncHandler<ListQueuesRequest, ListQueuesResult> asyncHandler) {
948         final ListQueuesRequest finalRequest = beforeClientExecution(request);
949
950         return executorService.submit(new java.util.concurrent.Callable<ListQueuesResult>() {
951             @Override
952             public ListQueuesResult call() throws Exception {
953                 ListQueuesResult result = null;
954
955                 try {
956                     result = executeListQueues(finalRequest);
957                 } catch (Exception ex) {
958                     if (asyncHandler != null) {
959                         asyncHandler.onError(ex);
960                     }
961                     throw ex;
962                 }
963
964                 if (asyncHandler != null) {
965                     asyncHandler.onSuccess(finalRequest, result);
966                 }
967                 return result;
968             }
969         });
970     }
971
972     /**
973      * Simplified method form for invoking the ListQueues operation.
974      *
975      * @see #listQueuesAsync(ListQueuesRequest)
976      */
977     @Override
978     public java.util.concurrent.Future<ListQueuesResult> listQueuesAsync() {
979
980         return listQueuesAsync(new ListQueuesRequest());
981     }
982
983     /**
984      * Simplified method form for invoking the ListQueues operation with an AsyncHandler.
985      *
986      * @see #listQueuesAsync(ListQueuesRequest, com.amazonaws.handlers.AsyncHandler)
987      */
988     @Override
989     public java.util.concurrent.Future<ListQueuesResult> listQueuesAsync(com.amazonaws.handlers.AsyncHandler<ListQueuesRequest, ListQueuesResult> asyncHandler) {
990
991         return listQueuesAsync(new ListQueuesRequest(), asyncHandler);
992     }
993
994     /**
995      * Simplified method form for invoking the ListQueues operation.
996      *
997      * @see #listQueuesAsync(ListQueuesRequest)
998      */
999     @Override
1000     public java.util.concurrent.Future<ListQueuesResult> listQueuesAsync(String queueNamePrefix) {
1001
1002         return listQueuesAsync(new ListQueuesRequest().withQueueNamePrefix(queueNamePrefix));
1003     }
1004
1005     /**
1006      * Simplified method form for invoking the ListQueues operation with an AsyncHandler.
1007      *
1008      * @see #listQueuesAsync(ListQueuesRequest, com.amazonaws.handlers.AsyncHandler)
1009      */
1010     @Override
1011     public java.util.concurrent.Future<ListQueuesResult> listQueuesAsync(String queueNamePrefix,
1012             com.amazonaws.handlers.AsyncHandler<ListQueuesRequest, ListQueuesResult> asyncHandler) {
1013
1014         return listQueuesAsync(new ListQueuesRequest().withQueueNamePrefix(queueNamePrefix), asyncHandler);
1015     }
1016
1017     @Override
1018     public java.util.concurrent.Future<PurgeQueueResult> purgeQueueAsync(PurgeQueueRequest request) {
1019
1020         return purgeQueueAsync(request, null);
1021     }
1022
1023     @Override
1024     public java.util.concurrent.Future<PurgeQueueResult> purgeQueueAsync(final PurgeQueueRequest request,
1025             final com.amazonaws.handlers.AsyncHandler<PurgeQueueRequest, PurgeQueueResult> asyncHandler) {
1026         final PurgeQueueRequest finalRequest = beforeClientExecution(request);
1027
1028         return executorService.submit(new java.util.concurrent.Callable<PurgeQueueResult>() {
1029             @Override
1030             public PurgeQueueResult call() throws Exception {
1031                 PurgeQueueResult result = null;
1032
1033                 try {
1034                     result = executePurgeQueue(finalRequest);
1035                 } catch (Exception ex) {
1036                     if (asyncHandler != null) {
1037                         asyncHandler.onError(ex);
1038                     }
1039                     throw ex;
1040                 }
1041
1042                 if (asyncHandler != null) {
1043                     asyncHandler.onSuccess(finalRequest, result);
1044                 }
1045                 return result;
1046             }
1047         });
1048     }
1049
1050     @Override
1051     public java.util.concurrent.Future<ReceiveMessageResult> receiveMessageAsync(ReceiveMessageRequest request) {
1052
1053         return receiveMessageAsync(request, null);
1054     }
1055
1056     @Override
1057     public java.util.concurrent.Future<ReceiveMessageResult> receiveMessageAsync(final ReceiveMessageRequest request,
1058             final com.amazonaws.handlers.AsyncHandler<ReceiveMessageRequest, ReceiveMessageResult> asyncHandler) {
1059         final ReceiveMessageRequest finalRequest = beforeClientExecution(request);
1060
1061         return executorService.submit(new java.util.concurrent.Callable<ReceiveMessageResult>() {
1062             @Override
1063             public ReceiveMessageResult call() throws Exception {
1064                 ReceiveMessageResult result = null;
1065
1066                 try {
1067                     result = executeReceiveMessage(finalRequest);
1068                 } catch (Exception ex) {
1069                     if (asyncHandler != null) {
1070                         asyncHandler.onError(ex);
1071                     }
1072                     throw ex;
1073                 }
1074
1075                 if (asyncHandler != null) {
1076                     asyncHandler.onSuccess(finalRequest, result);
1077                 }
1078                 return result;
1079             }
1080         });
1081     }
1082
1083     /**
1084      * Simplified method form for invoking the ReceiveMessage operation.
1085      *
1086      * @see #receiveMessageAsync(ReceiveMessageRequest)
1087      */
1088     @Override
1089     public java.util.concurrent.Future<ReceiveMessageResult> receiveMessageAsync(String queueUrl) {
1090
1091         return receiveMessageAsync(new ReceiveMessageRequest().withQueueUrl(queueUrl));
1092     }
1093
1094     /**
1095      * Simplified method form for invoking the ReceiveMessage operation with an AsyncHandler.
1096      *
1097      * @see #receiveMessageAsync(ReceiveMessageRequest, com.amazonaws.handlers.AsyncHandler)
1098      */
1099     @Override
1100     public java.util.concurrent.Future<ReceiveMessageResult> receiveMessageAsync(String queueUrl,
1101             com.amazonaws.handlers.AsyncHandler<ReceiveMessageRequest, ReceiveMessageResult> asyncHandler) {
1102
1103         return receiveMessageAsync(new ReceiveMessageRequest().withQueueUrl(queueUrl), asyncHandler);
1104     }
1105
1106     @Override
1107     public java.util.concurrent.Future<RemovePermissionResult> removePermissionAsync(RemovePermissionRequest request) {
1108
1109         return removePermissionAsync(request, null);
1110     }
1111
1112     @Override
1113     public java.util.concurrent.Future<RemovePermissionResult> removePermissionAsync(final RemovePermissionRequest request,
1114             final com.amazonaws.handlers.AsyncHandler<RemovePermissionRequest, RemovePermissionResult> asyncHandler) {
1115         final RemovePermissionRequest finalRequest = beforeClientExecution(request);
1116
1117         return executorService.submit(new java.util.concurrent.Callable<RemovePermissionResult>() {
1118             @Override
1119             public RemovePermissionResult call() throws Exception {
1120                 RemovePermissionResult result = null;
1121
1122                 try {
1123                     result = executeRemovePermission(finalRequest);
1124                 } catch (Exception ex) {
1125                     if (asyncHandler != null) {
1126                         asyncHandler.onError(ex);
1127                     }
1128                     throw ex;
1129                 }
1130
1131                 if (asyncHandler != null) {
1132                     asyncHandler.onSuccess(finalRequest, result);
1133                 }
1134                 return result;
1135             }
1136         });
1137     }
1138
1139     /**
1140      * Simplified method form for invoking the RemovePermission operation.
1141      *
1142      * @see #removePermissionAsync(RemovePermissionRequest)
1143      */
1144     @Override
1145     public java.util.concurrent.Future<RemovePermissionResult> removePermissionAsync(String queueUrl, String label) {
1146
1147         return removePermissionAsync(new RemovePermissionRequest().withQueueUrl(queueUrl).withLabel(label));
1148     }
1149
1150     /**
1151      * Simplified method form for invoking the RemovePermission operation with an AsyncHandler.
1152      *
1153      * @see #removePermissionAsync(RemovePermissionRequest, com.amazonaws.handlers.AsyncHandler)
1154      */
1155     @Override
1156     public java.util.concurrent.Future<RemovePermissionResult> removePermissionAsync(String queueUrl, String label,
1157             com.amazonaws.handlers.AsyncHandler<RemovePermissionRequest, RemovePermissionResult> asyncHandler) {
1158
1159         return removePermissionAsync(new RemovePermissionRequest().withQueueUrl(queueUrl).withLabel(label), asyncHandler);
1160     }
1161
1162     @Override
1163     public java.util.concurrent.Future<SendMessageResult> sendMessageAsync(SendMessageRequest request) {
1164
1165         return sendMessageAsync(request, null);
1166     }
1167
1168     @Override
1169     public java.util.concurrent.Future<SendMessageResult> sendMessageAsync(final SendMessageRequest request,
1170             final com.amazonaws.handlers.AsyncHandler<SendMessageRequest, SendMessageResult> asyncHandler) {
1171         final SendMessageRequest finalRequest = beforeClientExecution(request);
1172
1173         return executorService.submit(new java.util.concurrent.Callable<SendMessageResult>() {
1174             @Override
1175             public SendMessageResult call() throws Exception {
1176                 SendMessageResult result = null;
1177
1178                 try {
1179                     result = executeSendMessage(finalRequest);
1180                 } catch (Exception ex) {
1181                     if (asyncHandler != null) {
1182                         asyncHandler.onError(ex);
1183                     }
1184                     throw ex;
1185                 }
1186
1187                 if (asyncHandler != null) {
1188                     asyncHandler.onSuccess(finalRequest, result);
1189                 }
1190                 return result;
1191             }
1192         });
1193     }
1194
1195     /**
1196      * Simplified method form for invoking the SendMessage operation.
1197      *
1198      * @see #sendMessageAsync(SendMessageRequest)
1199      */
1200     @Override
1201     public java.util.concurrent.Future<SendMessageResult> sendMessageAsync(String queueUrl, String messageBody) {
1202
1203         return sendMessageAsync(new SendMessageRequest().withQueueUrl(queueUrl).withMessageBody(messageBody));
1204     }
1205
1206     /**
1207      * Simplified method form for invoking the SendMessage operation with an AsyncHandler.
1208      *
1209      * @see #sendMessageAsync(SendMessageRequest, com.amazonaws.handlers.AsyncHandler)
1210      */
1211     @Override
1212     public java.util.concurrent.Future<SendMessageResult> sendMessageAsync(String queueUrl, String messageBody,
1213             com.amazonaws.handlers.AsyncHandler<SendMessageRequest, SendMessageResult> asyncHandler) {
1214
1215         return sendMessageAsync(new SendMessageRequest().withQueueUrl(queueUrl).withMessageBody(messageBody), asyncHandler);
1216     }
1217
1218     @Override
1219     public java.util.concurrent.Future<SendMessageBatchResult> sendMessageBatchAsync(SendMessageBatchRequest request) {
1220
1221         return sendMessageBatchAsync(request, null);
1222     }
1223
1224     @Override
1225     public java.util.concurrent.Future<SendMessageBatchResult> sendMessageBatchAsync(final SendMessageBatchRequest request,
1226             final com.amazonaws.handlers.AsyncHandler<SendMessageBatchRequest, SendMessageBatchResult> asyncHandler) {
1227         final SendMessageBatchRequest finalRequest = beforeClientExecution(request);
1228
1229         return executorService.submit(new java.util.concurrent.Callable<SendMessageBatchResult>() {
1230             @Override
1231             public SendMessageBatchResult call() throws Exception {
1232                 SendMessageBatchResult result = null;
1233
1234                 try {
1235                     result = executeSendMessageBatch(finalRequest);
1236                 } catch (Exception ex) {
1237                     if (asyncHandler != null) {
1238                         asyncHandler.onError(ex);
1239                     }
1240                     throw ex;
1241                 }
1242
1243                 if (asyncHandler != null) {
1244                     asyncHandler.onSuccess(finalRequest, result);
1245                 }
1246                 return result;
1247             }
1248         });
1249     }
1250
1251     /**
1252      * Simplified method form for invoking the SendMessageBatch operation.
1253      *
1254      * @see #sendMessageBatchAsync(SendMessageBatchRequest)
1255      */
1256     @Override
1257     public java.util.concurrent.Future<SendMessageBatchResult> sendMessageBatchAsync(String queueUrl, java.util.List<SendMessageBatchRequestEntry> entries) {
1258
1259         return sendMessageBatchAsync(new SendMessageBatchRequest().withQueueUrl(queueUrl).withEntries(entries));
1260     }
1261
1262     /**
1263      * Simplified method form for invoking the SendMessageBatch operation with an AsyncHandler.
1264      *
1265      * @see #sendMessageBatchAsync(SendMessageBatchRequest, com.amazonaws.handlers.AsyncHandler)
1266      */
1267     @Override
1268     public java.util.concurrent.Future<SendMessageBatchResult> sendMessageBatchAsync(String queueUrl, java.util.List<SendMessageBatchRequestEntry> entries,
1269             com.amazonaws.handlers.AsyncHandler<SendMessageBatchRequest, SendMessageBatchResult> asyncHandler) {
1270
1271         return sendMessageBatchAsync(new SendMessageBatchRequest().withQueueUrl(queueUrl).withEntries(entries), asyncHandler);
1272     }
1273
1274     @Override
1275     public java.util.concurrent.Future<SetQueueAttributesResult> setQueueAttributesAsync(SetQueueAttributesRequest request) {
1276
1277         return setQueueAttributesAsync(request, null);
1278     }
1279
1280     @Override
1281     public java.util.concurrent.Future<SetQueueAttributesResult> setQueueAttributesAsync(final SetQueueAttributesRequest request,
1282             final com.amazonaws.handlers.AsyncHandler<SetQueueAttributesRequest, SetQueueAttributesResult> asyncHandler) {
1283         final SetQueueAttributesRequest finalRequest = beforeClientExecution(request);
1284
1285         return executorService.submit(new java.util.concurrent.Callable<SetQueueAttributesResult>() {
1286             @Override
1287             public SetQueueAttributesResult call() throws Exception {
1288                 SetQueueAttributesResult result = null;
1289
1290                 try {
1291                     result = executeSetQueueAttributes(finalRequest);
1292                 } catch (Exception ex) {
1293                     if (asyncHandler != null) {
1294                         asyncHandler.onError(ex);
1295                     }
1296                     throw ex;
1297                 }
1298
1299                 if (asyncHandler != null) {
1300                     asyncHandler.onSuccess(finalRequest, result);
1301                 }
1302                 return result;
1303             }
1304         });
1305     }
1306
1307     /**
1308      * Simplified method form for invoking the SetQueueAttributes operation.
1309      *
1310      * @see #setQueueAttributesAsync(SetQueueAttributesRequest)
1311      */
1312     @Override
1313     public java.util.concurrent.Future<SetQueueAttributesResult> setQueueAttributesAsync(String queueUrl, java.util.Map<String, String> attributes) {
1314
1315         return setQueueAttributesAsync(new SetQueueAttributesRequest().withQueueUrl(queueUrl).withAttributes(attributes));
1316     }
1317
1318     /**
1319      * Simplified method form for invoking the SetQueueAttributes operation with an AsyncHandler.
1320      *
1321      * @see #setQueueAttributesAsync(SetQueueAttributesRequest, com.amazonaws.handlers.AsyncHandler)
1322      */
1323     @Override
1324     public java.util.concurrent.Future<SetQueueAttributesResult> setQueueAttributesAsync(String queueUrl, java.util.Map<String, String> attributes,
1325             com.amazonaws.handlers.AsyncHandler<SetQueueAttributesRequest, SetQueueAttributesResult> asyncHandler) {
1326
1327         return setQueueAttributesAsync(new SetQueueAttributesRequest().withQueueUrl(queueUrl).withAttributes(attributes), asyncHandler);
1328     }
1329
1330     @Override
1331     public java.util.concurrent.Future<TagQueueResult> tagQueueAsync(TagQueueRequest request) {
1332
1333         return tagQueueAsync(request, null);
1334     }
1335
1336     @Override
1337     public java.util.concurrent.Future<TagQueueResult> tagQueueAsync(final TagQueueRequest request,
1338             final com.amazonaws.handlers.AsyncHandler<TagQueueRequest, TagQueueResult> asyncHandler) {
1339         final TagQueueRequest finalRequest = beforeClientExecution(request);
1340
1341         return executorService.submit(new java.util.concurrent.Callable<TagQueueResult>() {
1342             @Override
1343             public TagQueueResult call() throws Exception {
1344                 TagQueueResult result = null;
1345
1346                 try {
1347                     result = executeTagQueue(finalRequest);
1348                 } catch (Exception ex) {
1349                     if (asyncHandler != null) {
1350                         asyncHandler.onError(ex);
1351                     }
1352                     throw ex;
1353                 }
1354
1355                 if (asyncHandler != null) {
1356                     asyncHandler.onSuccess(finalRequest, result);
1357                 }
1358                 return result;
1359             }
1360         });
1361     }
1362
1363     /**
1364      * Simplified method form for invoking the TagQueue operation.
1365      *
1366      * @see #tagQueueAsync(TagQueueRequest)
1367      */
1368     @Override
1369     public java.util.concurrent.Future<TagQueueResult> tagQueueAsync(String queueUrl, java.util.Map<String, String> tags) {
1370
1371         return tagQueueAsync(new TagQueueRequest().withQueueUrl(queueUrl).withTags(tags));
1372     }
1373
1374     /**
1375      * Simplified method form for invoking the TagQueue operation with an AsyncHandler.
1376      *
1377      * @see #tagQueueAsync(TagQueueRequest, com.amazonaws.handlers.AsyncHandler)
1378      */
1379     @Override
1380     public java.util.concurrent.Future<TagQueueResult> tagQueueAsync(String queueUrl, java.util.Map<String, String> tags,
1381             com.amazonaws.handlers.AsyncHandler<TagQueueRequest, TagQueueResult> asyncHandler) {
1382
1383         return tagQueueAsync(new TagQueueRequest().withQueueUrl(queueUrl).withTags(tags), asyncHandler);
1384     }
1385
1386     @Override
1387     public java.util.concurrent.Future<UntagQueueResult> untagQueueAsync(UntagQueueRequest request) {
1388
1389         return untagQueueAsync(request, null);
1390     }
1391
1392     @Override
1393     public java.util.concurrent.Future<UntagQueueResult> untagQueueAsync(final UntagQueueRequest request,
1394             final com.amazonaws.handlers.AsyncHandler<UntagQueueRequest, UntagQueueResult> asyncHandler) {
1395         final UntagQueueRequest finalRequest = beforeClientExecution(request);
1396
1397         return executorService.submit(new java.util.concurrent.Callable<UntagQueueResult>() {
1398             @Override
1399             public UntagQueueResult call() throws Exception {
1400                 UntagQueueResult result = null;
1401
1402                 try {
1403                     result = executeUntagQueue(finalRequest);
1404                 } catch (Exception ex) {
1405                     if (asyncHandler != null) {
1406                         asyncHandler.onError(ex);
1407                     }
1408                     throw ex;
1409                 }
1410
1411                 if (asyncHandler != null) {
1412                     asyncHandler.onSuccess(finalRequest, result);
1413                 }
1414                 return result;
1415             }
1416         });
1417     }
1418
1419     /**
1420      * Simplified method form for invoking the UntagQueue operation.
1421      *
1422      * @see #untagQueueAsync(UntagQueueRequest)
1423      */
1424     @Override
1425     public java.util.concurrent.Future<UntagQueueResult> untagQueueAsync(String queueUrl, java.util.List<String> tagKeys) {
1426
1427         return untagQueueAsync(new UntagQueueRequest().withQueueUrl(queueUrl).withTagKeys(tagKeys));
1428     }
1429
1430     /**
1431      * Simplified method form for invoking the UntagQueue operation with an AsyncHandler.
1432      *
1433      * @see #untagQueueAsync(UntagQueueRequest, com.amazonaws.handlers.AsyncHandler)
1434      */
1435     @Override
1436     public java.util.concurrent.Future<UntagQueueResult> untagQueueAsync(String queueUrl, java.util.List<String> tagKeys,
1437             com.amazonaws.handlers.AsyncHandler<UntagQueueRequest, UntagQueueResult> asyncHandler) {
1438
1439         return untagQueueAsync(new UntagQueueRequest().withQueueUrl(queueUrl).withTagKeys(tagKeys), asyncHandler);
1440     }
1441
1442     /**
1443      * Shuts down the client, releasing all managed resources. This includes forcibly terminating all pending
1444      * asynchronous service calls. Clients who wish to give pending asynchronous service calls time to complete should
1445      * call {@code getExecutorService().shutdown()} followed by {@code getExecutorService().awaitTermination()} prior to
1446      * calling this method.
1447      */
1448     @Override
1449     public void shutdown() {
1450         super.shutdown();
1451         executorService.shutdownNow();
1452     }
1453 }
1454