public ConstructorArgumentValues() 
{

}

Create a new empty ConstructorArgumentValues object.

 public ConstructorArgumentValues(ConstructorArgumentValues original) 
{
		addArgumentValues(original);
}

Deep copy constructor.

Parameters:

original - the ConstructorArgumentValues to copy

 public  void addArgumentValues(ConstructorArgumentValues other) 
{
		if (other != null) {
			for (Iterator it = other.indexedArgumentValues.entrySet().iterator(); it.hasNext();) {
				Map.Entry entry = (Map.Entry) it.next();
				ValueHolder valueHolder = (ValueHolder) entry.getValue();
				addOrMergeIndexedArgumentValue(entry.getKey(), valueHolder.copy());
			}
			for (Iterator it = other.genericArgumentValues.iterator(); it.hasNext();) {
				ValueHolder valueHolder = (ValueHolder) it.next();
				if (!this.genericArgumentValues.contains(valueHolder)) {
					this.genericArgumentValues.add(valueHolder.copy());
				}
			}
		}
}

Copy all given argument values into this object, using separate holder instances to keep the values independent from the original object.

Note: Identical ValueHolder instances will only be registered once, to allow for merging and re-merging of argument value definitions. Distinct ValueHolder instances carrying the same content are of course allowed.

 public  void addGenericArgumentValue(Object value) 
{
		this.genericArgumentValues.add(new ValueHolder(value));
}

Add generic argument value to be matched by type.

Note: A single generic argument value will just be used once, rather than matched multiple times (as of Spring 1.1).

 public  void addGenericArgumentValue(ConstructorArgumentValues.ValueHolder newValue) 
{
		Assert.notNull(newValue, "ValueHolder must not be null");
		if (!this.genericArgumentValues.contains(newValue)) {
			this.genericArgumentValues.add(newValue);
		}
}

Add generic argument value to be matched by type.

Note: A single generic argument value will just be used once, rather than matched multiple times (as of Spring 1.1).

 public  void addGenericArgumentValue(Object value,
    String type) 
{
		this.genericArgumentValues.add(new ValueHolder(value, type));
}

Add generic argument value to be matched by type.

Note: A single generic argument value will just be used once, rather than matched multiple times (as of Spring 1.1).

 public  void addIndexedArgumentValue(int index,
    Object value) 
{
		addIndexedArgumentValue(index, new ValueHolder(value));
}

Add argument value for the given index in the constructor argument list.

 public  void addIndexedArgumentValue(int index,
    ConstructorArgumentValues.ValueHolder newValue) 
{
		Assert.isTrue(index  >= 0, "Index must not be negative");
		Assert.notNull(newValue, "ValueHolder must not be null");
		addOrMergeIndexedArgumentValue(new Integer(index), newValue);
}

Add argument value for the given index in the constructor argument list.

 public  void addIndexedArgumentValue(int index,
    Object value,
    String type) 
{
		addIndexedArgumentValue(index, new ValueHolder(value, type));
}

Add argument value for the given index in the constructor argument list.

 public  void clear() 
{
		this.indexedArgumentValues.clear();
		this.genericArgumentValues.clear();
}

Clear this holder, removing all argument values.

 public boolean equals(Object other) 
{
		if (this == other) {
			return true;
		}
		if (!(other instanceof ConstructorArgumentValues)) {
			return false;
		}
		ConstructorArgumentValues that = (ConstructorArgumentValues) other;
		if (this.genericArgumentValues.size() != that.genericArgumentValues.size() ||
				this.indexedArgumentValues.size() != that.indexedArgumentValues.size()) {
			return false;
		}
		Iterator it1 = this.genericArgumentValues.iterator();
		Iterator it2 = that.genericArgumentValues.iterator();
		while (it1.hasNext() && it2.hasNext()) {
			ValueHolder vh1 = (ValueHolder) it1.next();
			ValueHolder vh2 = (ValueHolder) it2.next();
			if (!vh1.contentEquals(vh2)) {
				return false;
			}
		}
		for (Iterator it = this.indexedArgumentValues.entrySet().iterator(); it.hasNext();) {
			Map.Entry entry = (Map.Entry) it.next();
			ValueHolder vh1 = (ValueHolder) entry.getValue();
			ValueHolder vh2 = (ValueHolder) that.indexedArgumentValues.get(entry.getKey());
			if (!vh1.contentEquals(vh2)) {
				return false;
			}
		}
		return true;
}

 public int getArgumentCount() 
{
		return (this.indexedArgumentValues.size() + this.genericArgumentValues.size());
}

