com.fasterxml.jackson.databind.introspect

## Class DefaultAccessorNamingStrategy

- java.lang.Object
- - com.fasterxml.jackson.databind.introspect.AccessorNamingStrategy
  - - com.fasterxml.jackson.databind.introspect.DefaultAccessorNamingStrategy

Direct Known Subclasses:
  DefaultAccessorNamingStrategy.RecordNaming

    public class DefaultAccessorNamingStrategy
    extends AccessorNamingStrategy

Default `AccessorNamingStrategy` used by Jackson: to be used either as-is, or as base-class with overrides.

Since:
  2.12

### Nested Class Summary

Nested Classes
`static interface` `DefaultAccessorNamingStrategy.BaseNameValidator` Definition of a handler API to use for checking whether given base name (remainder of accessor method name after removing prefix) is acceptable based on various rules.
`static class` `DefaultAccessorNamingStrategy.FirstCharBasedValidator` Simple implementation of `DefaultAccessorNamingStrategy.BaseNameValidator` that checks the first character and nothing else.
`static class` `DefaultAccessorNamingStrategy.Provider` Provider for `DefaultAccessorNamingStrategy`.
`static class` `DefaultAccessorNamingStrategy.RecordNaming` Implementation used for supporting "non-prefix" naming convention of Java 14 `java.lang.Record` types, and in particular find default accessors for declared record fields.

### Nested classes/interfaces inherited from class com.fasterxml.jackson.databind.introspect.AccessorNamingStrategy

`AccessorNamingStrategy.Base`

### Field Summary

Fields
`protected DefaultAccessorNamingStrategy.BaseNameValidator` `_baseNameValidator` Optional validator for checking that base name
`protected MapperConfig<?>` `_config`
`protected AnnotatedClass` `_forClass`
`protected String` `_getterPrefix`
`protected String` `_isGetterPrefix`
`protected boolean` `_isGettersNonBoolean`
`protected String` `_mutatorPrefix` Prefix used by auto-detected mutators ("setters"): usually "set", but differs for builder objects ("with" by default).
`protected boolean` `_stdBeanNaming`

### Constructor Summary

Constructors
`protected` `DefaultAccessorNamingStrategy(MapperConfig<?> config, AnnotatedClass forClass, String mutatorPrefix, String getterPrefix, String isGetterPrefix, DefaultAccessorNamingStrategy.BaseNameValidator baseNameValidator)`

### Method Summary

All Methods Instance Methods Concrete Methods
`protected boolean` `_isCglibGetCallbacks(AnnotatedMethod am)`
`protected boolean` `_isGroovyMetaClassGetter(AnnotatedMethod am)`

`String`

`findNameForIsGetter(AnnotatedMethod am, String name)`
Method called to find whether given method would be considered an "is-getter" getter method in context of type introspected, and if so, what is the logical property it is associated with (which in turn suggest external name for property) Note that signature acceptability has already been checked (no arguments, has return value) but NOT the specific limitation that return type should be of boolean type -- implementation should apply latter check, if so desired (some languages may use different criteria).

`String`

`findNameForMutator(AnnotatedMethod am, String name)`
Method called to find whether given method would be considered a "mutator" (usually setter, but for builders "with-method" or similar) in context of type introspected, and if so, what is the logical property it is associated with (which in turn suggest external name for property) Note that signature acceptability has already been checked (exactly one parameter) by caller.

`String`

`findNameForRegularGetter(AnnotatedMethod am, String name)`
Method called to find whether given method would be considered a "regular" getter method in context of type introspected, and if so, what is the logical property it is associated with (which in turn suggest external name for property) Note that signature acceptability has already been checked (no arguments, does have a return value) by caller.

`protected String` `legacyManglePropertyName(String basename, int offset)` Method called to figure out name of the property, given corresponding suggested name based on a method or field name.
`String` `modifyFieldName(AnnotatedField field, String name)` Method called to find the name of logical property that given field should be associated with, if any.
`protected String` `stdManglePropertyName(String basename, int offset)`

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

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

### Field Detail

#### _config

    protected final MapperConfig<?> _config

#### _forClass

    protected final AnnotatedClass _forClass

#### _baseNameValidator

    protected final DefaultAccessorNamingStrategy.BaseNameValidator _baseNameValidator

Optional validator for checking that base name

#### _stdBeanNaming

    protected final boolean _stdBeanNaming

#### _isGettersNonBoolean

    protected final boolean _isGettersNonBoolean

#### _getterPrefix

    protected final String _getterPrefix

#### _isGetterPrefix

    protected final String _isGetterPrefix

