Attachment #82601 for bug #203492

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




/*******************************************************************************
 * 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;

import org.eclipse.core.databinding.observable.value.IObservableValue;

/**
 * Implementation of {@link IValueBindingBuilderDelegate} that determines
 * converters and validators from an {@link IStrategyDefaultsProvider}.
 */
public class ValueBindingBuilderDelegate implements
		IValueBindingBuilderDelegate {
	private IStrategyDefaultsProvider defaultsProvider;

	/**
	 * Constructs a new instance with the provided <code>defaultsProvider</code>.
	 * 
	 * @param defaultsProvider
	 */
	public ValueBindingBuilderDelegate(IStrategyDefaultsProvider defaultsProvider) {
		if (defaultsProvider == null) {
			throw new IllegalArgumentException(
					"Parameter 'defaultsProvider' was null."); //$NON-NLS-1$
		}

		this.defaultsProvider = defaultsProvider;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.core.databinding.IValueBindingBuilderDelegate#prepare(org.eclipse.core.databinding.observable.value.IObservableValue,
	 *      org.eclipse.core.databinding.observable.value.IObservableValue,
	 *      org.eclipse.core.databinding.UpdateValueStrategy,
	 *      org.eclipse.core.databinding.UpdateValueStrategy)
	 */
	public void prepare(IObservableValue source, IObservableValue destination,
			UpdateValueStrategy sourceToModelStrategy,
			UpdateValueStrategy destinationToTargetStrategy) {

		Object sourceType = source.getValueType();
		Object destinationType = destination.getValueType();

		if (sourceType != null && destinationType != null) {
			StrategyDefaults defaults = defaultsProvider.getDefaults(sourceType, destinationType);
			sourceToModelStrategy.setConverter(defaults.getConverter());
			sourceToModelStrategy.setAfterGetValidator(defaults.getValidator());

			defaults = defaultsProvider.getDefaults(destinationType, sourceType);
			destinationToTargetStrategy.setConverter(defaults.getConverter());
			destinationToTargetStrategy.setAfterGetValidator(defaults.getValidator());
		}
	}

	/* (non-Javadoc)
	 * @see org.eclipse.core.databinding.IValueBindingBuilderDelegate#createDestinationToSourceStrategy(int, org.eclipse.core.databinding.observable.value.IObservableValue, org.eclipse.core.databinding.observable.value.IObservableValue)
	 */
	public UpdateValueStrategy createDestinationToSourceStrategy(int policy,
			IObservableValue source, IObservableValue destination) {
		return new UpdateValueStrategy(policy);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.core.databinding.IValueBindingBuilderDelegate#createSourceToDestinationStrategy(int, org.eclipse.core.databinding.observable.value.IObservableValue, org.eclipse.core.databinding.observable.value.IObservableValue)
	 */
	public UpdateValueStrategy createSourceToDestinationStrategy(int policy,
			IObservableValue source, IObservableValue destination) {
		return new UpdateValueStrategy(policy);
	}
}




/*******************************************************************************
 * 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;

import org.eclipse.core.databinding.conversion.IConverter;
import org.eclipse.core.databinding.validation.IValidator;

/**
 * Provider of defaults (e.g. {@link IConverter converters} and
 * {@link IValidator validators}) to the binding process.
 */
public interface IStrategyDefaultsProvider {
	/**
	 * Provides a default converter and validator for the provides types.
	 * 
	 * @param sourceType
	 * @param destinationType
	 * @return defaults, <code>null</code> if none found
	 */
	public StrategyDefaults getDefaults(Object sourceType, Object destinationType);
}




/*******************************************************************************
 * 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;

import org.eclipse.core.databinding.observable.value.IObservableValue;

/**
 * A delegate for a {@link ValueBindingBuilder} to externalize the setup of the
 * binding.
 */
public interface IValueBindingBuilderDelegate {
	/**
	 * Creates the update strategy to be used when updating from source to
	 * destination.
	 * 
	 * @param policy
	 * 
	 * @param source
	 * @param destination
	 * @return strategy
	 */
	public UpdateValueStrategy createSourceToDestinationStrategy(int policy,
			IObservableValue source, IObservableValue destination);

	/**
	 * Creates the update strategy to be used when updating from destination to
	 * source.
	 * 
	 * @param policy
	 * @param source
	 * @param destination
	 * @return strategy
	 */
	public UpdateValueStrategy createDestinationToSourceStrategy(int policy,
			IObservableValue source, IObservableValue destination);

	/**
	 * Invoked for the customization of the provided strategies. This allows for
	 * the configuring of converters and validators in the strategies.
	 * 
	 * @param source
	 * @param destination
	 * @param sourceToDestinationStrategy
	 * @param destinationToSourceStrategy
	 */
	public void prepare(IObservableValue source, IObservableValue destination,
			UpdateValueStrategy sourceToDestinationStrategy,
			UpdateValueStrategy destinationToSourceStrategy);
}




/*******************************************************************************
 * 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;

import org.eclipse.core.databinding.conversion.IConverter;
import org.eclipse.core.databinding.validation.IValidator;

/**
 * 
 */
public class StrategyDefaults {
	private IConverter converter;
	private IValidator validator;
	
	public StrategyDefaults() {
	}
	
	public StrategyDefaults(IConverter converter, IValidator validator) {
		this.setConverter(converter);
		this.setValidator(validator);
	}

	/**
	 * @param converter The converter to set.
	 */
	public void setConverter(IConverter converter) {
		this.converter = converter;
	}

	/**
	 * @return Returns the converter.
	 */
	public IConverter getConverter() {
		return converter;
	}

	/**
	 * @param validator The validator to set.
	 */
	public void setValidator(IValidator validator) {
		this.validator = validator;
	}

	/**
	 * @return Returns the validator.
	 */
	public IValidator getValidator() {
		return validator;
	}
}




/*******************************************************************************
 * 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;

import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.core.runtime.Assert;

/**
 * A builder to streamline the process of constructing {@link Binding bindings}
 * between {@link IObservableValue observable values}.
 */
public class ValueBindingBuilder {
	private int sourceToDestinationPolicy = -1;

	private int destinationToSourcePolicy = -1;

	private DataBindingContext dbc;

	private IValueBindingBuilderDelegate delegate;

	/**
	 * Constructs a new instance. Public instantiation is not allowed.
	 * 
	 * @see #withDefaults()
	 */
	private ValueBindingBuilder() {
	}

	/**
	 * Sets the {@link UpdateValueStrategy#getUpdatePolicy() update policy} to
	 * be used for source to destination updates.
	 * 
	 * @param updatePolicy
	 * @return this builder for chaining
	 */
	public ValueBindingBuilder sourceToDestinationPolicy(int updatePolicy) {
		sourceToDestinationPolicy = updatePolicy;
		return this;
	}

	public int getSourceToDestinationPolicy() {
		return sourceToDestinationPolicy;
	}

	/**
	 * Sets the {@link UpdateValueStrategy#getUpdatePolicy() update policy} to
	 * be used for destination to source updates.
	 * 
	 * @param updatePolicy
	 * @return this builder for chaining
	 */
	public ValueBindingBuilder destinationToSourcePolicy(int updatePolicy) {
		destinationToSourcePolicy = updatePolicy;
		return this;
	}

	public int getDestinationToSourcePolicy() {
		return destinationToSourcePolicy;
	}

	/**
	 * Sets the {@link DataBindingContext} to be used when creating bindings.
	 * 
	 * @param dbc
	 * @return this builder for chaining
	 */
	public ValueBindingBuilder dbc(DataBindingContext dbc) {
		this.dbc = dbc;
		return this;
	}

	public DataBindingContext getDbc() {
		return dbc;
	}

	/**
	 * Creates a copy of the builder inheriting all state.
	 * 
	 * @return new builder
	 */
	public ValueBindingBuilder copy() {
		ValueBindingBuilder builder = new ValueBindingBuilder();
		builder.sourceToDestinationPolicy = sourceToDestinationPolicy;
		builder.destinationToSourcePolicy = destinationToSourcePolicy;
		builder.dbc = dbc;
		builder.delegate = delegate;

		return builder;
	}

	/**
	 * Sets the delegate to prepare strategies.
	 * 
	 * @param delegate
	 * @return this builder for chaining
	 */
	public ValueBindingBuilder delegate(IValueBindingBuilderDelegate delegate) {
		this.delegate = delegate;
		return this;
	}

	public IValueBindingBuilderDelegate getDelegate() {
		return delegate;
	}

	/**
	 * Binds the provided <code>source</code> to the provided
	 * <code>destination</code> using the {@link DataBindingContext} in
	 * context.
	 * 
	 * @param source
	 *            source to bind, does not become state in the builder
	 * @param destination
	 *            destination to bind, does not become state in the builder
	 * @return binding
	 */
	public Binding bind(IObservableValue source, IObservableValue destination) {
		return bind(dbc, source, destination);
	}

	/**
	 * Binds the provided <code>source</code> to the provided
	 * <code>destination</code> using the provided <code>dbc</code>.
	 * 
	 * @param dbc
	 *            dbc to create the binding, does not become state in the
	 *            builder
	 * @param source
	 *            source to bind, does not become state in the builder
	 * @param destination
	 *            destination to bind, does not become state in the builder
	 * @return binding
	 */
	public Binding bind(DataBindingContext dbc, IObservableValue source,
			IObservableValue destination) {
		return bind(dbc, sourceToDestinationPolicy, destinationToSourcePolicy,
				source, destination);
	}

	/**
	 * Binds the provided <code>source</code> to the provided
	 * <code>destination</code> using the provided <code>dbc</code>.
	 * 
	 * @param dbc
	 *            creates the binding, does not become state in the builder
	 * @param sourceToDestinationPolicy
	 *            policy for source to destination updates, does not become
	 *            state in the builder
	 * @param destinationToSourcePolicy
	 *            policy for destination to source updates, does not become
	 *            state in the builder
	 * @param source
	 *            source to bind, does not become state in the builder
	 * @param destination
	 *            destination to bind, does not become state in the builder
	 * @return binding
	 */
	public Binding bind(DataBindingContext dbc, int sourceToDestinationPolicy,
			int destinationToSourcePolicy, IObservableValue source,
			IObservableValue destination) {
		if (dbc == null) {
			throw new IllegalArgumentException("Parameter 'dbc' was null."); //$NON-NLS-1$
		}
		if (source == null) {
			throw new IllegalArgumentException("Parameter 'source' was null."); //$NON-NLS-1$
		}
		if (destination == null) {
			throw new IllegalArgumentException(
					"Parameter 'destination' was null."); //$NON-NLS-1$
		}

		if (delegate == null) {
			// Default a delegate if one hasn't been set yet.
			delegate = new ValueBindingBuilderDelegate(
					new CoreStrategyDefaultsProvider());
		}
		
		UpdateValueStrategy sourceToDestinationStrategy = delegate
				.createSourceToDestinationStrategy(sourceToDestinationPolicy,
						source, destination);
		UpdateValueStrategy destinationToSourceStrategy = delegate
				.createSourceToDestinationStrategy(destinationToSourcePolicy,
						source, destination);

		Assert.isNotNull(sourceToDestinationStrategy,
				"source to destination strategy"); //$NON-NLS-1$
		Assert.isNotNull(destinationToSourceStrategy,
				"destination to source strategy"); //$NON-NLS-1$


		delegate.prepare(source, destination, sourceToDestinationStrategy,
				destinationToSourceStrategy);

		// For backwards compability.
		sourceToDestinationStrategy.fillDefaults(source, destination);
		destinationToSourceStrategy.fillDefaults(destination, source);

		return dbc.bindValue(source, destination, sourceToDestinationStrategy,
				destinationToSourceStrategy);
	}

	/**
	 * Constructs a builder with the following defaults.
	 * <ul>
	 * <li>Source to destination policy =
	 * {@link UpdateValueStrategy#POLICY_UPDATE}</li>
	 * <li>Destination to source policy =
	 * {@link UpdateValueStrategy#POLICY_UPDATE}</li>
	 * </ul>
	 * 
	 * @return builder
	 */
	public static ValueBindingBuilder withDefaults() {
		ValueBindingBuilder builder = new ValueBindingBuilder();
		builder.sourceToDestinationPolicy = builder.destinationToSourcePolicy = UpdateValueStrategy.POLICY_UPDATE;

		return builder;
	}
}




/*******************************************************************************
 * 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;

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

import org.eclipse.core.databinding.conversion.IConverter;
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.databinding.validation.IValidator;
import org.eclipse.core.internal.databinding.ClassLookupSupport;
import org.eclipse.core.internal.databinding.Pair;
import org.eclipse.core.internal.databinding.conversion.CharacterToStringConverter;
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.NumberToNumberConverter;
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.StringToCharacterConverter;
import org.eclipse.core.internal.databinding.conversion.StringToDateConverter;
import org.eclipse.core.internal.databinding.conversion.StringToShortConverter;
import org.eclipse.core.internal.databinding.validation.NumberFormatConverter;
import org.eclipse.core.internal.databinding.validation.NumberToByteValidator;
import org.eclipse.core.internal.databinding.validation.NumberToDoubleValidator;
import org.eclipse.core.internal.databinding.validation.NumberToFloatValidator;
import org.eclipse.core.internal.databinding.validation.NumberToIntegerValidator;
import org.eclipse.core.internal.databinding.validation.NumberToLongValidator;
import org.eclipse.core.internal.databinding.validation.NumberToShortValidator;
import org.eclipse.core.internal.databinding.validation.NumberToUnboundedNumberValidator;
import org.eclipse.core.internal.databinding.validation.ObjectToPrimitiveValidator;
import org.eclipse.core.internal.databinding.validation.StringToByteValidator;
import org.eclipse.core.internal.databinding.validation.StringToCharacterValidator;
import org.eclipse.core.internal.databinding.validation.StringToDateValidator;
import org.eclipse.core.internal.databinding.validation.StringToDoubleValidator;
import org.eclipse.core.internal.databinding.validation.StringToFloatValidator;
import org.eclipse.core.internal.databinding.validation.StringToIntegerValidator;
import org.eclipse.core.internal.databinding.validation.StringToLongValidator;
import org.eclipse.core.internal.databinding.validation.StringToShortValidator;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;

import com.ibm.icu.text.NumberFormat;

/**
 * @since 3.3
 */
public class CoreStrategyDefaultsProvider implements IStrategyDefaultsProvider {
	private static ValidatorRegistry validatorRegistry = new ValidatorRegistry();

	private static HashMap validatorsByConverter = new HashMap();

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.core.databinding.IStrategyDefaultsProvider#getDefaults(java.lang.Object,
	 *      java.lang.Object, org.eclipse.core.databinding.StrategyDefaults)
	 */
	public StrategyDefaults getDefaults(Object sourceType, Object destinationType) {
		IConverter converter = createConverter(sourceType, destinationType);

		if (converter != null) {
			IValidator validator = createValidator(converter, sourceType,
					destinationType);
			return new StrategyDefaults(converter, validator);
		}
		
		return null;
	}

	/**
	 * 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 converter 
	 * @param fromType
	 * @param toType
	 * @return an IValidator, or <code>null</code> if unsuccessful
	 */
	private IValidator createValidator(IConverter converter, Object fromType,
			Object toType) {
		if (fromType == null || toType == null) {
			return new IValidator() {

				public IStatus validate(Object value) {
					return Status.OK_STATUS;
				}
			};
		}

		return findValidator(converter, fromType, toType);
	}

	private IValidator findValidator(IConverter converter, Object fromType,
			Object toType) {
		IValidator result = null;

		if (String.class.equals(fromType)) {
			result = (IValidator) validatorsByConverter.get(converter);

			if (result == null) {
				// TODO sring based lookup
				if (Integer.class.equals(toType) || Integer.TYPE.equals(toType)) {
					result = new StringToIntegerValidator(
							(NumberFormatConverter) converter);
				} else if (Long.class.equals(toType)
						|| Long.TYPE.equals(toType)) {
					result = new StringToLongValidator(
							(NumberFormatConverter) converter);
				} else if (Float.class.equals(toType)
						|| Float.TYPE.equals(toType)) {
					result = new StringToFloatValidator(
							(NumberFormatConverter) converter);
				} else if (Double.class.equals(toType)
						|| Double.TYPE.equals(toType)) {
					result = new StringToDoubleValidator(
							(NumberFormatConverter) converter);
				} else if (Byte.class.equals(toType)
						|| Byte.TYPE.equals(toType)) {
					result = new StringToByteValidator(
							(NumberFormatConverter) converter);
				} else if (Short.class.equals(toType)
						|| Short.TYPE.equals(toType)) {
					result = new StringToShortValidator(
							(NumberFormatConverter) converter);
				} else if (Character.class.equals(toType)
						|| Character.TYPE.equals(toType)
						&& converter instanceof StringToCharacterConverter) {
					result = new StringToCharacterValidator(
							(StringToCharacterConverter) converter);
				} else if (Date.class.equals(toType)
						&& converter instanceof StringToDateConverter) {
					result = new StringToDateValidator(
							(StringToDateConverter) converter);
				}

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

			if (result == null) {
				if (converter instanceof NumberToByteConverter) {
					result = new NumberToByteValidator(
							(NumberToByteConverter) converter);
				} else if (converter instanceof NumberToShortConverter) {
					result = new NumberToShortValidator(
							(NumberToShortConverter) converter);
				} else if (converter instanceof NumberToIntegerConverter) {
					result = new NumberToIntegerValidator(
							(NumberToIntegerConverter) converter);
				} else if (converter instanceof NumberToLongConverter) {
					result = new NumberToLongValidator(
							(NumberToLongConverter) converter);
				} else if (converter instanceof NumberToFloatConverter) {
					result = new NumberToFloatValidator(
							(NumberToFloatConverter) converter);
				} else if (converter instanceof NumberToDoubleConverter) {
					result = new NumberToDoubleValidator(
							(NumberToDoubleConverter) converter);
				} else if (converter instanceof NumberToBigIntegerConverter
						|| converter instanceof NumberToBigDecimalConverter) {
					result = new NumberToUnboundedNumberValidator(
							(NumberToNumberConverter) converter);
				}
			}
		}

		if (result == null) {
			// TODO string based lookup
			result = validatorRegistry.get(fromType, toType);
		}

		return result;
	}

	private static class ValidatorRegistry {

		private HashMap validators = new HashMap();

		/**
		 * Adds the system-provided validators to the current validator
		 * registry. This is done automatically for the validator registry
		 * singleton.
		 */
		private ValidatorRegistry() {
			// Standalone validators here...
			associate(Integer.class, Integer.TYPE,
					new ObjectToPrimitiveValidator(Integer.TYPE));
			associate(Byte.class, Byte.TYPE, new ObjectToPrimitiveValidator(
					Byte.TYPE));
			associate(Short.class, Short.TYPE, new ObjectToPrimitiveValidator(
					Short.TYPE));
			associate(Long.class, Long.TYPE, new ObjectToPrimitiveValidator(
					Long.TYPE));
			associate(Float.class, Float.TYPE, new ObjectToPrimitiveValidator(
					Float.TYPE));
			associate(Double.class, Double.TYPE,
					new ObjectToPrimitiveValidator(Double.TYPE));
			associate(Boolean.class, Boolean.TYPE,
					new ObjectToPrimitiveValidator(Boolean.TYPE));

			associate(Object.class, Integer.TYPE,
					new ObjectToPrimitiveValidator(Integer.TYPE));
			associate(Object.class, Byte.TYPE, new ObjectToPrimitiveValidator(
					Byte.TYPE));
			associate(Object.class, Short.TYPE, new ObjectToPrimitiveValidator(
					Short.TYPE));
			associate(Object.class, Long.TYPE, new ObjectToPrimitiveValidator(
					Long.TYPE));
			associate(Object.class, Float.TYPE, new ObjectToPrimitiveValidator(
					Float.TYPE));
			associate(Object.class, Double.TYPE,
					new ObjectToPrimitiveValidator(Double.TYPE));
			associate(Object.class, Boolean.TYPE,
					new ObjectToPrimitiveValidator(Boolean.TYPE));
		}

		/**
		 * Associate a particular validator that can validate the conversion
		 * (fromClass, toClass)
		 * 
		 * @param fromClass
		 *            The Class to convert from
		 * @param toClass
		 *            The Class to convert to
		 * @param validator
		 *            The IValidator
		 */
		private void associate(Object fromClass, Object toClass,
				IValidator validator) {
			validators.put(new Pair(fromClass, toClass), validator);
		}

		/**
		 * Return an IValidator for a specific fromClass and toClass.
		 * 
		 * @param fromClass
		 *            The Class to convert from
		 * @param toClass
		 *            The Class to convert to
		 * @return An appropriate IValidator
		 */
		private IValidator get(Object fromClass, Object toClass) {
			IValidator result = (IValidator) validators.get(new Pair(fromClass,
					toClass));
			if (result != null)
				return result;
			if (fromClass != null && toClass != null && fromClass == toClass) {
				return new IValidator() {
					public IStatus validate(Object value) {
						return Status.OK_STATUS;
					}
				};
			}
			return new IValidator() {
				public IStatus validate(Object value) {
					return Status.OK_STATUS;
				}
			};
		}
	}

	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 final String CHARACTER_TYPE = "java.lang.Character.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;
		else if (clazz == Character.TYPE)
			return Character.class;
		return clazz;
	}

	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$
		}
	}

	/**
	 * Tries to create a converter that can convert from values of type
	 * 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
	 */
	private IConverter createConverter(Object fromType, Object toType) {
		if (!(fromType instanceof Class) || !(toType instanceof Class)) {
			return 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();
			// Standard and Boxed Types
			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.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.Character"), StringToCharacterConverter.toCharacter(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.Character", "java.lang.String"), CharacterToStringConverter.fromCharacter(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$		

			// Character.TYPE
			converterMap
					.put(
							new Pair("java.lang.String", CHARACTER_TYPE), StringToCharacterConverter.toCharacter(true)); //$NON-NLS-1$
			converterMap
					.put(
							new Pair(CHARACTER_TYPE, "java.lang.Character"), new IdentityConverter(Character.TYPE, Character.class)); //$NON-NLS-1$
			converterMap
					.put(
							new Pair(CHARACTER_TYPE, "java.lang.String"), CharacterToStringConverter.fromCharacter(true)); //$NON-NLS-1$
			converterMap
					.put(
							new Pair(CHARACTER_TYPE, "java.lang.Object"), new IdentityConverter(Character.TYPE, Object.class)); //$NON-NLS-1$		

			// Miscellaneous
			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));
			}
		}
	}

	/**
	 * 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
	 */
	protected 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;
	}

	/*
	 * Default converter implementation, does not perform any conversion.
	 */
	protected static final class DefaultConverter implements IConverter {

		private final Object toType;

		private final Object fromType;

		/**
		 * @param fromType
		 * @param toType
		 */
		DefaultConverter(Object fromType, Object toType) {
			this.toType = toType;
			this.fromType = fromType;
		}

		public Object convert(Object fromObject) {
			return fromObject;
		}

		public Object getFromType() {
			return fromType;
		}

		public Object getToType() {
			return toType;
		}
	}
}




