Attachment #142074 for bug #183055

View | Details | Raw Unified | Return to bug 183055 | Differences between

and this patch





/**
 * @since 1.0
 * 
 */
public class BindingMessages {


	 * Returns the resource object with the given key in the resource bundle for
	 * JFace Data Binding. If there isn't any value under the given key, the key
	 * is returned.
	 * 
	 * @param key
	 *            the resource name
	 * @return the string

	/**
	 * Returns a formatted string with the given key in the resource bundle for
	 * JFace Data Binding.
	 * 
	 * @param key
	 * @param arguments
	 * @return formatted string, the key if the key is invalid
	 */
	public static String formatString(String key, Object[] arguments) {
		try {
			return formatStringValue(getString(key), arguments);
		} catch (MissingResourceException e) {
			return key;
		}
	}

	/**
	 * Returns a formatted string with the given key in the resource bundle for
	 * JFace Data Binding.
	 * 
	 * @param pattern
	 * @param arguments
	 * @return formatted string, the key if the key is invalid
	 */
	public static String formatStringValue(String pattern, Object[] arguments) {
		return MessageFormat.format(pattern, arguments);
	}
}





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

import com.ibm.icu.text.DateFormat;

/**
 * Convert a String to a java.util.Date, respecting the current locale
 * 
 * @since 1.0
 */
public class StringToDateConverter extends DateConversionSupport implements
		IConverter {

	/**
	 * 
	 */
	public StringToDateConverter() {
		super();
	}

	/**
	 * 
	 * @param formats
	 */
	public StringToDateConverter(DateFormat[] formats) {
		super(formats);
	}

	public Object convert(Object source) {
		return parse(source.toString());
	}


	public Object getToType() {
		return Date.class;
	}
}




 * </p>
 */
public abstract class DateConversionSupport {
	private final static int DATE_FORMAT = DateFormat.SHORT;
	private final static int DEFAULT_FORMATTER_INDEX = 0;

	private final static int NUM_VIRTUAL_FORMATTERS = 1;

	/**
	 * Alternative formatters for date, time and date/time. Raw milliseconds are
	 * covered as a special case.
	 */
	private final DateFormat[] formatters;

	/**
	 * 
	 */
	public DateConversionSupport() {
		// TODO: These could be shared, but would have to be synchronized.
		this(new DateFormat[] {
				new SimpleDateFormat(BindingMessages
						.getString(BindingMessages.DATE_FORMAT_DATE_TIME)),
				new SimpleDateFormat(BindingMessages
						.getString(BindingMessages.DATEFORMAT_TIME)),
				DateFormat.getDateTimeInstance(DATE_FORMAT, DateFormat.SHORT),
				DateFormat.getDateInstance(DATE_FORMAT),
				DateFormat.getTimeInstance(DateFormat.SHORT),
				DateFormat.getDateTimeInstance(DATE_FORMAT, DateFormat.MEDIUM),
				DateFormat.getTimeInstance(DateFormat.MEDIUM) });
	}

	/**
	 * 
	 * @param formats
	 */
	public DateConversionSupport(DateFormat[] formats) {
		this.formatters = formats;
	}

	/**
	 * Tries all available formatters to parse the given string according to the
	 * default locale or as a raw millisecond value and returns the result of
	 * the first successful run.
	 * 
	 * @param str
	 *            A string specifying a date according to the default locale or
	 *            in raw milliseconds
	 * @return The parsed date, or null, if no available formatter could
	 *         interpret the input string
	 */
	protected Date parse(String str) {
		for (int formatterIdx = 0; formatterIdx < formatters.length; formatterIdx++) {
			Date parsed = parse(str, formatterIdx);
			if (parsed != null) {
				return parsed;
			}
		}
		return null;
	}

