BaseClientResponse (RESTEasy JAX-RS 3.0.10.Final API)

java.lang.Object
- javax.ws.rs.core.Response
- - org.jboss.resteasy.client.ClientResponse<T>
  - - org.jboss.resteasy.client.core.BaseClientResponse<T>

public class BaseClientResponse<T>
extends ClientResponse<T>

Version:: $Revision: 1 $
Author:: Bill Burke

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static interface BaseClientResponse.BaseClientResponseStreamFactory
- Nested classes/interfaces inherited from class javax.ws.rs.core.Response
  Response.ResponseBuilder, Response.Status, Response.StatusType

Nested Classes
Modifier and Type	Class and Description
`static interface`	`BaseClientResponse.BaseClientResponseStreamFactory`

Field Summary

Fields
Modifier and Type	Field and Description
`protected String`	`alternateMediaType`
`protected Annotation[]`	`annotations`
`protected String`	`attributeExceptionsTo`
`protected Map<String,Object>`	`attributes`
`protected Exception`	`exception`
`protected ClientExecutor`	`executor`
`protected Type`	`genericReturnType`
`protected MultivaluedMap<String,String>`	`headers`
`protected LinkHeader`	`linkHeader`
`protected Link`	`location`
`protected ResteasyProviderFactory`	`providerFactory`
`protected ReaderInterceptor[]`	`readerInterceptors`
`protected Class<?>`	`returnType`
`protected int`	`status`
`protected BaseClientResponse.BaseClientResponseStreamFactory`	`streamFactory`
`protected Object`	`unmarshaledEntity`
`protected boolean`	`wasReleased`

Constructor Summary

Constructors
Constructor and Description
`BaseClientResponse(BaseClientResponse.BaseClientResponseStreamFactory streamFactory)`
`BaseClientResponse(BaseClientResponse.BaseClientResponseStreamFactory streamFactory, ClientExecutor executor)`

Method Summary

