|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Packages that use Annotated | |
---|---|
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.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.xc | Package that contains Xml Compatibility functionality for Jackson. |
Uses of Annotated in org.codehaus.jackson.map |
---|
Methods in org.codehaus.jackson.map with parameters of type Annotated | |
---|---|
abstract Class<? extends JsonDeserializer<?>> |
AnnotationIntrospector.findContentDeserializer(Annotated am)
Method for getting a deserializer definition for content (values) of associated Collection , array or
Map property. |
Class<? extends JsonDeserializer<?>> |
AnnotationIntrospector.Pair.findContentDeserializer(Annotated am)
|
abstract Class<?> |
AnnotationIntrospector.findDeserializationContentType(Annotated am)
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. |
Class<?> |
AnnotationIntrospector.Pair.findDeserializationContentType(Annotated am)
|
abstract Class<?> |
AnnotationIntrospector.findDeserializationKeyType(Annotated am)
Method for accessing additional narrowing type definition that a method can have, to define more specific key type to use. |
Class<?> |
AnnotationIntrospector.Pair.findDeserializationKeyType(Annotated am)
|
abstract Class<?> |
AnnotationIntrospector.findDeserializationType(Annotated am)
Method for accessing annotated type definition that a method can have, to be used as the type for serialization instead of the runtime type. |
Class<?> |
AnnotationIntrospector.Pair.findDeserializationType(Annotated am)
|
abstract Object |
AnnotationIntrospector.findDeserializer(Annotated am)
Method for getting a deserializer definition on specified method or field. |
Object |
AnnotationIntrospector.Pair.findDeserializer(Annotated am)
|
abstract Class<? extends KeyDeserializer> |
AnnotationIntrospector.findKeyDeserializer(Annotated am)
Method for getting a deserializer definition for keys of associated Map property. |
Class<? extends KeyDeserializer> |
AnnotationIntrospector.Pair.findKeyDeserializer(Annotated am)
|
abstract String |
AnnotationIntrospector.findNamespace(Annotated ann)
Method that can be called to figure out generic namespace property for an annotated object. |
String |
AnnotationIntrospector.Pair.findNamespace(Annotated ann)
Combination logic is such that if the primary returns non-null non-empty namespace, that is returned. |
abstract JsonSerialize.Inclusion |
AnnotationIntrospector.findSerializationInclusion(Annotated a,
JsonSerialize.Inclusion defValue)
Method for checking whether given annotated entity (class, method, field) defines which Bean/Map properties are to be included in serialization. |
JsonSerialize.Inclusion |
AnnotationIntrospector.Pair.findSerializationInclusion(Annotated a,
JsonSerialize.Inclusion defValue)
|
abstract Class<?> |
AnnotationIntrospector.findSerializationType(Annotated a)
Method for accessing annotated type definition that a method/field can have, to be used as the type for serialization instead of the runtime type. |
Class<?> |
AnnotationIntrospector.Pair.findSerializationType(Annotated a)
|
abstract JsonSerialize.Typing |
AnnotationIntrospector.findSerializationTyping(Annotated a)
Method for accessing declared typing mode annotated (if any). |
JsonSerialize.Typing |
AnnotationIntrospector.Pair.findSerializationTyping(Annotated a)
|
abstract Class<?>[] |
AnnotationIntrospector.findSerializationViews(Annotated a)
Method for checking if annotated serializable property (represented by field or getter method) has definitions for views it is to be included in. |
Class<?>[] |
AnnotationIntrospector.Pair.findSerializationViews(Annotated a)
|
abstract Object |
AnnotationIntrospector.findSerializer(Annotated am)
Method for getting a serializer definition on specified method or field. |
Object |
AnnotationIntrospector.Pair.findSerializer(Annotated am)
|
abstract boolean |
AnnotationIntrospector.hasCreatorAnnotation(Annotated a)
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. |
boolean |
AnnotationIntrospector.Pair.hasCreatorAnnotation(Annotated a)
|
Uses of Annotated in org.codehaus.jackson.map.deser |
---|
Methods in org.codehaus.jackson.map.deser with parameters of type Annotated | ||
---|---|---|
protected JsonDeserializer<Object> |
BasicDeserializerFactory.findDeserializerFromAnnotation(DeserializationConfig config,
Annotated a)
Helper method called to check if a class or method has annotation that tells which class to use for deserialization. |
|
protected
|
BasicDeserializerFactory.modifyTypeByAnnotation(DeserializationConfig config,
Annotated a,
T type)
Method called to see if given method has annotations that indicate a more specific type than what the argument specifies. |
|
protected JavaType |
BasicDeserializerFactory.resolveType(DeserializationConfig config,
BasicBeanDescription beanDesc,
Type rawType,
Annotated a)
Helper method used to resolve method return types and field types. |
Uses of Annotated in org.codehaus.jackson.map.introspect |
---|
Subclasses of Annotated in org.codehaus.jackson.map.introspect | |
---|---|
class |
AnnotatedClass
|
class |
AnnotatedConstructor
|
class |
AnnotatedField
|
class |
AnnotatedMethod
|
class |
AnnotatedParameter
Object that represents method parameters, mostly so that associated annotations can be processed conveniently. |
class |
AnnotatedWithParams
Intermediate base class that encapsulates features that constructors and methods share. |
Uses of Annotated in org.codehaus.jackson.map.ser |
---|
Methods in org.codehaus.jackson.map.ser with parameters of type Annotated | |
---|---|
protected BeanPropertyWriter |
PropertyBuilder._buildProperty(String name,
JsonSerializer<Object> ser,
boolean defaultUseStaticTyping,
Annotated a,
Method m,
Field f)
|
protected Class<?> |
PropertyBuilder.findSerializationType(Annotated a,
boolean useStaticTyping)
|
protected JsonSerializer<Object> |
BasicSerializerFactory.findSerializerFromAnnotation(SerializationConfig config,
Annotated a)
Helper method called to check if a class or method has an annotation (@link org.codehaus.jackson.map.ser.JsonSerialize#using) that tells the class to use for serialization. |
Uses of Annotated in org.codehaus.jackson.xc |
---|
Methods in org.codehaus.jackson.xc with parameters of type Annotated | ||
---|---|---|
protected XmlAccessType |
JaxbAnnotationIntrospector.findAccessType(Annotated ac)
Method for locating JAXB XmlAccessType annotation value
for given annotated entity, if it has one, or inherits one from
its ancestors (in JAXB sense, package etc). |
|
protected XmlAdapter<Object,Object> |
JaxbAnnotationIntrospector.findAdapter(Annotated am)
Finds the XmlAdapter for the specified annotation. |
|
protected
|
JaxbAnnotationIntrospector.findAnnotation(Class<A> annotationClass,
Annotated annotated,
boolean includePackage,
boolean includeClass,
boolean includeSuperclasses)
Finds an annotation. |
|
Class<JsonDeserializer<?>> |
JaxbAnnotationIntrospector.findContentDeserializer(Annotated am)
|
|
Class<?> |
JaxbAnnotationIntrospector.findDeserializationContentType(Annotated am)
|
|
Class<?> |
JaxbAnnotationIntrospector.findDeserializationKeyType(Annotated am)
|
|
Class<?> |
JaxbAnnotationIntrospector.findDeserializationType(Annotated am)
|
|
JsonDeserializer<?> |
JaxbAnnotationIntrospector.findDeserializer(Annotated am)
|
|
Class<KeyDeserializer> |
JaxbAnnotationIntrospector.findKeyDeserializer(Annotated am)
|
|
String |
JaxbAnnotationIntrospector.findNamespace(Annotated ann)
|
|
JsonSerialize.Inclusion |
JaxbAnnotationIntrospector.findSerializationInclusion(Annotated a,
JsonSerialize.Inclusion defValue)
By default only non-null properties are written (per the JAXB spec.) |
|
Class<?> |
JaxbAnnotationIntrospector.findSerializationType(Annotated a)
|
|
JsonSerialize.Typing |
JaxbAnnotationIntrospector.findSerializationTyping(Annotated a)
|
|
Class<?>[] |
JaxbAnnotationIntrospector.findSerializationViews(Annotated a)
|
|
JsonSerializer<?> |
JaxbAnnotationIntrospector.findSerializer(Annotated am)
|
|
boolean |
JaxbAnnotationIntrospector.hasCreatorAnnotation(Annotated am)
|
|
protected boolean |
JaxbAnnotationIntrospector.isFieldsAccessible(Annotated ac)
Whether fields are accessible to this class. |
|
protected boolean |
JaxbAnnotationIntrospector.isPropertiesAccessible(Annotated ac)
Whether properties are accessible to this class. |
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |