com.fasterxml.jackson.databind.jsontype.impl

## Class StdTypeResolverBuilder

- java.lang.Object
- - com.fasterxml.jackson.databind.jsontype.impl.StdTypeResolverBuilder

All Implemented Interfaces:
  TypeResolverBuilder<StdTypeResolverBuilder>

Direct Known Subclasses:
  ObjectMapper.DefaultTypeResolverBuilder

    public class StdTypeResolverBuilder
    extends Object
    implements TypeResolverBuilder<StdTypeResolverBuilder>

Default `TypeResolverBuilder` implementation.

### Field Summary

Fields
`protected TypeIdResolver` `_customIdResolver`
`protected Class<?>` `_defaultImpl` Default class to use in case type information is not available or is broken.
`protected com.fasterxml.jackson.annotation.JsonTypeInfo.Id` `_idType`
`protected com.fasterxml.jackson.annotation.JsonTypeInfo.As` `_includeAs`
`protected Boolean` `_requireTypeIdForSubtypes` Boolean value configured through `JsonTypeInfo.requireTypeIdForSubtypes()`.
`protected boolean` `_typeIdVisible` Whether type id should be exposed to deserializers or not
`protected String` `_typeProperty`

### Constructor Summary

Constructors
`` `StdTypeResolverBuilder()`
`protected` `StdTypeResolverBuilder(com.fasterxml.jackson.annotation.JsonTypeInfo.Id idType, com.fasterxml.jackson.annotation.JsonTypeInfo.As idAs, String propName)`
`` `StdTypeResolverBuilder(com.fasterxml.jackson.annotation.JsonTypeInfo.Value settings)`
`protected` `StdTypeResolverBuilder(StdTypeResolverBuilder base, Class<?> defaultImpl)` Copy-constructor

### Method Summary

All Methods Static Methods Instance Methods Concrete Methods
`protected boolean` `_hasTypeResolver(DeserializationConfig config, JavaType baseType)` Checks whether the given class has annotations indicating some type resolver is applied, for example `JsonTypeInfo`.
`protected String` `_propName(String propName, com.fasterxml.jackson.annotation.JsonTypeInfo.Id idType)`
`protected boolean` `_strictTypeIdHandling(DeserializationConfig config, JavaType baseType)` Determines whether strict type ID handling should be used for this type or not.
`protected boolean` `allowPrimitiveTypes(MapperConfig<?> config, JavaType baseType)` Overridable helper method that is called to determine whether type serializers and type deserializers may be created even if base type is Java `primitive` type.
`TypeDeserializer` `buildTypeDeserializer(DeserializationConfig config, JavaType baseType, Collection<NamedType> subtypes)` Method for building type deserializer based on current configuration of this builder.
`TypeSerializer` `buildTypeSerializer(SerializationConfig config, JavaType baseType, Collection<NamedType> subtypes)` Method for building type serializer based on current configuration of this builder.
`StdTypeResolverBuilder` `defaultImpl(Class<?> defaultImpl)` Method for specifying default implementation to use if type id is either not available, or cannot be resolved.
`protected JavaType` `defineDefaultImpl(DeserializationConfig config, JavaType baseType)`
`Class<?>` `getDefaultImpl()` Accessor for currently configured default type; implementation class that may be used in case no valid type information is available during type resolution
`String` `getTypeProperty()`
`protected TypeIdResolver` `idResolver(MapperConfig<?> config, JavaType baseType, PolymorphicTypeValidator subtypeValidator, Collection<NamedType> subtypes, boolean forSer, boolean forDeser)` Helper method that will either return configured custom type id resolver, or construct a standard resolver given configuration.
`StdTypeResolverBuilder` `inclusion(com.fasterxml.jackson.annotation.JsonTypeInfo.As includeAs)` Method for specifying mechanism to use for including type metadata in JSON.
`StdTypeResolverBuilder` `init(com.fasterxml.jackson.annotation.JsonTypeInfo.Id idType, TypeIdResolver idRes)` Initialization method that is called right after constructing the builder instance.
`StdTypeResolverBuilder` `init(com.fasterxml.jackson.annotation.JsonTypeInfo.Value settings, TypeIdResolver idRes)` Initialization method that is called right after constructing the builder instance, in cases where information could not be passed directly (for example when instantiated for an annotation)
`boolean` `isTypeIdVisible()`
`static StdTypeResolverBuilder` `noTypeInfoBuilder()`
`protected PolymorphicTypeValidator` `reportInvalidBaseType(MapperConfig<?> config, JavaType baseType, PolymorphicTypeValidator ptv)`
`PolymorphicTypeValidator` `subTypeValidator(MapperConfig<?> config)` Overridable helper method for determining actual validator to use when constructing type serializers and type deserializers.
`StdTypeResolverBuilder` `typeIdVisibility(boolean isVisible)` Method for specifying whether type id should be visible to `JsonDeserializer`s or not.
`StdTypeResolverBuilder` `typeProperty(String typeIdPropName)` Method for constructing an instance with specified type property name (property name to use for type id when using "as-property" inclusion).
`protected PolymorphicTypeValidator` `verifyBaseTypeValidity(MapperConfig<?> config, JavaType baseType)` Helper method called to check that base type is valid regarding possible constraints on basetype/subtype combinations allowed for polymorphic type handling.
`StdTypeResolverBuilder` `withDefaultImpl(Class<?> defaultImpl)` "Mutant factory" method for creating a new instance with different default implementation.
`StdTypeResolverBuilder` `withSettings(com.fasterxml.jackson.annotation.JsonTypeInfo.Value settings)` Method for overriding type information.

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Field Detail

#### _idType

    protected com.fasterxml.jackson.annotation.JsonTypeInfo.Id _idType

#### _includeAs

    protected com.fasterxml.jackson.annotation.JsonTypeInfo.As _includeAs

#### _typeProperty

    protected String _typeProperty

#### _typeIdVisible

    protected boolean _typeIdVisible

Whether type id should be exposed to deserializers or not

#### _requireTypeIdForSubtypes

    protected Boolean _requireTypeIdForSubtypes

Boolean value configured through `JsonTypeInfo.requireTypeIdForSubtypes()`. If this value is not `null`, this value should override the global configuration of `MapperFeature.REQUIRE_TYPE_ID_FOR_SUBTYPES`.

Since:
  2.16 (backported from Jackson 3.0)

#### _defaultImpl

    protected Class<?> _defaultImpl

Default class to use in case type information is not available or is broken.

#### _customIdResolver

    protected TypeIdResolver _customIdResolver

### Constructor Detail

#### StdTypeResolverBuilder

    public StdTypeResolverBuilder()

#### StdTypeResolverBuilder

    protected StdTypeResolverBuilder(com.fasterxml.jackson.annotation.JsonTypeInfo.Id idType,
                                     com.fasterxml.jackson.annotation.JsonTypeInfo.As idAs,
                                     String propName)

Since:
  2.9

#### StdTypeResolverBuilder

    protected StdTypeResolverBuilder(StdTypeResolverBuilder base,
                                     Class<?> defaultImpl)

Copy-constructor

Since:
  2.13

#### StdTypeResolverBuilder

    public StdTypeResolverBuilder(com.fasterxml.jackson.annotation.JsonTypeInfo.Value settings)

Since:
  2.16

### Method Detail

#### noTypeInfoBuilder

    public static StdTypeResolverBuilder noTypeInfoBuilder()

#### buildTypeSerializer

    public TypeSerializer buildTypeSerializer(SerializationConfig config,
                                              JavaType baseType,
                                              Collection<NamedType> subtypes)

Description copied from interface: `TypeResolverBuilder`
Method for building type serializer based on current configuration of this builder.

Specified by:
  `buildTypeSerializer` in interface `TypeResolverBuilder<StdTypeResolverBuilder>`
  `baseType` - Base type that constructed resolver will handle; super type of all types it will be used for.

#### buildTypeDeserializer

    public TypeDeserializer buildTypeDeserializer(DeserializationConfig config,
                                                  JavaType baseType,
                                                  Collection<NamedType> subtypes)

Description copied from interface: `TypeResolverBuilder`
Method for building type deserializer based on current configuration of this builder.

Specified by:
  `buildTypeDeserializer` in interface `TypeResolverBuilder<StdTypeResolverBuilder>`
  `baseType` - Base type that constructed resolver will handle; super type of all types it will be used for.
  `subtypes` - Known subtypes of the base type.

#### defineDefaultImpl

    protected JavaType defineDefaultImpl(DeserializationConfig config,
                                         JavaType baseType)

#### init

    public StdTypeResolverBuilder init(com.fasterxml.jackson.annotation.JsonTypeInfo.Id idType,
                                       TypeIdResolver idRes)

Description copied from interface: `TypeResolverBuilder`
Initialization method that is called right after constructing the builder instance.

Specified by:
  `init` in interface `TypeResolverBuilder<StdTypeResolverBuilder>`
Parameters:
  `idType` - Which type metadata is used
  `idRes` - (optional) Custom type id resolver used, if any
Returns:
  Resulting builder instance (usually this builder, but not necessarily)

#### init

    public StdTypeResolverBuilder init(com.fasterxml.jackson.annotation.JsonTypeInfo.Value settings,
                                       TypeIdResolver idRes)

Description copied from interface: `TypeResolverBuilder`
Initialization method that is called right after constructing the builder instance, in cases where information could not be passed directly (for example when instantiated for an annotation)

NOTE: This method is abstract in Jackson 3.0, at the moment of writing.

Specified by:
  `init` in interface `TypeResolverBuilder<StdTypeResolverBuilder>`
Parameters:
  `settings` - Configuration settings to apply.
Returns:
  Resulting builder instance (usually this builder, but not necessarily)

#### inclusion

    public StdTypeResolverBuilder inclusion(com.fasterxml.jackson.annotation.JsonTypeInfo.As includeAs)

Description copied from interface: `TypeResolverBuilder`
Method for specifying mechanism to use for including type metadata in JSON. If not explicitly called, setting defaults to `JsonTypeInfo.As.PROPERTY`.

Specified by:
  `inclusion` in interface `TypeResolverBuilder<StdTypeResolverBuilder>`
Parameters:
  `includeAs` - Mechanism used for including type metadata in JSON
Returns:
  Resulting builder instance (usually this builder, but may be a newly constructed instance for immutable builders}

#### typeProperty

    public StdTypeResolverBuilder typeProperty(String typeIdPropName)

Method for constructing an instance with specified type property name (property name to use for type id when using "as-property" inclusion).

Specified by:
  `typeProperty` in interface `TypeResolverBuilder<StdTypeResolverBuilder>`
Parameters:
  `typeIdPropName` - Name of JSON property to use for including type information
Returns:
  Resulting builder instance (usually this builder, but may be a newly constructed instance for immutable builders}

#### defaultImpl

    public StdTypeResolverBuilder defaultImpl(Class<?> defaultImpl)

Description copied from interface: `TypeResolverBuilder`
Method for specifying default implementation to use if type id is either not available, or cannot be resolved.

Specified by:
  `defaultImpl` in interface `TypeResolverBuilder<StdTypeResolverBuilder>`
Returns:
  Resulting builder instance (usually this builder, but may be a newly constructed instance for immutable builders}

#### typeIdVisibility

    public StdTypeResolverBuilder typeIdVisibility(boolean isVisible)

Description copied from interface: `TypeResolverBuilder`
Method for specifying whether type id should be visible to `JsonDeserializer`s or not.

Specified by:
  `typeIdVisibility` in interface `TypeResolverBuilder<StdTypeResolverBuilder>`
Returns:
  Resulting builder instance (usually this builder, but may be a newly constructed instance for immutable builders}

#### withDefaultImpl

    public StdTypeResolverBuilder withDefaultImpl(Class<?> defaultImpl)

Description copied from interface: `TypeResolverBuilder`
"Mutant factory" method for creating a new instance with different default implementation.

Specified by:
  `withDefaultImpl` in interface `TypeResolverBuilder<StdTypeResolverBuilder>`
Returns:
  Either this instance (if nothing changed) or a new instance with different default implementation

#### withSettings

    public StdTypeResolverBuilder withSettings(com.fasterxml.jackson.annotation.JsonTypeInfo.Value settings)

Description copied from interface: `TypeResolverBuilder`
Method for overriding type information.

