ProviderBase (Jackson JAX-RS 2.8.0 API)

java.lang.Object
- com.fasterxml.jackson.jaxrs.base.ProviderBase<THIS,MAPPER,EP_CONFIG,MAPPER_CONFIG>

All Implemented Interfaces:: com.fasterxml.jackson.core.Versioned, javax.ws.rs.ext.MessageBodyReader<Object>, javax.ws.rs.ext.MessageBodyWriter<Object>

Direct Known Subclasses:: JacksonCBORProvider, JacksonJsonProvider, JacksonSmileProvider, JacksonXMLProvider, JacksonYAMLProvider

public abstract class ProviderBase<THIS extends ProviderBase<THIS,MAPPER,EP_CONFIG,MAPPER_CONFIG>,MAPPER extends com.fasterxml.jackson.databind.ObjectMapper,EP_CONFIG extends EndpointConfigBase<EP_CONFIG>,MAPPER_CONFIG extends MapperConfiguratorBase<MAPPER_CONFIG,MAPPER>>
extends Object
implements javax.ws.rs.ext.MessageBodyReader<Object>, javax.ws.rs.ext.MessageBodyWriter<Object>, com.fasterxml.jackson.core.Versioned

Field Summary

Fields
Modifier and Type	Field and Description
`protected boolean`	`_cfgCheckCanDeserialize` Whether we want to actually check that Jackson has a deserializer for given type.
`protected boolean`	`_cfgCheckCanSerialize` Whether we want to actually check that Jackson has a serializer for given type.
`protected HashMap<ClassKey,Boolean>`	`_cfgCustomUntouchables` Map that contains overrides to default list of untouchable types: `true` meaning that entry is untouchable, `false` that is is not.
`protected Class<?>`	`_defaultReadView` View to use for reading if none defined for the end point.
`protected Class<?>`	`_defaultWriteView` View to use for writing if none defined for the end point.
`protected int`	`_jaxRSFeatures` Feature flags set.
`protected MAPPER_CONFIG`	`_mapperConfig` Helper object used for encapsulating configuration aspects of `ObjectMapper`
`protected AtomicReference<IOException>`	`_noContentExceptionRef`
`protected LRUMap<AnnotationBundleKey,EP_CONFIG>`	`_readers` Cache for resolved endpoint configurations when reading JSON data
`static Class<?>[]`	`_unreadableClasses`
`static HashSet<ClassKey>`	`_untouchables`
`static Class<?>[]`	`_unwritableClasses`
`protected LRUMap<AnnotationBundleKey,EP_CONFIG>`	`_writers` Cache for resolved endpoint configurations when writing JSON data
`static Class<?>[]`	`DEFAULT_UNREADABLES` These are classes that we never use for reading (never try to deserialize instances of these types).
`protected static HashSet<ClassKey>`	`DEFAULT_UNTOUCHABLES` Looks like we need to worry about accidental data binding for types we shouldn't be handling.
`static Class<?>[]`	`DEFAULT_UNWRITABLES` These are classes that we never use for writing (never try to serialize instances of these types).
`static String`	`HEADER_CONTENT_TYPE_OPTIONS` This header is useful on Windows, trying to deal with potential XSS attacks.
`protected static int`	`JAXRS_FEATURE_DEFAULTS`

Constructor Summary

Constructors
Modifier Constructor and Description

protected ProviderBase()
Deprecated.

protected ProviderBase(MAPPER_CONFIG mconfig)

Constructors
Modifier	Constructor and Description
`protected`	`ProviderBase()` Deprecated.
`protected`	`ProviderBase(MAPPER_CONFIG mconfig)`

Method Summary

Methods
Modifier and Type	Method and Description
`protected static void`	`_addSuperTypes(Class<?> cls, Class<?> endBefore, Collection<Class<?>> result, boolean addClassItself)`
`protected EP_CONFIG`	`_configForReading(MAPPER mapper, Annotation[] annotations, Class<?> defaultView)`
`protected abstract EP_CONFIG`	`_configForReading(com.fasterxml.jackson.databind.ObjectReader reader, Annotation[] annotations)`
`protected EP_CONFIG`	`_configForWriting(MAPPER mapper, Annotation[] annotations, Class<?> defaultView)`
`protected abstract EP_CONFIG`	`_configForWriting(com.fasterxml.jackson.databind.ObjectWriter writer, Annotation[] annotations)`
`protected static boolean`	`_containedIn(Class<?> mainType, HashSet<ClassKey> set)`
`protected com.fasterxml.jackson.core.JsonGenerator`	`_createGenerator(com.fasterxml.jackson.databind.ObjectWriter writer, OutputStream rawStream, com.fasterxml.jackson.core.JsonEncoding enc)` Overridable helper method called to create a `JsonGenerator` for writing contents into given raw `OutputStream`.
`protected IOException`	`_createNoContentException()`
`protected com.fasterxml.jackson.core.JsonParser`	`_createParser(com.fasterxml.jackson.databind.ObjectReader reader, InputStream rawStream)` Overridable helper method called to create a `JsonParser` for reading contents of given raw `InputStream`.
`protected EP_CONFIG`	`_endpointForReading(Class<Object> type, Type genericType, Annotation[] annotations, javax.ws.rs.core.MediaType mediaType, javax.ws.rs.core.MultivaluedMap<String,String> httpHeaders)` Overridable helper method that will basically fetch representation of the endpoint that can be used to get `ObjectReader` to use for deserializing content
`protected EP_CONFIG`	`_endpointForWriting(Object value, Class<?> type, Type genericType, Annotation[] annotations, javax.ws.rs.core.MediaType mediaType, javax.ws.rs.core.MultivaluedMap<String,Object> httpHeaders)`
`protected Boolean`	`_findCustomUntouchable(Class<?> mainType)`
`protected boolean`	`_isIgnorableForReading(ClassKey typeKey)` Overridable helper method called to check whether given type is a known "ignorable type" (in context of reading), values of which are not bound from content.
`protected boolean`	`_isIgnorableForWriting(ClassKey typeKey)` Overridable helper method called to check whether given type is a known "ignorable type" (in context of reading), values of which can not be written out.
`protected boolean`	`_isSpecialReadable(Class<?> type)` Overridable helper method used to allow handling of somewhat special types for reading
`protected abstract MAPPER`	`_locateMapperViaProvider(Class<?> type, javax.ws.rs.core.MediaType mediaType)` Helper method that is called if no mapper has been explicitly configured.
`protected void`	`_modifyHeaders(Object value, Class<?> type, Type genericType, Annotation[] annotations, javax.ws.rs.core.MultivaluedMap<String,Object> httpHeaders, EP_CONFIG endpoint)` Overridable method used for adding optional response headers before serializing response object.
`void`	`addUntouchable(Class<?> type)` Method for marking specified type as "untouchable", meaning that provider will not try to read or write values of this type (or its subtypes).
`void`	`checkCanDeserialize(boolean state)` Method for defining whether actual detection for existence of a deserializer for type should be done when `isReadable(java.lang.Class<?>, java.lang.reflect.Type, java.lang.annotation.Annotation[], javax.ws.rs.core.MediaType)` is called.
`void`	`checkCanSerialize(boolean state)` Method for defining whether actual detection for existence of a serializer for type should be done when `isWriteable(java.lang.Class<?>, java.lang.reflect.Type, java.lang.annotation.Annotation[], javax.ws.rs.core.MediaType)` is called.
`THIS`	`configure(com.fasterxml.jackson.databind.DeserializationFeature f, boolean state)`
`THIS`	`configure(JaxRSFeature feature, boolean state)`
`THIS`	`configure(com.fasterxml.jackson.core.JsonGenerator.Feature f, boolean state)`
`THIS`	`configure(com.fasterxml.jackson.core.JsonParser.Feature f, boolean state)`
`THIS`	`configure(com.fasterxml.jackson.databind.SerializationFeature f, boolean state)`
`THIS`	`disable(com.fasterxml.jackson.databind.DeserializationFeature f)`
`THIS`	`disable(JaxRSFeature feature)`
`THIS`	`disable(JaxRSFeature first, JaxRSFeature... f2)`
`THIS`	`disable(com.fasterxml.jackson.core.JsonGenerator.Feature f)`
`THIS`	`disable(com.fasterxml.jackson.core.JsonParser.Feature f)`
`THIS`	`disable(com.fasterxml.jackson.databind.SerializationFeature f)`
`THIS`	`enable(com.fasterxml.jackson.databind.DeserializationFeature f)`
`THIS`	`enable(JaxRSFeature feature)`
`THIS`	`enable(JaxRSFeature first, JaxRSFeature... f2)`
`THIS`	`enable(com.fasterxml.jackson.core.JsonGenerator.Feature f)`
`THIS`	`enable(com.fasterxml.jackson.core.JsonParser.Feature f)`
`THIS`	`enable(com.fasterxml.jackson.databind.SerializationFeature f)`
`protected com.fasterxml.jackson.core.JsonEncoding`	`findEncoding(javax.ws.rs.core.MediaType mediaType, javax.ws.rs.core.MultivaluedMap<String,Object> httpHeaders)` Helper method to use for determining desired output encoding.
`protected static List<Class<?>>`	`findSuperTypes(Class<?> cls, Class<?> endBefore)`
`protected static List<Class<?>>`	`findSuperTypes(Class<?> cls, Class<?> endBefore, List<Class<?>> result)`
`long`	`getSize(Object value, Class<?> type, Type genericType, Annotation[] annotations, javax.ws.rs.core.MediaType mediaType)` Method that JAX-RS container calls to try to figure out serialized length of given value.
`protected abstract boolean`	`hasMatchingMediaType(javax.ws.rs.core.MediaType mediaType)` Helper method used to check whether given media type is supported by this provider.
`protected boolean`	`hasMatchingMediaTypeForReading(javax.ws.rs.core.MediaType mediaType)` Helper method used to check whether given media type is supported by this provider for read operations (when binding input data such as POST body).
`protected boolean`	`hasMatchingMediaTypeForWriting(javax.ws.rs.core.MediaType mediaType)` Helper method used to check whether given media type is supported by this provider for writing operations, such as when converting response object to response body of request (like GET or POST).
`boolean`	`isEnabled(JaxRSFeature f)`
`boolean`	`isReadable(Class<?> type, Type genericType, Annotation[] annotations, javax.ws.rs.core.MediaType mediaType)` Method that JAX-RS container calls to try to check whether values of given type (and media type) can be deserialized by this provider.
`boolean`	`isWriteable(Class<?> type, Type genericType, Annotation[] annotations, javax.ws.rs.core.MediaType mediaType)` Method that JAX-RS container calls to try to check whether given value (of specified type) can be serialized by this provider.
`MAPPER`	`locateMapper(Class<?> type, javax.ws.rs.core.MediaType mediaType)` Method called to locate `ObjectMapper` to use for serialization and deserialization.
`Object`	`readFrom(Class<Object> type, Type genericType, Annotation[] annotations, javax.ws.rs.core.MediaType mediaType, javax.ws.rs.core.MultivaluedMap<String,String> httpHeaders, InputStream entityStream)` Method that JAX-RS container calls to deserialize given value.
`void`	`removeUntouchable(Class<?> type)` Method for removing definition of specified type as untouchable: usually only
`void`	`setAnnotationsToUse(Annotations[] annotationsToUse)` Method for configuring which annotation sets to use (including none).
`THIS`	`setDefaultReadView(Class<?> view)` Method for specifying JSON View to use for reading content when end point does not have explicit View annotations.
`THIS`	`setDefaultView(Class<?> view)` Method for specifying JSON View to use for reading and writing content when end point does not have explicit View annotations.
`THIS`	`setDefaultWriteView(Class<?> view)` Method for specifying JSON View to use for reading content when end point does not have explicit View annotations.
`void`	`setMapper(MAPPER m)` Method that can be used to directly define `ObjectMapper` to use for serialization and deserialization; if null, will use the standard provider discovery from context instead.
`void`	`writeTo(Object value, Class<?> type, Type genericType, Annotation[] annotations, javax.ws.rs.core.MediaType mediaType, javax.ws.rs.core.MultivaluedMap<String,Object> httpHeaders, OutputStream entityStream)` Method that JAX-RS container calls to serialize given value.

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

