Uses of Class
tools.jackson.databind.cfg.MapperConfig

Packages that use MapperConfig

Package	Description
tools.jackson.databind	Basic data binding (mapping) functionality that allows for reading JSON content into Java Objects (POJOs) and JSON Trees (JsonNode), as well as writing Java Objects and trees as JSON.
tools.jackson.databind.cfg	Package that contains most of configuration-related classes; exception being couple of most-commonly used configuration things (like Feature enumerations) that are at the main level (tools.jackson.databind).
tools.jackson.databind.deser	Contains implementation classes of deserialization part of data binding.
tools.jackson.databind.deser.bean
tools.jackson.databind.introspect	Functionality needed for Bean introspection, required for detecting accessors and mutators for Beans, as well as locating and handling method annotations.
tools.jackson.databind.jsontype	Package that contains interfaces that define how to implement functionality for dynamically resolving type during deserialization.
tools.jackson.databind.jsontype.impl	Package that contains standard implementations for TypeResolverBuilder and TypeIdResolver.
tools.jackson.databind.ser	Contains implementation classes of serialization part of data binding.
tools.jackson.databind.ser.impl	Contains implementation classes of serialization part of data binding.
tools.jackson.databind.util	Utility classes for Mapper package.

Uses of MapperConfig in tools.jackson.databind

Subclasses of MapperConfig in tools.jackson.databind

Modifier and Type	Class	Description
final class	DeserializationConfig	Object that contains baseline configuration for deserialization process.
final class	SerializationConfig	Object that contains baseline configuration for serialization process.

Fields in tools.jackson.databind declared as MapperConfig

Modifier and Type	Field	Description
protected final MapperConfig<?>	BeanDescription.SupplierBase._config

Methods in tools.jackson.databind that return MapperConfig

Modifier and Type	Method	Description
abstract MapperConfig<?>	DatabindContext.getConfig()	Accessor to currently active configuration (both per-request configs and per-mapper config).

Methods in tools.jackson.databind with parameters of type MapperConfig