Specified by:
  `withSettings` in interface `TypeResolverBuilder<StdTypeResolverBuilder>`

#### _propName

    protected String _propName(String propName,
                               com.fasterxml.jackson.annotation.JsonTypeInfo.Id idType)

Since:
  2.16; non-static since 2.17

#### getDefaultImpl

    public Class<?> getDefaultImpl()

Description copied from interface: `TypeResolverBuilder`
Accessor for currently configured default type; implementation class that may be used in case no valid type information is available during type resolution

Specified by:
  `getDefaultImpl` in interface `TypeResolverBuilder<StdTypeResolverBuilder>`

#### getTypeProperty

    public String getTypeProperty()

#### isTypeIdVisible

    public boolean isTypeIdVisible()

#### idResolver

    protected TypeIdResolver idResolver(MapperConfig<?> config,
                                        JavaType baseType,
                                        PolymorphicTypeValidator subtypeValidator,
                                        Collection<NamedType> subtypes,
                                        boolean forSer,
                                        boolean forDeser)

Helper method that will either return configured custom type id resolver, or construct a standard resolver given configuration.

#### subTypeValidator

    public PolymorphicTypeValidator subTypeValidator(MapperConfig<?> config)

Overridable helper method for determining actual validator to use when constructing type serializers and type deserializers.

Default implementation simply uses one configured and accessible using `MapperConfig.getPolymorphicTypeValidator()`.

Since:
  2.10

#### verifyBaseTypeValidity

    protected PolymorphicTypeValidator verifyBaseTypeValidity(MapperConfig<?> config,
                                                              JavaType baseType)

Helper method called to check that base type is valid regarding possible constraints on basetype/subtype combinations allowed for polymorphic type handling. Currently limits are verified for class name - based methods only.

Since:
  2.10

#### reportInvalidBaseType

    protected PolymorphicTypeValidator reportInvalidBaseType(MapperConfig<?> config,
                                                             JavaType baseType,
                                                             PolymorphicTypeValidator ptv)

Since:
  2.10

#### allowPrimitiveTypes

    protected boolean allowPrimitiveTypes(MapperConfig<?> config,
                                          JavaType baseType)

Overridable helper method that is called to determine whether type serializers and type deserializers may be created even if base type is Java `primitive` type. Default implementation simply returns `false` (since primitive types can not be sub-classed, are never polymorphic) but custom implementations may change the logic for some special cases.

Parameters:
  `config` - Currently active configuration
  `baseType` - Primitive base type for property being handled
Returns:
  True if type (de)serializer may be created even if base type is Java `primitive` type; false if not
Since:
  2.11.1

#### _strictTypeIdHandling

    protected boolean _strictTypeIdHandling(DeserializationConfig config,
                                            JavaType baseType)

Determines whether strict type ID handling should be used for this type or not. This will be enabld as configured by `JsonTypeInfo.requireTypeIdForSubtypes()` unless its value is `OptBoolean.DEFAULT`. In case the value of `JsonTypeInfo.requireTypeIdForSubtypes()` is `OptBoolean.DEFAULT`, this will be enabled when either the type has type resolver annotations or if `MapperFeature.REQUIRE_TYPE_ID_FOR_SUBTYPES` is enabled.

Parameters:
  `config` - the deserialization configuration to use
  `baseType` - the base type to check for type resolver annotations
Returns:
  `true` if the class has type resolver annotations, or the strict handling feature is enabled, `false` otherwise.
Since:
  2.15

#### _hasTypeResolver

    protected boolean _hasTypeResolver(DeserializationConfig config,
                                       JavaType baseType)

Checks whether the given class has annotations indicating some type resolver is applied, for example `JsonTypeInfo`. Only initializes `_hasTypeResolver(com.fasterxml.jackson.databind.DeserializationConfig, com.fasterxml.jackson.databind.JavaType)` once if its value is null.

Parameters:
  `config` - the deserialization configuration to use
  `baseType` - the base type to check for type resolver annotations
Returns:
  true if the class has type resolver annotations, false otherwise
Since:
  2.15, using `ai.findPolymorphicTypeInfo(config, ac)` since 2.16.