	protected Date parse(String str, int formatterIdx) {
		if (formatterIdx >= 0) {
			ParsePosition pos = new ParsePosition(0);
			if (str == null) {
				return null;
			}
			Date date = formatters[formatterIdx].parse(str, pos);
			if (pos.getErrorIndex() != -1 || pos.getIndex() != str.length()) {
				return null;
			}
			return date;
		}
		try {
			long millisecs = Long.parseLong(str);
			return new Date(millisecs);
		} catch (NumberFormatException exc) {
		catch(NumberFormatException exc) {
		}
		return null;
	}

	/**
	 * Formats the given date with the default formatter according to the
	 * default locale.
	 * 
	 * @param date
	 *            a date
	 * @return a string representation of the given date according to the
	 *         default locale
	 */
	protected String format(Date date) {
		return format(date, DEFAULT_FORMATTER_INDEX);
	}

	protected String format(Date date, int formatterIdx) {
		if (date == null)
			return null;
		if (formatterIdx >= 0) {
			return formatters[formatterIdx].format(date);
		}
		return String.valueOf(date.getTime());
	}

	protected int numFormatters() {
		return formatters.length + NUM_VIRTUAL_FORMATTERS;
	}

	/**

	 * This is for testing purposes only and should not be a part of the API if
	 * this class was to be exposed.
	 * </p>
	 * 
	 * @param index
	 * @return date format
	 */
	protected DateFormat getDateFormat(int index) {
		if (index < 0 || index >= formatters.length) {
			throw new IllegalArgumentException(
					"'index' [" + index + "] is out of bounds."); //$NON-NLS-1$//$NON-NLS-2$
		}

		return formatters[index];





/**
 * Utility class for the parsing of strings to numbers.
 * 
 * @since 1.0
 */
public class StringToNumberParser {


	/**
	 * The result of a parse operation.
	 * 
	 * @since 1.0
	 */
	public static class ParseResult {

		 * The number as a result of the conversion. <code>null</code> if the
		 * value could not be converted or if the type is not a primitive and
		 * the value was an empty string.
		 * 
		 * @return number
		 */
		public Number getNumber() {

		/**
		 * ParsePosition if an error occurred while parsing. <code>null</code>
		 * if no error occurred.
		 * 
		 * @return parse position
		 */
		public ParsePosition getPosition() {


	/**
	 * Formats an appropriate message for a parsing error.
	 * 
	 * @param value
	 * @param position
	 * @return message

				.getErrorIndex() : position.getIndex();

		if (errorIndex < value.length()) {
			return BindingMessages.formatString(
					BindingMessages.VALIDATE_NUMBER_PARSE_ERROR, new Object[] {
							value, new Integer(errorIndex + 1),
							new Character(value.charAt(errorIndex)) });
		}
		return BindingMessages.formatString(
				BindingMessages.VALIDATE_NUMBER_PARSE_ERROR_NO_CHARACTER,
				new Object[] { value, new Integer(errorIndex + 1) });
	}

	/**
	 * Formats an appropriate message for an out of range error.
	 * 
	 * @param minValue
	 * @param maxValue
	 * @param numberFormat
	 *            when accessed method synchronizes on instance
	 * @return message
	 */
	public static String createOutOfRangeMessage(Number minValue,
			Number maxValue, NumberFormat numberFormat) {
		return createOutOfRangeMessage(
				BindingMessages.getString("Validate_NumberOutOfRangeError"), minValue, maxValue, numberFormat); //$NON-NLS-1$
	}

	/**
	 * Formats an appropriate message for an out of range error.
	 * 
	 * @param message
	 * @param minValue
	 * @param maxValue
	 * @param numberFormat
	 *            when accessed method synchronizes on instance
	 * @return message
	 */
	public static String createOutOfRangeMessage(String message,
			Number minValue, Number maxValue, NumberFormat numberFormat) {
		String min = null;
		String max = null;


			max = numberFormat.format(maxValue);
		}

		return BindingMessages.formatStringValue(message, new Object[] { min,
				max });
	}

	/**
	 * Returns <code>true</code> if the provided <code>number</code> is in the
	 * range of a integer.
	 * 
	 * @param number
	 * @return <code>true</code> if a valid integer
	 * @throws IllegalArgumentException


	/**
	 * Validates the range of the provided <code>number</code>.
	 * 
	 * @param number
	 * @param bitLength
	 *            number of bits allowed to be in range
	 * @return <code>true</code> if in range
	 */
	private static boolean checkInteger(Number number, int bitLength) {

	}

	/**
	 * Returns <code>true</code> if the provided <code>number</code> is in the
	 * range of a long.
	 * 
	 * @param number
	 * @return <code>true</code> if in range
	 * @throws IllegalArgumentException

	}

	/**
	 * Returns <code>true</code> if the provided <code>number</code> is in the
	 * range of a float.
	 * 
	 * @param number
	 * @return <code>true</code> if in range
	 * @throws IllegalArgumentException
	 *             if the number type is unsupported
	 */
	public static boolean inFloatRange(Number number) {
		return checkDecimal(number, FLOAT_MIN_BIG_DECIMAL,
				FLOAT_MAX_BIG_DECIMAL);
	}

	private static boolean checkDecimal(Number number, BigDecimal min,
			BigDecimal max) {
		BigDecimal bigDecimal = null;
		if (number instanceof Integer || number instanceof Long) {
			bigDecimal = new BigDecimal(number.doubleValue());

	}

	/**
	 * Returns <code>true</code> if the provided <code>number</code> is in the
	 * range of a double.
	 * 
	 * @param number
	 * @return <code>true</code> if in range
	 * @throws IllegalArgumentException
	 *             if the number type is unsupported
	 */
	public static boolean inDoubleRange(Number number) {
		return checkDecimal(number, DOUBLE_MIN_BIG_DECIMAL,
				DOUBLE_MAX_BIG_DECIMAL);
	}

	/**
	 * Returns <code>true</code> if the provided <code>number</code> is in the
	 * range of a short.
	 * 
	 * @param number
	 * @return <code>true</code> if in range
	 */

	}

	/**
	 * Returns <code>true</code> if the provided <code>number</code> is in the
	 * range of a byte.
	 * 
	 * @param number
	 * @return <code>true</code> if in range
	 */





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

import com.ibm.icu.text.DateFormat;

/**
 * Converts a Java.util.Date to a String using the current locale. Null date
 * values are converted to an empty string.
 * 
 * @since 1.0
 */
public class DateToStringConverter extends DateConversionSupport implements
		IConverter {

	/**
	 * 
	 */
	public DateToStringConverter() {
		super();
	}

	/**
	 * 
	 * @param format
	 */
	public DateToStringConverter(DateFormat format) {
		super(new DateFormat[] { format });
	}

	public Object convert(Object source) {
		if (source != null)
			return format((Date) source);
		return ""; //$NON-NLS-1$
	}



	public Object getToType() {
		return String.class;
	}
}





import org.eclipse.core.internal.databinding.conversion.StringToNumberParser;


/**
 * Validates that a string is of the appropriate format and is in the range of
 * an integer.

		super(converter, MIN, MAX);
	}

	/**
	 * @param converter
	 * @param parseErrorMessage
	 * @param outOfRangeMessage
	 */
	public StringToIntegerValidator(NumberFormatConverter converter,
			String parseErrorMessage, String outOfRangeMessage) {
		super(converter, MIN, MAX, parseErrorMessage, outOfRangeMessage);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @seeorg.eclipse.core.internal.databinding.validation.
	 * AbstractStringToNumberValidator#inRange(java.lang.Number)
	 */
	protected boolean isInRange(Number number) {
		return StringToNumberParser.inIntegerRange(number);

Lines 28-51 Link Here

(-)src/org/eclipse/core/internal/databinding/validation/StringToDateValidator.java (-14 / +40 lines)
28	public class StringToDateValidator implements IValidator {	28	public class StringToDateValidator implements IValidator {
29	private final StringToDateConverter converter;	29	private final StringToDateConverter converter;
30		30
		31	private final String parseErrorMessage;
		32
31	/**	33	/**
32	* @param converter	34	* @param converter
33	*/	35	*/
34	public StringToDateValidator(StringToDateConverter converter) {	36	public StringToDateValidator(StringToDateConverter converter) {
		37	this(converter, null);
		38	}
		39
		40	/**
		41	* @param converter
		42	* @param parseErrorMessage
		43	*/
		44	public StringToDateValidator(StringToDateConverter converter,
		45	String parseErrorMessage) {
35	this.converter = converter;	46	this.converter = converter;
		47	this.parseErrorMessage = parseErrorMessage;
36	}	48	}
37		49
38	/*	50	/*
39	* (non-Javadoc)	51	* (non-Javadoc)
40	*	52	*
41	* @see org.eclipse.core.databinding.validation.IValidator#validate(java.lang.Object)	53	* @see
		54	* org.eclipse.core.databinding.validation.IValidator#validate(java.lang
		55	* .Object)
42	*/	56	*/
43	public IStatus validate(Object value) {	57	public IStatus validate(Object value) {
44	if (value instanceof String && ((String)value).trim().length()==0) {	58	if (value instanceof String && ((String) value).trim().length() == 0) {
45	return Status.OK_STATUS;	59	return Status.OK_STATUS;
46	}	60	}
47	Object convertedValue = converter.convert(value);	61	Object convertedValue = converter.convert(value);
48	//The StringToDateConverter returns null if it can't parse the date.	62	// The StringToDateConverter returns null if it can't parse the date.
49	if (convertedValue == null) {	63	if (convertedValue == null) {
50	return ValidationStatus.error(getErrorMessage());	64	return ValidationStatus.error(getErrorMessage());
51	}	65	}
Lines 55-64 Link Here
55		69
56	/*	70	/*
57	* (non-Javadoc)	71	* (non-Javadoc)
58	*	72	*
59	* @see org.eclipse.core.internal.databinding.validation.WrappedConverterValidator#getErrorMessage()	73	* @see
		74	* org.eclipse.core.internal.databinding.validation.WrappedConverterValidator
		75	* #getErrorMessage()
60	*/	76	*/
61	protected String getErrorMessage() {	77	protected String getErrorMessage() {
		78	if (parseErrorMessage != null) {
		79	return parseErrorMessage;
		80	}
		81
62	Date sampleDate = new Date();	82	Date sampleDate = new Date();
63		83
64	// FIXME We need to use the information from the	84	// FIXME We need to use the information from the
Lines 73-86 Link Here
73	samples.append('\'');	93	samples.append('\'');
74	samples.append(util.format(sampleDate, 0));	94	samples.append(util.format(sampleDate, 0));
75	samples.append('\'');	95	samples.append('\'');
76	return BindingMessages.getString(BindingMessages.EXAMPLES) + ": " + samples + ",..."; //$NON-NLS-1$//$NON-NLS-2$	96	return BindingMessages.getString(BindingMessages.EXAMPLES)
		97	+ ": " + samples + ",..."; //$NON-NLS-1$//$NON-NLS-2$
77	}	98	}
78		99
79	private static class FormatUtil extends DateConversionSupport {	100	private static class FormatUtil extends DateConversionSupport {
80	/*	101	/*
81	* (non-Javadoc)	102	* (non-Javadoc)
82	*	103	*
83	* @see org.eclipse.core.internal.databinding.conversion.DateConversionSupport#numFormatters()	104	* @see
		105	* org.eclipse.core.internal.databinding.conversion.DateConversionSupport
		106	* #numFormatters()
84	*/	107	*/
85	protected int numFormatters() {	108	protected int numFormatters() {
86	return super.numFormatters();	109	return super.numFormatters();
Lines 88-95 Link Here
88		111
89	/*	112	/*
90	* (non-Javadoc)	113	* (non-Javadoc)
91	*	114	*
92	* @see org.eclipse.core.internal.databinding.conversion.DateConversionSupport#format(java.util.Date)	115	* @see
		116	* org.eclipse.core.internal.databinding.conversion.DateConversionSupport
		117	* #format(java.util.Date)
93	*/	118	*/
94	protected String format(Date date) {	119	protected String format(Date date) {
95	return super.format(date);	120	return super.format(date);
Lines 97-105 Link Here
97		122
98	/*	123	/*
99	* (non-Javadoc)	124	* (non-Javadoc)
100	*	125	*
101	* @see org.eclipse.core.internal.databinding.conversion.DateConversionSupport#format(java.util.Date,	126	* @see
102	* int)	127	* org.eclipse.core.internal.databinding.conversion.DateConversionSupport
		128	* #format(java.util.Date, int)
103	*/	129	*/
104	protected String format(Date date, int formatterIdx) {	130	protected String format(Date date, int formatterIdx) {
105	return super.format(date, formatterIdx);	131	return super.format(date, formatterIdx);

Lines 11-16 Link Here

(-)src/org/eclipse/core/internal/databinding/validation/AbstractStringToNumberValidator.java (-14 / +59 lines)
11		11
12	package org.eclipse.core.internal.databinding.validation;	12	package org.eclipse.core.internal.databinding.validation;
13		13
		14	import java.text.ParsePosition;
		15
14	import org.eclipse.core.databinding.validation.IValidator;	16	import org.eclipse.core.databinding.validation.IValidator;
15	import org.eclipse.core.databinding.validation.ValidationStatus;	17	import org.eclipse.core.databinding.validation.ValidationStatus;
16	import org.eclipse.core.internal.databinding.conversion.StringToNumberParser;	18	import org.eclipse.core.internal.databinding.conversion.StringToNumberParser;
Lines 19-26 Link Here
19	import org.eclipse.core.runtime.Status;	21	import org.eclipse.core.runtime.Status;
20		22
21	/**	23	/**
22	* Validates a number that is to be converted by a {@link NumberFormatConverter}.	24	* Validates a number that is to be converted by a {@link NumberFormatConverter}
23	* Validation is comprised of parsing the String and range checks.	25	* . Validation is comprised of parsing the String and range checks.
24	*	26	*
25	* @since 1.0	27	* @since 1.0
26	*/	28	*/
Lines 31-50 Link Here
31	private final Number min;	33	private final Number min;
32	private final Number max;	34	private final Number max;
33		35
34	private String outOfRangeMessage;	36	private final String parseErrorMessage;
		37	private final String outOfRangeMessage;
		38
		39	private String formattedOutOfRangeMessage;
35		40
36	/**	41	/**
37	* Constructs a new instance.	42	* Constructs a new instance.
38	*	43	*
39	* @param converter converter and thus formatter to be used in validation	44	* @param converter
40	* @param min minimum value, used for reporting a range error to the user	45	* converter and thus formatter to be used in validation
41	* @param max maximum value, used for reporting a range error to the user	46	* @param min
		47	* minimum value, used for reporting a range error to the user
		48	* @param max
		49	* maximum value, used for reporting a range error to the user
42	*/	50	*/
43	protected AbstractStringToNumberValidator(NumberFormatConverter converter,	51	protected AbstractStringToNumberValidator(NumberFormatConverter converter,
44	Number min, Number max) {	52	Number min, Number max) {
		53	this(converter, min, max, null, null);
		54	}
		55
		56	/**
		57	* Constructs a new instance.
		58	*
		59	* @param converter
		60	* converter and thus formatter to be used in validation
		61	* @param min
		62	* minimum value, used for reporting a range error to the user
		63	* @param max
		64	* maximum value, used for reporting a range error to the user
		65	* @param parseErrorMessage
		66	* @param outOfRangeMessage
		67	*/
		68	protected AbstractStringToNumberValidator(NumberFormatConverter converter,
		69	Number min, Number max, String parseErrorMessage,
		70	String outOfRangeMessage) {
45	this.converter = converter;	71	this.converter = converter;
46	this.min = min;	72	this.min = min;
47	this.max = max;	73	this.max = max;
		74	this.parseErrorMessage = parseErrorMessage;
		75	this.outOfRangeMessage = outOfRangeMessage;
48		76
49	if (converter.getToType() instanceof Class) {	77	if (converter.getToType() instanceof Class) {
50	Class clazz = (Class) converter.getToType();	78	Class clazz = (Class) converter.getToType();
Lines 55-61 Link Here
55	}	83	}
56		84
57	/**	85	/**
58	* Validates the provided <code>value</code>. An error status is returned if:	86	* Validates the provided <code>value</code>. An error status is returned
		87	* if:
59	* <ul>	88	* <ul>
60	* <li>The value cannot be parsed.</li>	89	* <li>The value cannot be parsed.</li>
61	* <li>The value is out of range.</li>	90	* <li>The value is out of range.</li>
Lines 69-85 Link Here
69		98
70	if (result.getNumber() != null) {	99	if (result.getNumber() != null) {
71	if (!isInRange(result.getNumber())) {	100	if (!isInRange(result.getNumber())) {
72	if (outOfRangeMessage == null) {	101	if (formattedOutOfRangeMessage == null) {
73	outOfRangeMessage = StringToNumberParser	102	formattedOutOfRangeMessage = createOutOfRangeMessage();
74	.createOutOfRangeMessage(min, max, converter
75	.getNumberFormat());
76	}	103	}
77		104
78	return ValidationStatus.error(outOfRangeMessage);	105	return ValidationStatus.error(formattedOutOfRangeMessage);
79	}	106	}
80	} else if (result.getPosition() != null) {	107	} else if (result.getPosition() != null) {
81	String parseErrorMessage = StringToNumberParser.createParseErrorMessage(	108	String parseErrorMessage = createParseErrorMessage((String) value,
82	(String) value, result.getPosition());	109	result.getPosition());
83		110
84	return ValidationStatus.error(parseErrorMessage);	111	return ValidationStatus.error(parseErrorMessage);
85	}	112	}
Lines 94-97 Link Here
94	* @return <code>true</code> if in range	121	* @return <code>true</code> if in range
95	*/	122	*/
96	protected abstract boolean isInRange(Number number);	123	protected abstract boolean isInRange(Number number);
		124
		125	private String createParseErrorMessage(String input,
		126	ParsePosition parsePosition) {
		127	if (parseErrorMessage == null) {
		128	return StringToNumberParser.createParseErrorMessage(input,
		129	parsePosition);
		130	}
		131	return parseErrorMessage;
		132	}
		133
		134	private String createOutOfRangeMessage() {
		135	if (outOfRangeMessage == null) {
		136	return StringToNumberParser.createOutOfRangeMessage(min, max,
		137	converter.getNumberFormat());
		138	}
		139	return StringToNumberParser.createOutOfRangeMessage(outOfRangeMessage,
		140	min, max, converter.getNumberFormat());
		141	}
97	}	142	}

Lines 8-13 Link Here

(-)META-INF/MANIFEST.MF (+1 lines)
8	Bundle-Localization: plugin	8	Bundle-Localization: plugin
9	Export-Package: org.eclipse.core.databinding,	9	Export-Package: org.eclipse.core.databinding,
10	org.eclipse.core.databinding.conversion;x-internal:=false,	10	org.eclipse.core.databinding.conversion;x-internal:=false,
		11	org.eclipse.core.databinding.editing,
11	org.eclipse.core.databinding.validation;x-internal:=false,	12	org.eclipse.core.databinding.validation;x-internal:=false,
12	org.eclipse.core.internal.databinding;x-friends:="org.eclipse.core.databinding.beans",	13	org.eclipse.core.internal.databinding;x-friends:="org.eclipse.core.databinding.beans",
13	org.eclipse.core.internal.databinding.conversion;x-friends:="org.eclipse.jface.tests.databinding",	14	org.eclipse.core.internal.databinding.conversion;x-friends:="org.eclipse.jface.tests.databinding",




/*******************************************************************************
 * Copyright (c) 2009 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.validation;

import java.text.MessageFormat;
import java.util.Date;

import org.eclipse.core.databinding.validation.IValidator;
import org.eclipse.core.databinding.validation.ValidationStatus;
import org.eclipse.core.runtime.IStatus;

import com.ibm.icu.text.DateFormat;

/**
 * @since 1.3
 */
public class DateRangeValidator implements IValidator {

	private static final int UNDEFINED = -1;
	private static final int AFTER = 0;
	private static final int AFTER_EQUAL = 1;
	private static final int BEFORE = 2;
	private static final int BEFORE_EQUAL = 3;

	// TODO: Externalize
	private static final String AFTER_MESSAGE = "The date must be after {0}."; //$NON-NLS-1$
	private static final String AFTER_EQUAL_MESSAGE = "The date must be after or on {0}."; //$NON-NLS-1$
	private static final String BEFORE_MESSAGE = "The date must be before {0}."; //$NON-NLS-1$
	private static final String BEFORE_EQUAL_MESSAGE = "The date must be before or on {0}."; //$NON-NLS-1$
	private static final String WITHIN_RANGE_MESSAGE = "The date must lie between {0} and {1}."; //$NON-NLS-1$

	private final Date min;
	private final Date max;
	private final int minConstraint;
	private final int maxConstraint;
	private final String validationMessage;
	private final DateFormat format;

	/**
	 * 
	 * @param min
	 * @param max
	 * @param minConstraint
	 * @param maxConstraint
	 * @param validationMessage
	 * @param format
	 */
	private DateRangeValidator(Date min, Date max, int minConstraint,
			int maxConstraint, String validationMessage, DateFormat format) {
		this.min = min;
		this.max = max;
		this.minConstraint = minConstraint;
		this.maxConstraint = maxConstraint;
		this.validationMessage = validationMessage;
		this.format = format;
	}

	/**
	 * 
	 * @param min
	 * @param validationMessage
	 * @param format
	 * @return .
	 */
	public static DateRangeValidator after(Date min, String validationMessage,
			DateFormat format) {
		return new DateRangeValidator(min, null, AFTER, UNDEFINED,
				defaultIfNull(validationMessage, AFTER_MESSAGE), format);
	}

	/**
	 * 
	 * @param min
	 * @param validationMessage
	 * @param format
	 * @return .
	 */
	public static DateRangeValidator afterEqual(Date min,
			String validationMessage, DateFormat format) {
		return new DateRangeValidator(min, null, AFTER_EQUAL, UNDEFINED,
				defaultIfNull(validationMessage, AFTER_EQUAL_MESSAGE), format);
	}

	/**
	 * 
	 * @param max
	 * @param validationMessage
	 * @param format
	 * @return .
	 */
	public static DateRangeValidator before(Date max, String validationMessage,
			DateFormat format) {
		return new DateRangeValidator(null, max, UNDEFINED, BEFORE,
				defaultIfNull(validationMessage, BEFORE_MESSAGE), format);
	}

	/**
	 * 
	 * @param max
	 * @param validationMessage
	 * @param format
	 * @return .
	 */
	public static DateRangeValidator beforeEqual(Date max,
			String validationMessage, DateFormat format) {
		return new DateRangeValidator(null, max, UNDEFINED, BEFORE_EQUAL,
				defaultIfNull(validationMessage, BEFORE_EQUAL_MESSAGE), format);
	}

	/**
	 * 
	 * @param min
	 * @param max
	 * @param validationMessage
	 * @param format
	 * @return .
	 */
	public static DateRangeValidator range(Date min, Date max,
			String validationMessage, DateFormat format) {
		return new DateRangeValidator(min, max, AFTER_EQUAL, BEFORE_EQUAL,
				defaultIfNull(validationMessage, WITHIN_RANGE_MESSAGE), format);
	}

	public IStatus validate(Object value) {
		if (value != null) {
			Date date = (Date) value;
			if ((min != null && !fulfillsConstraint(date, min, minConstraint))
					|| (max != null && !fulfillsConstraint(date, max,
							maxConstraint))) {
				// TODO: Cache message?
				return ValidationStatus.error(MessageFormat.format(
						validationMessage, getFormattedRangeExtremas()));
			}
		}
		return ValidationStatus.ok();
	}

	private boolean fulfillsConstraint(Date date1, Date date2, int constraint) {
		switch (constraint) {
		case AFTER:
			return date1.after(date2);
		case AFTER_EQUAL:
			return date1.after(date2) || date1.equals(date2);
		case BEFORE:
			return date1.before(date2);
		case BEFORE_EQUAL:
			return date1.before(date2) || date1.equals(date2);
		case UNDEFINED:
		default:
			throw new IllegalArgumentException(
					"Unsupported constraint: " + constraint); //$NON-NLS-1$
		}
	}

	private String[] getFormattedRangeExtremas() {
		// TODO: Synchronize formatting to make it thread safe?
		if (min == null) {
			return new String[] { format.format(max) };
		} else if (max == null) {
			return new String[] { format.format(min) };
		}
		return new String[] { format.format(min), format.format(max) };
	}

	private static String defaultIfNull(String string, String defaultString) {
		return (string != null) ? string : defaultString;
	}
}




/*******************************************************************************
 * Copyright (c) 2009 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.editing;

import java.util.regex.Pattern;

import org.eclipse.core.databinding.conversion.IConverter;
import org.eclipse.core.internal.databinding.conversion.StringStripConverter;
import org.eclipse.core.internal.databinding.validation.NonNullValidator;
import org.eclipse.core.internal.databinding.validation.StringRegexValidator;

/**
 * @since 1.3
 */
public final class StringEditing extends Editing {

	private String requiredMessage = null;

	private String matchesMessage = null;

	private StringEditing(IConverter targetConverter) {
		setTargetConverter(targetConverter);
	}

	/**
	 * Creates a new editing object for strings which performs no validation or
	 * conversion.
	 * 
	 * @return The new editing object which performs no validation or
	 *         conversion.
	 */
	public static StringEditing withDefaults() {
		return new StringEditing(null);
	}

	/**
	 * Creates a new editing object which strips whitespace from both ends of
	 * the input string.
	 * 
	 * @param stripToNull
	 *            Whether to convert the input string to <code>null</code> in
	 *            case stripping the input string results in an empty string.
	 * @return The new editing object which strips whitespace from both ends of
	 *         the input string.
	 */
	public static StringEditing stripped(boolean stripToNull) {
		return new StringEditing(new StringStripConverter(stripToNull));
	}

	/**
	 * Adds a model validator ensuring that the parsed integer is not
	 * <code>null</code>. Uses the current {@link #requiredMessage(String)
	 * validation message}.
	 * 
	 * @return This editing instance for method chaining.
	 */
	public StringEditing required() {
		addModelValidator(new NonNullValidator(requiredMessage));
		return this;
	}

	/**
	 * Sets the validation message to be issued in case the input string is
	 * <code>null</code>.
	 * 
	 * @param message
	 *            The validation message to be issued in case the input string
	 *            is <code>null</code>.
	 * @return This editing instance for method chaining.
	 * 
	 * @see #required()
	 */
	public StringEditing requiredMessage(String message) {
		this.requiredMessage = message;
		return this;
	}

	/**
	 * Adds a model validator ensuring that the input string
	 * {@link Pattern#matches(String, CharSequence) matches} the given regular
	 * expression . Uses the current {@link #matchesMessage(String) validation
	 * message}.
	 * 
	 * @param regex
	 *            The regular expression which the input string must match.
	 * @return This editing instance for method chaining.
	 * 
	 * @see Pattern#matches(String, CharSequence)
	 */
	public StringEditing matches(String regex) {
		addModelValidator(new StringRegexValidator(regex, matchesMessage));
		return this;
	}

	/**
	 * Sets the validation message to be issued in case the input string does
	 * not match a given regular expression.
	 * 
	 * @param message
	 *            The validation message to be issued in case the input string
	 *            does not match a given regular expression.
	 * @return This editing instance for method chaining.
	 * 
	 * @see #matches(String)
	 */
	public StringEditing matchesMessage(String message) {
		this.matchesMessage = message;
		return this;
	}
}




/*******************************************************************************
 * Copyright (c) 2009 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.validation;

import org.eclipse.core.databinding.validation.IValidator;
import org.eclipse.core.databinding.validation.ValidationStatus;
import org.eclipse.core.runtime.IStatus;

/**
 * @since 1.3
 */
public class NonNullValidator implements IValidator {

	private final String validationMessage;

	/**
	 * 
	 */
	public NonNullValidator() {
		this(null);
	}

	/**
	 * @param validationMessage
	 */
	public NonNullValidator(String validationMessage) {
		// TODO: Externalize
		this.validationMessage = validationMessage != null ? validationMessage
				: "The value must not be empty."; //$NON-NLS-1$
	}

	public IStatus validate(Object value) {
		if (value == null) {
			return ValidationStatus.error(validationMessage);
		}
		return ValidationStatus.ok();
	}
}




/*******************************************************************************
 * Copyright (c) 2009 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.validation;

import java.text.MessageFormat;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.eclipse.core.databinding.validation.IValidator;
import org.eclipse.core.databinding.validation.ValidationStatus;
import org.eclipse.core.runtime.IStatus;

/**
 * @since 1.3
 */
public class StringRegexValidator implements IValidator {

	// TODO: Externalize
	private static final String REGEX_VALIDATION_MESSAGE = "The string must match the following regular expression: {0}."; //$NON-NLS-1$

	private final String regex;

	private final Pattern pattern;

	private final String validationMessage;

	/**
	 * 
	 * @param regex
	 */
	public StringRegexValidator(String regex) {
		this(regex, null);
	}

	/**
	 * 
	 * @param regex
	 * @param validationMessage
	 */
	public StringRegexValidator(String regex, String validationMessage) {
		this.regex = regex;
		this.pattern = Pattern.compile(regex);
		this.validationMessage = validationMessage != null ? validationMessage
				: REGEX_VALIDATION_MESSAGE;
	}

	public IStatus validate(Object value) {
		String input = (String) value;
		if (input != null) {
			Matcher matcher = pattern.matcher(input);
			if (!matcher.matches()) {
				// TODO: Cache message?
				return ValidationStatus.error(MessageFormat.format(
						validationMessage, new String[] { regex }));
			}
		}
		return ValidationStatus.ok();
	}
}




/*******************************************************************************
 * Copyright (c) 2009 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.validation;

import com.ibm.icu.text.NumberFormat;

/**
 * @since 1.3
 */
public class IntegerRangeValidator extends NumberRangeValidator {

	private static final Integer ZERO = new Integer(0);
	private static final Integer ONE = new Integer(1);

	/**
	 * @param min
	 * @param max
	 * @param minConstraint
	 * @param maxConstraint
	 * @param validationMessage
	 * @param format
	 */
	private IntegerRangeValidator(Number min, Number max, int minConstraint,
			int maxConstraint, String validationMessage, NumberFormat format) {
		super(min, max, minConstraint, maxConstraint, validationMessage, format);
	}

	/**
	 * 
	 * @param min
	 * @param validationMessage
	 * @param format
	 * @return .
	 */
	public static IntegerRangeValidator greater(int min,
			String validationMessage, NumberFormat format) {
		return new IntegerRangeValidator(new Integer(min), null, GREATER,
				UNDEFINED, defaultIfNull(validationMessage, GREATER_MESSAGE),
				format);
	}

	/**
	 * 
	 * @param min
	 * @param validationMessage
	 * @param format
	 * @return .
	 */
	public static IntegerRangeValidator greaterEqual(int min,
			String validationMessage, NumberFormat format) {
		return new IntegerRangeValidator(new Integer(min), null, GREATER_EQUAL,
				UNDEFINED, defaultIfNull(validationMessage,
						GREATER_EQUAL_MESSAGE), format);
	}

	/**
	 * 
	 * @param max
	 * @param validationMessage
	 * @param format
	 * @return .
	 */
	public static IntegerRangeValidator less(int max, String validationMessage,
			NumberFormat format) {
		return new IntegerRangeValidator(null, new Integer(max), UNDEFINED,
				LESS, defaultIfNull(validationMessage, LESS_MESSAGE), format);
	}

	/**
	 * 
	 * @param max
	 * @param validationMessage
	 * @param format
	 * @return .
	 */
	public static IntegerRangeValidator lessEqual(int max,
			String validationMessage, NumberFormat format) {
		return new IntegerRangeValidator(null, new Integer(max), UNDEFINED,
				LESS_EQUAL,
				defaultIfNull(validationMessage, LESS_EQUAL_MESSAGE), format);
	}

	/**
	 * 
	 * @param min
	 * @param max
	 * @param validationMessage
	 * @param format
	 * @return .
	 */
	public static IntegerRangeValidator range(int min, int max,
			String validationMessage, NumberFormat format) {
		return new IntegerRangeValidator(new Integer(min), new Integer(max),
				GREATER_EQUAL, LESS_EQUAL, defaultIfNull(validationMessage,
						WITHIN_RANGE_MESSAGE), format);
	}

	/**
	 * 
	 * @param validationMessage
	 * @param format
	 * @return .
	 */
	public static IntegerRangeValidator positive(String validationMessage,
			NumberFormat format) {
		return new IntegerRangeValidator(ONE, null, GREATER_EQUAL, UNDEFINED,
				defaultIfNull(validationMessage, POSITIVE_MESSAGE), format);
	}

	/**
	 * 
	 * @param validationMessage
	 * @param format
	 * @return .
	 */
	public static IntegerRangeValidator nonNegative(String validationMessage,
			NumberFormat format) {
		return new IntegerRangeValidator(ZERO, null, GREATER_EQUAL, UNDEFINED,
				defaultIfNull(validationMessage, NON_NEGATIVE_MESSAGE), format);
	}

	protected int compare(Number number1, Number number2) {
		Integer integer1 = (Integer) number1;
		Integer integer2 = (Integer) number2;
		return integer1.compareTo(integer2);
	}

	private static String defaultIfNull(String string, String defaultString) {
		return (string != null) ? string : defaultString;
	}
}




/*******************************************************************************
 * Copyright (c) 2009 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.validation;

import org.eclipse.core.databinding.validation.IValidator;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;

/**
 * @since 1.3
 */
public class CompositeValidator implements IValidator {

	private final IValidator[] validators;

	/**
	 * @param validators
	 */
	public CompositeValidator(IValidator[] validators) {
		this.validators = validators;
	}

	public IStatus validate(Object value) {
		// TODO: Define an aggregation strategy.
		int maxSeverity = IStatus.OK;
		IStatus maxStatus = Status.OK_STATUS;
		for (int i = 0; i < validators.length; i++) {
			IValidator validator = validators[i];
			IStatus status = validator.validate(value);
			if (status.getSeverity() > maxSeverity) {
				maxSeverity = status.getSeverity();
				maxStatus = status;
			}
		}
		return maxStatus;
	}
}




/*******************************************************************************
 * Copyright (c) 2009 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.editing;

import org.eclipse.core.databinding.conversion.NumberToStringConverter;
import org.eclipse.core.databinding.conversion.StringToNumberConverter;
import org.eclipse.core.internal.databinding.validation.IntegerRangeValidator;
import org.eclipse.core.internal.databinding.validation.NonNullValidator;
import org.eclipse.core.internal.databinding.validation.StringToIntegerValidator;

import com.ibm.icu.text.NumberFormat;

/**
 * @since 1.3
 */
public final class IntegerEditing extends Editing {

	private final NumberFormat format;

	private String requiredMessage = null;

	private String greaterMessage = null;

	private String greaterEqualMessage = null;

	private String lessMessage = null;

	private String lessEqualMessage = null;

	private String rangeMessage = null;

	private String positiveMessage = null;

	private String nonNegativeMessage = null;

	private IntegerEditing(NumberFormat format, String parseErrorMessage,
			String outOfRangeMessage) {
		this.format = format;

		StringToNumberConverter targetConverter = StringToNumberConverter
				.toInteger(format, false);

		addTargetValidator(new StringToIntegerValidator(targetConverter,
				parseErrorMessage, outOfRangeMessage));
		setTargetConverter(targetConverter);
		setModelConverter(NumberToStringConverter.fromInteger(format, false));
	}

	/**
	 * Creates a new editing object which defaults the validations and
	 * conversions used for editing based on the platform's locale. Uses the
	 * default validation messages.
	 * 
	 * @return The new editing object using the default validations and
	 *         conversions for editing.
	 * 
	 * @see NumberFormat#getIntegerInstance()
	 */
	public static IntegerEditing withDefaults() {
		return withDefaults(null, null);
	}

	/**
	 * Creates a new editing object which defaults the validations and
	 * conversions used for editing based on the platform's locale. Uses the
	 * specified custom validation messages.
	 * 
	 * @param parseErrorMessage
	 *            The validation message issued in case the input string cannot
	 *            be parsed to an integer.
	 * @param outOfRangeMessage
	 *            The validation message issued in case the input string
	 *            represents an integer whose value is out of range. Can be
	 *            parameterized by the <code>Integer.MIN_VALUE</code> and
	 *            <code>Integer.MAX_VALUE</code> values.
	 * @return The new editing object using the default validations and
	 *         conversions for editing.
	 */
	public static IntegerEditing withDefaults(String parseErrorMessage,
			String outOfRangeMessage) {
		return new IntegerEditing(NumberFormat.getIntegerInstance(),
				parseErrorMessage, outOfRangeMessage);
	}

	/**
	 * Creates a new editing object whose validations and conversions used for
	 * editing are based on the given integer format. Uses the default
	 * validation messages.
	 * 
	 * @param format
	 *            The integer format defining the validations and conversions
	 *            used for editing.
	 * @return The new editing object configured by the given integer format.
	 */
	public static IntegerEditing forFormat(NumberFormat format) {
		return forFormat(format, null, null);
	}

	/**
	 * Creates a new editing object whose validations and conversions used for
	 * editing are based on the given integer format. Uses the specified custom
	 * validation messages.
	 * 
	 * @param format
	 *            The integer format defining the validations and conversions
	 *            used for editing.
	 * @param parseErrorMessage
	 *            The validation message issued in case the input string cannot
	 *            be parsed to an integer.
	 * @param outOfRangeMessage
	 *            The validation message issued in case the input string
	 *            represents an integer whose value is out of range. Can be
	 *            parameterized by the <code>Integer.MIN_VALUE</code> and
	 *            <code>Integer.MAX_VALUE</code> values.
	 * @return The new editing object configured by the given integer format.
	 */
	public static IntegerEditing forFormat(NumberFormat format,
			String parseErrorMessage, String outOfRangeMessage) {
		return new IntegerEditing(format, parseErrorMessage, outOfRangeMessage);
	}

	/**
	 * Adds a model validator ensuring that the parsed integer is not
	 * <code>null</code>. Uses the current {@link #requiredMessage(String)
	 * validation message}.
	 * 
	 * @return This editing instance for method chaining.
	 */
	public IntegerEditing required() {
		addModelValidator(new NonNullValidator(requiredMessage));
		return this;
	}

	/**
	 * Sets the validation message to be issued in case the parsed integer is
	 * <code>null</code>.
	 * 
	 * @param message
	 *            The validation message to be issued in case the parsed integer
	 *            is <code>null</code>.
	 * @return This editing instance for method chaining.
	 * 
	 * @see #required()
	 */
	public IntegerEditing requiredMessage(String message) {
		this.requiredMessage = message;
		return this;
	}

	/**
	 * Adds a model validator ensuring that the parsed integer is greater than
	 * the given number. Uses the current {@link #greaterMessage(String)
	 * validation message}.
	 * 
	 * @param number
	 *            The number which the parsed integer must be greater than.
	 * @return This editing instance for method chaining.
	 */
	public IntegerEditing greater(int number) {
		addModelValidator(IntegerRangeValidator.greater(number, greaterMessage,
				format));
		return this;
	}

	/**
	 * Sets the validation message to be issued in case the parsed integer is
	 * not greater than a given number.
	 * 
	 * @param message
	 *            The validation message to be issued in case the parsed integer
	 *            is not greater than a given number.
	 * @return This editing instance for method chaining.
	 * 
	 * @see #greater(int)
	 */
	public IntegerEditing greaterMessage(String message) {
		this.greaterMessage = message;
		return this;
	}

	/**
	 * Adds a model validator ensuring that the parsed integer is greater than
	 * or equal to the given number. Uses the current
	 * {@link #greaterEqualMessage(String) validation message}.
	 * 
	 * @param number
	 *            The number which the parsed integer must be greater than or
	 *            equal to.
	 * @return This editing instance for method chaining.
	 */
	public IntegerEditing greaterEqual(int number) {
		addModelValidator(IntegerRangeValidator.greaterEqual(number,
				greaterEqualMessage, format));
		return this;
	}

	/**
	 * Sets the validation message to be issued in case the parsed integer is
	 * not greater than or equal to a given number.
	 * 
	 * @param message
	 *            The validation message to be issued in case the parsed integer
	 *            is not greater than or equal to a given number.
	 * @return This editing instance for method chaining.
	 * 
	 * @see #greaterEqual(int)
	 */
	public IntegerEditing greaterEqualMessage(String message) {
		this.greaterEqualMessage = message;
		return this;
	}

	/**
	 * Adds a model validator ensuring that the parsed integer is less than the
	 * given number. Uses the current {@link #lessMessage(String) validation
	 * message}.
	 * 
	 * @param number
	 *            The number which the parsed integer must be less than.
	 * @return This editing instance for method chaining.
	 */
	public IntegerEditing less(int number) {
		addModelValidator(IntegerRangeValidator.less(number, lessMessage,
				format));
		return this;
	}

	/**
	 * Sets the validation message to be issued in case the parsed integer is
	 * not less than a given number.
	 * 
	 * @param message
	 *            The validation message to be issued in case the parsed integer
	 *            is not less than a given number.
	 * @return This editing instance for method chaining.
	 * 
	 * @see #less(int)
	 */
	public IntegerEditing lessMessage(String message) {
		this.lessMessage = message;
		return this;
	}

	/**
	 * Adds a model validator ensuring that the parsed integer is less than or
	 * equal to the given number. Uses the current
	 * {@link #lessEqualMessage(String) validation message}.
	 * 
	 * @param number
	 *            The number which the parsed integer must be less than or equal
	 *            to.
	 * @return This editing instance for method chaining.
	 */
	public IntegerEditing lessEqual(int number) {
		addModelValidator(IntegerRangeValidator.greaterEqual(number,
				lessEqualMessage, format));
		return this;
	}

	/**
	 * Sets the validation message to be issued in case the parsed integer is
	 * not less than or equal to a given number.
	 * 
	 * @param message
	 *            The validation message to be issued in case the parsed integer
	 *            is not less than or equal to a given number.
	 * @return This editing instance for method chaining.
	 * 
	 * @see #lessEqual(int)
	 */
	public IntegerEditing lessEqualMessage(String message) {
		this.lessEqualMessage = message;
		return this;
	}

	/**
	 * Adds a model validator ensuring that the parsed integer is within the
	 * given range. Uses the current {@link #rangeMessage(String) validation
	 * message}.
	 * 
	 * @param min
	 *            The lower bound of the range (inclusive).
	 * @param max
	 *            The upper bound of the range (inclusive).
	 * @return This editing instance for method chaining.
	 */
	public IntegerEditing range(int min, int max) {
		addModelValidator(IntegerRangeValidator.range(min, max, rangeMessage,
				format));
		return this;
	}

	/**
	 * Sets the validation message to be issued in case the parsed integer is
	 * not within a given range.
	 * 
	 * @param message
	 *            The validation message to be issued in case the parsed integer
	 *            is not within a given range.
	 * @return This editing instance for method chaining.
	 * 
	 * @see #range(int, int)
	 */
	public IntegerEditing rangeMessage(String message) {
		this.rangeMessage = message;
		return this;
	}

	/**
	 * Adds a model validator ensuring that the parsed integer is positive. Uses
	 * the current {@link #positiveMessage(String) validation message}.
	 * 
	 * @return This editing instance for method chaining.
	 */
	public IntegerEditing positive() {
		addModelValidator(IntegerRangeValidator.positive(positiveMessage,
				format));
		return this;
	}

	/**
	 * Sets the validation message to be issued in case the parsed integer is
	 * not positive.
	 * 
	 * @param message
	 *            The validation message to be issued in case the parsed integer
	 *            is not positive.
	 * @return This editing instance for method chaining.
	 * 
	 * @see #positive()
	 */
	public IntegerEditing positiveMessage(String message) {
		this.positiveMessage = message;
		return this;
	}

	/**
	 * Adds a model validator ensuring that the parsed integer is non-negative.
	 * Uses the current {@link #nonNegativeMessage(String) validation message}.
	 * 
	 * @return This editing instance for method chaining.
	 */
	public IntegerEditing nonNegative() {
		addModelValidator(IntegerRangeValidator.nonNegative(nonNegativeMessage,
				format));
		return this;
	}

	/**
	 * Sets the validation message to be issued in case the parsed integer is
	 * negative.
	 * 
	 * @param message
	 *            The validation message to be issued in case the parsed integer
	 *            is negative.
	 * @return This editing instance for method chaining.
	 * 
	 * @see #nonNegative()
	 */
	public IntegerEditing nonNegativeMessage(String message) {
		this.nonNegativeMessage = message;
		return this;
	}
}




/*******************************************************************************
 * Copyright (c) 2009 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.editing;

import java.util.ArrayList;
import java.util.List;

import org.eclipse.core.databinding.UpdateListStrategy;
import org.eclipse.core.databinding.UpdateSetStrategy;
import org.eclipse.core.databinding.UpdateValueStrategy;
import org.eclipse.core.databinding.conversion.IConverter;
import org.eclipse.core.databinding.validation.IValidator;
import org.eclipse.core.internal.databinding.validation.CompositeValidator;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.MultiStatus;

/**
 * @since 1.3
 */
public class Editing {

	private final List targetValidators = new ArrayList();

	private IConverter targetConverter;

	private final List modelValidators = new ArrayList();

	private final List beforeSetModelValidators = new ArrayList();

	private IConverter modelConverter;

	/**
	 * Adds a custom target validator.
	 * 
	 * @param validator
	 *            The custom target validator to add.
	 * @return This editing instance for method chaining.
	 */
	public final Editing addTargetValidator(IValidator validator) {
		targetValidators.add(validator);
		return this;
	}

	/**
	 * Adds a custom model validator.
	 * 
	 * @param validator
	 *            The custom model validator to add.
	 * @return This editing instance for method chaining.
	 */
	public final Editing addModelValidator(IValidator validator) {
		modelValidators.add(validator);
		return this;
	}

	/**
	 * Adds a custom before-set model validator.
	 * 
	 * @param validator
	 *            The custom before-set model validator to add.
	 * @return This editing instance for method chaining.
	 */
	public final Editing addBeforeSetModelValidator(IValidator validator) {
		beforeSetModelValidators.add(validator);
		return this;
	}

	protected final void setTargetConverter(IConverter converter) {
		this.targetConverter = converter;
	}

	protected final void setModelConverter(IConverter converter) {
		this.modelConverter = converter;
	}

	/**
	 * Creates a new target-to-model {@link UpdateValueStrategy} with a default
	 * update policy configured by the current state of this editing object.
	 * 
	 * @return A new target-to-model {@link UpdateValueStrategy} configured by
	 *         the current state of this editing object.
	 * 
	 * @see UpdateValueStrategy#UpdateValueStrategy()
	 */
	public UpdateValueStrategy createTargetValueStrategy() {
		return applyToTargetValueStrategy(new UpdateValueStrategy());
	}

	/**
	 * Creates a new target-to-model {@link UpdateValueStrategy} with the given
	 * update policy configured by the current state of this editing object.
	 * 
	 * @param updatePolicy
	 *            The update policy to use.
	 * @return A new target-to-model {@link UpdateValueStrategy} configured by
	 *         the current state of this editing object.
	 * 
	 * @see UpdateValueStrategy#UpdateValueStrategy(int)
	 */
	public UpdateValueStrategy createTargetValueStrategy(int updatePolicy) {
		return applyToTargetValueStrategy(new UpdateValueStrategy(updatePolicy));
	}

	/**
	 * Creates a new model-to-target {@link UpdateValueStrategy} with a default
	 * update policy configured by the current state of this editing object.
	 * 
	 * @return A new model-to-target {@link UpdateValueStrategy} configured by
	 *         the current state of this editing object.
	 * 
	 * @see UpdateValueStrategy#UpdateValueStrategy()
	 */
	public UpdateValueStrategy createModelValueStrategy() {
		return applyToModelValueStrategy(new UpdateValueStrategy());
	}

	/**
	 * Creates a new model-to-target {@link UpdateValueStrategy} with the given
	 * update policy configured by the current state of this editing object.
	 * 
	 * @param updatePolicy
	 *            The update policy to use.
	 * @return A new model-to-target {@link UpdateValueStrategy} configured by
	 *         the current state of this editing object.
	 * 
	 * @see UpdateValueStrategy#UpdateValueStrategy(int)
	 */
	public UpdateValueStrategy createModelValueStrategy(int updatePolicy) {
		return applyToModelValueStrategy(new UpdateValueStrategy(updatePolicy));
	}

	/**
	 * Creates a new target-to-model {@link UpdateListStrategy} with a default
	 * update policy configured by the current state of this editing object.
	 * 
	 * @return A new target-to-model {@link UpdateListStrategy} configured by
	 *         the current state of this editing object.
	 * 
	 * @see UpdateListStrategy#UpdateListStrategy()
	 */
	public UpdateListStrategy createTargetListStrategy() {
		return applyToTargetListStrategy(new UpdateListStrategy());
	}

	/**
	 * Creates a new target-to-model {@link UpdateListStrategy} with the given
	 * update policy configured by the current state of this editing object.
	 * 
	 * @param updatePolicy
	 *            The update policy to use.
	 * @return A new target-to-model {@link UpdateListStrategy} configured by
	 *         the current state of this editing object.
	 * 
	 * @see UpdateListStrategy#UpdateListStrategy(int)
	 */
	public UpdateListStrategy createTargetListStrategy(int updatePolicy) {
		return applyToTargetListStrategy(new UpdateListStrategy(updatePolicy));
	}

	/**
	 * Creates a new model-to-target {@link UpdateListStrategy} with a default
	 * update policy configured by the current state of this editing object.
	 * 
	 * @return A new model-to-target {@link UpdateListStrategy} configured by
	 *         the current state of this editing object.
	 * 
	 * @see UpdateListStrategy#UpdateListStrategy()
	 */
	public UpdateListStrategy createModelListStrategy() {
		return applyToModelListStrategy(new UpdateListStrategy());
	}

	/**
	 * Creates a new model-to-target {@link UpdateListStrategy} with the given
	 * update policy configured by the current state of this editing object.
	 * 
	 * @param updatePolicy
	 *            The update policy to use.
	 * @return A new model-to-target {@link UpdateListStrategy} configured by
	 *         the current state of this editing object.
	 * 
	 * @see UpdateListStrategy#UpdateListStrategy(int)
	 */
	public UpdateListStrategy createModelListStrategy(int updatePolicy) {
		return applyToModelListStrategy(new UpdateListStrategy(updatePolicy));
	}

	/**
	 * Creates a new target-to-model {@link UpdateSetStrategy} with a default
	 * update policy configured by the current state of this editing object.
	 * 
	 * @return A new target-to-model {@link UpdateSetStrategy} configured by the
	 *         current state of this editing object.
	 * 
	 * @see UpdateListStrategy#UpdateListStrategy()
	 */
	public UpdateSetStrategy createTargetSetStrategy() {
		return applyToTargetSetStrategy(new UpdateSetStrategy());
	}

	/**
	 * Creates a new target-to-model {@link UpdateListStrategy} with the given
	 * update policy configured by the current state of this editing object.
	 * 
	 * @param updatePolicy
	 *            The update policy to use.
	 * @return A new target-to-model {@link UpdateListStrategy} configured by
	 *         the current state of this editing object.
	 * 
	 * @see UpdateSetStrategy#UpdateSetStrategy(int)
	 */
	public UpdateSetStrategy createTargetSetStrategy(int updatePolicy) {
		return applyToTargetSetStrategy(new UpdateSetStrategy(updatePolicy));
	}

	/**
	 * Creates a new model-to-target {@link UpdateSetStrategy} with a default
	 * update policy configured by the current state of this editing object.
	 * 
	 * @return A new model-to-target {@link UpdateSetStrategy} configured by the
	 *         current state of this editing object.
	 * 
	 * @see UpdateSetStrategy#UpdateSetStrategy()
	 */
	public UpdateSetStrategy createModelSetStrategy() {
		return applyToModelSetStrategy(new UpdateSetStrategy());
	}

	/**
	 * Creates a new model-to-target {@link UpdateSetStrategy} with the given
	 * update policy configured by the current state of this editing object.
	 * 
	 * @param updatePolicy
	 *            The update policy to use.
	 * @return A new model-to-target {@link UpdateSetStrategy} configured by the
	 *         current state of this editing object.
	 * 
	 * @see UpdateSetStrategy#UpdateSetStrategy(int)
	 */
	public UpdateSetStrategy createModelSetStrategy(int updatePolicy) {
		return applyToModelSetStrategy(new UpdateSetStrategy(updatePolicy));
	}

	/**
	 * Configures an existing target-to-model {@link UpdateValueStrategy} with
	 * the current state of this editing object.
	 * 
	 * @param updateStrategy
	 *            The {@link UpdateValueStrategy} to configure.
	 * @return The passed-in, configured target-to-model
	 *         {@link UpdateValueStrategy}.
	 */
	public UpdateValueStrategy applyToTargetValueStrategy(
			UpdateValueStrategy updateStrategy) {
		updateStrategy.setAfterGetValidator(createTargetValidator());
		updateStrategy.setConverter(targetConverter);
		updateStrategy.setAfterConvertValidator(createModelValidator());
		updateStrategy.setBeforeSetValidator(createBeforeSetModelValidator());
		return updateStrategy;
	}

	/**
	 * Configures an existing model-to-target {@link UpdateValueStrategy} with
	 * the current state of this editing object.
	 * 
	 * @param updateStrategy
	 *            The {@link UpdateValueStrategy} to configure.
	 * @return The passed-in, configured model-to-target
	 *         {@link UpdateValueStrategy}.
	 */
	public UpdateValueStrategy applyToModelValueStrategy(
			UpdateValueStrategy updateStrategy) {
		updateStrategy.setConverter(modelConverter);
		return updateStrategy;
	}

	/**
	 * Configures an existing target-to-model {@link UpdateListStrategy} with
	 * the current state of this editing object.
	 * 
	 * @param updateStrategy
	 *            The {@link UpdateListStrategy} to configure.
	 * @return The passed-in, configured target-to-model
	 *         {@link UpdateListStrategy}.
	 */
	public UpdateListStrategy applyToTargetListStrategy(
			UpdateListStrategy updateStrategy) {
		updateStrategy.setConverter(targetConverter);
		return updateStrategy;
	}

	/**
	 * Configures an existing model-to-target {@link UpdateListStrategy} with
	 * the current state of this editing object.
	 * 
	 * @param updateStrategy
	 *            The {@link UpdateListStrategy} to configure.
	 * @return The passed-in, configured model-to-target
	 *         {@link UpdateListStrategy}.
	 */
	public UpdateListStrategy applyToModelListStrategy(
			UpdateListStrategy updateStrategy) {
		updateStrategy.setConverter(modelConverter);
		return updateStrategy;
	}

	/**
	 * Configures an existing target-to-model {@link UpdateListStrategy} with
	 * the current state of this editing object.
	 * 
	 * @param updateStrategy
	 *            The {@link UpdateSetStrategy} to configure.
	 * @return The passed-in, configured target-to-model
	 *         {@link UpdateSetStrategy}.
	 */
	public UpdateSetStrategy applyToTargetSetStrategy(
			UpdateSetStrategy updateStrategy) {
		updateStrategy.setConverter(targetConverter);
		return updateStrategy;
	}

	/**
	 * Configures an existing model-to-target {@link UpdateSetStrategy} with the
	 * current state of this editing object.
	 * 
	 * @param updateStrategy
	 *            The {@link UpdateSetStrategy} to configure.
	 * @return The passed-in, configured model-to-target
	 *         {@link UpdateSetStrategy}.
	 */
	public UpdateSetStrategy applyToModelSetStrategy(
			UpdateSetStrategy updateStrategy) {
		updateStrategy.setConverter(modelConverter);
		return updateStrategy;
	}

	/**
	 * Converts a target value to a model value by performing the following
	 * steps:
	 * <ul>
	 * <li>
	 * Applying all the currently accumulated
	 * {@link #addTargetValidator(IValidator) target validators} to the given
	 * target value.</li>
	 * <li>
	 * {@link #setTargetConverter(IConverter) Converting} the target value to
	 * the model value.</li>
	 * <li>
	 * Applying all the currently accumulated
	 * {@link #addModelValidator(IValidator) model validators} to the converted
	 * model value.</li>
	 * <li>
	 * Applying all the currently accumulated
	 * {@link #addBeforeSetModelValidator(IValidator) before-set model
	 * validators} to the converted model value.</li>
	 * </ul>
	 * 
	 * <p>
	 * The conversion process will be aborted by returning <code>null</code>
	 * whenever any of the applied validators produces a {@link IStatus
	 * validation status} having {@link IStatus#getSeverity() severity}
	 * <code>IStatus.ERROR</code> or <code>IStatus.CANCEL</code>. During the
	 * conversion process, any validation status whose severity is different
	 * from <code>IStatus.OK</code> will be {@link MultiStatus#add(IStatus)
	 * added} to the given aggregate <code>validationStatus</code>.
	 * </p>
	 * 
	 * @param targetValue
	 *            The target value to be converted to a model value.
	 * @param validationStatus
	 *            Aggregate validation status to which to add the validations
	 *            produced during the conversion process.
	 * @return The converted model value or <code>null</code> in case the
	 *         conversion has been aborted due to a validation error.
	 */
	public final Object convertToModel(Object targetValue,
			MultiStatus validationStatus) {
		// TODO: Cache the target/model validators.
		IValidator targetValidator = createTargetValidator();
		if (!applyValidator(targetValidator, targetValue, validationStatus)) {
			return null;
		}

		Object modelValue = (targetConverter != null) ? targetConverter
				.convert(targetValue) : targetValue;

		IValidator modelValidator = createModelValidator();
		if (!applyValidator(modelValidator, modelValue, validationStatus)) {
			return null;
		}

		IValidator beforeSetModelValidator = createBeforeSetModelValidator();
		if (!applyValidator(beforeSetModelValidator, modelValue,
				validationStatus)) {
			return null;
		}

		return modelValue;
	}

	/**
	 * {@link #setModelConverter(IConverter) Converts} a model value to a target
	 * value.
	 * 
	 * @param modelValue
	 *            The target value to be converted to a model value.
	 * @return The converted target value.
	 */
	public final Object convertToTarget(Object modelValue) {
		return (modelConverter != null) ? modelConverter.convert(modelValue)
				: modelValue;
	}

	private IValidator createTargetValidator() {
		if (!targetValidators.isEmpty()) {
			CompositeValidator targetValidator = new CompositeValidator(
					(IValidator[]) targetValidators
							.toArray(new IValidator[targetValidators.size()]));
			return targetValidator;
		}
		return null;
	}

	private IValidator createModelValidator() {
		if (!modelValidators.isEmpty()) {
			return new CompositeValidator((IValidator[]) modelValidators
					.toArray(new IValidator[modelValidators.size()]));
		}
		return null;
	}

	private IValidator createBeforeSetModelValidator() {
		if (!beforeSetModelValidators.isEmpty()) {
			return new CompositeValidator(
					(IValidator[]) beforeSetModelValidators
							.toArray(new IValidator[beforeSetModelValidators
									.size()]));
		}
		return null;
	}

	private static boolean applyValidator(IValidator validator, Object value,
			MultiStatus aggregateStatus) {
		if (validator != null) {
			IStatus validationStatus = validator.validate(value);
			if (!validationStatus.isOK()) {
				aggregateStatus.add(validationStatus);
			}
			return isValid(validationStatus);
		}
		return true;
	}

	private static boolean isValid(IStatus status) {
		return status.isOK() || status.matches(IStatus.INFO | IStatus.WARNING);
	}
}




/*******************************************************************************
 * Copyright (c) 2009 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.editing;

import java.util.Date;

import org.eclipse.core.internal.databinding.conversion.DateToStringConverter;
import org.eclipse.core.internal.databinding.conversion.StringToDateConverter;
import org.eclipse.core.internal.databinding.validation.DateRangeValidator;
import org.eclipse.core.internal.databinding.validation.NonNullValidator;
import org.eclipse.core.internal.databinding.validation.StringToDateValidator;

import com.ibm.icu.text.DateFormat;

/**
 * @since 1.3
 */
public final class DateEditing extends Editing {

	private final DateFormat displayFormat;

	private String requiredMessage = null;

	private String afterMessage = null;

	private String afterEqualMessage = null;

	private String beforeMessage = null;

	private String beforeEqualMessage = null;

	private DateEditing(DateFormat[] inputFormats, String parseErrorMessage,
			DateFormat displayFormat) {
		this.displayFormat = displayFormat;

		StringToDateConverter targetConverter;
		if (inputFormats == null) {
			targetConverter = new StringToDateConverter();
		} else {
			targetConverter = new StringToDateConverter(inputFormats);
		}

		addTargetValidator(new StringToDateValidator(targetConverter,
				parseErrorMessage));
		setTargetConverter(targetConverter);
		setModelConverter(displayFormat == null ? new DateToStringConverter()
				: new DateToStringConverter(displayFormat));
	}

	/**
	 * Creates a new editing object which defaults the validations and
	 * conversions used for editing. Uses the default validation message.
	 * 
	 * @return The new editing object using the default validations and
	 *         conversions for editing.
	 */
	public static DateEditing withDefaults() {
		return withDefaults(null);
	}

	/**
	 * Creates a new editing object which defaults the validations and
	 * conversions used for editing. Uses the specified custom validation
	 * message.
	 * 
	 * @param parseErrorMessage
	 *            The validation message issued in case the input string cannot
	 *            be parsed to a date.
	 * @return The new editing object using the default validations and
	 *         conversions for editing.
	 */
	public static DateEditing withDefaults(String parseErrorMessage) {
		return new DateEditing(null, parseErrorMessage, null);
	}

	/**
	 * Creates a new editing object which supports all the given date input
	 * formats and which uses the specified format for displaying a date. Uses
	 * the default validation message.
	 * 
	 * @param inputFormats
	 *            The date formats supported for reading in dates.
	 * @param displayFormat
	 *            The date format for displaying dates.
	 * @return The new editing object configured by the given date formats.
	 */
	public static DateEditing forFormats(DateFormat[] inputFormats,
			DateFormat displayFormat) {
		return new DateEditing(inputFormats, null, displayFormat);
	}

	/**
	 * Creates a new editing object which supports all the given date input
	 * formats and which uses the specified format for displaying a date. Uses
	 * the specified custom validation message.
	 * 
	 * @param inputFormats
	 *            The date formats supported for reading in dates.
	 * @param parseErrorMessage
	 *            The validation message issued in case the input string cannot
	 *            be parsed to a date.
	 * @param displayFormat
	 *            The date format for displaying dates.
	 * @return The new editing object configured by the given date formats.
	 */
	public static DateEditing forFormats(DateFormat[] inputFormats,
			String parseErrorMessage, DateFormat displayFormat) {
		return new DateEditing(inputFormats, parseErrorMessage, displayFormat);
	}

	/**
	 * Adds a model validator ensuring that the parsed date is not
	 * <code>null</code>. Uses the current {@link #requiredMessage(String)
	 * validation message}.
	 * 
	 * @return This editing instance for method chaining.
	 */
	public DateEditing required() {
		addModelValidator(new NonNullValidator(requiredMessage));
		return this;
	}

	/**
	 * Sets the validation message to be issued in case the parsed date is
	 * <code>null</code>.
	 * 
	 * @param message
	 *            The validation message to be issued in case the parsed date is
	 *            <code>null</code>.
	 * @return This editing instance for method chaining.
	 * 
	 * @see #required()
	 */
	public DateEditing requiredMessage(String message) {
		this.requiredMessage = message;
		return this;
	}

	/**
	 * Adds a model validator ensuring that the parsed date is after the given
	 * date. Uses the current {@link #afterMessage(String) validation message}.
	 * 
	 * @param date
	 *            The date which must be before or on the parsed date.
	 * @return This editing instance for method chaining.
	 * 
	 * @see Date#after(Date)
	 */
	public DateEditing after(Date date) {
		addModelValidator(DateRangeValidator.after(date, afterMessage,
				displayFormat));
		return this;
	}

	/**
	 * Sets the validation message to be issued in case the parsed date is not
	 * after a given date.
	 * 
	 * @param message
	 *            The validation message to be issued in case the parsed date is
	 *            not after a given date.
	 * @return This editing instance for method chaining.
	 * 
	 * @see #after(Date)
	 */
	public DateEditing afterMessage(String message) {
		this.afterMessage = message;
		return this;
	}

	/**
	 * Adds a model validator ensuring that the parsed date is after or on the
	 * given date. Uses the current {@link #afterEqualMessage(String) validation
	 * message}.
	 * 
	 * @param date
	 *            The date which must be before the parsed date.
	 * @return This editing instance for method chaining.
	 * 
	 * @see Date#after(Date)
	 * @see Date#equals(Object)
	 */
	public DateEditing afterEqual(Date date) {
		addModelValidator(DateRangeValidator.afterEqual(date,
				afterEqualMessage, displayFormat));
		return this;
	}

	/**
	 * Sets the validation message to be issued in case the parsed date is not
	 * after or on a given date.
	 * 
	 * @param message
	 *            The validation message to be issued in case the parsed date is
	 *            not after or on a given date.
	 * @return This editing instance for method chaining.
	 * 
	 * @see #afterEqual(Date)
	 */
	public DateEditing afterEqualMessage(String message) {
		this.afterEqualMessage = message;
		return this;
	}

	/**
	 * Adds a model validator ensuring that the parsed date is before the given
	 * date. Uses the current {@link #beforeMessage(String) validation message}.
	 * 
	 * @param date
	 *            The date which must be after or on the parsed date.
	 * @return This editing instance for method chaining.
	 * 
	 * @see Date#before(Date)
	 */
	public DateEditing before(Date date) {
		addModelValidator(DateRangeValidator.before(date, beforeMessage,
				displayFormat));
		return this;
	}

	/**
	 * Sets the validation message to be issued in case the parsed date is not
	 * before a given date.
	 * 
	 * @param message
	 *            The validation message to be issued in case the parsed date is
	 *            not before a given date.
	 * @return This editing instance for method chaining.
	 * 
	 * @see #before(Date)
	 */
	public DateEditing beforeMessage(String message) {
		this.beforeMessage = message;
		return this;
	}

	/**
	 * Adds a model validator ensuring that the parsed date is before or on the
	 * given date. Uses the current {@link #beforeEqualMessage(String)
	 * validation message}.
	 * 
	 * @param date
	 *            The date which must be after the parsed date.
	 * @return This editing instance for method chaining.
	 * 
	 * @see Date#before(Date)
	 * @see Date#equals(Object)
	 */
	public DateEditing beforeEqual(Date date) {
		addModelValidator(DateRangeValidator.beforeEqual(date,
				beforeEqualMessage, displayFormat));
		return this;
	}

	/**
	 * Sets the validation message to be issued in case the parsed date is not
	 * before or on a given date.
	 * 
	 * @param message
	 *            The validation message to be issued in case the parsed date is
	 *            not before or on a given date.
	 * @return This editing instance for method chaining.
	 * 
	 * @see #beforeEqual(Date)
	 */
	public DateEditing beforeEqualMessage(String message) {
		this.beforeEqualMessage = message;
		return this;
	}
}




/*******************************************************************************
 * Copyright (c) 2009 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.conversion;

import org.eclipse.core.databinding.conversion.Converter;

/**
 * @since 1.3
 */
public class StringStripConverter extends Converter {

	private final boolean stripToNull;

	/**
	 * 
	 * @param stripToNull
	 */
	public StringStripConverter(boolean stripToNull) {
		super(String.class, String.class);
		this.stripToNull = stripToNull;
	}

	public Object convert(Object fromObject) {
		String string = (String) fromObject;

		if (string != null && string.length() != 0) {
			int stripStart = 0;
			while (stripStart < string.length()
					&& Character.isWhitespace(string.charAt(stripStart))) {
				stripStart++;
			}

			int stripEnd = string.length() - 1;
			while (stripEnd >= 0
					&& Character.isWhitespace(string.charAt(stripEnd))) {
				stripEnd--;
			}

			if (stripStart <= stripEnd) {
				string = string.substring(stripStart, stripEnd + 1);
			} else {
				string = null;
			}
		}

		if (string == null || string.length() == 0) {
			string = stripToNull ? null : ""; //$NON-NLS-1$
		}

		return string;
	}
}




/*******************************************************************************
 * Copyright (c) 2009 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.validation;

import java.text.MessageFormat;

import org.eclipse.core.databinding.validation.IValidator;
import org.eclipse.core.databinding.validation.ValidationStatus;
import org.eclipse.core.runtime.IStatus;

import com.ibm.icu.text.NumberFormat;

/**
 * @since 1.3
 */
public abstract class NumberRangeValidator implements IValidator {

	protected static final int UNDEFINED = -1;
	protected static final int GREATER = 0;
	protected static final int GREATER_EQUAL = 1;
	protected static final int LESS = 2;
	protected static final int LESS_EQUAL = 3;

	// TODO: Externalize
	protected static final String GREATER_MESSAGE = "The value must be greater than {0}."; //$NON-NLS-1$
	protected static final String GREATER_EQUAL_MESSAGE = "The value must be greater than or equal to {0}."; //$NON-NLS-1$
	protected static final String LESS_MESSAGE = "The value must be less than {0}."; //$NON-NLS-1$
	protected static final String LESS_EQUAL_MESSAGE = "The value must be less than or equal to {0}."; //$NON-NLS-1$
	protected static final String WITHIN_RANGE_MESSAGE = "The value must lie between {0} and {1}."; //$NON-NLS-1$
	protected static final String POSITIVE_MESSAGE = "The value must be positive."; //$NON-NLS-1$
	protected static final String NON_NEGATIVE_MESSAGE = "The value must not be negative."; //$NON-NLS-1$

	private final Number min;
	private final Number max;
	private final int minConstraint;
	private final int maxConstraint;
	private final String validationMessage;
	private final NumberFormat format;

	/**
	 * 
	 * @param min
	 * @param max
	 * @param minConstraint
	 * @param maxConstraint
	 * @param validationMessage
	 * @param format
	 */
	protected NumberRangeValidator(Number min, Number max, int minConstraint,
			int maxConstraint, String validationMessage, NumberFormat format) {
		this.min = min;
		this.max = max;
		this.minConstraint = minConstraint;
		this.maxConstraint = maxConstraint;
		this.validationMessage = validationMessage;
		this.format = format;
	}

	public IStatus validate(Object value) {
		if (value != null) {
			Number number = (Number) value;
			if ((min != null && !fulfillsConstraint(number, min, minConstraint))
					|| (max != null && !fulfillsConstraint(number, max,
							maxConstraint))) {
				// TODO: Cache message?
				return ValidationStatus.error(MessageFormat.format(
						validationMessage, getFormattedRangeExtremas()));
			}
		}
		return ValidationStatus.ok();
	}

	private boolean fulfillsConstraint(Number number1, Number number2,
			int constraint) {
		int compareResult = compare(number1, number2);
		switch (constraint) {
		case GREATER:
			return compareResult > 0;
		case GREATER_EQUAL:
			return compareResult >= 0;
		case LESS:
			return compareResult < 0;
		case LESS_EQUAL:
			return compareResult <= 0;
		case UNDEFINED:
		default:
			throw new IllegalArgumentException(
					"Unsupported constraint: " + constraint); //$NON-NLS-1$
		}
	}

	protected abstract int compare(Number number1, Number number2);

	private String[] getFormattedRangeExtremas() {
		// TODO: Synchronize formatting to make it thread safe?
		if (min == null) {
			return new String[] { format.format(max) };
		} else if (max == null) {
			return new String[] { format.format(min) };
		}
		return new String[] { format.format(min), format.format(max) };
	}
}

Lines 11-17 Link Here

(-)META-INF/MANIFEST.MF (-1 / +2 lines)
11	org.eclipse.core.runtime,	11	org.eclipse.core.runtime,
12	org.eclipse.core.databinding.beans,	12	org.eclipse.core.databinding.beans,
13	org.eclipse.jface.databinding,	13	org.eclipse.jface.databinding,
14	org.eclipse.core.databinding.property	14	org.eclipse.core.databinding.property,
		15	com.ibm.icu;bundle-version="3.8.1"
15	Export-Package: org.eclipse.jface.examples.databinding;x-internal:=false,	16	Export-Package: org.eclipse.jface.examples.databinding;x-internal:=false,
16	org.eclipse.jface.examples.databinding.mask;x-internal:=false,	17	org.eclipse.jface.examples.databinding.mask;x-internal:=false,
17	org.eclipse.jface.examples.databinding.mask.internal;x-internal:=true,	18	org.eclipse.jface.examples.databinding.mask.internal;x-internal:=true,




/*******************************************************************************
 * Copyright (c) 2006, 2009 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.jface.examples.databinding.snippets;

import java.util.Calendar;
import java.util.Date;

import org.eclipse.core.databinding.Binding;
import org.eclipse.core.databinding.DataBindingContext;
import org.eclipse.core.databinding.editing.Editing;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.list.WritableList;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.core.databinding.observable.value.WritableValue;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.jface.databinding.swt.ISWTObservableValue;
import org.eclipse.jface.databinding.swt.SWTObservables;
import org.eclipse.jface.databinding.viewers.ObservableListContentProvider;
import org.eclipse.jface.examples.databinding.util.EditingFactory;
import org.eclipse.jface.internal.databinding.provisional.fieldassist.ControlDecorationSupport;
import org.eclipse.jface.layout.GridDataFactory;
import org.eclipse.jface.layout.GridLayoutFactory;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.ListViewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.FocusAdapter;
import org.eclipse.swt.events.FocusEvent;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Group;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Text;

public class Snippet035Editing {

	private static final String EMAIL_REGEX = "\\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,4}\\b";

	private DataBindingContext dbc;

	public static void main(String[] args) {
		Display display = new Display();

		Realm.runWithDefault(SWTObservables.getRealm(display), new Runnable() {
			public void run() {
				Shell shell = new Snippet035Editing().createShell();
				Display display = Display.getCurrent();
				while (!shell.isDisposed()) {
					if (!display.readAndDispatch()) {
						display.sleep();
					}
				}
			}
		});
	}

	private Shell createShell() {
		Display display = Display.getCurrent();
		Shell shell = new Shell(display);
		shell.setText("Editing");
		shell.setLayout(new GridLayout(1, false));

		dbc = new DataBindingContext();

		createValueSection(shell);
		createListSection(shell);

		shell.pack();
		shell.open();

		return shell;
	}

	private void createValueSection(Composite parent) {
		Group section = createSectionGroup(parent, "Value bindings", false);

		// Edit an e-mail address.
		Text emailText = createTextField(section, "E-Mail*");
		Editing emailEditing = EditingFactory.forString().required().matches(EMAIL_REGEX);
		bindTextField(emailText, new WritableValue(), emailEditing);

		// Edit a required, positive integer and use the default validation message.
		Text positiveText = createTextField(section, "Positive value*");
		Editing positiveEditing = EditingFactory.forInteger().required().positive();
		bindTextField(positiveText, new WritableValue(), positiveEditing);

		// Edit an integer within the range [1, 100] and use the default
		// validation message.
		Text rangeText = createTextField(section, "Value in [1, 100]");
		Editing rangeEditing = EditingFactory.forInteger().range(1, 100);
		bindTextField(rangeText, new WritableValue(new Integer(0), null), rangeEditing);

		// Edit a percentage value which must lie within [0, 100] and use a custom
		// validation message which indicates that the value actually represents
		// a percentage value.
		Text percentText = createTextField(section, "Value [%]");
		Editing percentEditing = EditingFactory.forInteger().rangeMessage("Please specify a valid percentage value within [{0}, {1}].").range(0, 100);
		bindTextField(percentText, new WritableValue(new Integer(-1), null), percentEditing);

		// Edit a hex integer within the range [0x00, 0xff]. The range validation
		// message will display the range boundaries in hex format as well.
		Text hexText = createTextField(section, "Hex value in [0x00, 0xff]");
		Editing hexEditing = EditingFactory.forHexInteger(2).range(0x00, 0xff);
		bindTextField(hexText, new WritableValue(new Integer(0), null), hexEditing);
	}

	private void createListSection(Composite parent) {
		Group section = createSectionGroup(parent, "List bindings", true);

		// Our date should be >= 01.01.1990.
		Calendar year1990Calendar = Calendar.getInstance();
		year1990Calendar.clear();
		year1990Calendar.set(1990, 0, 1);
		Date year1990 = year1990Calendar.getTime();

		// Edit a date supporting the default input/display patterns.
		Text dateText = createTextField(section, "Date");
		Editing dateEditing = EditingFactory.forDate().afterEqual(year1990);
		final WritableValue dateObservable = new WritableValue();
		final Binding dateBinding = bindTextField(dateText, dateObservable, dateEditing);

		// Create a list to which the dates are added when the user hits ENTER.
		new Label(section, SWT.LEFT);
		ListViewer dateListViewer = new ListViewer(section);
		GridDataFactory.fillDefaults().grab(true, true).hint(150, 200).applyTo(dateListViewer.getList());

		dateListViewer.setContentProvider(new ObservableListContentProvider());
		dateListViewer.setLabelProvider(new LabelProvider());

		// We use the same DateEditing object as for the text field above to
		// create a list binding which maps the entered dates to their string
		// representation which is then set as input on the ListViewer.
		final WritableList targetDateList = new WritableList();
		final WritableList modelDateList = new WritableList();
		dbc.bindList(
				targetDateList,
				modelDateList,
				dateEditing.createTargetListStrategy(),
				dateEditing.createModelListStrategy());

		// Set the list containing the string representation of the dates as input.
		dateListViewer.setInput(targetDateList);

		// Add the current date in the text field when the user hits ENTER.
		dateText.addSelectionListener(new SelectionAdapter() {
			public void widgetDefaultSelected(SelectionEvent e) {
				IStatus dateValidationStatus = (IStatus) dateBinding.getValidationStatus().getValue();
				Date date = (Date) dateObservable.getValue();
				if (dateValidationStatus.isOK() && date != null) {
					modelDateList.add(date);
				}
			}
		});
	}

	private Binding bindTextField(Text text, IObservableValue modelValue, Editing editing) {
		// Create the binding using the editing object.
		ISWTObservableValue textObservable = SWTObservables.observeText(text, SWT.Modify);
		Binding binding = dbc.bindValue(
				textObservable,
				modelValue,
				editing.createTargetValueStrategy(),
				editing.createModelValueStrategy());

		// Decorate the control with the validation status.
		ControlDecorationSupport.create(binding, SWT.TOP);

		// Re-format when the text field looses the focus in order to always
		// display the model in the default format in case multiple input formats
		// are supported.
		formatOnFocusOut(text, binding);

		return binding;
	}

	private static void formatOnFocusOut(final Control control, final Binding binding) {
		control.addFocusListener(new FocusAdapter() {
			public void focusLost(FocusEvent e) {
				IStatus dateValidationStatus = (IStatus) binding.getValidationStatus().getValue();
				if (dateValidationStatus.isOK()) {
					binding.updateModelToTarget();
				}
			}
		});
	}

	private static Group createSectionGroup(Composite parent, String groupText, boolean grabVertical) {
		Group section = new Group(parent, SWT.SHADOW_ETCHED_IN);
		section.setText(groupText);
		GridLayoutFactory.fillDefaults().numColumns(2).equalWidth(false).margins(5, 5).spacing(15, 5).applyTo(section);
		GridDataFactory.fillDefaults().grab(true, grabVertical).applyTo(section);
		return section;
	}

	private static Text createTextField(Composite parent, String labelText) {
		Label label = new Label(parent, SWT.LEFT);
		label.setText(labelText);
		GridDataFactory.fillDefaults().align(SWT.LEFT, SWT.CENTER).applyTo(label);

		Text text = new Text(parent, SWT.BORDER);
		GridDataFactory.fillDefaults().grab(true, false).hint(150, SWT.DEFAULT).applyTo(text);

		return text;
	}
}




/*******************************************************************************
 * Copyright (c) 2009 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.jface.examples.databinding.util;

import org.eclipse.core.databinding.editing.DateEditing;
import org.eclipse.core.databinding.editing.IntegerEditing;
import org.eclipse.core.databinding.editing.StringEditing;

import com.ibm.icu.text.DateFormat;
import com.ibm.icu.text.SimpleDateFormat;

/**
 * @since 3.2
 */
public final class EditingFactory {

	private static final String REQUIRED_MESSAGE = "Please specify a value.";

	private static final String INTEGER_PARSE_ERROR_MESSAGE = "The input is invalid.";

	private static final String INTEGER_OUT_OF_RANGE_MESSAGE = "The value lies outside the supported range.";

	private static final String INTEGER_RANGE_MESSAGE = "The value must lie between {0} and {1}.";

	private static final String[] DATE_INPUT_PATTERNS = new String[] {
		"dd.MM.yy",
		"dd/MM/yy",
		"dd.MM.yyyy",
		"dd/MM/yyyy"
	};

	private static final String DATE_DISPLAY_PATTERN = "dd.MM.yyyy";

	private static final String DATE_PARSE_ERROR_MESSAGE = createDateParseErrorMessage(DATE_INPUT_PATTERNS);

	private EditingFactory() {
		// prevent instantiation
	}

	public static StringEditing forString() {
		return StringEditing.stripped(true);
	}

	public static IntegerEditing forInteger() {
		return IntegerEditing
				.withDefaults(INTEGER_PARSE_ERROR_MESSAGE, INTEGER_OUT_OF_RANGE_MESSAGE)
				.requiredMessage(REQUIRED_MESSAGE)
				.rangeMessage(INTEGER_RANGE_MESSAGE);
	}

	public static IntegerEditing forHexInteger(int digits) {
		return IntegerEditing
				.forFormat(RadixNumberFormat.getHexInstance("0x", digits), INTEGER_PARSE_ERROR_MESSAGE, INTEGER_OUT_OF_RANGE_MESSAGE)
				.requiredMessage(REQUIRED_MESSAGE)
				.rangeMessage(INTEGER_RANGE_MESSAGE);
	}

	public static DateEditing forDate() {
		return DateEditing
				.forFormats(
						createDateFormats(DATE_INPUT_PATTERNS),
						DATE_PARSE_ERROR_MESSAGE,
						new SimpleDateFormat(DATE_DISPLAY_PATTERN))
				.requiredMessage(REQUIRED_MESSAGE);
	}

	private static DateFormat[] createDateFormats(String[] datePatterns) {
		DateFormat[] dateFormats = new DateFormat[datePatterns.length];
		for (int i = 0; i < dateFormats.length; i++) {
			dateFormats[i] = new SimpleDateFormat(datePatterns[i]);
		}
		return dateFormats;
	}

	private static String createDateParseErrorMessage(String[] datePatterns) {
		StringBuffer messageSb = new StringBuffer();
		messageSb.append("Supported formats: ");
		for (int i = 0; i < datePatterns.length; i++) {
			if (i > 0) {
				messageSb.append(", ");
			}
			messageSb.append(datePatterns[i]);
		}
		return messageSb.toString();
	}
}




/*******************************************************************************
 * Copyright (c) 2009 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.jface.examples.databinding.util;

import org.eclipse.core.databinding.editing.Editing;
import org.eclipse.core.databinding.observable.map.IObservableMap;
import org.eclipse.core.databinding.util.Policy;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.MultiStatus;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.viewers.CellEditor;
import org.eclipse.jface.viewers.ColumnViewer;
import org.eclipse.jface.viewers.EditingSupport;
import org.eclipse.jface.viewers.TextCellEditor;
import org.eclipse.swt.widgets.Composite;

/**
 * @since 3.2
 */
public class ObservableMapEditingSupport extends EditingSupport {

	private final IObservableMap attributeMap;

	private final Editing editing;

	private final CellEditor cellEditor;

	public ObservableMapEditingSupport(ColumnViewer viewer, IObservableMap attributeMap, Editing editing) {
		super(viewer);
		this.attributeMap = attributeMap;
		this.editing = editing;
		this.cellEditor = new TextCellEditor((Composite) getViewer().getControl());
	}

	protected boolean canEdit(Object element) {
		return true;
	}

	protected CellEditor getCellEditor(Object element) {
		return cellEditor;
	}

	protected Object getValue(Object element) {
		return editing.convertToTarget(attributeMap.get(element));
	}

	protected void setValue(Object element, Object value) {
		MultiStatus validationStatus = new MultiStatus(Policy.JFACE_DATABINDING, 0, null, null);
		Object modelValue = editing.convertToModel(value, validationStatus);
		if (handleValidation(validationStatus)) {
			attributeMap.put(element, modelValue);
		}
	}

	private boolean handleValidation(IStatus validationStatus) {
		if (validationStatus.matches(IStatus.ERROR | IStatus.CANCEL)) {
			MessageDialog.openError(getViewer().getControl().getShell(), "Validation Error", getValidationMessage(validationStatus));
			return false;
		}
		return true;
	}

	private static String getValidationMessage(IStatus validationStatus) {
		if (!validationStatus.isMultiStatus()) {
			return validationStatus.getMessage();
		}

		MultiStatus multiStatus = (MultiStatus) validationStatus;
		StringBuffer sb = new StringBuffer();
		IStatus[] childStatus = multiStatus.getChildren();
		for (int i = 0; i < childStatus.length; i++) {
			if (i > 0) {
				sb.append('\n');
			}
			sb.append(getValidationMessage(childStatus[i]));
		}
		return sb.toString();
	}
}




/*******************************************************************************
 * Copyright (c) 2006, 2009 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.jface.examples.databinding.snippets;

import java.util.Date;

import org.eclipse.core.databinding.Binding;
import org.eclipse.core.databinding.DataBindingContext;
import org.eclipse.core.databinding.beans.BeansObservables;
import org.eclipse.core.databinding.editing.Editing;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.list.WritableList;
import org.eclipse.core.databinding.observable.map.IObservableMap;
import org.eclipse.core.databinding.observable.set.IObservableSet;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.jface.databinding.swt.ISWTObservableValue;
import org.eclipse.jface.databinding.swt.SWTObservables;
import org.eclipse.jface.databinding.viewers.ObservableListContentProvider;
import org.eclipse.jface.databinding.viewers.ViewersObservables;
import org.eclipse.jface.examples.databinding.ModelObject;
import org.eclipse.jface.examples.databinding.util.EditingFactory;
import org.eclipse.jface.examples.databinding.util.ObservableMapEditingCellLabelProvider;
import org.eclipse.jface.examples.databinding.util.ObservableMapEditingSupport;
import org.eclipse.jface.internal.databinding.provisional.fieldassist.ControlDecorationSupport;
import org.eclipse.jface.layout.GridDataFactory;
import org.eclipse.jface.layout.GridLayoutFactory;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.jface.viewers.TableViewerColumn;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.FocusAdapter;
import org.eclipse.swt.events.FocusEvent;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Group;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Text;

public class Snippet036EditingTable {

	private final Editing nameEditing = EditingFactory.forString().required();

	private final Editing ageEditing = EditingFactory.forInteger().required().nonNegative();

	private final Editing bdayEditing = EditingFactory.forDate().before(new Date());

	private DataBindingContext dbc;

	private TableViewer tableViewer;

	public static void main(String[] args) {
		Display display = new Display();

		Realm.runWithDefault(SWTObservables.getRealm(display), new Runnable() {
			public void run() {
				Shell shell = new Snippet036EditingTable().createShell();
				Display display = Display.getCurrent();
				while (!shell.isDisposed()) {
					if (!display.readAndDispatch()) {
						display.sleep();
					}
				}
			}
		});
	}

	private Shell createShell() {
		Display display = Display.getCurrent();
		Shell shell = new Shell(display);
		shell.setText("Editing");
		shell.setLayout(new GridLayout(2, false));

		dbc = new DataBindingContext();

		createTableSection(shell);
		createFieldSection(shell);

		shell.pack();
		shell.open();

		return shell;
	}

	private void createTableSection(Composite parent) {
		Group section = createSectionGroup(parent, 1);

		tableViewer = new TableViewer(section, SWT.SINGLE | SWT.H_SCROLL | SWT.V_SCROLL | SWT.BORDER | SWT.FULL_SELECTION);
		GridDataFactory.fillDefaults().grab(true, true).hint(350, 250).applyTo(tableViewer.getTable());
		tableViewer.getTable().setHeaderVisible(true);
		tableViewer.getTable().setLinesVisible(true);

		ObservableListContentProvider contentProvider = new ObservableListContentProvider();
		tableViewer.setContentProvider(contentProvider);
		IObservableSet contentElements = contentProvider.getKnownElements();

		IObservableMap nameMap = BeansObservables.observeMap(contentElements, "name");
		createColumn("Name*", 150, nameMap, nameEditing);

		IObservableMap ageMap = BeansObservables.observeMap(contentElements, "age");
		createColumn("Age*", 50, ageMap, ageEditing);

		IObservableMap bdayMap = BeansObservables.observeMap(contentElements, "birthday");
		createColumn("Birthday", 80, bdayMap, bdayEditing);

		WritableList people = new WritableList();
		people.add(new Person("John Doe", 27));
		people.add(new Person("Steve Northover", 33));
		people.add(new Person("Grant Gayed", 54));
		people.add(new Person("Veronika Irvine", 25));
		people.add(new Person("Mike Wilson", 44));
		people.add(new Person("Christophe Cornu", 37));
		people.add(new Person("Lynne Kues", 65));
		people.add(new Person("Silenio Quarti", 15));

		tableViewer.setInput(people);

		tableViewer.setSelection(new StructuredSelection(people.get(0)));
	}

	private TableViewerColumn createColumn(String text, int width, IObservableMap attributeMap, Editing modelEditing) {
		TableViewerColumn column = new TableViewerColumn(tableViewer, SWT.NONE);
		column.getColumn().setText(text);
		column.getColumn().setWidth(width);
		column.setLabelProvider(new ObservableMapEditingCellLabelProvider(attributeMap, modelEditing));
		column.setEditingSupport(new ObservableMapEditingSupport(tableViewer, attributeMap, modelEditing));
		return column;
	}

	private void createFieldSection(Composite parent) {
		final Group section = createSectionGroup(parent, 2);

		final IObservableValue personObservable = ViewersObservables.observeSingleSelection(tableViewer);

		Text nameText = createTextField(section, "Name*");
		IObservableValue nameObservable = BeansObservables.observeDetailValue(personObservable, "name", null);
		bindTextField(nameText, nameObservable, nameEditing);

		Text ageText = createTextField(section, "Age*");
		IObservableValue ageObservable = BeansObservables.observeDetailValue(personObservable, "age", null);
		bindTextField(ageText, ageObservable, ageEditing);

		Text bdayText = createTextField(section, "Birthday");
		IObservableValue bdayObservable = BeansObservables.observeDetailValue(personObservable, "birthday", null);
		bindTextField(bdayText, bdayObservable, bdayEditing);
	}

	private Binding bindTextField(
			Text text,
			IObservableValue modelValue,
			Editing editing) {
		// Create the binding using the editing object.
		ISWTObservableValue textObservable = SWTObservables.observeText(text, SWT.Modify);
		Binding binding = dbc.bindValue(
				textObservable,
				modelValue,
				editing.createTargetValueStrategy(),
				editing.createModelValueStrategy());

		// Decorate the control with the validation status.
		ControlDecorationSupport.create(binding, SWT.TOP);

		formatOnFocusOut(text, binding);

		return binding;
	}

	private static void formatOnFocusOut(final Control control, final Binding binding) {
		control.addFocusListener(new FocusAdapter() {
			public void focusLost(FocusEvent e) {
				IStatus dateValidationStatus = (IStatus) binding.getValidationStatus().getValue();
				if (dateValidationStatus.isOK()) {
					binding.updateModelToTarget();
				}
			}
		});
	}

	private Group createSectionGroup(Composite parent, int numColumns) {
		Group section = new Group(parent, SWT.SHADOW_ETCHED_IN);
		GridLayoutFactory.fillDefaults().numColumns(numColumns).equalWidth(false).margins(5, 5).spacing(15, 5).applyTo(section);
		GridDataFactory.fillDefaults().grab(true, true).applyTo(section);
		return section;
	}

	private static Text createTextField(Composite parent, String labelText) {
		Label label = new Label(parent, SWT.LEFT);
		label.setText(labelText);
		GridDataFactory.fillDefaults().align(SWT.LEFT, SWT.CENTER).applyTo(label);

		Text text = new Text(parent, SWT.BORDER);
		GridDataFactory.fillDefaults().grab(true, false).hint(200, SWT.DEFAULT).applyTo(text);

		return text;
	}

	private static final class Person extends ModelObject {

		private String name;

		private int age;

		private Date birthday;

		public Person(String name, int age) {
			this.name = name;
			this.age = age;
		}

		public String getName() {
			return name;
		}

		public void setName(String name) {
			firePropertyChange("name", this.name, this.name = name);
		}

		public int getAge() {
			return age;
		}

		public void setAge(int age) {
			firePropertyChange("age", this.age, this.age = age);
		}

		public Date getBirthday() {
			return birthday;
		}

		public void setBirthday(Date birthday) {
			firePropertyChange("birthday", this.birthday, this.birthday = birthday);
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2009 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.jface.examples.databinding.util;

import java.math.BigInteger;
import java.text.FieldPosition;
import java.text.ParsePosition;

import com.ibm.icu.math.BigDecimal;
import com.ibm.icu.text.NumberFormat;

/**
 * @since 3.2
 *
 */
public class RadixNumberFormat extends NumberFormat {

	private static final long serialVersionUID = 411884077848863891L;

	private final int radix;

	private final String prefix;

	private final int digits;

	private RadixNumberFormat(int radix, String prefix, int digits) {
		this.radix = radix;
		this.prefix = prefix != null ? prefix : "";
		this.digits = digits;
	}

	public static RadixNumberFormat getHexInstance() {
		return getHexInstance(null, 0);
	}

	public static RadixNumberFormat getHexInstance(String prefix, int digits) {
		return new RadixNumberFormat(16, prefix, digits);
	}

	public StringBuffer format(double number, StringBuffer toAppendTo,
			FieldPosition pos) {
		// TODO omallo: Is this necessary due to a bug in NumberFormat.format(Object, ...)?
		return format((long) number, toAppendTo, pos);
	}

	public StringBuffer format(long number, StringBuffer toAppendTo,
			FieldPosition pos) {
		return toAppendTo.append(prefix).append(addPadding(Long.toString(number, radix)));
	}

	public StringBuffer format(BigInteger number, StringBuffer toAppendTo,
			FieldPosition pos) {
		return toAppendTo.append(prefix).append(addPadding(number.toString(radix)));
	}

	public StringBuffer format(BigDecimal number, StringBuffer toAppendTo,
			FieldPosition pos) {
		throw new UnsupportedOperationException();
	}

	public Number parse(String text, ParsePosition parsePosition) {
		if (text.length() == 0) {
			return null;
		}

		parsePosition.setIndex(parsePosition.getIndex() + text.length());

		try {
			if (text.startsWith(prefix)) {
				return Integer.parseInt(text.substring(prefix.length()), radix);
			}
			return Integer.parseInt(text, radix);
		} catch (NumberFormatException e) {
			parsePosition.setErrorIndex(0);
			return null;
		}
	}

	private String addPadding(String numberText) {
		if (numberText.length() >= digits) {
			return numberText;
		}

		StringBuffer sb = new StringBuffer();
		for (int i = numberText.length(); i < digits; i++) {
			sb.append('0');
		}
		sb.append(numberText);
		return sb.toString();
	}
}




/*******************************************************************************
 * Copyright (c) 2009 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.jface.examples.databinding.util;

import org.eclipse.core.databinding.editing.Editing;
import org.eclipse.core.databinding.observable.map.IObservableMap;
import org.eclipse.jface.databinding.viewers.ObservableMapCellLabelProvider;
import org.eclipse.jface.viewers.ViewerCell;

/**
 * @since 3.2
 */
public class ObservableMapEditingCellLabelProvider extends
		ObservableMapCellLabelProvider {

	private final IObservableMap attributeMap;

	private final Editing editing;

	public ObservableMapEditingCellLabelProvider(IObservableMap attributeMap, Editing editing) {
		super(attributeMap);
		this.attributeMap = attributeMap;
		this.editing = editing;
	}

	public void update(ViewerCell cell) {
		Object element = cell.getElement();
		Object attribute = attributeMap.get(element);
		cell.setText((String) editing.convertToTarget(attribute));
	}
}

Return to bug 183055

Lines 15-27 Link Here

(-)src/org/eclipse/core/internal/databinding/conversion/StringToDateConverter.java (-2 / +20 lines)
15		15
16	import org.eclipse.core.databinding.conversion.IConverter;	16	import org.eclipse.core.databinding.conversion.IConverter;
17		17
		18	import com.ibm.icu.text.DateFormat;
18		19
19	/**	20	/**
20	* Convert a String to a java.util.Date, respecting the current locale	21	* Convert a String to a java.util.Date, respecting the current locale
21	*	22	*
22	* @since 1.0	23	* @since 1.0
23	*/	24	*/
24	public class StringToDateConverter extends DateConversionSupport implements IConverter {	25	public class StringToDateConverter extends DateConversionSupport implements
		26	IConverter {
		27
		28	/**
		29	*
		30	*/
		31	public StringToDateConverter() {
		32	super();
		33	}
		34
		35	/**
		36	*
		37	* @param formats
		38	*/
		39	public StringToDateConverter(DateFormat[] formats) {
		40	super(formats);
		41	}
		42
25	public Object convert(Object source) {	43	public Object convert(Object source) {
26	return parse(source.toString());	44	return parse(source.toString());
27	}	45	}
Lines 32-36 Link Here
32		50
33	public Object getToType() {	51	public Object getToType() {
34	return Date.class;	52	return Date.class;
35	}	53	}
36	}	54	}

Lines 31-115 Link Here

(-)src/org/eclipse/core/internal/databinding/conversion/DateConversionSupport.java (-45 / +68 lines)
31	* </p>	31	* </p>
32	*/	32	*/
33	public abstract class DateConversionSupport {	33	public abstract class DateConversionSupport {
34	private final static int DATE_FORMAT=DateFormat.SHORT;	34	private final static int DATE_FORMAT = DateFormat.SHORT;
35	private final static int DEFAULT_FORMATTER_INDEX=0;	35	private final static int DEFAULT_FORMATTER_INDEX = 0;
36		36
37	private final static int NUM_VIRTUAL_FORMATTERS=1;	37	private final static int NUM_VIRTUAL_FORMATTERS = 1;
38		38
39	/**	39	/**
40	* Alternative formatters for date, time and date/time.	40	* Alternative formatters for date, time and date/time. Raw milliseconds are
41	* Raw milliseconds are covered as a special case.	41	* covered as a special case.
42	*/	42	*/
43	// TODO: These could be shared, but would have to be synchronized.	43	private final DateFormat[] formatters;
44	private DateFormat[] formatters = {	44
45	new SimpleDateFormat(BindingMessages.getString(BindingMessages.DATE_FORMAT_DATE_TIME)),	45	/**
46	new SimpleDateFormat(BindingMessages.getString(BindingMessages.DATEFORMAT_TIME)),	46	*
47	DateFormat.getDateTimeInstance(DATE_FORMAT, DateFormat.SHORT),	47	*/
48	DateFormat.getDateInstance(DATE_FORMAT),	48	public DateConversionSupport() {
49	DateFormat.getTimeInstance(DateFormat.SHORT),	49	// TODO: These could be shared, but would have to be synchronized.
50	DateFormat.getDateTimeInstance(DATE_FORMAT,DateFormat.MEDIUM),	50	this(new DateFormat[] {
51	DateFormat.getTimeInstance(DateFormat.MEDIUM)	51	new SimpleDateFormat(BindingMessages
52	};	52	.getString(BindingMessages.DATE_FORMAT_DATE_TIME)),
		53	new SimpleDateFormat(BindingMessages
		54	.getString(BindingMessages.DATEFORMAT_TIME)),
		55	DateFormat.getDateTimeInstance(DATE_FORMAT, DateFormat.SHORT),
		56	DateFormat.getDateInstance(DATE_FORMAT),
		57	DateFormat.getTimeInstance(DateFormat.SHORT),
		58	DateFormat.getDateTimeInstance(DATE_FORMAT, DateFormat.MEDIUM),
		59	DateFormat.getTimeInstance(DateFormat.MEDIUM) });
		60	}
		61
		62	/**
		63	*
		64	* @param formats
		65	*/
		66	public DateConversionSupport(DateFormat[] formats) {
		67	this.formatters = formats;
		68	}
53		69
54	/**	70	/**
55	* Tries all available formatters to parse the given string according to the	71	* Tries all available formatters to parse the given string according to the
56	* default locale or as a raw millisecond value and returns the result of the	72	* default locale or as a raw millisecond value and returns the result of
57	* first successful run.	73	* the first successful run.
58	*	74	*
59	* @param str A string specifying a date according to the default locale or in raw milliseconds	75	* @param str
60	* @return The parsed date, or null, if no available formatter could interpret the input string	76	* A string specifying a date according to the default locale or
		77	* in raw milliseconds
		78	* @return The parsed date, or null, if no available formatter could
		79	* interpret the input string
61	*/	80	*/
62	protected Date parse(String str) {	81	protected Date parse(String str) {
63	for (int formatterIdx = 0; formatterIdx < formatters.length; formatterIdx++) {	82	for (int formatterIdx = 0; formatterIdx < formatters.length; formatterIdx++) {
64	Date parsed=parse(str,formatterIdx);	83	Date parsed = parse(str, formatterIdx);
65	if(parsed!=null) {	84	if (parsed != null) {
66	return parsed;	85	return parsed;
67	}	86	}
68	}	87	}
69	return null;	88	return null;
70	}	89	}
71		90
72	protected Date parse(String str,int formatterIdx) {	91	protected Date parse(String str, int formatterIdx) {
73	if(formatterIdx>=0) {	92	if (formatterIdx >= 0) {
74	ParsePosition pos=new ParsePosition(0);	93	ParsePosition pos = new ParsePosition(0);
75	if (str == null) {	94	if (str == null) {
76	return null;	95	return null;
77	}	96	}
78	Date date=formatters[formatterIdx].parse(str,pos);	97	Date date = formatters[formatterIdx].parse(str, pos);
79	if(pos.getErrorIndex()!=-1\|\|pos.getIndex()!=str.length()) {	98	if (pos.getErrorIndex() != -1 \|\| pos.getIndex() != str.length()) {
80	return null;	99	return null;
81	}	100	}
82	return date;	101	return date;
83	}	102	}
84	try {	103	try {
85	long millisecs=Long.parseLong(str);	104	long millisecs = Long.parseLong(str);
86	return new Date(millisecs);	105	return new Date(millisecs);
87	}	106	} catch (NumberFormatException exc) {
88	catch(NumberFormatException exc) {
89	}	107	}
90	return null;	108	return null;
91	}	109	}
92		110
93	/**	111	/**
94	* Formats the given date with the default formatter according to the default locale.	112	* Formats the given date with the default formatter according to the
95	* @param date a date	113	* default locale.
96	* @return a string representation of the given date according to the default locale	114	*
		115	* @param date
		116	* a date
		117	* @return a string representation of the given date according to the
		118	* default locale
97	*/	119	*/
98	protected String format(Date date) {	120	protected String format(Date date) {
99	return format(date,DEFAULT_FORMATTER_INDEX);	121	return format(date, DEFAULT_FORMATTER_INDEX);
100	}	122	}
101		123
102	protected String format(Date date,int formatterIdx) {	124	protected String format(Date date, int formatterIdx) {
103	if (date == null)	125	if (date == null)
104	return null;	126	return null;
105	if(formatterIdx>=0) {	127	if (formatterIdx >= 0) {
106	return formatters[formatterIdx].format(date);	128	return formatters[formatterIdx].format(date);
107	}	129	}
108	return String.valueOf(date.getTime());	130	return String.valueOf(date.getTime());
109	}	131	}
110		132
111	protected int numFormatters() {	133	protected int numFormatters() {
112	return formatters.length+NUM_VIRTUAL_FORMATTERS;	134	return formatters.length + NUM_VIRTUAL_FORMATTERS;
113	}	135	}
114		136
115	/**	137	/**
Lines 118-130 Link Here
118	* This is for testing purposes only and should not be a part of the API if	140	* This is for testing purposes only and should not be a part of the API if
119	* this class was to be exposed.	141	* this class was to be exposed.
120	* </p>	142	* </p>
121	*	143	*
122	* @param index	144	* @param index
123	* @return date format	145	* @return date format
124	*/	146	*/
125	protected DateFormat getDateFormat(int index) {	147	protected DateFormat getDateFormat(int index) {
126	if (index < 0 \|\| index >= formatters.length) {	148	if (index < 0 \|\| index >= formatters.length) {
127	throw new IllegalArgumentException("'index' [" + index + "] is out of bounds."); //$NON-NLS-1$//$NON-NLS-2$	149	throw new IllegalArgumentException(
		150	"'index' [" + index + "] is out of bounds."); //$NON-NLS-1$//$NON-NLS-2$
128	}	151	}
129		152
130	return formatters[index];	153	return formatters[index];

Lines 21-27 Link Here

(-)src/org/eclipse/core/internal/databinding/conversion/StringToNumberParser.java (-35 / +58 lines)
21		21
22	/**	22	/**
23	* Utility class for the parsing of strings to numbers.	23	* Utility class for the parsing of strings to numbers.
24	*	24	*
25	* @since 1.0	25	* @since 1.0
26	*/	26	*/
27	public class StringToNumberParser {	27	public class StringToNumberParser {
Lines 73-79 Link Here
73		73
74	/**	74	/**
75	* The result of a parse operation.	75	* The result of a parse operation.
76	*	76	*
77	* @since 1.0	77	* @since 1.0
78	*/	78	*/
79	public static class ParseResult {	79	public static class ParseResult {
Lines 84-90 Link Here
84	* The number as a result of the conversion. <code>null</code> if the	84	* The number as a result of the conversion. <code>null</code> if the
85	* value could not be converted or if the type is not a primitive and	85	* value could not be converted or if the type is not a primitive and
86	* the value was an empty string.	86	* the value was an empty string.
87	*	87	*
88	* @return number	88	* @return number
89	*/	89	*/
90	public Number getNumber() {	90	public Number getNumber() {
Lines 94-100 Link Here
94	/**	94	/**
95	* ParsePosition if an error occurred while parsing. <code>null</code>	95	* ParsePosition if an error occurred while parsing. <code>null</code>
96	* if no error occurred.	96	* if no error occurred.
97	*	97	*
98	* @return parse position	98	* @return parse position
99	*/	99	*/
100	public ParsePosition getPosition() {	100	public ParsePosition getPosition() {
Lines 104-110 Link Here
104		104
105	/**	105	/**
106	* Formats an appropriate message for a parsing error.	106	* Formats an appropriate message for a parsing error.
107	*	107	*
108	* @param value	108	* @param value
109	* @param position	109	* @param position
110	* @return message	110	* @return message
Lines 115-138 Link Here
115	.getErrorIndex() : position.getIndex();	115	.getErrorIndex() : position.getIndex();
116		116
117	if (errorIndex < value.length()) {	117	if (errorIndex < value.length()) {
118	return BindingMessages.formatString(BindingMessages.VALIDATE_NUMBER_PARSE_ERROR,	118	return BindingMessages.formatString(
119	new Object[] { value, new Integer(errorIndex + 1),	119	BindingMessages.VALIDATE_NUMBER_PARSE_ERROR, new Object[] {
		120	value, new Integer(errorIndex + 1),
120	new Character(value.charAt(errorIndex)) });	121	new Character(value.charAt(errorIndex)) });
121	}	122	}
122	return BindingMessages.formatString(BindingMessages.VALIDATE_NUMBER_PARSE_ERROR_NO_CHARACTER,	123	return BindingMessages.formatString(
		124	BindingMessages.VALIDATE_NUMBER_PARSE_ERROR_NO_CHARACTER,
123	new Object[] { value, new Integer(errorIndex + 1) });	125	new Object[] { value, new Integer(errorIndex + 1) });
124	}	126	}
125		127
126	/**	128	/**
127	* Formats an appropriate message for an out of range error.	129	* Formats an appropriate message for an out of range error.
128	*	130	*
129	* @param minValue	131	* @param minValue
130	* @param maxValue	132	* @param maxValue
131	* @param numberFormat when accessed method synchronizes on instance	133	* @param numberFormat
		134	* when accessed method synchronizes on instance
132	* @return message	135	* @return message
133	*/	136	*/
134	public static String createOutOfRangeMessage(Number minValue,	137	public static String createOutOfRangeMessage(Number minValue,
135	Number maxValue, NumberFormat numberFormat) {	138	Number maxValue, NumberFormat numberFormat) {
		139	return createOutOfRangeMessage(
		140	BindingMessages.getString("Validate_NumberOutOfRangeError"), minValue, maxValue, numberFormat); //$NON-NLS-1$
		141	}
		142
		143	/**
		144	* Formats an appropriate message for an out of range error.
		145	*
		146	* @param message
		147	* @param minValue
		148	* @param maxValue
		149	* @param numberFormat
		150	* when accessed method synchronizes on instance
		151	* @return message
		152	*/
		153	public static String createOutOfRangeMessage(String message,
		154	Number minValue, Number maxValue, NumberFormat numberFormat) {
136	String min = null;	155	String min = null;
137	String max = null;	156	String max = null;
138		157
Lines 141-154 Link Here
141	max = numberFormat.format(maxValue);	160	max = numberFormat.format(maxValue);
142	}	161	}
143		162
144	return BindingMessages.formatString(	163	return BindingMessages.formatStringValue(message, new Object[] { min,
145	"Validate_NumberOutOfRangeError", new Object[] { min, max }); //$NON-NLS-1$	164	max });
146	}	165	}
147		166
148	/**	167	/**
149	* Returns <code>true</code> if the provided <code>number</code> is in	168	* Returns <code>true</code> if the provided <code>number</code> is in the
150	* the range of a integer.	169	* range of a integer.
151	*	170	*
152	* @param number	171	* @param number
153	* @return <code>true</code> if a valid integer	172	* @return <code>true</code> if a valid integer
154	* @throws IllegalArgumentException	173	* @throws IllegalArgumentException
Lines 160-168 Link Here
160		179
161	/**	180	/**
162	* Validates the range of the provided <code>number</code>.	181	* Validates the range of the provided <code>number</code>.
163	*	182	*
164	* @param number	183	* @param number
165	* @param bitLength number of bits allowed to be in range	184	* @param bitLength
		185	* number of bits allowed to be in range
166	* @return <code>true</code> if in range	186	* @return <code>true</code> if in range
167	*/	187	*/
168	private static boolean checkInteger(Number number, int bitLength) {	188	private static boolean checkInteger(Number number, int bitLength) {
Lines 202-210 Link Here
202	}	222	}
203		223
204	/**	224	/**
205	* Returns <code>true</code> if the provided <code>number</code> is in	225	* Returns <code>true</code> if the provided <code>number</code> is in the
206	* the range of a long.	226	* range of a long.
207	*	227	*
208	* @param number	228	* @param number
209	* @return <code>true</code> if in range	229	* @return <code>true</code> if in range
210	* @throws IllegalArgumentException	230	* @throws IllegalArgumentException
Lines 215-233 Link Here
215	}	235	}
216		236
217	/**	237	/**
218	* Returns <code>true</code> if the provided <code>number</code> is in	238	* Returns <code>true</code> if the provided <code>number</code> is in the
219	* the range of a float.	239	* range of a float.
220	*	240	*
221	* @param number	241	* @param number
222	* @return <code>true</code> if in range	242	* @return <code>true</code> if in range
223	* @throws IllegalArgumentException	243	* @throws IllegalArgumentException
224	* if the number type is unsupported	244	* if the number type is unsupported
225	*/	245	*/
226	public static boolean inFloatRange(Number number) {	246	public static boolean inFloatRange(Number number) {
227	return checkDecimal(number, FLOAT_MIN_BIG_DECIMAL, FLOAT_MAX_BIG_DECIMAL);	247	return checkDecimal(number, FLOAT_MIN_BIG_DECIMAL,
		248	FLOAT_MAX_BIG_DECIMAL);
228	}	249	}
229		250
230	private static boolean checkDecimal(Number number, BigDecimal min, BigDecimal max) {	251	private static boolean checkDecimal(Number number, BigDecimal min,
		252	BigDecimal max) {
231	BigDecimal bigDecimal = null;	253	BigDecimal bigDecimal = null;
232	if (number instanceof Integer \|\| number instanceof Long) {	254	if (number instanceof Integer \|\| number instanceof Long) {
233	bigDecimal = new BigDecimal(number.doubleValue());	255	bigDecimal = new BigDecimal(number.doubleValue());
Lines 265-286 Link Here
265	}	287	}
266		288
267	/**	289	/**
268	* Returns <code>true</code> if the provided <code>number</code> is in	290	* Returns <code>true</code> if the provided <code>number</code> is in the
269	* the range of a double.	291	* range of a double.
270	*	292	*
271	* @param number	293	* @param number
272	* @return <code>true</code> if in range	294	* @return <code>true</code> if in range
273	* @throws IllegalArgumentException	295	* @throws IllegalArgumentException
274	* if the number type is unsupported	296	* if the number type is unsupported
275	*/	297	*/
276	public static boolean inDoubleRange(Number number) {	298	public static boolean inDoubleRange(Number number) {
277	return checkDecimal(number, DOUBLE_MIN_BIG_DECIMAL, DOUBLE_MAX_BIG_DECIMAL);	299	return checkDecimal(number, DOUBLE_MIN_BIG_DECIMAL,
		300	DOUBLE_MAX_BIG_DECIMAL);
278	}	301	}
279		302
280	/**	303	/**
281	* Returns <code>true</code> if the provided <code>number</code> is in	304	* Returns <code>true</code> if the provided <code>number</code> is in the
282	* the range of a short.	305	* range of a short.
283	*	306	*
284	* @param number	307	* @param number
285	* @return <code>true</code> if in range	308	* @return <code>true</code> if in range
286	*/	309	*/
Lines 289-297 Link Here
289	}	312	}
290		313
291	/**	314	/**
292	* Returns <code>true</code> if the provided <code>number</code> is in	315	* Returns <code>true</code> if the provided <code>number</code> is in the
293	* the range of a byte.	316	* range of a byte.
294	*	317	*
295	* @param number	318	* @param number
296	* @return <code>true</code> if in range	319	* @return <code>true</code> if in range
297	*/	320	*/

Added Link Here

(-)src/org/eclipse/core/internal/databinding/validation/DateRangeValidator.java (+177 lines)
1	/*******************************************************************************
2	* Copyright (c) 2009 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.internal.databinding.validation;
13
14	import java.text.MessageFormat;
15	import java.util.Date;
16
17	import org.eclipse.core.databinding.validation.IValidator;
18	import org.eclipse.core.databinding.validation.ValidationStatus;
19	import org.eclipse.core.runtime.IStatus;
20
21	import com.ibm.icu.text.DateFormat;
22
23	/**
24	* @since 1.3
25	*/
26	public class DateRangeValidator implements IValidator {
27
28	private static final int UNDEFINED = -1;
29	private static final int AFTER = 0;
30	private static final int AFTER_EQUAL = 1;
31	private static final int BEFORE = 2;
32	private static final int BEFORE_EQUAL = 3;
33
34	// TODO: Externalize
35	private static final String AFTER_MESSAGE = "The date must be after {0}."; //$NON-NLS-1$
36	private static final String AFTER_EQUAL_MESSAGE = "The date must be after or on {0}."; //$NON-NLS-1$
37	private static final String BEFORE_MESSAGE = "The date must be before {0}."; //$NON-NLS-1$
38	private static final String BEFORE_EQUAL_MESSAGE = "The date must be before or on {0}."; //$NON-NLS-1$
39	private static final String WITHIN_RANGE_MESSAGE = "The date must lie between {0} and {1}."; //$NON-NLS-1$
40
41	private final Date min;
42	private final Date max;
43	private final int minConstraint;
44	private final int maxConstraint;
45	private final String validationMessage;
46	private final DateFormat format;
47
48	/**
49	*
50	* @param min
51	* @param max
52	* @param minConstraint
53	* @param maxConstraint
54	* @param validationMessage
55	* @param format
56	*/
57	private DateRangeValidator(Date min, Date max, int minConstraint,
58	int maxConstraint, String validationMessage, DateFormat format) {
59	this.min = min;
60	this.max = max;
61	this.minConstraint = minConstraint;
62	this.maxConstraint = maxConstraint;
63	this.validationMessage = validationMessage;
64	this.format = format;
65	}
66
67	/**
68	*
69	* @param min
70	* @param validationMessage
71	* @param format
72	* @return .
73	*/
74	public static DateRangeValidator after(Date min, String validationMessage,
75	DateFormat format) {
76	return new DateRangeValidator(min, null, AFTER, UNDEFINED,
77	defaultIfNull(validationMessage, AFTER_MESSAGE), format);
78	}
79
80	/**
81	*
82	* @param min
83	* @param validationMessage
84	* @param format
85	* @return .
86	*/
87	public static DateRangeValidator afterEqual(Date min,
88	String validationMessage, DateFormat format) {
89	return new DateRangeValidator(min, null, AFTER_EQUAL, UNDEFINED,
90	defaultIfNull(validationMessage, AFTER_EQUAL_MESSAGE), format);
91	}
92
93	/**
94	*
95	* @param max
96	* @param validationMessage
97	* @param format
98	* @return .
99	*/
100	public static DateRangeValidator before(Date max, String validationMessage,
101	DateFormat format) {
102	return new DateRangeValidator(null, max, UNDEFINED, BEFORE,
103	defaultIfNull(validationMessage, BEFORE_MESSAGE), format);
104	}
105
106	/**
107	*
108	* @param max
109	* @param validationMessage
110	* @param format
111	* @return .
112	*/
113	public static DateRangeValidator beforeEqual(Date max,
114	String validationMessage, DateFormat format) {
115	return new DateRangeValidator(null, max, UNDEFINED, BEFORE_EQUAL,
116	defaultIfNull(validationMessage, BEFORE_EQUAL_MESSAGE), format);
117	}
118
119	/**
120	*
121	* @param min
122	* @param max
123	* @param validationMessage
124	* @param format
125	* @return .
126	*/
127	public static DateRangeValidator range(Date min, Date max,
128	String validationMessage, DateFormat format) {
129	return new DateRangeValidator(min, max, AFTER_EQUAL, BEFORE_EQUAL,
130	defaultIfNull(validationMessage, WITHIN_RANGE_MESSAGE), format);
131	}
132
133	public IStatus validate(Object value) {
134	if (value != null) {
135	Date date = (Date) value;
136	if ((min != null && !fulfillsConstraint(date, min, minConstraint))
137	\|\| (max != null && !fulfillsConstraint(date, max,
138	maxConstraint))) {
139	// TODO: Cache message?
140	return ValidationStatus.error(MessageFormat.format(
141	validationMessage, getFormattedRangeExtremas()));
142	}
143	}
144	return ValidationStatus.ok();
145	}
146
147	private boolean fulfillsConstraint(Date date1, Date date2, int constraint) {
148	switch (constraint) {
149	case AFTER:
150	return date1.after(date2);
151	case AFTER_EQUAL:
152	return date1.after(date2) \|\| date1.equals(date2);
153	case BEFORE:
154	return date1.before(date2);
155	case BEFORE_EQUAL:
156	return date1.before(date2) \|\| date1.equals(date2);
157	case UNDEFINED:
158	default:
159	throw new IllegalArgumentException(
160	"Unsupported constraint: " + constraint); //$NON-NLS-1$
161	}
162	}
163
164	private String[] getFormattedRangeExtremas() {
165	// TODO: Synchronize formatting to make it thread safe?
166	if (min == null) {
167	return new String[] { format.format(max) };
168	} else if (max == null) {
169	return new String[] { format.format(min) };
170	}
171	return new String[] { format.format(min), format.format(max) };
172	}
173
174	private static String defaultIfNull(String string, String defaultString) {
175	return (string != null) ? string : defaultString;
176	}
177	}

Added Link Here

(-)src/org/eclipse/core/databinding/editing/StringEditing.java (+119 lines)
1	/*******************************************************************************
2	* Copyright (c) 2009 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.editing;
13
14	import java.util.regex.Pattern;
15
16	import org.eclipse.core.databinding.conversion.IConverter;
17	import org.eclipse.core.internal.databinding.conversion.StringStripConverter;
18	import org.eclipse.core.internal.databinding.validation.NonNullValidator;
19	import org.eclipse.core.internal.databinding.validation.StringRegexValidator;
20
21	/**
22	* @since 1.3
23	*/
24	public final class StringEditing extends Editing {
25
26	private String requiredMessage = null;
27
28	private String matchesMessage = null;
29
30	private StringEditing(IConverter targetConverter) {
31	setTargetConverter(targetConverter);
32	}
33
34	/**
35	* Creates a new editing object for strings which performs no validation or
36	* conversion.
37	*
38	* @return The new editing object which performs no validation or
39	* conversion.
40	*/
41	public static StringEditing withDefaults() {
42	return new StringEditing(null);
43	}
44
45	/**
46	* Creates a new editing object which strips whitespace from both ends of
47	* the input string.
48	*
49	* @param stripToNull
50	* Whether to convert the input string to <code>null</code> in
51	* case stripping the input string results in an empty string.
52	* @return The new editing object which strips whitespace from both ends of
53	* the input string.
54	*/
55	public static StringEditing stripped(boolean stripToNull) {
56	return new StringEditing(new StringStripConverter(stripToNull));
57	}
58
59	/**
60	* Adds a model validator ensuring that the parsed integer is not
61	* <code>null</code>. Uses the current {@link #requiredMessage(String)
62	* validation message}.
63	*
64	* @return This editing instance for method chaining.
65	*/
66	public StringEditing required() {
67	addModelValidator(new NonNullValidator(requiredMessage));
68	return this;
69	}
70
71	/**
72	* Sets the validation message to be issued in case the input string is
73	* <code>null</code>.
74	*
75	* @param message
76	* The validation message to be issued in case the input string
77	* is <code>null</code>.
78	* @return This editing instance for method chaining.
79	*
80	* @see #required()
81	*/
82	public StringEditing requiredMessage(String message) {
83	this.requiredMessage = message;
84	return this;
85	}
86
87	/**
88	* Adds a model validator ensuring that the input string
89	* {@link Pattern#matches(String, CharSequence) matches} the given regular
90	* expression . Uses the current {@link #matchesMessage(String) validation
91	* message}.
92	*
93	* @param regex
94	* The regular expression which the input string must match.
95	* @return This editing instance for method chaining.
96	*
97	* @see Pattern#matches(String, CharSequence)
98	*/
99	public StringEditing matches(String regex) {
100	addModelValidator(new StringRegexValidator(regex, matchesMessage));
101	return this;
102	}
103
104	/**
105	* Sets the validation message to be issued in case the input string does
106	* not match a given regular expression.
107	*
108	* @param message
109	* The validation message to be issued in case the input string
110	* does not match a given regular expression.
111	* @return This editing instance for method chaining.
112	*
113	* @see #matches(String)
114	*/
115	public StringEditing matchesMessage(String message) {
116	this.matchesMessage = message;
117	return this;
118	}
119	}

Added Link Here

(-)src/org/eclipse/jface/examples/databinding/snippets/Snippet035Editing.java (+218 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006, 2009 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.jface.examples.databinding.snippets;
13
14	import java.util.Calendar;
15	import java.util.Date;
16
17	import org.eclipse.core.databinding.Binding;
18	import org.eclipse.core.databinding.DataBindingContext;
19	import org.eclipse.core.databinding.editing.Editing;
20	import org.eclipse.core.databinding.observable.Realm;
21	import org.eclipse.core.databinding.observable.list.WritableList;
22	import org.eclipse.core.databinding.observable.value.IObservableValue;
23	import org.eclipse.core.databinding.observable.value.WritableValue;
24	import org.eclipse.core.runtime.IStatus;
25	import org.eclipse.jface.databinding.swt.ISWTObservableValue;
26	import org.eclipse.jface.databinding.swt.SWTObservables;
27	import org.eclipse.jface.databinding.viewers.ObservableListContentProvider;
28	import org.eclipse.jface.examples.databinding.util.EditingFactory;
29	import org.eclipse.jface.internal.databinding.provisional.fieldassist.ControlDecorationSupport;
30	import org.eclipse.jface.layout.GridDataFactory;
31	import org.eclipse.jface.layout.GridLayoutFactory;
32	import org.eclipse.jface.viewers.LabelProvider;
33	import org.eclipse.jface.viewers.ListViewer;
34	import org.eclipse.swt.SWT;
35	import org.eclipse.swt.events.FocusAdapter;
36	import org.eclipse.swt.events.FocusEvent;
37	import org.eclipse.swt.events.SelectionAdapter;
38	import org.eclipse.swt.events.SelectionEvent;
39	import org.eclipse.swt.layout.GridLayout;
40	import org.eclipse.swt.widgets.Composite;
41	import org.eclipse.swt.widgets.Control;
42	import org.eclipse.swt.widgets.Display;
43	import org.eclipse.swt.widgets.Group;
44	import org.eclipse.swt.widgets.Label;
45	import org.eclipse.swt.widgets.Shell;
46	import org.eclipse.swt.widgets.Text;
47
48	public class Snippet035Editing {
49
50	private static final String EMAIL_REGEX = "\\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,4}\\b";
51
52	private DataBindingContext dbc;
53
54	public static void main(String[] args) {
55	Display display = new Display();
56
57	Realm.runWithDefault(SWTObservables.getRealm(display), new Runnable() {
58	public void run() {
59	Shell shell = new Snippet035Editing().createShell();
60	Display display = Display.getCurrent();
61	while (!shell.isDisposed()) {
62	if (!display.readAndDispatch()) {
63	display.sleep();
64	}
65	}
66	}
67	});
68	}
69
70	private Shell createShell() {
71	Display display = Display.getCurrent();
72	Shell shell = new Shell(display);
73	shell.setText("Editing");
74	shell.setLayout(new GridLayout(1, false));
75
76	dbc = new DataBindingContext();
77
78	createValueSection(shell);
79	createListSection(shell);
80
81	shell.pack();
82	shell.open();
83
84	return shell;
85	}
86
87	private void createValueSection(Composite parent) {
88	Group section = createSectionGroup(parent, "Value bindings", false);
89
90	// Edit an e-mail address.
91	Text emailText = createTextField(section, "E-Mail*");
92	Editing emailEditing = EditingFactory.forString().required().matches(EMAIL_REGEX);
93	bindTextField(emailText, new WritableValue(), emailEditing);
94
95	// Edit a required, positive integer and use the default validation message.
96	Text positiveText = createTextField(section, "Positive value*");
97	Editing positiveEditing = EditingFactory.forInteger().required().positive();
98	bindTextField(positiveText, new WritableValue(), positiveEditing);
99
100	// Edit an integer within the range [1, 100] and use the default
101	// validation message.
102	Text rangeText = createTextField(section, "Value in [1, 100]");
103	Editing rangeEditing = EditingFactory.forInteger().range(1, 100);
104	bindTextField(rangeText, new WritableValue(new Integer(0), null), rangeEditing);
105
106	// Edit a percentage value which must lie within [0, 100] and use a custom
107	// validation message which indicates that the value actually represents
108	// a percentage value.
109	Text percentText = createTextField(section, "Value [%]");
110	Editing percentEditing = EditingFactory.forInteger().rangeMessage("Please specify a valid percentage value within [{0}, {1}].").range(0, 100);
111	bindTextField(percentText, new WritableValue(new Integer(-1), null), percentEditing);
112
113	// Edit a hex integer within the range [0x00, 0xff]. The range validation
114	// message will display the range boundaries in hex format as well.
115	Text hexText = createTextField(section, "Hex value in [0x00, 0xff]");
116	Editing hexEditing = EditingFactory.forHexInteger(2).range(0x00, 0xff);
117	bindTextField(hexText, new WritableValue(new Integer(0), null), hexEditing);
118	}
119
120	private void createListSection(Composite parent) {
121	Group section = createSectionGroup(parent, "List bindings", true);
122
123	// Our date should be >= 01.01.1990.
124	Calendar year1990Calendar = Calendar.getInstance();
125	year1990Calendar.clear();
126	year1990Calendar.set(1990, 0, 1);
127	Date year1990 = year1990Calendar.getTime();
128
129	// Edit a date supporting the default input/display patterns.
130	Text dateText = createTextField(section, "Date");
131	Editing dateEditing = EditingFactory.forDate().afterEqual(year1990);
132	final WritableValue dateObservable = new WritableValue();
133	final Binding dateBinding = bindTextField(dateText, dateObservable, dateEditing);
134
135	// Create a list to which the dates are added when the user hits ENTER.
136	new Label(section, SWT.LEFT);
137	ListViewer dateListViewer = new ListViewer(section);
138	GridDataFactory.fillDefaults().grab(true, true).hint(150, 200).applyTo(dateListViewer.getList());
139
140	dateListViewer.setContentProvider(new ObservableListContentProvider());
141	dateListViewer.setLabelProvider(new LabelProvider());
142
143	// We use the same DateEditing object as for the text field above to
144	// create a list binding which maps the entered dates to their string
145	// representation which is then set as input on the ListViewer.
146	final WritableList targetDateList = new WritableList();
147	final WritableList modelDateList = new WritableList();
148	dbc.bindList(
149	targetDateList,
150	modelDateList,
151	dateEditing.createTargetListStrategy(),
152	dateEditing.createModelListStrategy());
153
154	// Set the list containing the string representation of the dates as input.
155	dateListViewer.setInput(targetDateList);
156
157	// Add the current date in the text field when the user hits ENTER.
158	dateText.addSelectionListener(new SelectionAdapter() {
159	public void widgetDefaultSelected(SelectionEvent e) {
160	IStatus dateValidationStatus = (IStatus) dateBinding.getValidationStatus().getValue();
161	Date date = (Date) dateObservable.getValue();
162	if (dateValidationStatus.isOK() && date != null) {
163	modelDateList.add(date);
164	}
165	}
166	});
167	}
168
169	private Binding bindTextField(Text text, IObservableValue modelValue, Editing editing) {
170	// Create the binding using the editing object.
171	ISWTObservableValue textObservable = SWTObservables.observeText(text, SWT.Modify);
172	Binding binding = dbc.bindValue(
173	textObservable,
174	modelValue,
175	editing.createTargetValueStrategy(),
176	editing.createModelValueStrategy());
177
178	// Decorate the control with the validation status.
179	ControlDecorationSupport.create(binding, SWT.TOP);
180
181	// Re-format when the text field looses the focus in order to always
182	// display the model in the default format in case multiple input formats
183	// are supported.
184	formatOnFocusOut(text, binding);
185
186	return binding;
187	}
188
189	private static void formatOnFocusOut(final Control control, final Binding binding) {
190	control.addFocusListener(new FocusAdapter() {
191	public void focusLost(FocusEvent e) {
192	IStatus dateValidationStatus = (IStatus) binding.getValidationStatus().getValue();
193	if (dateValidationStatus.isOK()) {
194	binding.updateModelToTarget();
195	}
196	}
197	});
198	}
199
200	private static Group createSectionGroup(Composite parent, String groupText, boolean grabVertical) {
201	Group section = new Group(parent, SWT.SHADOW_ETCHED_IN);
202	section.setText(groupText);
203	GridLayoutFactory.fillDefaults().numColumns(2).equalWidth(false).margins(5, 5).spacing(15, 5).applyTo(section);
204	GridDataFactory.fillDefaults().grab(true, grabVertical).applyTo(section);
205	return section;
206	}
207
208	private static Text createTextField(Composite parent, String labelText) {
209	Label label = new Label(parent, SWT.LEFT);
210	label.setText(labelText);
211	GridDataFactory.fillDefaults().align(SWT.LEFT, SWT.CENTER).applyTo(label);
212
213	Text text = new Text(parent, SWT.BORDER);
214	GridDataFactory.fillDefaults().grab(true, false).hint(150, SWT.DEFAULT).applyTo(text);
215
216	return text;
217	}
218	}