software.amazon.awssdk.services.protocolrestxml.DefaultProtocolRestXmlAsyncClient Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of protocol-tests Show documentation
Contains functional tests for all supported protocols.
There is a newer version: 2.0.6
/*
 * Copyright 2013-2018 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 software.amazon.awssdk.services.protocolrestxml;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.w3c.dom.Node;
import software.amazon.awssdk.annotations.Generated;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.awscore.client.handler.AwsAsyncClientHandler;
import software.amazon.awssdk.awscore.exception.AwsServiceException;
import software.amazon.awssdk.awscore.http.response.DefaultErrorResponseHandler;
import software.amazon.awssdk.awscore.http.response.StaxResponseHandler;
import software.amazon.awssdk.awscore.protocol.xml.StandardErrorUnmarshaller;
import software.amazon.awssdk.core.client.handler.AsyncClientHandler;
import software.amazon.awssdk.core.client.handler.ClientExecutionParams;
import software.amazon.awssdk.core.internal.client.config.SdkClientConfiguration;
import software.amazon.awssdk.core.runtime.transform.Unmarshaller;
import software.amazon.awssdk.services.protocolrestxml.model.AllTypesRequest;
import software.amazon.awssdk.services.protocolrestxml.model.AllTypesResponse;
import software.amazon.awssdk.services.protocolrestxml.model.DeleteOperationRequest;
import software.amazon.awssdk.services.protocolrestxml.model.DeleteOperationResponse;
import software.amazon.awssdk.services.protocolrestxml.model.IdempotentOperationRequest;
import software.amazon.awssdk.services.protocolrestxml.model.IdempotentOperationResponse;
import software.amazon.awssdk.services.protocolrestxml.model.MapOfStringToListOfStringInQueryParamsRequest;
import software.amazon.awssdk.services.protocolrestxml.model.MapOfStringToListOfStringInQueryParamsResponse;
import software.amazon.awssdk.services.protocolrestxml.model.MembersInHeadersRequest;
import software.amazon.awssdk.services.protocolrestxml.model.MembersInHeadersResponse;
import software.amazon.awssdk.services.protocolrestxml.model.MembersInQueryParamsRequest;
import software.amazon.awssdk.services.protocolrestxml.model.MembersInQueryParamsResponse;
import software.amazon.awssdk.services.protocolrestxml.model.MultiLocationOperationRequest;
import software.amazon.awssdk.services.protocolrestxml.model.MultiLocationOperationResponse;
import software.amazon.awssdk.services.protocolrestxml.model.OperationWithExplicitPayloadBlobRequest;
import software.amazon.awssdk.services.protocolrestxml.model.OperationWithExplicitPayloadBlobResponse;
import software.amazon.awssdk.services.protocolrestxml.model.OperationWithGreedyLabelRequest;
import software.amazon.awssdk.services.protocolrestxml.model.OperationWithGreedyLabelResponse;
import software.amazon.awssdk.services.protocolrestxml.model.OperationWithModeledContentTypeRequest;
import software.amazon.awssdk.services.protocolrestxml.model.OperationWithModeledContentTypeResponse;
import software.amazon.awssdk.services.protocolrestxml.model.ProtocolRestXmlException;
import software.amazon.awssdk.services.protocolrestxml.model.QueryParamWithoutValueRequest;
import software.amazon.awssdk.services.protocolrestxml.model.QueryParamWithoutValueResponse;
import software.amazon.awssdk.services.protocolrestxml.model.RestXmlTypesRequest;
import software.amazon.awssdk.services.protocolrestxml.model.RestXmlTypesResponse;
import software.amazon.awssdk.services.protocolrestxml.transform.AllTypesRequestMarshaller;
import software.amazon.awssdk.services.protocolrestxml.transform.AllTypesResponseUnmarshaller;
import software.amazon.awssdk.services.protocolrestxml.transform.DeleteOperationRequestMarshaller;
import software.amazon.awssdk.services.protocolrestxml.transform.DeleteOperationResponseUnmarshaller;
import software.amazon.awssdk.services.protocolrestxml.transform.EmptyModeledExceptionUnmarshaller;
import software.amazon.awssdk.services.protocolrestxml.transform.IdempotentOperationRequestMarshaller;
import software.amazon.awssdk.services.protocolrestxml.transform.IdempotentOperationResponseUnmarshaller;
import software.amazon.awssdk.services.protocolrestxml.transform.MapOfStringToListOfStringInQueryParamsRequestMarshaller;
import software.amazon.awssdk.services.protocolrestxml.transform.MapOfStringToListOfStringInQueryParamsResponseUnmarshaller;
import software.amazon.awssdk.services.protocolrestxml.transform.MembersInHeadersRequestMarshaller;
import software.amazon.awssdk.services.protocolrestxml.transform.MembersInHeadersResponseUnmarshaller;
import software.amazon.awssdk.services.protocolrestxml.transform.MembersInQueryParamsRequestMarshaller;
import software.amazon.awssdk.services.protocolrestxml.transform.MembersInQueryParamsResponseUnmarshaller;
import software.amazon.awssdk.services.protocolrestxml.transform.MultiLocationOperationRequestMarshaller;
import software.amazon.awssdk.services.protocolrestxml.transform.MultiLocationOperationResponseUnmarshaller;
import software.amazon.awssdk.services.protocolrestxml.transform.OperationWithExplicitPayloadBlobRequestMarshaller;
import software.amazon.awssdk.services.protocolrestxml.transform.OperationWithExplicitPayloadBlobResponseUnmarshaller;
import software.amazon.awssdk.services.protocolrestxml.transform.OperationWithGreedyLabelRequestMarshaller;
import software.amazon.awssdk.services.protocolrestxml.transform.OperationWithGreedyLabelResponseUnmarshaller;
import software.amazon.awssdk.services.protocolrestxml.transform.OperationWithModeledContentTypeRequestMarshaller;
import software.amazon.awssdk.services.protocolrestxml.transform.OperationWithModeledContentTypeResponseUnmarshaller;
import software.amazon.awssdk.services.protocolrestxml.transform.QueryParamWithoutValueRequestMarshaller;
import software.amazon.awssdk.services.protocolrestxml.transform.QueryParamWithoutValueResponseUnmarshaller;
import software.amazon.awssdk.services.protocolrestxml.transform.RestXmlTypesRequestMarshaller;
import software.amazon.awssdk.services.protocolrestxml.transform.RestXmlTypesResponseUnmarshaller;
import software.amazon.awssdk.utils.CompletableFutureUtils;

/**
 * Internal implementation of {@link ProtocolRestXmlAsyncClient}.
 *
 * @see ProtocolRestXmlAsyncClient#builder()
 */
