Uses of Class
tools.jackson.databind.introspect.AnnotatedClass

Packages that use AnnotatedClass

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.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.ser.jdk
tools.jackson.databind.util	Utility classes for Mapper package.

Uses of AnnotatedClass in tools.jackson.databind

Fields in tools.jackson.databind declared as AnnotatedClass

Modifier and Type	Field	Description
protected AnnotatedClass	BeanDescription.LazySupplier._classDesc

Methods in tools.jackson.databind that return AnnotatedClass

Modifier and Type	Method	Description
protected abstract AnnotatedClass	BeanDescription.LazySupplier._introspect(JavaType forType)
AnnotatedClass	BeanDescription.EagerSupplier.getClassInfo()
abstract AnnotatedClass	BeanDescription.getClassInfo()	Method for accessing low-level information about Class this item describes.
AnnotatedClass	BeanDescription.LazySupplier.getClassInfo()
AnnotatedClass	BeanDescription.Supplier.getClassInfo()
AnnotatedClass	DatabindContext.introspectClassAnnotations(Class<?> rawType)
AnnotatedClass	DatabindContext.introspectClassAnnotations(JavaType type)
AnnotatedClass	DatabindContext.introspectDirectClassAnnotations(JavaType type)

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

Modifier and Type	Method	Description
protected abstract BeanDescription	BeanDescription.LazySupplier._construct(JavaType forType, AnnotatedClass ac)
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.
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.
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.
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 names, if any, of the given set of Enum values.
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
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)
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).
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.
String[]	AnnotationIntrospector.findSerializationPropertyOrder(MapperConfig<?> config, AnnotatedClass ac)	Method for accessing defined property serialization order (which may be partial).
TypeDeserializer	DeserializationContext.findTypeDeserializer(JavaType baseType, AnnotatedClass classAnnotations)
String	AnnotationIntrospector.findTypeName(MapperConfig<?> config, AnnotatedClass ac)	Method for checking if specified type has explicit name.
TypeSerializer	SerializationContext.findTypeSerializer(JavaType baseType, AnnotatedClass classAnnotations)	Method called to get the TypeSerializer to use for including Type Id necessary for serializing for the given Java class.
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.
abstract BeanDescription	DatabindContext.introspectBeanDescription(JavaType type, AnnotatedClass classDef)
BeanDescription	DeserializationContext.introspectBeanDescription(JavaType type, AnnotatedClass ac)
BeanDescription	SerializationContext.introspectBeanDescription(JavaType type, AnnotatedClass ac)
BeanDescription	DeserializationContext.introspectBeanDescriptionForCreation(JavaType type, AnnotatedClass ac)
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.

Uses of AnnotatedClass in tools.jackson.databind.cfg

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

Modifier and Type	Method	Description
abstract JsonIgnoreProperties.Value	MapperConfig.getDefaultPropertyIgnorals(Class<?> baseType, AnnotatedClass actualClass)	Helper method that may be called to see if there are property ignoral definitions from annotations (via AnnotatedClass) or through "config overrides".
final JsonIgnoreProperties.Value	MapperConfigBase.getDefaultPropertyIgnorals(Class<?> baseType, AnnotatedClass actualClass)
abstract JsonIncludeProperties.Value	MapperConfig.getDefaultPropertyInclusions(Class<?> baseType, AnnotatedClass actualClass)	Helper method that may be called to see if there are property inclusion definitions from annotations (via AnnotatedClass).
final JsonIncludeProperties.Value	MapperConfigBase.getDefaultPropertyInclusions(Class<?> baseType, AnnotatedClass actualClass)
abstract VisibilityChecker	MapperConfig.getDefaultVisibilityChecker(Class<?> baseType, AnnotatedClass actualClass)	Accessor for object used for determining whether specific property elements (method, constructors, fields) can be auto-detected based on their visibility (access modifiers).
final VisibilityChecker	MapperConfigBase.getDefaultVisibilityChecker(Class<?> baseType, AnnotatedClass actualClass)

Uses of AnnotatedClass in tools.jackson.databind.deser

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

Modifier and Type	Method	Description
protected EnumResolver	BasicDeserializerFactory.constructEnumNamingStrategyResolver(DeserializationConfig config, AnnotatedClass enumClass)	Factory method used to resolve an instance of CompactStringObjectMap with EnumNamingStrategy applied for the target class.

Uses of AnnotatedClass in tools.jackson.databind.introspect

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

Modifier and Type	Field	Description
protected final AnnotatedClass	POJOPropertiesCollector._classDef	Low-level introspected class information (methods, fields etc)
protected final AnnotatedClass	BasicBeanDescription._classInfo	Information collected about the class introspected.
protected final AnnotatedClass	DefaultAccessorNamingStrategy._forClass

Fields in tools.jackson.databind.introspect with type parameters of type AnnotatedClass

