com.holonplatform.http.rest

## Interface RestClientOperations.InvocationOperations<RE,RP,RS,RL,RU>

- Type Parameters:
    `RE` - Concrete response entity type
    `RP` - Concrete response payload type
    `RP` - Concrete response stream type
    `RL` - Concrete response payload as list type
    `RL` - Concrete response as URI type
  All Known Subinterfaces:
    AsyncRestClient.AsyncInvocation, AsyncRestClient.AsyncRequestDefinition, RestClient.Invocation, RestClient.RequestDefinition
  Enclosing interface:
    RestClientOperations<C extends RestClientOperations<C,R>,R extends RestClientOperations.RequestConfiguration<R> & RestClientOperations.InvocationOperations>

      public static interface RestClientOperations.InvocationOperations<RE,RP,RS,RL,RU>

  Invocantion operations definitions.

- - ### Method Summary

    All Methods Instance Methods Abstract Methods
    Modifier and Type | Method and Description
    --- | ---
    `RE` | `delete()` Invoke the request using `DELETE` method and receive a response back.
    `<T> RE` | `delete(Class<T> responseType)` Invoke the request using `DELETE` method and receive a response back.
    `<T> RE` | `delete(ResponseType<T> responseType)` Invoke the request using `DELETE` method and receive a response back.
    `<T> RP` | `deleteForEntity(Class<T> responseType)` Invoke the request using `DELETE` method and receive the response entity payload back.
    `<T> RP` | `deleteForEntity(ResponseType<T> responseType)` Invoke the request using `DELETE` method and receive the response entity payload of given generic type back.
    `<T> RE` | `get(Class<T> responseType)` Invoke the request using `GET` method and receive a response back.
    `<T> RE` | `get(ResponseType<T> responseType)` Invoke the request using `GET` method and receive a response back.
    `<T> RL` | `getAsList(Class<T> responseType)` Convenience method to invoke the request using `GET` method and receive a response entity payload of `List` type back.
    `<T> RP` | `getForEntity(Class<T> responseType)` Invoke the request using `GET` method and receive the response entity payload back.
    `<T> RP` | `getForEntity(ResponseType<T> responseType)` Invoke the request using `GET` method and receive the response entity payload of given generic type back.
    `RS` | `getForStream()` Invoke the request using `GET` method and receive the response entity back as a stream.
    `RE` | `head()` Invoke the request using `HEAD` method and receive a response back.
    `<T,R> RE` | `invoke(HttpMethod method, RequestEntity<R> requestEntity, ResponseType<T> responseType)` Invoke the request and receive a response back.
    `<T,R> RP` | `invokeForEntity(HttpMethod method, RequestEntity<R> requestEntity, ResponseType<T> responseType)` Invoke the request and receive back the response content entity.
    `<T,R> RE` | `invokeForSuccess(HttpMethod method, RequestEntity<R> requestEntity, ResponseType<T> responseType)` Invoke the request and receive a response back only if the response has a success (`2xx`) status code.
    `RE` | `options()` Invoke the request using `OPTIONS` method and receive a response back.
    `<T> RE` | `options(Class<T> responseType)` Invoke the request using `OPTIONS` method and receive a response back.
    `<T> RE` | `options(ResponseType<T> responseType)` Invoke the request using `OPTIONS` method and receive a response back.
    `<T> RP` | `optionsForEntity(Class<T> responseType)` Invoke the request using `OPTIONS` method and receive the response entity payload back.
    `<T> RP` | `optionsForEntity(ResponseType<T> responseType)` Invoke the request using `OPTIONS` method and receive the response entity payload of given generic type back.
    `RE` | `patch(RequestEntity<?> entity)` Invoke the request using `PATCH` method with given `entity` request payload and receive a response back.
    `<T> RE` | `patch(RequestEntity<?> entity, Class<T> responseType)` Invoke the request using `PATCH` method with given `entity` request payload and receive a response back.
    `<T> RE` | `patch(RequestEntity<?> entity, ResponseType<T> responseType)` Invoke the request using `PATCH` method with given `entity` request payload and receive a response back.
    `<T> RP` | `patchForEntity(RequestEntity<?> entity, Class<T> responseType)` Invoke the request using `PATCH` method with given `entity` request payload and receive the response entity payload back.
    `<T> RP` | `patchForEntity(RequestEntity<?> entity, ResponseType<T> responseType)` Invoke the request using `PATCH` method with given `entity` request payload and receive the response entity payload back.
    `RE` | `post(RequestEntity<?> entity)` Invoke the request using `POST` method with given `entity` request payload and receive a response back.
    `<T> RE` | `post(RequestEntity<?> entity, Class<T> responseType)` Invoke the request using `POST` method with given `entity` request payload and receive a response back.
    `<T> RE` | `post(RequestEntity<?> entity, ResponseType<T> responseType)` Invoke the request using `POST` method with given `entity` request payload and receive a response back.
    `<T> RP` | `postForEntity(RequestEntity<?> entity, Class<T> responseType)` Invoke the request using `POST` method with given `entity` request payload and receive the response payload back.
    `<T> RP` | `postForEntity(RequestEntity<?> entity, ResponseType<T> responseType)` Invoke the request using `POST` method with given `entity` request payload and receive the response payload back.
    `RU` | `postForLocation(RequestEntity<?> entity)` Invoke the request using `POST` method with given `entity` request payload and receive the value of the `LOCATION` header back, if present.
    `RE` | `put(RequestEntity<?> entity)` Invoke the request using `PUT` method with given `entity` request payload and receive a response back.
    `<T> RE` | `put(RequestEntity<?> entity, Class<T> responseType)` Invoke the request using `PUT` method with given `entity` request payload and receive a response back.
    `<T> RE` | `put(RequestEntity<?> entity, ResponseType<T> responseType)` Invoke the request using `PUT` method with given `entity` request payload and receive a response back.
    `<T> RP` | `putForEntity(RequestEntity<?> entity, Class<T> responseType)` Invoke the request using `PUT` method with given `entity` request payload and receive the response entity payload back.
    `<T> RP` | `putForEntity(RequestEntity<?> entity, ResponseType<T> responseType)` Invoke the request using `PUT` method with given `entity` request entity payload and receive the response payload back.
    `RE` | `trace()` Invoke the request using `TRACE` method and receive a response back.
    `<T> RE` | `trace(Class<T> responseType)` Invoke the request using `TRACE` method and receive a response back.
    `<T> RE` | `trace(ResponseType<T> responseType)` Invoke the request using `TRACE` method and receive a response back.
    `<T> RP` | `traceForEntity(Class<T> responseType)` Invoke the request using `TRACE` method and receive the response entity payload back.
    `<T> RP` | `traceForEntity(ResponseType<T> responseType)` Invoke the request using `TRACE` method and receive the response entity payload of given generic type back.

