* Although default implementations are based on using annotations as the only * (or at least main) information source, custom implementations are not limited * in such a way, and in fact there is no expectation they should be. So the name * is bit of misnomer; this is a general configuration introspection facility. *
* NOTE: due to rapid addition of new methods (and changes to existing methods), * it is strongly recommended that custom implementations should not directly * extend this class, but rather extend {@link NopAnnotationIntrospector}. * This way added methods will not break backwards compatibility of custom annotation * introspectors. */ @SuppressWarnings("serial") public abstract class AnnotationIntrospector implements Versioned, java.io.Serializable { /* /********************************************************** /* Helper types /********************************************************** */ /** * Value type used with managed and back references; contains type and * logic name, used to link related references */ public static class ReferenceProperty { public enum Type { /** * Reference property that Jackson manages and that is serialized normally (by serializing * reference object), but is used for resolving back references during * deserialization. * Usually this can be defined by using * {@link com.fasterxml.jackson.annotation.JsonManagedReference} */ MANAGED_REFERENCE /** * Reference property that Jackson manages by suppressing it during serialization, * and reconstructing during deserialization. * Usually this can be defined by using * {@link com.fasterxml.jackson.annotation.JsonBackReference} */ ,BACK_REFERENCE ; } private final Type _type; private final String _name; public ReferenceProperty(Type t, String n) { _type = t; _name = n; } public static ReferenceProperty managed(String name) { return new ReferenceProperty(Type.MANAGED_REFERENCE, name); } public static ReferenceProperty back(String name) { return new ReferenceProperty(Type.BACK_REFERENCE, name); } public Type getType() { return _type; } public String getName() { return _name; } public boolean isManagedReference() { return _type == Type.MANAGED_REFERENCE; } public boolean isBackReference() { return _type == Type.BACK_REFERENCE; } } /* /********************************************************** /* Factory methods /********************************************************** */ /** * Factory method for accessing "no operation" implementation * of introspector: instance that will never find any annotation-based * configuration. * * @return "no operation" instance */ public static AnnotationIntrospector nopInstance() { return NopAnnotationIntrospector.instance; } public static AnnotationIntrospector pair(AnnotationIntrospector a1, AnnotationIntrospector a2) { return new AnnotationIntrospectorPair(a1, a2); } /* /********************************************************** /* Access to possibly chained introspectors /********************************************************** */ /** * Method that can be used to collect all "real" introspectors that * this introspector contains, if any; or this introspector * if it is not a container. Used to get access to all container * introspectors in their priority order. *
* Default implementation returns a Singleton list with this introspector
* as contents.
* This usually works for sub-classes, except for proxy or delegating "container
* introspectors" which need to override implementation.
*
* @return Collection of all introspectors starting with this one, in case
* multiple introspectors are chained
*/
public Collection
* Default implementation adds this introspector in result; this usually
* works for sub-classes, except for proxy or delegating "container
* introspectors" which need to override implementation.
*
* @param result Container to add introspectors to
*
* @return Passed in {@code Collection} filled with introspectors as explained
* above
*/
public Collection
* NOTE: method signature changed in 2.1, to return {@link PropertyName}
* instead of String.
*
* @param ac Annotated class to introspect
*
* @return Root name to use, if any; {@code null} if not
*/
public PropertyName findRootName(AnnotatedClass ac) {
return null;
}
/**
* Method for checking whether properties that have specified type
* (class, not generics aware) should be completely ignored for
* serialization and deserialization purposes.
*
* @param ac Annotated class to introspect
*
* @return Boolean.TRUE if properties of type should be ignored;
* Boolean.FALSE if they are not to be ignored, null for default
* handling (which is 'do not ignore')
*/
public Boolean isIgnorableType(AnnotatedClass ac) { return null; }
/**
* Method for finding information about properties to ignore either by
* name, or by more general specification ("ignore all unknown").
* This method combines multiple aspects of ignorals and deprecates
* earlier methods such as
* {@link #findPropertiesToIgnore(Annotated, boolean)} and
* {@link #findIgnoreUnknownProperties(AnnotatedClass)}.
*
* @param config Configuration settings in effect (for serialization or deserialization)
* @param ann Annotated entity (Class, Accessor) to introspect
*
* @since 2.12 (to replace {@code findPropertyIgnorals()})
*/
public JsonIgnoreProperties.Value findPropertyIgnoralByName(MapperConfig config, Annotated ann)
{
// In 2.12, remove redirection in future
return findPropertyIgnorals(ann);
}
/**
* Method for finding information about names of properties to included.
* This is typically used to strictly limit properties to include based
* on fully defined set of names ("allow-listing"), as opposed to excluding
* potential properties by exclusion ("deny-listing").
*
* @param config Configuration settings in effect (for serialization or deserialization)
* @param ann Annotated entity (Class, Accessor) to introspect
*
* @since 2.12
*/
public JsonIncludeProperties.Value findPropertyInclusionByName(MapperConfig config, Annotated ann) {
return JsonIncludeProperties.Value.all();
}
/**
* Method for finding if annotated class has associated filter; and if so,
* to return id that is used to locate filter.
*
* @param ann Annotated entity to introspect
*
* @return Id of the filter to use for filtering properties of annotated
* class, if any; or null if none found.
*/
public Object findFilterId(Annotated ann) { return null; }
/**
* Method for finding {@link PropertyNamingStrategy} for given
* class, if any specified by annotations; and if so, either return
* a {@link PropertyNamingStrategy} instance, or Class to use for
* creating instance
*
* @param ac Annotated class to introspect
*
* @return Sub-class or instance of {@link PropertyNamingStrategy}, if one
* is specified for given class; null if not.
*
* @since 2.1
*/
public Object findNamingStrategy(AnnotatedClass ac) { return null; }
/**
* Method used to check whether specified class defines a human-readable
* description to use for documentation.
* There are no further definitions for contents; for example, whether
* these may be marked up using HTML (or something like wiki format like Markup)
* is not defined.
*
* @param ac Annotated class to introspect
*
* @return Human-readable description, if any.
*
* @since 2.7
*/
public String findClassDescription(AnnotatedClass ac) { return null; }
/**
* @param forSerialization True if requesting properties to ignore for serialization;
* false if for deserialization
* @param ac Annotated class to introspect
*
* @return Array of names of properties to ignore
*
* @since 2.6
*
* @deprecated Since 2.8, use {@link #findPropertyIgnoralByName} instead
*/
@Deprecated // since 2.8
public String[] findPropertiesToIgnore(Annotated ac, boolean forSerialization) {
return null;
}
/**
* Method for checking whether an annotation indicates that all unknown properties
* should be ignored.
*
* @param ac Annotated class to introspect
*
* @return True if class has something indicating "ignore [all] unknown properties"
*
* @deprecated Since 2.8, use {@link #findPropertyIgnoralByName} instead
*/
@Deprecated // since 2.8
public Boolean findIgnoreUnknownProperties(AnnotatedClass ac) { return null; }
/**
* @since 2.8
* @deprecated 2.12, use {@link #findPropertyIgnoralByName} instead.
*/
@Deprecated // since 2.12
public JsonIgnoreProperties.Value findPropertyIgnorals(Annotated ac) {
return JsonIgnoreProperties.Value.empty();
}
/*
/**********************************************************
/* Property auto-detection
/**********************************************************
*/
/**
* Method for checking if annotations indicate changes to minimum visibility levels
* needed for auto-detecting property elements (fields, methods, constructors).
* A baseline checker is given, and introspector is to either return it as is
* (if no annotations are found), or build and return a derived instance (using
* checker's build methods).
*/
public VisibilityChecker findAutoDetectVisibility(AnnotatedClass ac, VisibilityChecker checker) {
return checker;
}
/*
/**********************************************************
/* Annotations for Polymorphic type handling
/**********************************************************
*/
/**
* Method for checking if given class has annotations that indicate
* that specific type resolver is to be used for handling instances.
* This includes not only
* instantiating resolver builder, but also configuring it based on
* relevant annotations (not including ones checked with a call to
* {@link #findSubtypes}
*
* @param config Configuration settings in effect (for serialization or deserialization)
* @param ac Annotated class to check for annotations
* @param baseType Base java type of value for which resolver is to be found
*
* @return Type resolver builder for given type, if one found; null if none
*/
public TypeResolverBuilder findTypeResolver(MapperConfig config,
AnnotatedClass ac, JavaType baseType) {
return null;
}
/**
* Method for checking if given property entity (field or method) has annotations
* that indicate that specific type resolver is to be used for handling instances.
* This includes not only
* instantiating resolver builder, but also configuring it based on
* relevant annotations (not including ones checked with a call to
* {@link #findSubtypes}
*
* @param config Configuration settings in effect (for serialization or deserialization)
* @param am Annotated member (field or method) to check for annotations
* @param baseType Base java type of property for which resolver is to be found
*
* @return Type resolver builder for properties of given entity, if one found;
* null if none
*/
public TypeResolverBuilder findPropertyTypeResolver(MapperConfig config,
AnnotatedMember am, JavaType baseType) {
return null;
}
/**
* Method for checking if given structured property entity (field or method that
* has nominal value of Map, Collection or array type) has annotations
* that indicate that specific type resolver is to be used for handling type
* information of contained values.
* This includes not only
* instantiating resolver builder, but also configuring it based on
* relevant annotations (not including ones checked with a call to
* {@link #findSubtypes}
*
* @param config Configuration settings in effect (for serialization or deserialization)
* @param am Annotated member (field or method) to check for annotations
* @param containerType Type of property for which resolver is to be found (must be a container type)
*
* @return Type resolver builder for values contained in properties of given entity,
* if one found; null if none
*/
public TypeResolverBuilder findPropertyContentTypeResolver(MapperConfig config,
AnnotatedMember am, JavaType containerType) {
return null;
}
/**
* Method for locating annotation-specified subtypes related to annotated
* entity (class, method, field). Note that this is only guaranteed to be
* a list of directly
* declared subtypes, no recursive processing is guarantees (i.e. caller
* has to do it if/as necessary)
*
* @param a Annotated entity (class, field/method) to check for annotations
*/
public List
* Since 2.9 this method may also be called to find "default view(s)" for
* {@link AnnotatedClass}
*
* @param a Annotated property (represented by a method, field or ctor parameter)
* @return Array of views (represented by classes) that the property is included in;
* if null, always included (same as returning array containing
* Specific example (and initial use case is for support Kotlin's "is getter"
* matching (see
* Kotling Interop
* for details), in which field like '{@code isOpen}' would have implicit name of
* "isOpen", match getter {@code getOpen()} and setter {@code setOpen(boolean)},
* but use logical external name of "isOpen" (and not implicit name of getter/setter, "open"!).
* To achieve this, field implicit name needs to remain "isOpen" but this method needs
* to return name {@code PropertyName.construct("open")}: doing so will "pull in" getter
* and/or setter, and rename them as "isOpen".
*
* @param config Effective mapper configuration in use
* @param f Field to check
* @param implName Implicit name of the field; usually name of field itself but not always,
* used as the target name for accessors to rename.
*
* @return Name used to find other accessors to rename, if any; {@code null} to indicate
* no renaming
*
* @since 2.11
*/
public PropertyName findRenameByField(MapperConfig config,
AnnotatedField f, PropertyName implName) {
return null;
}
/**
* @deprecated Since 2.9 Use {@link #findInjectableValue} instead
*/
@Deprecated // since 2.9
public Object findInjectableValueId(AnnotatedMember m) {
return null;
}
/*
/**********************************************************
/* Serialization: general annotations
/**********************************************************
*/
/**
* Method for getting a serializer definition on specified method
* or field. Type of definition is either instance (of type {@link JsonSerializer})
* or Class (of {@code Class
* This feature is typically used to convert internal values into types
* that Jackson can convert.
*
* Note also that this feature does not necessarily work well with polymorphic
* type handling, or object identity handling; if such features are needed
* an explicit serializer is usually better way to handle serialization.
*
* @param a Annotated property (field, method) or class to check for
* annotations
*
* @since 2.2
*/
public Object findSerializationConverter(Annotated a) {
return null;
}
/**
* Method for finding {@link 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).
*
* If not null, either has to be actual
* {@link Converter} instance, or class for such converter;
* and resulting converter will be used first to convert property
* value to converter target type, and then serializer for that
* type is used for actual serialization.
*
* Other notes are same as those for {@link #findSerializationConverter}
*
* @param a Annotated property (field, method) to check.
*
* @since 2.2
*/
public Object findSerializationContentConverter(AnnotatedMember a) {
return null;
}
/**
* Method for checking inclusion criteria for a type (Class) or property (yes, method
* name is bit unfortunate -- not just for properties!).
* In case of class, acts as the default for properties POJO contains; for properties
* acts as override for class defaults and possible global defaults.
*
* @since 2.6
*/
public JsonInclude.Value findPropertyInclusion(Annotated a) {
return JsonInclude.Value.empty();
}
/**
* Method for checking whether given annotated entity (class, method,
* field) defines which Bean/Map properties are to be included in
* serialization.
* If no annotation is found, method should return given second
* argument; otherwise value indicated by the annotation.
*
* Note that meaning of inclusion value depends on whether it is for
* a Class or property (field/method/constructor): in former case,
* it is the default for all properties; in latter case it is specific
* override for annotated property.
*
* @return Enumerated value indicating which properties to include
* in serialization
*
* @deprecated Since 2.7 Use {@link #findPropertyInclusion} instead
*/
@Deprecated // since 2.7
public JsonInclude.Include findSerializationInclusion(Annotated a, JsonInclude.Include defValue) {
return defValue;
}
/**
* Method for checking whether content (entries) of a {@link java.util.Map} property
* are to be included during serialization or not.
* NOTE: this is NOT called for POJO properties, or array/Collection elements.
*
* @since 2.5
*
* @deprecated Since 2.7 Use {@link #findPropertyInclusion} instead
*/
@Deprecated // since 2.7
public JsonInclude.Include findSerializationInclusionForContent(Annotated a, JsonInclude.Include defValue) {
return defValue;
}
/*
/**********************************************************
/* Serialization: type refinements
/**********************************************************
*/
/**
* 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.
*
* @since 2.7
*/
public JavaType refineSerializationType(final MapperConfig config,
final Annotated a, final JavaType baseType) throws JsonMappingException
{
return baseType;
}
/**
* @deprecated Since 2.7 call {@link #refineSerializationType} instead
*/
@Deprecated // since 2.7
public Class findSerializationType(Annotated a) {
return null;
}
/**
* @deprecated Since 2.7 call {@link #refineSerializationType} instead
*/
@Deprecated // since 2.7
public Class findSerializationKeyType(Annotated am, JavaType baseType) {
return null;
}
/**
* @deprecated Since 2.7 call {@link #refineSerializationType} instead
*/
@Deprecated // since 2.7
public Class findSerializationContentType(Annotated am, JavaType baseType) {
return null;
}
/*
/**********************************************************
/* Serialization: class annotations
/**********************************************************
*/
/**
* Method for accessing defined property serialization order (which may be
* partial). May return null if no ordering is defined.
*/
public String[] findSerializationPropertyOrder(AnnotatedClass ac) {
return null;
}
/**
* Method for checking whether an annotation indicates that serialized properties
* for which no explicit is defined should be alphabetically (lexicograpically)
* ordered
*/
public Boolean findSerializationSortAlphabetically(Annotated ann) {
return null;
}
/**
* Method for adding possible virtual properties to be serialized along
* with regular properties.
*
* @since 2.5
*/
public void findAndAddVirtualProperties(MapperConfig config, AnnotatedClass ac,
List
* This feature is typically used to convert intermediate Jackson types
* (that default deserializers can produce) into custom type instances.
*
* Note also that this feature does not necessarily work well with polymorphic
* type handling, or object identity handling; if such features are needed
* an explicit deserializer is usually better way to handle deserialization.
*
* @param a Annotated property (field, method) or class to check for
* annotations
*
* @since 2.2
*/
public Object findDeserializationConverter(Annotated a) {
return null;
}
/**
* Method for finding {@link 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).
*
* If not null, either has to be actual
* {@link Converter} instance, or class for such converter;
* and resulting converter will be used after Jackson has deserializer
* data into intermediate type (Converter input type), and Converter
* needs to convert this into its target type to be set as property value.
*
* Other notes are same as those for {@link #findDeserializationConverter}
*
* @param a Annotated property (field, method) to check.
*
* @since 2.2
*/
public Object findDeserializationContentConverter(AnnotatedMember a) {
return null;
}
/*
/**********************************************************
/* Deserialization: type refinements
/**********************************************************
*/
/**
* Method called to find out possible type refinements to use
* for deserialization.
*
* @since 2.7
*/
public JavaType refineDeserializationType(final MapperConfig config,
final Annotated a, final JavaType baseType) throws JsonMappingException
{
return baseType;
}
/**
* Method for accessing annotated type definition that a
* property can have, to be used as the type for deserialization
* instead of the static (declared) type.
* Type is usually narrowing conversion (i.e.subtype of declared type).
* Declared return type of the method is also considered acceptable.
*
* @param ann Annotated entity to introspect
* @param baseType Assumed type before considering annotations
*
* @return Class to use for deserialization instead of declared type
*
* @deprecated Since 2.7 call {@link #refineDeserializationType} instead
*/
@Deprecated
public Class findDeserializationType(Annotated ann, JavaType baseType) {
return null;
}
/**
* Method for accessing additional narrowing type definition that a
* method can have, to define more specific key type to use.
* It should be only be used with {@link java.util.Map} types.
*
* @param ann Annotated entity to introspect
* @param baseKeyType Assumed key type before considering annotations
*
* @return Class specifying more specific type to use instead of
* declared type, if annotation found; null if not
*
* @deprecated Since 2.7 call {@link #refineDeserializationType} instead
*/
@Deprecated
public Class findDeserializationKeyType(Annotated ann, JavaType baseKeyType) {
return null;
}
/**
* Method for accessing additional narrowing type definition that a
* method can have, to define more specific content type to use;
* content refers to Map values and Collection/array elements.
* It should be only be used with Map, Collection and array types.
*
* @param ann Annotated entity to introspect
* @param baseContentType Assumed content (value) type before considering annotations
*
* @return Class specifying more specific type to use instead of
* declared type, if annotation found; null if not
*
* @deprecated Since 2.7 call {@link #refineDeserializationType} instead
*/
@Deprecated
public Class findDeserializationContentType(Annotated ann, JavaType baseContentType) {
return null;
}
/*
/**********************************************************
/* Deserialization: class annotations
/**********************************************************
*/
/**
* Method getting {@link ValueInstantiator} to use for given
* type (class): return value can either be an instance of
* instantiator, or class of instantiator to create.
*
* @param ac Annotated class to introspect
*/
public Object findValueInstantiator(AnnotatedClass ac) {
return null;
}
/**
* 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).
*
* Note that unlike accessors for some helper Objects, this
* method does not allow returning instances: the reason is
* that builders have state, and a separate instance needs
* to be created for each deserialization call.
*
* @param ac Annotated class to introspect
*
* @since 2.0
*/
public Class findPOJOBuilder(AnnotatedClass ac) {
return null;
}
/**
* @param ac Annotated class to introspect
*
* @since 2.0
*/
public JsonPOJOBuilder.Value findPOJOBuilderConfig(AnnotatedClass ac) {
return null;
}
/*
/**********************************************************
/* Deserialization: property annotations
/**********************************************************
*/
/**
* Method for checking whether given property accessors (method,
* field) has an annotation that suggests property name to use
* for deserialization (reading JSON into POJOs).
* Should return null if no annotation
* is found; otherwise a non-null name (possibly
* {@link PropertyName#USE_DEFAULT}, which means "use default heuristics").
*
* @param ann Annotated entity to check
*
* @return Name to use if found; null if not.
*
* @since 2.1
*/
public PropertyName findNameForDeserialization(Annotated ann) {
return null;
}
/**
* 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.
*
* @param ann Annotated entity to check
*
* @return True if such annotation is found (and is not disabled),
* false otherwise
*
* @since 2.9
*/
public Boolean hasAnySetter(Annotated ann) {
return null;
}
/**
* Method for finding possible settings for property, given annotations
* on an accessor.
*
* @param ann Annotated entity to check
*
* @since 2.9
*/
public JsonSetter.Value findSetterInfo(Annotated ann) {
return JsonSetter.Value.empty();
}
/**
* Method for finding merge settings for property, if any.
*
* @param ann Annotated entity to check
*
* @since 2.9
*/
public Boolean findMergeInfo(Annotated ann) {
return null;
}
/**
* 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 {@link com.fasterxml.jackson.annotation.JsonCreator.Mode} to use.
*
* NOTE: caller needs to consider possibility of both `null` (no annotation found)
* and {@link com.fasterxml.jackson.annotation.JsonCreator.Mode#DISABLED} (annotation found,
* but disabled); latter is necessary as marker in case multiple introspectors are chained,
* as well as possibly as when using mix-in annotations.
*
* @param config Configuration settings in effect (for serialization or deserialization)
* @param ann Annotated accessor (usually constructor or static method) to check
*
* @since 2.9
*/
public JsonCreator.Mode findCreatorAnnotation(MapperConfig config, Annotated ann) {
// 13-Sep-2016, tatu: for backwards compatibility, implement using delegation
/// (remove from version AFTER 2.9)
if (hasCreatorAnnotation(ann)) {
JsonCreator.Mode mode = findCreatorBinding(ann);
if (mode == null) {
mode = JsonCreator.Mode.DEFAULT;
}
return mode;
}
return null;
}
/**
* Method for checking whether given annotated item (method, constructor)
* has an annotation
* that suggests that the method is a "creator" (aka factory)
* method to be used for construct new instances of deserialized
* values.
*
* @param ann Annotated entity to check
*
* @return True if such annotation is found (and is not disabled),
* false otherwise
*
* @deprecated Since 2.9 use {@link #findCreatorAnnotation} instead.
*/
@Deprecated
public boolean hasCreatorAnnotation(Annotated ann) {
return false;
}
/**
* Method for finding indication of creator binding mode for
* a creator (something for which {@link #hasCreatorAnnotation} returns
* true), for cases where there may be ambiguity (currently: single-argument
* creator with implicit but no explicit name for the argument).
*
* @param ann Annotated entity to check
*
* @since 2.5
* @deprecated Since 2.9 use {@link #findCreatorAnnotation} instead.
*/
@Deprecated
public JsonCreator.Mode findCreatorBinding(Annotated ann) {
return null;
}
/**
* @param am Annotated method to check
*
* @deprecated Since 2.9 use {@link #hasAnySetter} instead.
*
* @return {@code true} if "any-setter" annotation was found; {@code false} otherwise
*/
@Deprecated // since 2.9
public boolean hasAnySetterAnnotation(AnnotatedMethod am) {
return false;
}
/*
/**********************************************************
/* Overridable methods: may be used as low-level extension
/* points.
/**********************************************************
*/
/**
* Method that should be used by sub-classes for ALL
* annotation access;
* overridable so
* that sub-classes may, if they choose to, mangle actual access to
* block access ("hide" annotations) or perhaps change it.
*
* Default implementation is simply:
*
* Default implementation is simply:
*Object.class)
*/
public Class[] findViews(Annotated a) { return null; }
/**
* Method for finding format annotations for property or class.
* Return value is typically used by serializers and/or
* deserializers to customize presentation aspects of the
* serialized value.
*
* @since 2.1
*/
public JsonFormat.Value findFormat(Annotated memberOrClass) {
return JsonFormat.Value.empty();
}
/**
* 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.
* Note that not all serializers and deserializers support use this method:
* currently (2.1) it is only used by XML-backed handlers.
*
* @return Wrapper name to use, if any, or {@link PropertyName#USE_DEFAULT}
* to indicate that no wrapper element should be used.
*
* @since 2.1
*/
public PropertyName findWrapperName(Annotated ann) { return null; }
/**
* Method for finding suggested default value (as simple textual serialization)
* for the property. While core databind does not make any use of it, it is exposed
* for extension modules to use: an expected use is generation of schema representations
* and documentation.
*
* @since 2.5
*/
public String findPropertyDefaultValue(Annotated ann) { return null; }
/**
* Method used to check whether specified property member (accessor
* or mutator) defines human-readable description to use for documentation.
* There are no further definitions for contents; for example, whether
* these may be marked up using HTML is not defined.
*
* @return Human-readable description, if any.
*
* @since 2.3
*/
public String findPropertyDescription(Annotated ann) { return null; }
/**
* Method used to check whether specified property member (accessor
* or mutator) defines numeric index, and if so, what is the index value.
* Possible use cases for index values included use by underlying data format
* (some binary formats mandate use of index instead of name) and ordering
* of properties (for documentation, or during serialization).
*
* @since 2.4
*
* @return Explicitly specified index for the property, if any
*/
public Integer findPropertyIndex(Annotated ann) { return null; }
/**
* Method for finding implicit name for a property that given annotated
* member (field, method, creator parameter) may represent.
* This is different from explicit, annotation-based property name, in that
* it is "weak" and does not either proof that a property exists (for example,
* if visibility is not high enough), or override explicit names.
* In practice this method is used to introspect optional names for creator
* parameters (which may or may not be available and cannot be detected
* by standard databind); or to provide alternate name mangling for
* fields, getters and/or setters.
*
* @since 2.4
*/
public String findImplicitPropertyName(AnnotatedMember member) { return null; }
/**
* Method called to find if given property has alias(es) defined.
*
* @return `null` if member has no information; otherwise a `List` (possibly
* empty) of aliases to use.
*
* @since 2.9
*/
public ListCollection, array or {@code Map} property.
* Type of definition is either instance (of type {@link JsonSerializer})
* or Class (of type {@code ClassEnum values
* have explicitly defined name. Method will overwrite entries in incoming names
* array with explicit names found, if any, leaving other entries unmodified.
*
* @param enumType Type of Enumeration
* @param enumValues Values of enumeration
* @param names Matching declared names of enumeration values (with indexes
* matching {@code enumValues} entries)
*
* @return Array of names to use (possible {@code names} passed as argument)
*
* @since 2.7
*/
public String[] findEnumValues(Class enumType, Enum[] enumValues, String[] names) {
// 18-Oct-2016, tatu: In 2.8 delegated to deprecated method; not so in 2.9 and beyond
return names;
}
/**
* Method that is related to {@link #findEnumValues} but is called to check if
* there are alternative names (aliased) that can be accepted for entries, in
* addition to primary names introspected earlier.
* If so, these aliases should be returned in {@code aliases} {@link List} passed
* as argument (and initialized for proper size by caller).
*
* @param enumType Type of Enumeration
* @param enumValues Values of enumeration
* @param aliases (in/out) Pre-allocated array where aliases found, if any, may be
* added (in indexes matching those of {@code enumValues})
*
* @since 2.11
*/
public void findEnumAliases(Class enumType, Enum[] enumValues, String[][] aliases) {
;
}
/**
* Finds the Enum value that should be considered the default value, if possible.
*
* @param enumCls The Enum class to scan for the default value
*
* @return null if none found or it's not possible to determine one
*
* @since 2.8
*/
public Enum findDefaultEnumValue(Classenum.name
* without indicating whether that is explicit or not), and is inefficient to
* call one-by-one.
*/
@Deprecated
public String findEnumValue(Enum value) {
return value.name();
}
/**
* @param am Annotated method to check
*
* @deprecated Since 2.9 Use {@link #hasAsValue(Annotated)} instead.
*/
@Deprecated // since 2.9
public boolean hasAsValueAnnotation(AnnotatedMethod am) {
return false;
}
/**
* @param am Annotated method to check
*
* @deprecated Since 2.9 Use {@link #hasAnyGetter} instead
*/
@Deprecated
public boolean hasAnyGetterAnnotation(AnnotatedMethod am) {
return false;
}
/*
/**********************************************************
/* Deserialization: general annotations
/**********************************************************
*/
/**
* Method for getting a deserializer definition on specified method
* or field.
* Type of definition is either instance (of type {@link JsonDeserializer})
* or Class (of type {@code Class&Map property.
* Type of definition is either instance (of type {@link JsonDeserializer})
* or Class (of type {@code ClassCollection, array or
* Map property.
* Type of definition is either instance (of type {@link JsonDeserializer})
* or Class (of type {@code Class
* return annotated.getAnnotation(annoClass);
*
*
* @param ann Annotated entity to check for specified annotation
* @param annoClass Type of annotation to find
*
* @return Value of given annotation (as per {@code annoClass}), if entity
* has one; {@code null} otherwise
*
* @since 2.5
*/
protected A _findAnnotation(Annotated ann,
Class annoClass) {
return ann.getAnnotation(annoClass);
}
/**
* Method that should be used by sub-classes for ALL
* annotation existence access;
* overridable so that sub-classes may, if they choose to, mangle actual access to
* block access ("hide" annotations) or perhaps change value seen.
*
* return annotated.hasAnnotation(annoClass);
*
*
* @param ann Annotated entity to check for specified annotation
* @param annoClass Type of annotation to find
*
* @return {@code true} if specified annotation exists in given entity; {@code false} if not
*
* @since 2.5
*/
protected boolean _hasAnnotation(Annotated ann, Class annoClass) {
return ann.hasAnnotation(annoClass);
}
/**
* Alternative lookup method that is used to see if annotation has at least one of
* annotations of types listed in second argument.
*
* @param ann Annotated entity to check for specified annotation
* @param annoClasses Types of annotation to find
*
* @return {@code true} if at least one of specified annotation exists in given entity;
* {@code false} otherwise
*
* @since 2.7
*/
protected boolean _hasOneOf(Annotated ann, Class[] annoClasses) {
return ann.hasOneOf(annoClasses);
}
}