Refine search
JavaType keyType = type.getKeyType(); JavaType contentType = type.getContentType(); JsonDeserializer<Object> contentDeser = (JsonDeserializer<Object>) contentType.getValueHandler(); KeyDeserializer keyDes = (KeyDeserializer) keyType.getValueHandler(); TypeDeserializer contentTypeDeser = contentType.getTypeHandler(); Class<?> mapClass = type.getRawClass(); if (EnumMap.class.isAssignableFrom(mapClass)) { ValueInstantiator inst; if (type.isInterface() || type.isAbstract()) { @SuppressWarnings("rawtypes") Class<? extends Map> fallback = _mapFallbacks.get(mapClass.getName()); } else { if (type.getTypeHandler() == null) { throw new IllegalArgumentException("Cannot find a deserializer for non-concrete Map type "+type);
JavaType result = _findWellKnownSimple(rawType); if (result != null) { return result; result = ArrayType.construct(_fromAny(context, rawType.getComponentType(), bindings), bindings); } else { superInterfaces = _resolveSuperInterfaces(context, rawType, bindings); } else { result = MapType.construct(rawType, bindings, superClass, superInterfaces, CORE_TYPE_STRING, CORE_TYPE_STRING); result = superClass.refine(rawType, bindings, superClass, superInterfaces); if (!result.hasHandlers()) {
@Override public MapType withKeyValueHandler(Object h) { return new MapType(_class, _bindings, _superClass, _superInterfaces, _keyType.withValueHandler(h), _valueType, _valueHandler, _typeHandler, _asStatic); }
@Deprecated // since 2.7 public static MapType 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); } // !!! TODO: Wrong, does have supertypes return new MapType(rawType, bindings, _bogusSuperClass(rawType), null, keyT, valueT, null, null, false); }
Class<?> enumClass = ClassUtil.findEnumType((EnumSet<?>) value); str = typeFactory.constructCollectionType(EnumSet.class, enumClass).toCanonical(); } else if (value instanceof EnumMap<?,?>) { Class<?> enumClass = ClassUtil.findEnumType((EnumMap<?,?>) value); Class<?> valueClass = Object.class; str = typeFactory.constructMapType(EnumMap.class, enumClass, valueClass).toCanonical(); Class<?> staticType = _baseType.getRawClass(); if (ClassUtil.getOuterClass(staticType) == null) { cls = _baseType.getRawClass(); str = cls.getName();
/** * Method for constructing a {@link MapLikeType} instance *<p> * NOTE: type modifiers are NOT called on constructed type itself; but are called * for contained types. */ public MapLikeType constructMapLikeType(Class<?> mapClass, Class<?> keyClass, Class<?> valueClass) { return MapType.construct(mapClass, constructType(keyClass), constructType(valueClass)); }
@Override public JavaType widenKey(Class<?> keySubclass) { // Can do a quick check first: if (keySubclass == _keyType.getRawClass()) { return this; } return new MapType(_class, _keyType.widenBy(keySubclass), _valueType, _valueHandler, _typeHandler, _asStatic); }
if (EnumMap.class.isAssignableFrom(type.getRawClass())) { JavaType keyType = type.getKeyType(); if (keyType.isEnumType()) { // non-enum if we got it as type erased class (from instance) @SuppressWarnings("unchecked") Class<Enum<?>> enumClass = (Class<Enum<?>>) keyType.getRawClass(); enums = EnumValues.construct(enumClass, config.getAnnotationIntrospector()); return new EnumMapSerializer(type.getContentType(), staticTyping, enums, elementTypeSerializer, elementValueSerializer);
@Override public JavaType narrowKey(Class<?> keySubclass) { // Can do a quick check first: if (keySubclass == _keyType.getRawClass()) { return this; } return new MapType(_class, _keyType.narrowBy(keySubclass), _valueType, _valueHandler, _typeHandler, _asStatic); }
public synchronized Class<?> fetchOrCreatePairClass(MapType mapType) { ClassPair classPair = new ClassPair(mapType.getKeyType().getRawClass(), mapType.getContentType().getRawClass()); return fetchOrCreatePairClass(classPair); }
@Override public JsonSerializer<?> findMapSerializer(SerializationConfig config, MapType type, BeanDescription beanDesc, JsonSerializer<Object> keySerializer, TypeSerializer elementTypeSerializer, JsonSerializer<Object> elementValueSerializer) { // without this logic, Jackson will not be able to handle maps containing // hibernate proxies if (AbstractEntity.class.isAssignableFrom(type.getContentType().getRawClass())) { Object filterId = config.getAnnotationIntrospector().findFilterId((Annotated)beanDesc.getClassInfo()); return MapSerializer.construct( config.getAnnotationIntrospector().findPropertyIgnorals(beanDesc.getClassInfo()).getIgnored(), type, false, elementTypeSerializer, keySerializer, elementValueSerializer, filterId); } else { return null; } }
return ArrayType.construct(_constructType(clz.getComponentType(), null), null, null); keyType = paramTypes.get(0); contentType = (paramTypes.size() >= 2) ? paramTypes.get(1) : _unknownType(); return MapType.construct(clz, keyType, contentType); return _mapType(clz);
/** * Method that can be used to construct "raw" Map type; meaning that its * parameterization is unknown. * This is similar to using <code>Object.class</code> parameterization, * and is equivalent to calling: *<pre> * typeFactory.constructMapType(collectionClass, typeFactory.unknownType(), typeFactory.unknownType()); *<pre> *<p> * This method should only be used if parameterization is completely unavailable. */ public MapType constructRawMapType(Class<? extends Map> mapClass) { return MapType.construct(mapClass, unknownType(), unknownType()); }
private JavaType _mapType(Class<?> rawClass) { JavaType[] typeParams = findTypeParameters(rawClass, Map.class); // ok to have no types ("raw") if (typeParams == null) { return MapType.construct(rawClass, _unknownType(), _unknownType()); } // but exactly 2 types if any found if (typeParams.length != 2) { throw new IllegalArgumentException("Strange Map type "+rawClass.getName()+": can not determine type parameters"); } return MapType.construct(rawClass, typeParams[0], typeParams[1]); }
/** * Method called to finalize setup of this deserializer, * after deserializer itself has been registered. This * is needed to handle recursive and transitive dependencies. */ @Override public JsonDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property) throws JsonMappingException { KeyDeserializer keyDeser = _keyDeserializer; JsonDeserializer<?> deser = _valueDeserializer; TypeDeserializer typeDeser = _typeDeserializerForValue; // Do we need any contextualization? if ((keyDeser != null) && (deser != null) && (typeDeser == null)) { // nope return this; } if (keyDeser == null) { keyDeser = ctxt.findKeyDeserializer(_mapType.getKeyType(), property); } if (deser == null) { deser = ctxt.findContextualValueDeserializer(_mapType.getContentType(), property); } if (typeDeser != null) { typeDeser = typeDeser.forProperty(property); } return withResolved(keyDeser, typeDeser, deser); }
pt = new JavaType[paramCount]; for (int i = 0; i < paramCount; ++i) { pt[i] = _constructType(args[i], context); JavaType subtype = constructSimpleType(rawType, rawType, pt); JavaType[] mapParams = findTypeParameters(subtype, Map.class); if (mapParams.length != 2) { throw new IllegalArgumentException("Could not find 2 type parameters for Map class "+rawType.getName()+" (found "+mapParams.length+")"); return MapType.construct(rawType, mapParams[0], mapParams[1]);
@SuppressWarnings("unchecked") @Override public T deserialize(JsonParser p, DeserializationContext ctxt) throws IOException { // Ok: must point to START_OBJECT or FIELD_NAME JsonToken t = p.getCurrentToken(); if (t == JsonToken.START_OBJECT) { // If START_OBJECT, move to next; may also be END_OBJECT t = p.nextToken(); } if (t != JsonToken.FIELD_NAME && t != JsonToken.END_OBJECT) { return (T) ctxt.handleUnexpectedToken(_mapType.getRawClass(), p); } return _deserializeEntries(p, ctxt); }
@Override public MapType withKeyTypeHandler(Object h) { return new MapType(_class, _bindings, _superClass, _superInterfaces, _keyType.withTypeHandler(h), _valueType, _valueHandler, _typeHandler, _asStatic); }
@Override public JsonSerializer<?> modifyMapSerializer(SerializationConfig config, MapType valueType, BeanDescription beanDesc, JsonSerializer<?> serializer) { if (valueType.getKeyType().equals(SimpleType.construct(String.class))) { return new DelegatingMapSerializer(serializer); } return serializer; } });
private JavaType _mapType(Class<?> rawClass, TypeBindings bindings, JavaType superClass, JavaType[] superInterfaces) { JavaType kt, vt; // 28-May-2015, tatu: Properties are special, as per [databind#810]; fake "correct" parameter sig if (rawClass == Properties.class) { kt = vt = CORE_TYPE_STRING; } else { List<JavaType> typeParams = bindings.getTypeParameters(); // ok to have no types ("raw") switch (typeParams.size()) { case 0: // acceptable? kt = vt = _unknownType(); break; case 2: kt = typeParams.get(0); vt = typeParams.get(1); break; default: throw new IllegalArgumentException("Strange Map type "+rawClass.getName()+": cannot determine type parameters"); } } return MapType.construct(rawClass, bindings, superClass, superInterfaces, kt, vt); }