@Generated("software.amazon.awssdk:codegen")
@SdkInternalApi
final class DefaultProtocolRestXmlAsyncClient implements ProtocolRestXmlAsyncClient {
    private static final Logger log = LoggerFactory.getLogger(DefaultProtocolRestXmlAsyncClient.class);

    private final AsyncClientHandler clientHandler;

    private final List> exceptionUnmarshallers;

    protected DefaultProtocolRestXmlAsyncClient(SdkClientConfiguration clientConfiguration) {
        this.clientHandler = new AwsAsyncClientHandler(clientConfiguration);
        this.exceptionUnmarshallers = init();
    }

    @Override
    public final String serviceName() {
        return SERVICE_NAME;
    }

    /**
     * Invokes the AllTypes operation asynchronously.
     *
     * @param allTypesRequest
     * @return A Java Future containing the result of the AllTypes operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         EmptyModeledException
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         ProtocolRestXmlException Base class for all service exceptions. Unknown exceptions will be thrown as
     *         an instance of this type.
     *         
     * @sample ProtocolRestXmlAsyncClient.AllTypes
     */
    @Override
    public CompletableFuture allTypes(AllTypesRequest allTypesRequest) {
        try {

            StaxResponseHandler responseHandler = new StaxResponseHandler(
                    new AllTypesResponseUnmarshaller());

            DefaultErrorResponseHandler errorResponseHandler = new DefaultErrorResponseHandler(exceptionUnmarshallers);

            return clientHandler.execute(new ClientExecutionParams()
                    .withMarshaller(new AllTypesRequestMarshaller()).withResponseHandler(responseHandler)
                    .withErrorResponseHandler(errorResponseHandler).withInput(allTypesRequest));
        } catch (Throwable t) {
            return CompletableFutureUtils.failedFuture(t);
        }
    }

