com.amazonaws.services.cleanrooms.AWSCleanRoomsAsyncClient Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of aws-java-sdk-cleanrooms Show documentation
Show all versions of aws-java-sdk-cleanrooms Show documentation
The AWS Java SDK for AWS Clean Rooms module holds the client classes that are used for communicating with AWS Clean Rooms Service
/*
* Copyright 2019-2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with
* the License. A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions
* and limitations under the License.
*/
package com.amazonaws.services.cleanrooms;
import javax.annotation.Generated;
import com.amazonaws.services.cleanrooms.model.*;
import com.amazonaws.client.AwsAsyncClientParams;
import com.amazonaws.annotation.ThreadSafe;
import java.util.concurrent.ExecutorService;
/**
* Client for accessing AWS Clean Rooms Service asynchronously. Each asynchronous method will return a Java Future
* object representing the asynchronous operation; overloads which accept an {@code AsyncHandler} can be used to receive
* notification when an asynchronous operation completes.
*
*
* Welcome to the Clean Rooms API Reference.
*
*
* Clean Rooms is an Amazon Web Services service that helps multiple parties to join their data together in a secure
* collaboration workspace. In the collaboration, members who can query and receive results can get insights into the
* collective datasets without either party getting access to the other party's raw data.
*
*
* To learn more about Clean Rooms concepts, procedures, and best practices, see the Clean Rooms User Guide.
*
*
* To learn more about SQL commands, functions, and conditions supported in Clean Rooms, see the Clean Rooms SQL Reference.
*
*/
@ThreadSafe
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public class AWSCleanRoomsAsyncClient extends AWSCleanRoomsClient implements AWSCleanRoomsAsync {
private static final int DEFAULT_THREAD_POOL_SIZE = 50;
private final java.util.concurrent.ExecutorService executorService;
public static AWSCleanRoomsAsyncClientBuilder asyncBuilder() {
return AWSCleanRoomsAsyncClientBuilder.standard();
}
/**
* Constructs a new asynchronous client to invoke service methods on AWS Clean Rooms Service using the specified
* parameters.
*
* @param asyncClientParams
* Object providing client parameters.
*/
AWSCleanRoomsAsyncClient(AwsAsyncClientParams asyncClientParams) {
this(asyncClientParams, false);
}
/**
* Constructs a new asynchronous client to invoke service methods on AWS Clean Rooms Service using the specified
* parameters.
*
* @param asyncClientParams
* Object providing client parameters.
* @param endpointDiscoveryEnabled
* true will enable endpoint discovery if the service supports it.
*/
AWSCleanRoomsAsyncClient(AwsAsyncClientParams asyncClientParams, boolean endpointDiscoveryEnabled) {
super(asyncClientParams, endpointDiscoveryEnabled);
this.executorService = asyncClientParams.getExecutor();
}
/**
* Returns the executor service used by this client to execute async requests.
*
* @return The executor service used by this client to execute async requests.
*/
public ExecutorService getExecutorService() {
return executorService;
}
@Override
public java.util.concurrent.Future batchGetCollaborationAnalysisTemplateAsync(
BatchGetCollaborationAnalysisTemplateRequest request) {
return batchGetCollaborationAnalysisTemplateAsync(request, null);
}
@Override
public java.util.concurrent.Future batchGetCollaborationAnalysisTemplateAsync(
final BatchGetCollaborationAnalysisTemplateRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final BatchGetCollaborationAnalysisTemplateRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public BatchGetCollaborationAnalysisTemplateResult call() throws Exception {
BatchGetCollaborationAnalysisTemplateResult result = null;
try {
result = executeBatchGetCollaborationAnalysisTemplate(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future batchGetSchemaAsync(BatchGetSchemaRequest request) {
return batchGetSchemaAsync(request, null);
}
@Override
public java.util.concurrent.Future batchGetSchemaAsync(final BatchGetSchemaRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final BatchGetSchemaRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public BatchGetSchemaResult call() throws Exception {
BatchGetSchemaResult result = null;
try {
result = executeBatchGetSchema(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future batchGetSchemaAnalysisRuleAsync(BatchGetSchemaAnalysisRuleRequest request) {
return batchGetSchemaAnalysisRuleAsync(request, null);
}
@Override
public java.util.concurrent.Future batchGetSchemaAnalysisRuleAsync(final BatchGetSchemaAnalysisRuleRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final BatchGetSchemaAnalysisRuleRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public BatchGetSchemaAnalysisRuleResult call() throws Exception {
BatchGetSchemaAnalysisRuleResult result = null;
try {
result = executeBatchGetSchemaAnalysisRule(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createAnalysisTemplateAsync(CreateAnalysisTemplateRequest request) {
return createAnalysisTemplateAsync(request, null);
}
@Override
public java.util.concurrent.Future createAnalysisTemplateAsync(final CreateAnalysisTemplateRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateAnalysisTemplateRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateAnalysisTemplateResult call() throws Exception {
CreateAnalysisTemplateResult result = null;
try {
result = executeCreateAnalysisTemplate(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createCollaborationAsync(CreateCollaborationRequest request) {
return createCollaborationAsync(request, null);
}
@Override
public java.util.concurrent.Future createCollaborationAsync(final CreateCollaborationRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateCollaborationRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateCollaborationResult call() throws Exception {
CreateCollaborationResult result = null;
try {
result = executeCreateCollaboration(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createConfiguredAudienceModelAssociationAsync(
CreateConfiguredAudienceModelAssociationRequest request) {
return createConfiguredAudienceModelAssociationAsync(request, null);
}
@Override
public java.util.concurrent.Future createConfiguredAudienceModelAssociationAsync(
final CreateConfiguredAudienceModelAssociationRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateConfiguredAudienceModelAssociationRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateConfiguredAudienceModelAssociationResult call() throws Exception {
CreateConfiguredAudienceModelAssociationResult result = null;
try {
result = executeCreateConfiguredAudienceModelAssociation(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createConfiguredTableAsync(CreateConfiguredTableRequest request) {
return createConfiguredTableAsync(request, null);
}
@Override
public java.util.concurrent.Future createConfiguredTableAsync(final CreateConfiguredTableRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateConfiguredTableRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateConfiguredTableResult call() throws Exception {
CreateConfiguredTableResult result = null;
try {
result = executeCreateConfiguredTable(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createConfiguredTableAnalysisRuleAsync(
CreateConfiguredTableAnalysisRuleRequest request) {
return createConfiguredTableAnalysisRuleAsync(request, null);
}
@Override
public java.util.concurrent.Future createConfiguredTableAnalysisRuleAsync(
final CreateConfiguredTableAnalysisRuleRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateConfiguredTableAnalysisRuleRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateConfiguredTableAnalysisRuleResult call() throws Exception {
CreateConfiguredTableAnalysisRuleResult result = null;
try {
result = executeCreateConfiguredTableAnalysisRule(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createConfiguredTableAssociationAsync(
CreateConfiguredTableAssociationRequest request) {
return createConfiguredTableAssociationAsync(request, null);
}
@Override
public java.util.concurrent.Future createConfiguredTableAssociationAsync(
final CreateConfiguredTableAssociationRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateConfiguredTableAssociationRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateConfiguredTableAssociationResult call() throws Exception {
CreateConfiguredTableAssociationResult result = null;
try {
result = executeCreateConfiguredTableAssociation(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createConfiguredTableAssociationAnalysisRuleAsync(
CreateConfiguredTableAssociationAnalysisRuleRequest request) {
return createConfiguredTableAssociationAnalysisRuleAsync(request, null);
}
@Override
public java.util.concurrent.Future createConfiguredTableAssociationAnalysisRuleAsync(
final CreateConfiguredTableAssociationAnalysisRuleRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateConfiguredTableAssociationAnalysisRuleRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateConfiguredTableAssociationAnalysisRuleResult call() throws Exception {
CreateConfiguredTableAssociationAnalysisRuleResult result = null;
try {
result = executeCreateConfiguredTableAssociationAnalysisRule(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createIdMappingTableAsync(CreateIdMappingTableRequest request) {
return createIdMappingTableAsync(request, null);
}
@Override
public java.util.concurrent.Future createIdMappingTableAsync(final CreateIdMappingTableRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateIdMappingTableRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateIdMappingTableResult call() throws Exception {
CreateIdMappingTableResult result = null;
try {
result = executeCreateIdMappingTable(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createMembershipAsync(CreateMembershipRequest request) {
return createMembershipAsync(request, null);
}
@Override
public java.util.concurrent.Future createMembershipAsync(final CreateMembershipRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateMembershipRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateMembershipResult call() throws Exception {
CreateMembershipResult result = null;
try {
result = executeCreateMembership(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createPrivacyBudgetTemplateAsync(CreatePrivacyBudgetTemplateRequest request) {
return createPrivacyBudgetTemplateAsync(request, null);
}
@Override
public java.util.concurrent.Future createPrivacyBudgetTemplateAsync(final CreatePrivacyBudgetTemplateRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreatePrivacyBudgetTemplateRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreatePrivacyBudgetTemplateResult call() throws Exception {
CreatePrivacyBudgetTemplateResult result = null;
try {
result = executeCreatePrivacyBudgetTemplate(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteAnalysisTemplateAsync(DeleteAnalysisTemplateRequest request) {
return deleteAnalysisTemplateAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteAnalysisTemplateAsync(final DeleteAnalysisTemplateRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteAnalysisTemplateRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteAnalysisTemplateResult call() throws Exception {
DeleteAnalysisTemplateResult result = null;
try {
result = executeDeleteAnalysisTemplate(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteCollaborationAsync(DeleteCollaborationRequest request) {
return deleteCollaborationAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteCollaborationAsync(final DeleteCollaborationRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteCollaborationRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteCollaborationResult call() throws Exception {
DeleteCollaborationResult result = null;
try {
result = executeDeleteCollaboration(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteConfiguredAudienceModelAssociationAsync(
DeleteConfiguredAudienceModelAssociationRequest request) {
return deleteConfiguredAudienceModelAssociationAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteConfiguredAudienceModelAssociationAsync(
final DeleteConfiguredAudienceModelAssociationRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteConfiguredAudienceModelAssociationRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteConfiguredAudienceModelAssociationResult call() throws Exception {
DeleteConfiguredAudienceModelAssociationResult result = null;
try {
result = executeDeleteConfiguredAudienceModelAssociation(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteConfiguredTableAsync(DeleteConfiguredTableRequest request) {
return deleteConfiguredTableAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteConfiguredTableAsync(final DeleteConfiguredTableRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteConfiguredTableRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteConfiguredTableResult call() throws Exception {
DeleteConfiguredTableResult result = null;
try {
result = executeDeleteConfiguredTable(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteConfiguredTableAnalysisRuleAsync(
DeleteConfiguredTableAnalysisRuleRequest request) {
return deleteConfiguredTableAnalysisRuleAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteConfiguredTableAnalysisRuleAsync(
final DeleteConfiguredTableAnalysisRuleRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteConfiguredTableAnalysisRuleRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteConfiguredTableAnalysisRuleResult call() throws Exception {
DeleteConfiguredTableAnalysisRuleResult result = null;
try {
result = executeDeleteConfiguredTableAnalysisRule(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteConfiguredTableAssociationAsync(
DeleteConfiguredTableAssociationRequest request) {
return deleteConfiguredTableAssociationAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteConfiguredTableAssociationAsync(
final DeleteConfiguredTableAssociationRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteConfiguredTableAssociationRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteConfiguredTableAssociationResult call() throws Exception {
DeleteConfiguredTableAssociationResult result = null;
try {
result = executeDeleteConfiguredTableAssociation(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteConfiguredTableAssociationAnalysisRuleAsync(
DeleteConfiguredTableAssociationAnalysisRuleRequest request) {
return deleteConfiguredTableAssociationAnalysisRuleAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteConfiguredTableAssociationAnalysisRuleAsync(
final DeleteConfiguredTableAssociationAnalysisRuleRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteConfiguredTableAssociationAnalysisRuleRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteConfiguredTableAssociationAnalysisRuleResult call() throws Exception {
DeleteConfiguredTableAssociationAnalysisRuleResult result = null;
try {
result = executeDeleteConfiguredTableAssociationAnalysisRule(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteIdMappingTableAsync(DeleteIdMappingTableRequest request) {
return deleteIdMappingTableAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteIdMappingTableAsync(final DeleteIdMappingTableRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteIdMappingTableRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteIdMappingTableResult call() throws Exception {
DeleteIdMappingTableResult result = null;
try {
result = executeDeleteIdMappingTable(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteIdNamespaceAssociationAsync(DeleteIdNamespaceAssociationRequest request) {
return deleteIdNamespaceAssociationAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteIdNamespaceAssociationAsync(final DeleteIdNamespaceAssociationRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteIdNamespaceAssociationRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteIdNamespaceAssociationResult call() throws Exception {
DeleteIdNamespaceAssociationResult result = null;
try {
result = executeDeleteIdNamespaceAssociation(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteMemberAsync(DeleteMemberRequest request) {
return deleteMemberAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteMemberAsync(final DeleteMemberRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteMemberRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteMemberResult call() throws Exception {
DeleteMemberResult result = null;
try {
result = executeDeleteMember(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteMembershipAsync(DeleteMembershipRequest request) {
return deleteMembershipAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteMembershipAsync(final DeleteMembershipRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteMembershipRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteMembershipResult call() throws Exception {
DeleteMembershipResult result = null;
try {
result = executeDeleteMembership(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deletePrivacyBudgetTemplateAsync(DeletePrivacyBudgetTemplateRequest request) {
return deletePrivacyBudgetTemplateAsync(request, null);
}
@Override
public java.util.concurrent.Future deletePrivacyBudgetTemplateAsync(final DeletePrivacyBudgetTemplateRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeletePrivacyBudgetTemplateRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeletePrivacyBudgetTemplateResult call() throws Exception {
DeletePrivacyBudgetTemplateResult result = null;
try {
result = executeDeletePrivacyBudgetTemplate(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getAnalysisTemplateAsync(GetAnalysisTemplateRequest request) {
return getAnalysisTemplateAsync(request, null);
}
@Override
public java.util.concurrent.Future getAnalysisTemplateAsync(final GetAnalysisTemplateRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetAnalysisTemplateRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetAnalysisTemplateResult call() throws Exception {
GetAnalysisTemplateResult result = null;
try {
result = executeGetAnalysisTemplate(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getCollaborationAsync(GetCollaborationRequest request) {
return getCollaborationAsync(request, null);
}
@Override
public java.util.concurrent.Future getCollaborationAsync(final GetCollaborationRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetCollaborationRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetCollaborationResult call() throws Exception {
GetCollaborationResult result = null;
try {
result = executeGetCollaboration(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getCollaborationAnalysisTemplateAsync(
GetCollaborationAnalysisTemplateRequest request) {
return getCollaborationAnalysisTemplateAsync(request, null);
}
@Override
public java.util.concurrent.Future getCollaborationAnalysisTemplateAsync(
final GetCollaborationAnalysisTemplateRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetCollaborationAnalysisTemplateRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetCollaborationAnalysisTemplateResult call() throws Exception {
GetCollaborationAnalysisTemplateResult result = null;
try {
result = executeGetCollaborationAnalysisTemplate(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getCollaborationConfiguredAudienceModelAssociationAsync(
GetCollaborationConfiguredAudienceModelAssociationRequest request) {
return getCollaborationConfiguredAudienceModelAssociationAsync(request, null);
}
@Override
public java.util.concurrent.Future getCollaborationConfiguredAudienceModelAssociationAsync(
final GetCollaborationConfiguredAudienceModelAssociationRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetCollaborationConfiguredAudienceModelAssociationRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetCollaborationConfiguredAudienceModelAssociationResult call() throws Exception {
GetCollaborationConfiguredAudienceModelAssociationResult result = null;
try {
result = executeGetCollaborationConfiguredAudienceModelAssociation(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getCollaborationPrivacyBudgetTemplateAsync(
GetCollaborationPrivacyBudgetTemplateRequest request) {
return getCollaborationPrivacyBudgetTemplateAsync(request, null);
}
@Override
public java.util.concurrent.Future getCollaborationPrivacyBudgetTemplateAsync(
final GetCollaborationPrivacyBudgetTemplateRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetCollaborationPrivacyBudgetTemplateRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetCollaborationPrivacyBudgetTemplateResult call() throws Exception {
GetCollaborationPrivacyBudgetTemplateResult result = null;
try {
result = executeGetCollaborationPrivacyBudgetTemplate(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getConfiguredAudienceModelAssociationAsync(
GetConfiguredAudienceModelAssociationRequest request) {
return getConfiguredAudienceModelAssociationAsync(request, null);
}
@Override
public java.util.concurrent.Future getConfiguredAudienceModelAssociationAsync(
final GetConfiguredAudienceModelAssociationRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetConfiguredAudienceModelAssociationRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetConfiguredAudienceModelAssociationResult call() throws Exception {
GetConfiguredAudienceModelAssociationResult result = null;
try {
result = executeGetConfiguredAudienceModelAssociation(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getConfiguredTableAsync(GetConfiguredTableRequest request) {
return getConfiguredTableAsync(request, null);
}
@Override
public java.util.concurrent.Future getConfiguredTableAsync(final GetConfiguredTableRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetConfiguredTableRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetConfiguredTableResult call() throws Exception {
GetConfiguredTableResult result = null;
try {
result = executeGetConfiguredTable(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getConfiguredTableAnalysisRuleAsync(GetConfiguredTableAnalysisRuleRequest request) {
return getConfiguredTableAnalysisRuleAsync(request, null);
}
@Override
public java.util.concurrent.Future getConfiguredTableAnalysisRuleAsync(
final GetConfiguredTableAnalysisRuleRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetConfiguredTableAnalysisRuleRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetConfiguredTableAnalysisRuleResult call() throws Exception {
GetConfiguredTableAnalysisRuleResult result = null;
try {
result = executeGetConfiguredTableAnalysisRule(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getConfiguredTableAssociationAsync(GetConfiguredTableAssociationRequest request) {
return getConfiguredTableAssociationAsync(request, null);
}
@Override
public java.util.concurrent.Future getConfiguredTableAssociationAsync(
final GetConfiguredTableAssociationRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetConfiguredTableAssociationRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetConfiguredTableAssociationResult call() throws Exception {
GetConfiguredTableAssociationResult result = null;
try {
result = executeGetConfiguredTableAssociation(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getConfiguredTableAssociationAnalysisRuleAsync(
GetConfiguredTableAssociationAnalysisRuleRequest request) {
return getConfiguredTableAssociationAnalysisRuleAsync(request, null);
}
@Override
public java.util.concurrent.Future getConfiguredTableAssociationAnalysisRuleAsync(
final GetConfiguredTableAssociationAnalysisRuleRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetConfiguredTableAssociationAnalysisRuleRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetConfiguredTableAssociationAnalysisRuleResult call() throws Exception {
GetConfiguredTableAssociationAnalysisRuleResult result = null;
try {
result = executeGetConfiguredTableAssociationAnalysisRule(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getIdMappingTableAsync(GetIdMappingTableRequest request) {
return getIdMappingTableAsync(request, null);
}
@Override
public java.util.concurrent.Future getIdMappingTableAsync(final GetIdMappingTableRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetIdMappingTableRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetIdMappingTableResult call() throws Exception {
GetIdMappingTableResult result = null;
try {
result = executeGetIdMappingTable(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getMembershipAsync(GetMembershipRequest request) {
return getMembershipAsync(request, null);
}
@Override
public java.util.concurrent.Future getMembershipAsync(final GetMembershipRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetMembershipRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetMembershipResult call() throws Exception {
GetMembershipResult result = null;
try {
result = executeGetMembership(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getPrivacyBudgetTemplateAsync(GetPrivacyBudgetTemplateRequest request) {
return getPrivacyBudgetTemplateAsync(request, null);
}
@Override
public java.util.concurrent.Future getPrivacyBudgetTemplateAsync(final GetPrivacyBudgetTemplateRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetPrivacyBudgetTemplateRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetPrivacyBudgetTemplateResult call() throws Exception {
GetPrivacyBudgetTemplateResult result = null;
try {
result = executeGetPrivacyBudgetTemplate(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getProtectedQueryAsync(GetProtectedQueryRequest request) {
return getProtectedQueryAsync(request, null);
}
@Override
public java.util.concurrent.Future getProtectedQueryAsync(final GetProtectedQueryRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetProtectedQueryRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetProtectedQueryResult call() throws Exception {
GetProtectedQueryResult result = null;
try {
result = executeGetProtectedQuery(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getSchemaAsync(GetSchemaRequest request) {
return getSchemaAsync(request, null);
}
@Override
public java.util.concurrent.Future getSchemaAsync(final GetSchemaRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetSchemaRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetSchemaResult call() throws Exception {
GetSchemaResult result = null;
try {
result = executeGetSchema(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getSchemaAnalysisRuleAsync(GetSchemaAnalysisRuleRequest request) {
return getSchemaAnalysisRuleAsync(request, null);
}
@Override
public java.util.concurrent.Future getSchemaAnalysisRuleAsync(final GetSchemaAnalysisRuleRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetSchemaAnalysisRuleRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetSchemaAnalysisRuleResult call() throws Exception {
GetSchemaAnalysisRuleResult result = null;
try {
result = executeGetSchemaAnalysisRule(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future listAnalysisTemplatesAsync(ListAnalysisTemplatesRequest request) {
return listAnalysisTemplatesAsync(request, null);
}
@Override
public java.util.concurrent.Future listAnalysisTemplatesAsync(final ListAnalysisTemplatesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListAnalysisTemplatesRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListAnalysisTemplatesResult call() throws Exception {
ListAnalysisTemplatesResult result = null;
try {
result = executeListAnalysisTemplates(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future listCollaborationAnalysisTemplatesAsync(
ListCollaborationAnalysisTemplatesRequest request) {
return listCollaborationAnalysisTemplatesAsync(request, null);
}
@Override
public java.util.concurrent.Future listCollaborationAnalysisTemplatesAsync(
final ListCollaborationAnalysisTemplatesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListCollaborationAnalysisTemplatesRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListCollaborationAnalysisTemplatesResult call() throws Exception {
ListCollaborationAnalysisTemplatesResult result = null;
try {
result = executeListCollaborationAnalysisTemplates(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future listCollaborationConfiguredAudienceModelAssociationsAsync(
ListCollaborationConfiguredAudienceModelAssociationsRequest request) {
return listCollaborationConfiguredAudienceModelAssociationsAsync(request, null);
}
@Override
public java.util.concurrent.Future listCollaborationConfiguredAudienceModelAssociationsAsync(
final ListCollaborationConfiguredAudienceModelAssociationsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListCollaborationConfiguredAudienceModelAssociationsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListCollaborationConfiguredAudienceModelAssociationsResult call() throws Exception {
ListCollaborationConfiguredAudienceModelAssociationsResult result = null;
try {
result = executeListCollaborationConfiguredAudienceModelAssociations(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future listCollaborationIdNamespaceAssociationsAsync(
ListCollaborationIdNamespaceAssociationsRequest request) {
return listCollaborationIdNamespaceAssociationsAsync(request, null);
}
@Override
public java.util.concurrent.Future listCollaborationIdNamespaceAssociationsAsync(
final ListCollaborationIdNamespaceAssociationsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListCollaborationIdNamespaceAssociationsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListCollaborationIdNamespaceAssociationsResult call() throws Exception {
ListCollaborationIdNamespaceAssociationsResult result = null;
try {
result = executeListCollaborationIdNamespaceAssociations(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future listCollaborationPrivacyBudgetTemplatesAsync(
ListCollaborationPrivacyBudgetTemplatesRequest request) {
return listCollaborationPrivacyBudgetTemplatesAsync(request, null);
}
@Override
public java.util.concurrent.Future listCollaborationPrivacyBudgetTemplatesAsync(
final ListCollaborationPrivacyBudgetTemplatesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListCollaborationPrivacyBudgetTemplatesRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListCollaborationPrivacyBudgetTemplatesResult call() throws Exception {
ListCollaborationPrivacyBudgetTemplatesResult result = null;
try {
result = executeListCollaborationPrivacyBudgetTemplates(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future listCollaborationPrivacyBudgetsAsync(
ListCollaborationPrivacyBudgetsRequest request) {
return listCollaborationPrivacyBudgetsAsync(request, null);
}
@Override
public java.util.concurrent.Future listCollaborationPrivacyBudgetsAsync(
final ListCollaborationPrivacyBudgetsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListCollaborationPrivacyBudgetsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListCollaborationPrivacyBudgetsResult call() throws Exception {
ListCollaborationPrivacyBudgetsResult result = null;
try {
result = executeListCollaborationPrivacyBudgets(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future listCollaborationsAsync(ListCollaborationsRequest request) {
return listCollaborationsAsync(request, null);
}
@Override
public java.util.concurrent.Future listCollaborationsAsync(final ListCollaborationsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListCollaborationsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListCollaborationsResult call() throws Exception {
ListCollaborationsResult result = null;
try {
result = executeListCollaborations(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future listConfiguredAudienceModelAssociationsAsync(
ListConfiguredAudienceModelAssociationsRequest request) {
return listConfiguredAudienceModelAssociationsAsync(request, null);
}
@Override
public java.util.concurrent.Future listConfiguredAudienceModelAssociationsAsync(
final ListConfiguredAudienceModelAssociationsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListConfiguredAudienceModelAssociationsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListConfiguredAudienceModelAssociationsResult call() throws Exception {
ListConfiguredAudienceModelAssociationsResult result = null;
try {
result = executeListConfiguredAudienceModelAssociations(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future listConfiguredTableAssociationsAsync(
ListConfiguredTableAssociationsRequest request) {
return listConfiguredTableAssociationsAsync(request, null);
}
@Override
public java.util.concurrent.Future listConfiguredTableAssociationsAsync(
final ListConfiguredTableAssociationsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListConfiguredTableAssociationsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListConfiguredTableAssociationsResult call() throws Exception {
ListConfiguredTableAssociationsResult result = null;
try {
result = executeListConfiguredTableAssociations(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future listConfiguredTablesAsync(ListConfiguredTablesRequest request) {
return listConfiguredTablesAsync(request, null);
}
@Override
public java.util.concurrent.Future listConfiguredTablesAsync(final ListConfiguredTablesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListConfiguredTablesRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListConfiguredTablesResult call() throws Exception {
ListConfiguredTablesResult result = null;
try {
result = executeListConfiguredTables(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future listIdMappingTablesAsync(ListIdMappingTablesRequest request) {
return listIdMappingTablesAsync(request, null);
}
@Override
public java.util.concurrent.Future listIdMappingTablesAsync(final ListIdMappingTablesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListIdMappingTablesRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListIdMappingTablesResult call() throws Exception {
ListIdMappingTablesResult result = null;
try {
result = executeListIdMappingTables(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future listIdNamespaceAssociationsAsync(ListIdNamespaceAssociationsRequest request) {
return listIdNamespaceAssociationsAsync(request, null);
}
@Override
public java.util.concurrent.Future listIdNamespaceAssociationsAsync(final ListIdNamespaceAssociationsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListIdNamespaceAssociationsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListIdNamespaceAssociationsResult call() throws Exception {
ListIdNamespaceAssociationsResult result = null;
try {
result = executeListIdNamespaceAssociations(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future listMembersAsync(ListMembersRequest request) {
return listMembersAsync(request, null);
}
@Override
public java.util.concurrent.Future listMembersAsync(final ListMembersRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListMembersRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListMembersResult call() throws Exception {
ListMembersResult result = null;
try {
result = executeListMembers(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future listMembershipsAsync(ListMembershipsRequest request) {
return listMembershipsAsync(request, null);
}
@Override
public java.util.concurrent.Future listMembershipsAsync(final ListMembershipsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListMembershipsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListMembershipsResult call() throws Exception {
ListMembershipsResult result = null;
try {
result = executeListMemberships(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future listPrivacyBudgetTemplatesAsync(ListPrivacyBudgetTemplatesRequest request) {
return listPrivacyBudgetTemplatesAsync(request, null);
}
@Override
public java.util.concurrent.Future listPrivacyBudgetTemplatesAsync(final ListPrivacyBudgetTemplatesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListPrivacyBudgetTemplatesRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListPrivacyBudgetTemplatesResult call() throws Exception {
ListPrivacyBudgetTemplatesResult result = null;
try {
result = executeListPrivacyBudgetTemplates(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future listPrivacyBudgetsAsync(ListPrivacyBudgetsRequest request) {
return listPrivacyBudgetsAsync(request, null);
}
@Override
public java.util.concurrent.Future listPrivacyBudgetsAsync(final ListPrivacyBudgetsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListPrivacyBudgetsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListPrivacyBudgetsResult call() throws Exception {
ListPrivacyBudgetsResult result = null;
try {
result = executeListPrivacyBudgets(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future listProtectedQueriesAsync(ListProtectedQueriesRequest request) {
return listProtectedQueriesAsync(request, null);
}
@Override
public java.util.concurrent.Future listProtectedQueriesAsync(final ListProtectedQueriesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListProtectedQueriesRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListProtectedQueriesResult call() throws Exception {
ListProtectedQueriesResult result = null;
try {
result = executeListProtectedQueries(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future listSchemasAsync(ListSchemasRequest request) {
return listSchemasAsync(request, null);
}
@Override
public java.util.concurrent.Future listSchemasAsync(final ListSchemasRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListSchemasRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListSchemasResult call() throws Exception {
ListSchemasResult result = null;
try {
result = executeListSchemas(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future listTagsForResourceAsync(ListTagsForResourceRequest request) {
return listTagsForResourceAsync(request, null);
}
@Override
public java.util.concurrent.Future listTagsForResourceAsync(final ListTagsForResourceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListTagsForResourceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListTagsForResourceResult call() throws Exception {
ListTagsForResourceResult result = null;
try {
result = executeListTagsForResource(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future populateIdMappingTableAsync(PopulateIdMappingTableRequest request) {
return populateIdMappingTableAsync(request, null);
}
@Override
public java.util.concurrent.Future populateIdMappingTableAsync(final PopulateIdMappingTableRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final PopulateIdMappingTableRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public PopulateIdMappingTableResult call() throws Exception {
PopulateIdMappingTableResult result = null;
try {
result = executePopulateIdMappingTable(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future previewPrivacyImpactAsync(PreviewPrivacyImpactRequest request) {
return previewPrivacyImpactAsync(request, null);
}
@Override
public java.util.concurrent.Future previewPrivacyImpactAsync(final PreviewPrivacyImpactRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final PreviewPrivacyImpactRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public PreviewPrivacyImpactResult call() throws Exception {
PreviewPrivacyImpactResult result = null;
try {
result = executePreviewPrivacyImpact(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future startProtectedQueryAsync(StartProtectedQueryRequest request) {
return startProtectedQueryAsync(request, null);
}
@Override
public java.util.concurrent.Future startProtectedQueryAsync(final StartProtectedQueryRequest request,
final com.amazonaws.handlers.AsyncHandler