com.fasterxml.jackson.databind.jsontype.impl

## Class StdSubtypeResolver

- java.lang.Object
- - com.fasterxml.jackson.databind.jsontype.SubtypeResolver
  - - com.fasterxml.jackson.databind.jsontype.impl.StdSubtypeResolver

All Implemented Interfaces:
  Serializable

    public class StdSubtypeResolver
    extends SubtypeResolver
    implements Serializable

Standard `SubtypeResolver` implementation.

See Also:
  Serialized Form

### Field Summary

Fields
`protected LinkedHashSet<NamedType>` `_registeredSubtypes`

### Constructor Summary

Constructors
`` `StdSubtypeResolver()`
`protected` `StdSubtypeResolver(StdSubtypeResolver src)`

### Method Summary

All Methods Instance Methods Concrete Methods
`protected void` `_collectAndResolve(AnnotatedClass annotatedType, NamedType namedType, MapperConfig<?> config, AnnotationIntrospector ai, HashMap<NamedType,NamedType> collectedSubtypes)` Method called to find subtypes for a specific type (class), using type (class) as the unique key (in case of conflicts).
`protected void` `_collectAndResolveByTypeId(AnnotatedClass annotatedType, NamedType namedType, MapperConfig<?> config, Set<Class<?>> typesHandled, Map<String,NamedType> byName)` Method called to find subtypes for a specific type (class), using type id as the unique key (in case of conflicts).
`protected Collection<NamedType>` `_combineNamedAndUnnamed(Class<?> rawBase, Set<Class<?>> typesHandled, Map<String,NamedType> byName)` Helper method used for merging explicitly named types and handled classes without explicit names.
`Collection<NamedType>` `collectAndResolveSubtypesByClass(MapperConfig<?> config, AnnotatedClass type)` Method for finding out all reachable subtypes for given type, such that access is by type, typically needed for serialization (converting from type to type name).
`Collection<NamedType>` `collectAndResolveSubtypesByClass(MapperConfig<?> config, AnnotatedMember property, JavaType baseType)` Method for finding out all reachable subtypes for a property specified by given element (method or field), such that access is by type, typically needed for serialization (converting from type to type name).
`Collection<NamedType>` `collectAndResolveSubtypesByTypeId(MapperConfig<?> config, AnnotatedClass baseType)` Method for finding out all reachable subtypes for given type, such that access is by type id, typically needed for deserialization (converting from type id to type).
`Collection<NamedType>` `collectAndResolveSubtypesByTypeId(MapperConfig<?> config, AnnotatedMember property, JavaType baseType)` Method for finding out all reachable subtypes for a property specified by given element (method or field), such that access is by type id, typically needed for deserialization (converting from type id to type).
`SubtypeResolver` `copy()` Method called by `ObjectMapper.copy()` to make sure that `SubtypeResolver` instances used by two independent mappers can not cause thread-safety issues: if resolver is immutable, it may return `this`, but if not, it should create a copy with same configuration and return that instead.
`void` `registerSubtypes(Class<?>... classes)`
`void` `registerSubtypes(Collection<Class<?>> subtypes)`
`void` `registerSubtypes(NamedType... types)` Method for registering specified subtypes (possibly including type names); for type entries without name, non-qualified class name as used as name (unless overridden by annotation).

### Methods inherited from class com.fasterxml.jackson.databind.jsontype.SubtypeResolver

`collectAndResolveSubtypes, collectAndResolveSubtypes`

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

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

### Field Detail

#### _registeredSubtypes

    protected LinkedHashSet<NamedType> _registeredSubtypes

### Constructor Detail

#### StdSubtypeResolver

    public StdSubtypeResolver()

#### StdSubtypeResolver

    protected StdSubtypeResolver(StdSubtypeResolver src)

### Method Detail

#### copy

    public SubtypeResolver copy()

Description copied from class: `SubtypeResolver`
Method called by `ObjectMapper.copy()` to make sure that `SubtypeResolver` instances used by two independent mappers can not cause thread-safety issues: if resolver is immutable, it may return `this`, but if not, it should create a copy with same configuration and return that instead.

Overrides:
  `copy` in class `SubtypeResolver`