    /**
     * Invokes the DeleteOperation operation asynchronously.
     *
     * @param deleteOperationRequest
     * @return A Java Future containing the result of the DeleteOperation operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         ProtocolRestXmlException Base class for all service exceptions. Unknown exceptions will be thrown as
     *         an instance of this type.
     *         
     * @sample ProtocolRestXmlAsyncClient.DeleteOperation
     */
    @Override
    public CompletableFuture deleteOperation(DeleteOperationRequest deleteOperationRequest) {
        try {

            StaxResponseHandler responseHandler = new StaxResponseHandler(
                    new DeleteOperationResponseUnmarshaller());

            DefaultErrorResponseHandler errorResponseHandler = new DefaultErrorResponseHandler(exceptionUnmarshallers);

            return clientHandler.execute(new ClientExecutionParams()
                    .withMarshaller(new DeleteOperationRequestMarshaller()).withResponseHandler(responseHandler)
                    .withErrorResponseHandler(errorResponseHandler).withInput(deleteOperationRequest));
        } catch (Throwable t) {
            return CompletableFutureUtils.failedFuture(t);
        }
    }

    /**
     * Invokes the IdempotentOperation operation asynchronously.
     *
     * @param idempotentOperationRequest
     * @return A Java Future containing the result of the IdempotentOperation operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         ProtocolRestXmlException Base class for all service exceptions. Unknown exceptions will be thrown as
     *         an instance of this type.
     *         
     * @sample ProtocolRestXmlAsyncClient.IdempotentOperation
     */
    @Override
    public CompletableFuture idempotentOperation(
            IdempotentOperationRequest idempotentOperationRequest) {
        try {

            StaxResponseHandler responseHandler = new StaxResponseHandler(
                    new IdempotentOperationResponseUnmarshaller());

            DefaultErrorResponseHandler errorResponseHandler = new DefaultErrorResponseHandler(exceptionUnmarshallers);

            return clientHandler.execute(new ClientExecutionParams()
                    .withMarshaller(new IdempotentOperationRequestMarshaller()).withResponseHandler(responseHandler)
                    .withErrorResponseHandler(errorResponseHandler).withInput(idempotentOperationRequest));
        } catch (Throwable t) {
            return CompletableFutureUtils.failedFuture(t);
        }
    }

    /**
     * Invokes the MapOfStringToListOfStringInQueryParams operation asynchronously.
     *
     * @param mapOfStringToListOfStringInQueryParamsRequest
     * @return A Java Future containing the result of the MapOfStringToListOfStringInQueryParams operation returned by
     *         the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         ProtocolRestXmlException Base class for all service exceptions. Unknown exceptions will be thrown as
     *         an instance of this type.
     *         
     * @sample ProtocolRestXmlAsyncClient.MapOfStringToListOfStringInQueryParams
     */
    @Override
    public CompletableFuture mapOfStringToListOfStringInQueryParams(
            MapOfStringToListOfStringInQueryParamsRequest mapOfStringToListOfStringInQueryParamsRequest) {
        try {

            StaxResponseHandler responseHandler = new StaxResponseHandler(
                    new MapOfStringToListOfStringInQueryParamsResponseUnmarshaller());

            DefaultErrorResponseHandler errorResponseHandler = new DefaultErrorResponseHandler(exceptionUnmarshallers);

            return clientHandler
                    .execute(new ClientExecutionParams()
                            .withMarshaller(new MapOfStringToListOfStringInQueryParamsRequestMarshaller())
                            .withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
                            .withInput(mapOfStringToListOfStringInQueryParamsRequest));
        } catch (Throwable t) {
            return CompletableFutureUtils.failedFuture(t);
        }
    }

    /**
     * Invokes the MembersInHeaders operation asynchronously.
     *
     * @param membersInHeadersRequest
     * @return A Java Future containing the result of the MembersInHeaders operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         ProtocolRestXmlException Base class for all service exceptions. Unknown exceptions will be thrown as
     *         an instance of this type.
     *         
     * @sample ProtocolRestXmlAsyncClient.MembersInHeaders
     */
    @Override
    public CompletableFuture membersInHeaders(MembersInHeadersRequest membersInHeadersRequest) {
        try {

            StaxResponseHandler responseHandler = new StaxResponseHandler(
                    new MembersInHeadersResponseUnmarshaller());

            DefaultErrorResponseHandler errorResponseHandler = new DefaultErrorResponseHandler(exceptionUnmarshallers);

            return clientHandler.execute(new ClientExecutionParams()
                    .withMarshaller(new MembersInHeadersRequestMarshaller()).withResponseHandler(responseHandler)
                    .withErrorResponseHandler(errorResponseHandler).withInput(membersInHeadersRequest));
        } catch (Throwable t) {
            return CompletableFutureUtils.failedFuture(t);
        }
    }