Modifier and Type	Field	Description
protected HashMap<JavaType,AnnotatedClass>	BasicClassIntrospector._resolvedFullAnnotations	Reuse fully-resolved annotations during a single operation

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

Modifier and Type	Method	Description
protected AnnotatedClass	BasicClassIntrospector._findStdTypeDef(JavaType type)	Method called to see if type is one of core JDK types that we have cached for efficiency.
protected AnnotatedClass	BasicClassIntrospector._resolveAnnotatedClass(JavaType type)
protected AnnotatedClass	BasicClassIntrospector._resolveAnnotatedWithoutSuperTypes(JavaType type)
AnnotatedClass	POJOPropertiesCollector.getClassDef()
AnnotatedClass	BasicBeanDescription.getClassInfo()
AnnotatedClass	BasicClassIntrospector.introspectClassAnnotations(JavaType type)
abstract AnnotatedClass	ClassIntrospector.introspectClassAnnotations(JavaType type)	Factory method that introspects a AnnotatedClass that only has information regarding annotations class itself (or its supertypes) has, but nothing on methods or constructors.
AnnotatedClass	BasicClassIntrospector.introspectDirectClassAnnotations(JavaType type)
abstract AnnotatedClass	ClassIntrospector.introspectDirectClassAnnotations(JavaType type)	Factory method that introspects a AnnotatedClass that only has information regarding annotations class itself has (but NOT including its supertypes), but nothing on methods or constructors.
static AnnotatedClass	AnnotatedClassResolver.resolve(MapperConfig<?> config, JavaType forType, MixInResolver r)
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)

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

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)
protected POJOPropertiesCollector	BasicClassIntrospector.collectProperties(JavaType type, AnnotatedClass classDef, boolean forSerialization, String mutatorPrefix)
protected POJOPropertiesCollector	BasicClassIntrospector.collectPropertiesWithBuilder(JavaType type, AnnotatedClass builderClassDef, BeanDescription valueTypeDesc, boolean forSerialization)
protected POJOPropertiesCollector	BasicClassIntrospector.constructPropertyCollector(JavaType type, AnnotatedClass classDef, boolean forSerialization, AccessorNamingStrategy accNaming)	Overridable method called for creating POJOPropertiesCollector instance to use; override is needed if a custom sub-class is to be used.
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)
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.
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.findNamingStrategy(MapperConfig<?> config, AnnotatedClass ac)
Object	JacksonAnnotationIntrospector.findNamingStrategy(MapperConfig<?> config, AnnotatedClass ac)
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)
PotentialCreator	AnnotationIntrospectorPair.findPreferredCreator(MapperConfig<?> config, AnnotatedClass valueClass, List<PotentialCreator> declaredConstructors, List<PotentialCreator> declaredFactories, Optional<PotentialCreator> zeroParamsConstructor)
PropertyName	AnnotationIntrospectorPair.findRootName(MapperConfig<?> config, AnnotatedClass ac)
PropertyName	JacksonAnnotationIntrospector.findRootName(MapperConfig<?> config, AnnotatedClass ac)
String[]	AnnotationIntrospectorPair.findSerializationPropertyOrder(MapperConfig<?> config, AnnotatedClass ac)
String[]	JacksonAnnotationIntrospector.findSerializationPropertyOrder(MapperConfig<?> config, AnnotatedClass ac)
String	AnnotationIntrospectorPair.findTypeName(MapperConfig<?> config, AnnotatedClass ac)
String	JacksonAnnotationIntrospector.findTypeName(MapperConfig<?> config, AnnotatedClass ac)
Object	AnnotationIntrospectorPair.findValueInstantiator(MapperConfig<?> config, AnnotatedClass ac)
Object	JacksonAnnotationIntrospector.findValueInstantiator(MapperConfig<?> config, AnnotatedClass ac)
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)
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)
BasicBeanDescription	BasicClassIntrospector.introspectForCreation(JavaType type, AnnotatedClass classDef)
abstract BeanDescription	ClassIntrospector.introspectForCreation(JavaType type, AnnotatedClass classDef)	Factory method that introspects a BeanDescription that has information necessary for creating instances of given class ("creator"), as well as class annotations, but no information on member methods
BasicBeanDescription	BasicClassIntrospector.introspectForDeserialization(JavaType type, AnnotatedClass classDef)
abstract BeanDescription	ClassIntrospector.introspectForDeserialization(JavaType type, AnnotatedClass classDef)	Factory method that introspects a BeanDescription that has all information needed for deserialization purposes.
BasicBeanDescription	BasicClassIntrospector.introspectForSerialization(JavaType type, AnnotatedClass classDef)
abstract BeanDescription	ClassIntrospector.introspectForSerialization(JavaType type, AnnotatedClass classDef)	Factory method that introspects a BeanDescription that has all information needed for serialization purposes.
Boolean	AnnotationIntrospectorPair.isIgnorableType(MapperConfig<?> config, AnnotatedClass ac)
Boolean	JacksonAnnotationIntrospector.isIgnorableType(MapperConfig<?> config, AnnotatedClass ac)

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

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	BasicBeanDescription(POJOPropertiesCollector coll, JavaType type, AnnotatedClass classDef)
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)
	RecordNaming(MapperConfig<?> config, AnnotatedClass forClass)