Methods inherited from interface com.fasterxml.jackson.core.Versioned
version

- Field Detail
  - HEADER_CONTENT_TYPE_OPTIONS
```
public static final String HEADER_CONTENT_TYPE_OPTIONS
```
    This header is useful on Windows, trying to deal with potential XSS attacks.
    
    See Also:
    Constant Field Values
  - DEFAULT_UNTOUCHABLES
```
protected static final HashSet<ClassKey> DEFAULT_UNTOUCHABLES
```
    Looks like we need to worry about accidental data binding for types we shouldn't be handling. This is probably not a very good way to do it, but let's start by blacklisting things we are not to handle.
    (why ClassKey? since plain old Class has no hashCode() defined, lookups are painfully slow)
  - DEFAULT_UNREADABLES
```
public static final Class<?>[] DEFAULT_UNREADABLES
```
    These are classes that we never use for reading (never try to deserialize instances of these types).
  - DEFAULT_UNWRITABLES
```
public static final Class<?>[] DEFAULT_UNWRITABLES
```
    These are classes that we never use for writing (never try to serialize instances of these types).
  - JAXRS_FEATURE_DEFAULTS
```
protected static final int JAXRS_FEATURE_DEFAULTS
```
  - _mapperConfig
```
protected final MAPPER_CONFIG extends MapperConfiguratorBase<MAPPER_CONFIG,MAPPER> _mapperConfig
```
    Helper object used for encapsulating configuration aspects of ObjectMapper
  - _cfgCustomUntouchables