Return the number of argument values held in this instance, counting both indexed and generic argument values.

 public ConstructorArgumentValues.ValueHolder getArgumentValue(int index,
    Class requiredType) 
{
		return getArgumentValue(index, requiredType, null);
}

Look for an argument value that either corresponds to the given index in the constructor argument list or generically matches by type.

 public ConstructorArgumentValues.ValueHolder getArgumentValue(int index,
    Class requiredType,
    Set usedValueHolders) 
{
		Assert.isTrue(index  >= 0, "Index must not be negative");
		ValueHolder valueHolder = getIndexedArgumentValue(index, requiredType);
		if (valueHolder == null) {
			valueHolder = getGenericArgumentValue(requiredType, usedValueHolders);
		}
		return valueHolder;
}

Look for an argument value that either corresponds to the given index in the constructor argument list or generically matches by type.

 public ConstructorArgumentValues.ValueHolder getGenericArgumentValue(Class requiredType) 
{
		return getGenericArgumentValue(requiredType, null);
}

Look for a generic argument value that matches the given type.

 public ConstructorArgumentValues.ValueHolder getGenericArgumentValue(Class requiredType,
    Set usedValueHolders) 
{
		for (Iterator it = this.genericArgumentValues.iterator(); it.hasNext();) {
			ValueHolder valueHolder = (ValueHolder) it.next();
			if (usedValueHolders == null || !usedValueHolders.contains(valueHolder)) {
				if (requiredType != null) {
					// Check matching type.
					if (valueHolder.getType() != null) {
						if (valueHolder.getType().equals(requiredType.getName())) {
							return valueHolder;
						}
					}
					else if (ClassUtils.isAssignableValue(requiredType, valueHolder.getValue())) {
						return valueHolder;
					}
				}
				else {
					// No required type specified - > consider untyped values only.
					if (valueHolder.getType() == null) {
						return valueHolder;
					}
				}
			}
		}
		return null;
}

Look for the next generic argument value that matches the given type, ignoring argument values that have already been used in the current resolution process.

 public List getGenericArgumentValues() 
{
		return Collections.unmodifiableList(this.genericArgumentValues);
}

Return the list of generic argument values.

 public ConstructorArgumentValues.ValueHolder getIndexedArgumentValue(int index,
    Class requiredType) 
{
		Assert.isTrue(index  >= 0, "Index must not be negative");
		ValueHolder valueHolder = (ValueHolder) this.indexedArgumentValues.get(new Integer(index));
		if (valueHolder != null) {
			if (valueHolder.getType() == null ||
					(requiredType != null && requiredType.getName().equals(valueHolder.getType()))) {
				return valueHolder;
			}
		}
		return null;
}

Get argument value for the given index in the constructor argument list.

 public Map getIndexedArgumentValues() 
{
		return Collections.unmodifiableMap(this.indexedArgumentValues);
}

Return the map of indexed argument values.

 public int hashCode() 
{
		int hashCode = 7;
		for (Iterator it = this.genericArgumentValues.iterator(); it.hasNext();) {
			ValueHolder valueHolder = (ValueHolder) it.next();
			hashCode = 31 * hashCode + valueHolder.contentHashCode();
		}
		hashCode = 29 * hashCode;
		for (Iterator it = this.indexedArgumentValues.entrySet().iterator(); it.hasNext();) {
			Map.Entry entry = (Map.Entry) it.next();
			Integer key = (Integer) entry.getKey();
			ValueHolder value = (ValueHolder) entry.getValue();
			hashCode = 31 * hashCode + (value.contentHashCode() ^ key.hashCode());
		}
		return hashCode;
}

 public boolean isEmpty() 
{
		return (this.indexedArgumentValues.isEmpty() && this.genericArgumentValues.isEmpty());
}

Return if this holder does not contain any argument values, neither indexed ones nor generic ones.