Attachment #80312 for bug #203492

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




package org.eclipse.core.databinding;

import org.eclipse.core.databinding.conversion.IConverter;
import org.eclipse.core.databinding.conversion.IConverterProvider;
import org.eclipse.core.databinding.observable.list.IObservableList;
import org.eclipse.core.databinding.validation.ValidationStatus;
import org.eclipse.core.internal.databinding.BindingMessages;
import org.eclipse.core.internal.databinding.DefaultConverterProvider;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;


 * construction of the strategy (e.g. {@link #POLICY_NEVER},
 * {@link #POLICY_ON_REQUEST}, {@link #POLICY_UPDATE}).
 * </p>
 *
 *
 * @see DataBindingContext#bindList(IObservableList, IObservableList,
 *      UpdateListStrategy, UpdateListStrategy)
 * @see IConverter

	 * Helper method allowing API evolution of the above constant values. The
	 * compiler will not inline constant values into client code if values are
	 * "computed" using this helper.
	 *
	 * @param i
	 *            an integer
	 * @return the same integer

	 * calling one of the setter methods.
	 */
	public UpdateListStrategy() {
		this(true, POLICY_UPDATE,new DefaultConverterProvider());
	}

	/**
	 * @param provider
	 */
	public UpdateListStrategy(IConverterProvider provider) {
		this(true,POLICY_UPDATE,provider);
	}

	/**
	 * Creates a new update list strategy with a configurable update policy. A
	 * default converter will be provided. The defaults can be changed by
	 * calling one of the setter methods.
	 *
	 * @param updatePolicy
	 *            one of {@link #POLICY_NEVER}, {@link #POLICY_ON_REQUEST}, or
	 *            {@link #POLICY_UPDATE}

	}

	/**
	 * @param updatePolicy
	 * @param provider
	 */
	public UpdateListStrategy(int updatePolicy,IConverterProvider provider) {
		this(true,updatePolicy,provider);
	}

	/**
	 * Creates a new update list strategy with a configurable update policy. A
	 * default converter will be provided if <code>provideDefaults</code> is
	 * <code>true</code>. The defaults can be changed by calling one of the
	 * setter methods.
	 *
	 * @param provideDefaults
	 *            if <code>true</code>, default validators and a default
	 *            converter will be provided based on the observable list's

	 *            {@link #POLICY_UPDATE}
	 */
	public UpdateListStrategy(boolean provideDefaults, int updatePolicy) {
		this(true,updatePolicy,new DefaultConverterProvider());
	}

	/**
	 * @param provideDefaults
	 * @param updatePolicy
	 * @param provider
	 */
	public UpdateListStrategy(boolean provideDefaults, int updatePolicy, IConverterProvider provider) {
		super(provider==null?new DefaultConverterProvider():provider);
		this.provideDefaults = provideDefaults;
		this.updatePolicy = updatePolicy;
	}

	 * {@link #setConverter(IConverter) converter} if one exists. If no
	 * converter exists no conversion occurs.
	 * </p>
	 *
	 * @param element
	 * @return the converted element
	 */

	}

	/**
	 *
	 * @param source
	 * @param destination
	 */

	/**
	 * Sets the converter to be invoked when converting added elements from the
	 * source element type to the destination element type.
	 *
	 * @param converter
	 * @return the receiver, to enable method call chaining
	 */

	/**
	 * Adds the given element at the given index to the given observable list.
	 * Clients may extend but must call the super implementation.
	 *
	 * @param observableList
	 * @param element
	 * @param index

	/**
	 * Removes the element at the given index from the given observable list.
	 * Clients may extend but must call the super implementation.
	 *
	 * @param observableList
	 * @param index
	 * @return a status





package org.eclipse.core.databinding;

import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.HashMap;
import java.util.Map;

import org.eclipse.core.databinding.conversion.IConverter;
import org.eclipse.core.databinding.conversion.IConverterProvider;
import org.eclipse.core.databinding.conversion.StringToNumberConverter;
import org.eclipse.core.databinding.util.Policy;
import org.eclipse.core.internal.databinding.ClassLookupSupport;
import org.eclipse.core.internal.databinding.Pair;
import org.eclipse.core.internal.databinding.conversion.IdentityConverter;
import org.eclipse.core.internal.databinding.conversion.IntegerToStringConverter;
import org.eclipse.core.internal.databinding.conversion.NumberToBigDecimalConverter;
import org.eclipse.core.internal.databinding.conversion.NumberToBigIntegerConverter;
import org.eclipse.core.internal.databinding.conversion.NumberToByteConverter;
import org.eclipse.core.internal.databinding.conversion.NumberToDoubleConverter;
import org.eclipse.core.internal.databinding.conversion.NumberToFloatConverter;
import org.eclipse.core.internal.databinding.conversion.NumberToIntegerConverter;
import org.eclipse.core.internal.databinding.conversion.NumberToLongConverter;
import org.eclipse.core.internal.databinding.conversion.NumberToShortConverter;
import org.eclipse.core.internal.databinding.conversion.ObjectToStringConverter;
import org.eclipse.core.internal.databinding.conversion.StringToByteConverter;
import org.eclipse.core.internal.databinding.conversion.StringToShortConverter;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;

import com.ibm.icu.text.NumberFormat;

/**
 * @since 1.0
 *
 */
/* package */class UpdateStrategy {
	private IConverterProvider converterProvider;

//	/**
//	 *
//	 */
//	public UpdateStrategy() {
//		this(new DefaultConverterProvider());
//	}
	private static final String LONG_TYPE = "java.lang.Long.TYPE"; //$NON-NLS-1$
	private static Map converterMap;

	private static Class autoboxed(Class clazz) {
		if (clazz == Float.TYPE)
			return Float.class;
		else if (clazz == Double.TYPE)
			return Double.class;
		else if (clazz == Short.TYPE)
			return Short.class;
		else if (clazz == Integer.TYPE)
			return Integer.class;
		else if (clazz == Long.TYPE)
			return Long.class;
		else if (clazz == Byte.TYPE)
			return Byte.class;
		else if (clazz == Boolean.TYPE)
			return Boolean.class;
		return clazz;
	}

	/**
	 * @param converterProvider the provider implementation used
	 */
	public UpdateStrategy(IConverterProvider converterProvider) {
		this.converterProvider = converterProvider;
				&& !assignableFromModelToModelConverter.booleanValue()) {
			throw new BindingException(errorString
					+ " Expected: " + fromType + ", actual: " + toType); //$NON-NLS-1$//$NON-NLS-2$
		}
	}

	/**

	 * fromType. Returns <code>null</code> if no converter could be created.
	 * Either toType or modelDescription can be <code>null</code>, but not
	 * both.
	 *
	 * @param fromType
	 * @param toType
	 * @return an IConverter, or <code>null</code> if unsuccessful
	 */
	protected IConverter createConverter(Object fromType, Object toType) {
		IConverter convert = converterProvider.createConverter(fromType, toType);
		if( convert == null ) {
			convert = new DefaultConverter(fromType,toType);
		Class toClass = (Class) toType;
		Class originalToClass = toClass;
		if (toClass.isPrimitive()) {
			toClass = autoboxed(toClass);
		}
		Class fromClass = (Class) fromType;
		Class originalFromClass = fromClass;
		if (fromClass.isPrimitive()) {
			fromClass = autoboxed(fromClass);
		}
		if (!((Class) toType).isPrimitive()
				&& toClass.isAssignableFrom(fromClass)) {
			return new IdentityConverter(originalFromClass, originalToClass);
		}
		if (((Class) fromType).isPrimitive() && ((Class) toType).isPrimitive()
				&& fromType.equals(toType)) {
			return new IdentityConverter(originalFromClass, originalToClass);
		}
		Map converterMap = getConverterMap();
		Class[] supertypeHierarchyFlattened = ClassLookupSupport
				.getTypeHierarchyFlattened(fromClass);
		for (int i = 0; i < supertypeHierarchyFlattened.length; i++) {
			Class currentFromClass = supertypeHierarchyFlattened[i];
			if (currentFromClass == toType) {
				// converting to toType is just a widening
				return new IdentityConverter(fromClass, toClass);
			}
			Pair key = new Pair(getKeyForClass(fromType, currentFromClass),
					getKeyForClass(toType, toClass));
			Object converterOrClassname = converterMap.get(key);
			if (converterOrClassname instanceof IConverter) {
				return (IConverter) converterOrClassname;
			} else if (converterOrClassname instanceof String) {
				String classname = (String) converterOrClassname;
				Class converterClass;
				try {
					converterClass = Class.forName(classname);
					IConverter result = (IConverter) converterClass
							.newInstance();
					converterMap.put(key, result);
					return result;
				} catch (Exception e) {
					Policy
							.getLog()
							.log(
									new Status(
											IStatus.ERROR,
											Policy.JFACE_DATABINDING,
											0,
											"Error while instantiating default converter", e)); //$NON-NLS-1$
				}
			}
		}
		// Since we found no converter yet, try a "downcast" converter;
		// the IdentityConverter will automatically check the actual types at
		// runtime.
		if (fromClass.isAssignableFrom(toClass)) {
			return new IdentityConverter(originalFromClass, originalToClass);
		}
		return new DefaultConverter(fromType, toType);
	}

	private static Map getConverterMap() {
		// using string-based lookup avoids loading of too many classes
		if (converterMap == null) {
			//NumberFormat to be shared across converters for the formatting of integer values
			NumberFormat integerFormat = NumberFormat.getIntegerInstance();
			//NumberFormat to be shared across converters for formatting non integer values
			NumberFormat numberFormat = NumberFormat.getNumberInstance();
			
			converterMap = new HashMap();
			converterMap
					.put(
							new Pair("java.util.Date", "java.lang.String"), "org.eclipse.core.internal.databinding.conversion.DateToStringConverter"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
			converterMap
					.put(
							new Pair("java.lang.String", "java.lang.Boolean"), "org.eclipse.core.internal.databinding.conversion.StringToBooleanConverter"); //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$
			converterMap
					.put(
							new Pair("java.lang.String", "java.lang.Byte"), StringToByteConverter.toByte(integerFormat, false)); //$NON-NLS-1$//$NON-NLS-2$
			converterMap
					.put(
							new Pair("java.lang.String", "java.lang.Character"), "org.eclipse.core.internal.databinding.conversion.StringToCharacterConverter"); //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$
			converterMap
					.put(
							new Pair("java.lang.String", "java.util.Date"), "org.eclipse.core.internal.databinding.conversion.StringToDateConverter"); //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$
			converterMap
					.put(
							new Pair("java.lang.String", "java.lang.Short"), StringToShortConverter.toShort(integerFormat, false)); //$NON-NLS-1$//$NON-NLS-2$
			
			converterMap.put(new Pair("java.lang.String", "java.lang.Integer"), StringToNumberConverter.toInteger(integerFormat, false));  //$NON-NLS-1$//$NON-NLS-2$
			converterMap.put(new Pair("java.lang.String", "java.lang.Double"), StringToNumberConverter.toDouble(numberFormat, false));  //$NON-NLS-1$//$NON-NLS-2$
			converterMap.put(new Pair("java.lang.String", "java.lang.Long"), StringToNumberConverter.toLong(integerFormat, false));  //$NON-NLS-1$//$NON-NLS-2$
			converterMap.put(new Pair("java.lang.String", "java.lang.Float"), StringToNumberConverter.toFloat(numberFormat, false));  //$NON-NLS-1$//$NON-NLS-2$			
			converterMap.put(new Pair("java.lang.String", "java.math.BigInteger"), StringToNumberConverter.toBigInteger(integerFormat));  //$NON-NLS-1$//$NON-NLS-2$			
			converterMap.put(new Pair("java.lang.Integer", "java.lang.String"), NumberToStringConverter.fromInteger(integerFormat, false));  //$NON-NLS-1$//$NON-NLS-2$
			converterMap.put(new Pair("java.lang.Long", "java.lang.String"), NumberToStringConverter.fromLong(integerFormat, false));  //$NON-NLS-1$//$NON-NLS-2$
			converterMap.put(new Pair("java.lang.Double", "java.lang.String"), NumberToStringConverter.fromDouble(numberFormat, false));  //$NON-NLS-1$//$NON-NLS-2$
			converterMap.put(new Pair("java.lang.Float", "java.lang.String"), NumberToStringConverter.fromFloat(numberFormat, false));  //$NON-NLS-1$//$NON-NLS-2$
			converterMap.put(new Pair("java.math.BigInteger", "java.lang.String"), NumberToStringConverter.fromBigInteger(integerFormat));  //$NON-NLS-1$//$NON-NLS-2$
			converterMap.put(new Pair("java.lang.Byte", "java.lang.String"), IntegerToStringConverter.fromByte(integerFormat, false));   //$NON-NLS-1$//$NON-NLS-2$
			converterMap.put(new Pair("java.lang.Short", "java.lang.String"), IntegerToStringConverter.fromShort(integerFormat, false));  //$NON-NLS-1$//$NON-NLS-2$
			
			converterMap
					.put(
							new Pair("java.lang.Object", "java.lang.String"), "org.eclipse.core.internal.databinding.conversion.ObjectToStringConverter"); //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$

			// Integer.TYPE
			converterMap.put(new Pair("java.lang.String", INTEGER_TYPE), StringToNumberConverter.toInteger(integerFormat, true)); //$NON-NLS-1$
			converterMap
					.put(
							new Pair(INTEGER_TYPE, "java.lang.Integer"), new IdentityConverter(Integer.TYPE, Integer.class)); //$NON-NLS-1$
			converterMap
					.put(
							new Pair(INTEGER_TYPE, "java.lang.Object"), new IdentityConverter(Integer.TYPE, Object.class)); //$NON-NLS-1$
			converterMap.put(new Pair(INTEGER_TYPE, "java.lang.String"), NumberToStringConverter.fromInteger(integerFormat, true)); //$NON-NLS-1$

			// Byte.TYPE
			converterMap
					.put(
							new Pair("java.lang.String", BYTE_TYPE), StringToByteConverter.toByte(integerFormat, true)); //$NON-NLS-1$
			converterMap
					.put(
							new Pair(BYTE_TYPE, "java.lang.Byte"), new IdentityConverter(Byte.TYPE, Byte.class)); //$NON-NLS-1$
			converterMap
					.put(
							new Pair(BYTE_TYPE, "java.lang.String"), IntegerToStringConverter.fromByte(integerFormat, true)); //$NON-NLS-1$
			converterMap
					.put(
							new Pair(BYTE_TYPE, "java.lang.Object"), new IdentityConverter(Byte.TYPE, Object.class)); //$NON-NLS-1$

			// Double.TYPE
			converterMap.put(new Pair("java.lang.String", DOUBLE_TYPE), StringToNumberConverter.toDouble(numberFormat, true)); //$NON-NLS-1$
			converterMap.put(new Pair(DOUBLE_TYPE, "java.lang.String"), NumberToStringConverter.fromDouble(numberFormat, true)); //$NON-NLS-1$
			
			converterMap
					.put(
							new Pair(DOUBLE_TYPE, "java.lang.Double"), new IdentityConverter(Double.TYPE, Double.class)); //$NON-NLS-1$
			converterMap
					.put(
							new Pair(DOUBLE_TYPE, "java.lang.Object"), new IdentityConverter(Double.TYPE, Object.class)); //$NON-NLS-1$

			// Boolean.TYPE
			converterMap
					.put(
							new Pair("java.lang.String", BOOLEAN_TYPE), "org.eclipse.core.internal.databinding.conversion.StringToBooleanPrimitiveConverter"); //$NON-NLS-1$ //$NON-NLS-2$
			converterMap
					.put(
							new Pair(BOOLEAN_TYPE, "java.lang.Boolean"), new IdentityConverter(Boolean.TYPE, Boolean.class)); //$NON-NLS-1$
			converterMap
					.put(
							new Pair(BOOLEAN_TYPE, "java.lang.String"), new ObjectToStringConverter(Boolean.TYPE)); //$NON-NLS-1$
			converterMap
					.put(
							new Pair(BOOLEAN_TYPE, "java.lang.Object"), new IdentityConverter(Boolean.TYPE, Object.class)); //$NON-NLS-1$

			// Float.TYPE
			converterMap.put(new Pair("java.lang.String", FLOAT_TYPE), StringToNumberConverter.toFloat(numberFormat, true)); //$NON-NLS-1$
			converterMap.put(new Pair(FLOAT_TYPE, "java.lang.String"), NumberToStringConverter.fromFloat(numberFormat, true)); //$NON-NLS-1$
			converterMap
					.put(
							new Pair(FLOAT_TYPE, "java.lang.Float"), new IdentityConverter(Float.TYPE, Float.class)); //$NON-NLS-1$
			converterMap
					.put(
							new Pair(FLOAT_TYPE, "java.lang.Object"), new IdentityConverter(Float.TYPE, Object.class)); //$NON-NLS-1$		

			// Short.TYPE
			converterMap
					.put(
							new Pair("java.lang.String", SHORT_TYPE), StringToShortConverter.toShort(integerFormat, true)); //$NON-NLS-1$
			converterMap
					.put(
							new Pair(SHORT_TYPE, "java.lang.Short"), new IdentityConverter(Short.TYPE, Short.class)); //$NON-NLS-1$
			converterMap
					.put(
							new Pair(SHORT_TYPE, "java.lang.String"), IntegerToStringConverter.fromShort(integerFormat, true)); //$NON-NLS-1$
			converterMap
					.put(
							new Pair(SHORT_TYPE, "java.lang.Object"), new IdentityConverter(Short.TYPE, Object.class)); //$NON-NLS-1$		

			// Long.TYPE
			converterMap.put(new Pair("java.lang.String", LONG_TYPE), StringToNumberConverter.toLong(integerFormat, true)); //$NON-NLS-1$
			converterMap.put(new Pair(LONG_TYPE, "java.lang.String"), NumberToStringConverter.fromLong(integerFormat, true)); //$NON-NLS-1$
			converterMap
					.put(
							new Pair(LONG_TYPE, "java.lang.Long"), new IdentityConverter(Long.TYPE, Long.class)); //$NON-NLS-1$
			converterMap
					.put(
							new Pair(LONG_TYPE, "java.lang.Object"), new IdentityConverter(Long.TYPE, Object.class)); //$NON-NLS-1$		

			converterMap
					.put(
							new Pair("org.eclipse.core.runtime.IStatus", "java.lang.String"), "org.eclipse.core.internal.databinding.conversion.StatusToStringConverter"); //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$
			
			addNumberToByteConverters(converterMap, integerFormat, integerClasses);
			addNumberToByteConverters(converterMap, numberFormat, floatClasses);
			
			addNumberToShortConverters(converterMap, integerFormat, integerClasses);
			addNumberToShortConverters(converterMap, numberFormat, floatClasses);
			
			addNumberToIntegerConverters(converterMap, integerFormat, integerClasses);
			addNumberToIntegerConverters(converterMap, numberFormat, floatClasses);
			
			addNumberToLongConverters(converterMap, integerFormat, integerClasses);
			addNumberToLongConverters(converterMap, numberFormat, floatClasses);
			
			addNumberToFloatConverters(converterMap, integerFormat, integerClasses);
			addNumberToFloatConverters(converterMap, numberFormat, floatClasses);
			
			addNumberToDoubleConverters(converterMap, integerFormat, integerClasses);
			addNumberToDoubleConverters(converterMap, numberFormat, floatClasses);
			
			addNumberToBigIntegerConverters(converterMap, integerFormat, integerClasses);
			addNumberToBigIntegerConverters(converterMap, numberFormat, floatClasses);	
			
			addNumberToBigDecimalConverters(converterMap, integerFormat, integerClasses);
			addNumberToBigDecimalConverters(converterMap, numberFormat, floatClasses);
		}

		return converterMap;
	}
	
	private static final Class[] integerClasses = new Class[]{
		Byte.TYPE, Byte.class,
		Short.TYPE, Short.class, 
		Integer.TYPE, Integer.class,
		Long.TYPE, Long.class,
		BigInteger.class};

	private static final Class[] floatClasses = new Class[] {
		Float.TYPE, Float.class,
		Double.TYPE, Double.class,
		BigDecimal.class};
	
	/**
	 * Registers converters to boxed and unboxed types from a list of from classes.
	 * 
	 * @param map
	 * @param numberFormat
	 * @param fromTypes
	 */
	private static void addNumberToByteConverters(Map map,
			NumberFormat numberFormat, Class[] fromTypes) {
		
		for (int i = 0; i < fromTypes.length; i++) {
			Class fromType = fromTypes[i];
			if (!fromType.equals(Byte.class) && !fromType.equals(Byte.TYPE)) {
				String fromName = (fromType.isPrimitive()) ? getKeyForClass(fromType, null) : fromType.getName();
				
				map.put(new Pair(fromName, BYTE_TYPE), new NumberToByteConverter(numberFormat, fromType, true));
				map.put(new Pair(fromName, Byte.class.getName()), new NumberToByteConverter(numberFormat, fromType, false));
			}
		}
	}
	
	/**
	 * Registers converters to boxed and unboxed types from a list of from classes.
	 * 
	 * @param map
	 * @param numberFormat
	 * @param fromTypes
	 */
	private static void addNumberToShortConverters(Map map, NumberFormat numberFormat, Class[] fromTypes) {
		for (int i = 0; i < fromTypes.length; i++) {
			Class fromType = fromTypes[i];
			if (!fromType.equals(Short.class) && !fromType.equals(Short.TYPE)) {
				String fromName = (fromType.isPrimitive()) ? getKeyForClass(fromType, null) : fromType.getName();
				
				map.put(new Pair(fromName, SHORT_TYPE), new NumberToShortConverter(numberFormat, fromType, true));
				map.put(new Pair(fromName, Short.class.getName()), new NumberToShortConverter(numberFormat, fromType, false));
			}
		}
	}
	
	/**
	 * Registers converters to boxed and unboxed types from a list of from classes.
	 * 
	 * @param map
	 * @param numberFormat
	 * @param fromTypes
	 */
	private static void addNumberToIntegerConverters(Map map, NumberFormat numberFormat, Class[] fromTypes) {
		for (int i = 0; i < fromTypes.length; i++) {
			Class fromType = fromTypes[i];
			if (!fromType.equals(Integer.class) && !fromType.equals(Integer.TYPE)) {
				String fromName = (fromType.isPrimitive()) ? getKeyForClass(fromType, null) : fromType.getName();
				
				map.put(new Pair(fromName, INTEGER_TYPE), new NumberToIntegerConverter(numberFormat, fromType, true));
				map.put(new Pair(fromName, Integer.class.getName()), new NumberToIntegerConverter(numberFormat, fromType, false));
			}
		}
	}
	
	/**
	 * Registers converters to boxed and unboxed types from a list of from classes.
	 * 
	 * @param map
	 * @param numberFormat
	 * @param fromTypes
	 */
	private static void addNumberToLongConverters(Map map, NumberFormat numberFormat, Class[] fromTypes) {
		for (int i = 0; i < fromTypes.length; i++) {
			Class fromType = fromTypes[i];
			if (!fromType.equals(Long.class) && !fromType.equals(Long.TYPE)) {
				String fromName = (fromType.isPrimitive()) ? getKeyForClass(fromType, null) : fromType.getName();
				
				map.put(new Pair(fromName, LONG_TYPE), new NumberToLongConverter(numberFormat, fromType, true));
				map.put(new Pair(fromName, Long.class.getName()), new NumberToLongConverter(numberFormat, fromType, false));
			}
		}
	}

		return convert;
	 * Registers converters to boxed and unboxed types from a list of from classes.
	 * 
	 * @param map
	 * @param numberFormat
	 * @param fromTypes
	 */
	private static void addNumberToFloatConverters(Map map, NumberFormat numberFormat, Class[] fromTypes) {
		for (int i = 0; i < fromTypes.length; i++) {
			Class fromType = fromTypes[i];
			if (!fromType.equals(Float.class) && !fromType.equals(Float.TYPE)) {
				String fromName = (fromType.isPrimitive()) ? getKeyForClass(fromType, null) : fromType.getName();
				
				map.put(new Pair(fromName, FLOAT_TYPE), new NumberToFloatConverter(numberFormat, fromType, true));
				map.put(new Pair(fromName, Float.class.getName()), new NumberToFloatConverter(numberFormat, fromType, false));
			}
		}
	}
	
	/**
	 * Registers converters to boxed and unboxed types from a list of from classes.
	 * 
	 * @param map
	 * @param numberFormat
	 * @param fromTypes
	 */
	private static void addNumberToDoubleConverters(Map map, NumberFormat numberFormat, Class[] fromTypes) {
		for (int i = 0; i < fromTypes.length; i++) {
			Class fromType = fromTypes[i];
			if (!fromType.equals(Double.class) && !fromType.equals(Double.TYPE)) {
				String fromName = (fromType.isPrimitive()) ? getKeyForClass(fromType, null) : fromType.getName();
				
				map.put(new Pair(fromName, DOUBLE_TYPE), new NumberToDoubleConverter(numberFormat, fromType, true));
				map.put(new Pair(fromName, Double.class.getName()), new NumberToDoubleConverter(numberFormat, fromType, false));
			}
		}
	}

	final protected void checkAssignable(Object toType, Object fromType,
			String errorString) {
		Boolean assignableFromModelToModelConverter = isAssignableFromTo(
				fromType, toType);
		if (assignableFromModelToModelConverter != null
				&& !assignableFromModelToModelConverter.booleanValue()) {
			throw new BindingException(errorString
					+ " Expected: " + fromType + ", actual: " + toType); //$NON-NLS-1$//$NON-NLS-2$
		for (int i = 0; i < fromTypes.length; i++) {
			Class fromType = fromTypes[i];
			if (!fromType.equals(BigInteger.class)) {
				String fromName = (fromType.isPrimitive()) ? getKeyForClass(fromType, null) : fromType.getName();
				
				map.put(new Pair(fromName, BigInteger.class.getName()), new NumberToBigIntegerConverter(numberFormat, fromType));
			}
		}
	}
	
	/**
	 * Registers converters to boxed and unboxed types from a list of from classes.
	 * 
	 * @param map
	 * @param numberFormat
	 * @param fromTypes
	 */
	private static void addNumberToBigDecimalConverters(Map map, NumberFormat numberFormat, Class[] fromTypes) {
		for (int i = 0; i < fromTypes.length; i++) {
			Class fromType = fromTypes[i];
			if (!fromType.equals(BigDecimal.class)) {
				String fromName = (fromType.isPrimitive()) ? getKeyForClass(fromType, null) : fromType.getName();
				
				map.put(new Pair(fromName, BigDecimal.class.getName()), new NumberToBigDecimalConverter(numberFormat, fromType));
			}
		}
	}
	
	private static String getKeyForClass(Object originalValue, Class filteredValue) {
		if (originalValue instanceof Class) {
			Class originalClass = (Class) originalValue;
			if (originalClass.equals(Integer.TYPE)) {
				return INTEGER_TYPE;
			} else if (originalClass.equals(Byte.TYPE)) {
				return BYTE_TYPE;
			} else if (originalClass.equals(Boolean.TYPE)) {
				return BOOLEAN_TYPE;
			} else if (originalClass.equals(Double.TYPE)) {
				return DOUBLE_TYPE;
			} else if (originalClass.equals(Float.TYPE)) {
				return FLOAT_TYPE;
			} else if (originalClass.equals(Long.TYPE)) {
				return LONG_TYPE;
			} else if (originalClass.equals(Short.TYPE)) {
				return SHORT_TYPE;
			}
		}
		return filteredValue.getName();
	}

	/**

	 * @return whether fromType is assignable to toType
	 */
	protected Boolean isAssignableFromTo(Object fromType, Object toType) {
		return converterProvider.isAssignableFromTo(fromType, toType);
			Class toClass = (Class) toType;
			if (toClass.isPrimitive()) {
				toClass = autoboxed(toClass);
			}
			Class fromClass = (Class) fromType;
			if (fromClass.isPrimitive()) {
				fromClass = autoboxed(fromClass);
			}
			return toClass.isAssignableFrom(fromClass) ? Boolean.TRUE
					: Boolean.FALSE;
		}
		return null;
	}

	/*

Lines 16-21 Link Here

(-)src/org/eclipse/core/databinding/DataBindingContext.java (-23 / +42 lines)
16		16
17	import java.util.Iterator;	17	import java.util.Iterator;
18		18
		19	import org.eclipse.core.databinding.conversion.IConverterProvider;
19	import org.eclipse.core.databinding.observable.Observables;	20	import org.eclipse.core.databinding.observable.Observables;
20	import org.eclipse.core.databinding.observable.Realm;	21	import org.eclipse.core.databinding.observable.Realm;
21	import org.eclipse.core.databinding.observable.list.IObservableList;	22	import org.eclipse.core.databinding.observable.list.IObservableList;
Lines 47-53 Link Here
47	* could be aggregated to set the page status and fulfillment. Each page in the	48	* could be aggregated to set the page status and fulfillment. Each page in the
48	* <code>IWizard</code> would have its own context instance.	49	* <code>IWizard</code> would have its own context instance.
49	* </p>	50	* </p>
50	*	51	*
51	* @since 1.0	52	* @since 1.0
52	*/	53	*/
53	public class DataBindingContext {	54	public class DataBindingContext {
Lines 62-71 Link Here
62		63
63	private Realm validationRealm;	64	private Realm validationRealm;
64		65
		66	private IConverterProvider converterProvider;
		67
65	/**	68	/**
66	* Creates a data binding context, using the current default realm for the	69	* Creates a data binding context, using the current default realm for the
67	* validation observables.	70	* validation observables.
68	*	71	*
69	* @see Realm	72	* @see Realm
70	*/	73	*/
71	public DataBindingContext() {	74	public DataBindingContext() {
Lines 73-88 Link Here
73	}	76	}
74		77
75	/**	78	/**
		79	* @param converterProvider
		80	*/
		81	public DataBindingContext(IConverterProvider converterProvider) {
		82	this(Realm.getDefault(),null);
		83	}
		84
		85	/**
76	* Creates a data binding context using the given realm for the validation	86	* Creates a data binding context using the given realm for the validation
77	* observables.	87	* observables.
78	*	88	*
79	* @param validationRealm	89	* @param validationRealm
80	* the realm to be used for the validation observables	90	* the realm to be used for the validation observables
81	*	91	*
82	* @see Realm	92	* @see Realm
83	*/	93	*/
84	public DataBindingContext(Realm validationRealm) {	94	public DataBindingContext(Realm validationRealm) {
		95	this(validationRealm,null);
		96	}
		97
		98	/**
		99	* @param validationRealm
		100	* @param converterProvider
		101	*/
		102	public DataBindingContext(Realm validationRealm,IConverterProvider converterProvider) {
85	Assert.isNotNull(validationRealm);	103	Assert.isNotNull(validationRealm);
		104	this.converterProvider = converterProvider;
86	this.validationRealm = validationRealm;	105	this.validationRealm = validationRealm;
87	bindings = new WritableList(validationRealm);	106	bindings = new WritableList(validationRealm);
88		107
Lines 97-103 Link Here
97	* validation and conversion can be employed to customize the process. For	116	* validation and conversion can be employed to customize the process. For
98	* specifics on the customization of the process see	117	* specifics on the customization of the process see
99	* {@link UpdateValueStrategy}.	118	* {@link UpdateValueStrategy}.
100	*	119	*
101	* @param targetObservableValue	120	* @param targetObservableValue
102	* target value, commonly a UI widget	121	* target value, commonly a UI widget
103	* @param modelObservableValue	122	* @param modelObservableValue
Lines 109-115 Link Here
109	* strategy to employ when the model is the source of the change	128	* strategy to employ when the model is the source of the change
110	* and the target is the destination	129	* and the target is the destination
111	* @return created binding	130	* @return created binding
112	*	131	*
113	* @see UpdateValueStrategy	132	* @see UpdateValueStrategy
114	*/	133	*/
115	public final Binding bindValue(IObservableValue targetObservableValue,	134	public final Binding bindValue(IObservableValue targetObservableValue,
Lines 131-166 Link Here
131	/**	150	/**
132	* Returns an update value strategy to be used for copying values from the	151	* Returns an update value strategy to be used for copying values from the
133	* from value to the to value. Clients may override.	152	* from value to the to value. Clients may override.
134	*	153	*
135	* @param fromValue	154	* @param fromValue
136	* @param toValue	155	* @param toValue
137	* @return a update value strategy	156	* @return a update value strategy
138	*/	157	*/
139	protected UpdateValueStrategy createModelToTargetUpdateValueStrategy(	158	protected UpdateValueStrategy createModelToTargetUpdateValueStrategy(
140	IObservableValue fromValue, IObservableValue toValue) {	159	IObservableValue fromValue, IObservableValue toValue) {
141	return new UpdateValueStrategy();	160	return new UpdateValueStrategy(converterProvider);
142	}	161	}
143		162
144	/**	163	/**
145	* Returns an update value strategy to be used for copying values from the	164	* Returns an update value strategy to be used for copying values from the
146	* from value to the to value. Clients may override.	165	* from value to the to value. Clients may override.
147	*	166	*
148	* @param fromValue	167	* @param fromValue
149	* @param toValue	168	* @param toValue
150	* @return a update value strategy	169	* @return a update value strategy
151	*/	170	*/
152	protected UpdateValueStrategy createTargetToModelUpdateValueStrategy(	171	protected UpdateValueStrategy createTargetToModelUpdateValueStrategy(
153	IObservableValue fromValue, IObservableValue toValue) {	172	IObservableValue fromValue, IObservableValue toValue) {
154	return new UpdateValueStrategy();	173	return new UpdateValueStrategy(converterProvider);
155	}	174	}
156		175
157	/**	176	/**
158	* Creates a {@link Binding} to synchronize the values of two	177	* Creates a {@link Binding} to synchronize the values of two
159	* {@link IObservableList observable lists}. During synchronization	178	* {@link IObservableList observable lists}. During synchronization
160	* validation and conversion can be employed to customize the process. For	179	* validation and conversion can be employed to customize the process. For
161	* specifics on the customization of the process see	180	* specifics on the customization of the process see
162	* {@link UpdateListStrategy}.	181	* {@link UpdateListStrategy}.
163	*	182	*
164	* @param targetObservableList	183	* @param targetObservableList
165	* target list, commonly a list representing a list in the UI	184	* target list, commonly a list representing a list in the UI
166	* @param modelObservableList	185	* @param modelObservableList
Lines 172-178 Link Here
172	* strategy to employ when the model is the source of the change	191	* strategy to employ when the model is the source of the change
173	* and the target is the destination	192	* and the target is the destination
174	* @return created binding	193	* @return created binding
175	*	194	*
176	* @see UpdateListStrategy	195	* @see UpdateListStrategy
177	*/	196	*/
178	public final Binding bindList(IObservableList targetObservableList,	197	public final Binding bindList(IObservableList targetObservableList,
Lines 203-220 Link Here
203	protected UpdateListStrategy createModelToTargetUpdateListStrategy(	222	protected UpdateListStrategy createModelToTargetUpdateListStrategy(
204	IObservableList modelObservableList,	223	IObservableList modelObservableList,
205	IObservableList targetObservableList) {	224	IObservableList targetObservableList) {
206	return new UpdateListStrategy();	225	return new UpdateListStrategy(converterProvider);
207	}	226	}
208		227
209	/**	228	/**
210	* @param targetObservableList	229	* @param targetObservableList
211	* @param modelObservableList	230	* @param modelObservableList
212	* @return an update list strategy	231	* @return an update list strategy
213	*/	232	*/
214	protected UpdateListStrategy createTargetToModelUpdateListStrategy(	233	protected UpdateListStrategy createTargetToModelUpdateListStrategy(
215	IObservableList targetObservableList,	234	IObservableList targetObservableList,
216	IObservableList modelObservableList) {	235	IObservableList modelObservableList) {
217	return new UpdateListStrategy();	236	return new UpdateListStrategy(converterProvider);
218	}	237	}
219		238
220	/**	239	/**
Lines 231-237 Link Here
231	/**	250	/**
232	* Returns an unmodifiable observable list with elements of type	251	* Returns an unmodifiable observable list with elements of type
233	* {@link Binding}, ordered by time of addition.	252	* {@link Binding}, ordered by time of addition.
234	*	253	*
235	* @return the observable list containing all bindings	254	* @return the observable list containing all bindings
236	*/	255	*/
237	public final IObservableList getBindings() {	256	public final IObservableList getBindings() {
Lines 243-249 Link Here
243	* statuses (type: {@link IStatus}). The keys of the map are the bindings	262	* statuses (type: {@link IStatus}). The keys of the map are the bindings
244	* returned by {@link #getBindings()}, and the values are the current	263	* returned by {@link #getBindings()}, and the values are the current
245	* validaion status objects for each binding.	264	* validaion status objects for each binding.
246	*	265	*
247	* @return the observable map from bindings to status objects.	266	* @return the observable map from bindings to status objects.
248	*/	267	*/
249	public final IObservableMap getValidationStatusMap() {	268	public final IObservableMap getValidationStatusMap() {
Lines 252-258 Link Here
252		271
253	/**	272	/**
254	* Adds the given binding to this data binding context.	273	* Adds the given binding to this data binding context.
255	*	274	*
256	* @param binding	275	* @param binding
257	* The binding to add.	276	* The binding to add.
258	*/	277	*/
Lines 263-269 Link Here
263	/**	282	/**
264	* Updates all model observable objects to reflect the current state of the	283	* Updates all model observable objects to reflect the current state of the
265	* target observable objects.	284	* target observable objects.
266	*	285	*
267	*/	286	*/
268	public final void updateModels() {	287	public final void updateModels() {
269	for (Iterator it = bindings.iterator(); it.hasNext();) {	288	for (Iterator it = bindings.iterator(); it.hasNext();) {
Lines 275-281 Link Here
275	/**	294	/**
276	* Updates all target observable objects to reflect the current state of the	295	* Updates all target observable objects to reflect the current state of the
277	* model observable objects.	296	* model observable objects.
278	*	297	*
279	*/	298	*/
280	public final void updateTargets() {	299	public final void updateTargets() {
281	for (Iterator it = bindings.iterator(); it.hasNext();) {	300	for (Iterator it = bindings.iterator(); it.hasNext();) {
Lines 286-292 Link Here
286		305
287	/**	306	/**
288	* Removes the given binding.	307	* Removes the given binding.
289	*	308	*
290	* @param binding	309	* @param binding
291	* @return <code>true</code> if was associated with the context,	310	* @return <code>true</code> if was associated with the context,
292	* <code>false</code> if not	311	* <code>false</code> if not
Lines 297-303 Link Here
297		316
298	/**	317	/**
299	* Returns the validation realm.	318	* Returns the validation realm.
300	*	319	*
301	* @return the realm for the validation observables	320	* @return the realm for the validation observables
302	* @see Realm	321	* @see Realm
303	*/	322	*/




import java.util.HashMap;

import org.eclipse.core.databinding.conversion.IConverter;
import org.eclipse.core.databinding.conversion.IConverterProvider;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.core.databinding.validation.IValidator;
import org.eclipse.core.databinding.validation.ValidationStatus;
import org.eclipse.core.internal.databinding.BindingMessages;
import org.eclipse.core.internal.databinding.DefaultConverterProvider;
import org.eclipse.core.internal.databinding.Pair;
import org.eclipse.core.internal.databinding.conversion.NumberToBigDecimalConverter;
import org.eclipse.core.internal.databinding.conversion.NumberToBigIntegerConverter;

 * construction of the strategy (e.g. {@link #POLICY_NEVER},
 * {@link #POLICY_CONVERT}, {@link #POLICY_ON_REQUEST}, {@link #POLICY_UPDATE}).
 * </p>
 *
 * @see DataBindingContext#bindValue(IObservableValue, IObservableValue,
 *      UpdateValueStrategy, UpdateValueStrategy)
 * @see Binding#getValidationStatus()

	 * Helper method allowing API evolution of the above constant values. The
	 * compiler will not inline constant values into client code if values are
	 * "computed" using this helper.
	 *
	 * @param i
	 *            an integer
	 * @return the same integer

	}

	/**
	 * @param provider
	 */
	public UpdateValueStrategy(IConverterProvider provider) {
		this(true,POLICY_UPDATE,provider);
	}

	/**
	 * Creates a new update value strategy with a configurable update policy.
	 * Default validators and a default converter will be provided. The defaults
	 * can be changed by calling one of the setter methods.
	 *
	 * @param updatePolicy
	 *            one of {@link #POLICY_NEVER}, {@link #POLICY_ON_REQUEST},
	 *            {@link #POLICY_CONVERT}, or {@link #POLICY_UPDATE}
	 */
	public UpdateValueStrategy(int updatePolicy) {
		this(true, updatePolicy, new DefaultConverterProvider());
	}

	/**
	 * @param updatePolicy
	 * @param provider
	 */
	public UpdateValueStrategy(int updatePolicy,IConverterProvider provider) {
		this(true,updatePolicy,provider);
	}

	/**

	 * Default validators and a default converter will be provided if
	 * <code>provideDefaults</code> is <code>true</code>. The defaults can
	 * be changed by calling one of the setter methods.
	 *
	 * @param provideDefaults
	 *            if <code>true</code>, default validators and a default
	 *            converter will be provided based on the observable value's

	 *            {@link #POLICY_CONVERT}, or {@link #POLICY_UPDATE}
	 */
	public UpdateValueStrategy(boolean provideDefaults, int updatePolicy) {
		this(provideDefaults,updatePolicy,new DefaultConverterProvider());
	}

	/**
	 * @param provideDefaults
	 * @param updatePolicy
	 * @param provider
	 */
	public UpdateValueStrategy(boolean provideDefaults, int updatePolicy,IConverterProvider provider) {
		super(provider==null?new DefaultConverterProvider():provider);
		this.provideDefaults = provideDefaults;
		this.updatePolicy = updatePolicy;
	}

	 * {@link #setConverter(IConverter) converter} if one exists. If no
	 * converter exists no conversion occurs.
	 * </p>
	 *
	 * @param value
	 * @return the converted value
	 */

	 * Tries to create a validator that can validate values of type fromType.
	 * Returns <code>null</code> if no validator could be created. Either
	 * toType or modelDescription can be <code>null</code>, but not both.
	 *
	 * @param fromType
	 * @param toType
	 * @return an IValidator, or <code>null</code> if unsuccessful

	 * attempt is made to default the
	 * {@link #validateAfterGet(Object) after get validator}. If a validator
	 * cannot be defaulted it will be <code>null</code>.
	 *
	 * @param source
	 * @param destination
	 */

				}
			} else if (converter instanceof NumberToNumberConverter) {
				result = (IValidator) validatorsByConverter.get(converter);

				if (result == null) {
					if (converter instanceof NumberToByteConverter) {
						result = new NumberToByteValidator((NumberToByteConverter) converter);

	/**
	 * Sets the validator to be invoked after the source value is converted to
	 * the type of the destination observable.
	 *
	 * @param validator
	 * @return the receiver, to enable method call chaining
	 */

	/**
	 * Sets the validator to be invoked after the source value is retrieved at
	 * the beginning of the synchronization process.
	 *
	 * @param validator
	 * @return the receiver, to enable method call chaining
	 */

	/**
	 * Sets the validator to be invoked before the value is to be set on the
	 * destination at the end of the synchronization process.
	 *
	 * @param validator
	 * @return the receiver, to enable method call chaining
	 */

	/**
	 * Sets the converter to be invoked when converting from the source type to
	 * the destination type.
	 *
	 * @param converter
	 * @return the receiver, to enable method call chaining
	 */

	 * {@link #setAfterConvertValidator(IValidator) validator} if one exists. If
	 * one does not exist no validation will occur.
	 * </p>
	 *
	 * @param value
	 * @return an ok status
	 */

	 * {@link #setAfterGetValidator(IValidator) validator} if one exists. If one
	 * does not exist no validation will occur.
	 * </p>
	 *
	 * @param value
	 * @return an ok status
	 */

	 * {@link #setBeforeSetValidator(IValidator) validator} if one exists. If
	 * one does not exist no validation will occur.
	 * </p>
	 *
	 * @param value
	 * @return an ok status
	 */

		return beforeSetValidator == null ? Status.OK_STATUS
				: beforeSetValidator.validate(value);
	}

	/**
	 * Sets the current value of the given observable to the given value.
	 * Clients may extend but must call the super implementation.
	 *
	 * @param observableValue
	 * @param value
	 * @return status

		/**
		 * Associate a particular validator that can validate the conversion
		 * (fromClass, toClass)
		 *
		 * @param fromClass
		 *            The Class to convert from
		 * @param toClass


		/**
		 * Return an IValidator for a specific fromClass and toClass.
		 *
		 * @param fromClass
		 *            The Class to convert from
		 * @param toClass




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.core.internal.databinding;

import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.HashMap;
import java.util.Map;

import org.eclipse.core.databinding.conversion.IConverter;
import org.eclipse.core.databinding.conversion.IConverterProvider;
import org.eclipse.core.databinding.conversion.NumberToStringConverter;
import org.eclipse.core.databinding.conversion.StringToNumberConverter;
import org.eclipse.core.databinding.util.Policy;
import org.eclipse.core.internal.databinding.conversion.IdentityConverter;
import org.eclipse.core.internal.databinding.conversion.IntegerToStringConverter;
import org.eclipse.core.internal.databinding.conversion.NumberToBigDecimalConverter;
import org.eclipse.core.internal.databinding.conversion.NumberToBigIntegerConverter;
import org.eclipse.core.internal.databinding.conversion.NumberToByteConverter;
import org.eclipse.core.internal.databinding.conversion.NumberToDoubleConverter;
import org.eclipse.core.internal.databinding.conversion.NumberToFloatConverter;
import org.eclipse.core.internal.databinding.conversion.NumberToIntegerConverter;
import org.eclipse.core.internal.databinding.conversion.NumberToLongConverter;
import org.eclipse.core.internal.databinding.conversion.NumberToShortConverter;
import org.eclipse.core.internal.databinding.conversion.ObjectToStringConverter;
import org.eclipse.core.internal.databinding.conversion.StringToByteConverter;
import org.eclipse.core.internal.databinding.conversion.StringToShortConverter;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;

import com.ibm.icu.text.NumberFormat;


/**
 * @since 3.3
 *
 */
public class DefaultConverterProvider implements IConverterProvider {
	private static Map converterMap;

	private static final Class[] integerClasses = new Class[]{
		Byte.TYPE, Byte.class,
		Short.TYPE, Short.class,
		Integer.TYPE, Integer.class,
		Long.TYPE, Long.class,
		BigInteger.class};

	private static final Class[] floatClasses = new Class[] {
		Float.TYPE, Float.class,
		Double.TYPE, Double.class,
		BigDecimal.class};

	private static final String BOOLEAN_TYPE = "java.lang.Boolean.TYPE"; //$NON-NLS-1$
	private static final String SHORT_TYPE = "java.lang.Short.TYPE"; //$NON-NLS-1$
	private static final String BYTE_TYPE = "java.lang.Byte.TYPE"; //$NON-NLS-1$
	private static final String DOUBLE_TYPE = "java.lang.Double.TYPE"; //$NON-NLS-1$
	private static final String FLOAT_TYPE = "java.lang.Float.TYPE"; //$NON-NLS-1$
	private static final String INTEGER_TYPE = "java.lang.Integer.TYPE"; //$NON-NLS-1$
	private static final String LONG_TYPE = "java.lang.Long.TYPE"; //$NON-NLS-1$


	private static Class autoboxed(Class clazz) {
		if (clazz == Float.TYPE)
			return Float.class;
		else if (clazz == Double.TYPE)
			return Double.class;
		else if (clazz == Short.TYPE)
			return Short.class;
		else if (clazz == Integer.TYPE)
			return Integer.class;
		else if (clazz == Long.TYPE)
			return Long.class;
		else if (clazz == Byte.TYPE)
			return Byte.class;
		else if (clazz == Boolean.TYPE)
			return Boolean.class;
		return clazz;
	}




	/* (non-Javadoc)
	 * @see org.eclipse.core.databinding.conversion.IConverterProvider#createConverter(java.lang.Object, java.lang.Object)
	 */
	public IConverter createConverter(Object fromType, Object toType) {
		if (!(fromType instanceof Class) || !(toType instanceof Class)) {
			return null;
		}
		Class toClass = (Class) toType;
		Class originalToClass = toClass;
		if (toClass.isPrimitive()) {
			toClass = autoboxed(toClass);
		}
		Class fromClass = (Class) fromType;
		Class originalFromClass = fromClass;
		if (fromClass.isPrimitive()) {
			fromClass = autoboxed(fromClass);
		}
		if (!((Class) toType).isPrimitive()
				&& toClass.isAssignableFrom(fromClass)) {
			return new IdentityConverter(originalFromClass, originalToClass);
		}
		if (((Class) fromType).isPrimitive() && ((Class) toType).isPrimitive()
				&& fromType.equals(toType)) {
			return new IdentityConverter(originalFromClass, originalToClass);
		}
		Map converterMap = getConverterMap();
		Class[] supertypeHierarchyFlattened = ClassLookupSupport
				.getTypeHierarchyFlattened(fromClass);
		for (int i = 0; i < supertypeHierarchyFlattened.length; i++) {
			Class currentFromClass = supertypeHierarchyFlattened[i];
			if (currentFromClass == toType) {
				// converting to toType is just a widening
				return new IdentityConverter(fromClass, toClass);
			}
			Pair key = new Pair(getKeyForClass(fromType, currentFromClass),
					getKeyForClass(toType, toClass));
			Object converterOrClassname = converterMap.get(key);
			if (converterOrClassname instanceof IConverter) {
				return (IConverter) converterOrClassname;
			} else if (converterOrClassname instanceof String) {
				String classname = (String) converterOrClassname;
				Class converterClass;
				try {
					converterClass = Class.forName(classname);
					IConverter result = (IConverter) converterClass
							.newInstance();
					converterMap.put(key, result);
					return result;
				} catch (Exception e) {
					Policy
							.getLog()
							.log(
									new Status(
											IStatus.ERROR,
											Policy.JFACE_DATABINDING,
											0,
											"Error while instantiating default converter", e)); //$NON-NLS-1$
				}
			}
		}
		// Since we found no converter yet, try a "downcast" converter;
		// the IdentityConverter will automatically check the actual types at
		// runtime.
		if (fromClass.isAssignableFrom(toClass)) {
			return new IdentityConverter(originalFromClass, originalToClass);
		}
		return null;
	}

	/**
	 * Registers converters to boxed and unboxed types from a list of from classes.
	 *
	 * @param map
	 * @param numberFormat
	 * @param fromTypes
	 */
	private static void addNumberToByteConverters(Map map,
			NumberFormat numberFormat, Class[] fromTypes) {

		for (int i = 0; i < fromTypes.length; i++) {
			Class fromType = fromTypes[i];
			if (!fromType.equals(Byte.class) && !fromType.equals(Byte.TYPE)) {
				String fromName = (fromType.isPrimitive()) ? getKeyForClass(fromType, null) : fromType.getName();

				map.put(new Pair(fromName, BYTE_TYPE), new NumberToByteConverter(numberFormat, fromType, true));
				map.put(new Pair(fromName, Byte.class.getName()), new NumberToByteConverter(numberFormat, fromType, false));
			}
		}
	}

	/**
	 * Registers converters to boxed and unboxed types from a list of from classes.
	 *
	 * @param map
	 * @param numberFormat
	 * @param fromTypes
	 */
	private static void addNumberToShortConverters(Map map, NumberFormat numberFormat, Class[] fromTypes) {
		for (int i = 0; i < fromTypes.length; i++) {
			Class fromType = fromTypes[i];
			if (!fromType.equals(Short.class) && !fromType.equals(Short.TYPE)) {
				String fromName = (fromType.isPrimitive()) ? getKeyForClass(fromType, null) : fromType.getName();

				map.put(new Pair(fromName, SHORT_TYPE), new NumberToShortConverter(numberFormat, fromType, true));
				map.put(new Pair(fromName, Short.class.getName()), new NumberToShortConverter(numberFormat, fromType, false));
			}
		}
	}

	/**
	 * Registers converters to boxed and unboxed types from a list of from classes.
	 *
	 * @param map
	 * @param numberFormat
	 * @param fromTypes
	 */
	private static void addNumberToIntegerConverters(Map map, NumberFormat numberFormat, Class[] fromTypes) {
		for (int i = 0; i < fromTypes.length; i++) {
			Class fromType = fromTypes[i];
			if (!fromType.equals(Integer.class) && !fromType.equals(Integer.TYPE)) {
				String fromName = (fromType.isPrimitive()) ? getKeyForClass(fromType, null) : fromType.getName();

				map.put(new Pair(fromName, INTEGER_TYPE), new NumberToIntegerConverter(numberFormat, fromType, true));
				map.put(new Pair(fromName, Integer.class.getName()), new NumberToIntegerConverter(numberFormat, fromType, false));
			}
		}
	}

	/**
	 * Registers converters to boxed and unboxed types from a list of from classes.
	 *
	 * @param map
	 * @param numberFormat
	 * @param fromTypes
	 */
	private static void addNumberToLongConverters(Map map, NumberFormat numberFormat, Class[] fromTypes) {
		for (int i = 0; i < fromTypes.length; i++) {
			Class fromType = fromTypes[i];
			if (!fromType.equals(Long.class) && !fromType.equals(Long.TYPE)) {
				String fromName = (fromType.isPrimitive()) ? getKeyForClass(fromType, null) : fromType.getName();

				map.put(new Pair(fromName, LONG_TYPE), new NumberToLongConverter(numberFormat, fromType, true));
				map.put(new Pair(fromName, Long.class.getName()), new NumberToLongConverter(numberFormat, fromType, false));
			}
		}
	}

	/**
	 * Registers converters to boxed and unboxed types from a list of from classes.
	 *
	 * @param map
	 * @param numberFormat
	 * @param fromTypes
	 */
	private static void addNumberToFloatConverters(Map map, NumberFormat numberFormat, Class[] fromTypes) {
		for (int i = 0; i < fromTypes.length; i++) {
			Class fromType = fromTypes[i];
			if (!fromType.equals(Float.class) && !fromType.equals(Float.TYPE)) {
				String fromName = (fromType.isPrimitive()) ? getKeyForClass(fromType, null) : fromType.getName();

				map.put(new Pair(fromName, FLOAT_TYPE), new NumberToFloatConverter(numberFormat, fromType, true));
				map.put(new Pair(fromName, Float.class.getName()), new NumberToFloatConverter(numberFormat, fromType, false));
			}
		}
	}

	/**
	 * Registers converters to boxed and unboxed types from a list of from classes.
	 *
	 * @param map
	 * @param numberFormat
	 * @param fromTypes
	 */
	private static void addNumberToDoubleConverters(Map map, NumberFormat numberFormat, Class[] fromTypes) {
		for (int i = 0; i < fromTypes.length; i++) {
			Class fromType = fromTypes[i];
			if (!fromType.equals(Double.class) && !fromType.equals(Double.TYPE)) {
				String fromName = (fromType.isPrimitive()) ? getKeyForClass(fromType, null) : fromType.getName();

				map.put(new Pair(fromName, DOUBLE_TYPE), new NumberToDoubleConverter(numberFormat, fromType, true));
				map.put(new Pair(fromName, Double.class.getName()), new NumberToDoubleConverter(numberFormat, fromType, false));
			}
		}
	}

	/**
	 * Registers converters to boxed and unboxed types from a list of from classes.
	 *
	 * @param map
	 * @param numberFormat
	 * @param fromTypes
	 */
	private static void addNumberToBigIntegerConverters(Map map, NumberFormat numberFormat, Class[] fromTypes) {
		for (int i = 0; i < fromTypes.length; i++) {
			Class fromType = fromTypes[i];
			if (!fromType.equals(BigInteger.class)) {
				String fromName = (fromType.isPrimitive()) ? getKeyForClass(fromType, null) : fromType.getName();

				map.put(new Pair(fromName, BigInteger.class.getName()), new NumberToBigIntegerConverter(numberFormat, fromType));
			}
		}
	}

	/**
	 * Registers converters to boxed and unboxed types from a list of from classes.
	 *
	 * @param map
	 * @param numberFormat
	 * @param fromTypes
	 */
	private static void addNumberToBigDecimalConverters(Map map, NumberFormat numberFormat, Class[] fromTypes) {
		for (int i = 0; i < fromTypes.length; i++) {
			Class fromType = fromTypes[i];
			if (!fromType.equals(BigDecimal.class)) {
				String fromName = (fromType.isPrimitive()) ? getKeyForClass(fromType, null) : fromType.getName();

				map.put(new Pair(fromName, BigDecimal.class.getName()), new NumberToBigDecimalConverter(numberFormat, fromType));
			}
		}
	}


	private static String getKeyForClass(Object originalValue, Class filteredValue) {
		if (originalValue instanceof Class) {
			Class originalClass = (Class) originalValue;
			if (originalClass.equals(Integer.TYPE)) {
				return INTEGER_TYPE;
			} else if (originalClass.equals(Byte.TYPE)) {
				return BYTE_TYPE;
			} else if (originalClass.equals(Boolean.TYPE)) {
				return BOOLEAN_TYPE;
			} else if (originalClass.equals(Double.TYPE)) {
				return DOUBLE_TYPE;
			} else if (originalClass.equals(Float.TYPE)) {
				return FLOAT_TYPE;
			} else if (originalClass.equals(Long.TYPE)) {
				return LONG_TYPE;
			} else if (originalClass.equals(Short.TYPE)) {
				return SHORT_TYPE;
			}
		}
		return filteredValue.getName();
	}

	/**
	 * @param fromType
	 * @param toType
	 * @return whether fromType is assignable to toType
	 */
	public Boolean isAssignableFromTo(Object fromType, Object toType) {
		if (fromType instanceof Class && toType instanceof Class) {
			Class toClass = (Class) toType;
			if (toClass.isPrimitive()) {
				toClass = autoboxed(toClass);
			}
			Class fromClass = (Class) fromType;
			if (fromClass.isPrimitive()) {
				fromClass = autoboxed(fromClass);
			}
			return toClass.isAssignableFrom(fromClass) ? Boolean.TRUE
					: Boolean.FALSE;
		}
		return null;
	}



	private static Map getConverterMap() {
		// using string-based lookup avoids loading of too many classes
		if (converterMap == null) {
			//NumberFormat to be shared across converters for the formatting of integer values
			NumberFormat integerFormat = NumberFormat.getIntegerInstance();
			//NumberFormat to be shared across converters for formatting non integer values
			NumberFormat numberFormat = NumberFormat.getNumberInstance();

			converterMap = new HashMap();
			converterMap
					.put(
							new Pair("java.util.Date", "java.lang.String"), "org.eclipse.core.internal.databinding.conversion.DateToStringConverter"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
			converterMap
					.put(
							new Pair("java.lang.String", "java.lang.Boolean"), "org.eclipse.core.internal.databinding.conversion.StringToBooleanConverter"); //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$
			converterMap
					.put(
							new Pair("java.lang.String", "java.lang.Byte"), StringToByteConverter.toByte(integerFormat, false)); //$NON-NLS-1$//$NON-NLS-2$
			converterMap
					.put(
							new Pair("java.lang.String", "java.lang.Character"), "org.eclipse.core.internal.databinding.conversion.StringToCharacterConverter"); //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$
			converterMap
					.put(
							new Pair("java.lang.String", "java.util.Date"), "org.eclipse.core.internal.databinding.conversion.StringToDateConverter"); //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$
			converterMap
					.put(
							new Pair("java.lang.String", "java.lang.Short"), StringToShortConverter.toShort(integerFormat, false)); //$NON-NLS-1$//$NON-NLS-2$

			converterMap.put(new Pair("java.lang.String", "java.lang.Integer"), StringToNumberConverter.toInteger(integerFormat, false));  //$NON-NLS-1$//$NON-NLS-2$
			converterMap.put(new Pair("java.lang.String", "java.lang.Double"), StringToNumberConverter.toDouble(numberFormat, false));  //$NON-NLS-1$//$NON-NLS-2$
			converterMap.put(new Pair("java.lang.String", "java.lang.Long"), StringToNumberConverter.toLong(integerFormat, false));  //$NON-NLS-1$//$NON-NLS-2$
			converterMap.put(new Pair("java.lang.String", "java.lang.Float"), StringToNumberConverter.toFloat(numberFormat, false));  //$NON-NLS-1$//$NON-NLS-2$
			converterMap.put(new Pair("java.lang.String", "java.math.BigInteger"), StringToNumberConverter.toBigInteger(integerFormat));  //$NON-NLS-1$//$NON-NLS-2$
			converterMap.put(new Pair("java.lang.Integer", "java.lang.String"), NumberToStringConverter.fromInteger(integerFormat, false));  //$NON-NLS-1$//$NON-NLS-2$
			converterMap.put(new Pair("java.lang.Long", "java.lang.String"), NumberToStringConverter.fromLong(integerFormat, false));  //$NON-NLS-1$//$NON-NLS-2$
			converterMap.put(new Pair("java.lang.Double", "java.lang.String"), NumberToStringConverter.fromDouble(numberFormat, false));  //$NON-NLS-1$//$NON-NLS-2$
			converterMap.put(new Pair("java.lang.Float", "java.lang.String"), NumberToStringConverter.fromFloat(numberFormat, false));  //$NON-NLS-1$//$NON-NLS-2$
			converterMap.put(new Pair("java.math.BigInteger", "java.lang.String"), NumberToStringConverter.fromBigInteger(integerFormat));  //$NON-NLS-1$//$NON-NLS-2$
			converterMap.put(new Pair("java.lang.Byte", "java.lang.String"), IntegerToStringConverter.fromByte(integerFormat, false));   //$NON-NLS-1$//$NON-NLS-2$
			converterMap.put(new Pair("java.lang.Short", "java.lang.String"), IntegerToStringConverter.fromShort(integerFormat, false));  //$NON-NLS-1$//$NON-NLS-2$

			converterMap
					.put(
							new Pair("java.lang.Object", "java.lang.String"), "org.eclipse.core.internal.databinding.conversion.ObjectToStringConverter"); //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$

			// Integer.TYPE
			converterMap.put(new Pair("java.lang.String", INTEGER_TYPE), StringToNumberConverter.toInteger(integerFormat, true)); //$NON-NLS-1$
			converterMap
					.put(
							new Pair(INTEGER_TYPE, "java.lang.Integer"), new IdentityConverter(Integer.TYPE, Integer.class)); //$NON-NLS-1$
			converterMap
					.put(
							new Pair(INTEGER_TYPE, "java.lang.Object"), new IdentityConverter(Integer.TYPE, Object.class)); //$NON-NLS-1$
			converterMap.put(new Pair(INTEGER_TYPE, "java.lang.String"), NumberToStringConverter.fromInteger(integerFormat, true)); //$NON-NLS-1$

			// Byte.TYPE
			converterMap
					.put(
							new Pair("java.lang.String", BYTE_TYPE), StringToByteConverter.toByte(integerFormat, true)); //$NON-NLS-1$
			converterMap
					.put(
							new Pair(BYTE_TYPE, "java.lang.Byte"), new IdentityConverter(Byte.TYPE, Byte.class)); //$NON-NLS-1$
			converterMap
					.put(
							new Pair(BYTE_TYPE, "java.lang.String"), IntegerToStringConverter.fromByte(integerFormat, true)); //$NON-NLS-1$
			converterMap
					.put(
							new Pair(BYTE_TYPE, "java.lang.Object"), new IdentityConverter(Byte.TYPE, Object.class)); //$NON-NLS-1$

			// Double.TYPE
			converterMap.put(new Pair("java.lang.String", DOUBLE_TYPE), StringToNumberConverter.toDouble(numberFormat, true)); //$NON-NLS-1$
			converterMap.put(new Pair(DOUBLE_TYPE, "java.lang.String"), NumberToStringConverter.fromDouble(numberFormat, true)); //$NON-NLS-1$

			converterMap
					.put(
							new Pair(DOUBLE_TYPE, "java.lang.Double"), new IdentityConverter(Double.TYPE, Double.class)); //$NON-NLS-1$
			converterMap
					.put(
							new Pair(DOUBLE_TYPE, "java.lang.Object"), new IdentityConverter(Double.TYPE, Object.class)); //$NON-NLS-1$

			// Boolean.TYPE
			converterMap
					.put(
							new Pair("java.lang.String", BOOLEAN_TYPE), "org.eclipse.core.internal.databinding.conversion.StringToBooleanPrimitiveConverter"); //$NON-NLS-1$ //$NON-NLS-2$
			converterMap
					.put(
							new Pair(BOOLEAN_TYPE, "java.lang.Boolean"), new IdentityConverter(Boolean.TYPE, Boolean.class)); //$NON-NLS-1$
			converterMap
					.put(
							new Pair(BOOLEAN_TYPE, "java.lang.String"), new ObjectToStringConverter(Boolean.TYPE)); //$NON-NLS-1$
			converterMap
					.put(
							new Pair(BOOLEAN_TYPE, "java.lang.Object"), new IdentityConverter(Boolean.TYPE, Object.class)); //$NON-NLS-1$

			// Float.TYPE
			converterMap.put(new Pair("java.lang.String", FLOAT_TYPE), StringToNumberConverter.toFloat(numberFormat, true)); //$NON-NLS-1$
			converterMap.put(new Pair(FLOAT_TYPE, "java.lang.String"), NumberToStringConverter.fromFloat(numberFormat, true)); //$NON-NLS-1$
			converterMap
					.put(
							new Pair(FLOAT_TYPE, "java.lang.Float"), new IdentityConverter(Float.TYPE, Float.class)); //$NON-NLS-1$
			converterMap
					.put(
							new Pair(FLOAT_TYPE, "java.lang.Object"), new IdentityConverter(Float.TYPE, Object.class)); //$NON-NLS-1$

			// Short.TYPE
			converterMap
					.put(
							new Pair("java.lang.String", SHORT_TYPE), StringToShortConverter.toShort(integerFormat, true)); //$NON-NLS-1$
			converterMap
					.put(
							new Pair(SHORT_TYPE, "java.lang.Short"), new IdentityConverter(Short.TYPE, Short.class)); //$NON-NLS-1$
			converterMap
					.put(
							new Pair(SHORT_TYPE, "java.lang.String"), IntegerToStringConverter.fromShort(integerFormat, true)); //$NON-NLS-1$
			converterMap
					.put(
							new Pair(SHORT_TYPE, "java.lang.Object"), new IdentityConverter(Short.TYPE, Object.class)); //$NON-NLS-1$

			// Long.TYPE
			converterMap.put(new Pair("java.lang.String", LONG_TYPE), StringToNumberConverter.toLong(integerFormat, true)); //$NON-NLS-1$
			converterMap.put(new Pair(LONG_TYPE, "java.lang.String"), NumberToStringConverter.fromLong(integerFormat, true)); //$NON-NLS-1$
			converterMap
					.put(
							new Pair(LONG_TYPE, "java.lang.Long"), new IdentityConverter(Long.TYPE, Long.class)); //$NON-NLS-1$
			converterMap
					.put(
							new Pair(LONG_TYPE, "java.lang.Object"), new IdentityConverter(Long.TYPE, Object.class)); //$NON-NLS-1$

			converterMap
					.put(
							new Pair("org.eclipse.core.runtime.IStatus", "java.lang.String"), "org.eclipse.core.internal.databinding.conversion.StatusToStringConverter"); //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$

			addNumberToByteConverters(converterMap, integerFormat, integerClasses);
			addNumberToByteConverters(converterMap, numberFormat, floatClasses);

			addNumberToShortConverters(converterMap, integerFormat, integerClasses);
			addNumberToShortConverters(converterMap, numberFormat, floatClasses);

			addNumberToIntegerConverters(converterMap, integerFormat, integerClasses);
			addNumberToIntegerConverters(converterMap, numberFormat, floatClasses);

			addNumberToLongConverters(converterMap, integerFormat, integerClasses);
			addNumberToLongConverters(converterMap, numberFormat, floatClasses);

			addNumberToFloatConverters(converterMap, integerFormat, integerClasses);
			addNumberToFloatConverters(converterMap, numberFormat, floatClasses);

			addNumberToDoubleConverters(converterMap, integerFormat, integerClasses);
			addNumberToDoubleConverters(converterMap, numberFormat, floatClasses);

			addNumberToBigIntegerConverters(converterMap, integerFormat, integerClasses);
			addNumberToBigIntegerConverters(converterMap, numberFormat, floatClasses);

			addNumberToBigDecimalConverters(converterMap, integerFormat, integerClasses);
			addNumberToBigDecimalConverters(converterMap, numberFormat, floatClasses);
		}

		return converterMap;
	}
}




/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.core.databinding.conversion;

/**
 * @since 3.3
 *
 */
public interface IConverterProvider {
	/**
	 * @param fromType
	 * @param toType
	 * @return the converter
	 */
	public IConverter createConverter(Object fromType, Object toType);

	/**
	 * @param fromType
	 * @param toType
	 * @return null
	 */
	public Boolean isAssignableFromTo(Object fromType, Object toType);
}

Return to bug 203492

Lines 12-20 Link Here

(-)src/org/eclipse/core/databinding/UpdateListStrategy.java (-11 / +38 lines)
12	package org.eclipse.core.databinding;	12	package org.eclipse.core.databinding;
13		13
14	import org.eclipse.core.databinding.conversion.IConverter;	14	import org.eclipse.core.databinding.conversion.IConverter;
		15	import org.eclipse.core.databinding.conversion.IConverterProvider;
15	import org.eclipse.core.databinding.observable.list.IObservableList;	16	import org.eclipse.core.databinding.observable.list.IObservableList;
16	import org.eclipse.core.databinding.validation.ValidationStatus;	17	import org.eclipse.core.databinding.validation.ValidationStatus;
17	import org.eclipse.core.internal.databinding.BindingMessages;	18	import org.eclipse.core.internal.databinding.BindingMessages;
		19	import org.eclipse.core.internal.databinding.DefaultConverterProvider;
18	import org.eclipse.core.runtime.IStatus;	20	import org.eclipse.core.runtime.IStatus;
19	import org.eclipse.core.runtime.Status;	21	import org.eclipse.core.runtime.Status;
20		22
Lines 36-43 Link Here
36	* construction of the strategy (e.g. {@link #POLICY_NEVER},	38	* construction of the strategy (e.g. {@link #POLICY_NEVER},
37	* {@link #POLICY_ON_REQUEST}, {@link #POLICY_UPDATE}).	39	* {@link #POLICY_ON_REQUEST}, {@link #POLICY_UPDATE}).
38	* </p>	40	* </p>
39	*	41	*
40	*	42	*
41	* @see DataBindingContext#bindList(IObservableList, IObservableList,	43	* @see DataBindingContext#bindList(IObservableList, IObservableList,
42	* UpdateListStrategy, UpdateListStrategy)	44	* UpdateListStrategy, UpdateListStrategy)
43	* @see IConverter	45	* @see IConverter
Lines 71-77 Link Here
71	* Helper method allowing API evolution of the above constant values. The	73	* Helper method allowing API evolution of the above constant values. The
72	* compiler will not inline constant values into client code if values are	74	* compiler will not inline constant values into client code if values are
73	* "computed" using this helper.	75	* "computed" using this helper.
74	*	76	*
75	* @param i	77	* @param i
76	* an integer	78	* an integer
77	* @return the same integer	79	* @return the same integer
Lines 93-106 Link Here
93	* calling one of the setter methods.	95	* calling one of the setter methods.
94	*/	96	*/
95	public UpdateListStrategy() {	97	public UpdateListStrategy() {
96	this(true, POLICY_UPDATE);	98	this(true, POLICY_UPDATE,new DefaultConverterProvider());
		99	}
		100
		101	/**
		102	* @param provider
		103	*/
		104	public UpdateListStrategy(IConverterProvider provider) {
		105	this(true,POLICY_UPDATE,provider);
97	}	106	}
98		107
99	/**	108	/**
100	* Creates a new update list strategy with a configurable update policy. A	109	* Creates a new update list strategy with a configurable update policy. A
101	* default converter will be provided. The defaults can be changed by	110	* default converter will be provided. The defaults can be changed by
102	* calling one of the setter methods.	111	* calling one of the setter methods.
103	*	112	*
104	* @param updatePolicy	113	* @param updatePolicy
105	* one of {@link #POLICY_NEVER}, {@link #POLICY_ON_REQUEST}, or	114	* one of {@link #POLICY_NEVER}, {@link #POLICY_ON_REQUEST}, or
106	* {@link #POLICY_UPDATE}	115	* {@link #POLICY_UPDATE}
Lines 110-120 Link Here
110	}	119	}
111		120
112	/**	121	/**
		122	* @param updatePolicy
		123	* @param provider
		124	*/
		125	public UpdateListStrategy(int updatePolicy,IConverterProvider provider) {
		126	this(true,updatePolicy,provider);
		127	}
		128
		129	/**
113	* Creates a new update list strategy with a configurable update policy. A	130	* Creates a new update list strategy with a configurable update policy. A
114	* default converter will be provided if <code>provideDefaults</code> is	131	* default converter will be provided if <code>provideDefaults</code> is
115	* <code>true</code>. The defaults can be changed by calling one of the	132	* <code>true</code>. The defaults can be changed by calling one of the
116	* setter methods.	133	* setter methods.
117	*	134	*
118	* @param provideDefaults	135	* @param provideDefaults
119	* if <code>true</code>, default validators and a default	136	* if <code>true</code>, default validators and a default
120	* converter will be provided based on the observable list's	137	* converter will be provided based on the observable list's
Lines 124-129 Link Here
124	* {@link #POLICY_UPDATE}	141	* {@link #POLICY_UPDATE}
125	*/	142	*/
126	public UpdateListStrategy(boolean provideDefaults, int updatePolicy) {	143	public UpdateListStrategy(boolean provideDefaults, int updatePolicy) {
		144	this(true,updatePolicy,new DefaultConverterProvider());
		145	}
		146
		147	/**
		148	* @param provideDefaults
		149	* @param updatePolicy
		150	* @param provider
		151	*/
		152	public UpdateListStrategy(boolean provideDefaults, int updatePolicy, IConverterProvider provider) {
		153	super(provider==null?new DefaultConverterProvider():provider);
127	this.provideDefaults = provideDefaults;	154	this.provideDefaults = provideDefaults;
128	this.updatePolicy = updatePolicy;	155	this.updatePolicy = updatePolicy;
129	}	156	}
Lines 136-142 Link Here
136	* {@link #setConverter(IConverter) converter} if one exists. If no	163	* {@link #setConverter(IConverter) converter} if one exists. If no
137	* converter exists no conversion occurs.	164	* converter exists no conversion occurs.
138	* </p>	165	* </p>
139	*	166	*
140	* @param element	167	* @param element
141	* @return the converted element	168	* @return the converted element
142	*/	169	*/
Lines 145-151 Link Here
145	}	172	}
146		173
147	/**	174	/**
148	*	175	*
149	* @param source	176	* @param source
150	* @param destination	177	* @param destination
151	*/	178	*/
Lines 180-186 Link Here
180	/**	207	/**
181	* Sets the converter to be invoked when converting added elements from the	208	* Sets the converter to be invoked when converting added elements from the
182	* source element type to the destination element type.	209	* source element type to the destination element type.
183	*	210	*
184	* @param converter	211	* @param converter
185	* @return the receiver, to enable method call chaining	212	* @return the receiver, to enable method call chaining
186	*/	213	*/
Lines 192-198 Link Here
192	/**	219	/**
193	* Adds the given element at the given index to the given observable list.	220	* Adds the given element at the given index to the given observable list.
194	* Clients may extend but must call the super implementation.	221	* Clients may extend but must call the super implementation.
195	*	222	*
196	* @param observableList	223	* @param observableList
197	* @param element	224	* @param element
198	* @param index	225	* @param index
Lines 213-219 Link Here
213	/**	240	/**
214	* Removes the element at the given index from the given observable list.	241	* Removes the element at the given index from the given observable list.
215	* Clients may extend but must call the super implementation.	242	* Clients may extend but must call the super implementation.
216	*	243	*
217	* @param observableList	244	* @param observableList
218	* @param index	245	* @param index
219	* @return a status	246	* @return a status

Lines 15-24 Link Here

(-)src/org/eclipse/core/databinding/UpdateValueStrategy.java (-20 / +47 lines)
15	import java.util.HashMap;	15	import java.util.HashMap;
16		16
17	import org.eclipse.core.databinding.conversion.IConverter;	17	import org.eclipse.core.databinding.conversion.IConverter;
		18	import org.eclipse.core.databinding.conversion.IConverterProvider;
18	import org.eclipse.core.databinding.observable.value.IObservableValue;	19	import org.eclipse.core.databinding.observable.value.IObservableValue;
19	import org.eclipse.core.databinding.validation.IValidator;	20	import org.eclipse.core.databinding.validation.IValidator;
20	import org.eclipse.core.databinding.validation.ValidationStatus;	21	import org.eclipse.core.databinding.validation.ValidationStatus;
21	import org.eclipse.core.internal.databinding.BindingMessages;	22	import org.eclipse.core.internal.databinding.BindingMessages;
		23	import org.eclipse.core.internal.databinding.DefaultConverterProvider;
22	import org.eclipse.core.internal.databinding.Pair;	24	import org.eclipse.core.internal.databinding.Pair;
23	import org.eclipse.core.internal.databinding.conversion.NumberToBigDecimalConverter;	25	import org.eclipse.core.internal.databinding.conversion.NumberToBigDecimalConverter;
24	import org.eclipse.core.internal.databinding.conversion.NumberToBigIntegerConverter;	26	import org.eclipse.core.internal.databinding.conversion.NumberToBigIntegerConverter;
Lines 87-93 Link Here
87	* construction of the strategy (e.g. {@link #POLICY_NEVER},	89	* construction of the strategy (e.g. {@link #POLICY_NEVER},
88	* {@link #POLICY_CONVERT}, {@link #POLICY_ON_REQUEST}, {@link #POLICY_UPDATE}).	90	* {@link #POLICY_CONVERT}, {@link #POLICY_ON_REQUEST}, {@link #POLICY_UPDATE}).
89	* </p>	91	* </p>
90	*	92	*
91	* @see DataBindingContext#bindValue(IObservableValue, IObservableValue,	93	* @see DataBindingContext#bindValue(IObservableValue, IObservableValue,
92	* UpdateValueStrategy, UpdateValueStrategy)	94	* UpdateValueStrategy, UpdateValueStrategy)
93	* @see Binding#getValidationStatus()	95	* @see Binding#getValidationStatus()
Lines 131-137 Link Here
131	* Helper method allowing API evolution of the above constant values. The	133	* Helper method allowing API evolution of the above constant values. The
132	* compiler will not inline constant values into client code if values are	134	* compiler will not inline constant values into client code if values are
133	* "computed" using this helper.	135	* "computed" using this helper.
134	*	136	*
135	* @param i	137	* @param i
136	* an integer	138	* an integer
137	* @return the same integer	139	* @return the same integer
Lines 168-183 Link Here
168	}	170	}
169		171
170	/**	172	/**
		173	* @param provider
		174	*/
		175	public UpdateValueStrategy(IConverterProvider provider) {
		176	this(true,POLICY_UPDATE,provider);
		177	}
		178
		179	/**
171	* Creates a new update value strategy with a configurable update policy.	180	* Creates a new update value strategy with a configurable update policy.
172	* Default validators and a default converter will be provided. The defaults	181	* Default validators and a default converter will be provided. The defaults
173	* can be changed by calling one of the setter methods.	182	* can be changed by calling one of the setter methods.
174	*	183	*
175	* @param updatePolicy	184	* @param updatePolicy
176	* one of {@link #POLICY_NEVER}, {@link #POLICY_ON_REQUEST},	185	* one of {@link #POLICY_NEVER}, {@link #POLICY_ON_REQUEST},
177	* {@link #POLICY_CONVERT}, or {@link #POLICY_UPDATE}	186	* {@link #POLICY_CONVERT}, or {@link #POLICY_UPDATE}
178	*/	187	*/
179	public UpdateValueStrategy(int updatePolicy) {	188	public UpdateValueStrategy(int updatePolicy) {
180	this(true, updatePolicy);	189	this(true, updatePolicy, new DefaultConverterProvider());
		190	}
		191
		192	/**
		193	* @param updatePolicy
		194	* @param provider
		195	*/
		196	public UpdateValueStrategy(int updatePolicy,IConverterProvider provider) {
		197	this(true,updatePolicy,provider);
181	}	198	}
182		199
183	/**	200	/**
Lines 185-191 Link Here
185	* Default validators and a default converter will be provided if	202	* Default validators and a default converter will be provided if
186	* <code>provideDefaults</code> is <code>true</code>. The defaults can	203	* <code>provideDefaults</code> is <code>true</code>. The defaults can
187	* be changed by calling one of the setter methods.	204	* be changed by calling one of the setter methods.
188	*	205	*
189	* @param provideDefaults	206	* @param provideDefaults
190	* if <code>true</code>, default validators and a default	207	* if <code>true</code>, default validators and a default
191	* converter will be provided based on the observable value's	208	* converter will be provided based on the observable value's
Lines 195-200 Link Here
195	* {@link #POLICY_CONVERT}, or {@link #POLICY_UPDATE}	212	* {@link #POLICY_CONVERT}, or {@link #POLICY_UPDATE}
196	*/	213	*/
197	public UpdateValueStrategy(boolean provideDefaults, int updatePolicy) {	214	public UpdateValueStrategy(boolean provideDefaults, int updatePolicy) {
		215	this(provideDefaults,updatePolicy,new DefaultConverterProvider());
		216	}
		217
		218	/**
		219	* @param provideDefaults
		220	* @param updatePolicy
		221	* @param provider
		222	*/
		223	public UpdateValueStrategy(boolean provideDefaults, int updatePolicy,IConverterProvider provider) {
		224	super(provider==null?new DefaultConverterProvider():provider);
198	this.provideDefaults = provideDefaults;	225	this.provideDefaults = provideDefaults;
199	this.updatePolicy = updatePolicy;	226	this.updatePolicy = updatePolicy;
200	}	227	}
Lines 206-212 Link Here
206	* {@link #setConverter(IConverter) converter} if one exists. If no	233	* {@link #setConverter(IConverter) converter} if one exists. If no
207	* converter exists no conversion occurs.	234	* converter exists no conversion occurs.
208	* </p>	235	* </p>
209	*	236	*
210	* @param value	237	* @param value
211	* @return the converted value	238	* @return the converted value
212	*/	239	*/
Lines 218-224 Link Here
218	* Tries to create a validator that can validate values of type fromType.	245	* Tries to create a validator that can validate values of type fromType.
219	* Returns <code>null</code> if no validator could be created. Either	246	* Returns <code>null</code> if no validator could be created. Either
220	* toType or modelDescription can be <code>null</code>, but not both.	247	* toType or modelDescription can be <code>null</code>, but not both.
221	*	248	*
222	* @param fromType	249	* @param fromType
223	* @param toType	250	* @param toType
224	* @return an IValidator, or <code>null</code> if unsuccessful	251	* @return an IValidator, or <code>null</code> if unsuccessful
Lines 243-249 Link Here
243	* attempt is made to default the	270	* attempt is made to default the
244	* {@link #validateAfterGet(Object) after get validator}. If a validator	271	* {@link #validateAfterGet(Object) after get validator}. If a validator
245	* cannot be defaulted it will be <code>null</code>.	272	* cannot be defaulted it will be <code>null</code>.
246	*	273	*
247	* @param source	274	* @param source
248	* @param destination	275	* @param destination
249	*/	276	*/
Lines 316-322 Link Here
316	}	343	}
317	} else if (converter instanceof NumberToNumberConverter) {	344	} else if (converter instanceof NumberToNumberConverter) {
318	result = (IValidator) validatorsByConverter.get(converter);	345	result = (IValidator) validatorsByConverter.get(converter);
319		346
320	if (result == null) {	347	if (result == null) {
321	if (converter instanceof NumberToByteConverter) {	348	if (converter instanceof NumberToByteConverter) {
322	result = new NumberToByteValidator((NumberToByteConverter) converter);	349	result = new NumberToByteValidator((NumberToByteConverter) converter);
Lines 355-361 Link Here
355	/**	382	/**
356	* Sets the validator to be invoked after the source value is converted to	383	* Sets the validator to be invoked after the source value is converted to
357	* the type of the destination observable.	384	* the type of the destination observable.
358	*	385	*
359	* @param validator	386	* @param validator
360	* @return the receiver, to enable method call chaining	387	* @return the receiver, to enable method call chaining
361	*/	388	*/
Lines 367-373 Link Here
367	/**	394	/**
368	* Sets the validator to be invoked after the source value is retrieved at	395	* Sets the validator to be invoked after the source value is retrieved at
369	* the beginning of the synchronization process.	396	* the beginning of the synchronization process.
370	*	397	*
371	* @param validator	398	* @param validator
372	* @return the receiver, to enable method call chaining	399	* @return the receiver, to enable method call chaining
373	*/	400	*/
Lines 379-385 Link Here
379	/**	406	/**
380	* Sets the validator to be invoked before the value is to be set on the	407	* Sets the validator to be invoked before the value is to be set on the
381	* destination at the end of the synchronization process.	408	* destination at the end of the synchronization process.
382	*	409	*
383	* @param validator	410	* @param validator
384	* @return the receiver, to enable method call chaining	411	* @return the receiver, to enable method call chaining
385	*/	412	*/
Lines 391-397 Link Here
391	/**	418	/**
392	* Sets the converter to be invoked when converting from the source type to	419	* Sets the converter to be invoked when converting from the source type to
393	* the destination type.	420	* the destination type.
394	*	421	*
395	* @param converter	422	* @param converter
396	* @return the receiver, to enable method call chaining	423	* @return the receiver, to enable method call chaining
397	*/	424	*/
Lines 407-413 Link Here
407	* {@link #setAfterConvertValidator(IValidator) validator} if one exists. If	434	* {@link #setAfterConvertValidator(IValidator) validator} if one exists. If
408	* one does not exist no validation will occur.	435	* one does not exist no validation will occur.
409	* </p>	436	* </p>
410	*	437	*
411	* @param value	438	* @param value
412	* @return an ok status	439	* @return an ok status
413	*/	440	*/
Lines 423-429 Link Here
423	* {@link #setAfterGetValidator(IValidator) validator} if one exists. If one	450	* {@link #setAfterGetValidator(IValidator) validator} if one exists. If one
424	* does not exist no validation will occur.	451	* does not exist no validation will occur.
425	* </p>	452	* </p>
426	*	453	*
427	* @param value	454	* @param value
428	* @return an ok status	455	* @return an ok status
429	*/	456	*/
Lines 439-445 Link Here
439	* {@link #setBeforeSetValidator(IValidator) validator} if one exists. If	466	* {@link #setBeforeSetValidator(IValidator) validator} if one exists. If
440	* one does not exist no validation will occur.	467	* one does not exist no validation will occur.
441	* </p>	468	* </p>
442	*	469	*
443	* @param value	470	* @param value
444	* @return an ok status	471	* @return an ok status
445	*/	472	*/
Lines 447-457 Link Here
447	return beforeSetValidator == null ? Status.OK_STATUS	474	return beforeSetValidator == null ? Status.OK_STATUS
448	: beforeSetValidator.validate(value);	475	: beforeSetValidator.validate(value);
449	}	476	}
450		477
451	/**	478	/**
452	* Sets the current value of the given observable to the given value.	479	* Sets the current value of the given observable to the given value.
453	* Clients may extend but must call the super implementation.	480	* Clients may extend but must call the super implementation.
454	*	481	*
455	* @param observableValue	482	* @param observableValue
456	* @param value	483	* @param value
457	* @return status	484	* @return status
Lines 512-518 Link Here
512	/**	539	/**
513	* Associate a particular validator that can validate the conversion	540	* Associate a particular validator that can validate the conversion
514	* (fromClass, toClass)	541	* (fromClass, toClass)
515	*	542	*
516	* @param fromClass	543	* @param fromClass
517	* The Class to convert from	544	* The Class to convert from
518	* @param toClass	545	* @param toClass
Lines 527-533 Link Here
527		554
528	/**	555	/**
529	* Return an IValidator for a specific fromClass and toClass.	556	* Return an IValidator for a specific fromClass and toClass.
530	*	557	*
531	* @param fromClass	558	* @param fromClass
532	* The Class to convert from	559	* The Class to convert from
533	* @param toClass	560	* @param toClass

Added Link Here

(-)src/org/eclipse/core/databinding/conversion/IConverterProvider.java (+32 lines)
1	/*******************************************************************************
2	* Copyright (c) 2007 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.core.databinding.conversion;
13
14	/**
15	* @since 3.3
16	*
17	*/
18	public interface IConverterProvider {
19	/**
20	* @param fromType
21	* @param toType
22	* @return the converter
23	*/
24	public IConverter createConverter(Object fromType, Object toType);
25
26	/**
27	* @param fromType
28	* @param toType
29	* @return null
30	*/
31	public Boolean isAssignableFromTo(Object fromType, Object toType);
32	}