Modifier and Type	Method	Description
String	EnumNamingStrategies.DelegatingEnumNamingStrategy.convertEnumToExternalName(MapperConfig<?> config, AnnotatedClass cls, String enumName)
String	EnumNamingStrategy.convertEnumToExternalName(MapperConfig<?> config, AnnotatedClass cls, String enumName)	Translates the given enumName into an external property name according to the implementation of this EnumNamingStrategy.
List<PropertyName>	BeanProperty.Bogus.findAliases(MapperConfig<?> config)
List<PropertyName>	BeanProperty.findAliases(MapperConfig<?> config)	Method for accessing set of possible alternate names that are accepted during deserialization.
List<PropertyName>	BeanProperty.Std.findAliases(MapperConfig<?> config)
void	AnnotationIntrospector.findAndAddVirtualProperties(MapperConfig<?> config, AnnotatedClass ac, List<BeanPropertyWriter> properties)	Method for adding possible virtual properties to be serialized along with regular properties.
VisibilityChecker	AnnotationIntrospector.findAutoDetectVisibility(MapperConfig<?> config, AnnotatedClass ac, VisibilityChecker checker)	Method for checking if annotations indicate changes to minimum visibility levels needed for auto-detecting property elements (fields, methods, constructors).
String	AnnotationIntrospector.findClassDescription(MapperConfig<?> config, AnnotatedClass ac)	Method used to check whether specified class defines a human-readable description to use for documentation.
Object	AnnotationIntrospector.findContentDeserializer(MapperConfig<?> config, Annotated am)	Method for getting a deserializer definition for content (values) of associated Collection, array or Map property.
Object	AnnotationIntrospector.findContentSerializer(MapperConfig<?> config, Annotated am)	Method for getting a serializer definition for content (values) of associated Collection, array or Map property.
JsonCreator.Mode	AnnotationIntrospector.findCreatorAnnotation(MapperConfig<?> config, Annotated a)	Method called to check whether potential Creator (constructor or static factory method) has explicit annotation to indicate it as actual Creator; and if so, which JsonCreator.Mode to use.
Enum<?>	AnnotationIntrospector.findDefaultEnumValue(MapperConfig<?> config, AnnotatedClass ac, Enum<?>[] enumValues)	Finds the first Enum value that should be considered as default value for unknown Enum values, if present.
Object	AnnotationIntrospector.findDeserializationContentConverter(MapperConfig<?> config, AnnotatedMember a)	Method for finding Converter that annotated property has indicated needs to be used for values of container type (this also means that method should only be called for properties of container types, List/Map/array properties).
Object	AnnotationIntrospector.findDeserializationConverter(MapperConfig<?> config, Annotated a)	Method for finding Converter that annotated entity (property or class) has indicated to be used as part of deserialization.
Object	AnnotationIntrospector.findDeserializer(MapperConfig<?> config, Annotated am)	Method for getting a deserializer definition on specified method or field.
void	AnnotationIntrospector.findEnumAliases(MapperConfig<?> config, AnnotatedClass annotatedClass, Enum<?>[] enumValues, String[][] aliases)	Method that is called to check if there are alternative names (aliases) that can be accepted for entries in addition to primary names that were introspected earlier, related to AnnotationIntrospector.findEnumValues(tools.jackson.databind.cfg.MapperConfig<?>, tools.jackson.databind.introspect.AnnotatedClass, java.lang.Enum<?>[], java.lang.String[]).
Object	AnnotationIntrospector.findEnumNamingStrategy(MapperConfig<?> config, AnnotatedClass ac)	Method for finding EnumNamingStrategy for given class, if any specified by annotations; and if so, either return a EnumNamingStrategy instance, or Class to use for creating instance
String[]	AnnotationIntrospector.findEnumValues(MapperConfig<?> config, AnnotatedClass annotatedClass, Enum<?>[] enumValues, String[] names)	Finds the explicitly defined name of the given set of Enum values, if any.
Object	AnnotationIntrospector.findFilterId(MapperConfig<?> config, Annotated ann)	Method for finding if annotated class has associated filter; and if so, to return id that is used to locate filter.
JsonFormat.Value	AnnotationIntrospector.findFormat(MapperConfig<?> config, Annotated memberOrClass)	Method for finding format annotations for property or class.
JsonFormat.Value	BeanProperty.Bogus.findFormatOverrides(MapperConfig<?> config)
JsonFormat.Value	BeanProperty.findFormatOverrides(MapperConfig<?> config)	Helper method used to only access property-specified format overrides, if any, not considering type or global default format settings.
JsonFormat.Value	BeanProperty.Std.findFormatOverrides(MapperConfig<?> config)
String	AnnotationIntrospector.findImplicitPropertyName(MapperConfig<?> config, AnnotatedMember member)	Method for finding implicit name for a property that given annotated member (field, method, creator parameter) may represent.
JacksonInject.Value	AnnotationIntrospector.findInjectableValue(MapperConfig<?> config, AnnotatedMember member)	Method called to find out whether given member expectes a value to be injected, and if so, what is the identifier of the value to use during injection.
Object	AnnotationIntrospector.findKeyDeserializer(MapperConfig<?> config, Annotated am)	Method for getting a deserializer definition for keys of associated Map property.
Object	AnnotationIntrospector.findKeySerializer(MapperConfig<?> config, Annotated am)	Method for getting a serializer definition for keys of associated java.util.Map property.
Boolean	AnnotationIntrospector.findMergeInfo(MapperConfig<?> config, Annotated a)	Method for finding merge settings for property, if any.
PropertyName	AnnotationIntrospector.findNameForDeserialization(MapperConfig<?> config, Annotated ann)	Method for checking whether given property accessors (method, field) has an annotation that suggests property name to use for deserialization (reading JSON into POJOs).
PropertyName	AnnotationIntrospector.findNameForSerialization(MapperConfig<?> config, Annotated a)	Method for checking whether given property accessors (method, field) has an annotation that suggests property name to use for serialization.
String	AnnotationIntrospector.XmlExtensions.findNamespace(MapperConfig<?> config, Annotated ann)	Method that can be called to figure out generic namespace property for an annotated object.
Object	AnnotationIntrospector.findNamingStrategy(MapperConfig<?> config, AnnotatedClass ac)	Method for finding PropertyNamingStrategy for given class, if any specified by annotations; and if so, either return a PropertyNamingStrategy instance, or Class to use for creating instance
Object	AnnotationIntrospector.findNullSerializer(MapperConfig<?> config, Annotated am)	Method for getting a serializer definition for serializer to use for nulls (null values) of associated property or type.
ObjectIdInfo	AnnotationIntrospector.findObjectIdInfo(MapperConfig<?> config, Annotated ann)	Method for checking whether given annotated thing (type, or accessor) indicates that values referenced (values of type of annotated class, or values referenced by annotated property; latter having precedence) should include Object Identifier, and if so, specify details of Object Identity used.
ObjectIdInfo	AnnotationIntrospector.findObjectReferenceInfo(MapperConfig<?> config, Annotated ann, ObjectIdInfo objectIdInfo)	Method for figuring out additional properties of an Object Identity reference
Class<?>	AnnotationIntrospector.findPOJOBuilder(MapperConfig<?> config, AnnotatedClass ac)	Method for finding Builder object to use for constructing value instance and binding data (sort of combining value instantiators that can construct, and deserializers that can bind data).
JsonPOJOBuilder.Value	AnnotationIntrospector.findPOJOBuilderConfig(MapperConfig<?> config, AnnotatedClass ac)
JsonTypeInfo.Value	AnnotationIntrospector.findPolymorphicTypeInfo(MapperConfig<?> config, Annotated ann)	Method for checking whether given Class or Property Accessor specifies polymorphic type-handling information, to indicate need for polymorphic handling.
PotentialCreator	AnnotationIntrospector.findPreferredCreator(MapperConfig<?> config, AnnotatedClass valueClass, List<PotentialCreator> declaredConstructors, List<PotentialCreator> declaredFactories, Optional<PotentialCreator> zeroParamsConstructor)	Method called to check if introspector can find a Creator it considers its "Preferred Creator": Creator to use as the primary one, when no Creator has explicit annotation (AnnotationIntrospector.findCreatorAnnotation(tools.jackson.databind.cfg.MapperConfig<?>, tools.jackson.databind.introspect.Annotated) returns null).
JsonProperty.Access	AnnotationIntrospector.findPropertyAccess(MapperConfig<?> config, Annotated ann)	Method for finding optional access definition for a property, annotated on one of its accessors.
List<PropertyName>	AnnotationIntrospector.findPropertyAliases(MapperConfig<?> config, Annotated ann)	Method called to find if given property has alias(es) defined.
String	AnnotationIntrospector.findPropertyDefaultValue(MapperConfig<?> config, Annotated ann)	Method for finding suggested default value (as simple textual serialization) for the property.
String	AnnotationIntrospector.findPropertyDescription(MapperConfig<?> config, Annotated ann)	Method used to check whether specified property member (accessor or mutator) defines human-readable description to use for documentation.
JsonFormat.Value	BeanProperty.Bogus.findPropertyFormat(MapperConfig<?> config, Class<?> baseType)
JsonFormat.Value	BeanProperty.findPropertyFormat(MapperConfig<?> config, Class<?> baseType)	Helper method used to look up format settings applicable to this property, considering both possible per-type configuration settings
JsonFormat.Value	BeanProperty.Std.findPropertyFormat(MapperConfig<?> config, Class<?> baseType)
JsonIgnoreProperties.Value	AnnotationIntrospector.findPropertyIgnoralByName(MapperConfig<?> config, Annotated ann)	Method for finding information about properties to ignore either by name, or by more general specification ("ignore all unknown").
JsonInclude.Value	AnnotationIntrospector.findPropertyInclusion(MapperConfig<?> config, Annotated a)	Method for checking inclusion criteria for a type (Class) or property (yes, method name is bit unfortunate -- not just for properties!).
JsonInclude.Value	BeanProperty.Bogus.findPropertyInclusion(MapperConfig<?> config, Class<?> baseType)
JsonInclude.Value	BeanProperty.findPropertyInclusion(MapperConfig<?> config, Class<?> baseType)	Convenience method that is roughly equivalent to
JsonInclude.Value	BeanProperty.Std.findPropertyInclusion(MapperConfig<?> config, Class<?> baseType)
JsonIncludeProperties.Value	AnnotationIntrospector.findPropertyInclusionByName(MapperConfig<?> config, Annotated ann)	Method for finding information about names of properties to included.
Integer	AnnotationIntrospector.findPropertyIndex(MapperConfig<?> config, Annotated ann)	Method used to check whether specified property member (accessor or mutator) defines numeric index, and if so, what is the index value.
AnnotationIntrospector.ReferenceProperty	AnnotationIntrospector.findReferenceType(MapperConfig<?> config, AnnotatedMember member)	Method for checking if given member indicates that it is part of a reference (parent/child).
PropertyName	AnnotationIntrospector.findRenameByField(MapperConfig<?> config, AnnotatedField f, PropertyName implName)	Method called on fields that are eligible candidates for properties (that is, non-static member fields), but not necessarily selected (may or may not be visible), to let fields affect name linking.
PropertyName	AnnotationIntrospector.findRootName(MapperConfig<?> config, AnnotatedClass ac)	Method for locating name used as "root name" (for use by some serializers when outputting root-level object -- mostly for XML compatibility purposes) for given class, if one is defined.
Object	AnnotationIntrospector.findSerializationContentConverter(MapperConfig<?> config, AnnotatedMember a)	Method for finding Converter that annotated property has indicated needs to be used for values of container type (this also means that method should only be called for properties of container types, List/Map/array properties).
Object	AnnotationIntrospector.findSerializationConverter(MapperConfig<?> config, Annotated a)	Method for finding Converter that annotated entity (property or class) has indicated to be used as part of serialization.
String[]	AnnotationIntrospector.findSerializationPropertyOrder(MapperConfig<?> config, AnnotatedClass ac)	Method for accessing defined property serialization order (which may be partial).
Boolean	AnnotationIntrospector.findSerializationSortAlphabetically(MapperConfig<?> config, Annotated ann)	Method for checking whether an annotation indicates that serialized properties for which no explicit is defined should be alphabetically (lexicograpically) ordered
JsonSerialize.Typing	AnnotationIntrospector.findSerializationTyping(MapperConfig<?> config, Annotated a)	Method for accessing declared typing mode annotated (if any).
Object	AnnotationIntrospector.findSerializer(MapperConfig<?> config, Annotated am)	Method for getting a serializer definition on specified method or field.
JsonSetter.Value	AnnotationIntrospector.findSetterInfo(MapperConfig<?> config, Annotated a)	Method for finding possible settings for property, given annotations on an accessor.
List<NamedType>	AnnotationIntrospector.findSubtypes(MapperConfig<?> config, Annotated a)	Method for locating annotation-specified subtypes related to annotated entity (class, method, field).
Object	AnnotationIntrospector.findTypeIdResolver(MapperConfig<?> config, Annotated ann)
String	AnnotationIntrospector.findTypeName(MapperConfig<?> config, AnnotatedClass ac)	Method for checking if specified type has explicit name.
Object	AnnotationIntrospector.findTypeResolverBuilder(MapperConfig<?> config, Annotated ann)
NameTransformer	AnnotationIntrospector.findUnwrappingNameTransformer(MapperConfig<?> config, AnnotatedMember member)	Method called to check whether given property is marked to be "unwrapped" when being serialized (and appropriately handled in reverse direction, i.e. expect unwrapped representation during deserialization).
Object	AnnotationIntrospector.findValueInstantiator(MapperConfig<?> config, AnnotatedClass ac)	Method getting ValueInstantiator to use for given type (class): return value can either be an instance of instantiator, or class of instantiator to create.
Class<?>[]	AnnotationIntrospector.findViews(MapperConfig<?> config, Annotated a)	Method for checking if annotated property (represented by a field or getter/setter method) has definitions for views it is to be included in.
PropertyName	AnnotationIntrospector.findWrapperName(MapperConfig<?> config, Annotated ann)	Method used to check if specified property has annotation that indicates that it should be wrapped in an element; and if so, name to use.
Boolean	AnnotationIntrospector.hasAnyGetter(MapperConfig<?> config, Annotated ann)	Method for checking whether given method has an annotation that suggests that the method is to serve as "any setter"; method to be used for accessing set of miscellaneous "extra" properties, often bound with matching "any setter" method.
Boolean	AnnotationIntrospector.hasAnySetter(MapperConfig<?> config, Annotated ann)	Method for checking whether given method has an annotation that suggests that the method is to serve as "any setter"; method to be used for setting values of any properties for which no dedicated setter method is found.
Boolean	AnnotationIntrospector.hasAsKey(MapperConfig<?> config, Annotated a)	Method for checking whether given method has an annotation that suggests the return value of annotated field or method should be used as "the key" of the object instance; usually serialized as a primitive value such as String or number.
Boolean	AnnotationIntrospector.hasAsValue(MapperConfig<?> config, Annotated a)	Method for checking whether given method has an annotation that suggests that the return value of annotated method should be used as "the value" of the object instance; usually serialized as a primitive value such as String or number.
boolean	AnnotationIntrospector.hasIgnoreMarker(MapperConfig<?> config, AnnotatedMember member)	Method called to check whether given property is marked to be ignored.
Boolean	AnnotationIntrospector.hasRequiredMarker(MapperConfig<?> config, AnnotatedMember member)	Method that can be called to check whether this member has an annotation that suggests whether value for matching property is required or not.
Boolean	AnnotationIntrospector.isIgnorableType(MapperConfig<?> config, AnnotatedClass ac)	Method for checking whether properties that have specified type (class, not generics aware) should be completely ignored for serialization and deserialization purposes.
Boolean	AnnotationIntrospector.XmlExtensions.isOutputAsAttribute(MapperConfig<?> config, Annotated ann)	Method used to check whether given annotated element (field, method, constructor parameter) has indicator that suggests it be output as an XML attribute or not (if not, then as element)
Boolean	AnnotationIntrospector.XmlExtensions.isOutputAsCData(MapperConfig<?> config, Annotated ann)	Method used to check whether given annotated element (field, method, constructor parameter) has indicator that suggests it should be wrapped in a CDATA tag.
Boolean	AnnotationIntrospector.XmlExtensions.isOutputAsText(MapperConfig<?> config, Annotated ann)	Method used to check whether given annotated element (field, method, constructor parameter) has indicator that suggests it should be serialized as text, without element wrapper.
Boolean	AnnotationIntrospector.isTypeId(MapperConfig<?> config, AnnotatedMember member)	Method for checking whether given accessor claims to represent type id: if so, its value may be used as an override, instead of generated type id.
String	PropertyNamingStrategies.NamingBase.nameForConstructorParameter(MapperConfig<?> config, AnnotatedParameter ctorParam, String defaultName)
String	PropertyNamingStrategy.nameForConstructorParameter(MapperConfig<?> config, AnnotatedParameter ctorParam, String defaultName)	Method called to find external name (name used in JSON) for given logical POJO property, as defined by given constructor parameter; typically called when building a deserializer (but not necessarily only then).
String	PropertyNamingStrategies.NamingBase.nameForField(MapperConfig<?> config, AnnotatedField field, String defaultName)
String	PropertyNamingStrategy.nameForField(MapperConfig<?> config, AnnotatedField field, String defaultName)	Method called to find external name (name used in JSON) for given logical POJO property, as defined by given field.
String	PropertyNamingStrategies.NamingBase.nameForGetterMethod(MapperConfig<?> config, AnnotatedMethod method, String defaultName)
String	PropertyNamingStrategy.nameForGetterMethod(MapperConfig<?> config, AnnotatedMethod method, String defaultName)	Method called to find external name (name used in JSON) for given logical POJO property, as defined by given getter method; typically called when building a serializer.
String	PropertyNamingStrategies.NamingBase.nameForSetterMethod(MapperConfig<?> config, AnnotatedMethod method, String defaultName)
String	PropertyNamingStrategy.nameForSetterMethod(MapperConfig<?> config, AnnotatedMethod method, String defaultName)	Method called to find external name (name used in JSON) for given logical POJO property, as defined by given setter method; typically called when building a deserializer (but not necessarily only then).
JavaType	AnnotationIntrospector.refineDeserializationType(MapperConfig<?> config, Annotated a, JavaType baseType)	Method called to find out possible type refinements to use for deserialization.
JavaType	AnnotationIntrospector.refineSerializationType(MapperConfig<?> config, Annotated a, JavaType baseType)	Method called to find out possible type refinements to use for deserialization, including not just value itself but key and/or content type, if type has those.
AnnotatedMethod	AnnotationIntrospector.resolveSetterConflict(MapperConfig<?> config, AnnotatedMethod setter1, AnnotatedMethod setter2)	Method called in cases where a class has two methods eligible to be used for the same logical property, and default logic is not enough to figure out clear precedence.
SerializableString	PropertyName.simpleAsEncoded(MapperConfig<?> config)	Accessor that may be used to get lazily-constructed efficient representation of the simple name.

Constructors in tools.jackson.databind with parameters of type MapperConfig

Modifier	Constructor	Description
	EagerSupplier(MapperConfig<?> config, BeanDescription beanDesc)
protected	LazySupplier(MapperConfig<?> config, JavaType type)
protected	SupplierBase(MapperConfig<?> config, JavaType type)

Uses of MapperConfig in tools.jackson.databind.cfg

Classes in tools.jackson.databind.cfg with type parameters of type MapperConfig

Modifier and Type	Class	Description
class	MapperConfig<T extends MapperConfig<T>>	Interface that defines functionality accessible through both serialization and deserialization configuration objects; accessors to mode-independent configuration settings and such.

Subclasses of MapperConfig in tools.jackson.databind.cfg

Modifier and Type	Class	Description
class	MapperConfigBase<CFG extends ConfigFeature,T extends MapperConfigBase<CFG,T>>

Methods in tools.jackson.databind.cfg with parameters of type MapperConfig

Modifier and Type	Method	Description
Converter<?,?>	HandlerInstantiator.converterInstance(MapperConfig<?> config, Annotated annotated, Class<?> implClass)	Method called to construct a Converter instance used for specified class.
PropertyNamingStrategy	HandlerInstantiator.namingStrategyInstance(MapperConfig<?> config, Annotated annotated, Class<?> implClass)	Method called to construct a NamingStrategy instance used for specified class.
ObjectIdGenerator<?>	HandlerInstantiator.objectIdGeneratorInstance(MapperConfig<?> config, Annotated annotated, Class<?> implClass)	Method called to construct a ObjectIdHandler instance of specified type.
ObjectIdResolver	HandlerInstantiator.resolverIdGeneratorInstance(MapperConfig<?> config, Annotated annotated, Class<?> implClass)
abstract TypeIdResolver	HandlerInstantiator.typeIdResolverInstance(MapperConfig<?> config, Annotated annotated, Class<?> resolverClass)	Method called to get an instance of TypeIdResolver of specified type.
abstract TypeResolverBuilder<?>	HandlerInstantiator.typeResolverBuilderInstance(MapperConfig<?> config, Annotated annotated, Class<?> builderClass)	Method called to get an instance of TypeResolverBuilder of specified type.
ValueInstantiator	HandlerInstantiator.valueInstantiatorInstance(MapperConfig<?> config, Annotated annotated, Class<?> resolverClass)	Method called to construct an instance of ValueInstantiator of specified type.
VirtualBeanPropertyWriter	HandlerInstantiator.virtualPropertyWriterInstance(MapperConfig<?> config, Class<?> implClass)	Method called to construct a VirtualBeanPropertyWriter instance of specified type.

Constructors in tools.jackson.databind.cfg with parameters of type MapperConfig

Modifier	Constructor	Description
protected	MapperConfig(MapperConfig<T> src)
protected	MapperConfig(MapperConfig<T> src, BaseSettings base)

Uses of MapperConfig in tools.jackson.databind.deser

Methods in tools.jackson.databind.deser with parameters of type MapperConfig

Modifier and Type	Method	Description
protected boolean	BasicDeserializerFactory._hasCreatorAnnotation(MapperConfig<?> config, Annotated ann)

Uses of MapperConfig in tools.jackson.databind.deser.bean

Fields in tools.jackson.databind.deser.bean declared as MapperConfig

Modifier and Type	Field	Description
protected final MapperConfig<?>	CreatorCandidate._config

Methods in tools.jackson.databind.deser.bean with parameters of type MapperConfig

Modifier and Type	Method	Description
static BeanPropertyMap	BeanPropertyMap.construct(MapperConfig<?> config, Collection<SettableBeanProperty> props, PropertyName[][] aliases, boolean caseInsensitive)
static CreatorCandidate	CreatorCandidate.construct(MapperConfig<?> config, AnnotatedWithParams creator, BeanPropertyDefinition[] propDefs)

Constructors in tools.jackson.databind.deser.bean with parameters of type MapperConfig

Modifier	Constructor	Description
protected	CreatorCandidate(MapperConfig<?> config, AnnotatedWithParams ct, CreatorCandidate.Param[] params, int count)
	CreatorCollector(MapperConfig<?> config, JavaType beanType)

Uses of MapperConfig in tools.jackson.databind.introspect

Fields in tools.jackson.databind.introspect declared as MapperConfig

Modifier and Type	Field	Description
protected final MapperConfig<?>	AnnotatedClass._config
protected final MapperConfig<?>	BasicBeanDescription._config
protected final MapperConfig<?>	BasicClassIntrospector._config
protected final MapperConfig<?>	CollectorBase._config
protected final MapperConfig<?>	CollectorBase._config
protected final MapperConfig<?>	DefaultAccessorNamingStrategy._config
protected final MapperConfig<?>	POJOPropertiesCollector._config	Configuration settings
protected final MapperConfig<?>	POJOPropertyBuilder._config

Methods in tools.jackson.databind.introspect that return MapperConfig

Modifier and Type	Method	Description
MapperConfig<?>	POJOPropertiesCollector.getConfig()

Methods in tools.jackson.databind.introspect with parameters of type MapperConfig

Modifier and Type	Method	Description
protected BeanPropertyWriter	JacksonAnnotationIntrospector._constructVirtualProperty(JsonAppend.Attr attr, MapperConfig<?> config, AnnotatedClass ac, JavaType type)
protected BeanPropertyWriter	JacksonAnnotationIntrospector._constructVirtualProperty(JsonAppend.Prop prop, MapperConfig<?> config, AnnotatedClass ac)
static List<AnnotatedField>	AnnotatedFieldCollector.collectFields(MapperConfig<?> config, TypeResolutionContext tc, MixInResolver mixins, JavaType type, Class<?> primaryMixIn, boolean collectAnnotations)
static AnnotatedMethodMap	AnnotatedMethodCollector.collectMethods(MapperConfig<?> config, TypeResolutionContext tc, MixInResolver mixins, JavaType type, List<JavaType> superTypes, Class<?> primaryMixIn, boolean collectAnnotations)
List<PropertyName>	ConcreteBeanPropertyBase.findAliases(MapperConfig<?> config)
void	AnnotationIntrospectorPair.findAndAddVirtualProperties(MapperConfig<?> config, AnnotatedClass ac, List<BeanPropertyWriter> properties)
void	JacksonAnnotationIntrospector.findAndAddVirtualProperties(MapperConfig<?> config, AnnotatedClass ac, List<BeanPropertyWriter> properties)
VisibilityChecker	AnnotationIntrospectorPair.findAutoDetectVisibility(MapperConfig<?> config, AnnotatedClass ac, VisibilityChecker checker)
VisibilityChecker	JacksonAnnotationIntrospector.findAutoDetectVisibility(MapperConfig<?> config, AnnotatedClass ac, VisibilityChecker checker)
String	AnnotationIntrospectorPair.findClassDescription(MapperConfig<?> config, AnnotatedClass ac)
String	JacksonAnnotationIntrospector.findClassDescription(MapperConfig<?> config, AnnotatedClass ac)
Object	AnnotationIntrospectorPair.findContentDeserializer(MapperConfig<?> config, Annotated am)
Object	JacksonAnnotationIntrospector.findContentDeserializer(MapperConfig<?> config, Annotated a)
Object	AnnotationIntrospectorPair.findContentSerializer(MapperConfig<?> config, Annotated a)
Object	JacksonAnnotationIntrospector.findContentSerializer(MapperConfig<?> config, Annotated a)
JsonCreator.Mode	AnnotationIntrospectorPair.findCreatorAnnotation(MapperConfig<?> config, Annotated a)
JsonCreator.Mode	JacksonAnnotationIntrospector.findCreatorAnnotation(MapperConfig<?> config, Annotated a)
Enum<?>	AnnotationIntrospectorPair.findDefaultEnumValue(MapperConfig<?> config, AnnotatedClass annotatedClass, Enum<?>[] enumValues)
Enum<?>	JacksonAnnotationIntrospector.findDefaultEnumValue(MapperConfig<?> config, AnnotatedClass annotatedClass, Enum<?>[] enumValues)	Finds the Enum value that should be considered the default value, if possible.
Object	AnnotationIntrospectorPair.findDeserializationContentConverter(MapperConfig<?> config, AnnotatedMember a)
Object	JacksonAnnotationIntrospector.findDeserializationContentConverter(MapperConfig<?> config, AnnotatedMember a)
Object	AnnotationIntrospectorPair.findDeserializationConverter(MapperConfig<?> config, Annotated a)
Object	JacksonAnnotationIntrospector.findDeserializationConverter(MapperConfig<?> config, Annotated a)
Object	AnnotationIntrospectorPair.findDeserializer(MapperConfig<?> config, Annotated a)
Object	JacksonAnnotationIntrospector.findDeserializer(MapperConfig<?> config, Annotated a)
void	AnnotationIntrospectorPair.findEnumAliases(MapperConfig<?> config, AnnotatedClass annotatedClass, Enum<?>[] enumConstants, String[][] aliases)
void	JacksonAnnotationIntrospector.findEnumAliases(MapperConfig<?> config, AnnotatedClass annotatedClass, Enum<?>[] enumValues, String[][] aliasList)
Object	AnnotationIntrospectorPair.findEnumNamingStrategy(MapperConfig<?> config, AnnotatedClass ac)
Object	JacksonAnnotationIntrospector.findEnumNamingStrategy(MapperConfig<?> config, AnnotatedClass ac)
String[]	AnnotationIntrospectorPair.findEnumValues(MapperConfig<?> config, AnnotatedClass annotatedClass, Enum<?>[] enumValues, String[] names)
String[]	JacksonAnnotationIntrospector.findEnumValues(MapperConfig<?> config, AnnotatedClass annotatedClass, Enum<?>[] enumValues, String[] names)
Object	AnnotationIntrospectorPair.findFilterId(MapperConfig<?> config, Annotated ann)
Object	JacksonAnnotationIntrospector.findFilterId(MapperConfig<?> config, Annotated a)
JsonFormat.Value	AnnotationIntrospectorPair.findFormat(MapperConfig<?> config, Annotated ann)
JsonFormat.Value	JacksonAnnotationIntrospector.findFormat(MapperConfig<?> config, Annotated ann)
JsonFormat.Value	ConcreteBeanPropertyBase.findFormatOverrides(MapperConfig<?> config)
String	AnnotationIntrospectorPair.findImplicitPropertyName(MapperConfig<?> config, AnnotatedMember ann)
String	JacksonAnnotationIntrospector.findImplicitPropertyName(MapperConfig<?> config, AnnotatedMember m)
JacksonInject.Value	AnnotationIntrospectorPair.findInjectableValue(MapperConfig<?> config, AnnotatedMember m)
JacksonInject.Value	JacksonAnnotationIntrospector.findInjectableValue(MapperConfig<?> config, AnnotatedMember m)
Object	AnnotationIntrospectorPair.findKeyDeserializer(MapperConfig<?> config, Annotated a)
Object	JacksonAnnotationIntrospector.findKeyDeserializer(MapperConfig<?> config, Annotated a)
Object	AnnotationIntrospectorPair.findKeySerializer(MapperConfig<?> config, Annotated a)
Object	JacksonAnnotationIntrospector.findKeySerializer(MapperConfig<?> config, Annotated a)
Boolean	AnnotationIntrospectorPair.findMergeInfo(MapperConfig<?> config, Annotated a)
Boolean	JacksonAnnotationIntrospector.findMergeInfo(MapperConfig<?> config, Annotated a)
PropertyName	AnnotationIntrospectorPair.findNameForDeserialization(MapperConfig<?> config, Annotated a)
PropertyName	JacksonAnnotationIntrospector.findNameForDeserialization(MapperConfig<?> config, Annotated a)
PropertyName	AnnotationIntrospectorPair.findNameForSerialization(MapperConfig<?> config, Annotated a)
PropertyName	JacksonAnnotationIntrospector.findNameForSerialization(MapperConfig<?> config, Annotated a)
Object	AnnotationIntrospectorPair.findNamingStrategy(MapperConfig<?> config, AnnotatedClass ac)
Object	JacksonAnnotationIntrospector.findNamingStrategy(MapperConfig<?> config, AnnotatedClass ac)
Object	AnnotationIntrospectorPair.findNullSerializer(MapperConfig<?> config, Annotated a)
Object	JacksonAnnotationIntrospector.findNullSerializer(MapperConfig<?> config, Annotated a)
ObjectIdInfo	AnnotationIntrospectorPair.findObjectIdInfo(MapperConfig<?> config, Annotated ann)
ObjectIdInfo	JacksonAnnotationIntrospector.findObjectIdInfo(MapperConfig<?> config, Annotated ann)
ObjectIdInfo	AnnotationIntrospectorPair.findObjectReferenceInfo(MapperConfig<?> config, Annotated ann, ObjectIdInfo objectIdInfo)
ObjectIdInfo	JacksonAnnotationIntrospector.findObjectReferenceInfo(MapperConfig<?> config, Annotated ann, ObjectIdInfo objectIdInfo)
Class<?>	AnnotationIntrospectorPair.findPOJOBuilder(MapperConfig<?> config, AnnotatedClass ac)
Class<?>	JacksonAnnotationIntrospector.findPOJOBuilder(MapperConfig<?> config, AnnotatedClass ac)
JsonPOJOBuilder.Value	AnnotationIntrospectorPair.findPOJOBuilderConfig(MapperConfig<?> config, AnnotatedClass ac)
JsonPOJOBuilder.Value	JacksonAnnotationIntrospector.findPOJOBuilderConfig(MapperConfig<?> config, AnnotatedClass ac)
JsonTypeInfo.Value	AnnotationIntrospectorPair.findPolymorphicTypeInfo(MapperConfig<?> config, Annotated ann)
JsonTypeInfo.Value	JacksonAnnotationIntrospector.findPolymorphicTypeInfo(MapperConfig<?> config, Annotated ann)
PotentialCreator	AnnotationIntrospectorPair.findPreferredCreator(MapperConfig<?> config, AnnotatedClass valueClass, List<PotentialCreator> declaredConstructors, List<PotentialCreator> declaredFactories, Optional<PotentialCreator> zeroParamsConstructor)
JsonProperty.Access	AnnotationIntrospectorPair.findPropertyAccess(MapperConfig<?> config, Annotated ann)
JsonProperty.Access	JacksonAnnotationIntrospector.findPropertyAccess(MapperConfig<?> config, Annotated m)
List<PropertyName>	AnnotationIntrospectorPair.findPropertyAliases(MapperConfig<?> config, Annotated ann)
List<PropertyName>	JacksonAnnotationIntrospector.findPropertyAliases(MapperConfig<?> config, Annotated m)
String	AnnotationIntrospectorPair.findPropertyDefaultValue(MapperConfig<?> config, Annotated ann)
String	JacksonAnnotationIntrospector.findPropertyDefaultValue(MapperConfig<?> config, Annotated ann)
String	AnnotationIntrospectorPair.findPropertyDescription(MapperConfig<?> config, Annotated ann)
String	JacksonAnnotationIntrospector.findPropertyDescription(MapperConfig<?> config, Annotated ann)
JsonFormat.Value	ConcreteBeanPropertyBase.findPropertyFormat(MapperConfig<?> config, Class<?> baseType)
JsonIgnoreProperties.Value	AnnotationIntrospectorPair.findPropertyIgnoralByName(MapperConfig<?> config, Annotated a)
JsonIgnoreProperties.Value	JacksonAnnotationIntrospector.findPropertyIgnoralByName(MapperConfig<?> config, Annotated a)
JsonInclude.Value	AnnotationIntrospectorPair.findPropertyInclusion(MapperConfig<?> config, Annotated a)
JsonInclude.Value	ConcreteBeanPropertyBase.findPropertyInclusion(MapperConfig<?> config, Class<?> baseType)
JsonInclude.Value	JacksonAnnotationIntrospector.findPropertyInclusion(MapperConfig<?> config, Annotated a)
JsonIncludeProperties.Value	AnnotationIntrospectorPair.findPropertyInclusionByName(MapperConfig<?> config, Annotated a)
JsonIncludeProperties.Value	JacksonAnnotationIntrospector.findPropertyInclusionByName(MapperConfig<?> config, Annotated a)
Integer	AnnotationIntrospectorPair.findPropertyIndex(MapperConfig<?> config, Annotated ann)
Integer	JacksonAnnotationIntrospector.findPropertyIndex(MapperConfig<?> config, Annotated ann)
AnnotationIntrospector.ReferenceProperty	AnnotationIntrospectorPair.findReferenceType(MapperConfig<?> config, AnnotatedMember member)
AnnotationIntrospector.ReferenceProperty	JacksonAnnotationIntrospector.findReferenceType(MapperConfig<?> config, AnnotatedMember member)
PropertyName	AnnotationIntrospectorPair.findRenameByField(MapperConfig<?> config, AnnotatedField f, PropertyName implName)
PropertyName	JacksonAnnotationIntrospector.findRenameByField(MapperConfig<?> config, AnnotatedField f, PropertyName implName)
PropertyName	AnnotationIntrospectorPair.findRootName(MapperConfig<?> config, AnnotatedClass ac)
PropertyName	JacksonAnnotationIntrospector.findRootName(MapperConfig<?> config, AnnotatedClass ac)
Object	AnnotationIntrospectorPair.findSerializationContentConverter(MapperConfig<?> config, AnnotatedMember a)
Object	JacksonAnnotationIntrospector.findSerializationContentConverter(MapperConfig<?> config, AnnotatedMember a)
Object	AnnotationIntrospectorPair.findSerializationConverter(MapperConfig<?> config, Annotated a)
Object	JacksonAnnotationIntrospector.findSerializationConverter(MapperConfig<?> config, Annotated a)
String[]	AnnotationIntrospectorPair.findSerializationPropertyOrder(MapperConfig<?> config, AnnotatedClass ac)
String[]	JacksonAnnotationIntrospector.findSerializationPropertyOrder(MapperConfig<?> config, AnnotatedClass ac)
Boolean	AnnotationIntrospectorPair.findSerializationSortAlphabetically(MapperConfig<?> config, Annotated ann)
Boolean	JacksonAnnotationIntrospector.findSerializationSortAlphabetically(MapperConfig<?> config, Annotated ann)
JsonSerialize.Typing	AnnotationIntrospectorPair.findSerializationTyping(MapperConfig<?> config, Annotated a)
JsonSerialize.Typing	JacksonAnnotationIntrospector.findSerializationTyping(MapperConfig<?> config, Annotated a)
Object	AnnotationIntrospectorPair.findSerializer(MapperConfig<?> config, Annotated am)
Object	JacksonAnnotationIntrospector.findSerializer(MapperConfig<?> config, Annotated a)
JsonSetter.Value	AnnotationIntrospectorPair.findSetterInfo(MapperConfig<?> config, Annotated a)
JsonSetter.Value	JacksonAnnotationIntrospector.findSetterInfo(MapperConfig<?> config, Annotated a)
List<NamedType>	AnnotationIntrospectorPair.findSubtypes(MapperConfig<?> config, Annotated a)
List<NamedType>	JacksonAnnotationIntrospector.findSubtypes(MapperConfig<?> config, Annotated a)
Object	AnnotationIntrospectorPair.findTypeIdResolver(MapperConfig<?> config, Annotated ann)
Object	JacksonAnnotationIntrospector.findTypeIdResolver(MapperConfig<?> config, Annotated ann)
String	AnnotationIntrospectorPair.findTypeName(MapperConfig<?> config, AnnotatedClass ac)
String	JacksonAnnotationIntrospector.findTypeName(MapperConfig<?> config, AnnotatedClass ac)
Object	AnnotationIntrospectorPair.findTypeResolverBuilder(MapperConfig<?> config, Annotated ann)
Object	JacksonAnnotationIntrospector.findTypeResolverBuilder(MapperConfig<?> config, Annotated ann)
NameTransformer	AnnotationIntrospectorPair.findUnwrappingNameTransformer(MapperConfig<?> config, AnnotatedMember member)
NameTransformer	JacksonAnnotationIntrospector.findUnwrappingNameTransformer(MapperConfig<?> config, AnnotatedMember member)
Object	AnnotationIntrospectorPair.findValueInstantiator(MapperConfig<?> config, AnnotatedClass ac)
Object	JacksonAnnotationIntrospector.findValueInstantiator(MapperConfig<?> config, AnnotatedClass ac)
Class<?>[]	AnnotationIntrospectorPair.findViews(MapperConfig<?> config, Annotated a)
Class<?>[]	JacksonAnnotationIntrospector.findViews(MapperConfig<?> config, Annotated a)
PropertyName	AnnotationIntrospectorPair.findWrapperName(MapperConfig<?> config, Annotated ann)
abstract AccessorNamingStrategy	AccessorNamingStrategy.Provider.forBuilder(MapperConfig<?> config, AnnotatedClass builderClass, BeanDescription valueTypeDesc)	Factory method for creating strategy instance for POJOs that are deserialized using Builder type: in this case eventual target (value) type is different from type of "builder" object that is used by databinding to accumulate state.
AccessorNamingStrategy	DefaultAccessorNamingStrategy.Provider.forBuilder(MapperConfig<?> config, AnnotatedClass builderClass, BeanDescription valueTypeDesc)
BasicClassIntrospector	BasicClassIntrospector.forOperation(MapperConfig<?> config)
abstract ClassIntrospector	ClassIntrospector.forOperation(MapperConfig<?> config)	Method called to further create an instance to be used for a single operation (read or write, typically matching ObjectMapper readValue() or writeValue()).
static BasicBeanDescription	BasicBeanDescription.forOtherUse(MapperConfig<?> config, JavaType type, AnnotatedClass ac)	Factory method to use for constructing an instance to use for purposes other than building serializers or deserializers; will only have information on class, not on properties.
abstract AccessorNamingStrategy	AccessorNamingStrategy.Provider.forPOJO(MapperConfig<?> config, AnnotatedClass valueClass)	Factory method for creating strategy instance for a "regular" POJO, called if none of the other factory methods is applicable.
AccessorNamingStrategy	DefaultAccessorNamingStrategy.Provider.forPOJO(MapperConfig<?> config, AnnotatedClass targetClass)
abstract AccessorNamingStrategy	AccessorNamingStrategy.Provider.forRecord(MapperConfig<?> config, AnnotatedClass recordClass)	Factory method for creating strategy instance for special java.lang.Record type (new in JDK 14).
AccessorNamingStrategy	DefaultAccessorNamingStrategy.Provider.forRecord(MapperConfig<?> config, AnnotatedClass recordClass)
Boolean	AnnotationIntrospectorPair.hasAnyGetter(MapperConfig<?> config, Annotated a)
Boolean	JacksonAnnotationIntrospector.hasAnyGetter(MapperConfig<?> config, Annotated a)
Boolean	AnnotationIntrospectorPair.hasAnySetter(MapperConfig<?> config, Annotated a)
Boolean	JacksonAnnotationIntrospector.hasAnySetter(MapperConfig<?> config, Annotated a)
Boolean	AnnotationIntrospectorPair.hasAsKey(MapperConfig<?> config, Annotated a)
Boolean	JacksonAnnotationIntrospector.hasAsKey(MapperConfig<?> config, Annotated a)
Boolean	AnnotationIntrospectorPair.hasAsValue(MapperConfig<?> config, Annotated a)
Boolean	JacksonAnnotationIntrospector.hasAsValue(MapperConfig<?> config, Annotated a)
boolean	AnnotationIntrospectorPair.hasIgnoreMarker(MapperConfig<?> config, AnnotatedMember m)
boolean	JacksonAnnotationIntrospector.hasIgnoreMarker(MapperConfig<?> config, AnnotatedMember m)
boolean	PotentialCreator.hasNameOrInjectForAllParams(MapperConfig<?> config)
Boolean	AnnotationIntrospectorPair.hasRequiredMarker(MapperConfig<?> config, AnnotatedMember m)
Boolean	JacksonAnnotationIntrospector.hasRequiredMarker(MapperConfig<?> config, AnnotatedMember m)
PotentialCreator	PotentialCreator.introspectParamNames(MapperConfig<?> config)
PotentialCreator	PotentialCreator.introspectParamNames(MapperConfig<?> config, PropertyName[] implicits)	Variant used when implicit names are known; such as case for JDK Record types.
Boolean	AnnotationIntrospectorPair.isIgnorableType(MapperConfig<?> config, AnnotatedClass ac)
Boolean	JacksonAnnotationIntrospector.isIgnorableType(MapperConfig<?> config, AnnotatedClass ac)
Boolean	AnnotationIntrospectorPair.isTypeId(MapperConfig<?> config, AnnotatedMember member)
Boolean	JacksonAnnotationIntrospector.isTypeId(MapperConfig<?> config, AnnotatedMember member)
JavaType	AnnotationIntrospectorPair.refineDeserializationType(MapperConfig<?> config, Annotated a, JavaType baseType)
JavaType	JacksonAnnotationIntrospector.refineDeserializationType(MapperConfig<?> config, Annotated a, JavaType baseType)
JavaType	AnnotationIntrospectorPair.refineSerializationType(MapperConfig<?> config, Annotated a, JavaType baseType)
JavaType	JacksonAnnotationIntrospector.refineSerializationType(MapperConfig<?> config, Annotated a, JavaType baseType)
static AnnotatedClass	AnnotatedClassResolver.resolve(MapperConfig<?> config, JavaType forType, MixInResolver r)
AnnotatedMethod	AnnotationIntrospectorPair.resolveSetterConflict(MapperConfig<?> config, AnnotatedMethod setter1, AnnotatedMethod setter2)
AnnotatedMethod	JacksonAnnotationIntrospector.resolveSetterConflict(MapperConfig<?> config, AnnotatedMethod setter1, AnnotatedMethod setter2)
static AnnotatedClass	AnnotatedClassResolver.resolveWithoutSuperTypes(MapperConfig<?> config, Class<?> forType)
static AnnotatedClass	AnnotatedClassResolver.resolveWithoutSuperTypes(MapperConfig<?> config, Class<?> forType, MixInResolver r)
static AnnotatedClass	AnnotatedClassResolver.resolveWithoutSuperTypes(MapperConfig<?> config, JavaType forType, MixInResolver r)
void	PotentialCreators.setPropertiesBased(MapperConfig<?> config, PotentialCreator ctor, String mode)

Constructors in tools.jackson.databind.introspect with parameters of type MapperConfig

Modifier	Constructor	Description
protected	BasicBeanDescription(MapperConfig<?> config, JavaType type, AnnotatedClass classDef)	Alternate constructor used in cases where property information is not needed, only class info.
protected	BasicClassIntrospector(MapperConfig<?> config)
protected	DefaultAccessorNamingStrategy(MapperConfig<?> config, AnnotatedClass forClass, String mutatorPrefix, String getterPrefix, String isGetterPrefix, DefaultAccessorNamingStrategy.BaseNameValidator baseNameValidator)
protected	POJOPropertiesCollector(MapperConfig<?> config, boolean forSerialization, JavaType type, AnnotatedClass classDef, AccessorNamingStrategy accessorNaming)
	POJOPropertyBuilder(MapperConfig<?> config, AnnotationIntrospector ai, boolean forSerialization, PropertyName internalName)
protected	POJOPropertyBuilder(MapperConfig<?> config, AnnotationIntrospector ai, boolean forSerialization, PropertyName internalName, PropertyName name)
	RecordNaming(MapperConfig<?> config, AnnotatedClass forClass)

Uses of MapperConfig in tools.jackson.databind.jsontype

Methods in tools.jackson.databind.jsontype with parameters of type MapperConfig