package org.eclipse.jface.examples.databinding.snippets;

import org.eclipse.core.databinding.DataBindingContext;
import org.eclipse.core.databinding.ValueBindingBuilder;
import org.eclipse.core.databinding.beans.PojoObservables;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.jface.databinding.swt.SWTObservables;
import org.eclipse.swt.SWT;

		Display display = new Display();
		final ViewModel viewModel = new ViewModel();

		Realm.runWithDefault(SWTObservables.getRealm(display), new Runnable() {
			public void run() {
				final Shell shell = new View(viewModel).createShell();
				// The SWT event loop
				Display display = Display.getCurrent();
				while (!shell.isDisposed()) {
					if (!display.readAndDispatch()) {
						display.sleep();
								display.sleep();
							}
						}
					}
				}
			}
		});
		// Print the results
		System.out.println("person.getName() = "
				+ viewModel.getPerson().getName());

	// The GUI view
	static class View {
		private ViewModel viewModel;

		private Text name;

		public View(ViewModel viewModel) {

			name = new Text(shell, SWT.BORDER);

			// Bind it
			ValueBindingBuilder builder = ValueBindingBuilder.withDefaults()
					.dbc(new DataBindingContext());
			Person person = viewModel.getPerson();

			builder.bind(SWTObservables.observeText(name, SWT.Modify),
					PojoObservables.observeValue(person, "name"));
					null, null);

			// Open and return the Shell
			shell.pack();

Return to bug 203492

Added Link Here

(-)src/org/eclipse/core/databinding/ValueBindingBuilderDelegate.java (+79 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;
13
14	import org.eclipse.core.databinding.observable.value.IObservableValue;
15
16	/**
17	* Implementation of {@link IValueBindingBuilderDelegate} that determines
18	* converters and validators from an {@link IStrategyDefaultsProvider}.
19	*/
20	public class ValueBindingBuilderDelegate implements
21	IValueBindingBuilderDelegate {
22	private IStrategyDefaultsProvider defaultsProvider;
23
24	/**
25	* Constructs a new instance with the provided <code>defaultsProvider</code>.
26	*
27	* @param defaultsProvider
28	*/
29	public ValueBindingBuilderDelegate(IStrategyDefaultsProvider defaultsProvider) {
30	if (defaultsProvider == null) {
31	throw new IllegalArgumentException(
32	"Parameter 'defaultsProvider' was null."); //$NON-NLS-1$
33	}
34
35	this.defaultsProvider = defaultsProvider;
36	}
37
38	/*
39	* (non-Javadoc)
40	*
41	* @see org.eclipse.core.databinding.IValueBindingBuilderDelegate#prepare(org.eclipse.core.databinding.observable.value.IObservableValue,
42	* org.eclipse.core.databinding.observable.value.IObservableValue,
43	* org.eclipse.core.databinding.UpdateValueStrategy,
44	* org.eclipse.core.databinding.UpdateValueStrategy)
45	*/
46	public void prepare(IObservableValue source, IObservableValue destination,
47	UpdateValueStrategy sourceToModelStrategy,
48	UpdateValueStrategy destinationToTargetStrategy) {
49
50	Object sourceType = source.getValueType();
51	Object destinationType = destination.getValueType();
52
53	if (sourceType != null && destinationType != null) {
54	StrategyDefaults defaults = defaultsProvider.getDefaults(sourceType, destinationType);
55	sourceToModelStrategy.setConverter(defaults.getConverter());
56	sourceToModelStrategy.setAfterGetValidator(defaults.getValidator());
57
58	defaults = defaultsProvider.getDefaults(destinationType, sourceType);
59	destinationToTargetStrategy.setConverter(defaults.getConverter());
60	destinationToTargetStrategy.setAfterGetValidator(defaults.getValidator());
61	}
62	}
63
64	/* (non-Javadoc)
65	* @see org.eclipse.core.databinding.IValueBindingBuilderDelegate#createDestinationToSourceStrategy(int, org.eclipse.core.databinding.observable.value.IObservableValue, org.eclipse.core.databinding.observable.value.IObservableValue)
66	*/
67	public UpdateValueStrategy createDestinationToSourceStrategy(int policy,
68	IObservableValue source, IObservableValue destination) {
69	return new UpdateValueStrategy(policy);
70	}
71
72	/* (non-Javadoc)
73	* @see org.eclipse.core.databinding.IValueBindingBuilderDelegate#createSourceToDestinationStrategy(int, org.eclipse.core.databinding.observable.value.IObservableValue, org.eclipse.core.databinding.observable.value.IObservableValue)
74	*/
75	public UpdateValueStrategy createSourceToDestinationStrategy(int policy,
76	IObservableValue source, IObservableValue destination) {
77	return new UpdateValueStrategy(policy);
78	}
79	}

Added Link Here

(-)src/org/eclipse/core/databinding/StrategyDefaults.java (+59 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;
13
14	import org.eclipse.core.databinding.conversion.IConverter;
15	import org.eclipse.core.databinding.validation.IValidator;
16
17	/**
18	*
19	*/
20	public class StrategyDefaults {
21	private IConverter converter;
22	private IValidator validator;
23
24	public StrategyDefaults() {
25	}
26
27	public StrategyDefaults(IConverter converter, IValidator validator) {
28	this.setConverter(converter);
29	this.setValidator(validator);
30	}
31
32	/**
33	* @param converter The converter to set.
34	*/
35	public void setConverter(IConverter converter) {
36	this.converter = converter;
37	}
38
39	/**
40	* @return Returns the converter.
41	*/
42	public IConverter getConverter() {
43	return converter;
44	}
45
46	/**
47	* @param validator The validator to set.
48	*/
49	public void setValidator(IValidator validator) {
50	this.validator = validator;
51	}
52
53	/**
54	* @return Returns the validator.
55	*/
56	public IValidator getValidator() {
57	return validator;
58	}
59	}

Lines 13-19 Link Here

(-)src/org/eclipse/jface/examples/databinding/snippets/Snippet000HelloWorld.java (-17 / +18 lines)
13	package org.eclipse.jface.examples.databinding.snippets;	13	package org.eclipse.jface.examples.databinding.snippets;
14		14
15	import org.eclipse.core.databinding.DataBindingContext;	15	import org.eclipse.core.databinding.DataBindingContext;
16	import org.eclipse.core.databinding.beans.BeansObservables;	16	import org.eclipse.core.databinding.ValueBindingBuilder;
		17	import org.eclipse.core.databinding.beans.PojoObservables;
17	import org.eclipse.core.databinding.observable.Realm;	18	import org.eclipse.core.databinding.observable.Realm;
18	import org.eclipse.jface.databinding.swt.SWTObservables;	19	import org.eclipse.jface.databinding.swt.SWTObservables;
19	import org.eclipse.swt.SWT;	20	import org.eclipse.swt.SWT;
Lines 34-52 Link Here
34	Display display = new Display();	35	Display display = new Display();
35	final ViewModel viewModel = new ViewModel();	36	final ViewModel viewModel = new ViewModel();
36		37
37	Realm.runWithDefault(SWTObservables.getRealm(display),	38	Realm.runWithDefault(SWTObservables.getRealm(display), new Runnable() {
38	new Runnable() {	39	public void run() {
39	public void run() {	40	final Shell shell = new View(viewModel).createShell();
40	final Shell shell = new View(viewModel).createShell();	41	// The SWT event loop
41	// The SWT event loop	42	Display display = Display.getCurrent();
42	Display display = Display.getCurrent();	43	while (!shell.isDisposed()) {
43	while (!shell.isDisposed()) {	44	if (!display.readAndDispatch()) {
44	if (!display.readAndDispatch()) {	45	display.sleep();
45	display.sleep();
46	}
47	}
48	}	46	}
49	});	47	}
		48	}
		49	});
50	// Print the results	50	// Print the results
51	System.out.println("person.getName() = "	51	System.out.println("person.getName() = "
52	+ viewModel.getPerson().getName());	52	+ viewModel.getPerson().getName());
Lines 90-95 Link Here
90	// The GUI view	90	// The GUI view
91	static class View {	91	static class View {
92	private ViewModel viewModel;	92	private ViewModel viewModel;
		93
93	private Text name;	94	private Text name;
94		95
95	public View(ViewModel viewModel) {	96	public View(ViewModel viewModel) {
Lines 104-115 Link Here
104	name = new Text(shell, SWT.BORDER);	105	name = new Text(shell, SWT.BORDER);
105		106
106	// Bind it	107	// Bind it
107	DataBindingContext bindingContext = new DataBindingContext();	108	ValueBindingBuilder builder = ValueBindingBuilder.withDefaults()
		109	.dbc(new DataBindingContext());
108	Person person = viewModel.getPerson();	110	Person person = viewModel.getPerson();
109		111
110	bindingContext.bindValue(SWTObservables.observeText(name,	112	builder.bind(SWTObservables.observeText(name, SWT.Modify),
111	SWT.Modify), BeansObservables.observeValue(person, "name"),	113	PojoObservables.observeValue(person, "name"));
112	null, null);
113		114
114	// Open and return the Shell	115	// Open and return the Shell
115	shell.pack();	116	shell.pack();

Added Link Here

(-)src/org/eclipse/core/databinding/IStrategyDefaultsProvider.java (+30 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;
13
14	import org.eclipse.core.databinding.conversion.IConverter;
15	import org.eclipse.core.databinding.validation.IValidator;
16
17	/**
18	* Provider of defaults (e.g. {@link IConverter converters} and
19	* {@link IValidator validators}) to the binding process.
20	*/
21	public interface IStrategyDefaultsProvider {
22	/**
23	* Provides a default converter and validator for the provides types.
24	*
25	* @param sourceType
26	* @param destinationType
27	* @return defaults, <code>null</code> if none found
28	*/
29	public StrategyDefaults getDefaults(Object sourceType, Object destinationType);
30	}

Added Link Here

(-)src/org/eclipse/core/databinding/IValueBindingBuilderDelegate.java (+58 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;
13
14	import org.eclipse.core.databinding.observable.value.IObservableValue;
15
16	/**
17	* A delegate for a {@link ValueBindingBuilder} to externalize the setup of the
18	* binding.
19	*/
20	public interface IValueBindingBuilderDelegate {
21	/**
22	* Creates the update strategy to be used when updating from source to
23	* destination.
24	*
25	* @param policy
26	*
27	* @param source
28	* @param destination
29	* @return strategy
30	*/
31	public UpdateValueStrategy createSourceToDestinationStrategy(int policy,
32	IObservableValue source, IObservableValue destination);
33
34	/**
35	* Creates the update strategy to be used when updating from destination to
36	* source.
37	*
38	* @param policy
39	* @param source
40	* @param destination
41	* @return strategy
42	*/
43	public UpdateValueStrategy createDestinationToSourceStrategy(int policy,
44	IObservableValue source, IObservableValue destination);
45
46	/**
47	* Invoked for the customization of the provided strategies. This allows for
48	* the configuring of converters and validators in the strategies.
49	*
50	* @param source
51	* @param destination
52	* @param sourceToDestinationStrategy
53	* @param destinationToSourceStrategy
54	*/
55	public void prepare(IObservableValue source, IObservableValue destination,
56	UpdateValueStrategy sourceToDestinationStrategy,
57	UpdateValueStrategy destinationToSourceStrategy);
58	}