| Package | Description |
|---|---|
| org.codehaus.jackson.map |
Contains basic mapper (conversion) functionality that
allows for converting between regular streaming json content and
Java objects (beans or Tree Model: support for both is via
ObjectMapper class, as well
as convenience methods included in
JsonParser |
| org.codehaus.jackson.map.deser |
Contains implementation classes of deserialization part of
data binding.
|
| org.codehaus.jackson.map.deser.std |
Contains public standard implementations of abstraction that
Jackson uses.
|
| org.codehaus.jackson.map.introspect |
Functionality needed for Bean introspection, required for detecting
accessors and mutators for Beans, as well as locating and handling
method annotations.
|
| org.codehaus.jackson.map.ser |
Contains implementation classes of serialization part of
data binding.
|
| org.codehaus.jackson.map.util |
Utility classes for Mapper package.
|
| org.codehaus.jackson.xc |
Package that contains XML Compatibility functionality for Jackson, such
as handlers for JAXB annotations
|
| Modifier and Type | Method and Description |
|---|---|
abstract AnnotatedMethod |
BeanDescription.findAnyGetter() |
abstract AnnotatedMethod |
BeanDescription.findAnySetter() |
abstract AnnotatedMethod |
BeanDescription.findJsonValueMethod() |
abstract AnnotatedMethod |
BeanPropertyDefinition.getGetter() |
abstract AnnotatedMethod |
BeanPropertyDefinition.getSetter() |
| Modifier and Type | Method and Description |
|---|---|
abstract LinkedHashMap<String,AnnotatedMethod> |
BeanDescription.findGetters(VisibilityChecker<?> visibilityChecker,
Collection<String> ignoredProperties)
Deprecated.
Since 1.9 use
BeanDescription.findProperties() |
abstract LinkedHashMap<String,AnnotatedMethod> |
BeanDescription.findSetters(VisibilityChecker<?> visibilityChecker)
Deprecated.
Since 1.9 use
BeanDescription.findProperties() |
| Modifier and Type | Method and Description |
|---|---|
abstract String |
AnnotationIntrospector.findGettablePropertyName(AnnotatedMethod am)
Method for checking whether given method has an annotation
that suggests property name associated with method that
may be a "getter".
|
String |
AnnotationIntrospector.Pair.findGettablePropertyName(AnnotatedMethod am) |
abstract String |
AnnotationIntrospector.findSettablePropertyName(AnnotatedMethod am)
Method for checking whether given method has an annotation
that suggests property name associated with method that
may be a "setter".
|
String |
AnnotationIntrospector.Pair.findSettablePropertyName(AnnotatedMethod am) |
boolean |
AnnotationIntrospector.hasAnyGetterAnnotation(AnnotatedMethod am)
Method for checking whether given method has an annotation
that suggests that the method is to serve as "any setter";
method to be used for accessing set of miscellaneous "extra"
properties, often bound with matching "any setter" method.
|
boolean |
AnnotationIntrospector.Pair.hasAnyGetterAnnotation(AnnotatedMethod am) |
boolean |
AnnotationIntrospector.hasAnySetterAnnotation(AnnotatedMethod am)
Method for checking whether given method has an annotation
that suggests that the method is to serve as "any setter";
method to be used for setting values of any properties for
which no dedicated setter method is found.
|
boolean |
AnnotationIntrospector.Pair.hasAnySetterAnnotation(AnnotatedMethod am) |
abstract boolean |
AnnotationIntrospector.hasAsValueAnnotation(AnnotatedMethod am)
Method for checking whether given method has an annotation
that suggests that the return value of annotated method
should be used as "the value" of the object instance; usually
serialized as a primitive value such as String or number.
|
boolean |
AnnotationIntrospector.Pair.hasAsValueAnnotation(AnnotatedMethod am) |
abstract boolean |
AnnotationIntrospector.isIgnorableMethod(AnnotatedMethod m)
Method for checking whether there is an annotation that
indicates that given method should be ignored for all
operations (serialization, deserialization).
|
boolean |
AnnotationIntrospector.Pair.isIgnorableMethod(AnnotatedMethod m) |
String |
PropertyNamingStrategy.nameForGetterMethod(MapperConfig<?> config,
AnnotatedMethod method,
String defaultName)
Method called to find external name (name used in JSON) for given logical
POJO property,
as defined by given getter method; typically called when building a serializer.
|
String |
PropertyNamingStrategy.PropertyNamingStrategyBase.nameForGetterMethod(MapperConfig<?> config,
AnnotatedMethod method,
String defaultName) |
String |
PropertyNamingStrategy.nameForSetterMethod(MapperConfig<?> config,
AnnotatedMethod method,
String defaultName)
Method called to find external name (name used in JSON) for given logical
POJO property,
as defined by given setter method; typically called when building a deserializer
(but not necessarily only then).
|
String |
PropertyNamingStrategy.PropertyNamingStrategyBase.nameForSetterMethod(MapperConfig<?> config,
AnnotatedMethod method,
String defaultName) |
| Modifier and Type | Field and Description |
|---|---|
protected AnnotatedMethod |
SettableBeanProperty.MethodProperty._annotated |
protected AnnotatedMethod |
SettableBeanProperty.SetterlessProperty._annotated |
| Modifier and Type | Method and Description |
|---|---|
protected boolean |
BeanDeserializerFactory._handleSingleArgumentFactory(DeserializationConfig config,
BasicBeanDescription beanDesc,
VisibilityChecker<?> vchecker,
AnnotationIntrospector intr,
CreatorCollector creators,
AnnotatedMethod factory,
boolean isCreator) |
protected SettableAnyProperty |
BeanDeserializerFactory.constructAnySetter(DeserializationConfig config,
BasicBeanDescription beanDesc,
AnnotatedMethod setter)
Method called to construct fallback
SettableAnyProperty
for handling unknown bean properties, given a method that
has been designated as such setter. |
protected SettableBeanProperty |
BeanDeserializerFactory.constructSettableProperty(DeserializationConfig config,
BasicBeanDescription beanDesc,
String name,
AnnotatedMethod setter)
Method that will construct a regular bean property setter using
the given setter method.
|
protected SettableBeanProperty |
BeanDeserializerFactory.constructSetterlessProperty(DeserializationConfig config,
BasicBeanDescription beanDesc,
String name,
AnnotatedMethod getter)
Method that will construct a regular bean property setter using
the given setter method.
|
| Constructor and Description |
|---|
SettableAnyProperty(BeanProperty property,
AnnotatedMethod setter,
JavaType type)
Deprecated.
Since 1.9 - use variant that takes deserializer
|
SettableAnyProperty(BeanProperty property,
AnnotatedMethod setter,
JavaType type,
JsonDeserializer<Object> valueDeser) |
SettableBeanProperty.MethodProperty(String name,
JavaType type,
TypeDeserializer typeDeser,
Annotations contextAnnotations,
AnnotatedMethod method) |
SettableBeanProperty.SetterlessProperty(String name,
JavaType type,
TypeDeserializer typeDeser,
Annotations contextAnnotations,
AnnotatedMethod method) |
| Modifier and Type | Method and Description |
|---|---|
static KeyDeserializer |
StdKeyDeserializers.constructEnumKeyDeserializer(EnumResolver<?> enumResolver,
AnnotatedMethod factory) |
static JsonDeserializer<?> |
EnumDeserializer.deserializerForCreator(DeserializationConfig config,
Class<?> enumClass,
AnnotatedMethod factory)
Factory method used when Enum instances are to be deserialized
using a creator (static factory method)
|
| Constructor and Description |
|---|
EnumDeserializer.FactoryBasedDeserializer(Class<?> cls,
AnnotatedMethod f,
Class<?> inputType) |
| Modifier and Type | Field and Description |
|---|---|
protected AnnotatedMethod |
BasicBeanDescription._anyGetterMethod |
protected AnnotatedMethod |
BasicBeanDescription._anySetterMethod |
protected AnnotatedMethod |
BasicBeanDescription._jsonValueMethod |
| Modifier and Type | Field and Description |
|---|---|
protected LinkedList<AnnotatedMethod> |
POJOPropertiesCollector._anyGetters |
protected LinkedList<AnnotatedMethod> |
POJOPropertiesCollector._anySetters |
protected List<AnnotatedMethod> |
AnnotatedClass._creatorMethods
Single argument static methods that might be usable
as factory methods
|
protected org.codehaus.jackson.map.introspect.POJOPropertyBuilder.Node<AnnotatedMethod> |
POJOPropertyBuilder._getters |
protected LinkedList<AnnotatedMethod> |
POJOPropertiesCollector._jsonValueGetters
Method(s) marked with 'JsonValue' annotation
|
protected LinkedHashMap<MemberKey,AnnotatedMethod> |
AnnotatedMethodMap._methods |
protected org.codehaus.jackson.map.introspect.POJOPropertyBuilder.Node<AnnotatedMethod> |
POJOPropertyBuilder._setters |
| Modifier and Type | Method and Description |
|---|---|
protected AnnotatedMethod |
AnnotatedClass._constructCreatorMethod(Method m) |
protected AnnotatedMethod |
AnnotatedClass._constructMethod(Method m) |
AnnotatedMethod |
AnnotatedMethodMap.find(Method m) |
AnnotatedMethod |
AnnotatedMethodMap.find(String name,
Class<?>[] paramTypes) |
AnnotatedMethod |
BasicBeanDescription.findAnyGetter()
Method used to locate the method of introspected class that
implements
JsonAnyGetter. |
AnnotatedMethod |
BasicBeanDescription.findAnySetter()
Method used to locate the method of introspected class that
implements
JsonAnySetter. |
AnnotatedMethod |
BasicBeanDescription.findJsonValueMethod()
Method for locating the getter method that is annotated with
JsonValue annotation,
if any. |
AnnotatedMethod |
BasicBeanDescription.findMethod(String name,
Class<?>[] paramTypes) |
AnnotatedMethod |
AnnotatedClass.findMethod(String name,
Class<?>[] paramTypes) |
AnnotatedMethod |
POJOPropertiesCollector.getAnyGetterMethod() |
AnnotatedMethod |
POJOPropertiesCollector.getAnySetterMethod() |
AnnotatedMethod |
POJOPropertyBuilder.getGetter() |
AnnotatedMethod |
POJOPropertiesCollector.getJsonValueMethod() |
AnnotatedMethod |
POJOPropertyBuilder.getSetter() |
AnnotatedMethod |
AnnotatedMethodMap.remove(AnnotatedMethod am)
Method called to remove specified method, assuming
it exists in the Map
|
AnnotatedMethod |
AnnotatedMethodMap.remove(Method m) |
AnnotatedMethod |
AnnotatedMethod.withAnnotations(AnnotationMap ann) |
AnnotatedMethod |
AnnotatedMethod.withMethod(Method m)
Method that constructs a new instance with settings (annotations, parameter annotations)
of this instance, but with different physical
Method. |
| Modifier and Type | Method and Description |
|---|---|
LinkedHashMap<String,AnnotatedMethod> |
BasicBeanDescription.findGetters(VisibilityChecker<?> visibilityChecker,
Collection<String> ignoredProperties) |
LinkedHashMap<String,AnnotatedMethod> |
BasicBeanDescription.findSetters(VisibilityChecker<?> visibilityChecker) |
List<AnnotatedMethod> |
BasicBeanDescription.getFactoryMethods() |
List<AnnotatedMethod> |
AnnotatedClass.getStaticMethods() |
Iterator<AnnotatedMethod> |
AnnotatedMethodMap.iterator() |
Iterable<AnnotatedMethod> |
AnnotatedClass.memberMethods() |
| Modifier and Type | Method and Description |
|---|---|
protected void |
AnnotatedClass._addMixOvers(Method mixin,
AnnotatedMethod target,
boolean addParamAnnotations) |
protected void |
AnnotatedClass._addMixUnders(Method src,
AnnotatedMethod target)
Method that will add annotations from specified source method to target method,
but only if target does not yet have them.
|
void |
AnnotatedMethodMap.add(AnnotatedMethod am)
Method called to add specified annotated method in the Map.
|
void |
POJOPropertyBuilder.addGetter(AnnotatedMethod a,
String ename,
boolean visible,
boolean ignored) |
void |
POJOPropertyBuilder.addSetter(AnnotatedMethod a,
String ename,
boolean visible,
boolean ignored) |
String |
NopAnnotationIntrospector.findGettablePropertyName(AnnotatedMethod am) |
String |
JacksonAnnotationIntrospector.findGettablePropertyName(AnnotatedMethod am) |
String |
NopAnnotationIntrospector.findSettablePropertyName(AnnotatedMethod am) |
String |
JacksonAnnotationIntrospector.findSettablePropertyName(AnnotatedMethod am) |
boolean |
JacksonAnnotationIntrospector.hasAnyGetterAnnotation(AnnotatedMethod am) |
boolean |
JacksonAnnotationIntrospector.hasAnySetterAnnotation(AnnotatedMethod am) |
boolean |
NopAnnotationIntrospector.hasAsValueAnnotation(AnnotatedMethod am) |
boolean |
JacksonAnnotationIntrospector.hasAsValueAnnotation(AnnotatedMethod am) |
protected boolean |
BasicBeanDescription.isFactoryMethod(AnnotatedMethod am) |
boolean |
VisibilityChecker.isGetterVisible(AnnotatedMethod m) |
boolean |
VisibilityChecker.Std.isGetterVisible(AnnotatedMethod m) |
boolean |
NopAnnotationIntrospector.isIgnorableMethod(AnnotatedMethod m) |
boolean |
JacksonAnnotationIntrospector.isIgnorableMethod(AnnotatedMethod m) |
boolean |
VisibilityChecker.isIsGetterVisible(AnnotatedMethod m) |
boolean |
VisibilityChecker.Std.isIsGetterVisible(AnnotatedMethod m) |
boolean |
VisibilityChecker.isSetterVisible(AnnotatedMethod m) |
boolean |
VisibilityChecker.Std.isSetterVisible(AnnotatedMethod m) |
AnnotatedMethod |
AnnotatedMethodMap.remove(AnnotatedMethod am)
Method called to remove specified method, assuming
it exists in the Map
|
| Constructor and Description |
|---|
AnyGetterWriter(AnnotatedMethod anyGetter,
MapSerializer serializer) |
| Modifier and Type | Method and Description |
|---|---|
protected static boolean |
BeanUtil.isCglibGetCallbacks(AnnotatedMethod am)
This method was added to address [JACKSON-53]: need to weed out
CGLib-injected "getCallbacks".
|
protected static boolean |
BeanUtil.isGroovyMetaClassGetter(AnnotatedMethod am)
Another helper method to deal with rest of [JACKSON-103]
|
protected static boolean |
BeanUtil.isGroovyMetaClassSetter(AnnotatedMethod am)
Similar to
BeanUtil.isCglibGetCallbacks(org.codehaus.jackson.map.introspect.AnnotatedMethod), need to suppress
a cyclic reference to resolve [JACKSON-103] |
static String |
BeanUtil.okNameForGetter(AnnotatedMethod am) |
static String |
BeanUtil.okNameForIsGetter(AnnotatedMethod am,
String name) |
static String |
BeanUtil.okNameForRegularGetter(AnnotatedMethod am,
String name) |
static String |
BeanUtil.okNameForSetter(AnnotatedMethod am) |
| Modifier and Type | Method and Description |
|---|---|
String |
JaxbAnnotationIntrospector.findGettablePropertyName(AnnotatedMethod am) |
String |
JaxbAnnotationIntrospector.findSettablePropertyName(AnnotatedMethod am) |
boolean |
JaxbAnnotationIntrospector.hasAnySetterAnnotation(AnnotatedMethod am) |
boolean |
JaxbAnnotationIntrospector.hasAsValueAnnotation(AnnotatedMethod am) |
boolean |
JaxbAnnotationIntrospector.isIgnorableMethod(AnnotatedMethod m) |