|
||||||||||
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.map.util | Utility classes for Mapper package. |
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,
JavaType baseContentType,
String propName)
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,
JavaType baseContentType,
String propName)
|
abstract Class<?> |
AnnotationIntrospector.findDeserializationKeyType(Annotated am,
JavaType baseKeyType,
String propName)
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,
JavaType baseKeyType,
String propName)
|
abstract Class<?> |
AnnotationIntrospector.findDeserializationType(Annotated am,
JavaType baseType,
String propName)
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,
JavaType baseType,
String propName)
|
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 List<NamedType> |
AnnotationIntrospector.findSubtypes(Annotated a)
Method for locating annotation-specified subtypes related to annotated entity (class, method, field). |
List<NamedType> |
AnnotationIntrospector.Pair.findSubtypes(Annotated a)
|
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,
String propName)
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
Object that represents non-static (and usually non-transient/volatile) fields of a class. |
class |
AnnotatedMember
Intermediate base class for annotated entities that are members of a class; fields, methods and constructors. |
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. |
Methods in org.codehaus.jackson.map.introspect with parameters of type Annotated | |
---|---|
protected boolean |
JacksonAnnotationIntrospector._isIgnorable(Annotated a)
|
Class<JsonDeserializer<?>> |
NopAnnotationIntrospector.findContentDeserializer(Annotated am)
|
Class<? extends JsonDeserializer<?>> |
JacksonAnnotationIntrospector.findContentDeserializer(Annotated a)
|
Class<?> |
NopAnnotationIntrospector.findDeserializationContentType(Annotated am,
JavaType t,
String propName)
|
Class<?> |
JacksonAnnotationIntrospector.findDeserializationContentType(Annotated am,
JavaType baseContentType,
String propName)
|
Class<?> |
NopAnnotationIntrospector.findDeserializationKeyType(Annotated am,
JavaType t,
String propName)
|
Class<?> |
JacksonAnnotationIntrospector.findDeserializationKeyType(Annotated am,
JavaType baseKeyType,
String propName)
|
Class<?> |
NopAnnotationIntrospector.findDeserializationType(Annotated am,
JavaType t,
String propName)
|
Class<?> |
JacksonAnnotationIntrospector.findDeserializationType(Annotated am,
JavaType baseType,
String propName)
|
Object |
NopAnnotationIntrospector.findDeserializer(Annotated am)
|
Class<? extends JsonDeserializer<?>> |
JacksonAnnotationIntrospector.findDeserializer(Annotated a)
|
Class<KeyDeserializer> |
NopAnnotationIntrospector.findKeyDeserializer(Annotated am)
|
Class<? extends KeyDeserializer> |
JacksonAnnotationIntrospector.findKeyDeserializer(Annotated a)
|
String |
NopAnnotationIntrospector.findNamespace(Annotated ann)
|
String |
JacksonAnnotationIntrospector.findNamespace(Annotated ann)
|
JsonSerialize.Inclusion |
NopAnnotationIntrospector.findSerializationInclusion(Annotated a,
JsonSerialize.Inclusion defValue)
|
JsonSerialize.Inclusion |
JacksonAnnotationIntrospector.findSerializationInclusion(Annotated a,
JsonSerialize.Inclusion defValue)
|
Class<?> |
NopAnnotationIntrospector.findSerializationType(Annotated a)
|
Class<?> |
JacksonAnnotationIntrospector.findSerializationType(Annotated am)
|
JsonSerialize.Typing |
NopAnnotationIntrospector.findSerializationTyping(Annotated a)
|
JsonSerialize.Typing |
JacksonAnnotationIntrospector.findSerializationTyping(Annotated a)
|
Class<?>[] |
NopAnnotationIntrospector.findSerializationViews(Annotated a)
|
Class<?>[] |
JacksonAnnotationIntrospector.findSerializationViews(Annotated a)
|
Object |
NopAnnotationIntrospector.findSerializer(Annotated am)
|
Class<? extends JsonSerializer<?>> |
JacksonAnnotationIntrospector.findSerializer(Annotated a)
|
List<NamedType> |
NopAnnotationIntrospector.findSubtypes(Annotated a)
|
List<NamedType> |
JacksonAnnotationIntrospector.findSubtypes(Annotated a)
|
boolean |
NopAnnotationIntrospector.hasCreatorAnnotation(Annotated a)
|
boolean |
JacksonAnnotationIntrospector.hasCreatorAnnotation(Annotated a)
|
protected String |
BasicBeanDescription.mangleGetterName(Annotated a,
String basename)
|
protected String |
BasicBeanDescription.mangleSetterName(Annotated a,
String basename)
|
Uses of Annotated in org.codehaus.jackson.map.ser |
---|
Methods in org.codehaus.jackson.map.ser with parameters of type Annotated | |
---|---|
protected JavaType |
PropertyBuilder.findSerializationType(Annotated a,
boolean useStaticTyping)
Method that will try to determine statically defined type of property being serialized, based on annotations (for overrides), and alternatively declared type (if static typing for serialization is enabled). |
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.map.util |
---|
Methods in org.codehaus.jackson.map.util with parameters of type Annotated | |
---|---|
static List<NamedType> |
SubTypeHelper.collectAndResolveSubtypes(Annotated base,
MapperConfig<?> config,
AnnotationIntrospector ai)
|
Uses of Annotated in org.codehaus.jackson.xc |
---|
Methods in org.codehaus.jackson.xc with parameters of type Annotated | ||
---|---|---|
protected Class<?> |
JaxbAnnotationIntrospector._doFindDeserializationType(Annotated a,
JavaType baseType,
String propName)
|
|
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 associated with given annotatable thing; or if not found, a default annotation it may have (from super class, package and so on) |
|
Class<JsonDeserializer<?>> |
JaxbAnnotationIntrospector.findContentDeserializer(Annotated am)
|
|
Class<?> |
JaxbAnnotationIntrospector.findDeserializationContentType(Annotated a,
JavaType baseContentType,
String propName)
|
|
Class<?> |
JaxbAnnotationIntrospector.findDeserializationKeyType(Annotated am,
JavaType baseKeyType,
String propName)
|
|
Class<?> |
JaxbAnnotationIntrospector.findDeserializationType(Annotated a,
JavaType baseType,
String propName)
JAXB does allow specifying (more) concrete class for deserialization by using \@XmlElement annotation. |
|
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)
Implementation of this method is slightly tricky, given that JAXB defaults differ from Jackson defaults. |
|
Class<?> |
JaxbAnnotationIntrospector.findSerializationType(Annotated a)
|
|
JsonSerialize.Typing |
JaxbAnnotationIntrospector.findSerializationTyping(Annotated a)
|
|
Class<?>[] |
JaxbAnnotationIntrospector.findSerializationViews(Annotated a)
|
|
JsonSerializer<?> |
JaxbAnnotationIntrospector.findSerializer(Annotated am)
|
|
List<NamedType> |
JaxbAnnotationIntrospector.findSubtypes(Annotated a)
|
|
boolean |
JaxbAnnotationIntrospector.hasCreatorAnnotation(Annotated am)
|
|
protected boolean |
JaxbAnnotationIntrospector.isPropertiesAccessible(Annotated ac)
Whether properties are accessible to this class. |
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |