throws JsonMappingException JavaType keyType = type.getKeyType(); JavaType contentType = type.getContentType(); final DeserializationConfig config = ctxt.getConfig(); JsonDeserializer<Object> contentDeser = (JsonDeserializer<Object>) contentType.getValueHandler(); KeyDeserializer keyDes = (KeyDeserializer) keyType.getValueHandler(); TypeDeserializer contentTypeDeser = contentType.getTypeHandler();
public MapLikeType withKeyValueHandler(Object h) { return new MapLikeType(_class, _bindings, _superClass, _superInterfaces, _keyType.withValueHandler(h), _valueType, _valueHandler, _typeHandler, _asStatic); }
@Override public StringBuilder getGenericSignature(StringBuilder sb) { _classSignature(_class, sb, false); sb.append('<'); _keyType.getGenericSignature(sb); _valueType.getGenericSignature(sb); sb.append(">;"); return sb; }
@Deprecated // since 2.7; remove from 2.8 public static MapLikeType construct(Class<?> rawType, JavaType keyT, JavaType valueT) { // First: may need to fabricate TypeBindings (needed for refining into // concrete collection types, as per [databind#1102]) TypeVariable<?>[] vars = rawType.getTypeParameters(); TypeBindings bindings; if ((vars == null) || (vars.length != 2)) { bindings = TypeBindings.emptyBindings(); } else { bindings = TypeBindings.create(rawType, keyT, valueT); } return new MapLikeType(rawType, bindings, _bogusSuperClass(rawType), null, keyT, valueT, null, null, false); }
throws JsonMappingException final DeserializationConfig config = ctxt.getConfig(); if (type.isEnumType()) { return factory.createEnumDeserializer(ctxt, type, beanDesc); if (type.isContainerType()) { if (type.isArrayType()) { return factory.createArrayDeserializer(ctxt, (ArrayType) type, beanDesc); JsonFormat.Value format = beanDesc.findExpectedFormat(null); if ((format == null) || format.getShape() != JsonFormat.Shape.OBJECT) { MapLikeType mlt = (MapLikeType) type; if (mlt.isTrueMapType()) { return factory.createMapDeserializer(ctxt,(MapType) mlt, beanDesc); JsonFormat.Value format = beanDesc.findExpectedFormat(null); if ((format == null) || format.getShape() != JsonFormat.Shape.OBJECT) { CollectionLikeType clt = (CollectionLikeType) type; if (clt.isTrueCollectionType()) { return factory.createCollectionDeserializer(ctxt, (CollectionType) clt, beanDesc);
throws JsonMappingException final DeserializationConfig config = ctxt.getConfig(); if (type.isAbstract() || type.isMapLikeType() || type.isCollectionLikeType()) { type = factory.mapAbstractType(config, type); beanDesc.getClassInfo()); if (deser != null) { return deser; JavaType newType = modifyTypeByAnnotation(ctxt, beanDesc.getClassInfo(), type); if (newType != type) { type = newType; Class<?> builder = beanDesc.findPOJOBuilder(); if (builder != null) { return (JsonDeserializer<Object>) factory.createBuilderBasedDeserializer( if (type.isMapLikeType()) { MapLikeType mlt = (MapLikeType) type; if (mlt.isTrueMapType()) { return (JsonDeserializer<Object>) factory.createMapDeserializer(ctxt, (MapType) mlt, beanDesc);
if (!staticTyping && type.useStaticType()) { if (!type.isContainerType() || !type.getContentType().isJavaLangObject()) { staticTyping = true; beanDesc.getClassInfo()); if (type.isMapLikeType()) { // implements java.util.Map MapLikeType mlt = (MapLikeType) type; JsonSerializer<Object> keySerializer = _findKeySerializer(prov, beanDesc.getClassInfo()); if (mlt.isTrueMapType()) { return buildMapSerializer(prov, (MapType) mlt, beanDesc, staticTyping, keySerializer, elementTypeSerializer, elementValueSerializer); if (type.isCollectionLikeType()) { CollectionLikeType clt = (CollectionLikeType) type; if (clt.isTrueCollectionType()) { return buildCollectionSerializer(prov, (CollectionType) clt, beanDesc, staticTyping, elementTypeSerializer, elementValueSerializer);
AnnotationIntrospector intr = ctxt.getAnnotationIntrospector(); Class<?> subclass = intr.findDeserializationType(a, type); if (subclass != null) { try { type = (T) type.narrowBy(subclass); } catch (IllegalArgumentException iae) { throw new JsonMappingException("Failed to narrow type "+type+" with concrete-type annotation (value "+subclass.getName()+"), method '"+a.getName()+"': "+iae.getMessage(), null, iae); if (type.isContainerType()) { Class<?> keyClass = intr.findDeserializationKeyType(a, type.getKeyType()); if (keyClass != null) { type = (T) ((MapLikeType) type).narrowKey(keyClass); } catch (IllegalArgumentException iae) { throw new JsonMappingException("Failed to narrow key type "+type+" with key-type annotation ("+keyClass.getName()+"): "+iae.getMessage(), null, iae); if (keyType != null && keyType.getValueHandler() == null) { Object kdDef = intr.findKeyDeserializer(a); KeyDeserializer kd = ctxt.keyDeserializerInstance(a, kdDef); if (kd != null) { type = (T) ((MapLikeType) type).withKeyValueHandler(kd); keyType = type.getKeyType(); // just in case it's used below if (contentType.getValueHandler() == null) { // as with above, avoid resetting (which would trigger exception) Object cdDef = intr.findContentDeserializer(a); JsonDeserializer<?> cd = ctxt.deserializerInstance(a, cdDef); if (cd != null) { type = (T) type.withContentValueHandler(cd);
@Override public JavaType modifyType(JavaType type, Type jdkType, TypeBindings bindings, TypeFactory typeFactory) { if (type.isReferenceType() || type.isContainerType()) { return type; } final Class<?> raw = type.getRawClass(); // First: make Multimaps look more Map-like if (raw == Multimap.class) { return MapLikeType.upgradeFrom(type, type.containedTypeOrUnknown(0), type.containedTypeOrUnknown(1)); } if (raw == Optional.class) { return ReferenceType.upgradeFrom(type, type.containedTypeOrUnknown(0)); } return type; } }
throws JsonMappingException AnnotationIntrospector intr = ctxt.getAnnotationIntrospector(); if (intr == null) { return type; if (type.isMapLikeType()) { JavaType keyType = type.getKeyType(); if (keyType != null && keyType.getValueHandler() == null) { Object kdDef = intr.findKeyDeserializer(a); if (kdDef != null) { KeyDeserializer kd = ctxt.keyDeserializerInstance(a, kdDef); if (kd != null) { type = ((MapLikeType) type).withKeyValueHandler(kd); keyType = type.getKeyType(); // just in case it's used below if (contentType != null) { if (contentType.getValueHandler() == null) { // as with above, avoid resetting (which would trigger exception) Object cdDef = intr.findContentDeserializer(a); if (cdDef != null) { JsonDeserializer<?> cd = null; Class<?> cdClass = _verifyAsClass(cdDef, "findContentDeserializer", JsonDeserializer.None.class); if (cdClass != null) { cd = ctxt.deserializerInstance(a, cdClass); type = intr.refineDeserializationType(ctxt.getConfig(), a, type);
if (type.isContainerType()) { AnnotationIntrospector intr = ctxt.getAnnotationIntrospector(); JavaType keyType = type.getKeyType(); if (keyType != null) { Object kdDef = intr.findKeyDeserializer(member); KeyDeserializer kd = ctxt.keyDeserializerInstance(member, kdDef); if (kd != null) { type = ((MapLikeType) type).withKeyValueHandler(kd); keyType = type.getKeyType(); // just in case it's used below Object cdDef = intr.findContentDeserializer(member); JsonDeserializer<?> cd = ctxt.deserializerInstance(member, cdDef); if (cd != null) { type = type.withContentValueHandler(cd);
@SuppressWarnings("unchecked") @Override public void resolve(DeserializationContext ctxt) throws JsonMappingException { JavaType keyType = javaType.getKeyType(); if (keyType.getRawClass().isAssignableFrom(Comparable.class)) { keyComparator = (Comparator<Object> & Serializable) (o1, o2) -> ((Comparable) o1).compareTo(o2); } else { keyComparator = (Comparator<Object> & Serializable) (o1, o2) -> o1.toString().compareTo(o2.toString()); } keyDeserializer = ctxt.findKeyDeserializer(keyType, null); valueDeserializer = ctxt.findRootValueDeserializer(javaType.getContentType()); } }
JavaType elementType = type.getContentType(); TypeSerializer elementTypeSerializer = createTypeSerializer(config, elementType); beanDesc.getClassInfo(), property); if (type.isMapLikeType()) { // implements java.util.Map MapLikeType mlt = (MapLikeType) type; JsonSerializer<Object> keySerializer = _findKeySerializer(prov, beanDesc.getClassInfo(), property); if (mlt.isTrueMapType()) { return buildMapSerializer(config, (MapType) mlt, beanDesc, staticTyping, keySerializer, elementTypeSerializer, elementValueSerializer); if (type.isCollectionLikeType()) { CollectionLikeType clt = (CollectionLikeType) type; if (clt.isTrueCollectionType()) { // only have custom ones, if any: return buildCollectionSerializer(config, (CollectionType) clt, beanDesc, property, staticTyping, elementTypeSerializer, elementValueSerializer);
throws JsonMappingException AnnotationIntrospector intr = ctxt.getAnnotationIntrospector(); if (intr == null) { return type; if (type.isMapLikeType()) { JavaType keyType = type.getKeyType(); if (keyType != null) { Object kdDef = intr.findKeyDeserializer(member); KeyDeserializer kd = ctxt.keyDeserializerInstance(member, kdDef); if (kd != null) { type = ((MapLikeType) type).withKeyValueHandler(kd); keyType = type.getKeyType(); // just in case it's used below if (type.hasContentType()) { // that is, is either container- or reference-type Object cdDef = intr.findContentDeserializer(member); JsonDeserializer<?> cd = ctxt.deserializerInstance(member, cdDef); if (cd != null) { type = type.withContentValueHandler(cd); type = intr.refineDeserializationType(ctxt.getConfig(), member, type); return type;
@Override public void resolve(DeserializationContext ctxt) throws JsonMappingException { super.resolve(ctxt); JavaType containerType = ctxt.getTypeFactory().constructCollectionType(ArrayList.class, javaType.getContentType()); containerDeserializer = ctxt.findContextualValueDeserializer(containerType, null); }
/** * Same as {@link #getType(com.fasterxml.jackson.databind.type.SimpleType)} * * @param jacksonType * @return */ public Type getType(MapLikeType jacksonType) { String signature = JacksonSignature.createSignature(jacksonType); JavaType keyType = jacksonType.getKeyType(); JavaType valueType = jacksonType.getContentType(); Class<?> containerClass = jacksonType.getRawClass(); String keySignature = JacksonSignature.createSignature(keyType); String valSignature = JacksonSignature.createSignature(valueType); MapTypeJrapidoc type = new MapTypeJrapidoc(containerClass.getName(), signature, keyType.getRawClass().getName(), keySignature, valueType .getRawClass().getName(), valSignature); if (cache.containsKey(signature)) { return cache.get(signature); } cache.put(signature, type); getType(keyType); getType(valueType); return type; }
@Override public JavaType modifyType(JavaType type, Type jdkType, TypeBindings bindings, TypeFactory typeFactory) { final Class<?> raw = type.getRawClass(); if (Seq.class.isAssignableFrom(raw) && CharSeq.class != raw) { return CollectionLikeType.upgradeFrom(type, type.containedTypeOrUnknown(0)); } if (Set.class.isAssignableFrom(raw)) { return CollectionLikeType.upgradeFrom(type, type.containedTypeOrUnknown(0)); } if (PriorityQueue.class.isAssignableFrom(raw)) { return CollectionLikeType.upgradeFrom(type, type.containedTypeOrUnknown(0)); } if (Map.class.isAssignableFrom(raw)) { return MapLikeType.upgradeFrom(type, type.containedTypeOrUnknown(0), type.containedTypeOrUnknown(1)); } if (Multimap.class.isAssignableFrom(raw)) { return MapLikeType.upgradeFrom(type, type.containedTypeOrUnknown(0), type.containedTypeOrUnknown(1)); } if (Lazy.class.isAssignableFrom(raw)) { return ReferenceType.upgradeFrom(type, type.containedTypeOrUnknown(0)); } if (Option.class.isAssignableFrom(raw)) { return ReferenceType.upgradeFrom(type, type.containedTypeOrUnknown(0)); } return type; } }
@Override JavaType emulatedJavaType(JavaType type, TypeFactory typeFactory) { MapLikeType mapLikeType = (MapLikeType) type; return typeFactory.constructMapType(LinkedHashMap.class, mapLikeType.getKeyType(), mapLikeType.getContentType()); }
/** * We need to use this method to properly handle possible contextual variants of key and value * deserializers, as well as type deserializers. */ @Override public JsonDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property) throws JsonMappingException { KeyDeserializer kd = keyDeserializer; if (kd == null) { kd = ctxt.findKeyDeserializer(type.getKeyType(), property); } JsonDeserializer<?> valueDeser = elementDeserializer; final JavaType vt = type.getContentType(); if (valueDeser == null) { valueDeser = ctxt.findContextualValueDeserializer(vt, property); } else { // if directly assigned, probably not yet contextual, so: valueDeser = ctxt.handleSecondaryContextualization(valueDeser, property, vt); } // Type deserializer is slightly different; must be passed, but needs to become contextual: TypeDeserializer vtd = elementTypeDeserializer; if (vtd != null) { vtd = vtd.forProperty(property); } return _createContextual(type, kd, vtd, valueDeser, creatorMethod, findContentNullProvider(ctxt, property, valueDeser)); }
JavaType valueType = _type.getContentType(); if (valueType.isFinal()) { valueSer = provider.findValueSerializer(valueType, property); Object serDef = intr.findKeySerializer(propertyAcc); if (serDef != null) { keySer = provider.serializerInstance(propertyAcc, serDef); serDef = intr.findContentSerializer(propertyAcc); if (serDef != null) { valueSer = provider.serializerInstance(propertyAcc, serDef); filterId = intr.findFilterId(propertyAcc); JavaType valueType = _type.getContentType(); if (valueType.useStaticType()) { valueSer = provider.findValueSerializer(valueType, property); keySer = provider.findKeySerializer(_type.getKeyType(), property); } else { keySer = provider.handleSecondaryContextualization(keySer, property);