Modifier and Type	Method	Description
protected TypeResolverBuilder<?>	TypeResolverProvider._constructStdTypeResolverBuilder(MapperConfig<?> config, JsonTypeInfo.Value typeInfo, JavaType baseType)
protected TypeResolverBuilder<?>	TypeResolverProvider._findTypeResolver(MapperConfig<?> config, Annotated ann, JavaType baseType)
abstract Collection<NamedType>	SubtypeResolver.collectAndResolveSubtypesByClass(MapperConfig<?> config, AnnotatedClass baseType)	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).
abstract Collection<NamedType>	SubtypeResolver.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).
abstract Collection<NamedType>	SubtypeResolver.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).
abstract Collection<NamedType>	SubtypeResolver.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).

Uses of MapperConfig in tools.jackson.databind.jsontype.impl

Methods in tools.jackson.databind.jsontype.impl with parameters of type MapperConfig

Modifier and Type	Method	Description
protected void	StdSubtypeResolver._collectAndResolve(MapperConfig<?> config, AnnotatedClass annotatedType, NamedType namedType, 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	StdSubtypeResolver._collectAndResolveByTypeId(MapperConfig<?> config, AnnotatedClass annotatedType, NamedType namedType, 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).
Collection<NamedType>	StdSubtypeResolver.collectAndResolveSubtypesByClass(MapperConfig<?> config, AnnotatedClass type)
Collection<NamedType>	StdSubtypeResolver.collectAndResolveSubtypesByClass(MapperConfig<?> config, AnnotatedMember property, JavaType baseType)
Collection<NamedType>	StdSubtypeResolver.collectAndResolveSubtypesByTypeId(MapperConfig<?> config, AnnotatedClass baseType)
Collection<NamedType>	StdSubtypeResolver.collectAndResolveSubtypesByTypeId(MapperConfig<?> config, AnnotatedMember property, JavaType baseType)
static SimpleNameIdResolver	SimpleNameIdResolver.construct(MapperConfig<?> config, JavaType baseType, Collection<NamedType> subtypes, boolean forSer, boolean forDeser)
static TypeNameIdResolver	TypeNameIdResolver.construct(MapperConfig<?> config, JavaType baseType, Collection<NamedType> subtypes, boolean forSer, boolean forDeser)

Uses of MapperConfig in tools.jackson.databind.ser

Methods in tools.jackson.databind.ser with parameters of type MapperConfig

Modifier and Type	Method	Description
abstract VirtualBeanPropertyWriter	VirtualBeanPropertyWriter.withConfig(MapperConfig<?> config, AnnotatedClass declaringClass, BeanPropertyDefinition propDef, JavaType type)	Contextualization method called on a newly constructed virtual bean property.

Uses of MapperConfig in tools.jackson.databind.ser.impl

Methods in tools.jackson.databind.ser.impl with parameters of type MapperConfig

Modifier and Type	Method	Description
VirtualBeanPropertyWriter	AttributePropertyWriter.withConfig(MapperConfig<?> config, AnnotatedClass declaringClass, BeanPropertyDefinition propDef, JavaType type)	Since this method should typically not be called on this sub-type, default implementation simply throws an IllegalStateException.

Uses of MapperConfig in tools.jackson.databind.util

Fields in tools.jackson.databind.util declared as MapperConfig

Modifier and Type	Field	Description
protected final MapperConfig<?>	SimpleBeanPropertyDefinition._config

Methods in tools.jackson.databind.util with parameters of type MapperConfig

Modifier and Type	Method	Description
protected static Enum<?>	EnumResolver._enumDefault(MapperConfig<?> config, AnnotatedClass annotatedClass, Enum<?>[] enums)	Internal helper method used to resolve JsonEnumDefaultValue
static String	BeanUtil.checkUnsupportedType(MapperConfig<?> config, JavaType type)	Helper method called by BeanDeserializerFactory and BeanSerializerFactory to check if given unrecognized type (to be (de)serialized as general POJO) is one of "well-known" types for which there would be a datatype module; and if so, return appropriate failure message to give to caller.
static EnumValues	EnumValues.construct(MapperConfig<?> config, Class<Enum<?>> enumClass, List<String> externalValues)
static SimpleBeanPropertyDefinition	SimpleBeanPropertyDefinition.construct(MapperConfig<?> config, AnnotatedMember member)
static SimpleBeanPropertyDefinition	SimpleBeanPropertyDefinition.construct(MapperConfig<?> config, AnnotatedMember member, PropertyName name)
static SimpleBeanPropertyDefinition	SimpleBeanPropertyDefinition.construct(MapperConfig<?> config, AnnotatedMember member, PropertyName name, PropertyMetadata metadata, JsonInclude.Include inclusion)	Method called to create instance for virtual properties.
static SimpleBeanPropertyDefinition	SimpleBeanPropertyDefinition.construct(MapperConfig<?> config, AnnotatedMember member, PropertyName name, PropertyMetadata metadata, JsonInclude.Value inclusion)
static EnumValues	EnumValues.constructFromName(MapperConfig<?> config, AnnotatedClass annotatedClass)
static EnumValues	EnumValues.constructFromToString(MapperConfig<?> config, AnnotatedClass annotatedClass)
static EnumValues	EnumValues.constructUsingEnumNamingStrategy(MapperConfig<?> config, AnnotatedClass annotatedClass, EnumNamingStrategy namingStrategy)	Returns String serializations of Enum name using an instance of EnumNamingStrategy.
static PotentialCreator	RecordUtil.findCanonicalRecordConstructor(MapperConfig<?> config, AnnotatedClass recordClass, List<PotentialCreator> constructors)

Constructors in tools.jackson.databind.util with parameters of type MapperConfig

Modifier	Constructor	Description
protected	SimpleBeanPropertyDefinition(MapperConfig<?> config, AnnotatedMember member, PropertyName fullName, PropertyMetadata metadata, JsonInclude.Value inclusion)