@Nullable private static Class<?> getCollectionParameterType(MethodParameter methodParam) { Class<?> paramType = methodParam.getNestedParameterType(); if (Collection.class == paramType || List.class.isAssignableFrom(paramType)){ Class<?> valueType = ResolvableType.forMethodParameter(methodParam).asCollection().resolveGeneric(); if (valueType != null) { return valueType; } } return null; }
@Nullable public Class<?> getCollectionType(int nestingLevel) { return getResolvableType().getNested(nestingLevel).asCollection().resolveGeneric(); }
@Override @SuppressWarnings("unchecked") protected Set<Object> createInstance() { if (this.sourceSet == null) { throw new IllegalArgumentException("'sourceSet' is required"); } Set<Object> result = null; if (this.targetSetClass != null) { result = BeanUtils.instantiateClass(this.targetSetClass); } else { result = new LinkedHashSet<>(this.sourceSet.size()); } Class<?> valueType = null; if (this.targetSetClass != null) { valueType = ResolvableType.forClass(this.targetSetClass).asCollection().resolveGeneric(); } if (valueType != null) { TypeConverter converter = getBeanTypeConverter(); for (Object elem : this.sourceSet) { result.add(converter.convertIfNecessary(elem, valueType)); } } else { result.addAll(this.sourceSet); } return result; }
@Override @SuppressWarnings("unchecked") protected List<Object> createInstance() { if (this.sourceList == null) { throw new IllegalArgumentException("'sourceList' is required"); } List<Object> result = null; if (this.targetListClass != null) { result = BeanUtils.instantiateClass(this.targetListClass); } else { result = new ArrayList<>(this.sourceList.size()); } Class<?> valueType = null; if (this.targetListClass != null) { valueType = ResolvableType.forClass(this.targetListClass).asCollection().resolveGeneric(); } if (valueType != null) { TypeConverter converter = getBeanTypeConverter(); for (Object elem : this.sourceList) { result.add(converter.convertIfNecessary(elem, valueType)); } } else { result.addAll(this.sourceList); } return result; }
private void growCollectionIfNecessary(Collection<Object> collection, int index, String name, PropertyHandler ph, int nestingLevel) { if (!isAutoGrowNestedPaths()) { return; } int size = collection.size(); if (index >= size && index < this.autoGrowCollectionLimit) { Class<?> elementType = ph.getResolvableType().getNested(nestingLevel).asCollection().resolveGeneric(); if (elementType != null) { for (int i = collection.size(); i < index + 1; i++) { collection.add(newValue(elementType, null, name)); } } } }
@Nullable private static Class<?> getCollectionParameterType(MethodParameter methodParam) { Class<?> paramType = methodParam.getNestedParameterType(); if (Collection.class == paramType || List.class.isAssignableFrom(paramType)){ Class<?> valueType = ResolvableType.forMethodParameter(methodParam).asCollection().resolveGeneric(); if (valueType != null) { return valueType; } } return null; }
@Nullable public Class<?> getCollectionType(int nestingLevel) { return getResolvableType().getNested(nestingLevel).asCollection().resolveGeneric(); }
ResolvableType.forMethodParameter(parameter).asCollection().resolveGeneric(); if (elementType != null) { return convertDataArrayToTargetCollection(array, targetClass, elementType); ResolvableType.forMethodParameter(parameter).asCollection().resolveGeneric(); if (elementType != null) { return convertDataArrayToTargetCollection(array, targetClass, elementType);
private void growCollectionIfNecessary(Collection<Object> collection, int index, String name, PropertyHandler ph, int nestingLevel) { if (!isAutoGrowNestedPaths()) { return; } int size = collection.size(); if (index >= size && index < this.autoGrowCollectionLimit) { Class<?> elementType = ph.getResolvableType().getNested(nestingLevel).asCollection().resolveGeneric(); if (elementType != null) { for (int i = collection.size(); i < index + 1; i++) { collection.add(newValue(elementType, null, name)); } } } }
valueClass = ResolvableType.forMethodParameter(parameter).asCollection().resolveGeneric(); if (valueClass == null) { throw new IllegalArgumentException(
@Test public void genericOfGenericWithAs() throws Exception { ResolvableType type = ResolvableType.forField(Fields.class.getField("stringListList")).asCollection(); assertThat(type.toString(), equalTo("java.util.Collection<java.util.List<java.lang.String>>")); assertThat(type.getGeneric().asCollection().toString(), equalTo("java.util.Collection<java.lang.String>")); }
@Test public void resolveFromClassWithGenerics() throws Exception { ResolvableType type = ResolvableType.forClassWithGenerics(List.class, ResolvableType.forClassWithGenerics(List.class, String.class)); assertThat(type.asCollection().toString(), equalTo("java.util.Collection<java.util.List<java.lang.String>>")); assertThat(type.asCollection().getGeneric().toString(), equalTo("java.util.List<java.lang.String>")); assertThat(type.asCollection().getGeneric().asCollection().toString(), equalTo("java.util.Collection<java.lang.String>")); assertThat(type.toString(), equalTo("java.util.List<java.util.List<java.lang.String>>")); assertThat(type.asCollection().getGeneric().getGeneric().resolve(), equalTo((Type) String.class)); }
@Test public void resolveGenericArrayFromGeneric() throws Exception { ResolvableType type = ResolvableType.forField(Fields.class.getField("stringArrayList")); ResolvableType generic = type.asCollection().getGeneric(); assertThat(generic.getType().toString(), equalTo("E")); assertThat(generic.isArray(), equalTo(true)); assertThat(generic.resolve(), equalTo((Class) String[].class)); }
@Test public void testSpr16456() throws Exception { ResolvableType genericType = ResolvableType.forField( UnresolvedWithGenerics.class.getDeclaredField("set")).asCollection(); ResolvableType type = ResolvableType.forClassWithGenerics(ArrayList.class, genericType.getGeneric()); assertThat(type.resolveGeneric(), equalTo(Integer.class)); }
@Test public void resolveTypeVariableFromSuperType() throws Exception { ResolvableType type = ResolvableType.forClass(ExtendsList.class); assertThat(type.resolve(), equalTo((Class) ExtendsList.class)); assertThat(type.asCollection().resolveGeneric(), equalTo((Class) CharSequence.class)); }
@Test public void asCollection() throws Exception { ResolvableType type = ResolvableType.forClass(ExtendsList.class).asCollection(); assertThat(type.resolve(), equalTo((Class) Collection.class)); assertThat(type.resolveGeneric(), equalTo((Class) CharSequence.class)); }
@Test public void hasGenerics() throws Exception { ResolvableType type = ResolvableType.forClass(ExtendsList.class); assertThat(type.hasGenerics(), equalTo(false)); assertThat(type.asCollection().hasGenerics(), equalTo(true)); }
@Test public void getComponentTypeForVariableThatResolvesToGenericArray() throws Exception { ResolvableType type = ResolvableType.forClass(ListOfGenericArray.class).asCollection().getGeneric(); assertThat(type.isArray(), equalTo(true)); assertThat(type.getType(), instanceOf(TypeVariable.class)); assertThat(type.getComponentType().getType().toString(), equalTo("java.util.List<java.lang.String>")); }
/** * If this type is an array, returns the array's component type. * If this type is a {@code Stream}, returns the stream's component type. * If this type is a {@link Collection} and it is parameterized, returns the Collection's element type. * If the Collection is not parameterized, returns {@code null} indicating the element type is not declared. * @return the array component type or Collection element type, or {@code null} if this type is a * Collection but its element type is not parameterized * @throws IllegalStateException if this type is not a {@code java.util.Collection} or array type */ @Nullable public TypeDescriptor getElementTypeDescriptor() { if (getResolvableType().isArray()) { return new TypeDescriptor(getResolvableType().getComponentType(), null, getAnnotations()); } if (Stream.class.isAssignableFrom(getType())) { return getRelatedIfResolvable(this, getResolvableType().as(Stream.class).getGeneric(0)); } return getRelatedIfResolvable(this, getResolvableType().asCollection().getGeneric(0)); }
@Test public void noneReturnValues() throws Exception { ResolvableType none = ResolvableType.NONE; assertThat(none.as(Object.class), equalTo(ResolvableType.NONE)); assertThat(none.asCollection(), equalTo(ResolvableType.NONE)); assertThat(none.asMap(), equalTo(ResolvableType.NONE)); assertThat(none.getComponentType(), equalTo(ResolvableType.NONE)); assertThat(none.getGeneric(0), equalTo(ResolvableType.NONE)); assertThat(none.getGenerics().length, equalTo(0)); assertThat(none.getInterfaces().length, equalTo(0)); assertThat(none.getSuperType(), equalTo(ResolvableType.NONE)); assertThat(none.getType(), equalTo(ResolvableType.EmptyType.INSTANCE)); assertThat(none.hasGenerics(), equalTo(false)); assertThat(none.isArray(), equalTo(false)); assertThat(none.resolve(), nullValue()); assertThat(none.resolve(String.class), equalTo((Class) String.class)); assertThat(none.resolveGeneric(0), nullValue()); assertThat(none.resolveGenerics().length, equalTo(0)); assertThat(none.toString(), equalTo("?")); assertThat(none.hasUnresolvableGenerics(), equalTo(false)); assertThat(none.isAssignableFrom(ResolvableType.forClass(Object.class)), equalTo(false)); }