Uses of AnnotatedClass in tools.jackson.databind.jsontype

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

Modifier and Type	Method	Description
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.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).
TypeDeserializer	TypeResolverProvider.findTypeDeserializer(DeserializationContext ctxt, JavaType baseType, AnnotatedClass classInfo)
TypeSerializer	TypeResolverProvider.findTypeSerializer(SerializationContext ctxt, JavaType baseType, AnnotatedClass classInfo)	Method for checking if given class has annotations that indicate that specific type resolver is to be used for handling instances of given type.

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

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

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.collectAndResolveSubtypesByTypeId(MapperConfig<?> config, AnnotatedClass baseType)

Uses of AnnotatedClass in tools.jackson.databind.ser

Methods in tools.jackson.databind.ser that return AnnotatedClass

Modifier and Type	Method	Description
AnnotatedClass	BeanSerializerBuilder.getClassInfo()

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

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 AnnotatedClass in tools.jackson.databind.ser.impl

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

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 AnnotatedClass in tools.jackson.databind.ser.jdk

Methods in tools.jackson.databind.ser.jdk with parameters of type AnnotatedClass

Modifier and Type	Method	Description
protected static EnumValues	EnumSerializer.constructEnumNamingStrategyValues(SerializationConfig config, Class<Enum<?>> enumClass, AnnotatedClass annotatedClass)	Factory method used to resolve an instance of EnumValues with EnumNamingStrategy applied for the target class.
static ValueSerializer<Object>	JDKKeySerializers.getFallbackKeySerializer(SerializationConfig config, Class<?> rawKeyType, AnnotatedClass annotatedClass)	Method called if no specified key serializer was located; will return a "default" key serializer except with special handling for Enums

Uses of AnnotatedClass in tools.jackson.databind.util

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

Modifier and Type	Method	Description
protected static Enum<?>	EnumResolver._enumDefault(MapperConfig<?> config, AnnotatedClass annotatedClass, Enum<?>[] enums)	Internal helper method used to resolve JsonEnumDefaultValue
static EnumDefinition	EnumDefinition.construct(MapperConfig<?> config, AnnotatedClass annotatedClass)
static EnumValues	EnumValues.construct(SerializationConfig config, AnnotatedClass enumClass)	Deprecated. Since 3.1 call EnumValues.constructFromName(tools.jackson.databind.cfg.MapperConfig<?>, tools.jackson.databind.introspect.AnnotatedClass) or EnumValues.constructFromToString(tools.jackson.databind.cfg.MapperConfig<?>, tools.jackson.databind.introspect.AnnotatedClass) instead.
static EnumValuesToWrite	EnumValuesToWrite.construct(MapperConfig<?> config, AnnotatedClass annotatedClass, EnumNamingStrategy enumNamingStrategy, Enum<?>[] enumConstants, String[] explicitNames0)
static EnumResolver	EnumResolver.constructFor(DeserializationConfig config, AnnotatedClass annotatedClass)	Factory method for constructing an EnumResolver based on the given DeserializationConfig and AnnotatedClass of the enum to be resolved.
static EnumValues	EnumValues.constructFromName(MapperConfig<?> config, AnnotatedClass annotatedClass)
static EnumValues	EnumValues.constructFromToString(MapperConfig<?> config, AnnotatedClass annotatedClass)
static EnumResolver	EnumResolver.constructUsingEnumNamingStrategy(DeserializationConfig config, AnnotatedClass annotatedClass, EnumNamingStrategy enumNamingStrategy)	Factory method for constructing an EnumResolver with EnumNamingStrategy applied.
static EnumValues	EnumValues.constructUsingEnumNamingStrategy(MapperConfig<?> config, AnnotatedClass annotatedClass, EnumNamingStrategy namingStrategy)	Returns String serializations of Enum name using an instance of EnumNamingStrategy.
static EnumResolver	EnumResolver.constructUsingIndex(DeserializationConfig config, AnnotatedClass annotatedClass)	Factory method for constructing resolver that maps from index of Enum.values() into Enum value.
static EnumResolver	EnumResolver.constructUsingMethod(DeserializationConfig config, AnnotatedClass annotatedClass, AnnotatedMember accessor)	Method used when actual String serialization is indicated using @JsonValue on a method in Enum class.
static EnumResolver	EnumResolver.constructUsingToString(DeserializationConfig config, AnnotatedClass annotatedClass)	Factory method for constructing resolver that maps from Enum.toString() into Enum value
static PotentialCreator	RecordUtil.findCanonicalRecordConstructor(MapperConfig<?> config, AnnotatedClass recordClass, List<PotentialCreator> constructors)