com.amazonaws.services.costexplorer.AWSCostExplorerAsyncClient Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of aws-java-sdk-costexplorer Show documentation
The AWS Java SDK for AWS Cost Explorer module holds the client classes that are used for communicating with AWS Cost Explorer Service
The newest version!
/*
 * Copyright 2020-2025 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.costexplorer;

import javax.annotation.Generated;

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

import java.util.concurrent.ExecutorService;

/**
 * Client for accessing AWS Cost Explorer 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.
 * 
 * 

 * You can use the Cost Explorer API to programmatically query your cost and usage data. You can query for aggregated
 * data such as total monthly costs or total daily usage. You can also query for granular data. This might include the
 * number of daily write operations for Amazon DynamoDB database tables in your production environment.
 * 
 * 
 * Service Endpoint
 * 
 * 
 * The Cost Explorer API provides the following endpoint:
 * 
 * 
 * 
 * 
 * https://ce.us-east-1.amazonaws.com
 * 
 * 
 * 
 * 
 * For information about the costs that are associated with the Cost Explorer API, see Amazon Web Services Cost Management Pricing.
 * 
 */
@ThreadSafe
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public class AWSCostExplorerAsyncClient extends AWSCostExplorerClient implements AWSCostExplorerAsync {

    private static final int DEFAULT_THREAD_POOL_SIZE = 50;

    private final java.util.concurrent.ExecutorService executorService;

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

    /**
     * Constructs a new asynchronous client to invoke service methods on AWS Cost Explorer using the specified
     * parameters.
     *
     * @param asyncClientParams
     *        Object providing client parameters.
     */
    AWSCostExplorerAsyncClient(AwsAsyncClientParams asyncClientParams) {
        this(asyncClientParams, false);
    }

    /**
     * Constructs a new asynchronous client to invoke service methods on AWS Cost Explorer using the specified
     * parameters.
     *
     * @param asyncClientParams
     *        Object providing client parameters.
     * @param endpointDiscoveryEnabled
     *        true will enable endpoint discovery if the service supports it.
     */
    AWSCostExplorerAsyncClient(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 createAnomalyMonitorAsync(CreateAnomalyMonitorRequest request) {

        return createAnomalyMonitorAsync(request, null);
    }

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

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

                try {
                    result = executeCreateAnomalyMonitor(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 createAnomalySubscriptionAsync(CreateAnomalySubscriptionRequest request) {

        return createAnomalySubscriptionAsync(request, null);
    }

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

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

                try {
                    result = executeCreateAnomalySubscription(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 createCostCategoryDefinitionAsync(CreateCostCategoryDefinitionRequest request) {

        return createCostCategoryDefinitionAsync(request, null);
    }

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

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

                try {
                    result = executeCreateCostCategoryDefinition(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 deleteAnomalyMonitorAsync(DeleteAnomalyMonitorRequest request) {

        return deleteAnomalyMonitorAsync(request, null);
    }

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

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

                try {
                    result = executeDeleteAnomalyMonitor(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 deleteAnomalySubscriptionAsync(DeleteAnomalySubscriptionRequest request) {

        return deleteAnomalySubscriptionAsync(request, null);
    }

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

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

                try {
                    result = executeDeleteAnomalySubscription(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 deleteCostCategoryDefinitionAsync(DeleteCostCategoryDefinitionRequest request) {

        return deleteCostCategoryDefinitionAsync(request, null);
    }

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

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

                try {
                    result = executeDeleteCostCategoryDefinition(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 describeCostCategoryDefinitionAsync(DescribeCostCategoryDefinitionRequest request) {

        return describeCostCategoryDefinitionAsync(request, null);
    }

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

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

                try {
                    result = executeDescribeCostCategoryDefinition(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 getAnomaliesAsync(GetAnomaliesRequest request) {

        return getAnomaliesAsync(request, null);
    }

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

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

                try {
                    result = executeGetAnomalies(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 getAnomalyMonitorsAsync(GetAnomalyMonitorsRequest request) {

        return getAnomalyMonitorsAsync(request, null);
    }

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

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

                try {
                    result = executeGetAnomalyMonitors(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 getAnomalySubscriptionsAsync(GetAnomalySubscriptionsRequest request) {

        return getAnomalySubscriptionsAsync(request, null);
    }

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

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

                try {
                    result = executeGetAnomalySubscriptions(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 getApproximateUsageRecordsAsync(GetApproximateUsageRecordsRequest request) {

        return getApproximateUsageRecordsAsync(request, null);
    }

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

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

                try {
                    result = executeGetApproximateUsageRecords(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 getCostAndUsageAsync(GetCostAndUsageRequest request) {

        return getCostAndUsageAsync(request, null);
    }

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

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

                try {
                    result = executeGetCostAndUsage(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 getCostAndUsageWithResourcesAsync(GetCostAndUsageWithResourcesRequest request) {

        return getCostAndUsageWithResourcesAsync(request, null);
    }

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

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

                try {
                    result = executeGetCostAndUsageWithResources(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 getCostCategoriesAsync(GetCostCategoriesRequest request) {

        return getCostCategoriesAsync(request, null);
    }

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

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

                try {
                    result = executeGetCostCategories(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 getCostForecastAsync(GetCostForecastRequest request) {

        return getCostForecastAsync(request, null);
    }

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

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

                try {
                    result = executeGetCostForecast(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 getDimensionValuesAsync(GetDimensionValuesRequest request) {

        return getDimensionValuesAsync(request, null);
    }

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

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

                try {
                    result = executeGetDimensionValues(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 getReservationCoverageAsync(GetReservationCoverageRequest request) {

        return getReservationCoverageAsync(request, null);
    }

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

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

                try {
                    result = executeGetReservationCoverage(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 getReservationPurchaseRecommendationAsync(
            GetReservationPurchaseRecommendationRequest request) {

        return getReservationPurchaseRecommendationAsync(request, null);
    }

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

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

                try {
                    result = executeGetReservationPurchaseRecommendation(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 getReservationUtilizationAsync(GetReservationUtilizationRequest request) {

        return getReservationUtilizationAsync(request, null);
    }

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

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

                try {
                    result = executeGetReservationUtilization(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 getRightsizingRecommendationAsync(GetRightsizingRecommendationRequest request) {

        return getRightsizingRecommendationAsync(request, null);
    }

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

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

                try {
                    result = executeGetRightsizingRecommendation(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 getSavingsPlanPurchaseRecommendationDetailsAsync(
            GetSavingsPlanPurchaseRecommendationDetailsRequest request) {

        return getSavingsPlanPurchaseRecommendationDetailsAsync(request, null);
    }

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

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

                try {
                    result = executeGetSavingsPlanPurchaseRecommendationDetails(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 getSavingsPlansCoverageAsync(GetSavingsPlansCoverageRequest request) {

        return getSavingsPlansCoverageAsync(request, null);
    }

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

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

                try {
                    result = executeGetSavingsPlansCoverage(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 getSavingsPlansPurchaseRecommendationAsync(
            GetSavingsPlansPurchaseRecommendationRequest request) {

        return getSavingsPlansPurchaseRecommendationAsync(request, null);
    }

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

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

                try {
                    result = executeGetSavingsPlansPurchaseRecommendation(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 getSavingsPlansUtilizationAsync(GetSavingsPlansUtilizationRequest request) {

        return getSavingsPlansUtilizationAsync(request, null);
    }

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

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

                try {
                    result = executeGetSavingsPlansUtilization(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 getSavingsPlansUtilizationDetailsAsync(
            GetSavingsPlansUtilizationDetailsRequest request) {

        return getSavingsPlansUtilizationDetailsAsync(request, null);
    }

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

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

                try {
                    result = executeGetSavingsPlansUtilizationDetails(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 getTagsAsync(GetTagsRequest request) {

        return getTagsAsync(request, null);
    }

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

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

                try {
                    result = executeGetTags(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 getUsageForecastAsync(GetUsageForecastRequest request) {

        return getUsageForecastAsync(request, null);
    }

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

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

                try {
                    result = executeGetUsageForecast(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 listCostAllocationTagBackfillHistoryAsync(
            ListCostAllocationTagBackfillHistoryRequest request) {

        return listCostAllocationTagBackfillHistoryAsync(request, null);
    }

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

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

                try {
                    result = executeListCostAllocationTagBackfillHistory(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 listCostAllocationTagsAsync(ListCostAllocationTagsRequest request) {

        return listCostAllocationTagsAsync(request, null);
    }

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

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

                try {
                    result = executeListCostAllocationTags(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 listCostCategoryDefinitionsAsync(ListCostCategoryDefinitionsRequest request) {

        return listCostCategoryDefinitionsAsync(request, null);
    }

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

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

                try {
                    result = executeListCostCategoryDefinitions(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 listSavingsPlansPurchaseRecommendationGenerationAsync(
            ListSavingsPlansPurchaseRecommendationGenerationRequest request) {

        return listSavingsPlansPurchaseRecommendationGenerationAsync(request, null);
    }

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

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

                try {
                    result = executeListSavingsPlansPurchaseRecommendationGeneration(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 provideAnomalyFeedbackAsync(ProvideAnomalyFeedbackRequest request) {

        return provideAnomalyFeedbackAsync(request, null);
    }

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

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

                try {
                    result = executeProvideAnomalyFeedback(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 startCostAllocationTagBackfillAsync(StartCostAllocationTagBackfillRequest request) {

        return startCostAllocationTagBackfillAsync(request, null);
    }

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

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

                try {
                    result = executeStartCostAllocationTagBackfill(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 startSavingsPlansPurchaseRecommendationGenerationAsync(
            StartSavingsPlansPurchaseRecommendationGenerationRequest request) {

        return startSavingsPlansPurchaseRecommendationGenerationAsync(request, null);
    }

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

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

                try {
                    result = executeStartSavingsPlansPurchaseRecommendationGeneration(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 updateAnomalyMonitorAsync(UpdateAnomalyMonitorRequest request) {

        return updateAnomalyMonitorAsync(request, null);
    }

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

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

                try {
                    result = executeUpdateAnomalyMonitor(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 updateAnomalySubscriptionAsync(UpdateAnomalySubscriptionRequest request) {

        return updateAnomalySubscriptionAsync(request, null);
    }

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

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

                try {
                    result = executeUpdateAnomalySubscription(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 updateCostAllocationTagsStatusAsync(UpdateCostAllocationTagsStatusRequest request) {

        return updateCostAllocationTagsStatusAsync(request, null);
    }

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

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

                try {
                    result = executeUpdateCostAllocationTagsStatus(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 updateCostCategoryDefinitionAsync(UpdateCostCategoryDefinitionRequest request) {

        return updateCostCategoryDefinitionAsync(request, null);
    }

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

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

                try {
                    result = executeUpdateCostCategoryDefinition(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();
    }
}