- - ### Method Detail

    - #### invoke

          <T,R> RE invoke(HttpMethod method,
                          RequestEntity<R> requestEntity,
                          ResponseType<T> responseType)

      Invoke the request and receive a response back.

      The response payload is processed and possibly converted by concrete client implementation.

      Type Parameters:
        `T` - Response type
        `R` - Request entity type
      Parameters:
        `method` - Request method
        `requestEntity` - Request entity
        `responseType` - Expected response payload type
      Returns:
        the result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)

    - #### invokeForSuccess

          <T,R> RE invokeForSuccess(HttpMethod method,
                                    RequestEntity<R> requestEntity,
                                    ResponseType<T> responseType)

      Invoke the request and receive a response back only if the response has a success (`2xx`) status code.
      Type Parameters:
        `T` - Response type
        `R` - Request entity type
      Parameters:
        `method` - Request method
        `requestEntity` - Request entity
        `responseType` - Expected response payload type
      Returns:
        the result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `UnsuccessfulResponseException` - In case the status code of the response returned by the server is not a successful type status code, i.e. it is not a `2xx` status code

    - #### invokeForEntity

          <T,R> RP invokeForEntity(HttpMethod method,
                                   RequestEntity<R> requestEntity,
                                   ResponseType<T> responseType)

      Invoke the request and receive back the response content entity.
      Type Parameters:
        `T` - Response type
        `R` - Request entity type
      Parameters:
        `method` - Request method
        `requestEntity` - Request entity
        `responseType` - Expected response payload type
      Returns:
        the response payload of expected type as the result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `UnsuccessfulResponseException` - In case the status code of the response returned by the server is not a successful type status code, i.e. it is not a `2xx` status code

    - #### get

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

      Invoke the request using `GET` method and receive a response back.
      Type Parameters:
        `T` - Response type
      Parameters:
        `responseType` - Expected response payload type
      Returns:
        the result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)

    - #### get

          <T> RE get(ResponseType<T> responseType)

      Invoke the request using `GET` method and receive a response back.
      Type Parameters:
        `T` - Response type
      Parameters:
        `responseType` - Expected response payload type
      Returns:
        the result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)

    - #### getForEntity

          <T> RP getForEntity(Class<T> responseType)

      Invoke the request using `GET` method and receive the response entity payload back.
      Type Parameters:
        `T` - Response entity type
      Parameters:
        `responseType` - Expected response payload type
      Returns:
        the response payload of expected type as the result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `UnsuccessfulResponseException` - In case the status code of the response returned by the server is not a successful type status code, i.e. it is not a `2xx` status code

    - #### getForEntity

          <T> RP getForEntity(ResponseType<T> responseType)

      Invoke the request using `GET` method and receive the response entity payload of given generic type back.
      Type Parameters:
        `T` - Response entity type
      Parameters:
        `responseType` - Response payload generic type representation
      Returns:
        the response payload of expected type as the result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `UnsuccessfulResponseException` - In case the status code of the response returned by the server is not a successful type status code, i.e. it is not a `2xx` status code

    - #### getForStream

          RS getForStream()

      Invoke the request using `GET` method and receive the response entity back as a stream.
      Returns:
        the response payload stream
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `UnsuccessfulResponseException` - In case the status code of the response returned by the server is not a successful type status code, i.e. it is not a `2xx` status code

    - #### getAsList

          <T> RL getAsList(Class<T> responseType)

      Convenience method to invoke the request using `GET` method and receive a response entity payload of `List` type back.
      Type Parameters:
        `T` - Response entity type
      Parameters:
        `responseType` - Expected response type
      Returns:
        the response payload of expected type as the result of the request invocation, or an empty List if not present
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `UnsuccessfulResponseException` - In case the status code of the response returned by the server is not a successful type status code, i.e. it is not a `2xx` status code

    - #### post

          RE post(RequestEntity<?> entity)

      Invoke the request using `POST` method with given `entity` request payload and receive a response back.

      The response type is conventionally of `Void` type, because no response paylod is expected from this invocation. Refer to the other `post` methods to obtain a response payload.

      Parameters:
        `entity` - Request payload
      Returns:
        the result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)

    - #### post

          <T> RE post(RequestEntity<?> entity,
                      Class<T> responseType)

      Invoke the request using `POST` method with given `entity` request payload and receive a response back.
      Type Parameters:
        `T` - Response type
      Parameters:
        `entity` - Request payload
        `responseType` - Expected response payload type
      Returns:
        the result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)

    - #### post

          <T> RE post(RequestEntity<?> entity,
                      ResponseType<T> responseType)

      Invoke the request using `POST` method with given `entity` request payload and receive a response back.
      Type Parameters:
        `T` - Response type
      Parameters:
        `entity` - Request payload
        `responseType` - Expected response payload type
      Returns:
        the result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)

    - #### postForEntity

          <T> RP postForEntity(RequestEntity<?> entity,
                               Class<T> responseType)

      Invoke the request using `POST` method with given `entity` request payload and receive the response payload back.
      Type Parameters:
        `T` - Response type
      Parameters:
        `entity` - Request payload
        `responseType` - Expected response payload type
      Returns:
        the response payload of expected type as the result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `UnsuccessfulResponseException` - In case the status code of the response returned by the server is not a successful type status code, i.e. it is not a `2xx` status code

    - #### postForEntity

          <T> RP postForEntity(RequestEntity<?> entity,
                               ResponseType<T> responseType)

      Invoke the request using `POST` method with given `entity` request payload and receive the response payload back.
      Type Parameters:
        `T` - Response type
      Parameters:
        `entity` - Request payload
        `responseType` - Expected response payload type
      Returns:
        the response payload of expected type as the result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `UnsuccessfulResponseException` - In case the status code of the response returned by the server is not a successful type status code, i.e. it is not a `2xx` status code

    - #### postForLocation

          RU postForLocation(RequestEntity<?> entity)

      Invoke the request using `POST` method with given `entity` request payload and receive the value of the `LOCATION` header back, if present.
      Parameters:
        `entity` - Request payload
      Returns:
        the value of the `LOCATION` header back, if present
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `UnsuccessfulResponseException` - In case the status code of the response returned by the server is not a successful type status code, i.e. it is not a `2xx` status code

    - #### put

          RE put(RequestEntity<?> entity)

      Invoke the request using `PUT` method with given `entity` request payload and receive a response back.

      The response type is conventionally of `Void` type, because no response paylod is expected from this invocation. Refer to the other `post` methods to obtain a response payload.

      Parameters:
        `entity` - Request payload
      Returns:
        the result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)

    - #### put

          <T> RE put(RequestEntity<?> entity,
                     Class<T> responseType)

      Invoke the request using `PUT` method with given `entity` request payload and receive a response back.
      Type Parameters:
        `T` - Response type
      Parameters:
        `entity` - Request payload
        `responseType` - Expected response payload type
      Returns:
        the result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)

    - #### put

          <T> RE put(RequestEntity<?> entity,
                     ResponseType<T> responseType)

      Invoke the request using `PUT` method with given `entity` request payload and receive a response back.
      Type Parameters:
        `T` - Response type
      Parameters:
        `entity` - Request payload
        `responseType` - Expected response payload type
      Returns:
        the result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)

    - #### putForEntity

          <T> RP putForEntity(RequestEntity<?> entity,
                              Class<T> responseType)

      Invoke the request using `PUT` method with given `entity` request payload and receive the response entity payload back.
      Type Parameters:
        `T` - Response entity type
      Parameters:
        `entity` - Request payload
        `responseType` - Expected response payload type
      Returns:
        the response payload of expected type as the result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `UnsuccessfulResponseException` - In case the status code of the response returned by the server is not a successful type status code, i.e. it is not a `2xx` status code

    - #### putForEntity

          <T> RP putForEntity(RequestEntity<?> entity,
                              ResponseType<T> responseType)

      Invoke the request using `PUT` method with given `entity` request entity payload and receive the response payload back.
      Type Parameters:
        `T` - Response entity type
      Parameters:
        `entity` - Request payload
        `responseType` - Expected response payload type
      Returns:
        the response payload of expected type as the result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `UnsuccessfulResponseException` - In case the status code of the response returned by the server is not a successful type status code, i.e. it is not a `2xx` status code

    - #### patch

          RE patch(RequestEntity<?> entity)

      Invoke the request using `PATCH` method with given `entity` request payload and receive a response back.

      The response type is conventionally of `Void` type, because no response paylod is expected from this invocation. Refer to the other `post` methods to obtain a response payload.

      Parameters:
        `entity` - Request payload
      Returns:
        the result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)

    - #### patch

          <T> RE patch(RequestEntity<?> entity,
                       Class<T> responseType)

      Invoke the request using `PATCH` method with given `entity` request payload and receive a response back.
      Type Parameters:
        `T` - Response type
      Parameters:
        `entity` - Request payload
        `responseType` - Expected response payload type
      Returns:
        the result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `UnsuccessfulResponseException` - In case the status code of the response returned by the server is not a successful type status code, i.e. it is not a `2xx` status code

    - #### patch

          <T> RE patch(RequestEntity<?> entity,
                       ResponseType<T> responseType)

      Invoke the request using `PATCH` method with given `entity` request payload and receive a response back.
      Type Parameters:
        `T` - Response type
      Parameters:
        `entity` - Request payload
        `responseType` - Expected response payload type
      Returns:
        the result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `UnsuccessfulResponseException` - In case the status code of the response returned by the server is not a successful type status code, i.e. it is not a `2xx` status code

    - #### patchForEntity

          <T> RP patchForEntity(RequestEntity<?> entity,
                                Class<T> responseType)

      Invoke the request using `PATCH` method with given `entity` request payload and receive the response entity payload back.
      Type Parameters:
        `T` - Response entity type
      Parameters:
        `entity` - Request payload
        `responseType` - Expected response payload type
      Returns:
        the response payload of expected type as the result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `UnsuccessfulResponseException` - In case the status code of the response returned by the server is not a successful type status code, i.e. it is not a `2xx` status code

    - #### patchForEntity

          <T> RP patchForEntity(RequestEntity<?> entity,
                                ResponseType<T> responseType)

      Invoke the request using `PATCH` method with given `entity` request payload and receive the response entity payload back.
      Type Parameters:
        `T` - Response entity type
      Parameters:
        `entity` - Request payload
        `responseType` - Expected response payload type
      Returns:
        the response payload of expected type as the result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `UnsuccessfulResponseException` - In case the status code of the response returned by the server is not a successful type status code, i.e. it is not a `2xx` status code

    - #### delete

          RE delete()

      Invoke the request using `DELETE` method and receive a response back.

      The response type is conventionally of `Void` type, because no response paylod is expected from this invocation. Refer to the other `post` methods to obtain a response payload.

      Returns:
        the result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel)

    - #### delete

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

      Invoke the request using `DELETE` method and receive a response back.
      Type Parameters:
        `T` - Response type
      Parameters:
        `responseType` - Expected response payload type
      Returns:
        the result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)

    - #### delete

          <T> RE delete(ResponseType<T> responseType)

      Invoke the request using `DELETE` method and receive a response back.
      Type Parameters:
        `T` - Response type
      Parameters:
        `responseType` - Response payload generic type representation
      Returns:
        the result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)

    - #### deleteForEntity

          <T> RP deleteForEntity(Class<T> responseType)

      Invoke the request using `DELETE` method and receive the response entity payload back.
      Type Parameters:
        `T` - Response entity type
      Parameters:
        `responseType` - Expected response payload type
      Returns:
        the response payload of expected type as the result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `UnsuccessfulResponseException` - In case the status code of the response returned by the server is not a successful type status code, i.e. it is not a `2xx` status code

    - #### deleteForEntity

          <T> RP deleteForEntity(ResponseType<T> responseType)

      Invoke the request using `DELETE` method and receive the response entity payload of given generic type back.
      Type Parameters:
        `T` - Response entity type
      Parameters:
        `responseType` - Response payload generic type representation
      Returns:
        the response payload of expected type as the result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `UnsuccessfulResponseException` - In case the status code of the response returned by the server is not a successful type status code, i.e. it is not a `2xx` status code

    - #### options

          RE options()

      Invoke the request using `OPTIONS` method and receive a response back.

      The response type is conventionally of `Void` type, because no response paylod is expected from this invocation. Refer to the other `post` methods to obtain a response payload.

      Returns:
        the result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel)

    - #### options

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

      Invoke the request using `OPTIONS` method and receive a response back.
      Type Parameters:
        `T` - Response type
      Parameters:
        `responseType` - Expected response payload type
      Returns:
        the result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)

    - #### options

          <T> RE options(ResponseType<T> responseType)

      Invoke the request using `OPTIONS` method and receive a response back.
      Type Parameters:
        `T` - Response type
      Parameters:
        `responseType` - Response payload generic type representation
      Returns:
        the result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)

    - #### optionsForEntity

          <T> RP optionsForEntity(Class<T> responseType)

      Invoke the request using `OPTIONS` method and receive the response entity payload back.
      Type Parameters:
        `T` - Response entity type
      Parameters:
        `responseType` - Expected response payload type
      Returns:
        the response payload of expected type as the result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `UnsuccessfulResponseException` - In case the status code of the response returned by the server is not a successful type status code, i.e. it is not a `2xx` status code

    - #### optionsForEntity

          <T> RP optionsForEntity(ResponseType<T> responseType)

      Invoke the request using `OPTIONS` method and receive the response entity payload of given generic type back.
      Type Parameters:
        `T` - Response entity type
      Parameters:
        `responseType` - Response payload generic type representation
      Returns:
        the response payload of expected type as the result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `UnsuccessfulResponseException` - In case the status code of the response returned by the server is not a successful type status code, i.e. it is not a `2xx` status code

    - #### trace

          RE trace()

      Invoke the request using `TRACE` method and receive a response back.

      The response type is conventionally of `Void` type, because no response paylod is expected from this invocation. Refer to the other `post` methods to obtain a response payload.

      Returns:
        the result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)

    - #### trace

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

      Invoke the request using `TRACE` method and receive a response back.
      Type Parameters:
        `T` - Response type
      Parameters:
        `responseType` - Expected response payload type
      Returns:
        the result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)

    - #### trace

          <T> RE trace(ResponseType<T> responseType)

      Invoke the request using `TRACE` method and receive a response back.
      Type Parameters:
        `T` - Response type
      Parameters:
        `responseType` - Response payload generic type representation
      Returns:
        the result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)

    - #### traceForEntity

          <T> RP traceForEntity(Class<T> responseType)

      Invoke the request using `TRACE` method and receive the response entity payload back.
      Type Parameters:
        `T` - Response entity type
      Parameters:
        `responseType` - Expected response payload type
      Returns:
        the response payload of expected type as the result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `UnsuccessfulResponseException` - In case the status code of the response returned by the server is not a successful type status code, i.e. it is not a `2xx` status code

    - #### traceForEntity

          <T> RP traceForEntity(ResponseType<T> responseType)

      Invoke the request using `TRACE` method and receive the response entity payload of given generic type back.
      Type Parameters:
        `T` - Response entity type
      Parameters:
        `responseType` - Response payload generic type representation
      Returns:
        the response payload of expected type as the result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)
        `UnsuccessfulResponseException` - In case the status code of the response returned by the server is not a successful type status code, i.e. it is not a `2xx` status code

    - #### head

          RE head()

      Invoke the request using `HEAD` method and receive a response back.
      Returns:
        the result of the request invocation
      Throws:
        `HttpClientInvocationException` - Internal invocation failure (for example, an I/O error on communication channel or expected and actual payload type mismatch)

Copyright © 2019 The Holon Platform. All rights reserved.