| Package | Description | 
|---|---|
| com.fasterxml.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. | 
| com.fasterxml.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 ( 
com.fasterxml.jackson.databind). | 
| com.fasterxml.jackson.databind.deser | 
 Contains implementation classes of deserialization part of 
 data binding. 
 | 
| com.fasterxml.jackson.databind.deser.impl | 
 Contains those implementation classes of deserialization part of 
 data binding that are not considered part of public or semi-public
 interfaces. 
 | 
| com.fasterxml.jackson.databind.exc | |
| com.fasterxml.jackson.databind.ext | 
 Contains extended support for "external" packages: things that
may or may not be present in runtime environment, but that are
commonly enough used so that explicit support can be added. 
 | 
| com.fasterxml.jackson.databind.introspect | 
 Functionality needed for Bean introspection, required for detecting
 accessors and mutators for Beans, as well as locating and handling
 method annotations. 
 | 
| com.fasterxml.jackson.databind.ser | 
 Contains implementation classes of serialization part of 
 data binding. 
 | 
| com.fasterxml.jackson.databind.ser.impl | 
 Contains implementation classes of serialization part of 
 data binding. 
 | 
| com.fasterxml.jackson.databind.ser.std | |
| com.fasterxml.jackson.databind.util | 
 Utility classes for Mapper package. 
 | 
| Modifier and Type | Field and Description | 
|---|---|
protected PropertyName | 
BeanProperty.Std._name  | 
protected PropertyName | 
BeanProperty.Std._wrapperName  | 
static PropertyName | 
PropertyName.NO_NAME
Special placeholder value that indicates that there is no name associated. 
 | 
static PropertyName | 
PropertyName.USE_DEFAULT
Special placeholder value that indicates that name to use should be
 based on the standard heuristics. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
static PropertyName | 
PropertyName.construct(String simpleName)  | 
static PropertyName | 
PropertyName.construct(String simpleName,
         String ns)  | 
