public CustomCollectionEditor(Class collectionType) 
{
		this(collectionType, false);
}

Create a new CustomCollectionEditor for the given target type, keeping an incoming null as-is.

Parameters:

collectionType - the target type, which needs to be a sub-interface of Collection or a concrete Collection class

Also see:

java.util.Collection
java.util.ArrayList
java.util.TreeSet
java.util.LinkedHashSet

 public CustomCollectionEditor(Class collectionType,
    boolean nullAsEmptyCollection) 
{
		if (collectionType == null) {
			throw new IllegalArgumentException("Collection type is required");
		}
		if (!Collection.class.isAssignableFrom(collectionType)) {
			throw new IllegalArgumentException(
					"Collection type [" + collectionType.getName() + "] does not implement [java.util.Collection]");
		}
		this.collectionType = collectionType;
		this.nullAsEmptyCollection = nullAsEmptyCollection;
}

Create a new CustomCollectionEditor for the given target type.

If the incoming value is of the given type, it will be used as-is. If it is a different Collection type or an array, it will be converted to a default implementation of the given Collection type. If the value is anything else, a target Collection with that single value will be created.

The default Collection implementations are: ArrayList for List, TreeSet for SortedSet, and LinkedHashSet for Set.

Parameters:

collectionType - the target type, which needs to be a sub-interface of Collection or a concrete Collection class

nullAsEmptyCollection - whether to convert an incoming null value to an empty Collection (of the appropriate type)

Also see:

java.util.Collection
java.util.ArrayList
java.util.TreeSet
java.util.LinkedHashSet

 protected boolean alwaysCreateNewCollection() 
{
		return false;
}

Return whether to always create a new Collection, even if the type of the passed-in Collection already matches.

Default is "false"; can be overridden to enforce creation of a new Collection, for example to convert elements in any case.

 protected Object convertElement(Object element) 
{
		return element;
}

Hook to convert each encountered Collection/array element. The default implementation simply returns the passed-in element as-is.

Can be overridden to perform conversion of certain elements, for example String to Integer if a String array comes in and should be converted to a Set of Integer objects.

Only called if actually creating a new Collection! This is by default not the case if the type of the passed-in Collection already matches. Override #alwaysCreateNewCollection() to enforce creating a new Collection in every case.

 protected Collection createCollection(Class collectionType,
    int initialCapacity) 
{
		if (!collectionType.isInterface()) {
			try {
				return (Collection) collectionType.newInstance();
			}
			catch (Exception ex) {
				throw new IllegalArgumentException(
						"Could not instantiate collection class [" + collectionType.getName() + "]: " + ex.getMessage());
			}
		}
		else if (List.class.equals(collectionType)) {
			return new ArrayList(initialCapacity);
		}
		else if (SortedSet.class.equals(collectionType)) {
			return new TreeSet();
		}
		else {
			return new LinkedHashSet(initialCapacity);
		}
}

Create a Collection of the given type, with the given initial capacity (if supported by the Collection type).

 public String getAsText() 
{
		return null;
}

This implementation returns null to indicate that there is no appropriate text representation.

 public  void setAsText(String text) throws IllegalArgumentException 
{
		setValue(text);
}

Convert the given text value to a Collection with a single element.

 public  void setValue(Object value) 
{
		if (value == null && this.nullAsEmptyCollection) {
			super.setValue(createCollection(this.collectionType, 0));
		}
		else if (value == null || (this.collectionType.isInstance(value) && !alwaysCreateNewCollection())) {
			// Use the source value as-is, as it matches the target type.
			super.setValue(value);
		}
		else if (value instanceof Collection) {
			// Convert Collection elements.
			Collection source = (Collection) value;
			Collection target = createCollection(this.collectionType, source.size());
			for (Iterator it = source.iterator(); it.hasNext();) {
				target.add(convertElement(it.next()));
			}
			super.setValue(target);
		}
		else if (value.getClass().isArray()) {
			// Convert array elements to Collection elements.
			int length = Array.getLength(value);
			Collection target = createCollection(this.collectionType, length);
			for (int i = 0; i <  length; i++) {
				target.add(convertElement(Array.get(value, i)));
			}
			super.setValue(target);
		}
		else {
			// A plain value: convert it to a Collection with a single element.
			Collection target = createCollection(this.collectionType, 1);
			target.add(convertElement(value));
			super.setValue(target);
		}
}

Convert the given value to a Collection of the target type.