```
protected HashMap<ClassKey,Boolean> _cfgCustomUntouchables
```
    Map that contains overrides to default list of untouchable types: true meaning that entry is untouchable, false that is is not.
  - _cfgCheckCanSerialize
```
protected boolean _cfgCheckCanSerialize
```
    Whether we want to actually check that Jackson has a serializer for given type. Since this should generally be the case (due to auto-discovery) and since the call to check availability can be bit expensive, defaults to false.
  - _cfgCheckCanDeserialize
```
protected boolean _cfgCheckCanDeserialize
```
    Whether we want to actually check that Jackson has a deserializer for given type. Since this should generally be the case (due to auto-discovery) and since the call to check availability can be bit expensive, defaults to false.
  - _jaxRSFeatures
```
protected int _jaxRSFeatures
```
    Feature flags set.
    
    Since:
    
    2.3
  - _defaultReadView
```
protected Class<?> _defaultReadView
```
    View to use for reading if none defined for the end point.
  - _defaultWriteView
```
protected Class<?> _defaultWriteView
```
    View to use for writing if none defined for the end point.
  - _untouchables
```
public static final HashSet<ClassKey> _untouchables
```
  - _unreadableClasses
```
public static final Class<?>[] _unreadableClasses
```
  - _unwritableClasses
```
public static final Class<?>[] _unwritableClasses
```
  - _readers
```
protected final LRUMap<AnnotationBundleKey,EP_CONFIG extends EndpointConfigBase<EP_CONFIG>> _readers
```
    Cache for resolved endpoint configurations when reading JSON data
  - _writers
```
protected final LRUMap<AnnotationBundleKey,EP_CONFIG extends EndpointConfigBase<EP_CONFIG>> _writers
```
    Cache for resolved endpoint configurations when writing JSON data
  - _noContentExceptionRef
```
protected final AtomicReference<IOException> _noContentExceptionRef
```
- Constructor Detail
  - ProviderBase
```
protected ProviderBase(MAPPER_CONFIG mconfig)
```
  - ProviderBase
```
@Deprecated
protected ProviderBase()
```
    Deprecated.
    
    Constructor that is only added to resolve issue #10; problems with combination of RESTeasy and CDI. Should NOT be used by any code explicitly; only exists for proxy support.
- Method Detail
  - checkCanDeserialize
