root
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Actions Packages Projects Releases Wiki Activity

collection and array merged into one

This commit is contained in:
Keith Donald 2009-09-18 23:02:52 +00:00
parent 2ca694350e
commit 48bc060a77
4 changed files with 133 additions and 142 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

112
org.springframework.core/src/main/java/org/springframework/core/convert/support/ArrayGenericConverter.java
View File

@ -1,112 +0,0 @@
/*
* Copyright 2002-2009 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.core.convert.support;
import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Collection;
import org.springframework.core.CollectionFactory;
import org.springframework.core.convert.TypeDescriptor;
class ArrayGenericConverter implements GenericConverter {
private GenericConversionService conversionService;
public ArrayGenericConverter(GenericConversionService conversionService) {
this.conversionService = conversionService;
}
public boolean canConvert(TypeDescriptor sourceType, TypeDescriptor targetType) {
return sourceType.isArray() || targetType.isArray();
}
public Object convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {
if (isArrayToArray(sourceType, targetType)) {
return convertArrayToArray(source, sourceType, targetType);
} else if (isArrayToCollection(sourceType, targetType)) {
return convertArrayToCollection(source, sourceType, targetType);
} else if (isCollectionToArray(sourceType, targetType)) {
return convertCollectionToArray(source, sourceType, targetType);
} else if (isArrayToObject(sourceType, targetType)) {
return convertArrayToObject(source, sourceType, targetType);
} else {
return convertObjectToArray(source, sourceType, targetType);
}
}
private boolean isArrayToArray(TypeDescriptor sourceType, TypeDescriptor targetType) {
return sourceType.isArray() && targetType.isArray();
}
private Object convertArrayToArray(Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {
if (sourceType.isAssignableTo(targetType)) {
return source;
}
TypeDescriptor sourceElementType = sourceType.getElementTypeDescriptor();
TypeDescriptor targetElementType = targetType.getElementTypeDescriptor();
Object target = Array.newInstance(targetElementType.getType(), Array.getLength(source));
GenericConverter converter = conversionService.getConverter(sourceElementType, targetElementType);
for (int i = 0; i < Array.getLength(target); i++) {
Array.set(target, i, converter.convert(Array.get(source, i), sourceElementType, targetElementType));
}
return target;
}
private boolean isArrayToCollection(TypeDescriptor sourceType, TypeDescriptor targetType) {
return sourceType.isArray() && targetType.isCollection();
}
private Object convertArrayToCollection(Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {
int length = Array.getLength(source);
Collection collection = CollectionFactory.createCollection(targetType.getType(), length);
TypeDescriptor targetElementType = targetType.getElementTypeDescriptor();
if (targetElementType == TypeDescriptor.NULL) {
for (int i = 0; i < length; i++) {
collection.add(Array.get(source, i));
}
} else {
TypeDescriptor sourceElementType = sourceType.getElementTypeDescriptor();
GenericConverter converter = conversionService.getConverter(sourceElementType, targetElementType);
for (int i = 0; i < length; i++) {
collection.add(converter.convert(Array.get(source, i), sourceElementType, targetElementType));
}
}
return collection;
}
private boolean isCollectionToArray(TypeDescriptor sourceType, TypeDescriptor targetType) {
return sourceType.isCollection() && targetType.isArray();
}
private Object convertCollectionToArray(Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {
throw new UnsupportedOperationException("Not yet implemented");
}
private boolean isArrayToObject(TypeDescriptor sourceType, TypeDescriptor targetType) {
return sourceType.isArray();
}
private Object convertArrayToObject(Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {
throw new UnsupportedOperationException("Not yet implemented");
}
private Object convertObjectToArray(Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {
throw new UnsupportedOperationException("Not yet implemented");
}
}

150
org.springframework.core/src/main/java/org/springframework/core/convert/support/CollectionGenericConverter.java
View File

@ -16,18 +16,13 @@
package org.springframework.core.convert.support;
import java.lang.reflect.Array;
import java.util.Collection;
import java.util.Iterator;
import org.springframework.core.CollectionFactory;
import org.springframework.core.convert.TypeDescriptor;
/**
* A generic converter that can convert from one collection type to another.
*
* @author Keith Donald
* @author Juergen Hoeller
* @since 3.0
*/
class CollectionGenericConverter implements GenericConverter {
private GenericConversionService conversionService;
@ -37,26 +32,119 @@ class CollectionGenericConverter implements GenericConverter {
}
public boolean canConvert(TypeDescriptor sourceType, TypeDescriptor targetType) {
return sourceType.isCollection() && targetType.isCollection();
return sourceType.isArray() || targetType.isArray() || sourceType.isCollection() || targetType.isCollection();
}
public Object convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {
Collection sourceCollection = (Collection) source;
TypeDescriptor targetElementType = targetType.getElementTypeDescriptor();
if (targetElementType == TypeDescriptor.NULL) {
return compatibleCollectionWithoutElementConversion(sourceCollection, targetType);
if (isArrayToArray(sourceType, targetType)) {
return convertArrayToArray(source, sourceType, targetType);
} else if (isArrayToCollection(sourceType, targetType)) {
return convertArrayToCollection(source, sourceType, targetType);
} else if (isCollectionToCollection(sourceType, targetType)) {
return convertCollectionToCollection(source, sourceType, targetType);
} else if (isCollectionToArray(sourceType, targetType)) {
return convertCollectionToArray(source, sourceType, targetType);
} else if (isArrayToObject(sourceType, targetType)) {
return convertArrayToObject(source, sourceType, targetType);
} else if (isObjectToArray(sourceType, targetType)) {
return convertObjectToArray(source, sourceType, targetType);
} else if (isCollectionToObject(sourceType, targetType)) {
return convertCollectionToObject(source, sourceType, targetType);
} else {
return convertObjectToCollection(source, sourceType, targetType);
}
}
private boolean isArrayToArray(TypeDescriptor sourceType, TypeDescriptor targetType) {
return sourceType.isArray() && targetType.isArray();
}
private Object convertArrayToArray(Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {
if (sourceType.isAssignableTo(targetType)) {
return source;
}
TypeDescriptor sourceElementType = sourceType.getElementTypeDescriptor();
TypeDescriptor targetElementType = targetType.getElementTypeDescriptor();
Object target = Array.newInstance(targetElementType.getType(), Array.getLength(source));
GenericConverter converter = conversionService.getConverter(sourceElementType, targetElementType);
for (int i = 0; i < Array.getLength(target); i++) {
Array.set(target, i, converter.convert(Array.get(source, i), sourceElementType, targetElementType));
}
return target;
}
private boolean isArrayToCollection(TypeDescriptor sourceType, TypeDescriptor targetType) {
return sourceType.isArray() && targetType.isCollection();
}
private Object convertArrayToCollection(Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {
int length = Array.getLength(source);
Collection collection = CollectionFactory.createCollection(targetType.getType(), length);
TypeDescriptor sourceElementType = sourceType.getElementTypeDescriptor();
TypeDescriptor targetElementType = targetType.getElementTypeDescriptor();
if (targetElementType == TypeDescriptor.NULL || sourceElementType.isAssignableTo(targetElementType)) {
for (int i = 0; i < length; i++) {
collection.add(Array.get(source, i));
}
} else {
GenericConverter converter = conversionService.getConverter(sourceElementType, targetElementType);
for (int i = 0; i < length; i++) {
collection.add(converter.convert(Array.get(source, i), sourceElementType, targetElementType));
}
}
return collection;
}
private boolean isCollectionToArray(TypeDescriptor sourceType, TypeDescriptor targetType) {
return sourceType.isCollection() && targetType.isArray();
}
private Object convertCollectionToArray(Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {
Collection sourceCollection = (Collection) source;
TypeDescriptor sourceElementType = sourceType.getElementTypeDescriptor();
if (sourceElementType == TypeDescriptor.NULL) {
sourceElementType = getElementType(sourceCollection);
}
TypeDescriptor targetElementType = targetType.getElementTypeDescriptor();
Object array = Array.newInstance(targetElementType.getType(), sourceCollection.size());
int i = 0;
if (sourceElementType == TypeDescriptor.NULL || sourceElementType.isAssignableTo(targetElementType)) {
return compatibleCollectionWithoutElementConversion(sourceCollection, targetType);
for (Iterator it = sourceCollection.iterator(); it.hasNext(); i++) {
Array.set(array, i, it.next());
}
} else {
GenericConverter converter = conversionService.getConverter(sourceElementType, targetElementType);
for (Iterator it = sourceCollection.iterator(); it.hasNext(); i++) {
Array.set(array, i, converter.convert(it.next(), sourceElementType, targetElementType));
}
}
return array;
}
private boolean isCollectionToCollection(TypeDescriptor sourceType, TypeDescriptor targetType) {
return sourceType.isCollection() && targetType.isCollection();
}
public Object convertCollectionToCollection(Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {
Collection sourceCollection = (Collection) source;
TypeDescriptor sourceElementType = sourceType.getElementTypeDescriptor();
if (sourceElementType == TypeDescriptor.NULL) {
sourceElementType = getElementType(sourceCollection);
}
TypeDescriptor targetElementType = targetType.getElementTypeDescriptor();
if (sourceElementType == TypeDescriptor.NULL || sourceElementType.isAssignableTo(targetElementType)) {
if (sourceType.isAssignableTo(targetType)) {
return source;
} else {
Collection targetCollection = CollectionFactory.createCollection(targetType.getType(), sourceCollection.size());
targetCollection.addAll(sourceCollection);
return targetCollection;
}
}
Collection targetCollection = CollectionFactory.createCollection(targetType.getType(), sourceCollection.size());
GenericConverter elementConverter = conversionService.getConverter(sourceElementType, targetElementType);
GenericConverter converter = conversionService.getConverter(sourceElementType, targetElementType);
for (Object element : sourceCollection) {
targetCollection.add(elementConverter.convert(element, sourceElementType, targetElementType));
targetCollection.add(converter.convert(element, sourceElementType, targetElementType));
}
return targetCollection;
}
@ -70,14 +158,32 @@ class CollectionGenericConverter implements GenericConverter {
return TypeDescriptor.NULL;
}
private Collection compatibleCollectionWithoutElementConversion(Collection source, TypeDescriptor targetType) {
if (targetType.getType().isAssignableFrom(source.getClass())) {
return source;
} else {
Collection target = CollectionFactory.createCollection(targetType.getType(), source.size());
target.addAll(source);
return target;
private boolean isArrayToObject(TypeDescriptor sourceType, TypeDescriptor targetType) {
return sourceType.isArray();
}
private Object convertArrayToObject(Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {
throw new UnsupportedOperationException("Not yet implemented");
}
private boolean isObjectToArray(TypeDescriptor sourceType, TypeDescriptor targetType) {
return targetType.isArray();
}
private Object convertObjectToArray(Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {
throw new UnsupportedOperationException("Not yet implemented");
}
private boolean isCollectionToObject(TypeDescriptor sourceType, TypeDescriptor targetType) {
return sourceType.isCollection();
}
private Object convertCollectionToObject(Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {
throw new UnsupportedOperationException("Not yet implemented");
}
private Object convertObjectToCollection(Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {
throw new UnsupportedOperationException("Not yet implemented");
}
}

1
org.springframework.core/src/main/java/org/springframework/core/convert/support/GenericConversionService.java
View File

@ -184,7 +184,6 @@ public class GenericConversionService implements ConversionService, ConverterReg
protected void initGenericConverters() {
addGenericConverter(new CollectionGenericConverter(this));
addGenericConverter(new MapGenericConverter(this));
addGenericConverter(new ArrayGenericConverter(this));
}
protected void addGenericConverter(GenericConverter converter) {

2
org.springframework.core/src/test/java/org/springframework/core/convert/support/GenericConversionServiceTests.java
View File

@ -186,7 +186,6 @@ public class GenericConversionServiceTests {
}
@Test
@Ignore
public void convertListToArray() {
List<String> list = new ArrayList<String>();
list.add("1");
@ -199,7 +198,6 @@ public class GenericConversionServiceTests {
}
@Test
@Ignore
public void convertListToArrayWithComponentConversion() {
converter.addConverterFactory(new StringToNumberConverterFactory());
List<String> list = new ArrayList<String>();