org.jboss.resteasy.client.jaxrs.internal

## Class AsynchronousInvoke

- java.lang.Object
- - org.jboss.resteasy.client.jaxrs.internal.AsynchronousInvoke

- All Implemented Interfaces:
    AsyncInvoker

      public class AsynchronousInvoke
      extends Object
      implements AsyncInvoker

  Version:
    $Revision: 1 $
  Author:
    Bill Burke

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected ClientInvocation` | `invocation`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `AsynchronousInvoke(ClientInvocation invocation)`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `Future<Response>` | `delete()` Invoke HTTP DELETE method for the current request asynchronously.
    `<T> Future<T>` | `delete(Class<T> responseType)` Invoke HTTP DELETE method for the current request asynchronously.
    `<T> Future<T>` | `delete(GenericType<T> responseType)` Invoke HTTP DELETE method for the current request asynchronously.
    `<T> Future<T>` | `delete(InvocationCallback<T> callback)` Invoke HTTP DELETE method for the current request asynchronously.
    `Future<Response>` | `get()` Invoke HTTP GET method for the current request asynchronously.
    `<T> Future<T>` | `get(Class<T> responseType)` Invoke HTTP GET method for the current request asynchronously.
    `<T> Future<T>` | `get(GenericType<T> responseType)` Invoke HTTP GET method for the current request asynchronously.
    `<T> Future<T>` | `get(InvocationCallback<T> callback)` Invoke HTTP GET method for the current request asynchronously.
    `Future<Response>` | `head()` Invoke HTTP HEAD method for the current request asynchronously.
    `Future<Response>` | `head(InvocationCallback<Response> callback)` Invoke HTTP HEAD method for the current request asynchronously.
    `Future<Response>` | `method(String name)` Invoke an arbitrary method for the current request asynchronously.
    `<T> Future<T>` | `method(String name, Class<T> responseType)` Invoke an arbitrary method for the current request asynchronously.
    `Future<Response>` | `method(String name, Entity<?> entity)` Invoke an arbitrary method for the current request asynchronously.
    `<T> Future<T>` | `method(String name, Entity<?> entity, Class<T> responseType)` Invoke an arbitrary method for the current request asynchronously.
    `<T> Future<T>` | `method(String name, Entity<?> entity, GenericType<T> responseType)` Invoke an arbitrary method for the current request asynchronously.
    `<T> Future<T>` | `method(String name, Entity<?> entity, InvocationCallback<T> callback)` Invoke an arbitrary method for the current request asynchronously.
    `<T> Future<T>` | `method(String name, GenericType<T> responseType)` Invoke an arbitrary method for the current request asynchronously.
    `<T> Future<T>` | `method(String name, InvocationCallback<T> callback)` Invoke an arbitrary method for the current request asynchronously.
    `Future<Response>` | `options()` Invoke HTTP OPTIONS method for the current request asynchronously.
    `<T> Future<T>` | `options(Class<T> responseType)` Invoke HTTP OPTIONS method for the current request asynchronously.
    `<T> Future<T>` | `options(GenericType<T> responseType)` Invoke HTTP OPTIONS method for the current request asynchronously.
    `<T> Future<T>` | `options(InvocationCallback<T> callback)` Invoke HTTP OPTIONS method for the current request asynchronously.
    `Future<Response>` | `post(Entity<?> entity)` Invoke HTTP POST method for the current request asynchronously.
    `<T> Future<T>` | `post(Entity<?> entity, Class<T> responseType)` Invoke HTTP POST method for the current request asynchronously.
    `<T> Future<T>` | `post(Entity<?> entity, GenericType<T> responseType)` Invoke HTTP POST method for the current request asynchronously.
    `<T> Future<T>` | `post(Entity<?> entity, InvocationCallback<T> callback)` Invoke HTTP POST method for the current request asynchronously.
    `Future<Response>` | `put(Entity<?> entity)` Invoke HTTP PUT method for the current request asynchronously.
    `<T> Future<T>` | `put(Entity<?> entity, Class<T> responseType)` Invoke HTTP PUT method for the current request asynchronously.
    `<T> Future<T>` | `put(Entity<?> entity, GenericType<T> responseType)` Invoke HTTP PUT method for the current request asynchronously.
    `<T> Future<T>` | `put(Entity<?> entity, InvocationCallback<T> callback)` Invoke HTTP PUT method for the current request asynchronously.
    `Future<Response>` | `trace()` Invoke HTTP TRACE method for the current request asynchronously.
    `<T> Future<T>` | `trace(Class<T> responseType)` Invoke HTTP TRACE method for the current request asynchronously.
    `<T> Future<T>` | `trace(GenericType<T> responseType)` Invoke HTTP TRACE method for the current request asynchronously.
    `<T> Future<T>` | `trace(InvocationCallback<T> callback)` Invoke HTTP TRACE method for the current request asynchronously.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### invocation

          protected ClientInvocation invocation

  - ### Constructor Detail

    - #### AsynchronousInvoke

          public AsynchronousInvoke(ClientInvocation invocation)

  - ### Method Detail

    - #### get

          public Future<Response> get()

      Description copied from interface: `AsyncInvoker`
      Invoke HTTP GET method for the current request asynchronously.

      Note that calling the `Future.get()` method on the returned `Future` instance may throw an `ExecutionException` that wraps a `ProcessingException` thrown in case of an invocation processing failure. Note that in case a processing of a properly received response fails, the wrapped processing exception will be of `ResponseProcessingException` type and will contain the `Response` instance whose processing has failed.

      Specified by:
        `get` in interface `AsyncInvoker`
      Returns:
        invocation response `future`.

    - #### get

          public <T> Future<T> get(Class<T> responseType)

      Description copied from interface: `AsyncInvoker`
      Invoke HTTP GET method for the current request asynchronously.

      Note that calling the `Future.get()` method on the returned `Future` instance may throw an `ExecutionException` that wraps either a `ProcessingException` thrown in case of an invocation processing failure or a `WebApplicationException` or one of its subclasses thrown in case the received response status code is not `successful` and the specified response type is not `Response`. In case a processing of a properly received response fails, the wrapped processing exception will be of `ResponseProcessingException` type and will contain the `Response` instance whose processing has failed.

      Specified by:
        `get` in interface `AsyncInvoker`
      Type Parameters:
        `T` - response entity type.
      Parameters:
        `responseType` - Java type the response entity will be converted to.
      Returns:
        invocation response `future`.

    - #### get

          public <T> Future<T> get(GenericType<T> responseType)

      Description copied from interface: `AsyncInvoker`
      Invoke HTTP GET method for the current request asynchronously.

      Note that calling the `Future.get()` method on the returned `Future` instance may throw an `ExecutionException` that wraps either a `ProcessingException` thrown in case of an invocation processing failure or a `WebApplicationException` or one of its subclasses thrown in case the received response status code is not `successful` and the specified response type is not `Response`. In case a processing of a properly received response fails, the wrapped processing exception will be of `ResponseProcessingException` type and will contain the `Response` instance whose processing has failed.

      Specified by:
        `get` in interface `AsyncInvoker`
      Type Parameters:
        `T` - generic response entity type.
      Parameters:
        `responseType` - representation of a generic Java type the response entity will be converted to.
      Returns:
        invocation response `future`.

    - #### get

          public <T> Future<T> get(InvocationCallback<T> callback)

      Description copied from interface: `AsyncInvoker`
      Invoke HTTP GET method for the current request asynchronously.

      Note that calling the `Future.get()` method on the returned `Future` instance may throw an `ExecutionException` that wraps either a `ProcessingException` thrown in case of an invocation processing failure or a `WebApplicationException` or one of its subclasses thrown in case the received response status code is not `successful` and the generic type of the supplied response callback is not `Response`. In case a processing of a properly received response fails, the wrapped processing exception will be of `ResponseProcessingException` type and will contain the `Response` instance whose processing has failed.

      Specified by:
        `get` in interface `AsyncInvoker`
      Type Parameters:
        `T` - generic response entity type.
      Parameters:
        `callback` - asynchronous invocation callback.
      Returns:
        invocation response `future`.

    - #### trace

          public Future<Response> trace()

      Description copied from interface: `AsyncInvoker`
      Invoke HTTP TRACE method for the current request asynchronously.

      Note that calling the `Future.get()` method on the returned `Future` instance may throw an `ExecutionException` that wraps a `ProcessingException` thrown in case of an invocation processing failure. In case a processing of a properly received response fails, the wrapped processing exception will be of `ResponseProcessingException` type and will contain the `Response` instance whose processing has failed.

      Specified by:
        `trace` in interface `AsyncInvoker`
      Returns:
        invocation response `future`.

    - #### trace

          public <T> Future<T> trace(Class<T> responseType)

      Description copied from interface: `AsyncInvoker`
      Invoke HTTP TRACE method for the current request asynchronously.

      Note that calling the `Future.get()` method on the returned `Future` instance may throw an `ExecutionException` that wraps either a `ProcessingException` thrown in case of an invocation processing failure or a `WebApplicationException` or one of its subclasses thrown in case the received response status code is not `successful` and the specified response type is not `Response`. In case a processing of a properly received response fails, the wrapped processing exception will be of `ResponseProcessingException` type and will contain the `Response` instance whose processing has failed.

      Specified by:
        `trace` in interface `AsyncInvoker`
      Type Parameters:
        `T` - response entity type.
      Parameters:
        `responseType` - Java type the response entity will be converted to.
      Returns:
        invocation response `future`.

    - #### trace

          public <T> Future<T> trace(GenericType<T> responseType)

      Description copied from interface: `AsyncInvoker`
      Invoke HTTP TRACE method for the current request asynchronously.

      Note that calling the `Future.get()` method on the returned `Future` instance may throw an `ExecutionException` that wraps either a `ProcessingException` thrown in case of an invocation processing failure or a `WebApplicationException` or one of its subclasses thrown in case the received response status code is not `successful` and the specified response type is not `Response`. In case a processing of a properly received response fails, the wrapped processing exception will be of `ResponseProcessingException` type and will contain the `Response` instance whose processing has failed.

      Specified by:
        `trace` in interface `AsyncInvoker`
      Type Parameters:
        `T` - generic response entity type.
      Parameters:
        `responseType` - representation of a generic Java type the response entity will be converted to.
      Returns:
        invocation response `future`.

    - #### trace

          public <T> Future<T> trace(InvocationCallback<T> callback)

      Description copied from interface: `AsyncInvoker`
      Invoke HTTP TRACE method for the current request asynchronously.

      Note that calling the `Future.get()` method on the returned `Future` instance may throw an `ExecutionException` that wraps either a `ProcessingException` thrown in case of an invocation processing failure or a `WebApplicationException` or one of its subclasses thrown in case the received response status code is not `successful` and the generic type of the supplied response callback is not `Response`. In case a processing of a properly received response fails, the wrapped processing exception will be of `ResponseProcessingException` type and will contain the `Response` instance whose processing has failed.

      Specified by:
        `trace` in interface `AsyncInvoker`
      Type Parameters:
        `T` - generic response entity type.
      Parameters:
        `callback` - asynchronous invocation callback.
      Returns:
        invocation response `future`.

    - #### put

          public Future<Response> put(Entity<?> entity)

      Description copied from interface: `AsyncInvoker`
      Invoke HTTP PUT method for the current request asynchronously.

      Note that calling the `Future.get()` method on the returned `Future` instance may throw an `ExecutionException` that wraps a `ProcessingException` thrown in case of an invocation processing failure. In case a processing of a properly received response fails, the wrapped processing exception will be of `ResponseProcessingException` type and will contain the `Response` instance whose processing has failed.

      Specified by:
        `put` in interface `AsyncInvoker`
      Parameters:
        `entity` - request entity, including it's full `Variant` information. Any variant-related HTTP headers previously set (namely `Content-Type`, `Content-Language` and `Content-Encoding`) will be overwritten using the entity variant information.
      Returns:
        invocation response `future`.

    - #### put

          public <T> Future<T> put(Entity<?> entity,
                          Class<T> responseType)

      Description copied from interface: `AsyncInvoker`
      Invoke HTTP PUT method for the current request asynchronously.

      Note that calling the `Future.get()` method on the returned `Future` instance may throw an `ExecutionException` that wraps either a `ProcessingException` thrown in case of an invocation processing failure or a `WebApplicationException` or one of its subclasses thrown in case the received response status code is not `successful` and the specified response type is not `Response`. In case a processing of a properly received response fails, the wrapped processing exception will be of `ResponseProcessingException` type and will contain the `Response` instance whose processing has failed.

      Specified by:
        `put` in interface `AsyncInvoker`
      Type Parameters:
        `T` - response entity type.
      Parameters:
        `entity` - request entity, including it's full `Variant` information. Any variant-related HTTP headers previously set (namely `Content-Type`, `Content-Language` and `Content-Encoding`) will be overwritten using the entity variant information.
        `responseType` - Java type the response entity will be converted to.
      Returns:
        invocation response `future`.

    - #### put

          public <T> Future<T> put(Entity<?> entity,
                          GenericType<T> responseType)

      Description copied from interface: `AsyncInvoker`
      Invoke HTTP PUT method for the current request asynchronously.

      Note that calling the `Future.get()` method on the returned `Future` instance may throw an `ExecutionException` that wraps either a `ProcessingException` thrown in case of an invocation processing failure or a `WebApplicationException` or one of its subclasses thrown in case the received response status code is not `successful` and the specified response type is not `Response`. In case a processing of a properly received response fails, the wrapped processing exception will be of `ResponseProcessingException` type and will contain the `Response` instance whose processing has failed.

      Specified by:
        `put` in interface `AsyncInvoker`
      Type Parameters:
        `T` - generic response entity type.
      Parameters:
        `entity` - request entity, including it's full `Variant` information. Any variant-related HTTP headers previously set (namely `Content-Type`, `Content-Language` and `Content-Encoding`) will be overwritten using the entity variant information.
        `responseType` - representation of a generic Java type the response entity will be converted to.
      Returns:
        invocation response `future`.

    - #### put

          public <T> Future<T> put(Entity<?> entity,
                          InvocationCallback<T> callback)

      Description copied from interface: `AsyncInvoker`
      Invoke HTTP PUT method for the current request asynchronously.

      Note that calling the `Future.get()` method on the returned `Future` instance may throw an `ExecutionException` that wraps either a `ProcessingException` thrown in case of an invocation processing failure or a `WebApplicationException` or one of its subclasses thrown in case the received response status code is not `successful` and the generic type of the supplied response callback is not `Response`. In case a processing of a properly received response fails, the wrapped processing exception will be of `ResponseProcessingException` type and will contain the `Response` instance whose processing has failed.

      Specified by:
        `put` in interface `AsyncInvoker`
      Type Parameters:
        `T` - generic response entity type.
      Parameters:
        `entity` - request entity, including it's full `Variant` information. Any variant-related HTTP headers previously set (namely `Content-Type`, `Content-Language` and `Content-Encoding`) will be overwritten using the entity variant information.
        `callback` - asynchronous invocation callback.
      Returns:
        invocation response `future`.

    - #### post

          public Future<Response> post(Entity<?> entity)

      Description copied from interface: `AsyncInvoker`
      Invoke HTTP POST method for the current request asynchronously.

      Note that calling the `Future.get()` method on the returned `Future` instance may throw an `ExecutionException` that wraps a `ProcessingException` thrown in case of an invocation processing failure. In case a processing of a properly received response fails, the wrapped processing exception will be of `ResponseProcessingException` type and will contain the `Response` instance whose processing has failed.

      Specified by:
        `post` in interface `AsyncInvoker`
      Parameters:
        `entity` - request entity, including it's full `Variant` information. Any variant-related HTTP headers previously set (namely `Content-Type`, `Content-Language` and `Content-Encoding`) will be overwritten using the entity variant information.
      Returns:
        invocation response `future`.

    - #### post

          public <T> Future<T> post(Entity<?> entity,
                           Class<T> responseType)

      Description copied from interface: `AsyncInvoker`
      Invoke HTTP POST method for the current request asynchronously.

      Note that calling the `Future.get()` method on the returned `Future` instance may throw an `ExecutionException` that wraps either a `ProcessingException` thrown in case of an invocation processing failure or a `WebApplicationException` or one of its subclasses thrown in case the received response status code is not `successful` and the specified response type is not `Response`. In case a processing of a properly received response fails, the wrapped processing exception will be of `ResponseProcessingException` type and will contain the `Response` instance whose processing has failed.

      Specified by:
        `post` in interface `AsyncInvoker`
      Type Parameters:
        `T` - response entity type.
      Parameters:
        `entity` - request entity, including it's full `Variant` information. Any variant-related HTTP headers previously set (namely `Content-Type`, `Content-Language` and `Content-Encoding`) will be overwritten using the entity variant information.
        `responseType` - Java type the response entity will be converted to.
      Returns:
        invocation response `future`.

    - #### post

          public <T> Future<T> post(Entity<?> entity,
                           GenericType<T> responseType)

      Description copied from interface: `AsyncInvoker`
      Invoke HTTP POST method for the current request asynchronously.

      Note that calling the `Future.get()` method on the returned `Future` instance may throw an `ExecutionException` that wraps either a `ProcessingException` thrown in case of an invocation processing failure or a `WebApplicationException` or one of its subclasses thrown in case the received response status code is not `successful` and the specified response type is not `Response`. In case a processing of a properly received response fails, the wrapped processing exception will be of `ResponseProcessingException` type and will contain the `Response` instance whose processing has failed.

      Specified by:
        `post` in interface `AsyncInvoker`
      Type Parameters:
        `T` - generic response entity type.
      Parameters:
        `entity` - request entity, including it's full `Variant` information. Any variant-related HTTP headers previously set (namely `Content-Type`, `Content-Language` and `Content-Encoding`) will be overwritten using the entity variant information.
        `responseType` - representation of a generic Java type the response entity will be converted to.
      Returns:
        invocation response `future`.

    - #### post

          public <T> Future<T> post(Entity<?> entity,
                           InvocationCallback<T> callback)

      Description copied from interface: `AsyncInvoker`
      Invoke HTTP POST method for the current request asynchronously.

      Note that calling the `Future.get()` method on the returned `Future` instance may throw an `ExecutionException` that wraps either a `ProcessingException` thrown in case of an invocation processing failure or a `WebApplicationException` or one of its subclasses thrown in case the received response status code is not `successful` and the generic type of the supplied response callback is not `Response`. In case a processing of a properly received response fails, the wrapped processing exception will be of `ResponseProcessingException` type and will contain the `Response` instance whose processing has failed.

      Specified by:
        `post` in interface `AsyncInvoker`
      Type Parameters:
        `T` - generic response entity type.
      Parameters:
        `entity` - request entity, including it's full `Variant` information. Any variant-related HTTP headers previously set (namely `Content-Type`, `Content-Language` and `Content-Encoding`) will be overwritten using the entity variant information.
        `callback` - asynchronous invocation callback.
      Returns:
        invocation response `future`.

    - #### delete

          public Future<Response> delete()

      Description copied from interface: `AsyncInvoker`
      Invoke HTTP DELETE method for the current request asynchronously.

      Note that calling the `Future.get()` method on the returned `Future` instance may throw an `ExecutionException` that wraps a `ProcessingException` thrown in case of an invocation processing failure. In case a processing of a properly received response fails, the wrapped processing exception will be of `ResponseProcessingException` type and will contain the `Response` instance whose processing has failed.

      Specified by:
        `delete` in interface `AsyncInvoker`
      Returns:
        invocation response `future`.

    - #### delete

          public <T> Future<T> delete(Class<T> responseType)

      Description copied from interface: `AsyncInvoker`
      Invoke HTTP DELETE method for the current request asynchronously.

      Note that calling the `Future.get()` method on the returned `Future` instance may throw an `ExecutionException` that wraps either a `ProcessingException` thrown in case of an invocation processing failure or a `WebApplicationException` or one of its subclasses thrown in case the received response status code is not `successful` and the specified response type is not `Response`. In case a processing of a properly received response fails, the wrapped processing exception will be of `ResponseProcessingException` type and will contain the `Response` instance whose processing has failed.

      Specified by:
        `delete` in interface `AsyncInvoker`
      Type Parameters:
        `T` - response entity type.
      Parameters:
        `responseType` - Java type the response entity will be converted to.
      Returns:
        invocation response `future`.

    - #### delete

          public <T> Future<T> delete(GenericType<T> responseType)

      Description copied from interface: `AsyncInvoker`
      Invoke HTTP DELETE method for the current request asynchronously.

      Note that calling the `Future.get()` method on the returned `Future` instance may throw an `ExecutionException` that wraps either a `ProcessingException` thrown in case of an invocation processing failure or a `WebApplicationException` or one of its subclasses thrown in case the received response status code is not `successful` and the specified response type is not `Response`. In case a processing of a properly received response fails, the wrapped processing exception will be of `ResponseProcessingException` type and will contain the `Response` instance whose processing has failed.

      Specified by:
        `delete` in interface `AsyncInvoker`
      Type Parameters:
        `T` - generic response entity type.
      Parameters:
        `responseType` - representation of a generic Java type the response entity will be converted to.
      Returns:
        invocation response `future`.

    - #### delete

          public <T> Future<T> delete(InvocationCallback<T> callback)

      Description copied from interface: `AsyncInvoker`
      Invoke HTTP DELETE method for the current request asynchronously.

      Note that calling the `Future.get()` method on the returned `Future` instance may throw an `ExecutionException` that wraps either a `ProcessingException` thrown in case of an invocation processing failure or a `WebApplicationException` or one of its subclasses thrown in case the received response status code is not `successful` and the generic type of the supplied response callback is not `Response`. In case a processing of a properly received response fails, the wrapped processing exception will be of `ResponseProcessingException` type and will contain the `Response` instance whose processing has failed.

      Specified by:
        `delete` in interface `AsyncInvoker`
      Type Parameters:
        `T` - generic response entity type.
      Parameters:
        `callback` - asynchronous invocation callback.
      Returns:
        invocation response `future`.

    - #### head

          public Future<Response> head()

      Description copied from interface: `AsyncInvoker`
      Invoke HTTP HEAD method for the current request asynchronously.

      Note that calling the `Future.get()` method on the returned `Future` instance may throw an `ExecutionException` that wraps a `ProcessingException` thrown in case of an invocation processing failure. In case a processing of a properly received response fails, the wrapped processing exception will be of `ResponseProcessingException` type and will contain the `Response` instance whose processing has failed.

      Specified by:
        `head` in interface `AsyncInvoker`
      Returns:
        invocation response `future`.

    - #### head

          public Future<Response> head(InvocationCallback<Response> callback)

      Description copied from interface: `AsyncInvoker`
      Invoke HTTP HEAD method for the current request asynchronously.

      Note that calling the `Future.get()` method on the returned `Future` instance may throw an `ExecutionException` that wraps a `ProcessingException` thrown in case of an invocation processing failure. In case a processing of a properly received response fails, the wrapped processing exception will be of `ResponseProcessingException` type and will contain the `Response` instance whose processing has failed.

      Specified by:
        `head` in interface `AsyncInvoker`
      Parameters:
        `callback` - asynchronous invocation callback.
      Returns:
        invocation response `future`.

    - #### options

          public Future<Response> options()

      Description copied from interface: `AsyncInvoker`
      Invoke HTTP OPTIONS method for the current request asynchronously.

      Note that calling the `Future.get()` method on the returned `Future` instance may throw an `ExecutionException` that wraps a `ProcessingException` thrown in case of an invocation processing failure. In case a processing of a properly received response fails, the wrapped processing exception will be of `ResponseProcessingException` type and will contain the `Response` instance whose processing has failed.

      Specified by:
        `options` in interface `AsyncInvoker`
      Returns:
        invocation response `future`.

    - #### options

          public <T> Future<T> options(Class<T> responseType)

      Description copied from interface: `AsyncInvoker`
      Invoke HTTP OPTIONS method for the current request asynchronously.

      Note that calling the `Future.get()` method on the returned `Future` instance may throw an `ExecutionException` that wraps either a `ProcessingException` thrown in case of an invocation processing failure or a `WebApplicationException` or one of its subclasses thrown in case the received response status code is not `successful` and the specified response type is not `Response`. In case a processing of a properly received response fails, the wrapped processing exception will be of `ResponseProcessingException` type and will contain the `Response` instance whose processing has failed.

      Specified by:
        `options` in interface `AsyncInvoker`
      Type Parameters:
        `T` - response entity type.
      Parameters:
        `responseType` - Java type the response entity will be converted to.
      Returns:
        invocation response `future`.

    - #### options

          public <T> Future<T> options(GenericType<T> responseType)

      Description copied from interface: `AsyncInvoker`
      Invoke HTTP OPTIONS method for the current request asynchronously.

      Note that calling the `Future.get()` method on the returned `Future` instance may throw an `ExecutionException` that wraps either a `ProcessingException` thrown in case of an invocation processing failure or a `WebApplicationException` or one of its subclasses thrown in case the received response status code is not `successful` and the specified response type is not `Response`. In case a processing of a properly received response fails, the wrapped processing exception will be of `ResponseProcessingException` type and will contain the `Response` instance whose processing has failed.

      Specified by:
        `options` in interface `AsyncInvoker`
      Type Parameters:
        `T` - generic response entity type.
      Parameters:
        `responseType` - representation of a generic Java type the response entity will be converted to.
      Returns:
        invocation response `future`.

    - #### options

          public <T> Future<T> options(InvocationCallback<T> callback)

      Description copied from interface: `AsyncInvoker`
      Invoke HTTP OPTIONS method for the current request asynchronously.

      Note that calling the `Future.get()` method on the returned `Future` instance may throw an `ExecutionException` that wraps either a `ProcessingException` thrown in case of an invocation processing failure or a `WebApplicationException` or one of its subclasses thrown in case the received response status code is not `successful` and the generic type of the supplied response callback is not `Response`. In case a processing of a properly received response fails, the wrapped processing exception will be of `ResponseProcessingException` type and will contain the `Response` instance whose processing has failed.

      Specified by:
        `options` in interface `AsyncInvoker`
      Type Parameters:
        `T` - generic response entity type.
      Parameters:
        `callback` - asynchronous invocation callback.
      Returns:
        invocation response `future`.

    - #### method

          public Future<Response> method(String name)

      Description copied from interface: `AsyncInvoker`
      Invoke an arbitrary method for the current request asynchronously.

      Note that calling the `Future.get()` method on the returned `Future` instance may throw an `ExecutionException` that wraps a `ProcessingException` thrown in case of an invocation processing failure. In case a processing of a properly received response fails, the wrapped processing exception will be of `ResponseProcessingException` type and will contain the `Response` instance whose processing has failed.

      Specified by:
        `method` in interface `AsyncInvoker`
      Parameters:
        `name` - method name.
      Returns:
        invocation response `future`.

    - #### method

          public <T> Future<T> method(String name,
                             Class<T> responseType)

      Description copied from interface: `AsyncInvoker`
      Invoke an arbitrary method for the current request asynchronously.

      Note that calling the `Future.get()` method on the returned `Future` instance may throw an `ExecutionException` that wraps either a `ProcessingException` thrown in case of an invocation processing failure or a `WebApplicationException` or one of its subclasses thrown in case the received response status code is not `successful` and the specified response type is not `Response`. In case a processing of a properly received response fails, the wrapped processing exception will be of `ResponseProcessingException` type and will contain the `Response` instance whose processing has failed.

      Specified by:
        `method` in interface `AsyncInvoker`
      Type Parameters:
        `T` - response entity type.
      Parameters:
        `name` - method name.
        `responseType` - Java type the response entity will be converted to.
      Returns:
        invocation response `future`.

    - #### method

          public <T> Future<T> method(String name,
                             GenericType<T> responseType)

      Description copied from interface: `AsyncInvoker`
      Invoke an arbitrary method for the current request asynchronously.

      Note that calling the `Future.get()` method on the returned `Future` instance may throw an `ExecutionException` that wraps either a `ProcessingException` thrown in case of an invocation processing failure or a `WebApplicationException` or one of its subclasses thrown in case the received response status code is not `successful` and the specified response type is not `Response`. In case a processing of a properly received response fails, the wrapped processing exception will be of `ResponseProcessingException` type and will contain the `Response` instance whose processing has failed.

      Specified by:
        `method` in interface `AsyncInvoker`
      Type Parameters:
        `T` - generic response entity type.
      Parameters:
        `name` - method name.
        `responseType` - representation of a generic Java type the response entity will be converted to.
      Returns:
        invocation response `future`.

    - #### method

          public <T> Future<T> method(String name,
                             InvocationCallback<T> callback)

      Description copied from interface: `AsyncInvoker`
      Invoke an arbitrary method for the current request asynchronously.

      Note that calling the `Future.get()` method on the returned `Future` instance may throw an `ExecutionException` that wraps either a `ProcessingException` thrown in case of an invocation processing failure or a `WebApplicationException` or one of its subclasses thrown in case the received response status code is not `successful` and the generic type of the supplied response callback is not `Response`. In case a processing of a properly received response fails, the wrapped processing exception will be of `ResponseProcessingException` type and will contain the `Response` instance whose processing has failed.

      Specified by:
        `method` in interface `AsyncInvoker`
      Type Parameters:
        `T` - generic response entity type.
      Parameters:
        `name` - method name.
        `callback` - asynchronous invocation callback.
      Returns:
        invocation response `future`.

    - #### method

          public Future<Response> method(String name,
                                Entity<?> entity)

      Description copied from interface: `AsyncInvoker`
      Invoke an arbitrary method for the current request asynchronously.

      Note that calling the `Future.get()` method on the returned `Future` instance may throw an `ExecutionException` that wraps a `ProcessingException` thrown in case of an invocation processing failure. In case a processing of a properly received response fails, the wrapped processing exception will be of `ResponseProcessingException` type and will contain the `Response` instance whose processing has failed.

      Specified by:
        `method` in interface `AsyncInvoker`
      Parameters:
        `name` - method name.
        `entity` - request entity, including it's full `Variant` information. Any variant-related HTTP headers previously set (namely `Content-Type`, `Content-Language` and `Content-Encoding`) will be overwritten using the entity variant information.
      Returns:
        invocation response `future`.

    - #### method

          public <T> Future<T> method(String name,
                             Entity<?> entity,
                             Class<T> responseType)

      Description copied from interface: `AsyncInvoker`
      Invoke an arbitrary method for the current request asynchronously.

      Note that calling the `Future.get()` method on the returned `Future` instance may throw an `ExecutionException` that wraps either a `ProcessingException` thrown in case of an invocation processing failure or a `WebApplicationException` or one of its subclasses thrown in case the received response status code is not `successful` and the specified response type is not `Response`. In case a processing of a properly received response fails, the wrapped processing exception will be of `ResponseProcessingException` type and will contain the `Response` instance whose processing has failed.

      Specified by:
        `method` in interface `AsyncInvoker`
      Type Parameters:
        `T` - response entity type.
      Parameters:
        `name` - method name.
        `entity` - request entity, including it's full `Variant` information. Any variant-related HTTP headers previously set (namely `Content-Type`, `Content-Language` and `Content-Encoding`) will be overwritten using the entity variant information.
        `responseType` - Java type the response entity will be converted to.
      Returns:
        invocation response `future`.

    - #### method

          public <T> Future<T> method(String name,
                             Entity<?> entity,
                             GenericType<T> responseType)

      Description copied from interface: `AsyncInvoker`
      Invoke an arbitrary method for the current request asynchronously.

      Note that calling the `Future.get()` method on the returned `Future` instance may throw an `ExecutionException` that wraps either a `ProcessingException` thrown in case of an invocation processing failure or a `WebApplicationException` or one of its subclasses thrown in case the received response status code is not `successful` and the specified response type is not `Response`. In case a processing of a properly received response fails, the wrapped processing exception will be of `ResponseProcessingException` type and will contain the `Response` instance whose processing has failed.

      Specified by:
        `method` in interface `AsyncInvoker`
      Type Parameters:
        `T` - generic response entity type.
      Parameters:
        `name` - method name.
        `entity` - request entity, including it's full `Variant` information. Any variant-related HTTP headers previously set (namely `Content-Type`, `Content-Language` and `Content-Encoding`) will be overwritten using the entity variant information.
        `responseType` - representation of a generic Java type the response entity will be converted to.
      Returns:
        invocation response `future`.

    - #### method

          public <T> Future<T> method(String name,
                             Entity<?> entity,
                             InvocationCallback<T> callback)

      Description copied from interface: `AsyncInvoker`
      Invoke an arbitrary method for the current request asynchronously.

      Note that calling the `Future.get()` method on the returned `Future` instance may throw an `ExecutionException` that wraps either a `ProcessingException` thrown in case of an invocation processing failure or a `WebApplicationException` or one of its subclasses thrown in case the received response status code is not `successful` and the generic type of the supplied response callback is not `Response`. In case a processing of a properly received response fails, the wrapped processing exception will be of `ResponseProcessingException` type and will contain the `Response` instance whose processing has failed.

      Specified by:
        `method` in interface `AsyncInvoker`
      Type Parameters:
        `T` - generic response entity type.
      Parameters:
        `name` - method name.
        `entity` - request entity, including it's full `Variant` information. Any variant-related HTTP headers previously set (namely `Content-Type`, `Content-Language` and `Content-Encoding`) will be overwritten using the entity variant information.
        `callback` - asynchronous invocation callback.
      Returns:
        invocation response `future`.

Copyright © 2014. All Rights Reserved.