```
public void checkCanDeserialize(boolean state)
```
    Method for defining whether actual detection for existence of a deserializer for type should be done when isReadable(java.lang.Class<?>, java.lang.reflect.Type, java.lang.annotation.Annotation[], javax.ws.rs.core.MediaType) is called.
  - checkCanSerialize
```
public void checkCanSerialize(boolean state)
```
    Method for defining whether actual detection for existence of a serializer for type should be done when isWriteable(java.lang.Class<?>, java.lang.reflect.Type, java.lang.annotation.Annotation[], javax.ws.rs.core.MediaType) is called.
  - addUntouchable
```
public void addUntouchable(Class<?> type)
```
    Method for marking specified type as "untouchable", meaning that provider will not try to read or write values of this type (or its subtypes).
    
    Parameters:
    type - Type to consider untouchable; can be any kind of class, including abstract class or interface. No instance of this type (including subtypes, i.e. types assignable to this type) will be read or written by provider
  - removeUntouchable
```
public void removeUntouchable(Class<?> type)
```
    Method for removing definition of specified type as untouchable: usually only
    
    Since:
    
    2.2
  - setAnnotationsToUse
```
public void setAnnotationsToUse(Annotations[] annotationsToUse)
```
    Method for configuring which annotation sets to use (including none). Annotation sets are defined in order decreasing precedence; that is, first one has the priority over following ones.
    
    Parameters:
    annotationsToUse - Ordered list of annotation sets to use; if null, default
  - setMapper
```
public void setMapper(MAPPER m)
```
    Method that can be used to directly define ObjectMapper to use for serialization and deserialization; if null, will use the standard provider discovery from context instead. Default setting is null.
  - setDefaultReadView
```
public THIS setDefaultReadView(Class<?> view)
```
    Method for specifying JSON View to use for reading content when end point does not have explicit View annotations.
    
    Since:
    
    2.3
  - setDefaultWriteView
```
public THIS setDefaultWriteView(Class<?> view)
```
    Method for specifying JSON View to use for reading content when end point does not have explicit View annotations.
    
    Since:
    
    2.3
  - setDefaultView
```
public THIS setDefaultView(Class<?> view)
```
    Method for specifying JSON View to use for reading and writing content when end point does not have explicit View annotations. Functionally equivalent to: setDefaultReadView(view); setDefaultWriteView(view);
    
    Since:
    
    2.3
  - configure
```
public THIS configure(JaxRSFeature feature,
             boolean state)
```
  - enable
```
public THIS enable(JaxRSFeature feature)
```
  - enable
```
public THIS enable(JaxRSFeature first,
          JaxRSFeature... f2)
```
  - disable
```
public THIS disable(JaxRSFeature feature)
```
  - disable
```
public THIS disable(JaxRSFeature first,
           JaxRSFeature... f2)
```
  - isEnabled
```
public boolean isEnabled(JaxRSFeature f)
```
  - configure
```
public THIS configure(com.fasterxml.jackson.databind.DeserializationFeature f,
             boolean state)
```
  - enable
```
public THIS enable(com.fasterxml.jackson.databind.DeserializationFeature f)
```
  - disable
```
public THIS disable(com.fasterxml.jackson.databind.DeserializationFeature f)
```
  - configure
```
public THIS configure(com.fasterxml.jackson.databind.SerializationFeature f,
             boolean state)
```
  - enable
```
public THIS enable(com.fasterxml.jackson.databind.SerializationFeature f)
```
  - disable
```
public THIS disable(com.fasterxml.jackson.databind.SerializationFeature f)
```
  - enable
```
public THIS enable(com.fasterxml.jackson.core.JsonParser.Feature f)
```
  - enable
```
public THIS enable(com.fasterxml.jackson.core.JsonGenerator.Feature f)
```
  - disable
```
public THIS disable(com.fasterxml.jackson.core.JsonParser.Feature f)
```
  - disable
```
public THIS disable(com.fasterxml.jackson.core.JsonGenerator.Feature f)
```
  - configure
```
public THIS configure(com.fasterxml.jackson.core.JsonParser.Feature f,
             boolean state)
```
  - configure
```
public THIS configure(com.fasterxml.jackson.core.JsonGenerator.Feature f,
             boolean state)
```
  - hasMatchingMediaTypeForReading
```
protected boolean hasMatchingMediaTypeForReading(javax.ws.rs.core.MediaType mediaType)
```
    Helper method used to check whether given media type is supported by this provider for read operations (when binding input data such as POST body).
    Default implementation simply calls hasMatchingMediaType(javax.ws.rs.core.MediaType).
    
    Since:
    
    2.3
  - hasMatchingMediaTypeForWriting
```
protected boolean hasMatchingMediaTypeForWriting(javax.ws.rs.core.MediaType mediaType)
```
    Helper method used to check whether given media type is supported by this provider for writing operations, such as when converting response object to response body of request (like GET or POST).
    Default implementation simply calls hasMatchingMediaType(javax.ws.rs.core.MediaType).
    
    Since:
    
    2.3
  - hasMatchingMediaType
```
protected abstract boolean hasMatchingMediaType(javax.ws.rs.core.MediaType mediaType)
```
    Helper method used to check whether given media type is supported by this provider.
    
    Since:
    
    2.2
  - _locateMapperViaProvider
```
protected abstract MAPPER _locateMapperViaProvider(Class<?> type,
                              javax.ws.rs.core.MediaType mediaType)
```
    Helper method that is called if no mapper has been explicitly configured.
  - _configForReading
```
protected EP_CONFIG _configForReading(MAPPER mapper,
                          Annotation[] annotations,
                          Class<?> defaultView)
```
  - _configForWriting
```
protected EP_CONFIG _configForWriting(MAPPER mapper,
                          Annotation[] annotations,
                          Class<?> defaultView)
```
  - _configForReading
```
protected abstract EP_CONFIG _configForReading(com.fasterxml.jackson.databind.ObjectReader reader,
                          Annotation[] annotations)
```
  - _configForWriting
```
protected abstract EP_CONFIG _configForWriting(com.fasterxml.jackson.databind.ObjectWriter writer,
                          Annotation[] annotations)
```
  - getSize
```
public long getSize(Object value,
           Class<?> type,
           Type genericType,
           Annotation[] annotations,
           javax.ws.rs.core.MediaType mediaType)
```
    Method that JAX-RS container calls to try to figure out serialized length of given value. Since computation of this length is about as expensive as serialization itself, implementation will return -1 to denote "not known", so that container will determine length from actual serialized output (if needed).
    
    Specified by:
    
    getSize in interface javax.ws.rs.ext.MessageBodyWriter<Object>
  - isWriteable
```
public boolean isWriteable(Class<?> type,
                  Type genericType,
                  Annotation[] annotations,
                  javax.ws.rs.core.MediaType mediaType)
```
    Method that JAX-RS container calls to try to check whether given value (of specified type) can be serialized by this provider. Implementation will first check that expected media type is expected one (by call to hasMatchingMediaType(javax.ws.rs.core.MediaType)); then verify that type is not one of "untouchable" types (types we will never automatically handle), and finally that there is a serializer for type (iff checkCanSerialize(boolean) has been called with true argument -- otherwise assumption is there will be a handler)
    
    Specified by:
    
    isWriteable in interface javax.ws.rs.ext.MessageBodyWriter<Object>
  - writeTo
```
public void writeTo(Object value,
           Class<?> type,
           Type genericType,
           Annotation[] annotations,
           javax.ws.rs.core.MediaType mediaType,
           javax.ws.rs.core.MultivaluedMap<String,Object> httpHeaders,
           OutputStream entityStream)
             throws IOException
```
    Method that JAX-RS container calls to serialize given value.
    
    Specified by:
    
    writeTo in interface javax.ws.rs.ext.MessageBodyWriter<Object>
    
    Throws:
    
    IOException
  - findEncoding
```
protected com.fasterxml.jackson.core.JsonEncoding findEncoding(javax.ws.rs.core.MediaType mediaType,
                                                   javax.ws.rs.core.MultivaluedMap<String,Object> httpHeaders)
```
    Helper method to use for determining desired output encoding. For now, will always just use UTF-8...
  - _modifyHeaders