Returns:
  Either new instance with same configuration as this one (if instances are mutable), or this instance (if immutable)

#### registerSubtypes

    public void registerSubtypes(NamedType... types)

Description copied from class: `SubtypeResolver`
Method for registering specified subtypes (possibly including type names); for type entries without name, non-qualified class name as used as name (unless overridden by annotation).

Specified by:
  `registerSubtypes` in class `SubtypeResolver`

#### registerSubtypes

    public void registerSubtypes(Class<?>... classes)

Specified by:
  `registerSubtypes` in class `SubtypeResolver`

#### registerSubtypes

    public void registerSubtypes(Collection<Class<?>> subtypes)

Specified by:
  `registerSubtypes` in class `SubtypeResolver`

#### collectAndResolveSubtypesByClass

    public Collection<NamedType> collectAndResolveSubtypesByClass(MapperConfig<?> config,
                                                                  AnnotatedMember property,
                                                                  JavaType baseType)

Description copied from class: `SubtypeResolver`
Method for finding out all reachable subtypes for a property specified by given element (method or field), such that access is by type, typically needed for serialization (converting from type to type name).

Overrides:
  `collectAndResolveSubtypesByClass` in class `SubtypeResolver`
  `baseType` - Effective property base type to use; may differ from actual type of property; for structured types it is content (value) type and NOT structured type.

#### collectAndResolveSubtypesByClass

    public Collection<NamedType> collectAndResolveSubtypesByClass(MapperConfig<?> config,
                                                                  AnnotatedClass type)

Description copied from class: `SubtypeResolver`
Method for finding out all reachable subtypes for given type, such that access is by type, typically needed for serialization (converting from type to type name).

Overrides:
  `collectAndResolveSubtypesByClass` in class `SubtypeResolver`
  `type` - Effective property base type to use; may differ from actual type of property; for structured types it is content (value) type and NOT structured type.

#### collectAndResolveSubtypesByTypeId

    public Collection<NamedType> collectAndResolveSubtypesByTypeId(MapperConfig<?> config,
                                                                   AnnotatedMember property,
                                                                   JavaType baseType)

Description copied from class: `SubtypeResolver`
Method for finding out all reachable subtypes for a property specified by given element (method or field), such that access is by type id, typically needed for deserialization (converting from type id to type).

Overrides:
  `collectAndResolveSubtypesByTypeId` in class `SubtypeResolver`
  `baseType` - Effective property base type to use; may differ from actual type of property; for structured types it is content (value) type and NOT structured type.

#### collectAndResolveSubtypesByTypeId

    public Collection<NamedType> collectAndResolveSubtypesByTypeId(MapperConfig<?> config,
                                                                   AnnotatedClass baseType)

Description copied from class: `SubtypeResolver`
Method for finding out all reachable subtypes for given type, such that access is by type id, typically needed for deserialization (converting from type id to type).

Overrides:
  `collectAndResolveSubtypesByTypeId` in class `SubtypeResolver`
  `baseType` - Effective property base type to use; may differ from actual type of property; for structured types it is content (value) type and NOT structured type.

#### _collectAndResolve

    protected void _collectAndResolve(AnnotatedClass annotatedType,
                                      NamedType namedType,
                                      MapperConfig<?> config,
                                      AnnotationIntrospector ai,
                                      HashMap<NamedType,NamedType> collectedSubtypes)

Method called to find subtypes for a specific type (class), using type (class) as the unique key (in case of conflicts).

#### _collectAndResolveByTypeId

    protected void _collectAndResolveByTypeId(AnnotatedClass annotatedType,
                                              NamedType namedType,
                                              MapperConfig<?> config,
                                              Set<Class<?>> typesHandled,
                                              Map<String,NamedType> byName)

Method called to find subtypes for a specific type (class), using type id as the unique key (in case of conflicts).

#### _combineNamedAndUnnamed

    protected Collection<NamedType> _combineNamedAndUnnamed(Class<?> rawBase,
                                                            Set<Class<?>> typesHandled,
                                                            Map<String,NamedType> byName)

Helper method used for merging explicitly named types and handled classes without explicit names.