/** * @deprecated Since 2.7 resolve raw type first, then find type parameters */ @Deprecated // since 2.7 public JavaType[] findTypeParameters(Class<?> clz, Class<?> expType, TypeBindings bindings) { return findTypeParameters(constructType(clz, bindings), expType); }
/** * @deprecated Since 2.7 resolve raw type first, then find type parameters */ @Deprecated // since 2.7 public JavaType[] findTypeParameters(Class<?> clz, Class<?> expType) { return findTypeParameters(constructType(clz), expType); }
/** * Reflection-based serialized find method, which checks if * given class implements one of recognized "add-on" interfaces. * Add-on here means a role that is usually or can be a secondary * trait: for example, * bean classes may implement {@link Iterable}, but their main * function is usually something else. The reason for */ protected final JsonSerializer<?> findSerializerByAddonType(SerializationConfig config, JavaType javaType, BeanDescription beanDesc, boolean staticTyping) throws JsonMappingException { Class<?> rawType = javaType.getRawClass(); if (Iterator.class.isAssignableFrom(rawType)) { JavaType[] params = config.getTypeFactory().findTypeParameters(javaType, Iterator.class); JavaType vt = (params == null || params.length != 1) ? TypeFactory.unknownType() : params[0]; return buildIteratorSerializer(config, javaType, beanDesc, staticTyping, vt); } if (Iterable.class.isAssignableFrom(rawType)) { JavaType[] params = config.getTypeFactory().findTypeParameters(javaType, Iterable.class); JavaType vt = (params == null || params.length != 1) ? TypeFactory.unknownType() : params[0]; return buildIterableSerializer(config, javaType, beanDesc, staticTyping, vt); } if (CharSequence.class.isAssignableFrom(rawType)) { return ToStringSerializer.instance; } return null; }
JavaType idType = prov.getTypeFactory().findTypeParameters(type, ObjectIdGenerator.class)[0]; gen = prov.objectIdGeneratorInstance(beanDesc.getClassInfo(), objectIdInfo); return ObjectIdWriter.construct(idType, objectIdInfo.getPropertyName(), gen,
} else { JavaType type = ctxt.constructType(implClass); idType = ctxt.getTypeFactory().findTypeParameters(type, ObjectIdGenerator.class)[0]; idProp = null; gen = ctxt.objectIdGeneratorInstance(beanDesc.getClassInfo(), objectIdInfo);
resolver = ctxt.objectIdResolverInstance(accessor, objectIdInfo); JavaType type = ctxt.constructType(implClass); idType = ctxt.getTypeFactory().findTypeParameters(type, ObjectIdGenerator.class)[0]; idGen = ctxt.objectIdGeneratorInstance(accessor, objectIdInfo);
} else { // other types are to be simpler JavaType type = ctxt.constructType(implClass); idType = ctxt.getTypeFactory().findTypeParameters(type, ObjectIdGenerator.class)[0]; idProp = null; idGen = ctxt.objectIdGeneratorInstance(accessor, objectIdInfo);
JavaType[] tps = tf.findTypeParameters(type, CLASS_ITERABLE); JavaType elemType = (tps == null || tps.length != 1) ? TypeFactory.unknownType() : tps[0]; CollectionType ct = tf.constructCollectionType(Collection.class, elemType);
Class<?> implClass = objectIdInfo.getGeneratorType(); JavaType type = provider.constructType(implClass); JavaType idType = provider.getTypeFactory().findTypeParameters(type, ObjectIdGenerator.class)[0];
private Class<?> findAdapterBoundType(XmlAdapter<?,?> adapter) { TypeFactory tf = getTypeFactory(); JavaType adapterType = tf.constructType(adapter.getClass()); JavaType[] params = tf.findTypeParameters(adapterType, XmlAdapter.class); // should not happen, except if our type resolution has a flaw, but: if (params == null || params.length < 2) { return Object.class; } return params[1].getRawClass(); }
protected Converter<Object,Object> _converter(XmlAdapter<?,?> adapter, boolean forSerialization) { TypeFactory tf = getTypeFactory(); JavaType adapterType = tf.constructType(adapter.getClass()); JavaType[] pt = tf.findTypeParameters(adapterType, XmlAdapter.class); // Order of type parameters for Converter is reverse between serializer, deserializer, // whereas JAXB just uses single ordering if (forSerialization) { return new AdapterConverter(adapter, pt[1], pt[0], forSerialization); } return new AdapterConverter(adapter, pt[0], pt[1], forSerialization); }
@SuppressWarnings("unchecked") private final XmlAdapter<Object,Object> checkAdapter(XmlJavaTypeAdapter adapterInfo, Class<?> typeNeeded, boolean forSerialization) { // if annotation has no type, it's applicable; if it has, must match Class<?> adaptedType = adapterInfo.type(); if (adaptedType == XmlJavaTypeAdapter.DEFAULT.class) { JavaType type = _typeFactory.constructType(adapterInfo.value()); JavaType[] params = _typeFactory.findTypeParameters(type, XmlAdapter.class); adaptedType = params[1].getRawClass(); } if (adaptedType.isAssignableFrom(typeNeeded)) { @SuppressWarnings("rawtypes") Class<? extends XmlAdapter> cls = adapterInfo.value(); // true -> yes, force access if need be return ClassUtil.createInstance(cls, true); } return null; }
JavaType[] contents = tf.findTypeParameters(resolvedType, MappingIterator.class); JavaType valueType = (contents == null || contents.length == 0) ? tf.constructType(Object.class) : contents[0];
/** * @deprecated Since 2.7 resolve raw type first, then find type parameters */ @Deprecated // since 2.7 public JavaType[] findTypeParameters(Class<?> clz, Class<?> expType) { return findTypeParameters(constructType(clz), expType); }
/** * @deprecated Since 2.7 resolve raw type first, then find type parameters */ @Deprecated // since 2.7 public JavaType[] findTypeParameters(Class<?> clz, Class<?> expType, TypeBindings bindings) { return findTypeParameters(constructType(clz, bindings), expType); }
@Override public JavaType getOutputType(TypeFactory typeFactory) { JavaType[] types = typeFactory.findTypeParameters(getClass(), Converter.class); if (types == null || types.length < 2) { throw new IllegalStateException("Can not find OUT type parameter for Converter of type "+getClass().getName()); } return types[1]; } }
@Override public JavaType getInputType(TypeFactory typeFactory) { JavaType[] types = typeFactory.findTypeParameters(getClass(), Converter.class); if (types == null || types.length < 2) { throw new IllegalStateException("Can not find OUT type parameter for Converter of type "+getClass().getName()); } return types[0]; }
@Override public JavaType getOutputType(TypeFactory typeFactory) { JavaType[] types = typeFactory.findTypeParameters(getClass(), Converter.class); if (types == null || types.length < 2) { throw new IllegalStateException("Can not find OUT type parameter for Converter of type "+getClass().getName()); } return types[1]; } }
protected Converter<Object,Object> _converter(XmlAdapter<?,?> adapter, boolean forSerialization) { JavaType[] pt = getTypeFactory().findTypeParameters(adapter.getClass(), XmlAdapter.class); // Order of type parameters for Converter is reverse between serializer, deserializer, // whereas JAXB just uses single ordering if (forSerialization) { return new AdapterConverter(adapter, pt[1], pt[0], forSerialization); } return new AdapterConverter(adapter, pt[0], pt[1], forSerialization); } }
@Deprecated // since 2.5 protected JsonSerializer<?> buildIterableSerializer(SerializationConfig config, JavaType type, BeanDescription beanDesc, boolean staticTyping) throws JsonMappingException { JavaType[] params = config.getTypeFactory().findTypeParameters(type, Iterable.class); JavaType vt = (params == null || params.length != 1) ? TypeFactory.unknownType() : params[0]; return buildIterableSerializer(config, type, beanDesc, staticTyping, vt); }