• Home
• com.amazonaws
• aws-java-sdk-wellarchitected
• 1.12.750
• source code
• AWSWellArchitectedAsyncClient.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

com.amazonaws.services.wellarchitected.AWSWellArchitectedAsyncClient Maven / Gradle / Ivy

/*
 * 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.wellarchitected;

import javax.annotation.Generated;

import com.amazonaws.services.wellarchitected.model.*;
import com.amazonaws.client.AwsAsyncClientParams;
import com.amazonaws.annotation.ThreadSafe;

import java.util.concurrent.ExecutorService;

/**
 * Client for accessing Well-Architected 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.
 * 

 * Well-Architected Tool
 * 

 * This is the Well-Architected Tool API Reference. The WA Tool API provides programmatic access to the Well-Architected Tool in the Amazon Web Services Management Console. For information
 * about the Well-Architected Tool, see the Well-Architected Tool User Guide.
 * 
 */
@ThreadSafe
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public class AWSWellArchitectedAsyncClient extends AWSWellArchitectedClient implements AWSWellArchitectedAsync {

    private static final int DEFAULT_THREAD_POOL_SIZE = 50;

    private final java.util.concurrent.ExecutorService executorService;

    public static AWSWellArchitectedAsyncClientBuilder asyncBuilder() {
        return AWSWellArchitectedAsyncClientBuilder.standard();
    }

    /**
     * Constructs a new asynchronous client to invoke service methods on Well-Architected using the specified
     * parameters.
     *
     * @param asyncClientParams
     *        Object providing client parameters.
     */
    AWSWellArchitectedAsyncClient(AwsAsyncClientParams asyncClientParams) {
        this(asyncClientParams, false);
    }

    /**
     * Constructs a new asynchronous client to invoke service methods on Well-Architected using the specified
     * parameters.
     *
     * @param asyncClientParams
     *        Object providing client parameters.
     * @param endpointDiscoveryEnabled
     *        true will enable endpoint discovery if the service supports it.
     */
    AWSWellArchitectedAsyncClient(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 associateLensesAsync(AssociateLensesRequest request) {

        return associateLensesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future associateLensesAsync(final AssociateLensesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final AssociateLensesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public AssociateLensesResult call() throws Exception {
                AssociateLensesResult result = null;

                try {
                    result = executeAssociateLenses(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 associateProfilesAsync(AssociateProfilesRequest request) {

        return associateProfilesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future associateProfilesAsync(final AssociateProfilesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final AssociateProfilesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public AssociateProfilesResult call() throws Exception {
                AssociateProfilesResult result = null;

                try {
                    result = executeAssociateProfiles(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 createLensShareAsync(CreateLensShareRequest request) {

        return createLensShareAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createLensShareAsync(final CreateLensShareRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateLensShareRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateLensShareResult call() throws Exception {
                CreateLensShareResult result = null;

                try {
                    result = executeCreateLensShare(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 createLensVersionAsync(CreateLensVersionRequest request) {

        return createLensVersionAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createLensVersionAsync(final CreateLensVersionRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateLensVersionRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateLensVersionResult call() throws Exception {
                CreateLensVersionResult result = null;

                try {
                    result = executeCreateLensVersion(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 createMilestoneAsync(CreateMilestoneRequest request) {

        return createMilestoneAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createMilestoneAsync(final CreateMilestoneRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateMilestoneRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateMilestoneResult call() throws Exception {
                CreateMilestoneResult result = null;

                try {
                    result = executeCreateMilestone(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 createProfileAsync(CreateProfileRequest request) {

        return createProfileAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createProfileAsync(final CreateProfileRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateProfileRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateProfileResult call() throws Exception {
                CreateProfileResult result = null;

                try {
                    result = executeCreateProfile(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 createProfileShareAsync(CreateProfileShareRequest request) {

        return createProfileShareAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createProfileShareAsync(final CreateProfileShareRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateProfileShareRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateProfileShareResult call() throws Exception {
                CreateProfileShareResult result = null;

                try {
                    result = executeCreateProfileShare(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 createReviewTemplateAsync(CreateReviewTemplateRequest request) {

        return createReviewTemplateAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createReviewTemplateAsync(final CreateReviewTemplateRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateReviewTemplateRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateReviewTemplateResult call() throws Exception {
                CreateReviewTemplateResult result = null;

                try {
                    result = executeCreateReviewTemplate(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 createTemplateShareAsync(CreateTemplateShareRequest request) {

        return createTemplateShareAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createTemplateShareAsync(final CreateTemplateShareRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateTemplateShareRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateTemplateShareResult call() throws Exception {
                CreateTemplateShareResult result = null;

                try {
                    result = executeCreateTemplateShare(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 createWorkloadAsync(CreateWorkloadRequest request) {

        return createWorkloadAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createWorkloadAsync(final CreateWorkloadRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateWorkloadRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateWorkloadResult call() throws Exception {
                CreateWorkloadResult result = null;

                try {
                    result = executeCreateWorkload(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 createWorkloadShareAsync(CreateWorkloadShareRequest request) {

        return createWorkloadShareAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future createWorkloadShareAsync(final CreateWorkloadShareRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final CreateWorkloadShareRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public CreateWorkloadShareResult call() throws Exception {
                CreateWorkloadShareResult result = null;

                try {
                    result = executeCreateWorkloadShare(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 deleteLensAsync(DeleteLensRequest request) {

        return deleteLensAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteLensAsync(final DeleteLensRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteLensRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteLensResult call() throws Exception {
                DeleteLensResult result = null;

                try {
                    result = executeDeleteLens(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 deleteLensShareAsync(DeleteLensShareRequest request) {

        return deleteLensShareAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteLensShareAsync(final DeleteLensShareRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteLensShareRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteLensShareResult call() throws Exception {
                DeleteLensShareResult result = null;

                try {
                    result = executeDeleteLensShare(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 deleteProfileAsync(DeleteProfileRequest request) {

        return deleteProfileAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteProfileAsync(final DeleteProfileRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteProfileRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteProfileResult call() throws Exception {
                DeleteProfileResult result = null;

                try {
                    result = executeDeleteProfile(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 deleteProfileShareAsync(DeleteProfileShareRequest request) {

        return deleteProfileShareAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteProfileShareAsync(final DeleteProfileShareRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteProfileShareRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteProfileShareResult call() throws Exception {
                DeleteProfileShareResult result = null;

                try {
                    result = executeDeleteProfileShare(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 deleteReviewTemplateAsync(DeleteReviewTemplateRequest request) {

        return deleteReviewTemplateAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteReviewTemplateAsync(final DeleteReviewTemplateRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteReviewTemplateRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteReviewTemplateResult call() throws Exception {
                DeleteReviewTemplateResult result = null;

                try {
                    result = executeDeleteReviewTemplate(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 deleteTemplateShareAsync(DeleteTemplateShareRequest request) {

        return deleteTemplateShareAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteTemplateShareAsync(final DeleteTemplateShareRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteTemplateShareRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteTemplateShareResult call() throws Exception {
                DeleteTemplateShareResult result = null;

                try {
                    result = executeDeleteTemplateShare(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 deleteWorkloadAsync(DeleteWorkloadRequest request) {

        return deleteWorkloadAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteWorkloadAsync(final DeleteWorkloadRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteWorkloadRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteWorkloadResult call() throws Exception {
                DeleteWorkloadResult result = null;

                try {
                    result = executeDeleteWorkload(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 deleteWorkloadShareAsync(DeleteWorkloadShareRequest request) {

        return deleteWorkloadShareAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future deleteWorkloadShareAsync(final DeleteWorkloadShareRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DeleteWorkloadShareRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DeleteWorkloadShareResult call() throws Exception {
                DeleteWorkloadShareResult result = null;

                try {
                    result = executeDeleteWorkloadShare(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 disassociateLensesAsync(DisassociateLensesRequest request) {

        return disassociateLensesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future disassociateLensesAsync(final DisassociateLensesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DisassociateLensesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DisassociateLensesResult call() throws Exception {
                DisassociateLensesResult result = null;

                try {
                    result = executeDisassociateLenses(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 disassociateProfilesAsync(DisassociateProfilesRequest request) {

        return disassociateProfilesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future disassociateProfilesAsync(final DisassociateProfilesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final DisassociateProfilesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public DisassociateProfilesResult call() throws Exception {
                DisassociateProfilesResult result = null;

                try {
                    result = executeDisassociateProfiles(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 exportLensAsync(ExportLensRequest request) {

        return exportLensAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future exportLensAsync(final ExportLensRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ExportLensRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ExportLensResult call() throws Exception {
                ExportLensResult result = null;

                try {
                    result = executeExportLens(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 getAnswerAsync(GetAnswerRequest request) {

        return getAnswerAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getAnswerAsync(final GetAnswerRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetAnswerRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetAnswerResult call() throws Exception {
                GetAnswerResult result = null;

                try {
                    result = executeGetAnswer(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 getConsolidatedReportAsync(GetConsolidatedReportRequest request) {

        return getConsolidatedReportAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getConsolidatedReportAsync(final GetConsolidatedReportRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetConsolidatedReportRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetConsolidatedReportResult call() throws Exception {
                GetConsolidatedReportResult result = null;

                try {
                    result = executeGetConsolidatedReport(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 getGlobalSettingsAsync(GetGlobalSettingsRequest request) {

        return getGlobalSettingsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getGlobalSettingsAsync(final GetGlobalSettingsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetGlobalSettingsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetGlobalSettingsResult call() throws Exception {
                GetGlobalSettingsResult result = null;

                try {
                    result = executeGetGlobalSettings(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 getLensAsync(GetLensRequest request) {

        return getLensAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getLensAsync(final GetLensRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetLensRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetLensResult call() throws Exception {
                GetLensResult result = null;

                try {
                    result = executeGetLens(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 getLensReviewAsync(GetLensReviewRequest request) {

        return getLensReviewAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getLensReviewAsync(final GetLensReviewRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetLensReviewRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetLensReviewResult call() throws Exception {
                GetLensReviewResult result = null;

                try {
                    result = executeGetLensReview(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 getLensReviewReportAsync(GetLensReviewReportRequest request) {

        return getLensReviewReportAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getLensReviewReportAsync(final GetLensReviewReportRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetLensReviewReportRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetLensReviewReportResult call() throws Exception {
                GetLensReviewReportResult result = null;

                try {
                    result = executeGetLensReviewReport(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 getLensVersionDifferenceAsync(GetLensVersionDifferenceRequest request) {

        return getLensVersionDifferenceAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getLensVersionDifferenceAsync(final GetLensVersionDifferenceRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetLensVersionDifferenceRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetLensVersionDifferenceResult call() throws Exception {
                GetLensVersionDifferenceResult result = null;

                try {
                    result = executeGetLensVersionDifference(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 getMilestoneAsync(GetMilestoneRequest request) {

        return getMilestoneAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getMilestoneAsync(final GetMilestoneRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetMilestoneRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetMilestoneResult call() throws Exception {
                GetMilestoneResult result = null;

                try {
                    result = executeGetMilestone(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 getProfileAsync(GetProfileRequest request) {

        return getProfileAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getProfileAsync(final GetProfileRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetProfileRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetProfileResult call() throws Exception {
                GetProfileResult result = null;

                try {
                    result = executeGetProfile(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 getProfileTemplateAsync(GetProfileTemplateRequest request) {

        return getProfileTemplateAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getProfileTemplateAsync(final GetProfileTemplateRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetProfileTemplateRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetProfileTemplateResult call() throws Exception {
                GetProfileTemplateResult result = null;

                try {
                    result = executeGetProfileTemplate(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 getReviewTemplateAsync(GetReviewTemplateRequest request) {

        return getReviewTemplateAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getReviewTemplateAsync(final GetReviewTemplateRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetReviewTemplateRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetReviewTemplateResult call() throws Exception {
                GetReviewTemplateResult result = null;

                try {
                    result = executeGetReviewTemplate(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 getReviewTemplateAnswerAsync(GetReviewTemplateAnswerRequest request) {

        return getReviewTemplateAnswerAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getReviewTemplateAnswerAsync(final GetReviewTemplateAnswerRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetReviewTemplateAnswerRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetReviewTemplateAnswerResult call() throws Exception {
                GetReviewTemplateAnswerResult result = null;

                try {
                    result = executeGetReviewTemplateAnswer(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 getReviewTemplateLensReviewAsync(GetReviewTemplateLensReviewRequest request) {

        return getReviewTemplateLensReviewAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getReviewTemplateLensReviewAsync(final GetReviewTemplateLensReviewRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetReviewTemplateLensReviewRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetReviewTemplateLensReviewResult call() throws Exception {
                GetReviewTemplateLensReviewResult result = null;

                try {
                    result = executeGetReviewTemplateLensReview(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 getWorkloadAsync(GetWorkloadRequest request) {

        return getWorkloadAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future getWorkloadAsync(final GetWorkloadRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final GetWorkloadRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public GetWorkloadResult call() throws Exception {
                GetWorkloadResult result = null;

                try {
                    result = executeGetWorkload(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 importLensAsync(ImportLensRequest request) {

        return importLensAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future importLensAsync(final ImportLensRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ImportLensRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ImportLensResult call() throws Exception {
                ImportLensResult result = null;

                try {
                    result = executeImportLens(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 listAnswersAsync(ListAnswersRequest request) {

        return listAnswersAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future listAnswersAsync(final ListAnswersRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ListAnswersRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ListAnswersResult call() throws Exception {
                ListAnswersResult result = null;

                try {
                    result = executeListAnswers(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 listCheckDetailsAsync(ListCheckDetailsRequest request) {

        return listCheckDetailsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future listCheckDetailsAsync(final ListCheckDetailsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ListCheckDetailsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ListCheckDetailsResult call() throws Exception {
                ListCheckDetailsResult result = null;

                try {
                    result = executeListCheckDetails(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 listCheckSummariesAsync(ListCheckSummariesRequest request) {

        return listCheckSummariesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future listCheckSummariesAsync(final ListCheckSummariesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ListCheckSummariesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ListCheckSummariesResult call() throws Exception {
                ListCheckSummariesResult result = null;

                try {
                    result = executeListCheckSummaries(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 listLensReviewImprovementsAsync(ListLensReviewImprovementsRequest request) {

        return listLensReviewImprovementsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future listLensReviewImprovementsAsync(final ListLensReviewImprovementsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ListLensReviewImprovementsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ListLensReviewImprovementsResult call() throws Exception {
                ListLensReviewImprovementsResult result = null;

                try {
                    result = executeListLensReviewImprovements(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 listLensReviewsAsync(ListLensReviewsRequest request) {

        return listLensReviewsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future listLensReviewsAsync(final ListLensReviewsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ListLensReviewsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ListLensReviewsResult call() throws Exception {
                ListLensReviewsResult result = null;

                try {
                    result = executeListLensReviews(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 listLensSharesAsync(ListLensSharesRequest request) {

        return listLensSharesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future listLensSharesAsync(final ListLensSharesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ListLensSharesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ListLensSharesResult call() throws Exception {
                ListLensSharesResult result = null;

                try {
                    result = executeListLensShares(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 listLensesAsync(ListLensesRequest request) {

        return listLensesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future listLensesAsync(final ListLensesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ListLensesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ListLensesResult call() throws Exception {
                ListLensesResult result = null;

                try {
                    result = executeListLenses(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 listMilestonesAsync(ListMilestonesRequest request) {

        return listMilestonesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future listMilestonesAsync(final ListMilestonesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ListMilestonesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ListMilestonesResult call() throws Exception {
                ListMilestonesResult result = null;

                try {
                    result = executeListMilestones(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 listNotificationsAsync(ListNotificationsRequest request) {

        return listNotificationsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future listNotificationsAsync(final ListNotificationsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ListNotificationsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ListNotificationsResult call() throws Exception {
                ListNotificationsResult result = null;

                try {
                    result = executeListNotifications(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 listProfileNotificationsAsync(ListProfileNotificationsRequest request) {

        return listProfileNotificationsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future listProfileNotificationsAsync(final ListProfileNotificationsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ListProfileNotificationsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ListProfileNotificationsResult call() throws Exception {
                ListProfileNotificationsResult result = null;

                try {
                    result = executeListProfileNotifications(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 listProfileSharesAsync(ListProfileSharesRequest request) {

        return listProfileSharesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future listProfileSharesAsync(final ListProfileSharesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ListProfileSharesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ListProfileSharesResult call() throws Exception {
                ListProfileSharesResult result = null;

                try {
                    result = executeListProfileShares(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 listProfilesAsync(ListProfilesRequest request) {

        return listProfilesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future listProfilesAsync(final ListProfilesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ListProfilesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ListProfilesResult call() throws Exception {
                ListProfilesResult result = null;

                try {
                    result = executeListProfiles(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 listReviewTemplateAnswersAsync(ListReviewTemplateAnswersRequest request) {

        return listReviewTemplateAnswersAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future listReviewTemplateAnswersAsync(final ListReviewTemplateAnswersRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ListReviewTemplateAnswersRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ListReviewTemplateAnswersResult call() throws Exception {
                ListReviewTemplateAnswersResult result = null;

                try {
                    result = executeListReviewTemplateAnswers(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 listReviewTemplatesAsync(ListReviewTemplatesRequest request) {

        return listReviewTemplatesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future listReviewTemplatesAsync(final ListReviewTemplatesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ListReviewTemplatesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ListReviewTemplatesResult call() throws Exception {
                ListReviewTemplatesResult result = null;

                try {
                    result = executeListReviewTemplates(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 listShareInvitationsAsync(ListShareInvitationsRequest request) {

        return listShareInvitationsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future listShareInvitationsAsync(final ListShareInvitationsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ListShareInvitationsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ListShareInvitationsResult call() throws Exception {
                ListShareInvitationsResult result = null;

                try {
                    result = executeListShareInvitations(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 listTemplateSharesAsync(ListTemplateSharesRequest request) {

        return listTemplateSharesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future listTemplateSharesAsync(final ListTemplateSharesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ListTemplateSharesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ListTemplateSharesResult call() throws Exception {
                ListTemplateSharesResult result = null;

                try {
                    result = executeListTemplateShares(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 listWorkloadSharesAsync(ListWorkloadSharesRequest request) {

        return listWorkloadSharesAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future listWorkloadSharesAsync(final ListWorkloadSharesRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ListWorkloadSharesRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ListWorkloadSharesResult call() throws Exception {
                ListWorkloadSharesResult result = null;

                try {
                    result = executeListWorkloadShares(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 listWorkloadsAsync(ListWorkloadsRequest request) {

        return listWorkloadsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future listWorkloadsAsync(final ListWorkloadsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final ListWorkloadsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public ListWorkloadsResult call() throws Exception {
                ListWorkloadsResult result = null;

                try {
                    result = executeListWorkloads(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 tagResourceAsync(TagResourceRequest request) {

        return tagResourceAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future tagResourceAsync(final TagResourceRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final TagResourceRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public TagResourceResult call() throws Exception {
                TagResourceResult result = null;

                try {
                    result = executeTagResource(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 untagResourceAsync(UntagResourceRequest request) {

        return untagResourceAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future untagResourceAsync(final UntagResourceRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final UntagResourceRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public UntagResourceResult call() throws Exception {
                UntagResourceResult result = null;

                try {
                    result = executeUntagResource(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 updateAnswerAsync(UpdateAnswerRequest request) {

        return updateAnswerAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future updateAnswerAsync(final UpdateAnswerRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final UpdateAnswerRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public UpdateAnswerResult call() throws Exception {
                UpdateAnswerResult result = null;

                try {
                    result = executeUpdateAnswer(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 updateGlobalSettingsAsync(UpdateGlobalSettingsRequest request) {

        return updateGlobalSettingsAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future updateGlobalSettingsAsync(final UpdateGlobalSettingsRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final UpdateGlobalSettingsRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public UpdateGlobalSettingsResult call() throws Exception {
                UpdateGlobalSettingsResult result = null;

                try {
                    result = executeUpdateGlobalSettings(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 updateIntegrationAsync(UpdateIntegrationRequest request) {

        return updateIntegrationAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future updateIntegrationAsync(final UpdateIntegrationRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final UpdateIntegrationRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public UpdateIntegrationResult call() throws Exception {
                UpdateIntegrationResult result = null;

                try {
                    result = executeUpdateIntegration(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 updateLensReviewAsync(UpdateLensReviewRequest request) {

        return updateLensReviewAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future updateLensReviewAsync(final UpdateLensReviewRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final UpdateLensReviewRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public UpdateLensReviewResult call() throws Exception {
                UpdateLensReviewResult result = null;

                try {
                    result = executeUpdateLensReview(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 updateProfileAsync(UpdateProfileRequest request) {

        return updateProfileAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future updateProfileAsync(final UpdateProfileRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final UpdateProfileRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public UpdateProfileResult call() throws Exception {
                UpdateProfileResult result = null;

                try {
                    result = executeUpdateProfile(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 updateReviewTemplateAsync(UpdateReviewTemplateRequest request) {

        return updateReviewTemplateAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future updateReviewTemplateAsync(final UpdateReviewTemplateRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final UpdateReviewTemplateRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public UpdateReviewTemplateResult call() throws Exception {
                UpdateReviewTemplateResult result = null;

                try {
                    result = executeUpdateReviewTemplate(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 updateReviewTemplateAnswerAsync(UpdateReviewTemplateAnswerRequest request) {

        return updateReviewTemplateAnswerAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future updateReviewTemplateAnswerAsync(final UpdateReviewTemplateAnswerRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final UpdateReviewTemplateAnswerRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public UpdateReviewTemplateAnswerResult call() throws Exception {
                UpdateReviewTemplateAnswerResult result = null;

                try {
                    result = executeUpdateReviewTemplateAnswer(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 updateReviewTemplateLensReviewAsync(UpdateReviewTemplateLensReviewRequest request) {

        return updateReviewTemplateLensReviewAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future updateReviewTemplateLensReviewAsync(
            final UpdateReviewTemplateLensReviewRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final UpdateReviewTemplateLensReviewRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public UpdateReviewTemplateLensReviewResult call() throws Exception {
                UpdateReviewTemplateLensReviewResult result = null;

                try {
                    result = executeUpdateReviewTemplateLensReview(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 updateShareInvitationAsync(UpdateShareInvitationRequest request) {

        return updateShareInvitationAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future updateShareInvitationAsync(final UpdateShareInvitationRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final UpdateShareInvitationRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public UpdateShareInvitationResult call() throws Exception {
                UpdateShareInvitationResult result = null;

                try {
                    result = executeUpdateShareInvitation(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 updateWorkloadAsync(UpdateWorkloadRequest request) {

        return updateWorkloadAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future updateWorkloadAsync(final UpdateWorkloadRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final UpdateWorkloadRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public UpdateWorkloadResult call() throws Exception {
                UpdateWorkloadResult result = null;

                try {
                    result = executeUpdateWorkload(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 updateWorkloadShareAsync(UpdateWorkloadShareRequest request) {

        return updateWorkloadShareAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future updateWorkloadShareAsync(final UpdateWorkloadShareRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final UpdateWorkloadShareRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public UpdateWorkloadShareResult call() throws Exception {
                UpdateWorkloadShareResult result = null;

                try {
                    result = executeUpdateWorkloadShare(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 upgradeLensReviewAsync(UpgradeLensReviewRequest request) {

        return upgradeLensReviewAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future upgradeLensReviewAsync(final UpgradeLensReviewRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final UpgradeLensReviewRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public UpgradeLensReviewResult call() throws Exception {
                UpgradeLensReviewResult result = null;

                try {
                    result = executeUpgradeLensReview(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 upgradeProfileVersionAsync(UpgradeProfileVersionRequest request) {

        return upgradeProfileVersionAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future upgradeProfileVersionAsync(final UpgradeProfileVersionRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final UpgradeProfileVersionRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public UpgradeProfileVersionResult call() throws Exception {
                UpgradeProfileVersionResult result = null;

                try {
                    result = executeUpgradeProfileVersion(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 upgradeReviewTemplateLensReviewAsync(
            UpgradeReviewTemplateLensReviewRequest request) {

        return upgradeReviewTemplateLensReviewAsync(request, null);
    }

    @Override
    public java.util.concurrent.Future upgradeReviewTemplateLensReviewAsync(
            final UpgradeReviewTemplateLensReviewRequest request,
            final com.amazonaws.handlers.AsyncHandler asyncHandler) {
        final UpgradeReviewTemplateLensReviewRequest finalRequest = beforeClientExecution(request);

        return executorService.submit(new java.util.concurrent.Callable() {
            @Override
            public UpgradeReviewTemplateLensReviewResult call() throws Exception {
                UpgradeReviewTemplateLensReviewResult result = null;

                try {
                    result = executeUpgradeReviewTemplateLensReview(finalRequest);
                } catch (Exception ex) {
                    if (asyncHandler != null) {
                        asyncHandler.onError(ex);
                    }
                    throw ex;
                }

                if (asyncHandler != null) {
                    asyncHandler.onSuccess(finalRequest, result);
                }
                return result;
            }
        });
    }

    /**
     * Shuts down the client, releasing all managed resources. This includes forcibly terminating all pending
     * asynchronous service calls. Clients who wish to give pending asynchronous service calls time to complete should
     * call {@code getExecutorService().shutdown()} followed by {@code getExecutorService().awaitTermination()} prior to
     * calling this method.
     */
    @Override
    public void shutdown() {
        super.shutdown();
        executorService.shutdownNow();
    }
}