```
protected void _modifyHeaders(Object value,
                  Class<?> type,
                  Type genericType,
                  Annotation[] annotations,
                  javax.ws.rs.core.MultivaluedMap<String,Object> httpHeaders,
                  EP_CONFIG endpoint)
                       throws IOException
```
    Overridable method used for adding optional response headers before serializing response object.
    
    Throws:
    
    IOException
  - _createGenerator
```
protected com.fasterxml.jackson.core.JsonGenerator _createGenerator(com.fasterxml.jackson.databind.ObjectWriter writer,
                                                        OutputStream rawStream,
                                                        com.fasterxml.jackson.core.JsonEncoding enc)
                                                             throws IOException
```
    Overridable helper method called to create a JsonGenerator for writing contents into given raw OutputStream.
    
    Throws:
    
    IOException
    Since:
    
    2.3
  - _endpointForWriting
```
protected EP_CONFIG _endpointForWriting(Object value,
                            Class<?> type,
                            Type genericType,
                            Annotation[] annotations,
                            javax.ws.rs.core.MediaType mediaType,
                            javax.ws.rs.core.MultivaluedMap<String,Object> httpHeaders)
```
  - isReadable
```
public boolean isReadable(Class<?> type,
                 Type genericType,
                 Annotation[] annotations,
                 javax.ws.rs.core.MediaType mediaType)
```
    Method that JAX-RS container calls to try to check whether values of given type (and media type) can be deserialized by this provider. Implementation will first check that expected media type is a JSON type (via call to hasMatchingMediaType(javax.ws.rs.core.MediaType)); then verify that type is not one of "untouchable" types (types we will never automatically handle), and finally that there is a deserializer for type (iff checkCanDeserialize(boolean) has been called with true argument -- otherwise assumption is there will be a handler)
    
    Specified by:
    
    isReadable in interface javax.ws.rs.ext.MessageBodyReader<Object>
  - readFrom
```
public Object readFrom(Class<Object> type,
              Type genericType,
              Annotation[] annotations,
              javax.ws.rs.core.MediaType mediaType,
              javax.ws.rs.core.MultivaluedMap<String,String> httpHeaders,
              InputStream entityStream)
                throws IOException
```
    Method that JAX-RS container calls to deserialize given value.
    
    Specified by:
    
    readFrom in interface javax.ws.rs.ext.MessageBodyReader<Object>
    
    Throws:
    
    IOException
  - _createParser
```
protected com.fasterxml.jackson.core.JsonParser _createParser(com.fasterxml.jackson.databind.ObjectReader reader,
                                                  InputStream rawStream)
                                                       throws IOException
```
    Overridable helper method called to create a JsonParser for reading contents of given raw InputStream. May return null to indicate that Stream is empty; that is, contains no content.
    
    Throws:
    
    IOException
    Since:
    
    2.2
  - _endpointForReading
```
protected EP_CONFIG _endpointForReading(Class<Object> type,
                            Type genericType,
                            Annotation[] annotations,
                            javax.ws.rs.core.MediaType mediaType,
                            javax.ws.rs.core.MultivaluedMap<String,String> httpHeaders)
```
    Overridable helper method that will basically fetch representation of the endpoint that can be used to get ObjectReader to use for deserializing content
    
    Since:
    
    2.8
  - locateMapper
```
public MAPPER locateMapper(Class<?> type,
                  javax.ws.rs.core.MediaType mediaType)
```
    Method called to locate ObjectMapper to use for serialization and deserialization. Exact logic depends on setting of JaxRSFeature.DYNAMIC_OBJECT_MAPPER_LOOKUP.
    If JaxRSFeature.DYNAMIC_OBJECT_MAPPER_LOOKUP is disabled (default setting unless changed), behavior is as follows:
    1. If an instance has been explicitly defined by setMapper(MAPPER) (or non-null instance passed in constructor), that will be used.
    2. If not, will try to locate it using standard JAX-RS ContextResolver mechanism, if it has been properly configured to access it (by JAX-RS runtime).
    3. Finally, if no mapper is found, will return a default unconfigured ObjectMapper instance (one constructed with default constructor and not modified in any way)
    If JaxRSFeature.DYNAMIC_OBJECT_MAPPER_LOOKUP is enabled, steps 1 and 2 are reversed, such that JAX-RS ContextResolver is first used, and only if none is defined will configured mapper be used.
    Parameters:
    type - Class of object being serialized or deserialized; not checked at this point, since it is assumed that unprocessable classes have been already weeded out, but will be passed to ContextResolver as is.
    mediaType - Declared media type for the instance to process: not used by this method, but will be passed to ContextResolver as is.
  - _isSpecialReadable