PropertyName | 
AnnotationIntrospector.findNameForDeserialization(Annotated a)
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(Annotated a)
Method for checking whether given property accessors (method,
 field) has an annotation that suggests property name to use
 for serialization. 
 | 
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(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. 
 | 
PropertyName | 
AnnotationIntrospector.findWrapperName(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. 
 | 
PropertyName | 
BeanProperty.getFullName()
Method for getting full name definition, including possible
 format-specific additional properties (such as namespace when
 using XML backend). 
 | 
PropertyName | 
BeanProperty.Std.getFullName()  | 
PropertyName | 
BeanProperty.Bogus.getFullName()  | 
PropertyName | 
BeanProperty.getWrapperName()
If property is indicated to be wrapped, name of
 wrapper element to use. 
 | 
PropertyName | 
BeanProperty.Std.getWrapperName()  | 
PropertyName | 
BeanProperty.Bogus.getWrapperName()  | 
PropertyName | 
PropertyName.internSimpleName()  | 
PropertyName | 
PropertyName.withNamespace(String ns)
Fluent factory method for constructing an instance with different
 namespace. 
 | 
PropertyName | 
PropertyName.withSimpleName(String simpleName)
Fluent factory method for constructing an instance with different
 simple name. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
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)  | 
List<PropertyName> | 
BeanProperty.Bogus.findAliases(MapperConfig<?> config)  | 
List<PropertyName> | 
AnnotationIntrospector.findPropertyAliases(Annotated ann)
Method called to find if given property has alias(es) defined. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
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. 
 | 
ObjectWriter | 
ObjectWriter.withRootName(PropertyName rootName)  | 
ObjectReader | 
ObjectReader.withRootName(PropertyName rootName)  | 
SerializationConfig | 
SerializationConfig.withRootName(PropertyName rootName)  | 
DeserializationConfig | 
DeserializationConfig.withRootName(PropertyName rootName)  | 
| Constructor and Description | 
|---|
Std(PropertyName name,
   JavaType type,
   PropertyName wrapperName,
   AnnotatedMember member,
   PropertyMetadata metadata)  | 
Std(PropertyName name,
   JavaType type,
   PropertyName wrapperName,
   Annotations contextAnnotations,
   AnnotatedMember member,
   PropertyMetadata metadata)
Deprecated. 
 
Since 2.9 
 | 
| Modifier and Type | Field and Description | 
|---|---|
protected PropertyName | 
MapperConfigBase._rootName
Explicitly defined root name to use, if any; if empty
 String, will disable root-name wrapping; if null, will
 use defaults 
 | 
| Modifier and Type | Method and Description | 
|---|---|
abstract PropertyName | 
MapperConfig.findRootName(Class<?> rawRootType)  | 
PropertyName | 
MapperConfigBase.findRootName(Class<?> rawRootType)  | 
abstract PropertyName | 
MapperConfig.findRootName(JavaType rootType)  | 
PropertyName | 
MapperConfigBase.findRootName(JavaType rootType)  | 
PropertyName | 
MapperConfigBase.getFullRootName()  | 
| Modifier and Type | Method and Description | 
|---|---|
abstract T | 
MapperConfigBase.withRootName(PropertyName rootName)
Method for constructing and returning a new instance with different
 root name to use (none, if null). 
 | 
| Constructor and Description | 
|---|
MapperConfigBase(MapperConfigBase<CFG,T> src,
                PropertyName rootName)  | 
| Modifier and Type | Field and Description | 
|---|---|
protected PropertyName | 
SettableBeanProperty._propName
Logical name of the property (often but not always derived
 from the setter method name) 
 | 
protected PropertyName | 
SettableBeanProperty._wrapperName  | 
protected static PropertyName | 
BeanDeserializerBase.TEMP_PROPERTY_NAME  | 
protected static PropertyName | 
BasicDeserializerFactory.UNWRAPPED_CREATOR_PARAM_NAME
We need a placeholder for creator properties that don't have name
 but are marked with `@JsonWrapped` annotation. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
PropertyName | 
SettableBeanProperty.getFullName()  | 
PropertyName | 
SettableBeanProperty.getWrapperName()  | 
| Modifier and Type | Method and Description | 
|---|---|
protected Map<String,List<PropertyName>> | 
BeanDeserializerBuilder._collectAliases(Collection<SettableBeanProperty> props)  | 
| Modifier and Type | Method and Description | 
|---|---|
void | 
BeanDeserializerBuilder.addInjectable(PropertyName propName,
             JavaType propType,
             Annotations contextAnnotations,
             AnnotatedMember member,
             Object valueId)  | 
protected SettableBeanProperty | 
BasicDeserializerFactory.constructCreatorProperty(DeserializationContext ctxt,
                        BeanDescription beanDesc,
                        PropertyName name,
                        int index,
                        AnnotatedParameter param,
                        JacksonInject.Value injectable)
Method that will construct a property object that represents
 a logical property passed via Creator (constructor or static
 factory method) 
 | 
SettableBeanProperty | 
BeanDeserializerBuilder.findProperty(PropertyName propertyName)  | 
SettableBeanProperty | 
BeanDeserializerBase.findProperty(PropertyName propertyName)  | 
boolean | 
BeanDeserializerBuilder.hasProperty(PropertyName propertyName)  | 
SettableBeanProperty | 
BeanDeserializerBuilder.removeProperty(PropertyName name)  | 
abstract SettableBeanProperty | 
SettableBeanProperty.withName(PropertyName newName)
Fluent factory method for constructing and returning a new instance
 with specified property name. 
 | 
SettableBeanProperty | 
SettableBeanProperty.Delegating.withName(PropertyName newName)  | 
SettableBeanProperty | 
CreatorProperty.withName(PropertyName newName)  | 
| Constructor and Description | 
|---|
CreatorProperty(CreatorProperty src,
               PropertyName newName)  | 
CreatorProperty(PropertyName name,
               JavaType type,
               PropertyName wrapperName,
               TypeDeserializer typeDeser,
               Annotations contextAnnotations,
               AnnotatedParameter param,
               int index,
               Object injectableValueId,
               PropertyMetadata metadata)  | 
SettableBeanProperty(PropertyName propName,
                    JavaType type,
                    PropertyMetadata metadata,
                    JsonDeserializer<Object> valueDeser)
Constructor only used by  
ObjectIdValueProperty. | 
SettableBeanProperty(PropertyName propName,
                    JavaType type,
                    PropertyName wrapper,
                    TypeDeserializer typeDeser,
                    Annotations contextAnnotations,
                    PropertyMetadata metadata)  | 
SettableBeanProperty(SettableBeanProperty src,
                    PropertyName newName)
Copy-with-deserializer-change constructor for sub-classes to use. 
 | 
| Modifier and Type | Field and Description | 
|---|---|
protected PropertyName | 
NullsFailProvider._name  | 
PropertyName | 
ObjectIdReader.propertyName  | 
| Modifier and Type | Method and Description | 
|---|---|
PropertyName | 
CreatorCandidate.explicitParamName(int i)  | 
PropertyName | 
CreatorCandidate.findImplicitParamName(int i)  | 
PropertyName | 
CreatorCandidate.Param.fullName()  | 
PropertyName | 
CreatorCandidate.paramName(int i)  | 
| Modifier and Type | Method and Description | 
|---|---|
static ObjectIdReader | 
ObjectIdReader.construct(JavaType idType,
         PropertyName propName,
         ObjectIdGenerator<?> generator,
         JsonDeserializer<?> deser,
         SettableBeanProperty idProp,
         ObjectIdResolver resolver)
Factory method called by  
BeanSerializerBase
 with the initial information based on standard settings for the type
 for which serializer is being built. | 
SettableBeanProperty | 
SetterlessProperty.withName(PropertyName newName)  | 
SettableBeanProperty | 
MethodProperty.withName(PropertyName newName)  | 
SettableBeanProperty | 
ObjectIdReferenceProperty.withName(PropertyName newName)  | 
SettableBeanProperty | 
FieldProperty.withName(PropertyName newName)  | 
SettableBeanProperty | 
ObjectIdValueProperty.withName(PropertyName newName)  | 
| Modifier and Type | Method and Description | 
|---|---|
static BeanPropertyMap | 
BeanPropertyMap.construct(Collection<SettableBeanProperty> props,
         boolean caseInsensitive,
         Map<String,List<PropertyName>> aliasMapping)
Deprecated. 
 
since 2.11 
 | 
static BeanPropertyMap | 
BeanPropertyMap.construct(MapperConfig<?> config,
         Collection<SettableBeanProperty> props,
         Map<String,List<PropertyName>> aliasMapping)  | 
| Constructor and Description | 
|---|
FieldProperty(FieldProperty src,
             PropertyName newName)  | 
MethodProperty(MethodProperty src,
              PropertyName newName)  | 
NullsFailProvider(PropertyName name,
                 JavaType type)  | 
ObjectIdReader(JavaType t,
              PropertyName propName,
              ObjectIdGenerator<?> gen,
              JsonDeserializer<?> deser,
              SettableBeanProperty idProp,
              ObjectIdResolver resolver)  | 
ObjectIdReferenceProperty(ObjectIdReferenceProperty src,
                         PropertyName newName)  | 
ObjectIdValueProperty(ObjectIdValueProperty src,
                     PropertyName newName)  | 
SetterlessProperty(SetterlessProperty src,
                  PropertyName newName)  | 
ValueInjector(PropertyName propName,
             JavaType type,
             AnnotatedMember mutator,
             Object valueId)  | 
ValueInjector(PropertyName propName,
             JavaType type,
             Annotations contextAnnotations,
             AnnotatedMember mutator,
             Object valueId)
Deprecated. 
 
in 2.9 (remove from 3.0) 
 | 
| Constructor and Description | 
|---|
BeanPropertyMap(boolean caseInsensitive,
               Collection<SettableBeanProperty> props,
               Map<String,List<PropertyName>> aliasDefs)
Deprecated. 
 
since 2.11 
 | 
BeanPropertyMap(boolean caseInsensitive,
               Collection<SettableBeanProperty> props,
               Map<String,List<PropertyName>> aliasDefs,
               Locale locale)  | 
| Modifier and Type | Field and Description | 
|---|---|
protected PropertyName | 
InvalidNullException._propertyName
Name of property, if known, for which null was encountered. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
PropertyName | 
InvalidNullException.getPropertyName()  | 
| Modifier and Type | Method and Description | 
|---|---|
static InvalidNullException | 
InvalidNullException.from(DeserializationContext ctxt,
    PropertyName name,
    JavaType type)  | 
| Constructor and Description | 
|---|
InvalidNullException(DeserializationContext ctxt,
                    String msg,
                    PropertyName pname)  | 
| Modifier and Type | Method and Description | 
|---|---|
PropertyName | 
Java7SupportImpl.findConstructorName(AnnotatedParameter p)  | 
abstract PropertyName | 
Java7Support.findConstructorName(AnnotatedParameter p)  | 
| Modifier and Type | Field and Description | 
|---|---|
protected PropertyName | 
POJOPropertyBuilder._internalName
Original internal name, derived from accessor, of this
 property. 
 | 
protected PropertyName | 
POJOPropertyBuilder._name
External name of logical property; may change with
 renaming (by new instance being constructed using
 a new name) 
 | 
protected PropertyName | 
ObjectIdInfo._propertyName  | 
PropertyName | 
POJOPropertyBuilder.Linked.name  | 
| Modifier and Type | Field and Description | 
|---|---|
protected List<PropertyName> | 
ConcreteBeanPropertyBase._aliases  | 
protected Map<PropertyName,PropertyName> | 
POJOPropertiesCollector._fieldRenameMappings
A set of "field renamings" that have been discovered, indicating
 intended renaming of other accesors: key is the implicit original
 name and value intended name to use instead. 
 | 
protected Map<PropertyName,PropertyName> | 
POJOPropertiesCollector._fieldRenameMappings
A set of "field renamings" that have been discovered, indicating
 intended renaming of other accesors: key is the implicit original
 name and value intended name to use instead. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
protected PropertyName | 
JacksonAnnotationIntrospector._findConstructorName(Annotated a)  | 
protected PropertyName | 
BasicBeanDescription._findCreatorPropertyName(AnnotatedParameter param)
Deprecated. 
 
since 2.8 
 | 
protected PropertyName | 
JacksonAnnotationIntrospector._propertyName(String localName,
             String namespace)  | 
PropertyName | 
JacksonAnnotationIntrospector.findNameForDeserialization(Annotated a)  | 
PropertyName | 
AnnotationIntrospectorPair.findNameForDeserialization(Annotated a)  | 
PropertyName | 
JacksonAnnotationIntrospector.findNameForSerialization(Annotated a)  | 
PropertyName | 
AnnotationIntrospectorPair.findNameForSerialization(Annotated a)  | 
PropertyName | 
JacksonAnnotationIntrospector.findRenameByField(MapperConfig<?> config,
                 AnnotatedField f,
                 PropertyName implName)  | 
PropertyName | 
AnnotationIntrospectorPair.findRenameByField(MapperConfig<?> config,
                 AnnotatedField f,
                 PropertyName implName)  | 
PropertyName | 
JacksonAnnotationIntrospector.findRootName(AnnotatedClass ac)  | 
PropertyName | 
AnnotationIntrospectorPair.findRootName(AnnotatedClass ac)  | 
PropertyName | 
AnnotationIntrospectorPair.findWrapperName(Annotated ann)  | 
PropertyName | 
POJOPropertyBuilder.getFullName()  | 
abstract PropertyName | 
BeanPropertyDefinition.getFullName()  | 
PropertyName | 
ObjectIdInfo.getPropertyName()  | 
PropertyName | 
POJOPropertyBuilder.getWrapperName()  | 
abstract PropertyName | 
BeanPropertyDefinition.getWrapperName()
Accessor for finding wrapper name to use for property (if any). 
 | 
| Modifier and Type | Method and Description | 
|---|---|
List<PropertyName> | 
ConcreteBeanPropertyBase.findAliases(MapperConfig<?> config)  | 
Set<PropertyName> | 
POJOPropertyBuilder.findExplicitNames()
Method called to find out set of explicit names for accessors
 bound together due to implicit name. 
 | 
List<PropertyName> | 
JacksonAnnotationIntrospector.findPropertyAliases(Annotated m)  | 
List<PropertyName> | 
AnnotationIntrospectorPair.findPropertyAliases(Annotated ann)  | 
| Modifier and Type | Method and Description | 
|---|---|
protected POJOPropertyBuilder | 
POJOPropertiesCollector._property(Map<String,POJOPropertyBuilder> props,
         PropertyName name)  | 
void | 
POJOPropertyBuilder.addCtor(AnnotatedParameter a,
       PropertyName name,
       boolean explName,
       boolean visible,
       boolean ignored)  | 
void | 
POJOPropertyBuilder.addField(AnnotatedField a,
        PropertyName name,
        boolean explName,
        boolean visible,
        boolean ignored)  | 
void | 
POJOPropertyBuilder.addGetter(AnnotatedMethod a,
         PropertyName name,
         boolean explName,
         boolean visible,
         boolean ignored)  | 
void | 
POJOPropertyBuilder.addSetter(AnnotatedMethod a,
         PropertyName name,
         boolean explName,
         boolean visible,
         boolean ignored)  | 
BeanPropertyDefinition | 
BasicBeanDescription.findProperty(PropertyName name)  | 
PropertyName | 
JacksonAnnotationIntrospector.findRenameByField(MapperConfig<?> config,
                 AnnotatedField f,
                 PropertyName implName)  | 
PropertyName | 
AnnotationIntrospectorPair.findRenameByField(MapperConfig<?> config,
                 AnnotatedField f,
                 PropertyName implName)  | 
boolean | 
POJOPropertyBuilder.hasName(PropertyName name)  | 
boolean | 
BeanPropertyDefinition.hasName(PropertyName name)  | 
boolean | 
BasicBeanDescription.hasProperty(PropertyName name)  | 
POJOPropertyBuilder | 
POJOPropertyBuilder.withName(PropertyName newName)  | 
abstract BeanPropertyDefinition | 
BeanPropertyDefinition.withName(PropertyName newName)
Method that can be used to create a definition with
 same settings as this one, but with different
 (external) name; that is, one for which
  
BeanPropertyDefinition.getName() would return newName. | 
| Modifier and Type | Method and Description | 
|---|---|
Collection<POJOPropertyBuilder> | 
POJOPropertyBuilder.explode(Collection<PropertyName> newNames)
Method called when a previous call to  
POJOPropertyBuilder.findExplicitNames() found
 multiple distinct explicit names, and the property this builder represents
 basically needs to be broken apart and replaced by a set of more than
 one properties. | 
| Constructor and Description | 
|---|
Linked(T v,
      POJOPropertyBuilder.Linked<T> n,
      PropertyName name,
      boolean explName,
      boolean visible,
      boolean ignored)  | 
ObjectIdInfo(PropertyName prop,
            Class<?> scope,
            Class<? extends ObjectIdGenerator<?>> gen,
            boolean alwaysAsId)  | 
ObjectIdInfo(PropertyName prop,
            Class<?> scope,
            Class<? extends ObjectIdGenerator<?>> gen,
            boolean alwaysAsId,
            Class<? extends ObjectIdResolver> resolver)  | 
ObjectIdInfo(PropertyName name,
            Class<?> scope,
            Class<? extends ObjectIdGenerator<?>> gen,
            Class<? extends ObjectIdResolver> resolver)  | 
POJOPropertyBuilder(MapperConfig<?> config,
                   AnnotationIntrospector ai,
                   boolean forSerialization,
                   PropertyName internalName)  | 
POJOPropertyBuilder(MapperConfig<?> config,
                   AnnotationIntrospector ai,
                   boolean forSerialization,
                   PropertyName internalName,
                   PropertyName name)  | 
POJOPropertyBuilder(POJOPropertyBuilder src,
                   PropertyName newName)  | 
| Modifier and Type | Field and Description | 
|---|---|
protected PropertyName | 
BeanPropertyWriter._wrapperName
Wrapper name to use for this element, if any 
 | 
| Modifier and Type | Method and Description | 
|---|---|
PropertyName | 
BeanPropertyWriter.getFullName()  | 
abstract PropertyName | 
PropertyWriter.getFullName()  | 
PropertyName | 
BeanPropertyWriter.getWrapperName()  | 
| Modifier and Type | Method and Description | 
|---|---|
protected BeanPropertyWriter | 
BeanPropertyWriter._new(PropertyName newName)
Overridable factory method used by sub-classes 
 | 
boolean | 
BeanPropertyWriter.wouldConflictWithName(PropertyName name)
Method called to check to see if this property has a name that would
 conflict with a given name. 
 | 
| Constructor and Description | 
|---|
BeanPropertyWriter(BeanPropertyWriter base,
                  PropertyName name)  | 
VirtualBeanPropertyWriter(VirtualBeanPropertyWriter base,
                         PropertyName name)  | 
| Modifier and Type | Method and Description | 
|---|---|
static ObjectIdWriter | 
ObjectIdWriter.construct(JavaType idType,
         PropertyName propName,
         ObjectIdGenerator<?> generator,
         boolean alwaysAsId)
Factory method called by  
BeanSerializerBase
 with the initial information based on standard settings for the type
 for which serializer is being built. | 
| Modifier and Type | Field and Description | 
|---|---|
protected static PropertyName | 
BeanSerializerBase.NAME_FOR_OBJECT_REF  | 
| Modifier and Type | Method and Description | 
|---|---|
PropertyName | 
MapProperty.getFullName()  | 
PropertyName | 
MapProperty.getWrapperName()  | 
| Modifier and Type | Field and Description | 
|---|---|
protected PropertyName | 
SimpleBeanPropertyDefinition._fullName  | 
| Modifier and Type | Field and Description | 
|---|---|
protected LRUMap<ClassKey,PropertyName> | 
RootNameLookup._rootNames
For efficient operation, let's try to minimize number of times we
 need to introspect root element name to use. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
PropertyName | 
RootNameLookup.findRootName(Class<?> rootType,
            MapperConfig<?> config)  | 
PropertyName | 
RootNameLookup.findRootName(JavaType rootType,
            MapperConfig<?> config)  | 
PropertyName | 
SimpleBeanPropertyDefinition.getFullName()  | 
PropertyName | 
SimpleBeanPropertyDefinition.getWrapperName()  | 
| Modifier and Type | Method and Description | 
|---|---|
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)  | 
boolean | 
SimpleBeanPropertyDefinition.hasName(PropertyName name)  | 
BeanPropertyDefinition | 
SimpleBeanPropertyDefinition.withName(PropertyName newName)  | 
| Constructor and Description | 
|---|
SimpleBeanPropertyDefinition(AnnotationIntrospector intr,
                            AnnotatedMember member,
                            PropertyName fullName,
                            PropertyMetadata metadata,
                            JsonInclude.Value inclusion)  | 
Copyright © 2008–2020 FasterXML. All rights reserved.