• Home
• com.amazonaws
• aws-java-sdk-networkmanager
• 1.12.767
• source code
• AWSNetworkManagerAsyncClient.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.networkmanager.AWSNetworkManagerAsyncClient 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.networkmanager;

import javax.annotation.Generated;

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

import java.util.concurrent.ExecutorService;

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

 * 

 * Amazon Web Services enables you to centrally manage your Amazon Web Services Cloud WAN core network and your Transit
 * Gateway network across Amazon Web Services accounts, Regions, and on-premises locations.
 * 
 */
@ThreadSafe
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public class AWSNetworkManagerAsyncClient extends AWSNetworkManagerClient implements AWSNetworkManagerAsync {

    private static final int DEFAULT_THREAD_POOL_SIZE = 50;

    private final java.util.concurrent.ExecutorService executorService;

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

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

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

        return acceptAttachmentAsync(request, null);
    }

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

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

                try {
                    result = executeAcceptAttachment(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 associateConnectPeerAsync(AssociateConnectPeerRequest request) {

        return associateConnectPeerAsync(request, null);
    }

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

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

                try {
                    result = executeAssociateConnectPeer(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 associateCustomerGatewayAsync(AssociateCustomerGatewayRequest request) {

        return associateCustomerGatewayAsync(request, null);
    }

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

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

                try {
                    result = executeAssociateCustomerGateway(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 associateLinkAsync(AssociateLinkRequest request) {

        return associateLinkAsync(request, null);
    }

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

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

                try {
                    result = executeAssociateLink(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 associateTransitGatewayConnectPeerAsync(
            AssociateTransitGatewayConnectPeerRequest request) {

        return associateTransitGatewayConnectPeerAsync(request, null);
    }

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

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

                try {
                    result = executeAssociateTransitGatewayConnectPeer(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 createConnectAttachmentAsync(CreateConnectAttachmentRequest request) {

        return createConnectAttachmentAsync(request, null);
    }

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

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

                try {
                    result = executeCreateConnectAttachment(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 createConnectPeerAsync(CreateConnectPeerRequest request) {

        return createConnectPeerAsync(request, null);
    }

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

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

                try {
                    result = executeCreateConnectPeer(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 createConnectionAsync(CreateConnectionRequest request) {

        return createConnectionAsync(request, null);
    }

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

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

                try {
                    result = executeCreateConnection(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 createCoreNetworkAsync(CreateCoreNetworkRequest request) {

        return createCoreNetworkAsync(request, null);
    }

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

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

                try {
                    result = executeCreateCoreNetwork(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 createDeviceAsync(CreateDeviceRequest request) {

        return createDeviceAsync(request, null);
    }

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

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

                try {
                    result = executeCreateDevice(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 createGlobalNetworkAsync(CreateGlobalNetworkRequest request) {

        return createGlobalNetworkAsync(request, null);
    }

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

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

                try {
                    result = executeCreateGlobalNetwork(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 createLinkAsync(CreateLinkRequest request) {

        return createLinkAsync(request, null);
    }

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

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

                try {
                    result = executeCreateLink(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 createSiteAsync(CreateSiteRequest request) {

        return createSiteAsync(request, null);
    }

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

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

                try {
                    result = executeCreateSite(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 createSiteToSiteVpnAttachmentAsync(CreateSiteToSiteVpnAttachmentRequest request) {

        return createSiteToSiteVpnAttachmentAsync(request, null);
    }

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

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

                try {
                    result = executeCreateSiteToSiteVpnAttachment(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 createTransitGatewayPeeringAsync(CreateTransitGatewayPeeringRequest request) {

        return createTransitGatewayPeeringAsync(request, null);
    }

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

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

                try {
                    result = executeCreateTransitGatewayPeering(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 createTransitGatewayRouteTableAttachmentAsync(
            CreateTransitGatewayRouteTableAttachmentRequest request) {

        return createTransitGatewayRouteTableAttachmentAsync(request, null);
    }

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

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

                try {
                    result = executeCreateTransitGatewayRouteTableAttachment(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 createVpcAttachmentAsync(CreateVpcAttachmentRequest request) {

        return createVpcAttachmentAsync(request, null);
    }

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

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

                try {
                    result = executeCreateVpcAttachment(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 deleteAttachmentAsync(DeleteAttachmentRequest request) {

        return deleteAttachmentAsync(request, null);
    }

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

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

                try {
                    result = executeDeleteAttachment(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 deleteConnectPeerAsync(DeleteConnectPeerRequest request) {

        return deleteConnectPeerAsync(request, null);
    }

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

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

                try {
                    result = executeDeleteConnectPeer(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 deleteConnectionAsync(DeleteConnectionRequest request) {

        return deleteConnectionAsync(request, null);
    }

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

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

                try {
                    result = executeDeleteConnection(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 deleteCoreNetworkAsync(DeleteCoreNetworkRequest request) {

        return deleteCoreNetworkAsync(request, null);
    }

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

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

                try {
                    result = executeDeleteCoreNetwork(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 deleteCoreNetworkPolicyVersionAsync(DeleteCoreNetworkPolicyVersionRequest request) {

        return deleteCoreNetworkPolicyVersionAsync(request, null);
    }

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

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

                try {
                    result = executeDeleteCoreNetworkPolicyVersion(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 deleteDeviceAsync(DeleteDeviceRequest request) {

        return deleteDeviceAsync(request, null);
    }

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

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

                try {
                    result = executeDeleteDevice(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 deleteGlobalNetworkAsync(DeleteGlobalNetworkRequest request) {

        return deleteGlobalNetworkAsync(request, null);
    }

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

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

                try {
                    result = executeDeleteGlobalNetwork(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 deleteLinkAsync(DeleteLinkRequest request) {

        return deleteLinkAsync(request, null);
    }

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

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

                try {
                    result = executeDeleteLink(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 deletePeeringAsync(DeletePeeringRequest request) {

        return deletePeeringAsync(request, null);
    }

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

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

                try {
                    result = executeDeletePeering(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 deleteResourcePolicyAsync(DeleteResourcePolicyRequest request) {

        return deleteResourcePolicyAsync(request, null);
    }

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

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

                try {
                    result = executeDeleteResourcePolicy(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 deleteSiteAsync(DeleteSiteRequest request) {

        return deleteSiteAsync(request, null);
    }

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

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

                try {
                    result = executeDeleteSite(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 deregisterTransitGatewayAsync(DeregisterTransitGatewayRequest request) {

        return deregisterTransitGatewayAsync(request, null);
    }

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

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

                try {
                    result = executeDeregisterTransitGateway(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 describeGlobalNetworksAsync(DescribeGlobalNetworksRequest request) {

        return describeGlobalNetworksAsync(request, null);
    }

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

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

                try {
                    result = executeDescribeGlobalNetworks(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 disassociateConnectPeerAsync(DisassociateConnectPeerRequest request) {

        return disassociateConnectPeerAsync(request, null);
    }

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

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

                try {
                    result = executeDisassociateConnectPeer(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 disassociateCustomerGatewayAsync(DisassociateCustomerGatewayRequest request) {

        return disassociateCustomerGatewayAsync(request, null);
    }

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

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

                try {
                    result = executeDisassociateCustomerGateway(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 disassociateLinkAsync(DisassociateLinkRequest request) {

        return disassociateLinkAsync(request, null);
    }

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

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

                try {
                    result = executeDisassociateLink(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 disassociateTransitGatewayConnectPeerAsync(
            DisassociateTransitGatewayConnectPeerRequest request) {

        return disassociateTransitGatewayConnectPeerAsync(request, null);
    }

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

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

                try {
                    result = executeDisassociateTransitGatewayConnectPeer(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 executeCoreNetworkChangeSetAsync(ExecuteCoreNetworkChangeSetRequest request) {

        return executeCoreNetworkChangeSetAsync(request, null);
    }

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

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

                try {
                    result = executeExecuteCoreNetworkChangeSet(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 getConnectAttachmentAsync(GetConnectAttachmentRequest request) {

        return getConnectAttachmentAsync(request, null);
    }

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

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

                try {
                    result = executeGetConnectAttachment(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 getConnectPeerAsync(GetConnectPeerRequest request) {

        return getConnectPeerAsync(request, null);
    }

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

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

                try {
                    result = executeGetConnectPeer(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 getConnectPeerAssociationsAsync(GetConnectPeerAssociationsRequest request) {

        return getConnectPeerAssociationsAsync(request, null);
    }

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

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

                try {
                    result = executeGetConnectPeerAssociations(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 getConnectionsAsync(GetConnectionsRequest request) {

        return getConnectionsAsync(request, null);
    }

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

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

                try {
                    result = executeGetConnections(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 getCoreNetworkAsync(GetCoreNetworkRequest request) {

        return getCoreNetworkAsync(request, null);
    }

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

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

                try {
                    result = executeGetCoreNetwork(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 getCoreNetworkChangeEventsAsync(GetCoreNetworkChangeEventsRequest request) {

        return getCoreNetworkChangeEventsAsync(request, null);
    }

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

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

                try {
                    result = executeGetCoreNetworkChangeEvents(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 getCoreNetworkChangeSetAsync(GetCoreNetworkChangeSetRequest request) {

        return getCoreNetworkChangeSetAsync(request, null);
    }

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

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

                try {
                    result = executeGetCoreNetworkChangeSet(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 getCoreNetworkPolicyAsync(GetCoreNetworkPolicyRequest request) {

        return getCoreNetworkPolicyAsync(request, null);
    }

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

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

                try {
                    result = executeGetCoreNetworkPolicy(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 getCustomerGatewayAssociationsAsync(GetCustomerGatewayAssociationsRequest request) {

        return getCustomerGatewayAssociationsAsync(request, null);
    }

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

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

                try {
                    result = executeGetCustomerGatewayAssociations(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 getDevicesAsync(GetDevicesRequest request) {

        return getDevicesAsync(request, null);
    }

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

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

                try {
                    result = executeGetDevices(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 getLinkAssociationsAsync(GetLinkAssociationsRequest request) {

        return getLinkAssociationsAsync(request, null);
    }

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

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

                try {
                    result = executeGetLinkAssociations(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 getLinksAsync(GetLinksRequest request) {

        return getLinksAsync(request, null);
    }

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

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

                try {
                    result = executeGetLinks(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 getNetworkResourceCountsAsync(GetNetworkResourceCountsRequest request) {

        return getNetworkResourceCountsAsync(request, null);
    }

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

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

                try {
                    result = executeGetNetworkResourceCounts(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 getNetworkResourceRelationshipsAsync(
            GetNetworkResourceRelationshipsRequest request) {

        return getNetworkResourceRelationshipsAsync(request, null);
    }

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

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

                try {
                    result = executeGetNetworkResourceRelationships(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 getNetworkResourcesAsync(GetNetworkResourcesRequest request) {

        return getNetworkResourcesAsync(request, null);
    }

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

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

                try {
                    result = executeGetNetworkResources(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 getNetworkRoutesAsync(GetNetworkRoutesRequest request) {

        return getNetworkRoutesAsync(request, null);
    }

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

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

                try {
                    result = executeGetNetworkRoutes(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 getNetworkTelemetryAsync(GetNetworkTelemetryRequest request) {

        return getNetworkTelemetryAsync(request, null);
    }

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

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

                try {
                    result = executeGetNetworkTelemetry(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 getResourcePolicyAsync(GetResourcePolicyRequest request) {

        return getResourcePolicyAsync(request, null);
    }

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

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

                try {
                    result = executeGetResourcePolicy(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 getRouteAnalysisAsync(GetRouteAnalysisRequest request) {

        return getRouteAnalysisAsync(request, null);
    }

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

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

                try {
                    result = executeGetRouteAnalysis(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 getSiteToSiteVpnAttachmentAsync(GetSiteToSiteVpnAttachmentRequest request) {

        return getSiteToSiteVpnAttachmentAsync(request, null);
    }

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

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

                try {
                    result = executeGetSiteToSiteVpnAttachment(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 getSitesAsync(GetSitesRequest request) {

        return getSitesAsync(request, null);
    }

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

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

                try {
                    result = executeGetSites(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 getTransitGatewayConnectPeerAssociationsAsync(
            GetTransitGatewayConnectPeerAssociationsRequest request) {

        return getTransitGatewayConnectPeerAssociationsAsync(request, null);
    }

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

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

                try {
                    result = executeGetTransitGatewayConnectPeerAssociations(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 getTransitGatewayPeeringAsync(GetTransitGatewayPeeringRequest request) {

        return getTransitGatewayPeeringAsync(request, null);
    }

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

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

                try {
                    result = executeGetTransitGatewayPeering(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 getTransitGatewayRegistrationsAsync(GetTransitGatewayRegistrationsRequest request) {

        return getTransitGatewayRegistrationsAsync(request, null);
    }

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

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

                try {
                    result = executeGetTransitGatewayRegistrations(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 getTransitGatewayRouteTableAttachmentAsync(
            GetTransitGatewayRouteTableAttachmentRequest request) {

        return getTransitGatewayRouteTableAttachmentAsync(request, null);
    }

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

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

                try {
                    result = executeGetTransitGatewayRouteTableAttachment(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 getVpcAttachmentAsync(GetVpcAttachmentRequest request) {

        return getVpcAttachmentAsync(request, null);
    }

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

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

                try {
                    result = executeGetVpcAttachment(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 listAttachmentsAsync(ListAttachmentsRequest request) {

        return listAttachmentsAsync(request, null);
    }

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

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

                try {
                    result = executeListAttachments(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 listConnectPeersAsync(ListConnectPeersRequest request) {

        return listConnectPeersAsync(request, null);
    }

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

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

                try {
                    result = executeListConnectPeers(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 listCoreNetworkPolicyVersionsAsync(ListCoreNetworkPolicyVersionsRequest request) {

        return listCoreNetworkPolicyVersionsAsync(request, null);
    }

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

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

                try {
                    result = executeListCoreNetworkPolicyVersions(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 listCoreNetworksAsync(ListCoreNetworksRequest request) {

        return listCoreNetworksAsync(request, null);
    }

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

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

                try {
                    result = executeListCoreNetworks(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 listOrganizationServiceAccessStatusAsync(
            ListOrganizationServiceAccessStatusRequest request) {

        return listOrganizationServiceAccessStatusAsync(request, null);
    }

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

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

                try {
                    result = executeListOrganizationServiceAccessStatus(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 listPeeringsAsync(ListPeeringsRequest request) {

        return listPeeringsAsync(request, null);
    }

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

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

                try {
                    result = executeListPeerings(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 putCoreNetworkPolicyAsync(PutCoreNetworkPolicyRequest request) {

        return putCoreNetworkPolicyAsync(request, null);
    }

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

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

                try {
                    result = executePutCoreNetworkPolicy(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 putResourcePolicyAsync(PutResourcePolicyRequest request) {

        return putResourcePolicyAsync(request, null);
    }

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

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

                try {
                    result = executePutResourcePolicy(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 registerTransitGatewayAsync(RegisterTransitGatewayRequest request) {

        return registerTransitGatewayAsync(request, null);
    }

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

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

                try {
                    result = executeRegisterTransitGateway(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 rejectAttachmentAsync(RejectAttachmentRequest request) {

        return rejectAttachmentAsync(request, null);
    }

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

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

                try {
                    result = executeRejectAttachment(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 restoreCoreNetworkPolicyVersionAsync(
            RestoreCoreNetworkPolicyVersionRequest request) {

        return restoreCoreNetworkPolicyVersionAsync(request, null);
    }

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

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

                try {
                    result = executeRestoreCoreNetworkPolicyVersion(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 startOrganizationServiceAccessUpdateAsync(
            StartOrganizationServiceAccessUpdateRequest request) {

        return startOrganizationServiceAccessUpdateAsync(request, null);
    }

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

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

                try {
                    result = executeStartOrganizationServiceAccessUpdate(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 startRouteAnalysisAsync(StartRouteAnalysisRequest request) {

        return startRouteAnalysisAsync(request, null);
    }

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

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

                try {
                    result = executeStartRouteAnalysis(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 updateConnectionAsync(UpdateConnectionRequest request) {

        return updateConnectionAsync(request, null);
    }

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

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

                try {
                    result = executeUpdateConnection(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 updateCoreNetworkAsync(UpdateCoreNetworkRequest request) {

        return updateCoreNetworkAsync(request, null);
    }

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

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

                try {
                    result = executeUpdateCoreNetwork(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 updateDeviceAsync(UpdateDeviceRequest request) {

        return updateDeviceAsync(request, null);
    }

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

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

                try {
                    result = executeUpdateDevice(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 updateGlobalNetworkAsync(UpdateGlobalNetworkRequest request) {

        return updateGlobalNetworkAsync(request, null);
    }

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

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

                try {
                    result = executeUpdateGlobalNetwork(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 updateLinkAsync(UpdateLinkRequest request) {

        return updateLinkAsync(request, null);
    }

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

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

                try {
                    result = executeUpdateLink(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 updateNetworkResourceMetadataAsync(UpdateNetworkResourceMetadataRequest request) {

        return updateNetworkResourceMetadataAsync(request, null);
    }

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

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

                try {
                    result = executeUpdateNetworkResourceMetadata(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 updateSiteAsync(UpdateSiteRequest request) {

        return updateSiteAsync(request, null);
    }

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

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

                try {
                    result = executeUpdateSite(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 updateVpcAttachmentAsync(UpdateVpcAttachmentRequest request) {

        return updateVpcAttachmentAsync(request, null);
    }

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

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

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