```
protected boolean _isSpecialReadable(Class<?> type)
```
    Overridable helper method used to allow handling of somewhat special types for reading
    
    Since:
    
    2.2
  - _isIgnorableForReading
```
protected boolean _isIgnorableForReading(ClassKey typeKey)
```
    Overridable helper method called to check whether given type is a known "ignorable type" (in context of reading), values of which are not bound from content.
    
    Since:
    
    2.6
  - _isIgnorableForWriting
```
protected boolean _isIgnorableForWriting(ClassKey typeKey)
```
    Overridable helper method called to check whether given type is a known "ignorable type" (in context of reading), values of which can not be written out.
    
    Since:
    
    2.6
  - _createNoContentException
```
protected IOException _createNoContentException()
```
    Since:
    
    2.4
  - _containedIn
```
protected static boolean _containedIn(Class<?> mainType,
                   HashSet<ClassKey> set)
```
  - _findCustomUntouchable
```
protected Boolean _findCustomUntouchable(Class<?> mainType)
```
  - findSuperTypes
```
protected static List<Class<?>> findSuperTypes(Class<?> cls,
                            Class<?> endBefore)
```
  - findSuperTypes
```
protected static List<Class<?>> findSuperTypes(Class<?> cls,
                            Class<?> endBefore,
                            List<Class<?>> result)
```
  - _addSuperTypes
```
protected static void _addSuperTypes(Class<?> cls,
                  Class<?> endBefore,
                  Collection<Class<?>> result,
                  boolean addClassItself)
```

Class ProviderBase<THIS extends ProviderBase<THIS,MAPPER,EP_CONFIG,MAPPER_CONFIG>,MAPPER extends com.fasterxml.jackson.databind.ObjectMapper,EP_CONFIG extends EndpointConfigBase<EP_CONFIG>,MAPPER_CONFIG extends MapperConfiguratorBase<MAPPER_CONFIG,MAPPER>>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface com.fasterxml.jackson.core.Versioned

Field Detail

HEADER_CONTENT_TYPE_OPTIONS

DEFAULT_UNTOUCHABLES

DEFAULT_UNREADABLES

DEFAULT_UNWRITABLES

JAXRS_FEATURE_DEFAULTS

_mapperConfig

_cfgCustomUntouchables

_cfgCheckCanSerialize

_cfgCheckCanDeserialize

_jaxRSFeatures

_defaultReadView

_defaultWriteView

_untouchables

_unreadableClasses

_unwritableClasses

_readers

_writers

_noContentExceptionRef

Constructor Detail

ProviderBase

ProviderBase

Method Detail

checkCanDeserialize

checkCanSerialize

addUntouchable

removeUntouchable

setAnnotationsToUse

setMapper

setDefaultReadView

setDefaultWriteView

setDefaultView

configure

enable

enable

disable

disable

isEnabled

configure

enable

disable

configure

enable

disable

enable

enable

disable

disable

configure

configure

hasMatchingMediaTypeForReading

hasMatchingMediaTypeForWriting

hasMatchingMediaType

_locateMapperViaProvider

_configForReading

_configForWriting

_configForReading

_configForWriting

getSize

isWriteable

writeTo

findEncoding

_modifyHeaders

_createGenerator

_endpointForWriting

isReadable

readFrom

_createParser

_endpointForReading

locateMapper

_isSpecialReadable

_isIgnorableForReading

_isIgnorableForWriting

_createNoContentException