com.fasterxml.jackson.jaxrs.base

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

- 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:
    JacksonJsonProvider, JacksonSmileProvider, JacksonXMLProvider

      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 com.fasterxml.jackson.databind.util.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 com.fasterxml.jackson.databind.util.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.

  - ### Constructor Summary

    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 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 Boolean` | `_findCustomUntouchable(Class<?> mainType)`
    `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)`
    `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, boolean state)`
    `THIS` | `disable(JaxRSFeature feature)`
    `THIS` | `disable(JaxRSFeature first, JaxRSFeature... f2)`
    `THIS` | `disable(com.fasterxml.jackson.core.JsonGenerator.Feature f, boolean state)`
    `THIS` | `disable(com.fasterxml.jackson.core.JsonParser.Feature f, boolean state)`
    `THIS` | `disable(com.fasterxml.jackson.databind.SerializationFeature f, boolean state)`
    `THIS` | `enable(com.fasterxml.jackson.databind.DeserializationFeature f, boolean state)`
    `THIS` | `enable(JaxRSFeature feature)`
    `THIS` | `enable(JaxRSFeature first, JaxRSFeature... f2)`
    `THIS` | `enable(com.fasterxml.jackson.core.JsonGenerator.Feature f, boolean state)`
    `THIS` | `enable(com.fasterxml.jackson.core.JsonParser.Feature f, boolean state)`
    `THIS` | `enable(com.fasterxml.jackson.databind.SerializationFeature f, boolean state)`
    `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).

    - #### _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 com.fasterxml.jackson.databind.util.LRUMap<AnnotationBundleKey,EP_CONFIG extends EndpointConfigBase<EP_CONFIG>> _readers

      Cache for resolved endpoint configurations when reading JSON data

    - #### _writers

          protected final com.fasterxml.jackson.databind.util.LRUMap<AnnotationBundleKey,EP_CONFIG extends EndpointConfigBase<EP_CONFIG>> _writers

      Cache for resolved endpoint configurations when writing JSON data

    - #### _mapperConfig

          protected final MAPPER_CONFIG extends MapperConfiguratorBase<MAPPER_CONFIG,MAPPER> _mapperConfig

      Helper object used for encapsulating configuration aspects of `ObjectMapper`

  - ### 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,
                    boolean state)

    - #### disable

          public THIS disable(com.fasterxml.jackson.databind.DeserializationFeature f,
                     boolean state)

    - #### configure

          public THIS configure(com.fasterxml.jackson.databind.SerializationFeature f,
                       boolean state)

    - #### enable

          public THIS enable(com.fasterxml.jackson.databind.SerializationFeature f,
                    boolean state)

    - #### disable

          public THIS disable(com.fasterxml.jackson.databind.SerializationFeature f,
                     boolean state)

    - #### enable

          public THIS enable(com.fasterxml.jackson.core.JsonParser.Feature f,
                    boolean state)

    - #### enable

          public THIS enable(com.fasterxml.jackson.core.JsonGenerator.Feature f,
                    boolean state)

    - #### disable

          public THIS disable(com.fasterxml.jackson.core.JsonParser.Feature f,
                     boolean state)

    - #### disable

          public THIS disable(com.fasterxml.jackson.core.JsonGenerator.Feature f,
                     boolean state)

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

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

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

    - #### locateMapper

          public MAPPER locateMapper(Class<?> type,
                            javax.ws.rs.core.MediaType mediaType)

      Method called to locate `ObjectMapper` to use for serialization and deserialization. If an instance has been explicitly defined by `setMapper(MAPPER)` (or non-null instance passed in constructor), that will be used. 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). Finally, if no mapper is found, will return a default unconfigured `ObjectMapper` instance (one constructed with default constructor and not modified in any way)
      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

    - #### _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)

Copyright © 2012–2013 FasterXML. All rights reserved.