|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Packages that use JavaType | |
---|---|
org.codehaus.jackson | Main public API classes of the core streaming JSON
processor: most importantly JsonFactory
used for constructing
Json parser (JsonParser )
and generator
(JsonParser )
instances. |
org.codehaus.jackson.jaxrs | Jackson-based JAX-RS provider that can automatically serialize and deserialize resources for JSON content type (MediaType). |
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.jsontype | Package that contains interfaces that define how to implement functionality for dynamically resolving type during deserialization. |
org.codehaus.jackson.map.jsontype.impl | Package that contains standard implementations for
TypeResolverBuilder
and
org.codehaus.jackson.map.jsontype.JsonTypeResolver it
can construct. |
org.codehaus.jackson.map.ser | Contains implementation classes of serialization part of data binding. |
org.codehaus.jackson.map.type | Package that contains concrete implementations of
JavaType , as
well as the factory (TypeFactory ) for
constructing instances from various input data types
(like Class , Type )
and programmatically (for structured types, arrays,
List s and Map s). |
org.codehaus.jackson.map.util | Utility classes for Mapper package. |
org.codehaus.jackson.type | Contains classes needed for type introspection, mostly used by data binding functionality. |
org.codehaus.jackson.xc | Package that contains Xml Compatibility functionality for Jackson. |
Uses of JavaType in org.codehaus.jackson |
---|
Methods in org.codehaus.jackson with parameters of type JavaType | ||
---|---|---|
abstract
|
ObjectCodec.readValue(JsonParser jp,
JavaType valueType)
Method to deserialize JSON content as tree expressed using set of JsonNode instances. |
Uses of JavaType in org.codehaus.jackson.jaxrs |
---|
Methods in org.codehaus.jackson.jaxrs that return JavaType | |
---|---|
protected JavaType |
JacksonJsonProvider._convertType(Type jdkType)
Method used to construct a JDK generic type into type definition Jackson understands. |
Uses of JavaType in org.codehaus.jackson.map |
---|
Fields in org.codehaus.jackson.map declared as JavaType | |
---|---|
protected JavaType |
ObjectWriter._rootType
Specified root serialization type to use; can be same as runtime type, but usually one of its super types |
protected JavaType |
BeanDescription._type
Bean type information, including raw class and possible * generics information |
Fields in org.codehaus.jackson.map with type parameters of type JavaType | |
---|---|
protected ConcurrentHashMap<JavaType,JsonDeserializer<Object>> |
ObjectMapper._rootDeserializers
We will use a separate main-level Map for keeping track of root-level deserializers. |
Methods in org.codehaus.jackson.map that return JavaType | |
---|---|
JavaType |
BeanDescription.getType()
Method for accessing declared type of bean being introspected, including full generic type information (from declaration) |
Methods in org.codehaus.jackson.map with parameters of type JavaType | ||
---|---|---|
protected Object |
ObjectMapper._convert(Object fromValue,
JavaType toValueType)
|
|
protected JsonDeserializer<Object> |
ObjectMapper._findRootDeserializer(DeserializationConfig cfg,
JavaType valueType)
Method called to locate deserializer for the passed root-level value. |
|
protected Object |
ObjectMapper._readMapAndClose(JsonParser jp,
JavaType valueType)
|
|
protected Object |
ObjectMapper._readValue(DeserializationConfig cfg,
JsonParser jp,
JavaType valueType)
Actual implementation of value reading+binding operation. |
|
TypeDeserializer |
ObjectMapper.DefaultTypeResolverBuilder.buildTypeDeserializer(JavaType baseType,
Collection<NamedType> subtypes)
|
|
TypeSerializer |
ObjectMapper.DefaultTypeResolverBuilder.buildTypeSerializer(JavaType baseType,
Collection<NamedType> subtypes)
|
|
boolean |
ObjectMapper.canDeserialize(JavaType type)
Method that can be called to check whether mapper thinks it could deserialize an Object of given type. |
|
|
ObjectMapper.convertValue(Object fromValue,
JavaType toValueType)
|
|
abstract JsonDeserializer<Object> |
DeserializerFactory.createBeanDeserializer(DeserializationConfig config,
JavaType type,
DeserializerProvider p)
Method called to create (or, for completely immutable deserializers, reuse) a deserializer that can convert Json content into values of specified Java "bean" (POJO) type. |
|
JsonSerializer<Object> |
SerializerFactory.createSerializer(JavaType type,
SerializationConfig config)
Method called to create (or, for immutable serializers, reuse) a serializer for given type. |
|
TypeSerializer |
SerializerFactory.createTypeSerializer(JavaType baseType,
SerializationConfig config)
Method called to create a type information serializer for given base type, if one is needed. |
|
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 KeyDeserializer |
DeserializerProvider.findKeyDeserializer(DeserializationConfig config,
JavaType type)
Method called to get hold of a deserializer to use for deserializing keys for Map . |
|
abstract TypeResolverBuilder<?> |
AnnotationIntrospector.findPropertyContentTypeResolver(AnnotatedMember am,
JavaType containerType)
Method for checking if given structured property entity (field or method that has nominal value of Map, Collection or array type) has annotations that indicate that specific type resolver is to be used for handling type information of contained values. |
|
TypeResolverBuilder<?> |
AnnotationIntrospector.Pair.findPropertyContentTypeResolver(AnnotatedMember am,
JavaType baseType)
|
|
abstract TypeResolverBuilder<?> |
AnnotationIntrospector.findPropertyTypeResolver(AnnotatedMember am,
JavaType baseType)
Method for checking if given property entity (field or method) has annotations that indicate that specific type resolver is to be used for handling instances. |
|
TypeResolverBuilder<?> |
AnnotationIntrospector.Pair.findPropertyTypeResolver(AnnotatedMember am,
JavaType baseType)
|
|
TypeDeserializer |
DeserializerFactory.findTypeDeserializer(DeserializationConfig config,
JavaType baseType)
Method called to find and create a type information deserializer for given base type, if one is needed. |
|
abstract JsonDeserializer<Object> |
DeserializerProvider.findTypedValueDeserializer(DeserializationConfig config,
JavaType type)
Method called to locate deserializer for given type, as well as matching type deserializer (if one is needed); and if type deserializer is needed, construct a "wrapped" deserializer that can extract and use type information for calling actual deserializer. |
|
abstract JsonSerializer<Object> |
SerializerProvider.findTypedValueSerializer(JavaType valueType,
boolean cache)
Method called to locate regular serializer, matching type serializer, and if both found, wrap them in a serializer that calls both in correct sequence. |
|
abstract TypeResolverBuilder<?> |
AnnotationIntrospector.findTypeResolver(AnnotatedClass ac,
JavaType baseType)
Method for checking if given class has annotations that indicate that specific type resolver is to be used for handling instances. |
|
TypeResolverBuilder<?> |
AnnotationIntrospector.Pair.findTypeResolver(AnnotatedClass ac,
JavaType baseType)
|
|
abstract JsonDeserializer<Object> |
DeserializerProvider.findValueDeserializer(DeserializationConfig config,
JavaType type,
JavaType referrer,
String refPropName)
Method called to get hold of a deserializer for a value of given type; or if no such deserializer can be found, a default handler (which may do a best-effort generic serialization or just simply throw an exception when invoked). |
|
abstract JsonSerializer<Object> |
SerializerProvider.findValueSerializer(JavaType serializationType)
|
|
abstract T |
ClassIntrospector.forDeserialization(DeserializationConfig cfg,
JavaType type,
ClassIntrospector.MixInResolver r)
Factory method that constructs an introspector that has all information needed for deserialization purposes. |
|
TypeResolverBuilder<?> |
SerializationConfig.getDefaultTyper(JavaType baseType)
|
|
TypeResolverBuilder<?> |
MapperConfig.getDefaultTyper(JavaType baseType)
Method called to locate a type info handler for types that do not have one explicitly declared via annotations (or other configuration). |
|
TypeResolverBuilder<?> |
DeserializationConfig.getDefaultTyper(JavaType baseType)
|
|
abstract boolean |
DeserializerProvider.hasValueDeserializerFor(DeserializationConfig config,
JavaType type)
Method called to find out whether provider would be able to find a deserializer for given type, using a root reference (i.e. |
|
|
DeserializationConfig.introspect(JavaType type)
Method that will introspect full bean properties for the purpose of building a bean deserializer |
|
|
ObjectMapper.readValue(byte[] src,
int offset,
int len,
JavaType valueType)
|
|
|
ObjectMapper.readValue(File src,
JavaType valueType)
|
|
|
ObjectMapper.readValue(InputStream src,
JavaType valueType)
|
|
|
ObjectMapper.readValue(JsonParser jp,
JavaType valueType)
Method to deserialize Json content into a Java type, reference to which is passed as argument. |
|
|
ObjectMapper.readValue(JsonParser jp,
JavaType valueType,
DeserializationConfig cfg)
Method to deserialize Json content into a Java type, reference to which is passed as argument. |
|
|
ObjectMapper.readValue(Reader src,
JavaType valueType)
|
|
|
ObjectMapper.readValue(String content,
JavaType valueType)
|
|
|
ObjectMapper.readValue(URL src,
JavaType valueType)
|
|
abstract void |
SerializerProvider.serializeValue(SerializationConfig cfg,
JsonGenerator jgen,
Object value,
JavaType rootType,
SerializerFactory jsf)
The method to be called by ObjectMapper to
execute recursive serialization, using serializers that
this provider has access to; and using specified root type
for locating first-level serializer. |
|
ObjectWriter |
ObjectMapper.typedWriter(JavaType rootType)
Factory method for constructing ObjectWriter that will
serialize objects using specified root type, instead of actual
runtime type of value. |
|
abstract JsonMappingException |
DeserializationContext.unknownTypeException(JavaType baseType,
String id)
Helper method for constructing exception to indicate that given type id (parsed from JSON) could not be converted to a Java type. |
|
boolean |
ObjectMapper.DefaultTypeResolverBuilder.useForType(JavaType t)
Method called to check if the default type handler should be used for given type. |
|
ObjectWriter |
ObjectWriter.withType(JavaType rootType)
|
Constructors in org.codehaus.jackson.map with parameters of type JavaType | |
---|---|
BeanDescription(JavaType type)
|
|
ObjectWriter(ObjectMapper mapper,
Class<?> view,
JavaType rootType)
Constructor used by ObjectMapper for initial instantiation |
|
ObjectWriter(ObjectWriter base,
SerializationConfig config,
Class<?> view,
JavaType rootType)
Copy constructor used for building variations. |
Uses of JavaType in org.codehaus.jackson.map.deser |
---|
Fields in org.codehaus.jackson.map.deser declared as JavaType | |
---|---|
protected JavaType |
BeanDeserializer._beanType
|
Fields in org.codehaus.jackson.map.deser with type parameters of type JavaType | |
---|---|
protected ConcurrentHashMap<JavaType,JsonDeserializer<Object>> |
StdDeserializerProvider._cachedDeserializers
We will also cache some dynamically constructed deserializers; specifically, ones that are expensive to construct. |
protected HashMap<JavaType,JsonDeserializer<Object>> |
StdDeserializerProvider._incompleteDeserializers
During deserializer construction process we may need to keep track of partially completed deserializers, to resolve cyclic dependencies. |
Methods in org.codehaus.jackson.map.deser with type parameters of type JavaType | ||
---|---|---|
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. |
Methods in org.codehaus.jackson.map.deser that return JavaType | |
---|---|
JavaType |
SettableBeanProperty.getType()
|
JavaType |
SettableAnyProperty.getType()
|
JavaType |
StdDeserializer.getValueType()
Exact structured type deserializer handles, if known; null for non-structured (scalar) types. |
JavaType |
MapDeserializer.getValueType()
|
JavaType |
BeanDeserializer.getValueType()
|
JavaType |
ArrayDeserializer.getValueType()
|
protected JavaType |
BasicDeserializerFactory.resolveType(DeserializationConfig config,
BasicBeanDescription beanDesc,
Type rawType,
Annotated a)
Helper method used to resolve method return types and field types. |
Methods in org.codehaus.jackson.map.deser that return types with arguments of type JavaType | |
---|---|
static HashMap<JavaType,JsonDeserializer<Object>> |
ArrayDeserializers.getAll()
|
Methods in org.codehaus.jackson.map.deser with parameters of type JavaType | |
---|---|
protected JsonDeserializer<Object> |
StdDeserializerProvider._createAndCache2(DeserializationConfig config,
JavaType type,
JavaType referrer,
String refPropName)
Method that handles actual construction (via factory) and caching (both intermediate and eventual) |
protected JsonDeserializer<Object> |
StdDeserializerProvider._createAndCacheValueDeserializer(DeserializationConfig config,
JavaType type,
JavaType referrer,
String refPropName)
Method that will try to create a deserializer for given type, and resolve and cache it if necessary |
protected JsonDeserializer<Object> |
StdDeserializerProvider._createDeserializer(DeserializationConfig config,
JavaType type,
JavaType referrer,
String refPropName)
|
protected JsonDeserializer<Object> |
StdDeserializerProvider._findCachedDeserializer(JavaType type)
|
protected KeyDeserializer |
StdDeserializerProvider._handleUnknownKeyDeserializer(JavaType type)
|
protected JsonDeserializer<Object> |
StdDeserializerProvider._handleUnknownValueDeserializer(JavaType type)
|
JsonDeserializer<Object> |
BeanDeserializerFactory.buildBeanDeserializer(DeserializationConfig config,
JavaType type,
BasicBeanDescription beanDesc)
Method that is to actually build a bean deserializer instance. |
JsonDeserializer<Object> |
BeanDeserializerFactory.buildThrowableDeserializer(DeserializationConfig config,
JavaType type,
BasicBeanDescription beanDesc)
|
protected BeanDeserializer |
BeanDeserializerFactory.constructBeanDeserializerInstance(DeserializationConfig config,
JavaType type,
BasicBeanDescription beanDesc)
Method for construcing "empty" deserializer: overridable to allow sub-classing of BeanDeserializer . |
protected ThrowableDeserializer |
BeanDeserializerFactory.constructThrowableDeserializerInstance(DeserializationConfig config,
JavaType type,
BasicBeanDescription beanDesc)
|
JsonDeserializer<Object> |
CustomDeserializerFactory.createBeanDeserializer(DeserializationConfig config,
JavaType type,
DeserializerProvider p)
|
JsonDeserializer<Object> |
BeanDeserializerFactory.createBeanDeserializer(DeserializationConfig config,
JavaType type,
DeserializerProvider p)
Method that DeserializerProvider s call to create a new
deserializer for types other than Collections, Maps, arrays and
enums. |
JsonDeserializer<Object> |
BasicDeserializerFactory.createBeanDeserializer(DeserializationConfig config,
JavaType type,
DeserializerProvider p)
|
protected JsonDeserializer<Object> |
StdDeserializer.findDeserializer(DeserializationConfig config,
DeserializerProvider provider,
JavaType type,
String propertyName,
Map<JavaType,JsonDeserializer<Object>> seen)
Helper method used to locate deserializers for properties the bean itself contains. |
KeyDeserializer |
StdDeserializerProvider.findKeyDeserializer(DeserializationConfig config,
JavaType type)
|
TypeDeserializer |
BasicDeserializerFactory.findPropertyContentTypeDeserializer(DeserializationConfig config,
JavaType containerType,
AnnotatedMember propertyEntity)
Method called to find and create a type information deserializer for values of given container (list, array, map) property, if one is needed. |
TypeDeserializer |
BasicDeserializerFactory.findPropertyTypeDeserializer(DeserializationConfig config,
JavaType baseType,
AnnotatedMember propertyEntity)
Method called to create a type information deserializer for values of given non-container property, if one is needed. |
TypeDeserializer |
BasicDeserializerFactory.findTypeDeserializer(DeserializationConfig config,
JavaType baseType)
|
JsonDeserializer<Object> |
StdDeserializerProvider.findTypedValueDeserializer(DeserializationConfig config,
JavaType type)
|
JsonDeserializer<Object> |
StdDeserializerProvider.findValueDeserializer(DeserializationConfig config,
JavaType type,
JavaType referrer,
String refPropName)
|
boolean |
StdDeserializerProvider.hasValueDeserializerFor(DeserializationConfig config,
JavaType type)
Method that can be called to find out whether a deserializer can be found for given type |
JsonMappingException |
StdDeserializationContext.unknownTypeException(JavaType type,
String id)
|
Method parameters in org.codehaus.jackson.map.deser with type arguments of type JavaType | |
---|---|
protected JsonDeserializer<Object> |
StdDeserializer.findDeserializer(DeserializationConfig config,
DeserializerProvider provider,
JavaType type,
String propertyName,
Map<JavaType,JsonDeserializer<Object>> seen)
Helper method used to locate deserializers for properties the bean itself contains. |
Constructors in org.codehaus.jackson.map.deser with parameters of type JavaType | |
---|---|
BeanDeserializer(JavaType type)
|
|
MapDeserializer(JavaType mapType,
Constructor<Map<Object,Object>> defCtor,
KeyDeserializer keyDeser,
JsonDeserializer<Object> valueDeser,
TypeDeserializer valueTypeDeser)
|
|
SettableAnyProperty(JavaType type,
Method setter)
|
|
SettableBeanProperty.CreatorProperty(String propName,
JavaType type,
TypeDeserializer typeDeser,
Class<?> declaringClass,
int index)
|
|
SettableBeanProperty.FieldProperty(String propName,
JavaType type,
TypeDeserializer typeDeser,
Field f)
|
|
SettableBeanProperty.MethodProperty(String propName,
JavaType type,
TypeDeserializer typeDeser,
Method setter)
|
|
SettableBeanProperty.SetterlessProperty(String propName,
JavaType type,
TypeDeserializer typeDeser,
Method getter)
|
|
SettableBeanProperty(String propName,
JavaType type,
TypeDeserializer typeDeser)
|
|
ThrowableDeserializer(JavaType type)
|
Uses of JavaType in org.codehaus.jackson.map.introspect |
---|
Methods in org.codehaus.jackson.map.introspect that return JavaType | |
---|---|
JavaType |
Annotated.getType(TypeBindings context)
Full generic type of the annotated element; definition of what exactly this means depends on sub-class. |
Constructors in org.codehaus.jackson.map.introspect with parameters of type JavaType | |
---|---|
BasicBeanDescription(JavaType type,
AnnotatedClass ac,
AnnotationIntrospector ai)
|
Uses of JavaType in org.codehaus.jackson.map.jsontype |
---|
Methods in org.codehaus.jackson.map.jsontype that return JavaType | |
---|---|
JavaType |
TypeIdResolver.typeFromId(String id)
Method called to resolve type from given type identifier. |
Methods in org.codehaus.jackson.map.jsontype with parameters of type JavaType | |
---|---|
TypeDeserializer |
TypeResolverBuilder.buildTypeDeserializer(JavaType baseType,
Collection<NamedType> subtypes)
Method for building type deserializer based on current configuration of this builder. |
TypeSerializer |
TypeResolverBuilder.buildTypeSerializer(JavaType baseType,
Collection<NamedType> subtypes)
Method for building type serializer based on current configuration of this builder. |
void |
TypeIdResolver.init(JavaType baseType)
Method that will be called once before any type resolution calls; used to initialize instance with configuration. |
Uses of JavaType in org.codehaus.jackson.map.jsontype.impl |
---|
Fields in org.codehaus.jackson.map.jsontype.impl declared as JavaType | |
---|---|
protected JavaType |
TypeIdResolverBase._baseType
|
protected JavaType |
TypeDeserializerBase._baseType
|
Fields in org.codehaus.jackson.map.jsontype.impl with type parameters of type JavaType | |
---|---|
protected HashMap<String,JavaType> |
TypeNameIdResolver._idToType
Mappings from type id to JavaType, used for deserialization |
Methods in org.codehaus.jackson.map.jsontype.impl that return JavaType | |
---|---|
JavaType |
TypeNameIdResolver.typeFromId(String id)
|
JavaType |
MinimalClassNameIdResolver.typeFromId(String id)
|
JavaType |
ClassNameIdResolver.typeFromId(String id)
|
Methods in org.codehaus.jackson.map.jsontype.impl with parameters of type JavaType | |
---|---|
TypeDeserializer |
StdTypeResolverBuilder.buildTypeDeserializer(JavaType baseType,
Collection<NamedType> subtypes)
|
TypeSerializer |
StdTypeResolverBuilder.buildTypeSerializer(JavaType baseType,
Collection<NamedType> subtypes)
|
static TypeNameIdResolver |
TypeNameIdResolver.construct(JavaType baseType,
Collection<NamedType> subtypes,
boolean forSer,
boolean forDeser)
|
protected TypeIdResolver |
StdTypeResolverBuilder.idResolver(JavaType baseType,
Collection<NamedType> subtypes,
boolean forSer,
boolean forDeser)
Helper method that will either return configured custom type id resolver, or construct a standard resolver given configuration. |
void |
TypeIdResolverBase.init(JavaType bt)
|
Constructors in org.codehaus.jackson.map.jsontype.impl with parameters of type JavaType | |
---|---|
AsArrayTypeDeserializer(JavaType bt,
TypeIdResolver idRes)
|
|
AsPropertyTypeDeserializer(JavaType bt,
TypeIdResolver idRes,
String propName)
|
|
AsWrapperTypeDeserializer(JavaType bt,
TypeIdResolver idRes)
|
|
ClassNameIdResolver(JavaType baseType)
|
|
MinimalClassNameIdResolver(JavaType baseType)
|
|
TypeDeserializerBase(JavaType baseType,
TypeIdResolver idRes)
|
|
TypeIdResolverBase(JavaType baseType)
|
|
TypeNameIdResolver(JavaType baseType,
HashMap<String,String> typeToId,
HashMap<String,JavaType> idToType)
|
Constructor parameters in org.codehaus.jackson.map.jsontype.impl with type arguments of type JavaType | |
---|---|
TypeNameIdResolver(JavaType baseType,
HashMap<String,String> typeToId,
HashMap<String,JavaType> idToType)
|
Uses of JavaType in org.codehaus.jackson.map.ser |
---|
Fields in org.codehaus.jackson.map.ser declared as JavaType | |
---|---|
protected JavaType |
BeanPropertyWriter._cfgSerializationType
Type to use for locating serializer; normally same as return type of the accessor method, but may be overridden by annotations. |
protected JavaType |
ArraySerializers.ObjectArraySerializer._elementType
|
protected JavaType |
BeanPropertyWriter._nonTrivialBaseType
Base type of the property, if the declared type is "non-trivial"; meaning it is either a structured type (collection, map, array), or parametrized. |
protected JavaType |
MapSerializer._valueType
Declared type of contained values |
protected JavaType |
EnumMapSerializer._valueType
|
Methods in org.codehaus.jackson.map.ser that return JavaType | |
---|---|
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). |
JavaType |
BeanPropertyWriter.getSerializationType()
|
Methods in org.codehaus.jackson.map.ser with parameters of type JavaType | |
---|---|
protected JsonSerializer<Object> |
StdSerializerProvider._createAndCacheUntypedSerializer(JavaType type)
|
protected JsonSerializer<Object> |
StdSerializerProvider._createUntypedSerializer(JavaType type)
|
protected void |
StdSerializerProvider._serializeValue(JsonGenerator jgen,
Object value,
JavaType rootType)
Method called on the actual non-blueprint provider instance object, to kick off the serialization, when root type is explicitly specified and not determined from value. |
void |
SerializerCache.addNonTypedSerializer(JavaType type,
JsonSerializer<Object> ser)
|
void |
SerializerCache.addTypedSerializer(JavaType type,
JsonSerializer<Object> ser)
Method called if none of lookups succeeded, and caller had to construct a serializer. |
protected JsonSerializer<?> |
BasicSerializerFactory.buildCollectionSerializer(JavaType type,
SerializationConfig config,
BasicBeanDescription beanDesc)
|
protected JsonSerializer<?> |
BasicSerializerFactory.buildEnumMapSerializer(JavaType type,
SerializationConfig config,
BasicBeanDescription beanDesc)
|
protected JsonSerializer<?> |
BasicSerializerFactory.buildEnumSetSerializer(JavaType type,
SerializationConfig config,
BasicBeanDescription beanDesc)
|
protected JsonSerializer<?> |
BasicSerializerFactory.buildIndexedListSerializer(JavaType type,
SerializationConfig config,
BasicBeanDescription beanDesc)
|
protected JsonSerializer<?> |
BasicSerializerFactory.buildIterableSerializer(JavaType type,
SerializationConfig config,
BasicBeanDescription beanDesc)
|
protected JsonSerializer<?> |
BasicSerializerFactory.buildIteratorSerializer(JavaType type,
SerializationConfig config,
BasicBeanDescription beanDesc)
|
protected JsonSerializer<?> |
BasicSerializerFactory.buildMapSerializer(JavaType type,
SerializationConfig config,
BasicBeanDescription beanDesc)
Helper method that handles configuration details when constructing serializers for Map types. |
protected JsonSerializer<?> |
BasicSerializerFactory.buildObjectArraySerializer(JavaType type,
SerializationConfig config,
BasicBeanDescription beanDesc)
Helper method that handles configuration details when constructing serializers for Object[] (and subtypes). |
static ContainerSerializerBase<?> |
ContainerSerializers.collectionSerializer(JavaType elemType,
boolean staticTyping,
TypeSerializer vts)
|
static MapSerializer |
MapSerializer.construct(String[] ignoredList,
JavaType mapType,
boolean staticValueType,
TypeSerializer vts)
Factory method used to construct Map serializers. |
JsonSerializer<Object> |
CustomSerializerFactory.createSerializer(JavaType type,
SerializationConfig config)
|
JsonSerializer<Object> |
BeanSerializerFactory.createSerializer(JavaType type,
SerializationConfig config)
Main serializer constructor method. |
JsonSerializer<Object> |
BasicSerializerFactory.createSerializer(JavaType type,
SerializationConfig config)
|
TypeSerializer |
BasicSerializerFactory.createTypeSerializer(JavaType baseType,
SerializationConfig config)
Method called to construct a type serializer for values with given declared base type. |
static JsonSerializer<?> |
ContainerSerializers.enumSetSerializer(JavaType enumType)
|
JsonSerializer<Object> |
BeanSerializerFactory.findBeanSerializer(JavaType type,
SerializationConfig config,
BasicBeanDescription beanDesc)
Method that will try to construct a BeanSerializer for
given class. |
TypeSerializer |
BeanSerializerFactory.findPropertyContentTypeSerializer(JavaType containerType,
SerializationConfig config,
AnnotatedMember propertyEntity)
Method called to create a type information serializer for values of given container property if one is needed. |
TypeSerializer |
BeanSerializerFactory.findPropertyTypeSerializer(JavaType baseType,
SerializationConfig config,
AnnotatedMember propertyEntity)
Method called to create a type information serializer for values of given non-container property if one is needed. |
JsonSerializer<?> |
BasicSerializerFactory.findSerializerByAddonType(JavaType javaType,
SerializationConfig config,
BasicBeanDescription beanDesc)
Reflection-based serialized find method, which checks if given class implements one of recognized "add-on" interfaces. |
JsonSerializer<?> |
BasicSerializerFactory.findSerializerByLookup(JavaType type,
SerializationConfig config,
BasicBeanDescription beanDesc)
Fast lookup-based accessor method, which will only check for type itself, but not consider super-classes or implemented interfaces. |
JsonSerializer<?> |
BasicSerializerFactory.findSerializerByPrimaryType(JavaType type,
SerializationConfig config,
BasicBeanDescription beanDesc)
Reflection-based serialized find method, which checks if given class is a sub-type of one of well-known classes, or implements a "primary" interface. |
JsonSerializer<Object> |
StdSerializerProvider.findTypedValueSerializer(JavaType valueType,
boolean cache)
|
JsonSerializer<Object> |
StdSerializerProvider.findValueSerializer(JavaType valueType)
This variant was added in 1.5, to allow for efficient access using full structured types, not just classes. |
static ContainerSerializerBase<?> |
ContainerSerializers.indexedListSerializer(JavaType elemType,
boolean staticTyping,
TypeSerializer vts)
|
static ContainerSerializerBase<?> |
ContainerSerializers.iterableSerializer(JavaType elemType,
boolean staticTyping,
TypeSerializer vts)
|
static ContainerSerializerBase<?> |
ContainerSerializers.iteratorSerializer(JavaType elemType,
boolean staticTyping,
TypeSerializer vts)
|
static ContainerSerializerBase<?> |
ArraySerializers.objectArraySerializer(JavaType elementType,
boolean staticTyping,
TypeSerializer vts)
|
void |
SerializerCache.TypedKeyFull.reset(JavaType type)
|
void |
StdSerializerProvider.serializeValue(SerializationConfig config,
JsonGenerator jgen,
Object value,
JavaType rootType,
SerializerFactory jsf)
|
void |
BeanPropertyWriter.setNonTrivialBaseType(JavaType t)
Method called to define type to consider as "non-trivial" basetype, needed for dynamic serialization resolution for complex (usually container) types |
JsonSerializer<Object> |
SerializerCache.typedValueSerializer(JavaType type)
|
JsonSerializer<Object> |
ReadOnlyClassToSerializerMap.typedValueSerializer(JavaType type)
|
JsonSerializer<Object> |
SerializerCache.untypedValueSerializer(JavaType type)
|
JsonSerializer<Object> |
ReadOnlyClassToSerializerMap.untypedValueSerializer(JavaType type)
|
Uses of JavaType in org.codehaus.jackson.map.type |
---|
Subclasses of JavaType in org.codehaus.jackson.map.type | |
---|---|
class |
ArrayType
Array types represent Java arrays, both primitive and object valued. |
class |
CollectionType
Type that represents Java Collection types (Lists, Sets). |
class |
MapType
Type that represents Java Map types. |
class |
SimpleType
Simple types are defined as anything other than one of recognized container types (arrays, Collections, Maps). |
class |
TypeBase
|
Fields in org.codehaus.jackson.map.type declared as JavaType | |
---|---|
protected JavaType |
TypeBindings._contextType
Context type used for resolving all types, if specified. |
protected JavaType[] |
SimpleType._typeParameters
Generic type arguments for this type. |
static JavaType |
TypeBindings.UNBOUND
Marker to use for (temporarily) unbound references. |
Fields in org.codehaus.jackson.map.type with type parameters of type JavaType | |
---|---|
protected Map<String,JavaType> |
TypeBindings._bindings
Lazily-instantiated bindings of resolved type parameters |
Methods in org.codehaus.jackson.map.type with type parameters of type JavaType | ||
---|---|---|
protected
|
TypeFactory._findParentType(Class<?> clz,
Class<T> expType)
Method that is to figure out actual type parameters that given class binds to generic types defined by given interface type. |
Methods in org.codehaus.jackson.map.type that return JavaType | |
---|---|
protected JavaType |
TypeFactory._fromArrayType(GenericArrayType type,
TypeBindings context)
|
protected JavaType |
TypeFactory._fromClass(Class<?> clz,
TypeBindings context)
|
protected JavaType |
TypeFactory._fromParameterizedClass(Class<?> clz,
List<JavaType> paramTypes)
Method used by TypeParser when generics-aware version
is constructed. |
protected JavaType |
TypeFactory._fromParamType(ParameterizedType type,
TypeBindings context)
This method deals with parameterized types, that is, first class generic classes. |
JavaType |
TypeFactory._fromType(Type type,
TypeBindings context)
Factory method that can be used if type information is passed as Java typing returned from getGenericXxx methods
(usually for a return or argument type). |
protected JavaType |
TypeFactory._fromVariable(TypeVariable<?> type,
TypeBindings context)
|
protected JavaType |
TypeFactory._fromWildcard(WildcardType type,
TypeBindings context)
|
protected JavaType |
SimpleType._narrow(Class<?> subclass)
|
protected JavaType |
MapType._narrow(Class<?> subclass)
|
protected JavaType |
CollectionType._narrow(Class<?> subclass)
|
protected JavaType |
ArrayType._narrow(Class<?> subclass)
Handling of narrowing conversions for arrays is trickier: for now, it is not even allowed. |
protected JavaType |
TypeFactory._unknownType()
|
static JavaType |
TypeFactory.arrayType(Class<?> elementType)
Convenience factory method for constructing JavaType that
represent array that contains elements
of specified type. |
static JavaType |
TypeFactory.arrayType(JavaType elementType)
Convenience factory method for constructing JavaType that
represent array that contains elements
of specified type. |
static JavaType |
TypeFactory.collectionType(Class<? extends Collection> collectionType,
Class<?> elementType)
Convenience factory method for constructing JavaType that
represent Collection of specified type and contains elements
of specified type |
static JavaType |
TypeFactory.collectionType(Class<? extends Collection> collectionType,
JavaType elementType)
Convenience factory method for constructing JavaType that
represent Collection of specified type and contains elements
of specified type |
JavaType |
SimpleType.containedType(int index)
|
JavaType |
MapType.containedType(int index)
|
JavaType |
CollectionType.containedType(int index)
|
JavaType |
ArrayType.containedType(int index)
|
protected JavaType |
TypeBase.copyHandlers(JavaType fromType)
|
JavaType |
TypeBindings.findType(String name)
|
static JavaType |
TypeFactory.fromCanonical(String canonical)
Factory method for constructing a JavaType out of its canonical
representation (see toCanonical() ). |
static JavaType |
TypeFactory.fromClass(Class<?> clz)
Deprecated. Use TypeFactory.type(Type) instead |
static JavaType |
TypeFactory.fromType(Type type)
Deprecated. Use TypeFactory.type(Type) instead |
static JavaType |
TypeFactory.fromTypeReference(TypeReference<?> ref)
Deprecated. Use TypeFactory.type(Type) instead |
JavaType |
MapType.getContentType()
|
JavaType |
CollectionType.getContentType()
|
JavaType |
ArrayType.getContentType()
|
JavaType |
MapType.getKeyType()
|
static JavaType |
TypeFactory.mapType(Class<? extends Map> mapType,
Class<?> keyType,
Class<?> valueType)
Convenience factory method for constructing JavaType that
represent Map of specified type and contains elements
of specified type |
static JavaType |
TypeFactory.mapType(Class<? extends Map> mapType,
JavaType keyType,
JavaType valueType)
Convenience factory method for constructing JavaType that
represent Map of specified type and contains elements
of specified type |
JavaType |
SimpleType.narrowContentsBy(Class<?> subclass)
|
JavaType |
MapType.narrowContentsBy(Class<?> contentClass)
|
JavaType |
CollectionType.narrowContentsBy(Class<?> contentClass)
|
JavaType |
ArrayType.narrowContentsBy(Class<?> contentClass)
For array types, both main type and content type can be modified; but ultimately they are interchangeable. |
JavaType |
MapType.narrowKey(Class<?> keySubclass)
|
static JavaType |
TypeFactory.parametricType(Class<?> parametrized,
Class<?>... parameterClasses)
Factory method for constructing JavaType that
represents a parameterized type. |
static JavaType |
TypeFactory.parametricType(Class<?> parametrized,
JavaType... parameterTypes)
Factory method for constructing JavaType that
represents a parameterized type. |
JavaType |
TypeParser.parse(String canonical)
|
protected JavaType |
TypeParser.parseType(org.codehaus.jackson.map.type.TypeParser.MyTokenizer tokens)
|
static JavaType |
TypeFactory.specialize(JavaType baseType,
Class<?> subclass)
Method that tries to create specialized type given base type, and a sub-class thereof (which is assumed to use same parametrization as supertype). |
static JavaType |
TypeFactory.type(Type t)
Factory method for constructing JavaType from given
"raw" type; which may be anything from simple Class
to full generic type. |
static JavaType |
TypeFactory.type(Type type,
Class<?> context)
Factory method that can use given context to resolve named generic types. |
static JavaType |
TypeFactory.type(TypeReference<?> ref)
Factory method that can be used if the full generic type has been passed using TypeReference . |
static JavaType |
TypeFactory.type(Type type,
TypeBindings bindings)
|
Methods in org.codehaus.jackson.map.type that return types with arguments of type JavaType | |
---|---|
protected List<JavaType> |
TypeParser.parseTypes(org.codehaus.jackson.map.type.TypeParser.MyTokenizer tokens)
|
Methods in org.codehaus.jackson.map.type with parameters of type JavaType | |
---|---|
protected static SimpleType |
TypeFactory._constructSimple(Class<?> rawType,
JavaType[] parameterTypes)
|
static JavaType |
TypeFactory.arrayType(JavaType elementType)
Convenience factory method for constructing JavaType that
represent array that contains elements
of specified type. |
static JavaType |
TypeFactory.collectionType(Class<? extends Collection> collectionType,
JavaType elementType)
Convenience factory method for constructing JavaType that
represent Collection of specified type and contains elements
of specified type |
static CollectionType |
CollectionType.construct(Class<?> rawType,
JavaType elemT)
|
static MapType |
MapType.construct(Class<?> rawType,
JavaType keyT,
JavaType valueT)
|
static ArrayType |
ArrayType.construct(JavaType componentType)
|
protected JavaType |
TypeBase.copyHandlers(JavaType fromType)
|
static JavaType |
TypeFactory.mapType(Class<? extends Map> mapType,
JavaType keyType,
JavaType valueType)
Convenience factory method for constructing JavaType that
represent Map of specified type and contains elements
of specified type |
static JavaType |
TypeFactory.parametricType(Class<?> parametrized,
JavaType... parameterTypes)
Factory method for constructing JavaType that
represents a parameterized type. |
static JavaType |
TypeFactory.specialize(JavaType baseType,
Class<?> subclass)
Method that tries to create specialized type given base type, and a sub-class thereof (which is assumed to use same parametrization as supertype). |
Method parameters in org.codehaus.jackson.map.type with type arguments of type JavaType | |
---|---|
protected JavaType |
TypeFactory._fromParameterizedClass(Class<?> clz,
List<JavaType> paramTypes)
Method used by TypeParser when generics-aware version
is constructed. |
Constructors in org.codehaus.jackson.map.type with parameters of type JavaType | |
---|---|
SimpleType(Class<?> cls,
String[] typeNames,
JavaType[] typeParams)
|
|
TypeBindings(JavaType type)
|
Uses of JavaType in org.codehaus.jackson.map.util |
---|
Fields in org.codehaus.jackson.map.util declared as JavaType | |
---|---|
protected JavaType |
JSONWrappedObject._serializationType
Optional static type to use for serialization; if null, runtime type is used. |
protected JavaType |
JSONPObject._serializationType
Optional static type to use for serialization; if null, runtime type is used. |
Methods in org.codehaus.jackson.map.util that return JavaType | |
---|---|
JavaType |
JSONWrappedObject.getSerializationType()
|
JavaType |
JSONPObject.getSerializationType()
|
Constructors in org.codehaus.jackson.map.util with parameters of type JavaType | |
---|---|
JSONPObject(String function,
Object value,
JavaType asType)
|
|
JSONWrappedObject(String prefix,
String suffix,
Object value,
JavaType asType)
|
Uses of JavaType in org.codehaus.jackson.type |
---|
Methods in org.codehaus.jackson.type that return JavaType | |
---|---|
protected abstract JavaType |
JavaType._narrow(Class<?> subclass)
|
protected JavaType |
JavaType._widen(Class<?> superclass)
Default implementation is just to call _narrow(java.lang.Class>) , since
underlying type construction is usually identical |
JavaType |
JavaType.containedType(int index)
Method for accessing definitions of contained ("child") types. |
JavaType |
JavaType.forcedNarrowBy(Class<?> subclass)
More efficient version of narrowBy(java.lang.Class>) , called by
internal framework in cases where compatibility checks
are to be skipped. |
JavaType |
JavaType.getContentType()
Method for accessing content type of this type, if type has such a thing: simple types do not, structured types do (like arrays, Collections and Maps) |
JavaType |
JavaType.getKeyType()
Method for accessing key type for this type, assuming type has such a concept (only Map types do) |
JavaType |
JavaType.narrowBy(Class<?> subclass)
Method that can be called to do a "narrowing" conversions; that is, to return a type with a raw class that is assignable to the raw class of this type. |
abstract JavaType |
JavaType.narrowContentsBy(Class<?> contentClass)
|
JavaType |
JavaType.widenBy(Class<?> superclass)
Method that can be called to do a "widening" conversions; that is, to return a type with a raw class that could be assigned from this type. |
Uses of JavaType in org.codehaus.jackson.xc |
---|
Methods in org.codehaus.jackson.xc with parameters of type JavaType | |
---|---|
protected Class<?> |
JaxbAnnotationIntrospector._doFindDeserializationType(Annotated a,
JavaType baseType,
String propName)
|
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. |
TypeResolverBuilder<?> |
JaxbAnnotationIntrospector.findPropertyContentTypeResolver(AnnotatedMember am,
JavaType containerType)
|
TypeResolverBuilder<?> |
JaxbAnnotationIntrospector.findPropertyTypeResolver(AnnotatedMember am,
JavaType baseType)
|
TypeResolverBuilder<?> |
JaxbAnnotationIntrospector.findTypeResolver(AnnotatedClass ac,
JavaType baseType)
|
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |