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 JsonTypeInfo.Id` `_idType`
`protected JsonTypeInfo.As` `_includeAs`
`protected boolean` `_typeIdVisible` Whether type id should be exposed to deserializers or not
`protected String` `_typeProperty`

### Constructor Summary

Constructors
`` `StdTypeResolverBuilder()`
`protected` `StdTypeResolverBuilder(JsonTypeInfo.Id idType, JsonTypeInfo.As idAs, String propName)`
`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 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(JsonTypeInfo.As includeAs)` Method for specifying mechanism to use for including type metadata in JSON.
`StdTypeResolverBuilder` `init(JsonTypeInfo.Id idType, TypeIdResolver idRes)` Initialization method that is called right after constructing the builder instance.
`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.

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

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

### Field Detail

#### _idType

    protected JsonTypeInfo.Id _idType

#### _includeAs

    protected JsonTypeInfo.As _includeAs

#### _typeProperty

    protected String _typeProperty

#### _typeIdVisible

    protected boolean _typeIdVisible

Whether type id should be exposed to deserializers or not

#### _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(JsonTypeInfo.Id idType,
                                     JsonTypeInfo.As idAs,
                                     String propName)

Since:
  2.9

#### StdTypeResolverBuilder

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

Copy-constructor

Since:
  2.13

### Method Detail

#### noTypeInfoBuilder

    public static StdTypeResolverBuilder noTypeInfoBuilder()

#### init

    public StdTypeResolverBuilder init(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)

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

#### inclusion

    public StdTypeResolverBuilder inclusion(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

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