    /**
     * Invokes the MembersInQueryParams operation asynchronously.
     *
     * @param membersInQueryParamsRequest
     * @return A Java Future containing the result of the MembersInQueryParams operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         ProtocolRestXmlException Base class for all service exceptions. Unknown exceptions will be thrown as
     *         an instance of this type.
     *         
     * @sample ProtocolRestXmlAsyncClient.MembersInQueryParams
     */
    @Override
    public CompletableFuture membersInQueryParams(
            MembersInQueryParamsRequest membersInQueryParamsRequest) {
        try {

            StaxResponseHandler responseHandler = new StaxResponseHandler(
                    new MembersInQueryParamsResponseUnmarshaller());

            DefaultErrorResponseHandler errorResponseHandler = new DefaultErrorResponseHandler(exceptionUnmarshallers);

            return clientHandler.execute(new ClientExecutionParams()
                    .withMarshaller(new MembersInQueryParamsRequestMarshaller()).withResponseHandler(responseHandler)
                    .withErrorResponseHandler(errorResponseHandler).withInput(membersInQueryParamsRequest));
        } catch (Throwable t) {
            return CompletableFutureUtils.failedFuture(t);
        }
    }

    /**
     * Invokes the MultiLocationOperation operation asynchronously.
     *
     * @param multiLocationOperationRequest
     * @return A Java Future containing the result of the MultiLocationOperation operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         ProtocolRestXmlException Base class for all service exceptions. Unknown exceptions will be thrown as
     *         an instance of this type.
     *         
     * @sample ProtocolRestXmlAsyncClient.MultiLocationOperation
     */
    @Override
    public CompletableFuture multiLocationOperation(
            MultiLocationOperationRequest multiLocationOperationRequest) {
        try {

            StaxResponseHandler responseHandler = new StaxResponseHandler(
                    new MultiLocationOperationResponseUnmarshaller());

            DefaultErrorResponseHandler errorResponseHandler = new DefaultErrorResponseHandler(exceptionUnmarshallers);

            return clientHandler
                    .execute(new ClientExecutionParams()
                            .withMarshaller(new MultiLocationOperationRequestMarshaller()).withResponseHandler(responseHandler)
                            .withErrorResponseHandler(errorResponseHandler).withInput(multiLocationOperationRequest));
        } catch (Throwable t) {
            return CompletableFutureUtils.failedFuture(t);
        }
    }

    /**
     * Invokes the OperationWithExplicitPayloadBlob operation asynchronously.
     *
     * @param operationWithExplicitPayloadBlobRequest
     * @return A Java Future containing the result of the OperationWithExplicitPayloadBlob operation returned by the
     *         service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         ProtocolRestXmlException Base class for all service exceptions. Unknown exceptions will be thrown as
     *         an instance of this type.
     *         
     * @sample ProtocolRestXmlAsyncClient.OperationWithExplicitPayloadBlob
     */
    @Override
    public CompletableFuture operationWithExplicitPayloadBlob(
            OperationWithExplicitPayloadBlobRequest operationWithExplicitPayloadBlobRequest) {
        try {

            StaxResponseHandler responseHandler = new StaxResponseHandler(
                    new OperationWithExplicitPayloadBlobResponseUnmarshaller());

            DefaultErrorResponseHandler errorResponseHandler = new DefaultErrorResponseHandler(exceptionUnmarshallers);

            return clientHandler
                    .execute(new ClientExecutionParams()
                            .withMarshaller(new OperationWithExplicitPayloadBlobRequestMarshaller())
                            .withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
                            .withInput(operationWithExplicitPayloadBlobRequest));
        } catch (Throwable t) {
            return CompletableFutureUtils.failedFuture(t);
        }
    }

    /**
     * Invokes the OperationWithGreedyLabel operation asynchronously.
     *
     * @param operationWithGreedyLabelRequest
     * @return A Java Future containing the result of the OperationWithGreedyLabel operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         ProtocolRestXmlException Base class for all service exceptions. Unknown exceptions will be thrown as
     *         an instance of this type.
     *         
     * @sample ProtocolRestXmlAsyncClient.OperationWithGreedyLabel
     */
    @Override
    public CompletableFuture operationWithGreedyLabel(
            OperationWithGreedyLabelRequest operationWithGreedyLabelRequest) {
        try {

            StaxResponseHandler responseHandler = new StaxResponseHandler(
                    new OperationWithGreedyLabelResponseUnmarshaller());

            DefaultErrorResponseHandler errorResponseHandler = new DefaultErrorResponseHandler(exceptionUnmarshallers);

            return clientHandler
                    .execute(new ClientExecutionParams()
                            .withMarshaller(new OperationWithGreedyLabelRequestMarshaller()).withResponseHandler(responseHandler)
                            .withErrorResponseHandler(errorResponseHandler).withInput(operationWithGreedyLabelRequest));
        } catch (Throwable t) {
            return CompletableFutureUtils.failedFuture(t);
        }
    }

