|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Packages that use JavaType | |
---|---|
com.fasterxml.jackson.databind | 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 |
com.fasterxml.jackson.databind.cfg | Package that contains most of configuration-related classes;
exception being couple of most-commonly used configuration
things (like Feature enumerations) that are at the
main level (com.fasterxml.jackson.databind ). |
com.fasterxml.jackson.databind.deser | Contains implementation classes of deserialization part of data binding. |
com.fasterxml.jackson.databind.deser.impl | Contains those implementation classes of deserialization part of data binding that are not considered part of public or semi-public interfaces. |
com.fasterxml.jackson.databind.deser.std | Contains public standard implementations of abstraction that Jackson uses. |
com.fasterxml.jackson.databind.ext | Contains extended support for "external" packages: things that may or may not be present in runtime environment, but that are commonly enough used so that explicit support can be added. |
com.fasterxml.jackson.databind.introspect | Functionality needed for Bean introspection, required for detecting accessors and mutators for Beans, as well as locating and handling method annotations. |
com.fasterxml.jackson.databind.jsonFormatVisitors | |
com.fasterxml.jackson.databind.jsontype | Package that contains interfaces that define how to implement functionality for dynamically resolving type during deserialization. |
com.fasterxml.jackson.databind.jsontype.impl | Package that contains standard implementations for
TypeResolverBuilder
and
TypeIdResolver . |
com.fasterxml.jackson.databind.module | Package that contains classes and interfaces to help implement
custom extension Module s
(which are registered using
ObjectMapper.registerModule(com.fasterxml.jackson.databind.Module) . |
com.fasterxml.jackson.databind.ser | Contains implementation classes of serialization part of data binding. |
com.fasterxml.jackson.databind.ser.impl | Contains implementation classes of serialization part of data binding. |
com.fasterxml.jackson.databind.ser.std | |
com.fasterxml.jackson.databind.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). |
com.fasterxml.jackson.databind.util | Utility classes for Mapper package. |
Uses of JavaType in com.fasterxml.jackson.databind |
---|
Fields in com.fasterxml.jackson.databind 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 |
MappingIterator._type
|
protected JavaType |
BeanProperty.Std._type
|
protected JavaType |
BeanDescription._type
Bean type information, including raw class and possible * generics information |
protected JavaType |
ObjectReader._valueType
Declared type of value to instantiate during deserialization. |
protected static JavaType |
SerializerProvider.TYPE_OBJECT
|
Fields in com.fasterxml.jackson.databind with type parameters of type JavaType | |
---|---|
protected ConcurrentHashMap<JavaType,JsonDeserializer<Object>> |
ObjectReader._rootDeserializers
Root-level cached deserializers |
protected ConcurrentHashMap<JavaType,JsonDeserializer<Object>> |
ObjectMapper._rootDeserializers
We will use a separate main-level Map for keeping track of root-level deserializers. |
Methods in com.fasterxml.jackson.databind 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 |
SerializerProvider.constructSpecializedType(JavaType baseType,
Class<?> subclass)
Convenience method for constructing subtypes, retaining generic type parameter (if any) |
JavaType |
DeserializationContext.constructType(Class<?> cls)
Convenience method, functionally equivalent to: |
JavaType |
SerializerProvider.constructType(Type type)
Convenience method for constructing JavaType for given JDK
type (usually Class ) |
JavaType |
ObjectMapper.constructType(Type t)
Convenience method for constructing JavaType out of given
type (typically java.lang.Class ), but without explicit
context. |
JavaType |
JavaType.containedType(int index)
|
JavaType |
AbstractTypeResolver.findTypeMapping(DeserializationConfig config,
JavaType type)
Try to locate a subtype for given abstract type, to either resolve to a concrete type, or at least to a more-specific (and hopefully supported) abstract type, one which may have registered deserializers. |
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()
|
JavaType |
JavaType.getKeyType()
|
JavaType |
BeanProperty.getType()
Method to get declared type of the property. |
JavaType |
BeanProperty.Std.getType()
|
JavaType |
BeanDescription.getType()
Method for accessing declared type of bean being introspected, including full generic type information (from declaration) |
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 |
AbstractTypeResolver.resolveAbstractType(DeserializationConfig config,
JavaType type)
Method called to try to resolve an abstract type into concrete type (usually for purposes of deserializing), when no concrete implementation was found. |
abstract JavaType |
BeanDescription.resolveType(Type jdkType)
Method for resolving given JDK type, using this bean as the generic type resolution context. |
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. |
abstract JavaType |
JavaType.widenContentsBy(Class<?> contentClass)
|
abstract JavaType |
JavaType.withContentTypeHandler(Object h)
"Copy method" that will construct a new instance that is identical to this instance, except that its content type will have specified type handler assigned. |
abstract JavaType |
JavaType.withContentValueHandler(Object h)
"Copy method" that will construct a new instance that is identical to this instance, except that it will have specified content value handler assigned. |
abstract JavaType |
JavaType.withTypeHandler(Object h)
"Copy method" that will construct a new instance that is identical to this instance, except that it will have specified type handler assigned. |
abstract JavaType |
JavaType.withValueHandler(Object h)
"Copy method" that will construct a new instance that is identical to this instance, except that it will have specified value handler assigned. |
Methods in com.fasterxml.jackson.databind with parameters of type JavaType | ||
---|---|---|
protected Object |
ObjectMapper._convert(Object fromValue,
JavaType toValueType)
Actual conversion implementation: instead of using existing read and write methods, much of code is inlined. |
|
protected JsonSerializer<Object> |
SerializerProvider._createAndCacheUntypedSerializer(JavaType type)
|
|
protected JsonSerializer<Object> |
SerializerProvider._createUntypedSerializer(JavaType type)
|
|
protected JsonDeserializer<Object> |
ObjectReader._findRootDeserializer(DeserializationContext ctxt,
JavaType valueType)
Method called to locate deserializer for the passed root-level value. |
|
protected JsonDeserializer<Object> |
ObjectMapper._findRootDeserializer(DeserializationContext ctxt,
JavaType valueType)
Method called to locate deserializer for the passed root-level value. |
|
protected JsonDeserializer<Object> |
ObjectReader._prefetchRootDeserializer(DeserializationConfig config,
JavaType valueType)
Method called to locate deserializer ahead of time, if permitted by configuration. |
|
protected JsonSerializer<Object> |
ObjectWriter._prefetchRootSerializer(SerializationConfig config,
JavaType valueType)
Method called to locate (root) serializer ahead of time, if permitted by configuration. |
|
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. |
|
protected void |
SerializerProvider._reportIncompatibleRootType(Object value,
JavaType rootType)
|
|
protected Object |
ObjectMapper._unwrapAndDeserialize(JsonParser jp,
DeserializationContext ctxt,
DeserializationConfig config,
JavaType rootType,
JsonDeserializer<Object> deser)
|
|
protected Object |
ObjectReader._unwrapAndDeserialize(JsonParser jp,
DeserializationContext ctxt,
JavaType rootType,
JsonDeserializer<Object> deser)
|
|
void |
ObjectMapper.acceptJsonFormatVisitor(JavaType type,
JsonFormatVisitorWrapper visitor)
Method for visiting type hierarchy for given type, using specified visitor. |
|
void |
JsonSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor,
JavaType type)
Default implementation simply calls JsonFormatVisitorWrapper.expectAnyFormat(JavaType) . |
|
TypeDeserializer |
ObjectMapper.DefaultTypeResolverBuilder.buildTypeDeserializer(DeserializationConfig config,
JavaType baseType,
Collection<NamedType> subtypes)
|
|
TypeSerializer |
ObjectMapper.DefaultTypeResolverBuilder.buildTypeSerializer(SerializationConfig config,
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. |
|
JavaType |
SerializerProvider.constructSpecializedType(JavaType baseType,
Class<?> subclass)
Convenience method for constructing subtypes, retaining generic type parameter (if any) |
|
|
ObjectMapper.convertValue(Object fromValue,
JavaType toValueType)
|
|
JsonDeserializer<Object> |
DeserializationContext.findContextualValueDeserializer(JavaType type,
BeanProperty property)
Method for finding a value deserializer, and creating a contextual version if necessary, for value reached via specified property. |
|
Class<?> |
AnnotationIntrospector.findDeserializationContentType(Annotated am,
JavaType baseContentType)
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.findDeserializationKeyType(Annotated am,
JavaType baseKeyType)
Method for accessing additional narrowing type definition that a method can have, to define more specific key type to use. |
|
Class<?> |
AnnotationIntrospector.findDeserializationType(Annotated am,
JavaType baseType)
Method for accessing annotated type definition that a method can have, to be used as the type for serialization instead of the runtime type. |
|
KeyDeserializer |
DeserializationContext.findKeyDeserializer(JavaType keyType,
BeanProperty property)
Convenience method, functionally same as: |
|
JsonSerializer<Object> |
SerializerProvider.findKeySerializer(JavaType keyType,
BeanProperty property)
Method called to get the serializer to use for serializing non-null Map keys. |
|
JsonSerializer<Object> |
SerializerProvider.findNullKeySerializer(JavaType serializationType,
BeanProperty property)
Method called to find a serializer to use for null values for given declared type. |
|
TypeResolverBuilder<?> |
AnnotationIntrospector.findPropertyContentTypeResolver(MapperConfig<?> config,
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.findPropertyTypeResolver(MapperConfig<?> config,
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. |
|
JsonDeserializer<Object> |
DeserializationContext.findRootValueDeserializer(JavaType type)
Method for finding a deserializer for root-level value. |
|
Class<?> |
AnnotationIntrospector.findSerializationContentType(Annotated am,
JavaType baseType)
Method for finding possible widening type definition that a property value can have, to define less specific key type to use for serialization. |
|
Class<?> |
AnnotationIntrospector.findSerializationKeyType(Annotated am,
JavaType baseType)
Method for finding possible widening type definition that a property value can have, to define less specific key type to use for serialization. |
|
JsonSerializer<Object> |
SerializerProvider.findTypedValueSerializer(JavaType valueType,
boolean cache,
BeanProperty property)
Method called to locate regular serializer, matching type serializer, and if both found, wrap them in a serializer that calls both in correct sequence. |
|
JavaType |
AbstractTypeResolver.findTypeMapping(DeserializationConfig config,
JavaType type)
Try to locate a subtype for given abstract type, to either resolve to a concrete type, or at least to a more-specific (and hopefully supported) abstract type, one which may have registered deserializers. |
|
TypeResolverBuilder<?> |
AnnotationIntrospector.findTypeResolver(MapperConfig<?> config,
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. |
|
JsonSerializer<Object> |
SerializerProvider.findValueSerializer(JavaType valueType,
BeanProperty property)
Similar to SerializerProvider.findValueSerializer(Class,BeanProperty) , but takes
full generics-aware type instead of raw class. |
|
boolean |
DeserializationContext.hasValueDeserializerFor(JavaType type)
Method for checking whether we could find a deserializer for given type. |
|
|
SerializationConfig.introspect(JavaType type)
Method that will introspect full bean properties for the purpose of building a bean serializer |
|
|
DeserializationConfig.introspect(JavaType type)
Method that will introspect full bean properties for the purpose of building a bean deserializer |
|
BeanDescription |
SerializationConfig.introspectClassAnnotations(JavaType type)
Accessor for getting bean description that only contains class annotations: useful if no getter/setter/creator information is needed. |
|
BeanDescription |
DeserializationConfig.introspectClassAnnotations(JavaType type)
Accessor for getting bean description that only contains class annotations: useful if no getter/setter/creator information is needed. |
|
BeanDescription |
SerializationConfig.introspectDirectClassAnnotations(JavaType type)
Accessor for getting bean description that only contains immediate class annotations: ones from the class, and its direct mix-in, if any, but not from super types. |
|
BeanDescription |
DeserializationConfig.introspectDirectClassAnnotations(JavaType type)
Accessor for getting bean description that only contains immediate class annotations: ones from the class, and its direct mix-in, if any, but not from super types. |
|
|
DeserializationConfig.introspectForBuilder(JavaType type)
|
|
|
DeserializationConfig.introspectForCreation(JavaType type)
Method that will introspect subset of bean properties needed to construct bean instance. |
|
ObjectReader |
ObjectMapper.reader(JavaType type)
Factory method for constructing ObjectReader that will
read or update instances of specified type |
|
|
ObjectMapper.readValue(byte[] src,
int offset,
int len,
JavaType valueType)
|
|
|
ObjectMapper.readValue(byte[] src,
JavaType valueType)
|
|
|
ObjectMapper.readValue(File src,
JavaType valueType)
|
|
|
ObjectMapper.readValue(InputStream src,
JavaType valueType)
|
|
|
ObjectReader.readValue(JsonParser jp,
JavaType valueType)
Type-safe overloaded method, basically alias for ObjectReader.readValue(JsonParser, ResolvedType) . |
|
|
ObjectMapper.readValue(JsonParser jp,
JavaType valueType)
Type-safe overloaded method, basically alias for ObjectMapper.readValue(JsonParser, ResolvedType) . |
|
|
ObjectMapper.readValue(Reader src,
JavaType valueType)
|
|
|
ObjectMapper.readValue(String content,
JavaType valueType)
|
|
|
ObjectMapper.readValue(URL src,
JavaType valueType)
|
|
|
ObjectReader.readValues(JsonParser jp,
JavaType valueType)
Convenience method that is equivalent to: |
|
|
ObjectMapper.readValues(JsonParser jp,
JavaType valueType)
Type-safe overloaded method, basically alias for ObjectMapper.readValues(JsonParser, ResolvedType) . |
|
JavaType |
AbstractTypeResolver.resolveAbstractType(DeserializationConfig config,
JavaType type)
Method called to try to resolve an abstract type into concrete type (usually for purposes of deserializing), when no concrete implementation was found. |
|
JsonMappingException |
DeserializationContext.unknownTypeException(JavaType type,
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)
Method that will construct a new instance that uses specific type as the root type for serialization, instead of runtime dynamic type of the root object itself. |
|
ObjectReader |
ObjectReader.withType(JavaType valueType)
Method for constructing a new reader instance that is configured to data bind into specified type. |
|
BeanProperty.Std |
BeanProperty.Std.withType(JavaType type)
|
|
ObjectWriter |
ObjectMapper.writerWithType(JavaType rootType)
Factory method for constructing ObjectWriter that will
serialize objects using specified root type, instead of actual
runtime type of value. |
Constructors in com.fasterxml.jackson.databind with parameters of type JavaType | |
---|---|
BeanDescription(JavaType type)
|
|
BeanProperty.Std(String name,
JavaType type,
Annotations contextAnnotations,
AnnotatedMember member)
|
|
MappingIterator(JavaType type,
JsonParser jp,
DeserializationContext ctxt,
JsonDeserializer<?> deser)
Deprecated. Since 2.1, to be removed |
|
MappingIterator(JavaType type,
JsonParser jp,
DeserializationContext ctxt,
JsonDeserializer<?> deser,
boolean managedParser,
Object valueToUpdate)
|
|
ObjectReader(ObjectMapper mapper,
DeserializationConfig config,
JavaType valueType,
Object valueToUpdate,
FormatSchema schema,
InjectableValues injectableValues)
Constructor called when a root deserializer should be fetched based on other configuration. |
|
ObjectReader(ObjectReader base,
DeserializationConfig config,
JavaType valueType,
JsonDeserializer<Object> rootDeser,
Object valueToUpdate,
FormatSchema schema,
InjectableValues injectableValues,
DataFormatReaders dataFormatReaders)
Copy constructor used for building variations. |
|
ObjectWriter(ObjectMapper mapper,
SerializationConfig config,
JavaType rootType,
PrettyPrinter pp)
Constructor used by ObjectMapper for initial instantiation |
|
ObjectWriter(ObjectWriter base,
SerializationConfig config,
JavaType rootType,
JsonSerializer<Object> rootSer,
PrettyPrinter pp,
FormatSchema s)
Copy constructor used for building variations. |
Uses of JavaType in com.fasterxml.jackson.databind.cfg |
---|
Methods in com.fasterxml.jackson.databind.cfg that return JavaType | |
---|---|
JavaType |
MapperConfig.constructSpecializedType(JavaType baseType,
Class<?> subclass)
|
JavaType |
MapperConfig.constructType(Class<?> cls)
Helper method that will construct JavaType for given
raw class. |
JavaType |
MapperConfig.constructType(TypeReference<?> valueTypeRef)
Helper method that will construct JavaType for given
type reference
This is a simple short-cut for: |
Methods in com.fasterxml.jackson.databind.cfg with parameters of type JavaType | |
---|---|
JavaType |
MapperConfig.constructSpecializedType(JavaType baseType,
Class<?> subclass)
|
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). |
abstract BeanDescription |
MapperConfig.introspectClassAnnotations(JavaType type)
Accessor for getting bean description that only contains class annotations: useful if no getter/setter/creator information is needed. |
abstract BeanDescription |
MapperConfig.introspectDirectClassAnnotations(JavaType type)
Accessor for getting bean description that only contains immediate class annotations: ones from the class, and its direct mix-in, if any, but not from super types. |
Uses of JavaType in com.fasterxml.jackson.databind.deser |
---|
Fields in com.fasterxml.jackson.databind.deser declared as JavaType | |
---|---|
protected JavaType |
AbstractDeserializer._baseType
|
protected JavaType |
BeanDeserializerBase._beanType
Declared type of the bean this deserializer handles. |
protected JavaType |
SettableBeanProperty._type
Base type for property; may be a supertype of actual value. |
protected JavaType |
SettableAnyProperty._type
|
Fields in com.fasterxml.jackson.databind.deser with type parameters of type JavaType | |
---|---|
protected static HashMap<JavaType,JsonDeserializer<Object>> |
BasicDeserializerFactory._arrayDeserializers
Also special array deserializers for primitive array types. |
protected ConcurrentHashMap<JavaType,JsonDeserializer<Object>> |
DeserializerCache._cachedDeserializers
We will also cache some dynamically constructed deserializers; specifically, ones that are expensive to construct. |
protected HashMap<JavaType,JsonDeserializer<Object>> |
DeserializerCache._incompleteDeserializers
During deserializer construction process we may need to keep track of partially completed deserializers, to resolve cyclic dependencies. |
protected static HashMap<JavaType,KeyDeserializer> |
BasicDeserializerFactory._keyDeserializers
Set of available key deserializers is currently limited to standard types; and all known instances are storing in this map. |
Methods in com.fasterxml.jackson.databind.deser with type parameters of type JavaType | ||
---|---|---|
protected
|
BasicDeserializerFactory.modifyTypeByAnnotation(DeserializationContext ctxt,
Annotated a,
T type)
Method called to see if given method has annotations that indicate a more specific type than what the argument specifies. |
Methods in com.fasterxml.jackson.databind.deser that return JavaType | |
---|---|
JavaType |
ValueInstantiator.getDelegateType(DeserializationConfig config)
Method that can be used to determine what is the type of delegate type to use, if any; if no delegates are used, will return null. |
JavaType |
SettableBeanProperty.getType()
|
JavaType |
SettableAnyProperty.getType()
|
JavaType |
BeanDeserializerBase.getValueType()
|
abstract JavaType |
DeserializerFactory.mapAbstractType(DeserializationConfig config,
JavaType type)
Method that can be called to try to resolve an abstract type (interface, abstract class) into a concrete type, or at least something "more concrete" (abstract class instead of interface). |
JavaType |
BasicDeserializerFactory.mapAbstractType(DeserializationConfig config,
JavaType type)
|
protected JavaType |
BeanDeserializerFactory.materializeAbstractType(DeserializationConfig config,
BeanDescription beanDesc)
|
protected JavaType |
BasicDeserializerFactory.resolveType(DeserializationContext ctxt,
BeanDescription beanDesc,
JavaType type,
AnnotatedMember member)
Helper method used to resolve method return types and field types. |
Methods in com.fasterxml.jackson.databind.deser with parameters of type JavaType | |
---|---|
protected JsonDeserializer<Object> |
DeserializerCache._createAndCache2(DeserializationContext ctxt,
DeserializerFactory factory,
JavaType type)
Method that handles actual construction (via factory) and caching (both intermediate and eventual) |
protected JsonDeserializer<Object> |
DeserializerCache._createAndCacheValueDeserializer(DeserializationContext ctxt,
DeserializerFactory factory,
JavaType type)
Method that will try to create a deserializer for given type, and resolve and cache it if necessary |
protected JsonDeserializer<Object> |
DeserializerCache._createDeserializer(DeserializationContext ctxt,
DeserializerFactory factory,
JavaType type)
Method that does the heavy lifting of checking for per-type annotations, find out full type, and figure out which actual factory method to call. |
protected JsonDeserializer<Object> |
DeserializerCache._findCachedDeserializer(JavaType type)
|
protected JsonDeserializer<Object> |
BeanDeserializerFactory._findCustomBeanDeserializer(JavaType type,
DeserializationConfig config,
BeanDescription beanDesc)
|
protected AnnotatedMethod |
BasicDeserializerFactory._findJsonValueFor(DeserializationConfig config,
JavaType enumType)
|
protected KeyDeserializer |
DeserializerCache._handleUnknownKeyDeserializer(JavaType type)
|
protected JsonDeserializer<Object> |
DeserializerCache._handleUnknownValueDeserializer(JavaType type)
|
void |
BeanDeserializerBuilder.addInjectable(String propertyName,
JavaType propertyType,
Annotations contextAnnotations,
AnnotatedMember member,
Object valueId)
|
JsonDeserializer<Object> |
BeanDeserializerFactory.buildBeanDeserializer(DeserializationContext ctxt,
JavaType type,
BeanDescription beanDesc)
Method that is to actually build a bean deserializer instance. |
JsonDeserializer<?> |
BeanDeserializerBuilder.buildBuilderBased(JavaType valueType,
String expBuildMethodName)
Method for constructing a specialized deserializer that uses additional external Builder object during data binding. |
protected JsonDeserializer<Object> |
BeanDeserializerFactory.buildBuilderBasedDeserializer(DeserializationContext ctxt,
JavaType valueType,
BeanDescription builderDesc)
Method for constructing a bean deserializer that uses specified intermediate Builder for binding data, and construction of the value instance. |
JsonDeserializer<Object> |
BeanDeserializerFactory.buildThrowableDeserializer(DeserializationContext ctxt,
JavaType type,
BeanDescription beanDesc)
|
abstract JsonDeserializer<Object> |
DeserializerFactory.createBeanDeserializer(DeserializationContext ctxt,
JavaType type,
BeanDescription beanDesc)
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. |
JsonDeserializer<Object> |
BeanDeserializerFactory.createBeanDeserializer(DeserializationContext ctxt,
JavaType type,
BeanDescription beanDesc)
Method that DeserializerCache s call to create a new
deserializer for types other than Collections, Maps, arrays and
enums. |
abstract JsonDeserializer<Object> |
DeserializerFactory.createBuilderBasedDeserializer(DeserializationContext ctxt,
JavaType type,
BeanDescription beanDesc,
Class<?> builderClass)
Method called to create a deserializer that will use specified Builder class for building value instances. |
JsonDeserializer<Object> |
BeanDeserializerFactory.createBuilderBasedDeserializer(DeserializationContext ctxt,
JavaType valueType,
BeanDescription beanDesc,
Class<?> builderClass)
|
abstract JsonDeserializer<?> |
DeserializerFactory.createEnumDeserializer(DeserializationContext ctxt,
JavaType type,
BeanDescription beanDesc)
|
JsonDeserializer<?> |
BasicDeserializerFactory.createEnumDeserializer(DeserializationContext ctxt,
JavaType type,
BeanDescription beanDesc)
Factory method for constructing serializers of Enum types. |
abstract KeyDeserializer |
DeserializerFactory.createKeyDeserializer(DeserializationContext ctxt,
JavaType type)
Method called to find if factory knows how to create a key deserializer for specified type; currently this means checking if a module has registered possible deserializers. |
KeyDeserializer |
BasicDeserializerFactory.createKeyDeserializer(DeserializationContext ctxt,
JavaType type)
|
abstract JsonDeserializer<?> |
DeserializerFactory.createTreeDeserializer(DeserializationConfig config,
JavaType type,
BeanDescription beanDesc)
Method called to create and return a deserializer that can construct JsonNode(s) from JSON content. |
JsonDeserializer<?> |
BasicDeserializerFactory.createTreeDeserializer(DeserializationConfig config,
JavaType nodeType,
BeanDescription beanDesc)
|
JsonDeserializer<?> |
Deserializers.findBeanDeserializer(JavaType type,
DeserializationConfig config,
BeanDescription beanDesc)
Method called to locate deserializer for specified value type which does not belong to any other category (not an Enum, Collection, Map, Array or tree node) |
JsonDeserializer<?> |
Deserializers.Base.findBeanDeserializer(JavaType type,
DeserializationConfig config,
BeanDescription beanDesc)
|
KeyDeserializer |
DeserializerCache.findKeyDeserializer(DeserializationContext ctxt,
DeserializerFactory factory,
JavaType type)
Method called to get hold of a deserializer to use for deserializing keys for Map . |
KeyDeserializer |
KeyDeserializers.findKeyDeserializer(JavaType type,
DeserializationConfig config,
BeanDescription beanDesc)
|
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 annotated)
Method called to create a type information deserializer for values of given non-container property, if one is needed. |
protected JsonDeserializer<Object> |
BeanDeserializerFactory.findStdDeserializer(DeserializationConfig config,
JavaType type)
Method called by BeanDeserializerFactory to see if there might be a standard
deserializer registered for given type. |
abstract 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. |
TypeDeserializer |
BasicDeserializerFactory.findTypeDeserializer(DeserializationConfig config,
JavaType baseType)
|
JsonDeserializer<Object> |
DeserializerCache.findValueDeserializer(DeserializationContext ctxt,
DeserializerFactory factory,
JavaType propertyType)
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). |
boolean |
DeserializerCache.hasValueDeserializerFor(DeserializationContext ctxt,
DeserializerFactory factory,
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. |
abstract JavaType |
DeserializerFactory.mapAbstractType(DeserializationConfig config,
JavaType type)
Method that can be called to try to resolve an abstract type (interface, abstract class) into a concrete type, or at least something "more concrete" (abstract class instead of interface). |
JavaType |
BasicDeserializerFactory.mapAbstractType(DeserializationConfig config,
JavaType type)
|
protected JavaType |
BasicDeserializerFactory.resolveType(DeserializationContext ctxt,
BeanDescription beanDesc,
JavaType type,
AnnotatedMember member)
Helper method used to resolve method return types and field types. |
DataFormatReaders |
DataFormatReaders.withType(JavaType type)
|
Constructors in com.fasterxml.jackson.databind.deser with parameters of type JavaType | |
---|---|
CreatorProperty(String name,
JavaType type,
TypeDeserializer typeDeser,
Annotations contextAnnotations,
AnnotatedParameter param,
int index,
Object injectableValueId)
|
|
SettableAnyProperty(BeanProperty property,
AnnotatedMethod setter,
JavaType type,
JsonDeserializer<Object> valueDeser)
|
|
SettableAnyProperty(BeanProperty property,
Method rawSetter,
JavaType type,
JsonDeserializer<Object> valueDeser)
|
|
SettableBeanProperty(BeanPropertyDefinition propDef,
JavaType type,
TypeDeserializer typeDeser,
Annotations contextAnnotations)
|
|
SettableBeanProperty(String propName,
JavaType type,
TypeDeserializer typeDeser,
Annotations contextAnnotations)
|
Uses of JavaType in com.fasterxml.jackson.databind.deser.impl |
---|
Fields in com.fasterxml.jackson.databind.deser.impl declared as JavaType | |
---|---|
JavaType |
ObjectIdReader.idType
|
Methods in com.fasterxml.jackson.databind.deser.impl with parameters of type JavaType | |
---|---|
static ObjectIdReader |
ObjectIdReader.construct(JavaType idType,
String propName,
ObjectIdGenerator<?> generator,
JsonDeserializer<?> deser,
SettableBeanProperty idProp)
Factory method called by BeanSerializerBase
with the initial information based on standard settings for the type
for which serializer is being built. |
Constructors in com.fasterxml.jackson.databind.deser.impl with parameters of type JavaType | |
---|---|
FieldProperty(BeanPropertyDefinition propDef,
JavaType type,
TypeDeserializer typeDeser,
Annotations contextAnnotations,
AnnotatedField field)
|
|
MethodProperty(BeanPropertyDefinition propDef,
JavaType type,
TypeDeserializer typeDeser,
Annotations contextAnnotations,
AnnotatedMethod method)
|
|
NullProvider(JavaType type,
Object nullValue)
|
|
ObjectIdReader(JavaType t,
String propName,
ObjectIdGenerator<?> gen,
JsonDeserializer<?> deser,
SettableBeanProperty idProp)
|
|
SetterlessProperty(BeanPropertyDefinition propDef,
JavaType type,
TypeDeserializer typeDeser,
Annotations contextAnnotations,
AnnotatedMethod method)
|
|
ValueInjector(String propertyName,
JavaType type,
Annotations contextAnnotations,
AnnotatedMember mutator,
Object valueId)
|
Uses of JavaType in com.fasterxml.jackson.databind.deser.std |
---|
Fields in com.fasterxml.jackson.databind.deser.std declared as JavaType | |
---|---|
protected JavaType |
StringCollectionDeserializer._collectionType
|
protected JavaType |
CollectionDeserializer._collectionType
|
protected JavaType |
StdValueInstantiator._delegateType
|
protected JavaType |
StdDelegatingDeserializer._delegateType
Fully resolved delegate type, with generic information if any available. |
protected JavaType |
EnumSetDeserializer._enumType
|
protected JavaType |
MapDeserializer._mapType
|
protected JavaType |
EnumMapDeserializer._mapType
|
protected JavaType |
JdkDeserializers.AtomicReferenceDeserializer._referencedType
Type of value that we reference |
Fields in com.fasterxml.jackson.databind.deser.std with type parameters of type JavaType | |
---|---|
protected HashMap<JavaType,KeyDeserializer> |
StdKeyDeserializers._keyDeserializers
|
Methods in com.fasterxml.jackson.databind.deser.std that return JavaType | |
---|---|
JavaType |
JacksonDeserializers.JavaTypeDeserializer.deserialize(JsonParser jp,
DeserializationContext ctxt)
|
JavaType |
StringCollectionDeserializer.getContentType()
|
JavaType |
ObjectArrayDeserializer.getContentType()
|
JavaType |
MapDeserializer.getContentType()
|
abstract JavaType |
ContainerDeserializerBase.getContentType()
Accessor for declared type of contained value elements; either exact type, or one of its supertypes. |
JavaType |
CollectionDeserializer.getContentType()
|
JavaType |
StdValueInstantiator.getDelegateType(DeserializationConfig config)
|
JavaType |
StdDeserializer.getValueType()
Exact structured type deserializer handles, if known. |
JavaType |
MapDeserializer.getValueType()
|
Methods in com.fasterxml.jackson.databind.deser.std that return types with arguments of type JavaType | |
---|---|
static HashMap<JavaType,KeyDeserializer> |
StdKeyDeserializers.constructAll()
|
static HashMap<JavaType,JsonDeserializer<Object>> |
PrimitiveArrayDeserializers.getAll()
|
Methods in com.fasterxml.jackson.databind.deser.std with parameters of type JavaType | |
---|---|
protected boolean |
MapDeserializer._isStdKeyDeser(JavaType mapType,
KeyDeserializer keyDeser)
Helper method used to check whether we can just use the default key deserialization, where JSON String becomes Java String. |
void |
StdValueInstantiator.configureFromObjectSettings(AnnotatedWithParams defaultCreator,
AnnotatedWithParams delegateCreator,
JavaType delegateType,
CreatorProperty[] delegateArgs,
AnnotatedWithParams withArgsCreator,
CreatorProperty[] constructorArgs)
Method for setting properties related to instantiating values from JSON Object. |
static KeyDeserializer |
StdKeyDeserializers.constructDelegatingKeyDeserializer(DeserializationConfig config,
JavaType type,
JsonDeserializer<?> deser)
|
static KeyDeserializer |
StdKeyDeserializers.constructStringKeyDeserializer(DeserializationConfig config,
JavaType type)
|
protected JsonDeserializer<Object> |
StdDeserializer.findDeserializer(DeserializationContext ctxt,
JavaType type,
BeanProperty property)
Helper method used to locate deserializers for properties the type this deserializer handles contains (usually for properties of bean types) |
static KeyDeserializer |
StdKeyDeserializers.findStringBasedKeyDeserializer(DeserializationConfig config,
JavaType type)
|
protected StdDelegatingDeserializer<T> |
StdDelegatingDeserializer.withDelegate(Converter<Object,T> converter,
JavaType delegateType,
JsonDeserializer<?> delegateDeserializer)
Method used for creating resolved contextual instances. |
Uses of JavaType in com.fasterxml.jackson.databind.ext |
---|
Methods in com.fasterxml.jackson.databind.ext with parameters of type JavaType | |
---|---|
void |
DOMSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor,
JavaType typeHint)
|
void |
CoreXMLSerializers.XMLGregorianCalendarSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor,
JavaType typeHint)
|
JsonDeserializer<?> |
OptionalHandlerFactory.findDeserializer(JavaType type,
DeserializationConfig config)
|
JsonSerializer<?> |
OptionalHandlerFactory.findSerializer(SerializationConfig config,
JavaType type)
|
Uses of JavaType in com.fasterxml.jackson.databind.introspect |
---|
Fields in com.fasterxml.jackson.databind.introspect declared as JavaType | |
---|---|
protected JavaType |
POJOPropertiesCollector._type
Type of POJO for which properties are being collected. |
Methods in com.fasterxml.jackson.databind.introspect that return JavaType | |
---|---|
JavaType |
POJOPropertiesCollector.getType()
|
JavaType |
AnnotatedMethod.getType(TypeBindings bindings)
As per [JACKSON-468], we need to also allow declaration of local type bindings; mostly it will allow defining bounds. |
JavaType |
AnnotatedConstructor.getType(TypeBindings bindings)
As per [JACKSON-468], we need to also allow declaration of local type bindings; mostly it will allow defining bounds. |
JavaType |
Annotated.getType(TypeBindings context)
Full generic type of the annotated element; definition of what exactly this means depends on sub-class. |
protected JavaType |
AnnotatedWithParams.getType(TypeBindings bindings,
TypeVariable<?>[] typeParams)
|
JavaType |
AnnotatedWithParams.resolveParameterType(int index,
TypeBindings bindings)
Method called to fully resolve type of one of parameters, given specified type variable bindings. |
JavaType |
BasicBeanDescription.resolveType(Type jdkType)
|
Methods in com.fasterxml.jackson.databind.introspect with parameters of type JavaType | |
---|---|
protected BasicBeanDescription |
BasicClassIntrospector._findCachedDesc(JavaType type)
Method called to see if type is one of core JDK types that we have cached for efficiency. |
protected TypeResolverBuilder<?> |
JacksonAnnotationIntrospector._findTypeResolver(MapperConfig<?> config,
Annotated ann,
JavaType baseType)
Helper method called to construct and initialize instance of TypeResolverBuilder
if given annotated element indicates one is needed. |
protected POJOPropertiesCollector |
BasicClassIntrospector.collectProperties(MapperConfig<?> config,
JavaType type,
ClassIntrospector.MixInResolver r,
boolean forSerialization,
String mutatorPrefix)
|
protected POJOPropertiesCollector |
BasicClassIntrospector.collectPropertiesWithBuilder(MapperConfig<?> config,
JavaType type,
ClassIntrospector.MixInResolver r,
boolean forSerialization)
|
protected POJOPropertiesCollector |
BasicClassIntrospector.constructPropertyCollector(MapperConfig<?> config,
AnnotatedClass ac,
JavaType type,
boolean forSerialization,
String mutatorPrefix)
Overridable method called for creating POJOPropertiesCollector instance
to use; override is needed if a custom sub-class is to be used. |
Class<?> |
JacksonAnnotationIntrospector.findDeserializationContentType(Annotated am,
JavaType baseContentType)
|
Class<?> |
AnnotationIntrospectorPair.findDeserializationContentType(Annotated am,
JavaType baseContentType)
|
Class<?> |
JacksonAnnotationIntrospector.findDeserializationKeyType(Annotated am,
JavaType baseKeyType)
|
Class<?> |
AnnotationIntrospectorPair.findDeserializationKeyType(Annotated am,
JavaType baseKeyType)
|
Class<?> |
JacksonAnnotationIntrospector.findDeserializationType(Annotated am,
JavaType baseType)
|
Class<?> |
AnnotationIntrospectorPair.findDeserializationType(Annotated am,
JavaType baseType)
|
TypeResolverBuilder<?> |
JacksonAnnotationIntrospector.findPropertyContentTypeResolver(MapperConfig<?> config,
AnnotatedMember am,
JavaType containerType)
|
TypeResolverBuilder<?> |
AnnotationIntrospectorPair.findPropertyContentTypeResolver(MapperConfig<?> config,
AnnotatedMember am,
JavaType baseType)
|
TypeResolverBuilder<?> |
JacksonAnnotationIntrospector.findPropertyTypeResolver(MapperConfig<?> config,
AnnotatedMember am,
JavaType baseType)
|
TypeResolverBuilder<?> |
AnnotationIntrospectorPair.findPropertyTypeResolver(MapperConfig<?> config,
AnnotatedMember am,
JavaType baseType)
|
Class<?> |
JacksonAnnotationIntrospector.findSerializationContentType(Annotated am,
JavaType baseType)
|
Class<?> |
AnnotationIntrospectorPair.findSerializationContentType(Annotated am,
JavaType baseType)
|
Class<?> |
JacksonAnnotationIntrospector.findSerializationKeyType(Annotated am,
JavaType baseType)
|
Class<?> |
AnnotationIntrospectorPair.findSerializationKeyType(Annotated am,
JavaType baseType)
|
TypeResolverBuilder<?> |
JacksonAnnotationIntrospector.findTypeResolver(MapperConfig<?> config,
AnnotatedClass ac,
JavaType baseType)
|
TypeResolverBuilder<?> |
AnnotationIntrospectorPair.findTypeResolver(MapperConfig<?> config,
AnnotatedClass ac,
JavaType baseType)
|
abstract BeanDescription |
ClassIntrospector.forClassAnnotations(MapperConfig<?> cfg,
JavaType type,
ClassIntrospector.MixInResolver r)
Factory method that constructs an introspector that only has information regarding annotations class itself (or its supertypes) has, but nothing on methods or constructors. |
BasicBeanDescription |
BasicClassIntrospector.forClassAnnotations(MapperConfig<?> cfg,
JavaType type,
ClassIntrospector.MixInResolver r)
|
abstract BeanDescription |
ClassIntrospector.forCreation(DeserializationConfig cfg,
JavaType type,
ClassIntrospector.MixInResolver r)
Factory method that constructs an introspector that has information necessary for creating instances of given class ("creator"), as well as class annotations, but no information on member methods |
BasicBeanDescription |
BasicClassIntrospector.forCreation(DeserializationConfig cfg,
JavaType type,
ClassIntrospector.MixInResolver r)
|
abstract BeanDescription |
ClassIntrospector.forDeserialization(DeserializationConfig cfg,
JavaType type,
ClassIntrospector.MixInResolver r)
Factory method that constructs an introspector that has all information needed for deserialization purposes. |
BasicBeanDescription |
BasicClassIntrospector.forDeserialization(DeserializationConfig cfg,
JavaType type,
ClassIntrospector.MixInResolver r)
|
abstract BeanDescription |
ClassIntrospector.forDeserializationWithBuilder(DeserializationConfig cfg,
JavaType type,
ClassIntrospector.MixInResolver r)
Factory method that constructs an introspector that has all information needed for constructing deserializers that use intermediate Builder objects. |
BasicBeanDescription |
BasicClassIntrospector.forDeserializationWithBuilder(DeserializationConfig cfg,
JavaType type,
ClassIntrospector.MixInResolver r)
|
abstract BeanDescription |
ClassIntrospector.forDirectClassAnnotations(MapperConfig<?> cfg,
JavaType type,
ClassIntrospector.MixInResolver r)
Factory method that constructs an introspector that only has information regarding annotations class itself has (but NOT including its supertypes), but nothing on methods or constructors. |
BasicBeanDescription |
BasicClassIntrospector.forDirectClassAnnotations(MapperConfig<?> cfg,
JavaType type,
ClassIntrospector.MixInResolver r)
|
static BasicBeanDescription |
BasicBeanDescription.forOtherUse(MapperConfig<?> config,
JavaType type,
AnnotatedClass ac)
Factory method to use for constructing an instance to use for purposes other than building serializers or deserializers; will only have information on class, not on properties. |
abstract BeanDescription |
ClassIntrospector.forSerialization(SerializationConfig cfg,
JavaType type,
ClassIntrospector.MixInResolver r)
Factory method that constructs an introspector that has all information needed for serialization purposes. |
BasicBeanDescription |
BasicClassIntrospector.forSerialization(SerializationConfig cfg,
JavaType type,
ClassIntrospector.MixInResolver r)
|
Constructors in com.fasterxml.jackson.databind.introspect with parameters of type JavaType | |
---|---|
BasicBeanDescription(MapperConfig<?> config,
JavaType type,
AnnotatedClass classDef,
List<BeanPropertyDefinition> props)
|
|
POJOPropertiesCollector(MapperConfig<?> config,
boolean forSerialization,
JavaType type,
AnnotatedClass classDef,
String mutatorPrefix)
|
Uses of JavaType in com.fasterxml.jackson.databind.jsonFormatVisitors |
---|
Methods in com.fasterxml.jackson.databind.jsonFormatVisitors with parameters of type JavaType | |
---|---|
void |
JsonFormatVisitable.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor,
JavaType typeHint)
Get the representation of the schema to which this serializer will conform. |
JsonAnyFormatVisitor |
JsonFormatVisitorWrapper.expectAnyFormat(JavaType convertedType)
|
JsonArrayFormatVisitor |
JsonFormatVisitorWrapper.expectArrayFormat(JavaType convertedType)
|
JsonBooleanFormatVisitor |
JsonFormatVisitorWrapper.expectBooleanFormat(JavaType convertedType)
|
JsonIntegerFormatVisitor |
JsonFormatVisitorWrapper.expectIntegerFormat(JavaType convertedType)
|
JsonNullFormatVisitor |
JsonFormatVisitorWrapper.expectNullFormat(JavaType convertedType)
|
JsonNumberFormatVisitor |
JsonFormatVisitorWrapper.expectNumberFormat(JavaType convertedType)
|
JsonObjectFormatVisitor |
JsonFormatVisitorWrapper.expectObjectFormat(JavaType convertedType)
|
JsonStringFormatVisitor |
JsonFormatVisitorWrapper.expectStringFormat(JavaType convertedType)
|
void |
JsonArrayFormatVisitor.itemsFormat(JavaType contentType)
|
void |
JsonObjectFormatVisitor.optionalProperty(String name,
JsonFormatVisitable handler,
JavaType propertyTypeHint)
|
void |
JsonObjectFormatVisitor.property(String name,
JsonFormatVisitable handler,
JavaType propertyTypeHint)
|
Uses of JavaType in com.fasterxml.jackson.databind.jsontype |
---|
Methods in com.fasterxml.jackson.databind.jsontype that return JavaType | |
---|---|
JavaType |
TypeIdResolver.typeFromId(String id)
Method called to resolve type from given type identifier. |
Methods in com.fasterxml.jackson.databind.jsontype with parameters of type JavaType | |
---|---|
TypeDeserializer |
TypeResolverBuilder.buildTypeDeserializer(DeserializationConfig config,
JavaType baseType,
Collection<NamedType> subtypes)
Method for building type deserializer based on current configuration of this builder. |
TypeSerializer |
TypeResolverBuilder.buildTypeSerializer(SerializationConfig config,
JavaType baseType,
Collection<NamedType> subtypes)
Method for building type serializer based on current configuration of this builder. |
abstract Collection<NamedType> |
SubtypeResolver.collectAndResolveSubtypes(AnnotatedMember property,
MapperConfig<?> config,
AnnotationIntrospector ai,
JavaType baseType)
Method for finding out all reachable subtypes for a property specified by given element (method or field) |
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 com.fasterxml.jackson.databind.jsontype.impl |
---|
Fields in com.fasterxml.jackson.databind.jsontype.impl declared as JavaType | |
---|---|
protected JavaType |
TypeIdResolverBase._baseType
Common base type for all polymorphic instances handled. |
protected JavaType |
TypeDeserializerBase._baseType
|
protected JavaType |
TypeDeserializerBase._defaultImpl
Type to use as the default implementation, if type id is missing or can not be resolved. |
Fields in com.fasterxml.jackson.databind.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 com.fasterxml.jackson.databind.jsontype.impl that return JavaType | |
---|---|
JavaType |
TypeNameIdResolver.typeFromId(String id)
|
JavaType |
MinimalClassNameIdResolver.typeFromId(String id)
|
JavaType |
ClassNameIdResolver.typeFromId(String id)
|
Methods in com.fasterxml.jackson.databind.jsontype.impl with parameters of type JavaType | |
---|---|
TypeDeserializer |
StdTypeResolverBuilder.buildTypeDeserializer(DeserializationConfig config,
JavaType baseType,
Collection<NamedType> subtypes)
|
TypeSerializer |
StdTypeResolverBuilder.buildTypeSerializer(SerializationConfig config,
JavaType baseType,
Collection<NamedType> subtypes)
|
Collection<NamedType> |
StdSubtypeResolver.collectAndResolveSubtypes(AnnotatedMember property,
MapperConfig<?> config,
AnnotationIntrospector ai,
JavaType baseType)
|
static TypeNameIdResolver |
TypeNameIdResolver.construct(MapperConfig<?> config,
JavaType baseType,
Collection<NamedType> subtypes,
boolean forSer,
boolean forDeser)
|
protected TypeIdResolver |
StdTypeResolverBuilder.idResolver(MapperConfig<?> config,
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 com.fasterxml.jackson.databind.jsontype.impl with parameters of type JavaType | |
---|---|
AsArrayTypeDeserializer(JavaType bt,
TypeIdResolver idRes,
String typePropertyName,
boolean typeIdVisible,
Class<?> defaultImpl)
|
|
AsExternalTypeDeserializer(JavaType bt,
TypeIdResolver idRes,
String typePropertyName,
boolean typeIdVisible,
Class<?> defaultImpl)
|
|
AsPropertyTypeDeserializer(JavaType bt,
TypeIdResolver idRes,
String typePropertyName,
boolean typeIdVisible,
Class<?> defaultImpl)
|
|
AsWrapperTypeDeserializer(JavaType bt,
TypeIdResolver idRes,
String typePropertyName,
boolean typeIdVisible,
Class<?> defaultImpl)
|
|
ClassNameIdResolver(JavaType baseType,
TypeFactory typeFactory)
|
|
MinimalClassNameIdResolver(JavaType baseType,
TypeFactory typeFactory)
|
|
TypeDeserializerBase(JavaType baseType,
TypeIdResolver idRes,
String typePropertyName,
boolean typeIdVisible,
Class<?> defaultImpl)
|
|
TypeIdResolverBase(JavaType baseType,
TypeFactory typeFactory)
|
|
TypeNameIdResolver(MapperConfig<?> config,
JavaType baseType,
HashMap<String,String> typeToId,
HashMap<String,JavaType> idToType)
|
Constructor parameters in com.fasterxml.jackson.databind.jsontype.impl with type arguments of type JavaType | |
---|---|
TypeNameIdResolver(MapperConfig<?> config,
JavaType baseType,
HashMap<String,String> typeToId,
HashMap<String,JavaType> idToType)
|
Uses of JavaType in com.fasterxml.jackson.databind.module |
---|
Methods in com.fasterxml.jackson.databind.module that return JavaType | |
---|---|
JavaType |
SimpleAbstractTypeResolver.findTypeMapping(DeserializationConfig config,
JavaType type)
|
JavaType |
SimpleAbstractTypeResolver.resolveAbstractType(DeserializationConfig config,
JavaType type)
|
Methods in com.fasterxml.jackson.databind.module with parameters of type JavaType | |
---|---|
JsonDeserializer<?> |
SimpleDeserializers.findBeanDeserializer(JavaType type,
DeserializationConfig config,
BeanDescription beanDesc)
|
KeyDeserializer |
SimpleKeyDeserializers.findKeyDeserializer(JavaType type,
DeserializationConfig config,
BeanDescription beanDesc)
|
JsonSerializer<?> |
SimpleSerializers.findSerializer(SerializationConfig config,
JavaType type,
BeanDescription beanDesc)
|
JavaType |
SimpleAbstractTypeResolver.findTypeMapping(DeserializationConfig config,
JavaType type)
|
JavaType |
SimpleAbstractTypeResolver.resolveAbstractType(DeserializationConfig config,
JavaType type)
|
Uses of JavaType in com.fasterxml.jackson.databind.ser |
---|
Fields in com.fasterxml.jackson.databind.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 |
BeanPropertyWriter._declaredType
Type property is declared to have, either in class definition or associated annotations. |
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 parameterized. |
protected JavaType |
SerializerCache.TypeKey._type
|
Methods in com.fasterxml.jackson.databind.ser with type parameters of type JavaType | ||
---|---|---|
protected static
|
BasicSerializerFactory.modifySecondaryTypesByAnnotation(SerializationConfig config,
Annotated a,
T type)
|
|
protected
|
BasicSerializerFactory.modifyTypeByAnnotation(SerializationConfig config,
Annotated a,
T type)
Helper method used to encapsulate details of annotation-based type coercion |
Methods in com.fasterxml.jackson.databind.ser that return JavaType | |
---|---|
protected JavaType |
PropertyBuilder.findSerializationType(Annotated a,
boolean useStaticTyping,
JavaType declaredType)
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). |
abstract JavaType |
ContainerSerializer.getContentType()
Accessor for finding declared (static) element type for type this serializer is used for. |
JavaType |
BeanPropertyWriter.getSerializationType()
|
JavaType |
BeanPropertyWriter.getType()
|
Methods in com.fasterxml.jackson.databind.ser with parameters of type JavaType | |
---|---|
void |
DefaultSerializerProvider.acceptJsonFormatVisitor(JavaType javaType,
JsonFormatVisitorWrapper visitor)
The method to be called by ObjectMapper and ObjectWriter
to to expose the format of the given to to the given visitor |
void |
SerializerCache.addAndResolveNonTypedSerializer(JavaType type,
JsonSerializer<Object> ser,
SerializerProvider provider)
|
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.buildContainerSerializer(SerializerProvider prov,
JavaType type,
BeanDescription beanDesc,
BeanProperty property,
boolean staticTyping)
Deprecated. Since 2.1 (removed 'property' argument) |
protected JsonSerializer<?> |
BasicSerializerFactory.buildContainerSerializer(SerializerProvider prov,
JavaType type,
BeanDescription beanDesc,
boolean staticTyping)
|
protected JsonSerializer<?> |
BasicSerializerFactory.buildIterableSerializer(SerializationConfig config,
JavaType type,
BeanDescription beanDesc,
boolean staticTyping)
|
protected JsonSerializer<?> |
BasicSerializerFactory.buildIteratorSerializer(SerializationConfig config,
JavaType type,
BeanDescription beanDesc,
boolean staticTyping)
|
protected BeanPropertyWriter |
PropertyBuilder.buildWriter(BeanPropertyDefinition propDef,
JavaType declaredType,
JsonSerializer<?> ser,
TypeSerializer typeSer,
TypeSerializer contentTypeSer,
AnnotatedMember am,
boolean defaultUseStaticTyping)
|
static BeanSerializer |
BeanSerializer.createDummy(JavaType forType)
Method for constructing dummy bean serializer; one that never outputs any properties |
abstract JsonSerializer<Object> |
SerializerFactory.createKeySerializer(SerializationConfig config,
JavaType baseType)
Method called to create serializer to use for serializing JSON property names (which must be output as JsonToken.FIELD_NAME ) for Map that has specified declared
key type, and is for specified property (or, if property is null, as root value) |
JsonSerializer<Object> |
BasicSerializerFactory.createKeySerializer(SerializationConfig config,
JavaType type)
|
abstract JsonSerializer<Object> |
SerializerFactory.createSerializer(SerializerProvider prov,
JavaType baseType)
Method called to create (or, for immutable serializers, reuse) a serializer for given type. |
JsonSerializer<Object> |
BeanSerializerFactory.createSerializer(SerializerProvider prov,
JavaType origType)
Main serializer constructor method. |
abstract JsonSerializer<Object> |
BasicSerializerFactory.createSerializer(SerializerProvider prov,
JavaType type)
|
JsonSerializer<Object> |
SerializerFactory.createSerializer(SerializerProvider prov,
JavaType baseType,
BeanProperty property)
Deprecated. Since 2.1: need to use the new variant without 'property' argument (since one won't be passed) |
abstract TypeSerializer |
SerializerFactory.createTypeSerializer(SerializationConfig config,
JavaType baseType)
Method called to create a type information serializer for given base type, if one is needed. |
TypeSerializer |
BasicSerializerFactory.createTypeSerializer(SerializationConfig config,
JavaType baseType)
Method called to construct a type serializer for values with given declared base type. |
JsonSerializer<Object> |
BeanSerializerFactory.findBeanSerializer(SerializerProvider prov,
JavaType type,
BeanDescription beanDesc)
Method that will try to construct a BeanSerializer for
given class. |
JsonSerializer<Object> |
BeanSerializerFactory.findBeanSerializer(SerializerProvider prov,
JavaType type,
BeanDescription beanDesc,
BeanProperty property)
Deprecated. Since 2.1 (use variant without 'property' argument). |
TypeSerializer |
BeanSerializerFactory.findPropertyContentTypeSerializer(JavaType containerType,
SerializationConfig config,
AnnotatedMember accessor)
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 accessor)
Method called to create a type information serializer for values of given non-container property if one is needed. |
TypeSerializer |
BeanSerializerFactory.findPropertyTypeSerializer(JavaType baseType,
SerializationConfig config,
AnnotatedMember accessor,
BeanProperty property)
Deprecated. Since 2.1 |
protected JavaType |
PropertyBuilder.findSerializationType(Annotated a,
boolean useStaticTyping,
JavaType declaredType)
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). |
JsonSerializer<?> |
Serializers.findSerializer(SerializationConfig config,
JavaType type,
BeanDescription beanDesc)
Method called by serialization framework first time a serializer is needed for specified type, which is not of a container type (for which other methods are called). |
JsonSerializer<?> |
Serializers.Base.findSerializer(SerializationConfig config,
JavaType type,
BeanDescription beanDesc)
|
protected JsonSerializer<?> |
BasicSerializerFactory.findSerializerByAddonType(SerializationConfig config,
JavaType javaType,
BeanDescription beanDesc,
boolean staticTyping)
Reflection-based serialized find method, which checks if given class implements one of recognized "add-on" interfaces. |
protected JsonSerializer<?> |
BasicSerializerFactory.findSerializerByAnnotations(SerializerProvider prov,
JavaType type,
BeanDescription beanDesc)
Method called to see if one of primary per-class annotations (or related, like implementing of JsonSerializable )
determines the serializer to use. |
protected JsonSerializer<?> |
BasicSerializerFactory.findSerializerByLookup(JavaType type,
SerializationConfig config,
BeanDescription beanDesc,
boolean staticTyping)
Method that will use fast lookup (and identity comparison) methods to see if we know serializer to use for given type. |
protected JsonSerializer<?> |
BasicSerializerFactory.findSerializerByPrimaryType(SerializerProvider prov,
JavaType type,
BeanDescription beanDesc,
boolean staticTyping)
Method for checking if we can determine serializer to use based on set of known primary types, checking for set of known base types (exact matches having been compared against with findSerializerByLookup ). |
void |
SerializerCache.TypeKey.resetTyped(JavaType type)
|
void |
SerializerCache.TypeKey.resetUntyped(JavaType type)
|
void |
DefaultSerializerProvider.serializeValue(JsonGenerator jgen,
Object value,
JavaType rootType)
The method to be called by ObjectMapper and ObjectWriter
for serializing given value (assumed to be of specified root type,
instead of runtime type of value),
using serializers that
this provider has access to (via caching and/or creating new serializers
as need be), |
void |
DefaultSerializerProvider.serializeValue(JsonGenerator jgen,
Object value,
JavaType rootType,
JsonSerializer<Object> ser)
The method to be called by ObjectWriter
for serializing given value (assumed to be of specified root type,
instead of runtime type of value), when it may know specific
JsonSerializer to use. |
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> |
SerializerCache.untypedValueSerializer(JavaType type)
|
Constructors in com.fasterxml.jackson.databind.ser with parameters of type JavaType | |
---|---|
BeanPropertyWriter(BeanPropertyDefinition propDef,
AnnotatedMember member,
Annotations contextAnnotations,
JavaType declaredType,
JsonSerializer<?> ser,
TypeSerializer typeSer,
JavaType serType,
boolean suppressNulls,
Object suppressableValue)
|
|
BeanSerializer(JavaType type,
BeanSerializerBuilder builder,
BeanPropertyWriter[] properties,
BeanPropertyWriter[] filteredProperties)
|
|
SerializerCache.TypeKey(JavaType key,
boolean typed)
|
Uses of JavaType in com.fasterxml.jackson.databind.ser.impl |
---|
Fields in com.fasterxml.jackson.databind.ser.impl declared as JavaType | |
---|---|
JavaType |
ObjectIdWriter.idType
|
Methods in com.fasterxml.jackson.databind.ser.impl that return JavaType | |
---|---|
JavaType |
StringArraySerializer.getContentType()
|
Methods in com.fasterxml.jackson.databind.ser.impl with parameters of type JavaType | |
---|---|
void |
UnknownSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor,
JavaType typeHint)
|
void |
StringArraySerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor,
JavaType typeHint)
|
void |
FailingSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor,
JavaType typeHint)
|
static ObjectIdWriter |
ObjectIdWriter.construct(JavaType idType,
String propName,
ObjectIdGenerator<?> generator,
boolean alwaysAsId)
Factory method called by BeanSerializerBase
with the initial information based on standard settings for the type
for which serializer is being built. |
PropertySerializerMap.SerializerAndMapResult |
PropertySerializerMap.findAndAddSerializer(JavaType type,
SerializerProvider provider,
BeanProperty property)
|
JsonSerializer<Object> |
ReadOnlyClassToSerializerMap.typedValueSerializer(JavaType type)
|
JsonSerializer<Object> |
ReadOnlyClassToSerializerMap.untypedValueSerializer(JavaType type)
|
Constructors in com.fasterxml.jackson.databind.ser.impl with parameters of type JavaType | |
---|---|
IndexedListSerializer(JavaType elemType,
boolean staticTyping,
TypeSerializer vts,
BeanProperty property,
JsonSerializer<Object> valueSerializer)
|
|
IteratorSerializer(JavaType elemType,
boolean staticTyping,
TypeSerializer vts,
BeanProperty property)
|
|
ObjectIdWriter(JavaType t,
SerializedString propName,
ObjectIdGenerator<?> gen,
JsonSerializer<?> ser,
boolean alwaysAsId)
|
Uses of JavaType in com.fasterxml.jackson.databind.ser.std |
---|
Fields in com.fasterxml.jackson.databind.ser.std declared as JavaType | |
---|---|
protected JavaType |
StdDelegatingSerializer._delegateType
Fully resolved delegate type, with generic information if any available. |
protected JavaType |
ObjectArraySerializer._elementType
Declared type of element entries |
protected JavaType |
AsArraySerializerBase._elementType
|
protected JavaType |
MapSerializer._keyType
Declared type of keys |
protected JavaType |
MapSerializer._valueType
Declared type of contained values |
protected JavaType |
EnumMapSerializer._valueType
|
protected static JavaType |
MapSerializer.UNSPECIFIED_TYPE
|
Methods in com.fasterxml.jackson.databind.ser.std that return JavaType | |
---|---|
JavaType |
StdArraySerializers.BooleanArraySerializer.getContentType()
|
JavaType |
StdArraySerializers.ShortArraySerializer.getContentType()
|
JavaType |
StdArraySerializers.IntArraySerializer.getContentType()
|
JavaType |
StdArraySerializers.LongArraySerializer.getContentType()
|
JavaType |
StdArraySerializers.FloatArraySerializer.getContentType()
|
JavaType |
StdArraySerializers.DoubleArraySerializer.getContentType()
|
JavaType |
ObjectArraySerializer.getContentType()
|
JavaType |
MapSerializer.getContentType()
|
JavaType |
EnumMapSerializer.getContentType()
|
JavaType |
AsArraySerializerBase.getContentType()
|
Methods in com.fasterxml.jackson.databind.ser.std with parameters of type JavaType | |
---|---|
protected JsonSerializer<Object> |
ObjectArraySerializer._findAndAddDynamic(PropertySerializerMap map,
JavaType type,
SerializerProvider provider)
|
protected JsonSerializer<Object> |
MapSerializer._findAndAddDynamic(PropertySerializerMap map,
JavaType type,
SerializerProvider provider)
|
protected JsonSerializer<Object> |
AsArraySerializerBase._findAndAddDynamic(PropertySerializerMap map,
JavaType type,
SerializerProvider provider)
|
void |
ToStringSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor,
JavaType typeHint)
|
void |
TokenBufferSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor,
JavaType typeHint)
|
void |
StringSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor,
JavaType typeHint)
|
void |
StdSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor,
JavaType typeHint)
Default implementation specifies no format. |
void |
StdScalarSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor,
JavaType typeHint)
|
void |
StdKeySerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor,
JavaType typeHint)
|
void |
StdJdkSerializers.AtomicBooleanSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor,
JavaType typeHint)
|
void |
StdJdkSerializers.AtomicIntegerSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor,
JavaType typeHint)
|
void |
StdJdkSerializers.AtomicLongSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor,
JavaType typeHint)
|
void |
StdJdkSerializers.AtomicReferenceSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor,
JavaType typeHint)
|
void |
StdJdkSerializers.FileSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor,
JavaType typeHint)
|
void |
StdJdkSerializers.ClassSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor,
JavaType typeHint)
|
void |
StdDelegatingSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor,
JavaType typeHint)
|
void |
StdArraySerializers.BooleanArraySerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor,
JavaType typeHint)
|
void |
StdArraySerializers.ByteArraySerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor,
JavaType typeHint)
|
void |
StdArraySerializers.ShortArraySerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor,
JavaType typeHint)
|
void |
StdArraySerializers.CharArraySerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor,
JavaType typeHint)
|
void |
StdArraySerializers.IntArraySerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor,
JavaType typeHint)
|
void |
StdArraySerializers.LongArraySerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor,
JavaType typeHint)
|
void |
StdArraySerializers.FloatArraySerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor,
JavaType typeHint)
|
void |
StdArraySerializers.DoubleArraySerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor,
JavaType typeHint)
|
void |
StaticListSerializerBase.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor,
JavaType typeHint)
|
void |
SqlTimeSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor,
JavaType typeHint)
|
void |
SqlDateSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor,
JavaType typeHint)
|
void |
SerializableSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor,
JavaType typeHint)
|
void |
RawSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor,
JavaType typeHint)
|
void |
ObjectArraySerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor,
JavaType typeHint)
|
void |
NumberSerializers.IntegerSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor,
JavaType typeHint)
|
void |
NumberSerializers.IntLikeSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor,
JavaType typeHint)
|
void |
NumberSerializers.LongSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor,
JavaType typeHint)
|
void |
NumberSerializers.FloatSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor,
JavaType typeHint)
|
void |
NumberSerializers.DoubleSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor,
JavaType typeHint)
|
void |
NumberSerializers.NumberSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor,
JavaType typeHint)
|
void |
NullSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor,
JavaType typeHint)
|
void |
MapSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor,
JavaType typeHint)
|
void |
JsonValueSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor,
JavaType typeHint)
|
void |
EnumSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor,
JavaType typeHint)
|
void |
EnumMapSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor,
JavaType typeHint)
|
void |
DateTimeSerializerBase.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor,
JavaType typeHint)
|
void |
BooleanSerializer.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor,
JavaType typeHint)
|
void |
BeanSerializerBase.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor,
JavaType typeHint)
|
void |
AsArraySerializerBase.acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor,
JavaType typeHint)
|
static ContainerSerializer<?> |
StdContainerSerializers.collectionSerializer(JavaType elemType,
boolean staticTyping,
TypeSerializer vts,
BeanProperty property,
JsonSerializer<Object> valueSerializer)
Deprecated. Since 2.1; use variant that does not take 'property' argument |
static ContainerSerializer<?> |
StdContainerSerializers.collectionSerializer(JavaType elemType,
boolean staticTyping,
TypeSerializer vts,
JsonSerializer<Object> valueSerializer)
|
static MapSerializer |
MapSerializer.construct(String[] ignoredList,
JavaType mapType,
boolean staticValueType,
TypeSerializer vts,
JsonSerializer<Object> keySerializer,
JsonSerializer<Object> valueSerializer)
|
static JsonSerializer<?> |
StdContainerSerializers.enumSetSerializer(JavaType enumType)
|
static JsonSerializer<Object> |
StdKeySerializers.getStdKeySerializer(JavaType keyType)
|
static ContainerSerializer<?> |
StdContainerSerializers.indexedListSerializer(JavaType elemType,
boolean staticTyping,
TypeSerializer vts,
BeanProperty property,
JsonSerializer<Object> valueSerializer)
Deprecated. Since 2.1; use variant that does not take 'property' argument |
static ContainerSerializer<?> |
StdContainerSerializers.indexedListSerializer(JavaType elemType,
boolean staticTyping,
TypeSerializer vts,
JsonSerializer<Object> valueSerializer)
|
static ContainerSerializer<?> |
StdContainerSerializers.iterableSerializer(JavaType elemType,
boolean staticTyping,
TypeSerializer vts)
|
static ContainerSerializer<?> |
StdContainerSerializers.iteratorSerializer(JavaType elemType,
boolean staticTyping,
TypeSerializer vts)
|
protected StdDelegatingSerializer |
StdDelegatingSerializer.withDelegate(Converter<Object,?> converter,
JavaType delegateType,
JsonSerializer<?> delegateSerializer)
Method used for creating resolved contextual instances. |
Uses of JavaType in com.fasterxml.jackson.databind.type |
---|
Subclasses of JavaType in com.fasterxml.jackson.databind.type | |
---|---|
class |
ArrayType
Array types represent Java arrays, both primitive and object valued. |
class |
CollectionLikeType
Type that represents things that act similar to Collection ;
but may or may not be instances of that interface. |
class |
CollectionType
Type that represents Java Collection types (Lists, Sets). |
class |
MapLikeType
Type that represents Map-like types; things that consist of key/value pairs but that do not necessarily implement Map , but that do not have enough
introspection functionality to allow for some level of generic handling. |
class |
MapType
Type that represents "true" 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 com.fasterxml.jackson.databind.type declared as JavaType | |
---|---|
protected JavaType |
ArrayType._componentType
Type of elements in the array. |
protected JavaType |
TypeBindings._contextType
Context type used for resolving all types, if specified. |
protected JavaType |
CollectionLikeType._elementType
Type of elements in collection |
protected JavaType |
MapLikeType._keyType
Type of keys of Map. |
protected JavaType[] |
SimpleType._typeParameters
Generic type arguments for this type. |
protected JavaType |
MapLikeType._valueType
Type of values of Map. |
static JavaType |
TypeBindings.UNBOUND
Marker to use for (temporarily) unbound references. |
Fields in com.fasterxml.jackson.databind.type with type parameters of type JavaType | |
---|---|
protected Map<String,JavaType> |
TypeBindings._bindings
Lazily-instantiated bindings of resolved type parameters |
protected LRUMap<ClassKey,JavaType> |
TypeFactory._typeCache
Since type resolution can be expensive (specifically when resolving actual generic types), we will use small cache to avoid repetitive resolution of core types |
Methods in com.fasterxml.jackson.databind.type that return JavaType | |
---|---|
JavaType |
TypeFactory._constructType(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._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. |
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 |
MapLikeType._narrow(Class<?> subclass)
|
protected JavaType |
CollectionType._narrow(Class<?> subclass)
|
protected JavaType |
CollectionLikeType._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._resolveVariableViaSubTypes(HierarchicType leafType,
String variableName,
TypeBindings bindings)
|
protected JavaType |
TypeFactory._unknownType()
|
JavaType |
TypeFactory.constructFromCanonical(String canonical)
Factory method for constructing a JavaType out of its canonical
representation (see ResolvedType.toCanonical() ). |
JavaType |
TypeFactory.constructParametricType(Class<?> parametrized,
Class<?>... parameterClasses)
Factory method for constructing JavaType that
represents a parameterized type. |
JavaType |
TypeFactory.constructParametricType(Class<?> parametrized,
JavaType... parameterTypes)
Factory method for constructing JavaType that
represents a parameterized type. |
JavaType |
TypeFactory.constructSimpleType(Class<?> rawType,
JavaType[] parameterTypes)
Method for constructing a type instance with specified parameterization. |
JavaType |
TypeFactory.constructSpecializedType(JavaType baseType,
Class<?> subclass)
Factory method for creating a subtype of given base type, as defined by specified subclass; but retaining generic type information if any. |
JavaType |
TypeFactory.constructType(Type type)
|
JavaType |
TypeFactory.constructType(Type type,
Class<?> context)
|
JavaType |
TypeFactory.constructType(Type type,
JavaType context)
|
JavaType |
TypeFactory.constructType(TypeReference<?> typeRef)
|
JavaType |
TypeFactory.constructType(Type type,
TypeBindings bindings)
|
JavaType |
SimpleType.containedType(int index)
|
JavaType |
MapLikeType.containedType(int index)
|
JavaType |
CollectionLikeType.containedType(int index)
|
JavaType |
ArrayType.containedType(int index)
|
JavaType |
TypeBindings.findType(String name)
|
JavaType[] |
TypeFactory.findTypeParameters(Class<?> clz,
Class<?> expType)
|
JavaType[] |
TypeFactory.findTypeParameters(Class<?> clz,
Class<?> expType,
TypeBindings bindings)
|
JavaType[] |
TypeFactory.findTypeParameters(JavaType type,
Class<?> expType)
Method that is to figure out actual type parameters that given class binds to generic types defined by given (generic) interface or class. |
JavaType |
MapLikeType.getContentType()
|
JavaType |
CollectionLikeType.getContentType()
|
JavaType |
ArrayType.getContentType()
|
JavaType |
MapLikeType.getKeyType()
|
abstract JavaType |
TypeModifier.modifyType(JavaType type,
Type jdkType,
TypeBindings context,
TypeFactory typeFactory)
Method called to let modifier change constructed type definition. |
JavaType |
SimpleType.narrowContentsBy(Class<?> subclass)
|
JavaType |
MapType.narrowContentsBy(Class<?> contentClass)
|
JavaType |
MapLikeType.narrowContentsBy(Class<?> contentClass)
|
JavaType |
CollectionType.narrowContentsBy(Class<?> contentClass)
|
JavaType |
CollectionLikeType.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)
|
JavaType |
MapLikeType.narrowKey(Class<?> keySubclass)
|
JavaType |
TypeParser.parse(String canonical)
|
protected JavaType |
TypeParser.parseType(com.fasterxml.jackson.databind.type.TypeParser.MyTokenizer tokens)
|
JavaType |
TypeBindings.resolveType(Class<?> cls)
|
JavaType |
TypeBindings.resolveType(Type type)
|
JavaType[] |
TypeBindings.typesAsArray()
|
JavaType |
TypeFactory.uncheckedSimpleType(Class<?> cls)
Method that will force construction of a simple type, without trying to check for more specialized types. |
static JavaType |
TypeFactory.unknownType()
Method for constructing a marker type that indicates missing generic type information, which is handled same as simple type for java.lang.Object . |
JavaType |
SimpleType.widenContentsBy(Class<?> subclass)
|
JavaType |
MapType.widenContentsBy(Class<?> contentClass)
|
JavaType |
MapLikeType.widenContentsBy(Class<?> contentClass)
|
JavaType |
CollectionType.widenContentsBy(Class<?> contentClass)
|
JavaType |
CollectionLikeType.widenContentsBy(Class<?> contentClass)
|
JavaType |
ArrayType.widenContentsBy(Class<?> contentClass)
|
JavaType |
MapType.widenKey(Class<?> keySubclass)
|
JavaType |
MapLikeType.widenKey(Class<?> keySubclass)
|
JavaType |
SimpleType.withContentTypeHandler(Object h)
|
Methods in com.fasterxml.jackson.databind.type that return types with arguments of type JavaType | |
---|---|
protected List<JavaType> |
TypeParser.parseTypes(com.fasterxml.jackson.databind.type.TypeParser.MyTokenizer tokens)
|
Methods in com.fasterxml.jackson.databind.type with parameters of type JavaType | |
---|---|
void |
TypeBindings.addBinding(String name,
JavaType type)
|
static CollectionType |
CollectionType.construct(Class<?> rawType,
JavaType elemT)
|
static CollectionLikeType |
CollectionLikeType.construct(Class<?> rawType,
JavaType elemT)
|
static MapType |
MapType.construct(Class<?> rawType,
JavaType keyT,
JavaType valueT)
|
static MapLikeType |
MapLikeType.construct(Class<?> rawType,
JavaType keyT,
JavaType valueT)
|
static ArrayType |
ArrayType.construct(JavaType componentType,
Object valueHandler,
Object typeHandler)
|
ArrayType |
TypeFactory.constructArrayType(JavaType elementType)
Method for constructing an ArrayType . |
CollectionLikeType |
TypeFactory.constructCollectionLikeType(Class<?> collectionClass,
JavaType elementType)
Method for constructing a CollectionLikeType . |
CollectionType |
TypeFactory.constructCollectionType(Class<? extends Collection> collectionClass,
JavaType elementType)
Method for constructing a CollectionType . |
MapLikeType |
TypeFactory.constructMapLikeType(Class<?> mapClass,
JavaType keyType,
JavaType valueType)
Method for constructing a MapLikeType instance |
MapType |
TypeFactory.constructMapType(Class<? extends Map> mapClass,
JavaType keyType,
JavaType valueType)
Method for constructing a MapType instance |
JavaType |
TypeFactory.constructParametricType(Class<?> parametrized,
JavaType... parameterTypes)
Factory method for constructing JavaType that
represents a parameterized type. |
JavaType |
TypeFactory.constructSimpleType(Class<?> rawType,
JavaType[] parameterTypes)
Method for constructing a type instance with specified parameterization. |
JavaType |
TypeFactory.constructSpecializedType(JavaType baseType,
Class<?> subclass)
Factory method for creating a subtype of given base type, as defined by specified subclass; but retaining generic type information if any. |
JavaType |
TypeFactory.constructType(Type type,
JavaType context)
|
JavaType[] |
TypeFactory.findTypeParameters(JavaType type,
Class<?> expType)
Method that is to figure out actual type parameters that given class binds to generic types defined by given (generic) interface or class. |
abstract JavaType |
TypeModifier.modifyType(JavaType type,
Type jdkType,
TypeBindings context,
TypeFactory typeFactory)
Method called to let modifier change constructed type definition. |
Method parameters in com.fasterxml.jackson.databind.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 com.fasterxml.jackson.databind.type with parameters of type JavaType | |
---|---|
CollectionLikeType(Class<?> collT,
JavaType elemT,
Object valueHandler,
Object typeHandler)
|
|
MapLikeType(Class<?> mapType,
JavaType keyT,
JavaType valueT,
Object valueHandler,
Object typeHandler)
|
|
SimpleType(Class<?> cls,
String[] typeNames,
JavaType[] typeParams,
Object valueHandler,
Object typeHandler)
|
|
TypeBindings(TypeFactory typeFactory,
JavaType type)
|
Uses of JavaType in com.fasterxml.jackson.databind.util |
---|
Fields in com.fasterxml.jackson.databind.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 com.fasterxml.jackson.databind.util that return JavaType | |
---|---|
JavaType |
JSONWrappedObject.getSerializationType()
|
JavaType |
JSONPObject.getSerializationType()
|
Methods in com.fasterxml.jackson.databind.util with parameters of type JavaType | |
---|---|
SerializedString |
RootNameLookup.findRootName(JavaType rootType,
MapperConfig<?> config)
|
Constructors in com.fasterxml.jackson.databind.util with parameters of type JavaType | |
---|---|
JSONPObject(String function,
Object value,
JavaType asType)
|
|
JSONWrappedObject(String prefix,
String suffix,
Object value,
JavaType asType)
Constructor that should be used when specific serialization type to use is important, and needs to be passed instead of just using runtime (type-erased) type of the value. |
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |