javax.ws.rs.client

## Interface AsyncInvoker

-     public interface AsyncInvoker

  Uniform interface for asynchronous invocation of HTTP methods.
  Since:
    2.0
  Author:
    Marek Potociar

- - ### 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.

- - ### Method Detail

    - #### get

          Future<Response> get()

      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.

      Returns:
        invocation response `future`.

    - #### get

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

      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.

      Type Parameters:
        `T` - response entity type.
      Parameters:
        `responseType` - Java type the response entity will be converted to.
      Returns:
        invocation response `future`.

    - #### get

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

      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.

      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

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

      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.

      Type Parameters:
        `T` - generic response entity type.
      Parameters:
        `callback` - asynchronous invocation callback.
      Returns:
        invocation response `future`.

    - #### put

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

      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.

      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

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

      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.

      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

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

      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.

      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

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

      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.

      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

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

      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.

      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`.
      Throws:
        `ProcessingException` - in case the invocation processing has failed.

    - #### post

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

      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.

      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

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

      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.

      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

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

      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.

      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

          Future<Response> delete()

      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.

      Returns:
        invocation response `future`.

    - #### delete

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

      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.

      Type Parameters:
        `T` - response entity type.
      Parameters:
        `responseType` - Java type the response entity will be converted to.
      Returns:
        invocation response `future`.

    - #### delete

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

      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.

      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

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

      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.

      Type Parameters:
        `T` - generic response entity type.
      Parameters:
        `callback` - asynchronous invocation callback.
      Returns:
        invocation response `future`.

    - #### head

          Future<Response> head()

      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.

      Returns:
        invocation response `future`.

    - #### head

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

      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.

      Parameters:
        `callback` - asynchronous invocation callback.
      Returns:
        invocation response `future`.

    - #### options

          Future<Response> options()

      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.

      Returns:
        invocation response `future`.

    - #### options

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

      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.

      Type Parameters:
        `T` - response entity type.
      Parameters:
        `responseType` - Java type the response entity will be converted to.
      Returns:
        invocation response `future`.

    - #### options

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

      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.

      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

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

      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.

      Type Parameters:
        `T` - generic response entity type.
      Parameters:
        `callback` - asynchronous invocation callback.
      Returns:
        invocation response `future`.

    - #### trace

          Future<Response> trace()

      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.

      Returns:
        invocation response `future`.

    - #### trace

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

      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.

      Type Parameters:
        `T` - response entity type.
      Parameters:
        `responseType` - Java type the response entity will be converted to.
      Returns:
        invocation response `future`.

    - #### trace

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

      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.

      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

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

      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.

      Type Parameters:
        `T` - generic response entity type.
      Parameters:
        `callback` - asynchronous invocation callback.
      Returns:
        invocation response `future`.

    - #### method

          Future<Response> method(String name)

      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.

      Parameters:
        `name` - method name.
      Returns:
        invocation response `future`.

    - #### method

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

      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.

      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

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

      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.

      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

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

      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.

      Type Parameters:
        `T` - generic response entity type.
      Parameters:
        `name` - method name.
        `callback` - asynchronous invocation callback.
      Returns:
        invocation response `future`.

    - #### method

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

      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.

      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

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

      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.

      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

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

      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.

      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

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

      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.

      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 © 1996-2013, Oracle and/or its affiliates. All Rights Reserved. Use is subject to license terms.