    /**
     * Invokes the OperationWithModeledContentType operation asynchronously.
     *
     * @param operationWithModeledContentTypeRequest
     * @return A Java Future containing the result of the OperationWithModeledContentType operation returned by the
     *         service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         ProtocolRestXmlException Base class for all service exceptions. Unknown exceptions will be thrown as
     *         an instance of this type.
     *         
     * @sample ProtocolRestXmlAsyncClient.OperationWithModeledContentType
     */
    @Override
    public CompletableFuture operationWithModeledContentType(
            OperationWithModeledContentTypeRequest operationWithModeledContentTypeRequest) {
        try {

            StaxResponseHandler responseHandler = new StaxResponseHandler(
                    new OperationWithModeledContentTypeResponseUnmarshaller());

            DefaultErrorResponseHandler errorResponseHandler = new DefaultErrorResponseHandler(exceptionUnmarshallers);

            return clientHandler
                    .execute(new ClientExecutionParams()
                            .withMarshaller(new OperationWithModeledContentTypeRequestMarshaller())
                            .withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
                            .withInput(operationWithModeledContentTypeRequest));
        } catch (Throwable t) {
            return CompletableFutureUtils.failedFuture(t);
        }
    }

    /**
     * Invokes the QueryParamWithoutValue operation asynchronously.
     *
     * @param queryParamWithoutValueRequest
     * @return A Java Future containing the result of the QueryParamWithoutValue operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         ProtocolRestXmlException Base class for all service exceptions. Unknown exceptions will be thrown as
     *         an instance of this type.
     *         
     * @sample ProtocolRestXmlAsyncClient.QueryParamWithoutValue
     */
    @Override
    public CompletableFuture queryParamWithoutValue(
            QueryParamWithoutValueRequest queryParamWithoutValueRequest) {
        try {

            StaxResponseHandler responseHandler = new StaxResponseHandler(
                    new QueryParamWithoutValueResponseUnmarshaller());

            DefaultErrorResponseHandler errorResponseHandler = new DefaultErrorResponseHandler(exceptionUnmarshallers);

            return clientHandler
                    .execute(new ClientExecutionParams()
                            .withMarshaller(new QueryParamWithoutValueRequestMarshaller()).withResponseHandler(responseHandler)
                            .withErrorResponseHandler(errorResponseHandler).withInput(queryParamWithoutValueRequest));
        } catch (Throwable t) {
            return CompletableFutureUtils.failedFuture(t);
        }
    }

    /**
     * Invokes the RestXmlTypes operation asynchronously.
     *
     * @param restXmlTypesRequest
     * @return A Java Future containing the result of the RestXmlTypes operation returned by the service.

     *         The CompletableFuture returned by this method can be completed exceptionally with the following
     *         exceptions.
     *         
     *         SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
     *         Can be used for catch all scenarios.
     *         SdkClientException If any client side error occurs such as an IO related failure, failure to get
     *         credentials, etc.
     *         ProtocolRestXmlException Base class for all service exceptions. Unknown exceptions will be thrown as
     *         an instance of this type.
     *         
     * @sample ProtocolRestXmlAsyncClient.RestXmlTypes
     */
    @Override
    public CompletableFuture restXmlTypes(RestXmlTypesRequest restXmlTypesRequest) {
        try {

            StaxResponseHandler responseHandler = new StaxResponseHandler(
                    new RestXmlTypesResponseUnmarshaller());

            DefaultErrorResponseHandler errorResponseHandler = new DefaultErrorResponseHandler(exceptionUnmarshallers);

            return clientHandler.execute(new ClientExecutionParams()
                    .withMarshaller(new RestXmlTypesRequestMarshaller()).withResponseHandler(responseHandler)
                    .withErrorResponseHandler(errorResponseHandler).withInput(restXmlTypesRequest));
        } catch (Throwable t) {
            return CompletableFutureUtils.failedFuture(t);
        }
    }

    @Override
    public void close() {
        clientHandler.close();
    }

    private List> init() {
        List> unmarshallers = new ArrayList<>();
        unmarshallers.add(new EmptyModeledExceptionUnmarshaller());
        unmarshallers.add(new StandardErrorUnmarshaller(ProtocolRestXmlException.class));
        return unmarshallers;
    }
}