* This mapper (or, data binder, or codec) provides functionality for

* converting between Java objects (instances of JDK provided core classes,

* beans), and matching JSON constructs.

* It will use instances of {@link JsonParser} and {@link JsonGenerator}

* for implementing actual reading/writing of JSON.

*<p>

* The main conversion API is defined in {@link ObjectCodec}, so that

* implementation details of this class need not be exposed to

* streaming parser and generator classes.

*<p>

* Note on caching: root-level deserializers are always cached, and accessed

* using full (generics-aware) type information. This is different from

* caching of referenced types, which is more limited and is done only

* for a subset of all deserializer types. The main reason for difference

* is that at root-level there is no incoming reference (and hence no

* referencing property, no referral information or annotations to

* produce differing deserializers), and that the performance impact

* greatest at root level (since it'll essentially cache the full

* graph of deserializers involved).

*/

    extends ObjectCodec

    implements Versioned

    /*

    /**********************************************************

    /* Helper classes, enums

    /**********************************************************

     */

    /**

     * Enumeration used with {@link ObjectMapper#enableDefaultTyping()}

     * to specify what kind of types (classes) default typing should

     * be used for. It will only be used if no explicit type information

     * is found, but this enumeration further limits subset of those

     * types.

     *

     * @since 1.5

     */

    public enum DefaultTyping {

        /**

         * This value means that only properties that have

         * {@link java.lang.Object} as declared type (including

         * generic types without explicit type) will use default

         * typing.

         */

        JAVA_LANG_OBJECT,

       

        /**

         * Value that means that default typing will be used for

         * properties with declared type of {@link java.lang.Object}

         * or an abstract type (abstract class or interface).

         * Note that this does <b>not</b> include array types.

         */

        OBJECT_AND_NON_CONCRETE,

        /**

         * Value that means that default typing will be used for

         * all types covered by {@link #OBJECT_AND_NON_CONCRETE}

         * plus all array types for them.

         */

        NON_CONCRETE_AND_ARRAYS,

       

        /**

         * Value that means that default typing will be used for

         * all non-final types, with exception of small number of

         * "natural" types (String, Boolean, Integer, Double), which

         * can be correctly inferred from JSON; as well as for

         * all arrays of non-final types.

         */

        NON_FINAL

    }

    /**

     * Customized {@link TypeResolverBuilder} that provides type resolver builders

     * used with so-called "default typing"

     * (see {@link ObjectMapper#enableDefaultTyping()} for details).

     *<p>

     * Type resolver construction is based on configuration: implementation takes care

     * of only providing builders in cases where type information should be applied.

     * This is important since build calls may be sent for any and all types, and

     * type information should NOT be applied to all of them.

     */

    public static class DefaultTypeResolverBuilder

        extends StdTypeResolverBuilder

    {

        /**

         * Definition of what types is this default typer valid for.

         */

        protected final DefaultTyping _appliesFor;

        public DefaultTypeResolverBuilder(DefaultTyping t) {

            _appliesFor = t;

        }

        @Override

        public TypeDeserializer buildTypeDeserializer(DeserializationConfig config,

                JavaType baseType, Collection<NamedType> subtypes, BeanProperty property)

        {

            return useForType(baseType) ? super.buildTypeDeserializer(config, baseType, subtypes, property) : null;

        }

        @Override

        public TypeSerializer buildTypeSerializer(SerializationConfig config,

                JavaType baseType, Collection<NamedType> subtypes, BeanProperty property)

        {

            return useForType(baseType) ? super.buildTypeSerializer(config, baseType, subtypes, property) : null;           

        }

        /**

         * Method called to check if the default type handler should be

         * used for given type.

         * Note: "natural types" (String, Boolean, Integer, Double) will never

         * use typing; that is both due to them being concrete and final,

         * and since actual serializers and deserializers will also ignore any

         * attempts to enforce typing.

         */

        public boolean useForType(JavaType t)

        {

            switch (_appliesFor) {

            case NON_CONCRETE_AND_ARRAYS:

                while (t.isArrayType()) {

                    t = t.getContentType();

                }

                // fall through

            case OBJECT_AND_NON_CONCRETE:

                return (t.getRawClass() == Object.class) || !t.isConcrete();

            case NON_FINAL:

                while (t.isArrayType()) {

                    t = t.getContentType();

                }

                return !t.isFinal(); // includes Object.class

            default:

            //case JAVA_LANG_OBJECT:

                return (t.getRawClass() == Object.class);

            }

        }

    }

    /*

    /**********************************************************

    /* Internal constants, singletons

    /**********************************************************

     */

   

    // Quick little shortcut, to avoid having to use global TypeFactory instance...

    private final static JavaType JSON_NODE_TYPE = SimpleType.constructUnsafe(JsonNode.class);

    /* !!! 03-Apr-2009, tatu: Should try to avoid direct reference... but not

     *   sure what'd be simple and elegant way. So until then:

     */

    protected final static ClassIntrospector<? extends BeanDescription> DEFAULT_INTROSPECTOR = BasicClassIntrospector.instance;

    // 16-May-2009, tatu: Ditto ^^^

    protected final static AnnotationIntrospector DEFAULT_ANNOTATION_INTROSPECTOR = new JacksonAnnotationIntrospector();

    /**

     * @since 1.5

     */

    protected final static VisibilityChecker<?> STD_VISIBILITY_CHECKER = VisibilityChecker.Std.defaultInstance();

   

    /*

    /**********************************************************

    /* Configuration settings, shared

    /**********************************************************

     */

    /**

     * Factory used to create {@link JsonParser} and {@link JsonGenerator}

     * instances as necessary.

     */

    protected final JsonFactory _jsonFactory;

    /**

     * Registered concrete subtypes that can be used instead of (or

     * in addition to) ones declared using annotations.

     *

     * @since 1.6

     */

    protected SubtypeResolver _subtypeResolver;

    /**

     * Specific factory used for creating {@link JavaType} instances;

     * needed to allow modules to add more custom type handling

     * (mostly to support types of non-Java JVM languages)

     */

    protected TypeFactory _typeFactory;

    /**

     * Provider for values to inject in deserialized POJOs.

     *

     * @since 1.9

     */

    protected InjectableValues _injectableValues;

   

    /*

    /**********************************************************

    /* Configuration settings, serialization

    /**********************************************************

     */

    /**

     * Configuration object that defines basic global

     * settings for the serialization process

     */

    protected SerializationConfig _serializationConfig;

    /**

     * Object that manages access to serializers used for serialization,

     * including caching.

     * It is configured with {@link #_serializerFactory} to allow

     * for constructing custom serializers.

     */

    protected SerializerProvider _serializerProvider;

    /**

     * Serializer factory used for constructing serializers.

     */

    protected SerializerFactory _serializerFactory;

    /*

    /**********************************************************

    /* Configuration settings, deserialization

    /**********************************************************

     */

    /**

     * Configuration object that defines basic global

     * settings for the serialization process

     */

    protected DeserializationConfig _deserializationConfig;

    /**

     * Object that manages access to deserializers used for deserializing

     * JSON content into Java objects, including possible caching

     * of the deserializers. It contains a reference to

     * {@link DeserializerFactory} to use for constructing acutal deserializers.

     */

    protected DeserializerProvider _deserializerProvider;

    /*

    /**********************************************************

    /* Caching

    /**********************************************************

     */

    /* Note: handling of serializers and deserializers is not symmetric;

     * and as a result, only root-level deserializers can be cached here.

     * This is mostly because typing and resolution for deserializers is

     * fully static; whereas it is quite dynamic for serialization.

     */

    /**

     * We will use a separate main-level Map for keeping track

     * of root-level deserializers. This is where most succesful

     * cache lookups get resolved.

     * Map will contain resolvers for all kinds of types, including

     * container types: this is different from the component cache

     * which will only cache bean deserializers.

     *<p>

     * Given that we don't expect much concurrency for additions

     * (should very quickly converge to zero after startup), let's

     * explicitly define a low concurrency setting.

     *<p>

     * Since version 1.5, these may are either "raw" deserializers (when

     * no type information is needed for base type), or type-wrapped

     * deserializers (if it is needed)

     */

    final protected ConcurrentHashMap<JavaType, JsonDeserializer<Object>> _rootDeserializers

        = new ConcurrentHashMap<JavaType, JsonDeserializer<Object>>(64, 0.6f, 2);

    /*

    /**********************************************************

    /* Life-cycle: constructing instance

    /**********************************************************

     */

    /**

     * Default constructor, which will construct the default

     * {@link JsonFactory} as necessary, use

     * {@link StdSerializerProvider} as its

     * {@link SerializerProvider}, and

     * {@link BeanSerializerFactory} as its

     * {@link SerializerFactory}.

     * This means that it

     * can serialize all standard JDK types, as well as regular

     * Java Beans (based on method names and Jackson-specific annotations),

     * but does not support JAXB annotations.

     */

    public ObjectMapper()

    {

        this(null, null, null);

    }

    /**

     * Construct mapper that uses specified {@link JsonFactory}

     * for constructing necessary {@link JsonParser}s and/or

     * {@link JsonGenerator}s.

     */

    public ObjectMapper(JsonFactory jf)

    {

        this(jf, null, null);

    }

    /**

     * Construct mapper that uses specified {@link SerializerFactory}

     * for constructing necessary serializers.

     *

     * @deprecated Use other constructors instead; note that

     *   you can just set serializer factory with {@link #setSerializerFactory}

     */

    @Deprecated

    public ObjectMapper(SerializerFactory sf)

    {

        this(null, null, null);

        setSerializerFactory(sf);

    }

    public ObjectMapper(JsonFactory jf,

                        SerializerProvider sp, DeserializerProvider dp)

    {

      this(jf, sp, dp, null, null);

    }

    /**

     *

     * @param jf JsonFactory to use: if null, a new {@link MappingJsonFactory} will be constructed

     * @param sp SerializerProvider to use: if null, a {@link StdSerializerProvider} will be constructed

     * @param dp DeserializerProvider to use: if null, a {@link StdDeserializerProvider} will be constructed

     * @param sconfig Serialization configuration to use; if null, basic {@link SerializationConfig}

     *   will be constructed

     * @param dconfig Deserialization configuration to use; if null, basic {@link DeserializationConfig}

     *   will be constructed

     */

    public ObjectMapper(JsonFactory jf,

            SerializerProvider sp, DeserializerProvider dp,

            SerializationConfig sconfig, DeserializationConfig dconfig)

    {

        /* 02-Mar-2009, tatu: Important: we MUST default to using

         *   the mapping factory, otherwise tree serialization will

         *   have problems with POJONodes.

         * 03-Jan-2010, tatu: and obviously we also must pass 'this',

         *    to create actual linking.

         */

        if (jf == null) {

            _jsonFactory = new MappingJsonFactory(this);

        } else {

            _jsonFactory = jf;

            if (jf.getCodec() == null) { // as per [JACKSON-741]

                _jsonFactory.setCodec(this);

            }

        }

        // and default type factory is shared one

        _typeFactory = TypeFactory.defaultInstance();

        _serializationConfig = (sconfig != null) ? sconfig :

            new SerializationConfig(DEFAULT_INTROSPECTOR, DEFAULT_ANNOTATION_INTROSPECTOR, STD_VISIBILITY_CHECKER,

                    null, null, _typeFactory, null);

        _deserializationConfig = (dconfig != null) ? dconfig :

            new DeserializationConfig(DEFAULT_INTROSPECTOR, DEFAULT_ANNOTATION_INTROSPECTOR, STD_VISIBILITY_CHECKER,

                    null, null, _typeFactory, null);

        _serializerProvider = (sp == null) ? new StdSerializerProvider() : sp;

        _deserializerProvider = (dp == null) ? new StdDeserializerProvider() : dp;

        // Default serializer factory is stateless, can just assign

        _serializerFactory = BeanSerializerFactory.instance;

    }

    /*

    /**********************************************************

    /* Versioned impl

    /**********************************************************

     */

   

    /**

     * Method that will return version information stored in and read from jar

     * that contains this class.

     *

     * @since 1.6

     */

    //@Override

    public Version version() {

        return VersionUtil.versionFor(getClass());

    }

   

    /*

    /**********************************************************

    /* Module registration

    /**********************************************************

     */

    /**

     * Method for registering a module that can extend functionality

     * provided by this mapper; for example, by adding providers for

     * custom serializers and deserializers.

     *

     * @param module Module to register

     *

     * @since 1.7

     */

    public void registerModule(Module module)

    {

        /* Let's ensure we have access to name and version information,

         * even if we do not have immediate use for either. This way we know

         * that they will be available from beginning

         */

        String name = module.getModuleName();

        if (name == null) {

            throw new IllegalArgumentException("Module without defined name");

        }

        Version version = module.version();

        if (version == null) {

            throw new IllegalArgumentException("Module without defined version");

        }

        final ObjectMapper mapper = this;

       

        // And then call registration

        module.setupModule(new Module.SetupContext()

        {

            // // // Accessors

            //@Override

            public Version getMapperVersion() {

                return version();

            }

            //@Override

            public DeserializationConfig getDeserializationConfig() {

                return mapper.getDeserializationConfig();

            }

            //@Override

            public SerializationConfig getSerializationConfig() {

                return mapper.getSerializationConfig();

            }

            //@Override

            public boolean isEnabled(DeserializationConfig.Feature f) {

                return mapper.isEnabled(f);

            }

            //@Override

            public boolean isEnabled(SerializationConfig.Feature f) {

                return mapper.isEnabled(f);

            }

            //@Override

            public boolean isEnabled(JsonParser.Feature f) {

                return mapper.isEnabled(f);

            }

            //@Override

            public boolean isEnabled(JsonGenerator.Feature f) {

                return mapper.isEnabled(f);

            }

           

            // // // Methods for registering handlers: deserializers, serializers

           

            //@Override

            public void addDeserializers(Deserializers d) {

                mapper._deserializerProvider = mapper._deserializerProvider.withAdditionalDeserializers(d);

            }

            //@Override

            public void addKeyDeserializers(KeyDeserializers d) {

                mapper._deserializerProvider = mapper._deserializerProvider.withAdditionalKeyDeserializers(d);

            }

           

            //@Override

            public void addSerializers(Serializers s) {

                mapper._serializerFactory = mapper._serializerFactory.withAdditionalSerializers(s);

            }

            //@Override

            public void addKeySerializers(Serializers s) {

                mapper._serializerFactory = mapper._serializerFactory.withAdditionalKeySerializers(s);

            }

           

            //@Override

            public void addBeanSerializerModifier(BeanSerializerModifier modifier) {

                mapper._serializerFactory = mapper._serializerFactory.withSerializerModifier(modifier);

            }

            //@Override

            public void addBeanDeserializerModifier(BeanDeserializerModifier modifier) {

                mapper._deserializerProvider = mapper._deserializerProvider.withDeserializerModifier(modifier);

            }

            // // // Methods for registering handlers: other

           

            //@Override

            public void addAbstractTypeResolver(AbstractTypeResolver resolver) {

                mapper._deserializerProvider = mapper._deserializerProvider.withAbstractTypeResolver(resolver);

            }

            //@Override

            public void addTypeModifier(TypeModifier modifier) {

                TypeFactory f = mapper._typeFactory;

                f = f.withModifier(modifier);

                mapper.setTypeFactory(f);

            }

            //@Override

            public void addValueInstantiators(ValueInstantiators instantiators) {

                mapper._deserializerProvider = mapper._deserializerProvider.withValueInstantiators(instantiators);

            }

           

            //@Override

            public void insertAnnotationIntrospector(AnnotationIntrospector ai) {

                mapper._deserializationConfig = mapper._deserializationConfig.withInsertedAnnotationIntrospector(ai);

                mapper._serializationConfig = mapper._serializationConfig.withInsertedAnnotationIntrospector(ai);

            }

           

            //@Override

            public void appendAnnotationIntrospector(AnnotationIntrospector ai) {

                mapper._deserializationConfig = mapper._deserializationConfig.withAppendedAnnotationIntrospector(ai);

                mapper._serializationConfig = mapper._serializationConfig.withAppendedAnnotationIntrospector(ai);

            }

            //@Override

            public void setMixInAnnotations(Class<?> target, Class<?> mixinSource) {

                mapper._deserializationConfig.addMixInAnnotations(target, mixinSource);

                mapper._serializationConfig.addMixInAnnotations(target, mixinSource);

            }

        });

    }

    /**

     * Fluent-style alternative to {@link #registerModule}; functionally equivalent to:

     *<pre>

     *  mapper.registerModule(module);

     *  return mapper;

     *</pre>

     * NOTE: name is unfortunately misleading in suggesting that a new instance

     * might be created (as is the case with most other 'withXxx()' methods

     * for Jackson core objects) -- this is not the case; rather, this is just

     * a variant of {@link #registerModule} but one that returns 'this'

     * (like it should return, but does not for historical reasons).

     *

     * @since 1.8

     */

    public ObjectMapper withModule(Module module)

    {

        registerModule(module);

        return this;

    }

    /*

    /**********************************************************

    /* Configuration: main config object access

    /**********************************************************

     */

    /**

     * Method that returns the shared default {@link SerializationConfig}

     * object that defines configuration settings for serialization.

     * Returned object is "live" meaning that changes will be used

     * for future serialization operations for this mapper when using

     * mapper's default configuration

     */

    public SerializationConfig getSerializationConfig() {

        return _serializationConfig;

    }

    /**

     * Method that creates a copy of

     * the shared default {@link SerializationConfig} object

     * that defines configuration settings for serialization.

     * Since it is a copy, any changes made to the configuration

     * object will NOT directly affect serialization done using

     * basic serialization methods that use the shared object (that is,

     * ones that do not take separate {@link SerializationConfig}

     * argument.

     *<p>

     * The use case is that of changing object settings of the configuration

     * (like date format being used, see {@link SerializationConfig#setDateFormat}).

     */

    public SerializationConfig copySerializationConfig() {

        return _serializationConfig.createUnshared(_subtypeResolver);

    }

    /**

     * Method for replacing the shared default serialization configuration

     * object.

     */

    public ObjectMapper setSerializationConfig(SerializationConfig cfg) {

        _serializationConfig = cfg;

        return this;

    }

    /**

     * Method that returns

     * the shared default {@link DeserializationConfig} object

     * that defines configuration settings for deserialization.

     * Returned object is "live" meaning that changes will be used

     * for future deserialization operations for this mapper when using

     * mapper's default configuration

     */

    public DeserializationConfig getDeserializationConfig() {

        return _deserializationConfig;

    }

    /**

     * Method that creates a copy of

     * the shared default {@link DeserializationConfig} object

     * that defines configuration settings for deserialization.

     * Since it is a copy, any changes made to the configuration

     * object will NOT directly affect deserialization done using

     * basic deserialization methods that use the shared object (that is,

     * ones that do not take separate {@link DeserializationConfig}

     * argument.

     *<p>

     * The use case is that of changing object settings of the configuration

     * (like deserialization problem handler,

     * see {@link DeserializationConfig#addHandler})

     */

    public DeserializationConfig copyDeserializationConfig() {

        return _deserializationConfig.createUnshared(_subtypeResolver)

                .passSerializationFeatures(_serializationConfig._featureFlags);

    }

    /**

     * Method for replacing the shared default deserialization configuration

     * object.

     */

    public ObjectMapper setDeserializationConfig(DeserializationConfig cfg) {

        _deserializationConfig = cfg;

        return this;

    }

    /*

    /**********************************************************

    /* Configuration: ser/deser factory, provider access

    /**********************************************************

     */

   

    /**

     * Method for setting specific {@link SerializerFactory} to use

     * for constructing (bean) serializers.

     */

    public ObjectMapper setSerializerFactory(SerializerFactory f) {

        _serializerFactory = f;

        return this;

    }

    /**

     * Method for setting specific {@link SerializerProvider} to use

     * for handling caching of {@link JsonSerializer} instances.

     */

    public ObjectMapper setSerializerProvider(SerializerProvider p) {

        _serializerProvider = p;

        return this;

    }

    /**

     * @since 1.4

     */  

    public SerializerProvider getSerializerProvider() {

        return _serializerProvider;

    }

   

    /**

     * Method for setting specific {@link DeserializerProvider} to use

     * for handling caching of {@link JsonDeserializer} instances.

     */

    public ObjectMapper setDeserializerProvider(DeserializerProvider p) {

        _deserializerProvider = p;

        return this;

    }

    /**

     * @since 1.4

     */  

    public DeserializerProvider getDeserializerProvider() {

        return _deserializerProvider;

    }

    /*

    /**********************************************************

    /* Configuration, introspection

    /**********************************************************

     */

    /**

     * Method for accessing currently configured visibility checker;

     * object used for determining whether given property element

     * (method, field, constructor) can be auto-detected or not.

     *

     * @since 1.5

     */

    public VisibilityChecker<?> getVisibilityChecker() {

        return _serializationConfig.getDefaultVisibilityChecker();

    }

    /**

     * Method for setting currently configured visibility checker;

     * object used for determining whether given property element

     * (method, field, constructor) can be auto-detected or not.

     * This default checker is used if no per-class overrides

     * are defined.

     *

     * @since 1.5

     */   

    public void setVisibilityChecker(VisibilityChecker<?> vc) {

        _deserializationConfig = _deserializationConfig.withVisibilityChecker(vc);

        _serializationConfig = _serializationConfig.withVisibilityChecker(vc);

    }

    /**

     * Convenience method that allows changing configuration for

     * underlying {@link VisibilityChecker}s, to change details of what kinds of

     * properties are auto-detected.

     * Basically short cut for doing:

     *<pre>

     *  mapper.setVisibilityChecker(

     *     mapper.getVisibilityChecker().withVisibility(forMethod, visibility)

     *  );

     *</pre>

     * one common use case would be to do:

     *<pre>

     *  mapper.setVisibility(JsonMethod.FIELD, Visibility.ANY);

     *</pre>

     * which would make all member fields serializable without further annotations,

     * instead of just public fields (default setting).

     *

     * @param forMethod Type of property descriptor affected (field, getter/isGetter,

     *     setter, creator)

     * @param visibility Minimum visibility to require for the property descriptors of type

     *

     * @return Modified mapper instance (that is, "this"), to allow chaining

     *    of configuration calls

     *

     * @since 1.9

     */

    public ObjectMapper setVisibility(JsonMethod forMethod, JsonAutoDetect.Visibility visibility)

    {

        _deserializationConfig = _deserializationConfig.withVisibility(forMethod, visibility);

        _serializationConfig = _serializationConfig.withVisibility(forMethod, visibility);

        return this;

    }

   

    /**

     * Method for accessing subtype resolver in use.

     *

     * @since 1.6

     */

    public SubtypeResolver getSubtypeResolver() {

        if (_subtypeResolver == null) {

            _subtypeResolver = new StdSubtypeResolver();

        }

        return _subtypeResolver;

    }

    /**

     * Method for setting custom subtype resolver to use.

     *

     * @since 1.6

     */

    public void setSubtypeResolver(SubtypeResolver r) {

        _subtypeResolver = r;

    }

    /**

     * Method for changing {@link AnnotationIntrospector} used by this

     * mapper instance for both serialization and deserialization

     *

     * @since 1.8

     */

    public ObjectMapper setAnnotationIntrospector(AnnotationIntrospector ai) {

        _serializationConfig = _serializationConfig.withAnnotationIntrospector(ai);

        _deserializationConfig = _deserializationConfig.withAnnotationIntrospector(ai);

        return this;

    }

   

    /**

     * Method for setting custom property naming strategy to use.

     *

     * @since 1.8

     */

    public ObjectMapper setPropertyNamingStrategy(PropertyNamingStrategy s) {

        _serializationConfig = _serializationConfig.withPropertyNamingStrategy(s);

        _deserializationConfig = _deserializationConfig.withPropertyNamingStrategy(s);

        return this;

    }

    /**

     * Method for setting defalt POJO property inclusion strategy for serialization.

     * Equivalent to:

     *<pre>

     *  mapper.setSerializationConfig(mapper.getSerializationConfig().withSerializationInclusion(incl));

     *</pre>

     *

     * @since 1.9

     */

    public ObjectMapper setSerializationInclusion(JsonSerialize.Inclusion incl) {

        _serializationConfig = _serializationConfig.withSerializationInclusion(incl);

        return this;

    }

  

    /*

    /**********************************************************

    /* Type information configuration (1.5+)

    /**********************************************************

     */

    /**

     * Convenience method that is equivalent to calling

     *<pre>

     *  enableObjectTyping(DefaultTyping.OBJECT_AND_NON_CONCRETE);

     *</pre>

     */

    public ObjectMapper enableDefaultTyping() {

        return enableDefaultTyping(DefaultTyping.OBJECT_AND_NON_CONCRETE);

    }

    /**

     * Convenience method that is equivalent to calling

     *<pre>

     *  enableObjectTyping(dti, JsonTypeInfo.As.WRAPPER_ARRAY);

     *</pre>

     */

    public ObjectMapper enableDefaultTyping(DefaultTyping dti) {

        return enableDefaultTyping(dti, JsonTypeInfo.As.WRAPPER_ARRAY);

    }

    /**

     * Method for enabling automatic inclusion of type information, needed

     * for proper deserialization of polymorphic types (unless types

     * have been annotated with {@link com.facebook.presto.hive.shaded.org.codehaus.jackson.annotate.JsonTypeInfo}).

     *

     * @param applicability Defines kinds of types for which additional type information

     *    is added; see {@link DefaultTyping} for more information.

     */

    public ObjectMapper enableDefaultTyping(DefaultTyping applicability, JsonTypeInfo.As includeAs)

    {

        TypeResolverBuilder<?> typer = new DefaultTypeResolverBuilder(applicability);

        // we'll always use full class name, when using defaulting

        typer = typer.init(JsonTypeInfo.Id.CLASS, null);

        typer = typer.inclusion(includeAs);

        return setDefaultTyping(typer);

    }

    /**

     * Method for enabling automatic inclusion of type information -- needed

     * for proper deserialization of polymorphic types (unless types

     * have been annotated with {@link com.facebook.presto.hive.shaded.org.codehaus.jackson.annotate.JsonTypeInfo}) --

     * using "As.PROPERTY" inclusion mechanism and specified property name

     * to use for inclusion (default being "@class" since default type information

     * always uses class name as type identifier)

     *

     * @since 1.7

     */

    public ObjectMapper enableDefaultTypingAsProperty(DefaultTyping applicability, String propertyName)

    {

        TypeResolverBuilder<?> typer = new DefaultTypeResolverBuilder(applicability);

        // we'll always use full class name, when using defaulting

        typer = typer.init(JsonTypeInfo.Id.CLASS, null);

        typer = typer.inclusion(JsonTypeInfo.As.PROPERTY);

        typer = typer.typeProperty(propertyName);

        return setDefaultTyping(typer);

    }

   

    /**

     * Method for disabling automatic inclusion of type information; if so, only

     * explicitly annotated types (ones with

     * {@link com.facebook.presto.hive.shaded.org.codehaus.jackson.annotate.JsonTypeInfo}) will have

     * additional embedded type information.

     */

    public ObjectMapper disableDefaultTyping() {

        return setDefaultTyping(null);