Methods
Modifier and Type	Method and Description
`boolean`	`bufferEntity()` Buffer the message entity data.
`void`	`checkFailureStatus()`
`void`	`close()` Close the underlying message entity input stream (if available and open) as well as releases any other resources associated with the response (e.g.
`static ClientResponse`	`copyFromError(ClientResponse copy)` Store entity within a byte array input stream because we want to release the connection if a ClientResponseFailure is thrown.
`ClientResponseFailure`	`createResponseFailure(String message)`
`ClientResponseFailure`	`createResponseFailure(String message, Exception e)`
`protected void`	`finalize()`
`Set<String>`	`getAllowedMethods()` Get the allowed HTTP methods from the Allow HTTP header.
`Annotation[]`	`getAnnotations()`
`String`	`getAttributeExceptionsTo()`
`Map<String,Object>`	`getAttributes()` Used to pass information to and between interceptors.
`Map<String,NewCookie>`	`getCookies()` Get any new cookies set on the response message.
`Date`	`getDate()` Get message date.
`T`	`getEntity()` Unmarshal the target entity from the response OutputStream.
`<T2> T2`	`getEntity(Class<T2> type)` Extract the response body with the provided type information This method actually does the reading on the OutputStream.
`<T2> T2`	`getEntity(Class<T2> type, Type genericType)` Extract the response body with the provided type information This method actually does the reading on the OutputStream.
`<T2> T2`	`getEntity(Class<T2> type, Type genericType, Annotation[] anns)`
`<T2> T2`	`getEntity(GenericType<T2> genericType)` Extract the response body with the provided type information.
`<T2> T2`	`getEntity(GenericType<T2> genericType, Annotation[] ann)`
`EntityTag`	`getEntityTag()` Get the entity tag.
`Exception`	`getException()`
`Link`	`getHeaderAsLink(String headerName)` Header is assumed to be a URL, a Link object is created from it if it exists.
`String`	`getHeaderString(String name)` Get a message header as a single string value.
`Locale`	`getLanguage()` Get the language of the message entity.
`Date`	`getLastModified()` Get the last modified date.
`int`	`getLength()` Get Content-Length value.
`Link`	`getLink(String relation)` Get the link for the relation.
`Link.Builder`	`getLinkBuilder(String relation)` Convenience method that returns a `Link.Builder` for the relation.
`LinkHeader`	`getLinkHeader()` Get the link headers of the response.
`Set<Link>`	`getLinks()` Get the links attached to the message as headers.
`URI`	`getLocation()` Get the location.
`Link`	`getLocationLink()` Get the Location header as a Link so you can easily execute on it.
`MediaType`	`getMediaType()` Get the media type of the message entity.
`MultivaluedMap<String,Object>`	`getMetadata()` See `Response.getHeaders()`.
`String`	`getResponseHeader(String headerKey)`
`MultivaluedMap<String,String>`	`getResponseHeaders()` This method returns the same exact map as Response.getMetadata() except as a map of strings rather than objects
`Response.Status`	`getResponseStatus()`
`Class<?>`	`getReturnType()`
`int`	`getStatus()` Get the status code associated with the response.
`Response.StatusType`	`getStatusInfo()` Get the complete status information associated with the response.
`BaseClientResponse.BaseClientResponseStreamFactory`	`getStreamFactory()`
`MultivaluedMap<String,String>`	`getStringHeaders()` Get view of the response headers and their string values.
`boolean`	`hasEntity()` Check if there is an entity available in the response.
`boolean`	`hasLink(String relation)` Check if link for relation exists.
`<T> T`	`readEntity(Class<T> entityType)` Read the message entity input stream as an instance of specified Java type using a `MessageBodyReader` that supports mapping the message entity stream onto the requested type.
`<T> T`	`readEntity(Class<T> entityType, Annotation[] annotations)` Read the message entity input stream as an instance of specified Java type using a `MessageBodyReader` that supports mapping the message entity stream onto the requested type.
`<T> T`	`readEntity(GenericType<T> entityType)` Read the message entity input stream as an instance of specified Java type using a `MessageBodyReader` that supports mapping the message entity stream onto the requested type.
`<T> T`	`readEntity(GenericType<T> entityType, Annotation[] annotations)` Read the message entity input stream as an instance of specified Java type using a `MessageBodyReader` that supports mapping the message entity stream onto the requested type.
`protected <T2> Object`	`readFrom(Class<T2> type, Type genericType, MediaType media, Annotation[] annotations)`
`void`	`releaseConnection()`
`void`	`resetStream()` Attempts to reset the InputStream of the response.
`void`	`setAlternateMediaType(String alternateMediaType)`
`void`	`setAnnotations(Annotation[] annotations)`
`void`	`setAttributeExceptionsTo(String attributeExceptionsTo)`
`void`	`setAttributes(Map<String,Object> attributes)`
`void`	`setException(Exception exception)`
`void`	`setGenericReturnType(Type genericReturnType)`
`void`	`setHeaders(MultivaluedMap<String,String> headers)`
`void`	`setProviderFactory(ResteasyProviderFactory providerFactory)`
`void`	`setReaderInterceptors(ReaderInterceptor[] readerInterceptors)`
`void`	`setReturnType(Class<T> returnType)`
`void`	`setStatus(int status)`
`void`	`setStreamFactory(BaseClientResponse.BaseClientResponseStreamFactory streamFactory)`
`void`	`setWasReleased(boolean wasReleased)`
`boolean`	`wasReleased()`

Methods inherited from class javax.ws.rs.core.Response
accepted, accepted, created, fromResponse, getHeaders, noContent, notAcceptable, notModified, notModified, notModified, ok, ok, ok, ok, ok, seeOther, serverError, status, status, status, temporaryRedirect

Methods inherited from class java.lang.Object
clone, equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - providerFactory
```
protected ResteasyProviderFactory providerFactory
```
  - attributeExceptionsTo
```
protected String attributeExceptionsTo
```
  - headers
```
protected MultivaluedMap<String,String> headers
```
  - alternateMediaType
```
protected String alternateMediaType
```
  - returnType
```
protected Class<?> returnType
```
  - genericReturnType
```
protected Type genericReturnType
```
  - annotations
```
protected Annotation[] annotations
```
  - status
```
protected int status
```
  - wasReleased
```
protected boolean wasReleased
```
  - unmarshaledEntity
```
protected Object unmarshaledEntity
```
  - readerInterceptors
```
protected ReaderInterceptor[] readerInterceptors
```
  - exception
```
protected Exception exception
```
  - streamFactory
```
protected BaseClientResponse.BaseClientResponseStreamFactory streamFactory
```
  - linkHeader
```
protected LinkHeader linkHeader
```
  - location
```
protected Link location
```
  - executor
```
protected ClientExecutor executor
```
  - attributes
```
protected Map<String,Object> attributes
```
- Constructor Detail
  - BaseClientResponse
```
public BaseClientResponse(BaseClientResponse.BaseClientResponseStreamFactory streamFactory,
                  ClientExecutor executor)
```
  - BaseClientResponse
```
public BaseClientResponse(BaseClientResponse.BaseClientResponseStreamFactory streamFactory)
```
- Method Detail
  - copyFromError
```
public static ClientResponse copyFromError(ClientResponse copy)
```
    Store entity within a byte array input stream because we want to release the connection if a ClientResponseFailure is thrown. Copy status and headers, but ignore all type information stored in the ClientResponse.
    
    Parameters:
    copy -
    
    Returns:
  - getAttributes
```
public Map<String,Object> getAttributes()
```
    Description copied from class: ClientResponse
    
    Used to pass information to and between interceptors.
    
    Specified by:
    
    getAttributes in class ClientResponse<T>
    
    Returns:
  - setAttributes
```
public void setAttributes(Map<String,Object> attributes)
```
  - setReaderInterceptors
```
public void setReaderInterceptors(ReaderInterceptor[] readerInterceptors)
```
  - setStatus
```
public void setStatus(int status)
```
  - setHeaders
```
public void setHeaders(MultivaluedMap<String,String> headers)
```
  - setProviderFactory
```
public void setProviderFactory(ResteasyProviderFactory providerFactory)
```
  - setReturnType
```
public void setReturnType(Class<T> returnType)
```
  - getReturnType
```
public Class<?> getReturnType()
```
  - setGenericReturnType
```
public void setGenericReturnType(Type genericReturnType)
```
  - setAnnotations
```
public void setAnnotations(Annotation[] annotations)
```
  - getAttributeExceptionsTo
```
public String getAttributeExceptionsTo()
```
  - setAttributeExceptionsTo
```
public void setAttributeExceptionsTo(String attributeExceptionsTo)
```
  - getException
```
public Exception getException()
```
  - setException
```
public void setException(Exception exception)
```
  - getAnnotations
```
public Annotation[] getAnnotations()
```
  - getResponseHeader
```
public String getResponseHeader(String headerKey)
```
  - getLinkHeader
```
public LinkHeader getLinkHeader()
```
    Description copied from class: ClientResponse
    
    Get the link headers of the response. All Link objects returned will automatically have the same ClientExecutor as the request.
    
    Specified by:
    
    getLinkHeader in class ClientResponse<T>
    
    Returns:
    non-null
  - getLocationLink
```
public Link getLocationLink()
```
    Description copied from class: ClientResponse
    
    Get the Location header as a Link so you can easily execute on it. All Link objects returned will automatically have the same ClientExecutor as the request.
    
    Specified by:
    
    getLocationLink in class ClientResponse<T>
    
    Returns:
  - getHeaderAsLink
```
public Link getHeaderAsLink(String headerName)
```
    Description copied from class: ClientResponse
    
    Header is assumed to be a URL, a Link object is created from it if it exists. Also, the type field of the link with be initialized if there is another header appended with -Type. i.e. if the header was "custom" it will also look for a header of custom-type and expect that this is a media type.
    All Link objects returned will automatically have the same ClientExecutor as the request.
    
    Specified by:
    
    getHeaderAsLink in class ClientResponse<T>
    
    Returns:
    null if it doesn't exist
  - setAlternateMediaType
```
public void setAlternateMediaType(String alternateMediaType)
```
  - getStreamFactory
```
public BaseClientResponse.BaseClientResponseStreamFactory getStreamFactory()
```
  - setStreamFactory
```
public void setStreamFactory(BaseClientResponse.BaseClientResponseStreamFactory streamFactory)
```
  - resetStream
```
public void resetStream()
```
    Description copied from class: ClientResponse
    
    Attempts to reset the InputStream of the response. Useful for refetching an entity after a marshalling failure
    
    Specified by:
    
    resetStream in class ClientResponse<T>
  - getEntity
```
public T getEntity()
```
    Description copied from class: ClientResponse
    
    Unmarshal the target entity from the response OutputStream. You must have type information set via otherwise, this will not work.
    This method actually does the reading on the OutputStream. It will only do the read once. Afterwards, it will cache the result and return the cached result.
    
    Specified by:
    
    getEntity in class ClientResponse<T>
    
    Returns:
    the message entity or null if message does not contain an entity body (i.e. when Response.hasEntity() returns false).
  - getEntity
```
public <T2> T2 getEntity(Class<T2> type)
```
    Description copied from class: ClientResponse
    
    Extract the response body with the provided type information
    This method actually does the reading on the OutputStream. It will only do the read once. Afterwards, it will cache the result and return the cached result.
    
    Specified by:
    
    getEntity in class ClientResponse<T>
    
    Returns:
  - getEntity
```
public <T2> T2 getEntity(Class<T2> type,
                Type genericType)
```
    Description copied from class: ClientResponse
    
    Extract the response body with the provided type information
    This method actually does the reading on the OutputStream. It will only do the read once. Afterwards, it will cache the result and return the cached result.
    
    Specified by:
    
    getEntity in class ClientResponse<T>
    
    Returns:
  - getEntity
```
public <T2> T2 getEntity(Class<T2> type,
                Type genericType,
                Annotation[] anns)
```
    Specified by:
    
    getEntity in class ClientResponse<T>
    
    Returns:
  - getMediaType
```
public MediaType getMediaType()
```
    Description copied from class: Response
    
    Get the media type of the message entity.
    
    Specified by:
    
    getMediaType in class Response
    
    Returns:
    the media type or null if there is no response entity.
  - readFrom
```
protected <T2> Object readFrom(Class<T2> type,
                   Type genericType,
                   MediaType media,
                   Annotation[] annotations)
```
  - getEntity
```
public <T2> T2 getEntity(GenericType<T2> genericType)
```
    Description copied from class: ClientResponse
    Extract the response body with the provided type information. GenericType is a trick used to pass in generic type information to the resteasy runtime.
    For example:
```
 List list = response.getEntity(new GenericType() {});


 This method actually does the reading on the OutputStream.  It will only do the read once.  Afterwards, it will
 cache the result and return the cached result.
```
    Specified by:
    
    getEntity in class ClientResponse<T>
    
    Returns:
  - getEntity
```
public <T2> T2 getEntity(GenericType<T2> genericType,
                Annotation[] ann)
```
    Specified by:
    
    getEntity in class ClientResponse<T>
    
    Returns:
  - getResponseHeaders
```
public MultivaluedMap<String,String> getResponseHeaders()
```
    Description copied from class: ClientResponse
    
    This method returns the same exact map as Response.getMetadata() except as a map of strings rather than objects
    
    Specified by:
    
    getResponseHeaders in class ClientResponse<T>
    
    Returns:
  - getMetadata
```
public MultivaluedMap<String,Object> getMetadata()
```
    Description copied from class: Response
    
    See Response.getHeaders(). This method is considered deprecated. Users are encouraged to switch their code to use the getHeaders() method instead. The method may be annotated as @Deprecated in a future release of JAX-RS API.
    
    Specified by:
    
    getMetadata in class Response
    
    Returns:
    response headers as a multivalued map.
  - getStatus
```
public int getStatus()
```
    Description copied from class: Response
    
    Get the status code associated with the response.
    
    Specified by:
    
    getStatus in class Response
    
    Returns:
    the response status code.
  - getStatusInfo
```
public Response.StatusType getStatusInfo()
```
    Description copied from class: Response
    
    Get the complete status information associated with the response.
    
    Specified by:
    
    getStatusInfo in class Response
    
    Returns:
    the response status information. The returned value is never null.
  - checkFailureStatus
```
public void checkFailureStatus()
```
  - createResponseFailure
```
public ClientResponseFailure createResponseFailure(String message)
```
  - createResponseFailure
```
public ClientResponseFailure createResponseFailure(String message,
                                          Exception e)
```
  - getResponseStatus
```
public Response.Status getResponseStatus()
```
    Specified by:
    
    getResponseStatus in class ClientResponse<T>
  - wasReleased
```
public boolean wasReleased()
```
  - setWasReleased
```
public void setWasReleased(boolean wasReleased)
```
  - releaseConnection
```
public final void releaseConnection()
```
    Specified by:
    
    releaseConnection in class ClientResponse<T>
  - finalize
```
protected final void finalize()
                       throws Throwable
```
    Overrides:
    
    finalize in class Object
    
    Throws:
    
    Throwable
  - readEntity
```
public <T> T readEntity(Class<T> entityType)
```
    Description copied from class: Response
    
    Read the message entity input stream as an instance of specified Java type using a MessageBodyReader that supports mapping the message entity stream onto the requested type.
    Method throws an ProcessingException if the content of the message cannot be mapped to an entity of the requested type and IllegalStateException in case the entity is not backed by an input stream or if the original entity input stream has already been consumed without buffering the entity data prior consuming.
    
    A message instance returned from this method will be cached for subsequent retrievals via Response.getEntity(). Unless the supplied entity type is an input stream, this method automatically closes the an unconsumed original response entity data stream if open. In case the entity data has been buffered, the buffer will be reset prior consuming the buffered data to enable subsequent invocations of readEntity(...) methods on this response.
    
    Specified by:
    
    readEntity in class Response
    
    Type Parameters:
    T - entity instance Java type.
    Parameters:
    entityType - the type of entity.
    
    Returns:
    the message entity; for a zero-length response entities returns a corresponding Java object that represents zero-length data. In case no zero-length representation is defined for the Java type, a ProcessingException wrapping the underlying NoContentException is thrown.
    See Also:
    MessageBodyReader
  - readEntity
```
public <T> T readEntity(GenericType<T> entityType)
```
    Description copied from class: Response
    
    Read the message entity input stream as an instance of specified Java type using a MessageBodyReader that supports mapping the message entity stream onto the requested type.
    Method throws an ProcessingException if the content of the message cannot be mapped to an entity of the requested type and IllegalStateException in case the entity is not backed by an input stream or if the original entity input stream has already been consumed without buffering the entity data prior consuming.
    
    A message instance returned from this method will be cached for subsequent retrievals via Response.getEntity(). Unless the supplied entity type is an input stream, this method automatically closes the an unconsumed original response entity data stream if open. In case the entity data has been buffered, the buffer will be reset prior consuming the buffered data to enable subsequent invocations of readEntity(...) methods on this response.
    
    Specified by:
    
    readEntity in class Response
    
    Type Parameters:
    T - entity instance Java type.
    Parameters:
    entityType - the type of entity; may be generic.
    
    Returns:
    the message entity; for a zero-length response entities returns a corresponding Java object that represents zero-length data. In case no zero-length representation is defined for the Java type, a ProcessingException wrapping the underlying NoContentException is thrown.
    See Also:
    MessageBodyReader
  - readEntity
```
public <T> T readEntity(Class<T> entityType,
               Annotation[] annotations)
```
    Description copied from class: Response
    
    Read the message entity input stream as an instance of specified Java type using a MessageBodyReader that supports mapping the message entity stream onto the requested type.
    Method throws an ProcessingException if the content of the message cannot be mapped to an entity of the requested type and IllegalStateException in case the entity is not backed by an input stream or if the original entity input stream has already been consumed without buffering the entity data prior consuming.
    
    A message instance returned from this method will be cached for subsequent retrievals via Response.getEntity(). Unless the supplied entity type is an input stream, this method automatically closes the an unconsumed original response entity data stream if open. In case the entity data has been buffered, the buffer will be reset prior consuming the buffered data to enable subsequent invocations of readEntity(...) methods on this response.
    
    Specified by:
    
    readEntity in class Response
    
    Type Parameters:
    T - entity instance Java type.
    Parameters:
    entityType - the type of entity.
    annotations - annotations that will be passed to the MessageBodyReader.
    
    Returns:
    the message entity; for a zero-length response entities returns a corresponding Java object that represents zero-length data. In case no zero-length representation is defined for the Java type, a ProcessingException wrapping the underlying NoContentException is thrown.
    See Also:
    MessageBodyReader
  - readEntity
```
public <T> T readEntity(GenericType<T> entityType,
               Annotation[] annotations)
```
    Description copied from class: Response
    
    Read the message entity input stream as an instance of specified Java type using a MessageBodyReader that supports mapping the message entity stream onto the requested type.
    Method throws an ProcessingException if the content of the message cannot be mapped to an entity of the requested type and IllegalStateException in case the entity is not backed by an input stream or if the original entity input stream has already been consumed without buffering the entity data prior consuming.
    
    A message instance returned from this method will be cached for subsequent retrievals via Response.getEntity(). Unless the supplied entity type is an input stream, this method automatically closes the an unconsumed original response entity data stream if open. In case the entity data has been buffered, the buffer will be reset prior consuming the buffered data to enable subsequent invocations of readEntity(...) methods on this response.
    
    Specified by:
    
    readEntity in class Response
    
    Type Parameters:
    T - entity instance Java type.
    Parameters:
    entityType - the type of entity; may be generic.
    annotations - annotations that will be passed to the MessageBodyReader.
    
    Returns:
    the message entity; for a zero-length response entities returns a corresponding Java object that represents zero-length data. In case no zero-length representation is defined for the Java type, a ProcessingException wrapping the underlying NoContentException is thrown.
    See Also:
    MessageBodyReader
  - hasEntity
```
public boolean hasEntity()
```
    Description copied from class: Response
    
    Check if there is an entity available in the response. The method returns true if the entity is present, returns false otherwise.
    Note that the method may return true also for response messages with a zero-length content, in case the "Content-Length" and "Content-Type" headers are specified in the message. In such case, an attempt to read the entity using one of the readEntity(...) methods will return a corresponding instance representing a zero-length entity for a given Java type or produce a ProcessingException in case no such instance is available for the Java type.
    
    Specified by:
    
    hasEntity in class Response
    
    Returns:
    true if there is an entity present in the message, false otherwise.
  - bufferEntity
```
public boolean bufferEntity()
```
    Description copied from class: Response
    
    Buffer the message entity data.
    In case the message entity is backed by an unconsumed entity input stream, all the bytes of the original entity input stream are read and stored in a local buffer. The original entity input stream is consumed and automatically closed as part of the operation and the method returns true.
    
    In case the response entity instance is not backed by an unconsumed input stream an invocation of bufferEntity method is ignored and the method returns false.
    
    This operation is idempotent, i.e. it can be invoked multiple times with the same effect which also means that calling the bufferEntity() method on an already buffered (and thus closed) message instance is legal and has no further effect. Also, the result returned by the bufferEntity() method is consistent across all invocations of the method on the same Response instance.
    
    Buffering the message entity data allows for multiple invocations of readEntity(...) methods on the response instance. Note however, that once the response instance itself is closed, the implementations are expected to release the buffered message entity data too. Therefore any subsequent attempts to read a message entity stream on such closed response will result in an IllegalStateException being thrown.
    
    Specified by:
    
    bufferEntity in class Response
    
    Returns:
    true if the message entity input stream was available and was buffered successfully, returns false if the entity stream was not available.
  - close
```
public void close()
```
    Description copied from class: Response
    
    Close the underlying message entity input stream (if available and open) as well as releases any other resources associated with the response (e.g. buffered message entity data).
    This operation is idempotent, i.e. it can be invoked multiple times with the same effect which also means that calling the close() method on an already closed message instance is legal and has no further effect.
    
    The close() method should be invoked on all instances that contain an un-consumed entity input stream to ensure the resources associated with the instance are properly cleaned-up and prevent potential memory leaks. This is typical for client-side scenarios where application layer code processes only the response headers and ignores the response entity.
    
    Any attempts to manipulate (read, get, buffer) a message entity on a closed response will result in an IllegalStateException being thrown.
    
    Specified by:
    
    close in class Response
  - getHeaderString
```
public String getHeaderString(String name)
```
    Description copied from class: Response
    
    Get a message header as a single string value. Each single header value is converted to String using a RuntimeDelegate.HeaderDelegate if one is available via RuntimeDelegate.createHeaderDelegate(java.lang.Class) for the header value class or using its toString method if a header delegate is not available.
    
    Specified by:
    
    getHeaderString in class Response
    
    Parameters:
    name - the message header.
    
    Returns:
    the message header value. If the message header is not present then null is returned. If the message header is present but has no value then the empty string is returned. If the message header is present more than once then the values of joined together and separated by a ',' character.
    See Also:
    Response.getHeaders(), Response.getStringHeaders()
  - getLanguage
```
public Locale getLanguage()
```
    Description copied from class: Response
    
    Get the language of the message entity.
    
    Specified by:
    
    getLanguage in class Response
    
    Returns:
    the language of the entity or null if not specified.
  - getLength
```
public int getLength()
```
    Description copied from class: Response
    
    Get Content-Length value.
    
    Specified by:
    
    getLength in class Response
    
    Returns:
    Content-Length as integer if present and valid number. In other cases returns -1.
  - getCookies
```
public Map<String,NewCookie> getCookies()
```
    Description copied from class: Response
    
    Get any new cookies set on the response message.
    
    Specified by:
    
    getCookies in class Response
    
    Returns:
    a read-only map of cookie name (String) to Cookie.
  - getEntityTag
```
public EntityTag getEntityTag()
```
    Description copied from class: Response
    
    Get the entity tag.
    
    Specified by:
    
    getEntityTag in class Response
    
    Returns:
    the entity tag, otherwise null if not present.
  - getDate
```
public Date getDate()
```
    Description copied from class: Response
    
    Get message date.
    
    Specified by:
    
    getDate in class Response
    
    Returns:
    the message date, otherwise null if not present.
  - getLastModified
```
public Date getLastModified()
```
    Description copied from class: Response
    
    Get the last modified date.
    
    Specified by:
    
    getLastModified in class Response
    
    Returns:
    the last modified date, otherwise null if not present.
  - getLinks
```
public Set<Link> getLinks()
```
    Description copied from class: Response
    
    Get the links attached to the message as headers. Any links in the message that are relative must be resolved with respect to the actual request URI that produced this response. Note that request URIs may be updated by filters, so the actual request URI may differ from that in the original invocation.
    
    Specified by:
    
    getLinks in class Response
    
    Returns:
    links, may return empty Set if no links are present. Does not return null.
  - hasLink
```
public boolean hasLink(String relation)
```
    Description copied from class: Response
    
    Check if link for relation exists.
    
    Specified by:
    
    hasLink in class Response
    
    Parameters:
    relation - link relation.
    
    Returns:
    true if the link for the relation is present in the message headers, false otherwise.
  - getLink
```
public Link getLink(String relation)
```
    Description copied from class: Response
    
    Get the link for the relation. A relative link is resolved with respect to the actual request URI that produced this response. Note that request URIs may be updated by filters, so the actual request URI may differ from that in the original invocation.
    
    Specified by:
    
    getLink in class Response
    
    Parameters:
    relation - link relation.
    
    Returns:
    the link for the relation, otherwise null if not present.
  - getLinkBuilder
```
public Link.Builder getLinkBuilder(String relation)
```
    Description copied from class: Response
    
    Convenience method that returns a Link.Builder for the relation. See Response.getLink(java.lang.String) for more information.
    
    Specified by:
    
    getLinkBuilder in class Response
    
    Parameters:
    relation - link relation.
    
    Returns:
    the link builder for the relation, otherwise null if not present.
  - getLocation
```
public URI getLocation()
```
    Description copied from class: Response
    
    Get the location.
    
    Specified by:
    
    getLocation in class Response
    
    Returns:
    the location URI, otherwise null if not present.
  - getAllowedMethods
```
public Set<String> getAllowedMethods()
```
    Description copied from class: Response
    
    Get the allowed HTTP methods from the Allow HTTP header.
    
    Specified by:
    
    getAllowedMethods in class Response
    
    Returns:
    the allowed HTTP methods, all methods will returned as upper case strings.
  - getStringHeaders
```
public MultivaluedMap<String,String> getStringHeaders()
```
    Description copied from class: Response
    
    Get view of the response headers and their string values. The underlying header data may be subsequently modified by the JAX-RS runtime on the server side. Changes in the underlying header data are reflected in this view.
    
    Specified by:
    
    getStringHeaders in class Response
    
    Returns:
    response headers as a string view of header values.
    See Also:
    Response.getHeaders(), Response.getHeaderString(java.lang.String)

Class BaseClientResponse<T>

Nested Class Summary

Nested classes/interfaces inherited from class javax.ws.rs.core.Response

Field Summary

Constructor Summary

Method Summary

Methods inherited from class javax.ws.rs.core.Response

Methods inherited from class java.lang.Object

Field Detail

providerFactory

attributeExceptionsTo

headers

alternateMediaType

returnType

genericReturnType

annotations

status

wasReleased

unmarshaledEntity

readerInterceptors

exception

streamFactory

linkHeader

location

executor

attributes

Constructor Detail

BaseClientResponse

BaseClientResponse

Method Detail

copyFromError

getAttributes

setAttributes

setReaderInterceptors

setStatus

setHeaders

setProviderFactory

setReturnType

getReturnType

setGenericReturnType

setAnnotations

getAttributeExceptionsTo

setAttributeExceptionsTo

getException

setException

getAnnotations

getResponseHeader

getLinkHeader

getLocationLink

getHeaderAsLink

setAlternateMediaType

getStreamFactory

setStreamFactory

resetStream

getEntity

getEntity

getEntity

getEntity

getMediaType

readFrom

getEntity

getEntity

getResponseHeaders

getMetadata

getStatus

getStatusInfo

checkFailureStatus

createResponseFailure

createResponseFailure

getResponseStatus

wasReleased

setWasReleased

releaseConnection

finalize

readEntity

readEntity

readEntity

readEntity

hasEntity

bufferEntity