Since:
  2.14

#### _mutatorPrefix

    protected final String _mutatorPrefix

Prefix used by auto-detected mutators ("setters"): usually "set", but differs for builder objects ("with" by default).

### Constructor Detail

#### DefaultAccessorNamingStrategy

    protected DefaultAccessorNamingStrategy(MapperConfig<?> config,
                                            AnnotatedClass forClass,
                                            String mutatorPrefix,
                                            String getterPrefix,
                                            String isGetterPrefix,
                                            DefaultAccessorNamingStrategy.BaseNameValidator baseNameValidator)

### Method Detail

#### findNameForIsGetter

    public String findNameForIsGetter(AnnotatedMethod am,
                                      String name)

Description copied from class: `AccessorNamingStrategy`
Method called to find whether given method would be considered an "is-getter" getter method in context of type introspected, and if so, what is the logical property it is associated with (which in turn suggest external name for property)

Note that signature acceptability has already been checked (no arguments, has return value) but NOT the specific limitation that return type should be of boolean type -- implementation should apply latter check, if so desired (some languages may use different criteria). It is also possible that some implementations allow different return types than boolean types.

Note that visibility checks are applied separately; strategy does not need to be concerned with that aspect.

Specified by:
  `findNameForIsGetter` in class `AccessorNamingStrategy`
Parameters:
  `am` - Method to check
  `name` - Name to check (usually same as `AnnotatedMethod.getName()`
Returns:
  Implied property name for is-getter method, if match; `null` to indicate that the name does not conform to expected naming convention

#### findNameForRegularGetter

    public String findNameForRegularGetter(AnnotatedMethod am,
                                           String name)

Description copied from class: `AccessorNamingStrategy`
Method called to find whether given method would be considered a "regular" getter method in context of type introspected, and if so, what is the logical property it is associated with (which in turn suggest external name for property)

Note that signature acceptability has already been checked (no arguments, does have a return value) by caller.

Note that this method MAY be called for potential "is-getter" methods too (before `AccessorNamingStrategy.findNameForIsGetter(com.fasterxml.jackson.databind.introspect.AnnotatedMethod, java.lang.String)`)

Note that visibility checks are applied separately; strategy does not need to be concerned with that aspect.

Specified by:
  `findNameForRegularGetter` in class `AccessorNamingStrategy`
Parameters:
  `am` - Method to check
  `name` - Name to check (usually same as `AnnotatedMethod.getName()`
Returns:
  Implied property name for getter method, if match; `null` to indicate that the name does not conform to expected naming convention

#### findNameForMutator

    public String findNameForMutator(AnnotatedMethod am,
                                     String name)

Description copied from class: `AccessorNamingStrategy`
Method called to find whether given method would be considered a "mutator" (usually setter, but for builders "with-method" or similar) in context of type introspected, and if so, what is the logical property it is associated with (which in turn suggest external name for property)

Note that signature acceptability has already been checked (exactly one parameter) by caller.

Note that visibility checks are applied separately; strategy does not need to be concerned with that aspect.

Specified by:
  `findNameForMutator` in class `AccessorNamingStrategy`
Parameters:
  `am` - Method to check
  `name` - Name to check (usually same as `AnnotatedMethod.getName()`
Returns:
  Implied property name for mutator method, if match; `null` to indicate that the name does not conform to expected naming convention

#### modifyFieldName

    public String modifyFieldName(AnnotatedField field,
                                  String name)

Description copied from class: `AccessorNamingStrategy`
Method called to find the name of logical property that given field should be associated with, if any.

Note that visibility checks are applied separately; strategy does not need to be concerned with that aspect.

Specified by:
  `modifyFieldName` in class `AccessorNamingStrategy`
Parameters:
  `field` - Field to check
  `name` - Name to check (usually same as `AnnotatedField.getName()`
Returns:
  Implied property name matching given field (often field name as-is) or `null` to indicate that the name does not conform to expected naming convention (and will not be considered for property access)

#### legacyManglePropertyName

    protected String legacyManglePropertyName(String basename,
                                              int offset)

Method called to figure out name of the property, given corresponding suggested name based on a method or field name.

Parameters:
  `basename` - Name of accessor/mutator method, not including prefix ("get"/"is"/"set")

#### stdManglePropertyName

    protected String stdManglePropertyName(String basename,
                                           int offset)

#### _isCglibGetCallbacks

    protected boolean _isCglibGetCallbacks(AnnotatedMethod am)

#### _isGroovyMetaClassGetter

    protected boolean _isGroovyMetaClassGetter(AnnotatedMethod am)