Attachment #157180 for bug #183055

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

and this patch

Lines 17-21 Link Here

(-)META-INF/MANIFEST.MF (-1 / +2 lines)
17	org.eclipse.jface.examples.databinding.mask.internal;x-internal:=true,	17	org.eclipse.jface.examples.databinding.mask.internal;x-internal:=true,
18	org.eclipse.jface.examples.databinding.model;x-internal:=false,	18	org.eclipse.jface.examples.databinding.model;x-internal:=false,
19	org.eclipse.jface.examples.databinding.radioGroup;x-internal:=false	19	org.eclipse.jface.examples.databinding.radioGroup;x-internal:=false
20	Import-Package: com.ibm.icu.text	20	Import-Package: com.ibm.icu.math,
		21	com.ibm.icu.text
21	Bundle-RequiredExecutionEnvironment: J2SE-1.5	22	Bundle-RequiredExecutionEnvironment: J2SE-1.5




/*******************************************************************************
 * Copyright (c) 2009 Ovidio Mallo 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:
 *     Ovidio Mallo - initial API and implementation (bug 183055)
 ******************************************************************************/

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 Ovidio Mallo 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:
 *     Ovidio Mallo - initial API and implementation (bug 183055)
 ******************************************************************************/

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.BooleanEditing;
import org.eclipse.core.databinding.editing.DateEditing;
import org.eclipse.core.databinding.editing.DecimalEditing;
import org.eclipse.core.databinding.editing.Editing;
import org.eclipse.core.databinding.editing.IntegerEditing;
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.databinding.validation.IValidator;
import org.eclipse.core.databinding.validation.ValidationStatus;
import org.eclipse.core.databinding.validation.constraint.Constraints;
import org.eclipse.core.databinding.validation.constraint.IntegerConstraints;
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;

import com.ibm.icu.text.MessageFormat;

public class Snippet035Editing {

	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.forEmailString().required();
		bindTextField(emailText, new WritableValue(), emailEditing);

		// Edit a required, positive short using the default validation message.
		Text positiveText = createTextField(section, "Positive short*");
		IntegerEditing positiveEditing = EditingFactory.forShort().required().positive();
		bindTextField(positiveText, new WritableValue(), positiveEditing);

		// Edit a required double with a maximum of five significant and two
		// fractional digits.
		Text doubleText = createTextField(section, "Price [$]*");
		DecimalEditing doubleEditing = EditingFactory.forDouble().required().maxPrecision(5).maxScale(2);
		bindTextField(doubleText, new WritableValue(), doubleEditing);

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

		// Edit a percentage value which must lie within [0, 100] using a custom
		// validation message which indicates that the value actually represents
		// a percentage value. Note that the constraint message must be specified
		// before the actual constraint.
		Text percentText = createTextField(section, "Percentage [%]");
		IntegerEditing percentEditing = EditingFactory.forInteger();
		percentEditing.modelIntegerConstraints()
			.rangeMessage("Please specify a percentage value within [{0}, {1}].")
			.range(0, 100);
		bindTextField(percentText, new WritableValue(-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]");
		IntegerEditing hexEditing = EditingFactory.forHexInteger(2).range(0x00, 0xff);
		bindTextField(hexText, new WritableValue(0, null), hexEditing);

		// Edit a boolean value.
		Text boolText = createTextField(section, "Boolean value");
		BooleanEditing boolEditing = EditingFactory.forBoolean();
		bindTextField(boolText, new WritableValue(true, null), boolEditing);

		// Edit a value within [1, 10] or [20, 30].
		Text rangesText = createTextField(section, "Value in [1, 10] or [20, 30]");
		Editing rangesEditing = EditingFactory.forInteger().addModelValidator(new RangesValidator(1, 10, 20, 30));
		bindTextField(rangesText, new WritableValue(), rangesEditing);
	}

	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");
		DateEditing 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();
		dateEditing.bindList(dbc, targetDateList, modelDateList);

		// 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 = editing.bindValue(dbc, textObservable, modelValue);

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

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

		// Select the text when gaining focus.
		text.addFocusListener(new FocusAdapter() {
			public void focusGained(FocusEvent e) {
				text.selectAll();
			}
		});

		return text;
	}

	private static final class RangesValidator implements IValidator {

		private final String validationMessage;

		private final IValidator validator;

		public RangesValidator(int min1, int max1, int min2, int max2) {
			this.validationMessage = MessageFormat.format(
					"The value must lie within [{0}, {1}] or [{2}, {3}].",
					new Object[] { min1, max1, min2, max2 });
			this.validator =
				new IntegerConstraints()
					.range(min1, max1)
					.range(min2, max2)
					.aggregationPolicy(Constraints.AGGREGATION_MIN_SEVERITY)
					.createValidator();
		}

		public IStatus validate(Object value) {
			if (!validator.validate(value).isOK()) {
				return ValidationStatus.error(validationMessage);
			}
			return ValidationStatus.ok();
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2009 Ovidio Mallo 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:
 *     Ovidio Mallo - initial API and implementation (bug 183055)
 ******************************************************************************/

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

import java.util.Locale;

import org.eclipse.core.databinding.editing.BooleanEditing;
import org.eclipse.core.databinding.editing.DateEditing;
import org.eclipse.core.databinding.editing.DecimalEditing;
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.NumberFormat;

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

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

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

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

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

	private static final String[] BOOLEAN_TRUE_VALUES = new String[] {
		"yes", "y", "true", "1"
	};

	private static final String[] BOOLEAN_FALSE_VALUES = new String[] {
		"no", "n", "false", "0"
	};

	private static final String[] DATE_INPUT_PATTERNS = new String[] {
		"yyMMdd",
		"yyyyMMdd"
	};

	private static final String DATE_DISPLAY_PATTERN = "yyyyMMdd";

	private static final String DATE_PARSE_ERROR_MESSAGE = createDateParseErrorMessage(DATE_INPUT_PATTERNS);

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

	private static final String EMAIL_ERROR_MESSAGE = "Please specify a valid e-mail address.";

	private EditingFactory() {
		// prevent instantiation
	}

	public static StringEditing forString() {
		return StringEditing.strippedToNull();
	}

	public static StringEditing forEmailString() {
		StringEditing editing = StringEditing.strippedToNull();
		editing.modelStringConstraints()
				.matchesMessage(EMAIL_ERROR_MESSAGE)
				.matches(EMAIL_REGEX);
		return editing;
	}

	public static IntegerEditing forLong() {
		return forLong(Locale.getDefault());
	}

	public static IntegerEditing forLong(Locale locale) {
		IntegerEditing editing = IntegerEditing.forLongFormat(
				NumberFormat.getIntegerInstance(locale),
				NUMBER_PARSE_ERROR_MESSAGE,
				NUMBER_OUT_OF_RANGE_MESSAGE);
		configure(editing, locale);
		return editing;
	}

	public static IntegerEditing forInteger() {
		return forInteger(Locale.getDefault());
	}

	public static IntegerEditing forInteger(Locale locale) {
		IntegerEditing editing = IntegerEditing.forIntegerFormat(
				NumberFormat.getIntegerInstance(locale),
				NUMBER_PARSE_ERROR_MESSAGE,
				NUMBER_OUT_OF_RANGE_MESSAGE);
		configure(editing, locale);
		return editing;
	}

	public static IntegerEditing forShort() {
		return forShort(Locale.getDefault());
	}

	public static IntegerEditing forShort(Locale locale) {
		IntegerEditing editing = IntegerEditing.forShortFormat(
				NumberFormat.getIntegerInstance(locale),
				NUMBER_PARSE_ERROR_MESSAGE,
				NUMBER_OUT_OF_RANGE_MESSAGE);
		configure(editing, locale);
		return editing;
	}

	public static IntegerEditing forByte() {
		return forByte(Locale.getDefault());
	}

	public static IntegerEditing forByte(Locale locale) {
		IntegerEditing editing = IntegerEditing.forByteFormat(
				NumberFormat.getIntegerInstance(locale),
				NUMBER_PARSE_ERROR_MESSAGE,
				NUMBER_OUT_OF_RANGE_MESSAGE);
		configure(editing, locale);
		return editing;
	}

	public static IntegerEditing forHexInteger(int digits) {
		RadixNumberFormat hexFormat = RadixNumberFormat.getHexInstance("0x", digits);
		IntegerEditing editing = IntegerEditing.forIntegerFormat(
				hexFormat,
				NUMBER_PARSE_ERROR_MESSAGE,
				NUMBER_OUT_OF_RANGE_MESSAGE);
		configure(editing, Locale.getDefault());
		editing.modelIntegerConstraints().integerFormat(hexFormat);
		return editing;
	}

	private static void configure(IntegerEditing editing, Locale locale) {
		editing.modelIntegerConstraints()
				.integerFormat(NumberFormat.getIntegerInstance(locale))
				.requiredMessage(REQUIRED_MESSAGE)
				.rangeMessage(NUMBER_RANGE_MESSAGE);
	}

	public static DecimalEditing forDouble() {
		return forDouble(Locale.getDefault());
	}

	public static DecimalEditing forDouble(Locale locale) {
		DecimalEditing editing = DecimalEditing.forDoubleFormat(
				NumberFormat.getNumberInstance(locale),
				NUMBER_PARSE_ERROR_MESSAGE,
				NUMBER_OUT_OF_RANGE_MESSAGE);
		configure(editing, locale);
		return editing;
	}

	private static void configure(DecimalEditing editing, Locale locale) {
		editing.modelDecimalConstraints()
				.decimalFormat(NumberFormat.getNumberInstance())
				.requiredMessage(REQUIRED_MESSAGE)
				.rangeMessage(NUMBER_RANGE_MESSAGE);
	}

	public static BooleanEditing forBoolean() {
		BooleanEditing editing =
			BooleanEditing.forStringValues(
					BOOLEAN_TRUE_VALUES,
					BOOLEAN_FALSE_VALUES);
		configure(editing);
		return editing;
	}

	private static void configure(BooleanEditing editing) {
		editing.modelBooleanConstraints()
				.requiredMessage(REQUIRED_MESSAGE);
	}

	public static DateEditing forDate() {
		return forDate(Locale.getDefault());
	}

	public static DateEditing forDate(Locale locale) {
		DateEditing editing = DateEditing
				.forFormats(
						createDateFormats(DATE_INPUT_PATTERNS, locale),
						DATE_PARSE_ERROR_MESSAGE,
						DateFormat.getPatternInstance(DATE_DISPLAY_PATTERN, locale));
		editing.modelDateConstraints().requiredMessage(REQUIRED_MESSAGE);
		return editing;
	}

	private static DateFormat[] createDateFormats(String[] datePatterns, Locale locale) {
		DateFormat[] dateFormats = new DateFormat[datePatterns.length];
		for (int i = 0; i < dateFormats.length; i++) {
			dateFormats[i] = DateFormat.getPatternInstance(datePatterns[i], locale);
		}
		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 Ovidio Mallo 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:
 *     Ovidio Mallo - initial API and implementation (bug 183055)
 ******************************************************************************/

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) {
		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 Ovidio Mallo 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:
 *     Ovidio Mallo - initial API and implementation (bug 183055)
 ******************************************************************************/

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




/*******************************************************************************
 * Copyright (c) 2006, 2009 Ovidio Mallo 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:
 *     Ovidio Mallo - initial API and implementation (bug 183055)
 ******************************************************************************/

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.DateEditing;
import org.eclipse.core.databinding.editing.Editing;
import org.eclipse.core.databinding.editing.IntegerEditing;
import org.eclipse.core.databinding.editing.StringEditing;
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 StringEditing nameEditing = EditingFactory.forString().required();

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

	private final DateEditing 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 = editing.bindValue(dbc, textObservable, modelValue);

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

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

		// Select the text when gaining focus.
		text.addFocusListener(new FocusAdapter() {
			public void focusGained(FocusEvent e) {
				text.selectAll();
			}
		});

		return text;
	}

	public 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);
		}
	}
}




 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Ovidio Mallo - bug 183055
 ******************************************************************************/

/**

public class BindingMessagesTest extends TestCase {
	public void testFormatString() throws Exception {
		String key = "Validate_NumberOutOfRangeError";
		String result = BindingMessages.getFormattedString(key, new Object[] {"1", "2"});
		assertFalse("key should not be returned", key.equals(result));
	}
	
	public void testFormatStringForKeyNotFound() throws Exception {
		String key = "key_that_does_not_exist";
		String result = BindingMessages.getFormattedString(key, null);
		assertTrue(key.equals(result));
	}
}




 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Ovidio Mallo - bug 183055
 *******************************************************************************/

package org.eclipse.core.internal.databinding.conversion;

				.getErrorIndex() : position.getIndex();

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

	 */
	public static String createOutOfRangeMessage(Number minValue,
			Number maxValue, NumberFormat numberFormat) {
		return createOutOfRangeMessage(BindingMessages
				.getString(BindingMessages.VALIDATE_NUMBER_OUT_OF_RANGE_ERROR),
				minValue, maxValue, numberFormat);
	}

	/**
	 * 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
				.formatMessage(message, new Object[] { min, max });
	}

	/**




 * Contributors:
 *     db4objects - Initial API and implementation
 *     Tom Schindl<tom.schindl@bestsolution.at> - bugfix for 217940
 *     Ovidio Mallo - bug 183055
 */
package org.eclipse.core.internal.databinding.conversion;


 * StringToBooleanPrimitiveConverter.
 */
public class StringToBooleanPrimitiveConverter implements IConverter {
	private static final String[] trueValues;

	private static final String[] DEFAULT_TRUE_VALUES;
	private static final String[] DEFAULT_FALSE_VALUES;

	static {
		String delimiter = BindingMessages.getString(BindingMessages.VALUE_DELIMITER);
		String values = BindingMessages.getString(BindingMessages.TRUE_STRING_VALUES);
		DEFAULT_TRUE_VALUES = valuesToSortedArray(delimiter, values);

		values = BindingMessages.getString(BindingMessages.FALSE_STRING_VALUES);
		DEFAULT_FALSE_VALUES = valuesToSortedArray(delimiter, values);
	}

	private String[] trueValues = DEFAULT_TRUE_VALUES;
	private String[] falseValues = DEFAULT_FALSE_VALUES;

	/**
	 * Returns a sorted array with all values converted to upper case.
	 *

		return array;
	}

	/**
	 * Sets the string values which are considered to represent a
	 * <code>true</code> and <code>false</code> value, respectively.
	 * 
	 * <p>
	 * Note that the capitalization of the provided strings is ignored.
	 * </p>
	 * 
	 * @param trueValues
	 *            The set of strings representing a <code>true</code> value.
	 * @param falseValues
	 *            The set of strings representing a <code>false</code> value.
	 */
	public final void setSourceStrings(String[] trueValues, String[] falseValues) {
		this.trueValues = new String[trueValues.length];
		for (int i = 0; i < trueValues.length; i++) {
			this.trueValues[i] = trueValues[i].toUpperCase();
		}
		Arrays.sort(this.trueValues); // for binary search

		this.falseValues = new String[falseValues.length];
		for (int i = 0; i < falseValues.length; i++) {
			this.falseValues[i] = falseValues[i].toUpperCase();
		}
		Arrays.sort(this.falseValues); // for binary search
	}

	/*
	 * (non-Javadoc)
	 *




 *     db4objects - Initial API and implementation
 *     Tom Schindl<tom.schindl@bestsolution.at> - bugfix for 217940
 *     Matthew Hall - bug 121110
 *     Ovidio Mallo - bug 183055
 ******************************************************************************/
package org.eclipse.core.internal.databinding.conversion;


	};

	/**
	 * Sets the {@link DateFormat}s to be used for parsing/formatting dates. Any
	 * of the supplied formats will be used for {@link #parse(String) parsing} a
	 * date from a string while the first format in the array will be used for
	 * {@link #format(Date) formatting} a date as a string.
	 * 
	 * @param formatters
	 *            The {@link DateFormat}s to be used for parsing/formatting
	 *            dates.
	 */
	public final void setFormatters(DateFormat[] formatters) {
		this.formatters = formatters;
	}

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




 *     IBM Corporation - initial API and implementation
 *     Matt Carter - bug 180392
 *                 - bug 197679 (Character support completed)
 *     Ovidio Mallo - bug 183055
 *******************************************************************************/

package org.eclipse.core.databinding;

import org.eclipse.core.databinding.util.Policy;
import org.eclipse.core.internal.databinding.ClassLookupSupport;
import org.eclipse.core.internal.databinding.Pair;
import org.eclipse.core.internal.databinding.conversion.BooleanToStringConverter;
import org.eclipse.core.internal.databinding.conversion.CharacterToStringConverter;
import org.eclipse.core.internal.databinding.conversion.IdentityConverter;
import org.eclipse.core.internal.databinding.conversion.IntegerToStringConverter;

import org.eclipse.core.internal.databinding.conversion.NumberToIntegerConverter;
import org.eclipse.core.internal.databinding.conversion.NumberToLongConverter;
import org.eclipse.core.internal.databinding.conversion.NumberToShortConverter;
import org.eclipse.core.internal.databinding.conversion.ObjectToStringConverter;
import org.eclipse.core.internal.databinding.conversion.StringToByteConverter;
import org.eclipse.core.internal.databinding.conversion.StringToCharacterConverter;
import org.eclipse.core.internal.databinding.conversion.StringToShortConverter;

							new Pair(BOOLEAN_CLASS, "java.lang.Boolean"), new IdentityConverter(Boolean.class, Boolean.class)); //$NON-NLS-1$
			converterMap
					.put(
							new Pair(BOOLEAN_CLASS, "java.lang.String"), new BooleanToStringConverter(Boolean.class)); //$NON-NLS-1$
			converterMap
					.put(
							new Pair(BOOLEAN_CLASS, "java.lang.Object"), new IdentityConverter(Boolean.class, Object.class)); //$NON-NLS-1$

Lines 8-13 Link Here

(-)src/org/eclipse/core/internal/databinding/validation/StringToCharacterValidator.java (-3 / +16 lines)
8	* Contributors:	8	* Contributors:
9	* Matt Carter - initial API and implementation	9	* Matt Carter - initial API and implementation
10	* Tom Schindl<tom.schindl@bestsolution.at> - bugfix for 217940	10	* Tom Schindl<tom.schindl@bestsolution.at> - bugfix for 217940
		11	* Ovidio Mallo - bug 183055
11	******************************************************************************/	12	******************************************************************************/
12		13
13	package org.eclipse.core.internal.databinding.validation;	14	package org.eclipse.core.internal.databinding.validation;
Lines 26-31 Link Here
26		27
27	private final StringToCharacterConverter converter;	28	private final StringToCharacterConverter converter;
28		29
		30	private String parseErrorMessage = BindingMessages.getString(BindingMessages.VALIDATE_CHARACTER_HELP);
		31
29	/**	32	/**
30	* @param converter	33	* @param converter
31	*/	34	*/
Lines 33-38 Link Here
33	this.converter = converter;	36	this.converter = converter;
34	}	37	}
35		38
		39	/**
		40	* Sets the validation message to be used in case the source string does not
		41	* represent a valid character.
		42	*
		43	* @param message
		44	* The validation message to be used in case the source string
		45	* does not represent a valid character.
		46	*/
		47	public final void setParseErrorMessage(String message) {
		48	this.parseErrorMessage = message;
		49	}
		50
36	/*	51	/*
37	* (non-Javadoc)	52	* (non-Javadoc)
38	*	53	*
Lines 44-53 Link Here
44	} catch (IllegalArgumentException e) {	59	} catch (IllegalArgumentException e) {
45	// The StringToCharacterConverter throws an IllegalArgumentException	60	// The StringToCharacterConverter throws an IllegalArgumentException
46	// if it cannot convert.	61	// if it cannot convert.
47	return ValidationStatus.error(BindingMessages	62	return ValidationStatus.error(parseErrorMessage);
48	.getString(BindingMessages.VALIDATE_CHARACTER_HELP));
49	}	63	}
50	return Status.OK_STATUS;	64	return Status.OK_STATUS;
51	}	65	}
52
53	}	66	}

Lines 8-13 Link Here

(-)src/org/eclipse/core/internal/databinding/validation/StringToDateValidator.java (-8 / +24 lines)
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
10	* Tom Schindl<tom.schindl@bestsolution.at> - bugfix for 217940	10	* Tom Schindl<tom.schindl@bestsolution.at> - bugfix for 217940
		11	* Ovidio Mallo - bug 183055
11	*******************************************************************************/	12	*******************************************************************************/
12		13
13	package org.eclipse.core.internal.databinding.validation;	14	package org.eclipse.core.internal.databinding.validation;
Lines 28-33 Link Here
28	public class StringToDateValidator implements IValidator {	29	public class StringToDateValidator implements IValidator {
29	private final StringToDateConverter converter;	30	private final StringToDateConverter converter;
30		31
		32	private String parseErrorMessage = null;
		33
31	/**	34	/**
32	* @param converter	35	* @param converter
33	*/	36	*/
Lines 35-40 Link Here
35	this.converter = converter;	38	this.converter = converter;
36	}	39	}
37		40
		41	/**
		42	* Sets the validation message to be used in case the source string does not
		43	* represent a valid date.
		44	*
		45	* @param message
		46	* The validation message to be used in case the source string
		47	* does not represent a valid date.
		48	*/
		49	public final void setParseErrorMessage(String message) {
		50	this.parseErrorMessage = message;
		51	}
		52
38	/*	53	/*
39	* (non-Javadoc)	54	* (non-Javadoc)
40	*	55	*
Lines 47-64 Link Here
47	Object convertedValue = converter.convert(value);	62	Object convertedValue = converter.convert(value);
48	//The StringToDateConverter returns null if it can't parse the date.	63	//The StringToDateConverter returns null if it can't parse the date.
49	if (convertedValue == null) {	64	if (convertedValue == null) {
50	return ValidationStatus.error(getErrorMessage());	65	return ValidationStatus.error(getParseErrorMessage());
51	}	66	}
52		67
53	return Status.OK_STATUS;	68	return Status.OK_STATUS;
54	}	69	}
55		70
56	/*	71	private String getParseErrorMessage() {
57	* (non-Javadoc)	72	if (parseErrorMessage != null) {
58	*	73	return parseErrorMessage;
59	* @see org.eclipse.core.internal.databinding.validation.WrappedConverterValidator#getErrorMessage()	74	}
60	*/	75
61	protected String getErrorMessage() {
62	Date sampleDate = new Date();	76	Date sampleDate = new Date();
63		77
64	// FIXME We need to use the information from the	78	// FIXME We need to use the information from the
Lines 73-79 Link Here
73	samples.append('\'');	87	samples.append('\'');
74	samples.append(util.format(sampleDate, 0));	88	samples.append(util.format(sampleDate, 0));
75	samples.append('\'');	89	samples.append('\'');
76	return BindingMessages.getString(BindingMessages.EXAMPLES) + ": " + samples + ",..."; //$NON-NLS-1$//$NON-NLS-2$	90	parseErrorMessage = BindingMessages.getString(BindingMessages.EXAMPLES) + ": " + samples + ",..."; //$NON-NLS-1$//$NON-NLS-2$
		91
		92	return parseErrorMessage;
77	}	93	}
78		94
79	private static class FormatUtil extends DateConversionSupport {	95	private static class FormatUtil extends DateConversionSupport {

Lines 7-18 Link Here

(-)src/org/eclipse/core/internal/databinding/validation/AbstractStringToNumberValidator.java (-9 / +56 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
		10	* Ovidio Mallo - bug 183055
10	******************************************************************************/	11	******************************************************************************/
11		12
12	package org.eclipse.core.internal.databinding.validation;	13	package org.eclipse.core.internal.databinding.validation;
13		14
		15	import java.text.ParsePosition;
		16
14	import org.eclipse.core.databinding.validation.IValidator;	17	import org.eclipse.core.databinding.validation.IValidator;
15	import org.eclipse.core.databinding.validation.ValidationStatus;	18	import org.eclipse.core.databinding.validation.ValidationStatus;
		19	import org.eclipse.core.internal.databinding.BindingMessages;
16	import org.eclipse.core.internal.databinding.conversion.StringToNumberParser;	20	import org.eclipse.core.internal.databinding.conversion.StringToNumberParser;
17	import org.eclipse.core.internal.databinding.conversion.StringToNumberParser.ParseResult;	21	import org.eclipse.core.internal.databinding.conversion.StringToNumberParser.ParseResult;
18	import org.eclipse.core.runtime.IStatus;	22	import org.eclipse.core.runtime.IStatus;
Lines 31-37 Link Here
31	private final Number min;	35	private final Number min;
32	private final Number max;	36	private final Number max;
33		37
34	private String outOfRangeMessage;	38	private String parseErrorMessage;
		39
		40	private String outOfRangeMessage = BindingMessages.getString(BindingMessages.VALIDATE_NUMBER_OUT_OF_RANGE_ERROR);
		41	private String formattedOutOfRangeMessage;
35		42
36	/**	43	/**
37	* Constructs a new instance.	44	* Constructs a new instance.
Lines 55-60 Link Here
55	}	62	}
56		63
57	/**	64	/**
		65	* Sets the validation message pattern to be used in case the source string
		66	* does not represent a valid number.
		67	*
		68	* @param message
		69	* The validation message pattern to be used in case the source
		70	* string does not represent a valid number.
		71	*/
		72	public final void setParseErrorMessage(String message) {
		73	this.parseErrorMessage = message;
		74	}
		75
		76	/**
		77	* Sets the validation message pattern to be used in case the parsed number
		78	* lies outside the value range supported by the number type associated to
		79	* this validator.
		80	*
		81	* @param message
		82	* The validation message pattern to be used in case the parsed
		83	* number lies outside the supported value range. Can be
		84	* parameterized by the <code>Integer.MIN_VALUE</code> and
		85	* <code>Integer.MAX_VALUE</code> values.
		86	*/
		87	public final void setOutOfRangeMessage(String message) {
		88	this.outOfRangeMessage = message;
		89	this.formattedOutOfRangeMessage = null;
		90	}
		91
		92	/**
58	* Validates the provided <code>value</code>. An error status is returned if:	93	* Validates the provided <code>value</code>. An error status is returned if:
59	* <ul>	94	* <ul>
60	* <li>The value cannot be parsed.</li>	95	* <li>The value cannot be parsed.</li>
Lines 69-84 Link Here
69		104
70	if (result.getNumber() != null) {	105	if (result.getNumber() != null) {
71	if (!isInRange(result.getNumber())) {	106	if (!isInRange(result.getNumber())) {
72	if (outOfRangeMessage == null) {	107	return ValidationStatus.error(getFormattedOutOfRangeMessage());
73	outOfRangeMessage = StringToNumberParser
74	.createOutOfRangeMessage(min, max, converter
75	.getNumberFormat());
76	}
77
78	return ValidationStatus.error(outOfRangeMessage);
79	}	108	}
80	} else if (result.getPosition() != null) {	109	} else if (result.getPosition() != null) {
81	String parseErrorMessage = StringToNumberParser.createParseErrorMessage(	110	String parseErrorMessage = createParseErrorMessage(
82	(String) value, result.getPosition());	111	(String) value, result.getPosition());
83		112
84	return ValidationStatus.error(parseErrorMessage);	113	return ValidationStatus.error(parseErrorMessage);
Lines 94-97 Link Here
94	* @return <code>true</code> if in range	123	* @return <code>true</code> if in range
95	*/	124	*/
96	protected abstract boolean isInRange(Number number);	125	protected abstract boolean isInRange(Number number);
		126
		127	private String createParseErrorMessage(String input,
		128	ParsePosition parsePosition) {
		129	if (parseErrorMessage == null) {
		130	return StringToNumberParser.createParseErrorMessage(input,
		131	parsePosition);
		132	}
		133	return parseErrorMessage;
		134	}
		135
		136	private String getFormattedOutOfRangeMessage() {
		137	if (formattedOutOfRangeMessage == null) {
		138	formattedOutOfRangeMessage = StringToNumberParser
		139	.createOutOfRangeMessage(outOfRangeMessage, min, max,
		140	converter.getNumberFormat());
		141	}
		142	return formattedOutOfRangeMessage;
		143	}
97	}	144	}

Lines 8-14 Link Here

(-)META-INF/MANIFEST.MF (+2 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,
		13	org.eclipse.core.databinding.validation.constraint,
12	org.eclipse.core.internal.databinding;x-friends:="org.eclipse.core.databinding.beans",	14	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",	15	org.eclipse.core.internal.databinding.conversion;x-friends:="org.eclipse.jface.tests.databinding",
14	org.eclipse.core.internal.databinding.validation;x-friends:="org.eclipse.jface.tests.databinding"	16	org.eclipse.core.internal.databinding.validation;x-friends:="org.eclipse.jface.tests.databinding"

Lines 8-13 Link Here

(-)src/org/eclipse/core/internal/databinding/BindingMessages.java (-4 / +146 lines)
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
10	* Tom Schindl<tom.schindl@bestsolution.at> - bugfix for 217940	10	* Tom Schindl<tom.schindl@bestsolution.at> - bugfix for 217940
		11	* Ovidio Mallo - bug 183055
11	*******************************************************************************/	12	*******************************************************************************/
12	package org.eclipse.core.internal.databinding;	13	package org.eclipse.core.internal.databinding;
13		14
Lines 69-74 Link Here
69	public static final String FALSE_STRING_VALUES = "FalseStringValues"; //$NON-NLS-1$	70	public static final String FALSE_STRING_VALUES = "FalseStringValues"; //$NON-NLS-1$
70		71
71	/**	72	/**
		73	* Key to be used for a "Validate_InvalidBooleanString" message
		74	*/
		75	public static final String VALIDATE_INVALID_BOOLEAN_STRING = "Validate_InvalidBooleanString"; //$NON-NLS-1$
		76
		77	/**
72	* Key to be used for a "Validate_NumberOutOfRangeError" message	78	* Key to be used for a "Validate_NumberOutOfRangeError" message
73	*/	79	*/
74	public static final String VALIDATE_NUMBER_OUT_OF_RANGE_ERROR = "Validate_NumberOutOfRangeError"; //$NON-NLS-1$	80	public static final String VALIDATE_NUMBER_OUT_OF_RANGE_ERROR = "Validate_NumberOutOfRangeError"; //$NON-NLS-1$
Lines 99-104 Link Here
99	public static final String VALIDATE_CHARACTER_HELP = "Validate_CharacterHelp"; //$NON-NLS-1$	105	public static final String VALIDATE_CHARACTER_HELP = "Validate_CharacterHelp"; //$NON-NLS-1$
100		106
101	/**	107	/**
		108	* Key to be used for a "Validate_CharacterNoWhitespace" message
		109	*/
		110	public static final String VALIDATE_CHARACTER_NO_WHITESPACE = "Validate_CharacterNoWhitespace"; //$NON-NLS-1$
		111
		112	/**
		113	* Key to be used for a "Validate_CharacterNoSpace" message
		114	*/
		115	public static final String VALIDATE_CHARACTER_NO_SPACE = "Validate_CharacterNoSpace"; //$NON-NLS-1$
		116
		117	/**
		118	* Key to be used for a "Validate_CharacterLetter" message
		119	*/
		120	public static final String VALIDATE_CHARACTER_LETTER = "Validate_CharacterLetter"; //$NON-NLS-1$
		121
		122	/**
		123	* Key to be used for a "Validate_CharacterDigit" message
		124	*/
		125	public static final String VALIDATE_CHARACTER_DIGIT = "Validate_CharacterDigit"; //$NON-NLS-1$
		126
		127	/**
		128	* Key to be used for a "Validate_CharacterLetterOrDigit" message
		129	*/
		130	public static final String VALIDATE_CHARACTER_LETTER_OR_DIGIT = "Validate_CharacterLetterOrDigit"; //$NON-NLS-1$
		131
		132	/**
102	* Key to be used for a "Examples" message	133	* Key to be used for a "Examples" message
103	*/	134	*/
104	public static final String EXAMPLES = "Examples"; //$NON-NLS-1$	135	public static final String EXAMPLES = "Examples"; //$NON-NLS-1$
Lines 109-118 Link Here
109	public static final String VALIDATE_NUMBER_PARSE_ERROR_NO_CHARACTER = "Validate_NumberParseErrorNoCharacter"; //$NON-NLS-1$	140	public static final String VALIDATE_NUMBER_PARSE_ERROR_NO_CHARACTER = "Validate_NumberParseErrorNoCharacter"; //$NON-NLS-1$
110		141
111	/**	142	/**
		143	* Key to be used for a "Validate_NonNull" message
		144	*/
		145	public static final String VALIDATE_NON_NULL = "Validate_NonNull"; //$NON-NLS-1$
		146
		147	/**
		148	* Key to be used for a "Validate_NonEmptyString" message
		149	*/
		150	public static final String VALIDATE_NON_EMPTY_STRING = "Validate_NonEmptyString"; //$NON-NLS-1$
		151
		152	/**
		153	* Key to be used for a "Validate_NonStringRegex" message
		154	*/
		155	public static final String VALIDATE_STRING_REGEX = "Validate_NonStringRegex"; //$NON-NLS-1$
		156
		157	/**
		158	* Key to be used for a "Validate_NumberRangeGreater" message
		159	*/
		160	public static final String VALIDATE_NUMBER_RANGE_GREATER = "Validate_NumberRangeGreater"; //$NON-NLS-1$
		161
		162	/**
		163	* Key to be used for a "Validate_NumberRangeGreaterEqual" message
		164	*/
		165	public static final String VALIDATE_NUMBER_RANGE_GREATER_EQUAL = "Validate_NumberRangeGreaterEqual"; //$NON-NLS-1$
		166
		167	/**
		168	* Key to be used for a "Validate_NumberRangeLess" message
		169	*/
		170	public static final String VALIDATE_NUMBER_RANGE_LESS = "Validate_NumberRangeLess"; //$NON-NLS-1$
		171
		172	/**
		173	* Key to be used for a "Validate_NumberRangeLessEqual" message
		174	*/
		175	public static final String VALIDATE_NUMBER_RANGE_LESS_EQUAL = "Validate_NumberRangeLessEqual"; //$NON-NLS-1$
		176
		177	/**
		178	* Key to be used for a "Validate_NumberRangeWithinRange" message
		179	*/
		180	public static final String VALIDATE_NUMBER_RANGE_WITHIN_RANGE = "Validate_NumberRangeWithinRange"; //$NON-NLS-1$
		181
		182	/**
		183	* Key to be used for a "Validate_NumberRangePositive" message
		184	*/
		185	public static final String VALIDATE_NUMBER_RANGE_POSITIVE = "Validate_NumberRangePositive"; //$NON-NLS-1$
		186
		187	/**
		188	* Key to be used for a "Validate_NumberRangeNonNegative" message
		189	*/
		190	public static final String VALIDATE_NUMBER_RANGE_NON_NEGATIVE = "Validate_NumberRangeNonNegative"; //$NON-NLS-1$
		191
		192	/**
		193	* Key to be used for a "Validate_DateRangeAfter" message
		194	*/
		195	public static final String VALIDATE_DATE_RANGE_AFTER = "Validate_DateRangeAfter"; //$NON-NLS-1$
		196
		197	/**
		198	* Key to be used for a "Validate_DateRangeAfterEqual" message
		199	*/
		200	public static final String VALIDATE_DATE_RANGE_AFTER_EQUAL = "Validate_DateRangeAfterEqual"; //$NON-NLS-1$
		201
		202	/**
		203	* Key to be used for a "Validate_DateRangeBefore" message
		204	*/
		205	public static final String VALIDATE_DATE_RANGE_BEFORE = "Validate_DateRangeBefore"; //$NON-NLS-1$
		206
207	/**
208	* Key to be used for a "Validate_DateRangeBeforeEqual" message
209	*/
210	public static final String VALIDATE_DATE_RANGE_BEFORE_EQUAL = "Validate_DateRangeBeforeEqual"; //$NON-NLS-1$
211
212	/**
213	* Key to be used for a "Validate_DateRangeWithinRange" message
214	*/
215	public static final String VALIDATE_DATE_RANGE_WITHIN_RANGE = "Validate_DateRangeWithinRange"; //$NON-NLS-1$
216
217	/**
218	* Key to be used for a "Validate_StringLengthMin" message
219	*/
220	public static final String VALIDATE_STRING_LENGTH_MIN = "Validate_StringLengthMin"; //$NON-NLS-1$
221
222	/**
223	* Key to be used for a "Validate_StringLengthMax" message
224	*/
225	public static final String VALIDATE_STRING_LENGTH_MAX = "Validate_StringLengthMax"; //$NON-NLS-1$
226
227	/**
228	* Key to be used for a "Validate_StringLengthRange" message
229	*/
230	public static final String VALIDATE_STRING_LENGTH_RANGE = "Validate_StringLengthRange"; //$NON-NLS-1$
231
232	/**
233	* Key to be used for a "Validate_DecimalMaxScale" message
234	*/
235	public static final String VALIDATE_DECIMAL_MAX_SCALE = "Validate_DecimalMaxScale"; //$NON-NLS-1$
236
237	/**
238	* Key to be used for a "Validate_DecimalMaxPrecision" message
239	*/
240	public static final String VALIDATE_DECIMAL_MAX_PRECISION = "Validate_DecimalMaxPrecision"; //$NON-NLS-1$
241
242	/**
112	* Returns the resource object with the given key in the resource bundle for	243	* Returns the resource object with the given key in the resource bundle for
113	* JFace Data Binding. If there isn't any value under the given key, the key	244	* JFace Data Binding. If there isn't any value under the given key, the key
114	* is returned.	245	* is returned.
115	*	246	*
116	* @param key	247	* @param key
117	* the resource name	248	* the resource name
118	* @return the string	249	* @return the string
Lines 128-143 Link Here
128	/**	259	/**
129	* Returns a formatted string with the given key in the resource bundle for	260	* Returns a formatted string with the given key in the resource bundle for
130	* JFace Data Binding.	261	* JFace Data Binding.
131	*	262	*
132	* @param key	263	* @param key
133	* @param arguments	264	* @param arguments
134	* @return formatted string, the key if the key is invalid	265	* @return formatted string, the key if the key is invalid
135	*/	266	*/
136	public static String formatString(String key, Object[] arguments) {	267	public static String getFormattedString(String key, Object[] arguments) {
137	try {	268	try {
138	return MessageFormat.format(bundle.getString(key), arguments);	269	return formatMessage(getString(key), arguments);
139	} catch (MissingResourceException e) {	270	} catch (MissingResourceException e) {
140	return key;	271	return key;
141	}	272	}
142	}	273	}
		274
		275	/**
		276	* Formats the given message pattern with the provided arguments.
		277	*
		278	* @param pattern
		279	* @param arguments
		280	* @return formatted string
		281	*/
		282	public static String formatMessage(String pattern, Object[] arguments) {
		283	return MessageFormat.format(pattern, arguments);
		284	}
143	}	285	}

Lines 43-48 Link Here

(-)src/org/eclipse/core/internal/databinding/messages.properties (+45 lines)
43	TrueStringValues=yes,true	43	TrueStringValues=yes,true
44	FalseStringValues=no,false	44	FalseStringValues=no,false
45		45
		46	Validate_InvalidBooleanString=The boolean string is invalid.
		47
46	Validate_NumberOutOfRangeError=Please enter a value between [{0}] and [{1}] and with a similar format.	48	Validate_NumberOutOfRangeError=Please enter a value between [{0}] and [{1}] and with a similar format.
47	Validate_NumberParseError=Invalid character for value [{0}] at position [{1}] character [{2}].	49	Validate_NumberParseError=Invalid character for value [{0}] at position [{1}] character [{2}].
48	Validate_NumberParseErrorNoCharacter=Missing character for value [{0}] at position [{1}].	50	Validate_NumberParseErrorNoCharacter=Missing character for value [{0}] at position [{1}].
Lines 53-56 Link Here
53	Validate_NoChangeAllowedHelp=Changes are not allowed in this field	55	Validate_NoChangeAllowedHelp=Changes are not allowed in this field
54	Validate_CharacterHelp=Please type a character	56	Validate_CharacterHelp=Please type a character
55		57
		58	#CharacterValidator
		59	Validate_CharacterNoWhitespace=The character must be no whitespace.
		60	Validate_CharacterNoSpace=The character must be no space.
		61	Validate_CharacterLetter=The character must be a letter.
		62	Validate_CharacterDigit=The character must be a digit.
		63	Validate_CharacterLetterOrDigit=The character must be a letter or digit.
		64
		65	#NonNullValidator
		66	Validate_NonNull=The value must not be empty.
		67
		68	#NonEmptyStringValidator
		69	Validate_NonEmptyString=The string must not be empty.
		70
		71	#StringRegexValidator
		72	Validate_NonStringRegex=The string must match the following pattern: {0}.
		73
		74	#NumberRangeValidator
		75	Validate_NumberRangeGreater=The value must be greater than {0}.
		76	Validate_NumberRangeGreaterEqual=The value must be greater than or equal to {0}.
		77	Validate_NumberRangeLess=The value must be less than {0}.
		78	Validate_NumberRangeLessEqual=The value must be less than or equal to {0}.
		79	Validate_NumberRangeWithinRange=The value must lie between {0} and {1}.
		80	Validate_NumberRangePositive=The value must be positive.
		81	Validate_NumberRangeNonNegative=The value must not be negative.
		82
		83	#DateRangeValidator
		84	Validate_DateRangeAfter=The date must be after {0}.
		85	Validate_DateRangeAfterEqual=The date must be after or on {0}.
		86	Validate_DateRangeBefore=The date must be before {0}.
		87	Validate_DateRangeBeforeEqual=The date must be before or on {0}.
		88	Validate_DateRangeWithinRange=The date must lie between {0} and {1}.
		89
		90	#StringLengthValidator
		91	Validate_StringLengthMin=The string must have at least {0} characters.
		92	Validate_StringLengthMax=The string must not have more than {0} characters.
		93	Validate_StringLengthRange=The string must have between {0} and {1} characters.
		94
		95	#DecimalScaleValidator
		96	Validate_DecimalMaxScale=The decimal must not have more than {0} fractional digits.
		97
		98	#DecimalPrecisionValidator
		99	Validate_DecimalMaxPrecision=The decimal must not have more than {0} significant digits.
		100
56	Examples=Examples	101	Examples=Examples




/*******************************************************************************
 * Copyright (c) 2009 Ovidio Mallo 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:
 *     Ovidio Mallo - initial API and implementation (bug 183055)
 ******************************************************************************/

package org.eclipse.core.databinding.editing;

import java.util.regex.Pattern;

import org.eclipse.core.databinding.conversion.IConverter;
import org.eclipse.core.databinding.validation.constraint.Constraints;
import org.eclipse.core.databinding.validation.constraint.StringConstraints;
import org.eclipse.core.internal.databinding.conversion.StringStripConverter;
import org.eclipse.core.internal.databinding.conversion.StringTrimConverter;

/**
 * @noextend This class is not intended to be subclassed by clients.
 * @since 1.3
 */
public class StringEditing extends Editing {

	/**
	 * Creates a new editing object for booleans.
	 * 
	 * @param targetConverter
	 *            The {@link #setTargetConverter(IConverter) target converter}
	 *            to use for editing.
	 * 
	 * @noreference This constructor is not intended to be referenced by
	 *              clients.
	 */
	protected 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.
	 * 
	 * @return The new editing object which strips whitespace from both ends of
	 *         the input string.
	 * 
	 * @see Character#isWhitespace(char)
	 */
	public static StringEditing stripped() {
		return new StringEditing(new StringStripConverter(false));
	}

	/**
	 * Creates a new editing object which strips whitespace from both ends of
	 * the input string. In case stripping the input string results in an empty
	 * string, the input string will be converted to <code>null</code>.
	 * 
	 * @return The new editing object which strips whitespace from both ends of
	 *         the input string. Resulting empty strings are converted to
	 *         <code>null</code>.
	 * 
	 * @see Character#isWhitespace(char)
	 */
	public static StringEditing strippedToNull() {
		return new StringEditing(new StringStripConverter(true));
	}

	/**
	 * Creates a new editing object which {@link String#trim()}s the input
	 * string.
	 * 
	 * @return The new editing object which trims whitespace from both ends of
	 *         the input string.
	 * 
	 * @see String#trim()
	 */
	public static StringEditing trimmed() {
		return new StringEditing(new StringTrimConverter(false));
	}

	/**
	 * Creates a new editing object which {@link String#trim()}s the input
	 * string. In case trimming the input string results in an empty string, the
	 * input string will be converted to <code>null</code>.
	 * 
	 * @return The new editing object which trims whitespace from both ends of
	 *         the input string. Resulting empty strings are converted to
	 *         <code>null</code>.
	 * 
	 * @see String#trim()
	 */
	public static StringEditing trimmedToNull() {
		return new StringEditing(new StringTrimConverter(true));
	}

	/**
	 * Returns the target constraints to apply.
	 * 
	 * <p>
	 * This method provides a typesafe access to the {@link StringConstraints
	 * string target constraints} of this editing object and is equivalent to
	 * {@code (StringConstraints) targetConstraints()}.
	 * </p>
	 * 
	 * @return The target constraints to apply.
	 * 
	 * @see #targetConstraints()
	 * @see StringConstraints
	 */
	public StringConstraints targetStringConstraints() {
		return (StringConstraints) targetConstraints();
	}

	/**
	 * Returns the model constraints to apply.
	 * 
	 * <p>
	 * This method provides a typesafe access to the {@link StringConstraints
	 * string model constraints} of this editing object and is equivalent to
	 * {@code (StringConstraints) modelConstraints()}.
	 * </p>
	 * 
	 * @return The model constraints to apply.
	 * 
	 * @see #modelConstraints()
	 * @see StringConstraints
	 */
	public StringConstraints modelStringConstraints() {
		return (StringConstraints) modelConstraints();
	}

	/**
	 * Returns the before-set model constraints to apply.
	 * 
	 * <p>
	 * This method provides a typesafe access to the {@link StringConstraints
	 * string before-set model constraints} of this editing object and is
	 * equivalent to {@code (StringConstraints) beforeSetModelConstraints()}.
	 * </p>
	 * 
	 * @return The before-set model constraints to apply.
	 * 
	 * @see #beforeSetModelConstraints()
	 * @see StringConstraints
	 */
	public StringConstraints beforeSetModelStringConstraints() {
		return (StringConstraints) beforeSetModelConstraints();
	}

	protected Constraints createTargetConstraints() {
		return new StringConstraints();
	}

	protected Constraints createModelConstraints() {
		return new StringConstraints();
	}

	protected Constraints createBeforeSetModelConstraints() {
		return new StringConstraints();
	}

	/**
	 * Convenience method which adds a {@link StringConstraints#required()
	 * required constraint} to the set of {@link #modelStringConstraints()}.
	 * 
	 * @return This editing instance for method chaining.
	 * 
	 * @see StringConstraints#required()
	 * @see #modelStringConstraints()
	 */
	public StringEditing required() {
		modelStringConstraints().required();
		return this;
	}

	/**
	 * Convenience method which adds a {@link StringConstraints#nonEmpty()
	 * non-empty constraint} to the set of {@link #modelStringConstraints()}.
	 * 
	 * @return This editing instance for method chaining.
	 * 
	 * @see StringConstraints#nonEmpty()
	 * @see #modelStringConstraints()
	 */
	public StringEditing nonEmpty() {
		modelStringConstraints().nonEmpty();
		return this;
	}

	/**
	 * Convenience method which adds a {@link StringConstraints#minLength(int)
	 * min-length constraint} to the set of {@link #modelStringConstraints()}.
	 * 
	 * @param minLength
	 *            The min length of the min-length constraint.
	 * @return This editing instance for method chaining.
	 * 
	 * @see StringConstraints#minLength(int)
	 * @see #modelStringConstraints()
	 */
	public StringEditing minLength(int minLength) {
		modelStringConstraints().minLength(minLength);
		return this;
	}

	/**
	 * Convenience method which adds a {@link StringConstraints#maxLength(int)
	 * max-length constraint} to the set of {@link #modelStringConstraints()}.
	 * 
	 * @param maxLength
	 *            The max length of the max-length constraint.
	 * @return This editing instance for method chaining.
	 * 
	 * @see StringConstraints#maxLength(int)
	 * @see #modelStringConstraints()
	 */
	public StringEditing maxLength(int maxLength) {
		modelStringConstraints().maxLength(maxLength);
		return this;
	}

	/**
	 * Convenience method which adds a
	 * {@link StringConstraints#lengthRange(int, int) length-range constraint}
	 * to the set of {@link #modelStringConstraints()}.
	 * 
	 * @param minLength
	 *            The min length of the length-range constraint.
	 * @param maxLength
	 *            The max length of the length-range constraint.
	 * @return This editing instance for method chaining.
	 * 
	 * @see StringConstraints#lengthRange(int, int)
	 * @see #modelStringConstraints()
	 */
	public StringEditing lengthRange(int minLength, int maxLength) {
		modelStringConstraints().lengthRange(minLength, maxLength);
		return this;
	}

	/**
	 * Convenience method which adds a {@link StringConstraints#matches(String)
	 * matches constraint} to the set of {@link #modelStringConstraints()}.
	 * 
	 * @param regex
	 *            The regular expression of the matches constraint.
	 * @return This editing instance for method chaining.
	 * 
	 * @see StringConstraints#matches(String)
	 * @see #modelStringConstraints()
	 */
	public StringEditing matches(String regex) {
		modelStringConstraints().matches(regex);
		return this;
	}

	/**
	 * Convenience method which adds a
	 * {@link StringConstraints#matches(Pattern) matches constraint} to the set
	 * of {@link #modelStringConstraints()}.
	 * 
	 * @param pattern
	 *            The pattern of the matches constraint.
	 * @return This editing instance for method chaining.
	 * 
	 * @see StringConstraints#matches(Pattern)
	 * @see #modelStringConstraints()
	 */
	public StringEditing matches(Pattern pattern) {
		modelStringConstraints().matches(pattern);
		return this;
	}
}




/*******************************************************************************
 * Copyright (c) 2009 Ovidio Mallo 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:
 *     Ovidio Mallo - initial API and implementation (bug 183055)
 ******************************************************************************/

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.internal.databinding.BindingMessages;
import org.eclipse.core.runtime.IStatus;

import com.ibm.icu.text.DateFormat;

/**
 * Provides validations for date which must lie within an open/closed range.
 * 
 * @since 1.3
 */
public class DateRangeValidator implements IValidator {

	// The set of constraint types for the lower/upper bound of the date range.
	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;

	// The default validation messages.
	private static final String AFTER_MESSAGE = BindingMessages
			.getString(BindingMessages.VALIDATE_DATE_RANGE_AFTER);
	private static final String AFTER_EQUAL_MESSAGE = BindingMessages
			.getString(BindingMessages.VALIDATE_DATE_RANGE_AFTER_EQUAL);
	private static final String BEFORE_MESSAGE = BindingMessages
			.getString(BindingMessages.VALIDATE_DATE_RANGE_BEFORE);
	private static final String BEFORE_EQUAL_MESSAGE = BindingMessages
			.getString(BindingMessages.VALIDATE_DATE_RANGE_BEFORE_EQUAL);
	private static final String WITHIN_RANGE_MESSAGE = BindingMessages
			.getString(BindingMessages.VALIDATE_DATE_RANGE_WITHIN_RANGE);

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

	/**
	 * Single constructor which supports the individual date range types.
	 * 
	 * @param min
	 *            The min date of the range or <code>null</code> in case no
	 *            lower bound is defined.
	 * @param max
	 *            The max date of the range or <code>null</code> in case no
	 *            upper bound is defined.
	 * @param minConstraint
	 *            The type of constraint imposed by the lower bound of the
	 *            range.
	 * @param maxConstraint
	 *            The type of constraint imposed by the upper bound of the
	 *            range.
	 * @param validationMessage
	 *            The validation message pattern to use. Can be parameterized by
	 *            the lower and upper bound of the range, if defined.
	 * @param format
	 *            The date format to use for formatting dates in the validation
	 *            message.
	 */
	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;
	}

	/**
	 * Creates a validator which checks that an input date is after the given
	 * date.
	 * 
	 * @param date
	 *            The reference date of the after constraint.
	 * @param validationMessage
	 *            The validation message pattern to use. Can be parameterized
	 *            with the given reference date.
	 * @param format
	 *            The display format to use for formatting dates in the
	 *            validation message.
	 * @return The validator instance.
	 */
	public static DateRangeValidator after(Date date, String validationMessage,
			DateFormat format) {
		return new DateRangeValidator(date, null, AFTER, UNDEFINED,
				defaultIfNull(validationMessage, AFTER_MESSAGE), format);
	}

	/**
	 * Creates a validator which checks that an input date is after or on the
	 * given date.
	 * 
	 * @param date
	 *            The reference date of the after-equal constraint.
	 * @param validationMessage
	 *            The validation message pattern to use. Can be parameterized
	 *            with the given reference date.
	 * @param format
	 *            The display format to use for formatting dates in the
	 *            validation message.
	 * @return The validator instance.
	 */
	public static DateRangeValidator afterEqual(Date date,
			String validationMessage, DateFormat format) {
		return new DateRangeValidator(date, null, AFTER_EQUAL, UNDEFINED,
				defaultIfNull(validationMessage, AFTER_EQUAL_MESSAGE), format);
	}

	/**
	 * Creates a validator which checks that an input date is before the given
	 * date.
	 * 
	 * @param date
	 *            The reference date of the before constraint.
	 * @param validationMessage
	 *            The validation message pattern to use. Can be parameterized
	 *            with the given reference date.
	 * @param format
	 *            The display format to use for formatting dates in the
	 *            validation message.
	 * @return The validator instance.
	 */
	public static DateRangeValidator before(Date date,
			String validationMessage, DateFormat format) {
		return new DateRangeValidator(null, date, UNDEFINED, BEFORE,
				defaultIfNull(validationMessage, BEFORE_MESSAGE), format);
	}

	/**
	 * Creates a validator which checks that an input date is before or on the
	 * given date.
	 * 
	 * @param date
	 *            The reference date of the before-equal constraint.
	 * @param validationMessage
	 *            The validation message pattern to use. Can be parameterized
	 *            with the given reference date.
	 * @param format
	 *            The display format to use for formatting dates in the
	 *            validation message.
	 * @return The validator instance.
	 */
	public static DateRangeValidator beforeEqual(Date date,
			String validationMessage, DateFormat format) {
		return new DateRangeValidator(null, date, UNDEFINED, BEFORE_EQUAL,
				defaultIfNull(validationMessage, BEFORE_EQUAL_MESSAGE), format);
	}

	/**
	 * Creates a validator which checks that an input date is within the given
	 * range.
	 * 
	 * @param min
	 *            The lower bound of the range (inclusive).
	 * @param max
	 *            The upper bound of the range (inclusive).
	 * @param validationMessage
	 *            The validation message pattern to use. Can be parameterized
	 *            with the range's lower and upper bound.
	 * @param format
	 *            The display format to use for formatting dates in the
	 *            validation message.
	 * @return The validator instance.
	 */
	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))) {
				return ValidationStatus.error(getFormattedValidationMessage());
			}
		}
		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 synchronized String getFormattedValidationMessage() {
		if (formattedValidationMessage == null) {
			formattedValidationMessage = MessageFormat.format(
					validationMessage, getValidationMessageArguments());
		}
		return formattedValidationMessage;
	}

	private String[] getValidationMessageArguments() {
		synchronized (format) {
			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 Ovidio Mallo 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:
 *     Ovidio Mallo - initial API and implementation (bug 183055)
 ******************************************************************************/

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.internal.databinding.BindingMessages;
import org.eclipse.core.runtime.IStatus;

import com.ibm.icu.text.NumberFormat;

/**
 * Provides validations for numbers which must lie within an open/closed range.
 * 
 * @since 1.3
 */
public abstract class NumberRangeValidator implements IValidator {

	// The set of constraint types for the lower/upper bound of the date range.
	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;

	// The default validation messages.
	protected static final String GREATER_MESSAGE = BindingMessages
			.getString(BindingMessages.VALIDATE_NUMBER_RANGE_GREATER);
	protected static final String GREATER_EQUAL_MESSAGE = BindingMessages
			.getString(BindingMessages.VALIDATE_NUMBER_RANGE_GREATER_EQUAL);
	protected static final String LESS_MESSAGE = BindingMessages
			.getString(BindingMessages.VALIDATE_NUMBER_RANGE_LESS);
	protected static final String LESS_EQUAL_MESSAGE = BindingMessages
			.getString(BindingMessages.VALIDATE_NUMBER_RANGE_LESS_EQUAL);
	protected static final String WITHIN_RANGE_MESSAGE = BindingMessages
			.getString(BindingMessages.VALIDATE_NUMBER_RANGE_WITHIN_RANGE);
	protected static final String POSITIVE_MESSAGE = BindingMessages
			.getString(BindingMessages.VALIDATE_NUMBER_RANGE_POSITIVE);
	protected static final String NON_NEGATIVE_MESSAGE = BindingMessages
			.getString(BindingMessages.VALIDATE_NUMBER_RANGE_NON_NEGATIVE);

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

	/**
	 * Single constructor which supports the individual number range types.
	 * 
	 * @param min
	 *            The min number of the range or <code>null</code> in case no
	 *            lower bound is defined.
	 * @param max
	 *            The max number of the range or <code>null</code> in case no
	 *            upper bound is defined.
	 * @param minConstraint
	 *            The type of constraint imposed by the lower bound of the
	 *            range.
	 * @param maxConstraint
	 *            The type of constraint imposed by the upper bound of the
	 *            range.
	 * @param validationMessage
	 *            The validation message pattern to use. Can be parameterized by
	 *            the lower and upper bound of the range, if defined.
	 * @param format
	 *            The integer format to use for formatting numbers in the
	 *            validation message.
	 */
	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))) {
				return ValidationStatus.error(getFormattedValidationMessage());
			}
		}
		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$
		}
	}

	/**
	 * Comparator method to be implemented by subclasses in order to compare two
	 * instances of the concrete number type.
	 * 
	 * @param number1
	 *            The first number to compare.
	 * @param number2
	 *            The second number to compare.
	 * @return A negative number, zero, or a positive number in case the first
	 *         number is smaller than, equal to, or greater than the second
	 *         number, respectively.
	 */
	protected abstract int compare(Number number1, Number number2);

	private synchronized String getFormattedValidationMessage() {
		if (formattedValidationMessage == null) {
			formattedValidationMessage = MessageFormat.format(
					validationMessage, getValidationMessageArguments());
		}
		return formattedValidationMessage;
	}

	private String[] getValidationMessageArguments() {
		synchronized (format) {
			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) };
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2009 Ovidio Mallo 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:
 *     Ovidio Mallo - initial API and implementation (bug 183055)
 ******************************************************************************/

package org.eclipse.core.databinding.validation.constraint;

import org.eclipse.core.internal.databinding.validation.CharacterValidator;
import org.eclipse.core.internal.databinding.validation.NonNullValidator;

/**
 * Provides a set of constraints to apply to <code>Character</code>s.
 * 
 * <p>
 * Instances of this class can be used to define a set of constraints to apply
 * to characters. In addition, the validation messages to be issued for the
 * individual constraints can be configured.
 * </p>
 * 
 * @noextend This class is not intended to be subclassed by clients.
 * @since 1.3
 */
public class CharacterConstraints extends Constraints {

	private String requiredMessage = null;

	private String noWhitespaceMessage = null;

	private String noSpaceMessage = null;

	private String letterMessage = null;

	private String digitMessage = null;

	private String letterOrDigitMessage = null;

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

	/**
	 * Sets the validation message for the {@link #required()} constraint.
	 * 
	 * @param message
	 *            The validation message for the {@link #required()} constraint.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #required()
	 */
	public CharacterConstraints requiredMessage(String message) {
		this.requiredMessage = message;
		return this;
	}

	/**
	 * Adds a validator ensuring that the character is no
	 * {@link Character#isWhitespace(char) whitespace}. Uses the current
	 * {@link #noWhitespaceMessage(String) validation message}.
	 * 
	 * @return This constraints instance for method chaining.
	 */
	public CharacterConstraints noWhitespace() {
		addValidator(CharacterValidator.noWhitespace(noWhitespaceMessage));
		return this;
	}

	/**
	 * Sets the validation message for the {@link #noWhitespace()} constraint.
	 * 
	 * @param message
	 *            The validation message for the {@link #noWhitespace()}
	 *            constraint.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #noWhitespace()
	 */
	public CharacterConstraints noWhitespaceMessage(String message) {
		this.noWhitespaceMessage = message;
		return this;
	}

	/**
	 * Adds a validator ensuring that the character is no
	 * {@link Character#isSpaceChar(char) space}. Uses the current
	 * {@link #noSpaceMessage(String) validation message}.
	 * 
	 * @return This constraints instance for method chaining.
	 */
	public CharacterConstraints noSpace() {
		addValidator(CharacterValidator.noSpace(noSpaceMessage));
		return this;
	}

	/**
	 * Sets the validation message for the {@link #noSpace()} constraint.
	 * 
	 * @param message
	 *            The validation message for the {@link #noSpace()} constraint.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #noSpace()
	 */
	public CharacterConstraints noSpaceMessage(String message) {
		this.noSpaceMessage = message;
		return this;
	}

	/**
	 * Adds a validator ensuring that the character is a
	 * {@link Character#isLetter(char) letter}. Uses the current
	 * {@link #letterMessage(String) validation message}.
	 * 
	 * @return This constraints instance for method chaining.
	 */
	public CharacterConstraints letter() {
		addValidator(CharacterValidator.letter(letterMessage));
		return this;
	}

	/**
	 * Sets the validation message for the {@link #letter()} constraint.
	 * 
	 * @param message
	 *            The validation message for the {@link #letter()} constraint.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #letter()
	 */
	public CharacterConstraints letterMessage(String message) {
		this.letterMessage = message;
		return this;
	}

	/**
	 * Adds a validator ensuring that the character is a
	 * {@link Character#isDigit(char) digit}. Uses the current
	 * {@link #digitMessage(String) validation message}.
	 * 
	 * @return This constraints instance for method chaining.
	 */
	public CharacterConstraints digit() {
		addValidator(CharacterValidator.digit(digitMessage));
		return this;
	}

	/**
	 * Sets the validation message for the {@link #digit()} constraint.
	 * 
	 * @param message
	 *            The validation message for the {@link #digit()} constraint.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #digit()
	 */
	public CharacterConstraints digitMessage(String message) {
		this.digitMessage = message;
		return this;
	}

	/**
	 * Adds a validator ensuring that the character is a
	 * {@link Character#isLetterOrDigit(char) letter or digit}. Uses the current
	 * {@link #letterOrDigitMessage(String) validation message}.
	 * 
	 * @return This constraints instance for method chaining.
	 */
	public CharacterConstraints letterOrDigit() {
		addValidator(CharacterValidator.letterOrDigit(letterOrDigitMessage));
		return this;
	}

	/**
	 * Sets the validation message for the {@link #letterOrDigit()} constraint.
	 * 
	 * @param message
	 *            The validation message for the {@link #letterOrDigit()}
	 *            constraint.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #letterOrDigit()
	 */
	public CharacterConstraints letterOrDigitMessage(String message) {
		this.letterOrDigitMessage = message;
		return this;
	}
}




/*******************************************************************************
 * Copyright (c) 2009 Ovidio Mallo 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:
 *     Ovidio Mallo - initial API and implementation (bug 183055)
 ******************************************************************************/

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.internal.databinding.BindingMessages;
import org.eclipse.core.runtime.IStatus;

import com.ibm.icu.text.NumberFormat;

/**
 * Provides validations for strings which must have a specified length.
 * 
 * @since 1.3
 */
public class StringLengthValidator implements IValidator {

	// The default validation messages.
	private static final String MIN_LENGTH_MESSAGE = BindingMessages
			.getString(BindingMessages.VALIDATE_STRING_LENGTH_MIN);
	private static final String MAX_LENGTH_MESSAGE = BindingMessages
			.getString(BindingMessages.VALIDATE_STRING_LENGTH_MAX);
	private static final String LENGTH_RANGE_MESSAGE = BindingMessages
			.getString(BindingMessages.VALIDATE_STRING_LENGTH_RANGE);

	private final Integer minLength;
	private final Integer maxLength;
	private final String validationMessage;
	private String formattedValidationMessage;
	private final NumberFormat format;

	/**
	 * Creates a string length validator defining a minimum and/or maximum
	 * length for a string.
	 * 
	 * @param minLength
	 *            The minimum length of the string or <code>null</code> in case
	 *            no minimum length is defined.
	 * @param maxLength
	 *            The maximum length of the string or <code>null</code> in case
	 *            no maximum length is defined.
	 * @param validationMessage
	 *            The validation message pattern to use. Can be parameterized by
	 *            the lower and upper bound of the range, if defined.
	 * @param format
	 *            The number format to use for formatting integers (the length
	 *            bounds) in the validation message.
	 */
	private StringLengthValidator(Integer minLength, Integer maxLength,
			String validationMessage, NumberFormat format) {
		this.minLength = minLength;
		this.maxLength = maxLength;
		this.validationMessage = validationMessage;
		this.format = format;
	}

	/**
	 * Creates a validator which checks that an input string has the given
	 * minimum length.
	 * 
	 * @param minLength
	 *            The minimum length which the input string must have.
	 * @param validationMessage
	 *            The validation message pattern to use. Can be parameterized
	 *            with the given minimum length.
	 * @param format
	 *            The display format to use for formatting integers (the minimum
	 *            length) in the validation message.
	 * @return The validator instance.
	 */
	public static StringLengthValidator min(int minLength,
			String validationMessage, NumberFormat format) {
		return new StringLengthValidator(new Integer(minLength), null,
				defaultIfNull(validationMessage, MIN_LENGTH_MESSAGE), format);
	}

	/**
	 * Creates a validator which checks that an input string has the given
	 * maximum length.
	 * 
	 * @param maxLength
	 *            The maximum length which the input string must have.
	 * @param validationMessage
	 *            The validation message pattern to use. Can be parameterized
	 *            with the given maximum length.
	 * @param format
	 *            The display format to use for formatting integers (the maximum
	 *            length) in the validation message.
	 * @return The validator instance.
	 */
	public static StringLengthValidator max(int maxLength,
			String validationMessage, NumberFormat format) {
		return new StringLengthValidator(null, new Integer(maxLength),
				defaultIfNull(validationMessage, MAX_LENGTH_MESSAGE), format);
	}

	/**
	 * Creates a validator which checks that the length of an input string lies
	 * in the given range.
	 * 
	 * @param minLength
	 *            The minimum length which the input string must have.
	 * @param maxLength
	 *            The maximum length which the input string must have.
	 * @param validationMessage
	 *            The validation message pattern to use. Can be parameterized
	 *            with the given minimum and maximum lengths.
	 * @param format
	 *            The display format to use for formatting integers (the
	 *            minimum/maximum length) in the validation message.
	 * @return The validator instance.
	 */
	public static StringLengthValidator range(int minLength, int maxLength,
			String validationMessage, NumberFormat format) {
		return new StringLengthValidator(new Integer(minLength), new Integer(
				maxLength), defaultIfNull(validationMessage,
				LENGTH_RANGE_MESSAGE), format);
	}

	public IStatus validate(Object value) {
		String input = (String) value;
		if (input != null) {
			int inputLength = input.length();
			if ((minLength != null && inputLength < minLength.intValue())
					|| maxLength != null && inputLength > maxLength.intValue()) {
				return ValidationStatus.error(getFormattedValidationMessage());
			}
		}
		return ValidationStatus.ok();
	}

	private synchronized String getFormattedValidationMessage() {
		if (formattedValidationMessage == null) {
			formattedValidationMessage = MessageFormat.format(
					validationMessage, getValidationMessageArguments());
		}
		return formattedValidationMessage;
	}

	private String[] getValidationMessageArguments() {
		synchronized (format) {
			if (minLength == null) {
				return new String[] { format.format(maxLength) };
			} else if (maxLength == null) {
				return new String[] { format.format(minLength) };
			}
			return new String[] { format.format(minLength),
					format.format(maxLength) };
		}
	}

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




/*******************************************************************************
 * Copyright (c) 2009 Ovidio Mallo 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:
 *     Ovidio Mallo - initial API and implementation (bug 183055)
 ******************************************************************************/

package org.eclipse.core.databinding.validation.constraint;

import org.eclipse.core.internal.databinding.validation.DecimalPrecisionValidator;
import org.eclipse.core.internal.databinding.validation.DecimalRangeValidator;
import org.eclipse.core.internal.databinding.validation.DecimalScaleValidator;
import org.eclipse.core.internal.databinding.validation.NonNullValidator;

import com.ibm.icu.text.NumberFormat;

/**
 * Provides a set of constraints to apply to decimal numbers.
 * 
 * <p>
 * Instances of this class can be used to define a set of constraints to apply
 * to decimal numbers. In addition, the validation messages to be issued for the
 * individual constraints as well as the way in which model objects are
 * formatted in the validation messages can be configured.
 * </p>
 * 
 * <p>
 * The decimal types supported by this class are <code>double</code>, and
 * <code>float</code>.
 * </p>
 * 
 * @noextend This class is not intended to be subclassed by clients.
 * @since 1.3
 */
public class DecimalConstraints extends Constraints {

	private NumberFormat decimalFormat = NumberFormat.getNumberInstance();

	private NumberFormat scaleFormat = NumberFormat.getIntegerInstance();

	private NumberFormat precisionFormat = NumberFormat.getIntegerInstance();

	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 String maxScaleMessage = null;

	private String maxPrecisionMessage = null;

	/**
	 * Sets the format to use when formatting a decimal to be included in any of
	 * the validation messages.
	 * 
	 * @param format
	 *            The format to use for displaying decimals in validation
	 *            messages.
	 * @return This constraints instance for method chaining.
	 */
	public DecimalConstraints decimalFormat(NumberFormat format) {
		this.decimalFormat = format;
		return this;
	}

	/**
	 * Adds a validator ensuring that the input decimal is not <code>null</code>
	 * . Uses the current {@link #requiredMessage(String) validation message}.
	 * 
	 * @return This constraints instance for method chaining.
	 */
	public DecimalConstraints required() {
		addValidator(new NonNullValidator(requiredMessage));
		return this;
	}

	/**
	 * Sets the validation message for the {@link #required()} constraint.
	 * 
	 * @param message
	 *            The validation message for the {@link #required()} constraint.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #required()
	 */
	public DecimalConstraints requiredMessage(String message) {
		this.requiredMessage = message;
		return this;
	}

	/**
	 * Adds a validator ensuring that the input decimal is greater than the
	 * given number. Uses the current {@link #greaterMessage(String) validation
	 * message} and {@link #decimalFormat(NumberFormat) decimal format}.
	 * 
	 * @param number
	 *            The number which the input decimal must be greater than.
	 * @return This constraints instance for method chaining.
	 */
	public DecimalConstraints greater(double number) {
		addValidator(DecimalRangeValidator.greater(number, greaterMessage,
				decimalFormat));
		return this;
	}

	/**
	 * Sets the validation message pattern for the {@link #greater(double)}
	 * constraint.
	 * 
	 * @param message
	 *            The validation message pattern for the
	 *            {@link #greater(double)} constraint. Can be parameterized with
	 *            the number which the input decimal must be greater than.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #greater(double)
	 */
	public DecimalConstraints greaterMessage(String message) {
		this.greaterMessage = message;
		return this;
	}

	/**
	 * Adds a validator ensuring that the input decimal is greater than or equal
	 * to the given number. Uses the current
	 * {@link #greaterEqualMessage(String) validation message} and
	 * {@link #decimalFormat(NumberFormat) decimal format}.
	 * 
	 * @param number
	 *            The number which the input decimal must be greater than or
	 *            equal to.
	 * @return This constraints instance for method chaining.
	 */
	public DecimalConstraints greaterEqual(double number) {
		addValidator(DecimalRangeValidator.greaterEqual(number,
				greaterEqualMessage, decimalFormat));
		return this;
	}

	/**
	 * Sets the validation message pattern for the {@link #greaterEqual(double)}
	 * constraint.
	 * 
	 * @param message
	 *            The validation message pattern for the
	 *            {@link #greaterEqual(double)} constraint. Can be parameterized
	 *            with the number which the input decimal must be greater than
	 *            or equal to.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #greaterEqual(double)
	 */
	public DecimalConstraints greaterEqualMessage(String message) {
		this.greaterEqualMessage = message;
		return this;
	}

	/**
	 * Adds a validator ensuring that the input decimal is less than the given
	 * number. Uses the current {@link #lessMessage(String) validation message}
	 * and {@link #decimalFormat(NumberFormat) decimal format}.
	 * 
	 * @param number
	 *            The number which the input decimal must be less than.
	 * @return This constraints instance for method chaining.
	 */
	public DecimalConstraints less(double number) {
		addValidator(DecimalRangeValidator.less(number, lessMessage,
				decimalFormat));
		return this;
	}

	/**
	 * Sets the validation message pattern for the {@link #less(double)}
	 * constraint.
	 * 
	 * @param message
	 *            The validation message pattern for the {@link #less(double)}
	 *            constraint. Can be parameterized with the number which the
	 *            input decimal must be less than.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #less(double)
	 */
	public DecimalConstraints lessMessage(String message) {
		this.lessMessage = message;
		return this;
	}

	/**
	 * Adds a validator ensuring that the input decimal is less than or equal to
	 * the given number. Uses the current {@link #lessEqualMessage(String)
	 * validation message} and {@link #decimalFormat(NumberFormat) decimal
	 * format}.
	 * 
	 * @param number
	 *            The number which the input decimal must be less than or equal
	 *            to.
	 * @return This constraints instance for method chaining.
	 */
	public DecimalConstraints lessEqual(double number) {
		addValidator(DecimalRangeValidator.greaterEqual(number,
				lessEqualMessage, decimalFormat));
		return this;
	}

	/**
	 * Sets the validation message pattern for the {@link #lessEqual(double)}
	 * constraint.
	 * 
	 * @param message
	 *            The validation message pattern for the
	 *            {@link #lessEqual(double)} constraint. Can be parameterized
	 *            with the number which the input decimal must be less than or
	 *            equal to.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #lessEqual(double)
	 */
	public DecimalConstraints lessEqualMessage(String message) {
		this.lessEqualMessage = message;
		return this;
	}

	/**
	 * Adds a validator ensuring that the input decimal is within the given
	 * range. Uses the current {@link #rangeMessage(String) validation message}
	 * and {@link #decimalFormat(NumberFormat) decimal format}.
	 * 
	 * @param min
	 *            The lower bound of the range (inclusive).
	 * @param max
	 *            The upper bound of the range (inclusive).
	 * @return This constraints instance for method chaining.
	 */
	public DecimalConstraints range(double min, double max) {
		addValidator(DecimalRangeValidator.range(min, max, rangeMessage,
				decimalFormat));
		return this;
	}

	/**
	 * Sets the validation message pattern for the
	 * {@link #range(double, double)} constraint.
	 * 
	 * @param message
	 *            The validation message pattern for the
	 *            {@link #range(double, double)} constraint. Can be
	 *            parameterized with the min and max values of the range in
	 *            which the input decimal must lie.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #range(double, double)
	 */
	public DecimalConstraints rangeMessage(String message) {
		this.rangeMessage = message;
		return this;
	}

	/**
	 * Adds a validator ensuring that the input decimal is positive. Uses the
	 * current {@link #positiveMessage(String) validation message} and
	 * {@link #decimalFormat(NumberFormat) decimal format}.
	 * 
	 * @return This constraints instance for method chaining.
	 */
	public DecimalConstraints positive() {
		addValidator(DecimalRangeValidator.positive(positiveMessage,
				decimalFormat));
		return this;
	}

	/**
	 * Sets the validation message for the {@link #positive()} constraint.
	 * 
	 * @param message
	 *            The validation message for the {@link #positive()} constraint.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #positive()
	 */
	public DecimalConstraints positiveMessage(String message) {
		this.positiveMessage = message;
		return this;
	}

	/**
	 * Adds a validator ensuring that the input decimal is non-negative. Uses
	 * the current {@link #nonNegativeMessage(String) validation message} and
	 * {@link #decimalFormat(NumberFormat) decimal format}.
	 * 
	 * @return This constraints instance for method chaining.
	 */
	public DecimalConstraints nonNegative() {
		addValidator(DecimalRangeValidator.nonNegative(nonNegativeMessage,
				decimalFormat));
		return this;
	}

	/**
	 * Sets the validation message for the {@link #nonNegative()} constraint.
	 * 
	 * @param message
	 *            The validation message for the {@link #nonNegative()}
	 *            constraint.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #nonNegative()
	 */
	public DecimalConstraints nonNegativeMessage(String message) {
		this.nonNegativeMessage = message;
		return this;
	}

	/**
	 * Sets the format to use when formatting the scale in any of the validation
	 * messages stemming from a scale constraint.
	 * 
	 * @param format
	 *            The format to use for displaying the scale in validation
	 *            messages stemming from a scale constraint.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #maxScale(int)
	 */
	public DecimalConstraints scaleFormat(NumberFormat format) {
		this.scaleFormat = format;
		return this;
	}

	/**
	 * Adds a validator ensuring that the input decimal's scale is not greater
	 * than the given one. Uses the current {@link #maxScaleMessage(String)
	 * validation message} and {@link #scaleFormat(NumberFormat) scale format}.
	 * 
	 * @param scale
	 *            The maximum scale to enforce on the input decimal.
	 * @return This constraints instance for method chaining.
	 */
	public DecimalConstraints maxScale(int scale) {
		addValidator(DecimalScaleValidator.max(scale, maxScaleMessage,
				scaleFormat));
		return this;
	}

	/**
	 * Sets the validation message pattern for the {@link #maxScale(int)}
	 * constraint.
	 * 
	 * @param message
	 *            The validation message pattern for the {@link #maxScale(int)}
	 *            constraint. Can be parameterized with the maximum scale of the
	 *            decimal.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #maxScale(int)
	 */
	public DecimalConstraints maxScaleMessage(String message) {
		this.maxScaleMessage = message;
		return this;
	}

	/**
	 * Sets the format to use when formatting the precision in any of the
	 * validation messages stemming from a precision constraint.
	 * 
	 * @param format
	 *            The format to use for displaying the precision in validation
	 *            messages stemming from a precision constraint.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #maxPrecision(int)
	 */
	public DecimalConstraints precisionFormat(NumberFormat format) {
		this.precisionFormat = format;
		return this;
	}

	/**
	 * Adds a validator ensuring that the input decimal's precision is not
	 * greater than the given one. Uses the current
	 * {@link #maxPrecisionMessage(String) validation message} and
	 * {@link #precisionFormat(NumberFormat) precision format}.
	 * 
	 * @param precision
	 *            The maximum precision to enforce on the input decimal.
	 * @return This constraints instance for method chaining.
	 */
	public DecimalConstraints maxPrecision(int precision) {
		addValidator(DecimalPrecisionValidator.max(precision,
				maxPrecisionMessage, precisionFormat));
		return this;
	}

	/**
	 * Sets the validation message pattern for the {@link #maxPrecision(int)}
	 * constraint.
	 * 
	 * @param message
	 *            The validation message pattern for the
	 *            {@link #maxPrecision(int)} constraint. Can be parameterized
	 *            with the maximum precision of the decimal.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #maxPrecision(int)
	 */
	public DecimalConstraints maxPrecisionMessage(String message) {
		this.maxPrecisionMessage = message;
		return this;
	}
}




/*******************************************************************************
 * Copyright (c) 2009 Ovidio Mallo 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:
 *     Ovidio Mallo - initial API and implementation (bug 183055)
 ******************************************************************************/

package org.eclipse.core.databinding.validation.constraint;

import java.util.Date;

import org.eclipse.core.internal.databinding.validation.DateRangeValidator;
import org.eclipse.core.internal.databinding.validation.NonNullValidator;

import com.ibm.icu.text.DateFormat;

/**
 * Provides a set of constraints to apply to <code>Date</code>s.
 * 
 * <p>
 * Instances of this class can be used to define a set of constraints to apply
 * to dates. In addition, the validation messages to be issued for the
 * individual constraints as well as the way in which model objects are
 * formatted in the validation messages can be configured.
 * </p>
 * 
 * @see Date
 * 
 * @noextend This class is not intended to be subclassed by clients.
 * @since 1.3
 */
public class DateConstraints extends Constraints {

	private DateFormat dateFormat = DateFormat.getDateInstance();

	private String requiredMessage = null;

	private String afterMessage = null;

	private String afterEqualMessage = null;

	private String beforeMessage = null;

	private String beforeEqualMessage = null;

	private String rangeMessage = null;

	/**
	 * Sets the format to use when formatting a date to be included in any of
	 * the validation messages.
	 * 
	 * @param format
	 *            The format to use for displaying dates in validation messages.
	 * @return This constraints instance for method chaining.
	 */
	public DateConstraints dateFormat(DateFormat format) {
		this.dateFormat = format;
		return this;
	}

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

	/**
	 * Sets the validation message for the {@link #required()} constraint.
	 * 
	 * @param message
	 *            The validation message for the {@link #required()} constraint.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #required()
	 */
	public DateConstraints requiredMessage(String message) {
		this.requiredMessage = message;
		return this;
	}

	/**
	 * Adds a validator ensuring that the input date is after the given date.
	 * Uses the current {@link #afterMessage(String) validation message} and
	 * {@link #dateFormat(DateFormat) date format}.
	 * 
	 * @param date
	 *            The date which the input date must be after.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see Date#after(Date)
	 */
	public DateConstraints after(Date date) {
		addValidator(DateRangeValidator.after(date, afterMessage, dateFormat));
		return this;
	}

	/**
	 * Sets the validation message pattern for the {@link #after(Date)}
	 * constraint.
	 * 
	 * @param message
	 *            The validation message pattern for the {@link #after(Date)}
	 *            constraint. Can be parameterized with the date which the input
	 *            date must be after.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #after(Date)
	 */
	public DateConstraints afterMessage(String message) {
		this.afterMessage = message;
		return this;
	}

	/**
	 * Adds a validator ensuring that the input date is after or on the given
	 * date. Uses the current {@link #afterEqualMessage(String) validation
	 * message} and {@link #dateFormat(DateFormat) date format}.
	 * 
	 * @param date
	 *            The date which the input date must be after or on.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see Date#after(Date)
	 * @see Date#equals(Object)
	 */
	public DateConstraints afterEqual(Date date) {
		addValidator(DateRangeValidator.afterEqual(date, afterEqualMessage,
				dateFormat));
		return this;
	}

	/**
	 * Sets the validation message pattern for the {@link #afterEqual(Date)}
	 * constraint.
	 * 
	 * @param message
	 *            The validation message pattern for the
	 *            {@link #afterEqual(Date)} constraint. Can be parameterized
	 *            with the date which the input date must be after or on.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #afterEqual(Date)
	 */
	public DateConstraints afterEqualMessage(String message) {
		this.afterEqualMessage = message;
		return this;
	}

	/**
	 * Adds a validator ensuring that the input date is before the given date.
	 * Uses the current {@link #beforeMessage(String) validation message} and
	 * {@link #dateFormat(DateFormat) date format}.
	 * 
	 * @param date
	 *            The date which the input date must be before
	 * @return This constraints instance for method chaining.
	 * 
	 * @see Date#before(Date)
	 */
	public DateConstraints before(Date date) {
		addValidator(DateRangeValidator.before(date, beforeMessage, dateFormat));
		return this;
	}

	/**
	 * Sets the validation message pattern for the {@link #before(Date)}
	 * constraint.
	 * 
	 * @param message
	 *            The validation message pattern for the {@link #before(Date)}
	 *            constraint. Can be parameterized with the date which the input
	 *            date must be before.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #before(Date)
	 */
	public DateConstraints beforeMessage(String message) {
		this.beforeMessage = message;
		return this;
	}

	/**
	 * Adds a validator ensuring that the input date is before or on the given
	 * date. Uses the current {@link #beforeEqualMessage(String) validation
	 * message} and {@link #dateFormat(DateFormat) date format}.
	 * 
	 * @param date
	 *            The date which the input date must be before or on.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see Date#before(Date)
	 * @see Date#equals(Object)
	 */
	public DateConstraints beforeEqual(Date date) {
		addValidator(DateRangeValidator.beforeEqual(date, beforeEqualMessage,
				dateFormat));
		return this;
	}

	/**
	 * Sets the validation message pattern for the {@link #beforeEqual(Date)}
	 * constraint.
	 * 
	 * @param message
	 *            The validation message pattern for the
	 *            {@link #beforeEqual(Date)} constraint. Can be parameterized
	 *            with the date which the input date must be before or on.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #beforeEqual(Date)
	 */
	public DateConstraints beforeEqualMessage(String message) {
		this.beforeEqualMessage = message;
		return this;
	}

	/**
	 * Adds a validator ensuring that the input date is within the given range.
	 * Uses the current {@link #rangeMessage(String) validation message} and
	 * {@link #dateFormat(DateFormat) date format}.
	 * 
	 * @param minDate
	 *            The lower bound of the range (inclusive).
	 * @param maxDate
	 *            The upper bound of the range (inclusive).
	 * @return This constraints instance for method chaining.
	 */
	public DateConstraints range(Date minDate, Date maxDate) {
		addValidator(DateRangeValidator.range(minDate, maxDate, rangeMessage,
				dateFormat));
		return this;
	}

	/**
	 * Sets the validation message pattern for the {@link #range(Date, Date)}
	 * constraint.
	 * 
	 * @param message
	 *            The validation message pattern for the
	 *            {@link #range(Date, Date)} constraint. Can be parameterized
	 *            with the min and max dates of the range in which the input
	 *            date must lie.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #range(Date, Date)
	 */
	public DateConstraints rangeMessage(String message) {
		this.rangeMessage = message;
		return this;
	}
}




/*******************************************************************************
 * Copyright (c) 2009 Ovidio Mallo 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:
 *     Ovidio Mallo - initial API and implementation (bug 183055)
 ******************************************************************************/

package org.eclipse.core.internal.databinding.conversion;

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

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

	private final boolean trimToNull;

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

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

		if (string != null) {
			string = string.trim();

			if (trimToNull && string.length() == 0) {
				string = null;
			}
		}

		return string;
	}
}




/*******************************************************************************
 * Copyright (c) 2009 Ovidio Mallo 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:
 *     Ovidio Mallo - initial API and implementation (bug 183055)
 ******************************************************************************/

package org.eclipse.core.databinding.editing;

import org.eclipse.core.databinding.validation.constraint.BooleanConstraints;
import org.eclipse.core.databinding.validation.constraint.Constraints;
import org.eclipse.core.databinding.validation.constraint.StringConstraints;
import org.eclipse.core.internal.databinding.conversion.BooleanToStringConverter;
import org.eclipse.core.internal.databinding.conversion.StringToBooleanConverter;
import org.eclipse.core.internal.databinding.validation.StringToBooleanValidator;

/**
 * @noextend This class is not intended to be subclassed by clients.
 * @since 1.3
 */
public class BooleanEditing extends Editing {

	/**
	 * Creates a new editing object for booleans.
	 * 
	 * @param trueValues
	 *            The set of strings representing a <code>true</code> value.
	 * @param falseValues
	 *            The set of strings representing a <code>false</code> value.
	 * @param parseErrorMessage
	 *            The validation message issued in case the input string cannot
	 *            be parsed to a boolean.
	 * 
	 * @noreference This constructor is not intended to be referenced by
	 *              clients.
	 */
	protected BooleanEditing(String[] trueValues, String[] falseValues,
			String parseErrorMessage) {
		StringToBooleanConverter targetConverter = new StringToBooleanConverter();
		BooleanToStringConverter modelConverter = new BooleanToStringConverter(
				Boolean.class);

		StringToBooleanValidator targetValidator = new StringToBooleanValidator();
		if (parseErrorMessage != null) {
			targetValidator.setParseErrorMessage(parseErrorMessage);
		}

		if (trueValues != null && falseValues != null) {
			targetValidator.setSourceStrings(trueValues, falseValues);
			targetConverter.setSourceStrings(trueValues, falseValues);
			modelConverter.setTargetStrings(trueValues[0], falseValues[0]);
		}

		setTargetConverter(targetConverter);
		setModelConverter(modelConverter);
		addTargetValidator(targetValidator);
	}

	/**
	 * Creates a new editing object which uses the default set of string
	 * representations for boolean values for parsing and displaying.
	 * 
	 * @return The new editing object for the default set of string
	 *         representations for boolean values.
	 */
	public static BooleanEditing withDefaults() {
		return withDefaults(null);
	}

	/**
	 * Creates a new editing object which uses the default set of string
	 * representations for boolean values for parsing and displaying. Uses the
	 * specified custom validation message.
	 * 
	 * @param parseErrorMessage
	 *            The validation message issued in case the input string cannot
	 *            be parsed to a boolean.
	 * @return The new editing object for the default set of string
	 *         representations for boolean values.
	 */
	public static BooleanEditing withDefaults(String parseErrorMessage) {
		return new BooleanEditing(null, null, parseErrorMessage);
	}

	/**
	 * Creates a new editing object which uses the given set of string
	 * representations for boolean values for parsing and displaying.
	 * 
	 * <p>
	 * For parsing, the given string values will be considered valid
	 * representations of {@code true} and {@code false}, respectively. For
	 * displaying, the first element of the respective array will be used for
	 * representing the corresponding boolean value.
	 * </p>
	 * 
	 * @param trueValues
	 *            The set of strings representing a <code>true</code> value.
	 * @param falseValues
	 *            The set of strings representing a <code>false</code> value.
	 * @return The new editing object for the given set of string
	 *         representations for boolean values.
	 */
	public static BooleanEditing forStringValues(String[] trueValues,
			String[] falseValues) {
		return forStringValues(trueValues, falseValues, null);
	}

	/**
	 * Creates a new editing object which uses the given set of string
	 * representations for boolean values for parsing and displaying. Uses the
	 * specified custom validation message.
	 * 
	 * <p>
	 * For parsing, the given string values will be considered valid
	 * representations of {@code true} and {@code false}, respectively. For
	 * displaying, the first element of the respective array will be used for
	 * representing the corresponding boolean value.
	 * </p>
	 * 
	 * @param trueValues
	 *            The set of strings representing a <code>true</code> value.
	 * @param falseValues
	 *            The set of strings representing a <code>false</code> value.
	 * @param parseErrorMessage
	 *            The validation message issued in case the input string cannot
	 *            be parsed to a boolean.
	 * @return The new editing object for the given set of string
	 *         representations for boolean values.
	 */
	public static BooleanEditing forStringValues(String[] trueValues,
			String[] falseValues, String parseErrorMessage) {
		return new BooleanEditing(trueValues, falseValues, parseErrorMessage);
	}

	/**
	 * Returns the target constraints to apply.
	 * 
	 * <p>
	 * This method provides a typesafe access to the {@link StringConstraints
	 * string target constraints} of this editing object and is equivalent to
	 * {@code (StringConstraints) targetConstraints()}.
	 * </p>
	 * 
	 * @return The target constraints to apply.
	 * 
	 * @see #targetConstraints()
	 * @see StringConstraints
	 */
	public StringConstraints targetStringConstraints() {
		return (StringConstraints) targetConstraints();
	}

	/**
	 * Returns the model constraints to apply.
	 * 
	 * <p>
	 * This method provides a typesafe access to the {@link BooleanConstraints
	 * bool model constraints} of this editing object and is equivalent to
	 * {@code (BooleanConstraints) modelConstraints()}.
	 * </p>
	 * 
	 * @return The model constraints to apply.
	 * 
	 * @see #modelConstraints()
	 * @see BooleanConstraints
	 */
	public BooleanConstraints modelBooleanConstraints() {
		return (BooleanConstraints) modelConstraints();
	}

	/**
	 * Returns the before-set model constraints to apply.
	 * 
	 * <p>
	 * This method provides a typesafe access to the {@link BooleanConstraints
	 * bool before-set model constraints} of this editing object and is
	 * equivalent to {@code (BooleanConstraints) beforeSetModelConstraints()}.
	 * </p>
	 * 
	 * @return The before-set model constraints to apply.
	 * 
	 * @see #beforeSetModelConstraints()
	 * @see BooleanConstraints
	 */
	public BooleanConstraints beforeSetModelBooleanConstraints() {
		return (BooleanConstraints) beforeSetModelConstraints();
	}

	protected Constraints createTargetConstraints() {
		return new StringConstraints();
	}

	protected Constraints createModelConstraints() {
		return new BooleanConstraints();
	}

	protected Constraints createBeforeSetModelConstraints() {
		return new BooleanConstraints();
	}

	/**
	 * Convenience method which adds a {@link BooleanConstraints#required()
	 * required constraint} to the set of {@link #modelBooleanConstraints()}.
	 * 
	 * @return This editing instance for method chaining.
	 * 
	 * @see BooleanConstraints#required()
	 * @see #modelBooleanConstraints()
	 */
	public BooleanEditing required() {
		modelBooleanConstraints().required();
		return this;
	}
}




/*******************************************************************************
 * Copyright (c) 2009 Ovidio Mallo 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:
 *     Ovidio Mallo - initial API and implementation (bug 183055)
 ******************************************************************************/

package org.eclipse.core.databinding.validation.constraint;

import org.eclipse.core.internal.databinding.validation.NonNullValidator;

/**
 * Provides a set of constraints to apply to <code>Boolean</code>s.
 * 
 * <p>
 * Instances of this class can be used to define a set of constraints to apply
 * to booleans. In addition, the validation messages to be issued for the
 * individual constraints can be configured.
 * </p>
 * 
 * @noextend This class is not intended to be subclassed by clients.
 * @since 1.3
 */
public class BooleanConstraints extends Constraints {

	private String requiredMessage = null;

	/**
	 * Adds a validator ensuring that the boolean value is not <code>null</code>
	 * . Uses the current {@link #requiredMessage(String) validation message}.
	 * 
	 * @return This constraints instance for method chaining.
	 */
	public BooleanConstraints required() {
		addValidator(new NonNullValidator(requiredMessage));
		return this;
	}

	/**
	 * Sets the validation message for the {@link #required()} constraint.
	 * 
	 * @param message
	 *            The validation message for the {@link #required()} constraint.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #required()
	 */
	public BooleanConstraints requiredMessage(String message) {
		this.requiredMessage = message;
		return this;
	}
}




/*******************************************************************************
 * Copyright (c) 2009 Ovidio Mallo 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:
 *     Ovidio Mallo - initial API and implementation (bug 183055)
 ******************************************************************************/

package org.eclipse.core.databinding.validation.constraint;

import java.math.BigDecimal;

import org.eclipse.core.internal.databinding.validation.BigDecimalRangeValidator;
import org.eclipse.core.internal.databinding.validation.DecimalPrecisionValidator;
import org.eclipse.core.internal.databinding.validation.DecimalScaleValidator;
import org.eclipse.core.internal.databinding.validation.NonNullValidator;

import com.ibm.icu.text.NumberFormat;

/**
 * Provides a set of constraints to apply to <code>BigDecimal</code>s.
 * 
 * <p>
 * Instances of this class can be used to define a set of constraints to apply
 * to BigDecimal numbers. In addition, the validation messages to be issued for
 * the individual constraints as well as the way in which model objects are
 * formatted in the validation messages can be configured.
 * </p>
 * 
 * @see BigDecimal
 * 
 * @noextend This class is not intended to be subclassed by clients.
 * @since 1.3
 */
public class BigDecimalConstraints extends Constraints {

	private NumberFormat bigDecimalFormat = NumberFormat.getNumberInstance();

	private NumberFormat scaleFormat = NumberFormat.getIntegerInstance();

	private NumberFormat precisionFormat = NumberFormat.getIntegerInstance();

	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 String maxScaleMessage = null;

	private String maxPrecisionMessage = null;

	/**
	 * Sets the format to use when formatting a BigDecimal to be included in any
	 * of the validation messages.
	 * 
	 * @param format
	 *            The format to use for displaying BigDecimals in validation
	 *            messages.
	 * @return This constraints instance for method chaining.
	 */
	public BigDecimalConstraints bigDecimalFormat(NumberFormat format) {
		this.bigDecimalFormat = format;
		return this;
	}

	/**
	 * Adds a validator ensuring that the input BigDecimal is not
	 * <code>null</code>. Uses the current {@link #requiredMessage(String)
	 * validation message}.
	 * 
	 * @return This constraints instance for method chaining.
	 */
	public BigDecimalConstraints required() {
		addValidator(new NonNullValidator(requiredMessage));
		return this;
	}

	/**
	 * Sets the validation message for the {@link #required()} constraint.
	 * 
	 * @param message
	 *            The validation message for the {@link #required()} constraint.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #required()
	 */
	public BigDecimalConstraints requiredMessage(String message) {
		this.requiredMessage = message;
		return this;
	}

	/**
	 * Adds a validator ensuring that the input BigDecimal is greater than the
	 * given number. Uses the current {@link #greaterMessage(String) validation
	 * message} and {@link #bigDecimalFormat(NumberFormat) BigDecimal format}.
	 * 
	 * @param number
	 *            The number which the input BigDecimal must be greater than.
	 * @return This constraints instance for method chaining.
	 */
	public BigDecimalConstraints greater(BigDecimal number) {
		addValidator(BigDecimalRangeValidator.greater(number, greaterMessage,
				bigDecimalFormat));
		return this;
	}

	/**
	 * Sets the validation message pattern for the {@link #greater(BigDecimal)}
	 * constraint.
	 * 
	 * @param message
	 *            The validation message pattern for the
	 *            {@link #greater(BigDecimal)} constraint. Can be parameterized
	 *            with the number which the input BigDecimal must be greater
	 *            than.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #greater(BigDecimal)
	 */
	public BigDecimalConstraints greaterMessage(String message) {
		this.greaterMessage = message;
		return this;
	}

	/**
	 * Adds a validator ensuring that the input BigDecimal is greater than or
	 * equal to the given number. Uses the current
	 * {@link #greaterEqualMessage(String) validation message} and
	 * {@link #bigDecimalFormat(NumberFormat) BigDecimal format}.
	 * 
	 * @param number
	 *            The number which the input BigDecimal must be greater than or
	 *            equal to.
	 * @return This constraints instance for method chaining.
	 */
	public BigDecimalConstraints greaterEqual(BigDecimal number) {
		addValidator(BigDecimalRangeValidator.greaterEqual(number,
				greaterEqualMessage, bigDecimalFormat));
		return this;
	}

	/**
	 * Sets the validation message pattern for the
	 * {@link #greaterEqual(BigDecimal)} constraint.
	 * 
	 * @param message
	 *            The validation message pattern for the
	 *            {@link #greaterEqual(BigDecimal)} constraint. Can be
	 *            parameterized with the number which the input BigDecimal must
	 *            be greater than or equal to.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #greaterEqual(BigDecimal)
	 */
	public BigDecimalConstraints greaterEqualMessage(String message) {
		this.greaterEqualMessage = message;
		return this;
	}

	/**
	 * Adds a validator ensuring that the input BigDecimal is less than the
	 * given number. Uses the current {@link #lessMessage(String) validation
	 * message} and {@link #bigDecimalFormat(NumberFormat) BigDecimal format}.
	 * 
	 * @param number
	 *            The number which the input BigDecimal must be less than.
	 * @return This constraints instance for method chaining.
	 */
	public BigDecimalConstraints less(BigDecimal number) {
		addValidator(BigDecimalRangeValidator.less(number, lessMessage,
				bigDecimalFormat));
		return this;
	}

	/**
	 * Sets the validation message pattern for the {@link #less(BigDecimal)}
	 * constraint.
	 * 
	 * @param message
	 *            The validation message pattern for the
	 *            {@link #less(BigDecimal)} constraint. Can be parameterized
	 *            with the number which the input BigDecimal must be less than.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #less(BigDecimal)
	 */
	public BigDecimalConstraints lessMessage(String message) {
		this.lessMessage = message;
		return this;
	}

	/**
	 * Adds a validator ensuring that the input BigDecimal is less than or equal
	 * to the given number. Uses the current {@link #lessEqualMessage(String)
	 * validation message} and {@link #bigDecimalFormat(NumberFormat) BigDecimal
	 * format}.
	 * 
	 * @param number
	 *            The number which the input BigDecimal must be less than or
	 *            equal to.
	 * @return This constraints instance for method chaining.
	 */
	public BigDecimalConstraints lessEqual(BigDecimal number) {
		addValidator(BigDecimalRangeValidator.greaterEqual(number,
				lessEqualMessage, bigDecimalFormat));
		return this;
	}

	/**
	 * Sets the validation message pattern for the
	 * {@link #lessEqual(BigDecimal)} constraint.
	 * 
	 * @param message
	 *            The validation message pattern for the
	 *            {@link #lessEqual(BigDecimal)} constraint. Can be
	 *            parameterized with the number which the input BigDecimal must
	 *            be less than or equal to.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #lessEqual(BigDecimal)
	 */
	public BigDecimalConstraints lessEqualMessage(String message) {
		this.lessEqualMessage = message;
		return this;
	}

	/**
	 * Adds a validator ensuring that the input BigDecimal is within the given
	 * range. Uses the current {@link #rangeMessage(String) validation message}
	 * and {@link #bigDecimalFormat(NumberFormat) BigDecimal format}.
	 * 
	 * @param min
	 *            The lower bound of the range (inclusive).
	 * @param max
	 *            The upper bound of the range (inclusive).
	 * @return This constraints instance for method chaining.
	 */
	public BigDecimalConstraints range(BigDecimal min, BigDecimal max) {
		addValidator(BigDecimalRangeValidator.range(min, max, rangeMessage,
				bigDecimalFormat));
		return this;
	}

	/**
	 * Sets the validation message pattern for the
	 * {@link #range(BigDecimal, BigDecimal)} constraint.
	 * 
	 * @param message
	 *            The validation message pattern for the
	 *            {@link #range(BigDecimal, BigDecimal)} constraint. Can be
	 *            parameterized with the min and max values of the range in
	 *            which the input BigDecimal must lie.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #range(BigDecimal, BigDecimal)
	 */
	public BigDecimalConstraints rangeMessage(String message) {
		this.rangeMessage = message;
		return this;
	}

	/**
	 * Adds a validator ensuring that the input BigDecimal is positive. Uses the
	 * current {@link #positiveMessage(String) validation message} and
	 * {@link #bigDecimalFormat(NumberFormat) BigDecimal format}.
	 * 
	 * @return This constraints instance for method chaining.
	 */
	public BigDecimalConstraints positive() {
		addValidator(BigDecimalRangeValidator.positive(positiveMessage,
				bigDecimalFormat));
		return this;
	}

	/**
	 * Sets the validation message pattern for the {@link #positive()}
	 * constraint.
	 * 
	 * @param message
	 *            The validation message pattern for the {@link #positive()}
	 *            constraint.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #positive()
	 */
	public BigDecimalConstraints positiveMessage(String message) {
		this.positiveMessage = message;
		return this;
	}

	/**
	 * Adds a validator ensuring that the input BigDecimal is non-negative. Uses
	 * the current {@link #nonNegativeMessage(String) validation message} and
	 * {@link #bigDecimalFormat(NumberFormat) BigDecimal format}.
	 * 
	 * @return This constraints instance for method chaining.
	 */
	public BigDecimalConstraints nonNegative() {
		addValidator(BigDecimalRangeValidator.nonNegative(nonNegativeMessage,
				bigDecimalFormat));
		return this;
	}

	/**
	 * Sets the validation message pattern for the {@link #nonNegative()}
	 * constraint.
	 * 
	 * @param message
	 *            The validation message pattern for the {@link #nonNegative()}
	 *            constraint.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #nonNegative()
	 */
	public BigDecimalConstraints nonNegativeMessage(String message) {
		this.nonNegativeMessage = message;
		return this;
	}

	/**
	 * Sets the format to use when formatting the scale in any of the validation
	 * messages stemming from a scale constraint.
	 * 
	 * @param format
	 *            The format to use for displaying the scale in validation
	 *            messages stemming from a scale constraint.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #maxScale(int)
	 */
	public BigDecimalConstraints scaleFormat(NumberFormat format) {
		this.scaleFormat = format;
		return this;
	}

	/**
	 * Adds a validator ensuring that the input BigDecimal's scale is not
	 * greater than the given one. Uses the current
	 * {@link #maxScaleMessage(String) validation message} and
	 * {@link #scaleFormat(NumberFormat) scale format}.
	 * 
	 * @param scale
	 *            The maximum scale to enforce on the input BigDecimal.
	 * @return This constraints instance for method chaining.
	 */
	public BigDecimalConstraints maxScale(int scale) {
		addValidator(DecimalScaleValidator.max(scale, maxScaleMessage,
				scaleFormat));
		return this;
	}

	/**
	 * Sets the validation message pattern for the {@link #maxScale(int)}
	 * constraint.
	 * 
	 * @param message
	 *            The validation message pattern for the {@link #maxScale(int)}
	 *            constraint. Can be parameterized with the maximum scale of the
	 *            BigDecimal.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #maxScale(int)
	 */
	public BigDecimalConstraints maxScaleMessage(String message) {
		this.maxScaleMessage = message;
		return this;
	}

	/**
	 * Sets the format to use when formatting the precision in any of the
	 * validation messages stemming from a precision constraint.
	 * 
	 * @param format
	 *            The format to use for displaying the precision in validation
	 *            messages stemming from a precision constraint.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #maxPrecision(int)
	 */
	public BigDecimalConstraints precisionFormat(NumberFormat format) {
		this.precisionFormat = format;
		return this;
	}

	/**
	 * Adds a validator ensuring that the input decimal's precision is not
	 * greater than the given one. Uses the current
	 * {@link #maxPrecisionMessage(String) validation message} and
	 * {@link #precisionFormat(NumberFormat) precision format}.
	 * 
	 * @param precision
	 *            The maximum precision to enforce on the input decimal.
	 * @return This constraints instance for method chaining.
	 */
	public BigDecimalConstraints maxPrecision(int precision) {
		addValidator(DecimalPrecisionValidator.max(precision,
				maxPrecisionMessage, precisionFormat));
		return this;
	}

	/**
	 * Sets the validation message pattern for the {@link #maxPrecision(int)}
	 * constraint.
	 * 
	 * @param message
	 *            The validation message pattern for the
	 *            {@link #maxPrecision(int)} constraint. Can be parameterized
	 *            with the maximum precision of the decimal.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #maxPrecision(int)
	 */
	public BigDecimalConstraints maxPrecisionMessage(String message) {
		this.maxPrecisionMessage = message;
		return this;
	}
}




/*******************************************************************************
 * Copyright (c) 2009 Ovidio Mallo 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:
 *     Ovidio Mallo - initial API and implementation (bug 183055)
 ******************************************************************************/

package org.eclipse.core.internal.databinding.validation;

import java.math.BigInteger;

import com.ibm.icu.text.NumberFormat;

/**
 * Provides validations for BigIntegers which must lie within an open/closed
 * range.
 * 
 * @since 1.3
 */
public class BigIntegerRangeValidator extends NumberRangeValidator {

	private static final BigInteger ZERO = new BigInteger("0"); //$NON-NLS-1$
	private static final BigInteger ONE = new BigInteger("1"); //$NON-NLS-1$

	/**
	 * Single constructor which supports the individual integer range types.
	 * 
	 * @param min
	 *            The min BigInteger of the range or <code>null</code> in case
	 *            no lower bound is defined.
	 * @param max
	 *            The max BigInteger of the range or <code>null</code> in case
	 *            no upper bound is defined.
	 * @param minConstraint
	 *            The type of constraint imposed by the lower bound of the
	 *            range.
	 * @param maxConstraint
	 *            The type of constraint imposed by the upper bound of the
	 *            range.
	 * @param validationMessage
	 *            The validation message pattern to use. Can be parameterized by
	 *            the lower and upper bound of the range, if defined.
	 * @param format
	 *            The BigInteger format to use for formatting integers in the
	 *            validation message.
	 */
	private BigIntegerRangeValidator(BigInteger min, BigInteger max,
			int minConstraint, int maxConstraint, String validationMessage,
			NumberFormat format) {
		super(min, max, minConstraint, maxConstraint, validationMessage, format);
	}

	/**
	 * Creates a validator which checks that an input BigInteger is greater than
	 * the given number.
	 * 
	 * @param number
	 *            The reference number of the greater constraint.
	 * @param validationMessage
	 *            The validation message pattern to use. Can be parameterized
	 *            with the given reference number.
	 * @param format
	 *            The display format to use for formatting BigIntegers in the
	 *            validation message.
	 * @return The validator instance.
	 */
	public static BigIntegerRangeValidator greater(BigInteger number,
			String validationMessage, NumberFormat format) {
		return new BigIntegerRangeValidator(number, null, GREATER, UNDEFINED,
				defaultIfNull(validationMessage, GREATER_MESSAGE), format);
	}

	/**
	 * Creates a validator which checks that an input BigInteger is greater than
	 * or equal to the given number.
	 * 
	 * @param number
	 *            The reference number of the greater-equal constraint.
	 * @param validationMessage
	 *            The validation message pattern to use. Can be parameterized
	 *            with the given reference number.
	 * @param format
	 *            The display format to use for formatting BigIntegers in the
	 *            validation message.
	 * @return The validator instance.
	 */
	public static BigIntegerRangeValidator greaterEqual(BigInteger number,
			String validationMessage, NumberFormat format) {
		return new BigIntegerRangeValidator(number, null, GREATER_EQUAL,
				UNDEFINED, defaultIfNull(validationMessage,
						GREATER_EQUAL_MESSAGE), format);
	}

	/**
	 * Creates a validator which checks that an input BigInteger is less than
	 * the given number.
	 * 
	 * @param number
	 *            The reference number of the less constraint.
	 * @param validationMessage
	 *            The validation message pattern to use. Can be parameterized
	 *            with the given reference number.
	 * @param format
	 *            The display format to use for formatting BigIntegers in the
	 *            validation message.
	 * @return The validator instance.
	 */
	public static BigIntegerRangeValidator less(BigInteger number,
			String validationMessage, NumberFormat format) {
		return new BigIntegerRangeValidator(null, number, UNDEFINED, LESS,
				defaultIfNull(validationMessage, LESS_MESSAGE), format);
	}

	/**
	 * Creates a validator which checks that an input BigInteger is less than or
	 * equal to the given number.
	 * 
	 * @param number
	 *            The reference number of the less-equal constraint.
	 * @param validationMessage
	 *            The validation message pattern to use. Can be parameterized
	 *            with the given reference number.
	 * @param format
	 *            The display format to use for formatting BigIntegers in the
	 *            validation message.
	 * @return The validator instance.
	 */
	public static BigIntegerRangeValidator lessEqual(BigInteger number,
			String validationMessage, NumberFormat format) {
		return new BigIntegerRangeValidator(null, number, UNDEFINED,
				LESS_EQUAL,
				defaultIfNull(validationMessage, LESS_EQUAL_MESSAGE), format);
	}

	/**
	 * Creates a validator which checks that an input BigInteger is within the
	 * given range.
	 * 
	 * @param min
	 *            The lower bound of the range (inclusive).
	 * @param max
	 *            The upper bound of the range (inclusive).
	 * @param validationMessage
	 *            The validation message pattern to use. Can be parameterized
	 *            with the range's lower and upper bound.
	 * @param format
	 *            The display format to use for formatting BigIntegers in the
	 *            validation message.
	 * @return The validator instance.
	 */
	public static BigIntegerRangeValidator range(BigInteger min,
			BigInteger max, String validationMessage, NumberFormat format) {
		return new BigIntegerRangeValidator(min, max, GREATER_EQUAL,
				LESS_EQUAL, defaultIfNull(validationMessage,
						WITHIN_RANGE_MESSAGE), format);
	}

	/**
	 * Creates a validator which checks that an input BigInteger is positive.
	 * 
	 * @param validationMessage
	 *            The validation message to use.
	 * @param format
	 *            The display format to use for formatting BigIntegers in the
	 *            validation message.
	 * @return The validator instance.
	 */
	public static BigIntegerRangeValidator positive(String validationMessage,
			NumberFormat format) {
		return new BigIntegerRangeValidator(ONE, null, GREATER_EQUAL,
				UNDEFINED, defaultIfNull(validationMessage, POSITIVE_MESSAGE),
				format);
	}

	/**
	 * Creates a validator which checks that an input BigInteger is
	 * non-negative.
	 * 
	 * @param validationMessage
	 *            The validation message to use.
	 * @param format
	 *            The display format to use for formatting BigIntegers in the
	 *            validation message.
	 * @return The validator instance.
	 */
	public static BigIntegerRangeValidator nonNegative(
			String validationMessage, NumberFormat format) {
		return new BigIntegerRangeValidator(ZERO, null, GREATER_EQUAL,
				UNDEFINED, defaultIfNull(validationMessage,
						NON_NEGATIVE_MESSAGE), format);
	}

	protected int compare(Number number1, Number number2) {
		BigInteger bigInteger1 = (BigInteger) number1;
		BigInteger bigInteger2 = (BigInteger) number2;
		return bigInteger1.compareTo(bigInteger2);
	}

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




/*******************************************************************************
 * Copyright (c) 2009 Ovidio Mallo 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:
 *     Ovidio Mallo - initial API and implementation (bug 183055)
 ******************************************************************************/

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.internal.databinding.BindingMessages;
import org.eclipse.core.runtime.IStatus;

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

/**
 * Provides validations for the precision of decimal numbers.
 * 
 * @since 1.3
 */
public class DecimalPrecisionValidator implements IValidator {

	private static final String MAX_PRECISION_VALIDATION_MESSAGE = BindingMessages
			.getString(BindingMessages.VALIDATE_DECIMAL_MAX_PRECISION);

	private final int maxPrecision;

	private final String validationMessage;

	private String formattedValidationMessage;

	private final NumberFormat precisionFormat;

	private DecimalPrecisionValidator(int maxPrecision,
			String validationMessage, NumberFormat precisionFormat) {
		this.maxPrecision = maxPrecision;
		this.validationMessage = validationMessage != null ? validationMessage
				: MAX_PRECISION_VALIDATION_MESSAGE;
		this.precisionFormat = precisionFormat;
	}

	/**
	 * Creates a validator which checks that an input decimal has a precision
	 * which is less or equal to the given precision.
	 * 
	 * @param maxPrecision
	 *            The maximum precision to enforce on the input decimal.
	 * @param validationMessage
	 *            The validation message pattern to use. Can be parameterized
	 *            with the maximum precision to be enforced.
	 * @param precisionFormat
	 *            The display format to use for formatting the precision in the
	 *            validation message.
	 * @return The validator instance.
	 */
	public static DecimalPrecisionValidator max(int maxPrecision,
			String validationMessage, NumberFormat precisionFormat) {
		return new DecimalPrecisionValidator(maxPrecision, validationMessage,
				precisionFormat);
	}

	public IStatus validate(Object value) {
		if (value != null) {
			Number number = (Number) value;
			final int precision;
			if (number instanceof BigDecimal) {
				precision = computePrecision(((BigDecimal) number));
			} else {
				precision = computePrecision(new BigDecimal(number
						.doubleValue()));
			}
			if (precision > maxPrecision) {
				return ValidationStatus.error(getFormattedValidationMessage());
			}
		}
		return ValidationStatus.ok();
	}

	private static int computePrecision(BigDecimal bigDecimal) {
		// In Java 1.4, there is no direct API for retrieving the precision of
		// a BigDecimal so we use the length of the string representation of the
		// unscaled BigInteger value of the BigDecimal to actually compute it.
		return bigDecimal.unscaledValue().abs().toString().length();
	}

	private synchronized String getFormattedValidationMessage() {
		if (formattedValidationMessage == null) {
			formattedValidationMessage = MessageFormat.format(
					validationMessage, getValidationMessageArguments());
		}
		return formattedValidationMessage;
	}

	private String[] getValidationMessageArguments() {
		synchronized (precisionFormat) {
			return new String[] { precisionFormat.format(new Integer(
					maxPrecision)) };
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2007 Ovidio Mallo 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:
 *     Ovidio Mallo - initial API and implementation (bug 183055)
 ******************************************************************************/

package org.eclipse.core.internal.databinding.validation;

/**
 * Validates that a string is of the appropriate format for a BigDecimal.
 * 
 * @since 1.3
 */
public class StringToBigDecimalValidator extends
		AbstractStringToNumberValidator {

	/**
	 * @param converter
	 */
	public StringToBigDecimalValidator(NumberFormatConverter converter) {
		super(converter, null, null);
	}

	protected boolean isInRange(Number number) {
		return true;
	}
}




/*******************************************************************************
 * Copyright (c) 2009 Ovidio Mallo 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:
 *     Ovidio Mallo - initial API and implementation (bug 183055)
 ******************************************************************************/

package org.eclipse.core.internal.databinding.validation;

import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import java.util.StringTokenizer;

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

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

	// TODO: Some of this code is duplicated from StringToBooleanPrimitiveConverter!
	private static final String[] DEFAULT_TRUE_VALUES;
	private static final String[] DEFAULT_FALSE_VALUES;

	static {
		String delimiter = BindingMessages.getString(BindingMessages.VALUE_DELIMITER);
		String values = BindingMessages.getString(BindingMessages.TRUE_STRING_VALUES);
		DEFAULT_TRUE_VALUES = valuesToSortedArray(delimiter, values);

		values = BindingMessages.getString(BindingMessages.FALSE_STRING_VALUES);
		DEFAULT_FALSE_VALUES = valuesToSortedArray(delimiter, values);
	}

	private String[] trueValues = DEFAULT_TRUE_VALUES;
	private String[] falseValues = DEFAULT_FALSE_VALUES;

	private String parseErrorMessage = BindingMessages.getString(BindingMessages.VALIDATE_INVALID_BOOLEAN_STRING);

	/**
	 * Returns a sorted array with all values converted to upper case.
	 *
	 * @param delimiter
	 * @param values
	 * @return sorted array of values
	 */
	private static String[] valuesToSortedArray(String delimiter, String values) {
		List list = new LinkedList();
		StringTokenizer tokenizer = new StringTokenizer(values, delimiter);
		while (tokenizer.hasMoreTokens()) {
			list.add(tokenizer.nextToken().toUpperCase());
		}

		String[] array = (String[]) list.toArray(new String[list.size()]);
		Arrays.sort(array);

		return array;
	}

	/**
	 * Sets the validation message to be used in case the source string does not
	 * represent a valid boolean value.
	 * 
	 * @param message
	 *            The validation message to be used in case the source string
	 *            does not represent a valid boolean value.
	 */
	public final void setParseErrorMessage(String message) {
		this.parseErrorMessage = message;
	}

	/**
	 * Sets the string values which are considered to represent a
	 * <code>true</code> and <code>false</code> value, respectively.
	 * 
	 * <p>
	 * Note that the capitalization of the provided strings is ignored.
	 * </p>
	 * 
	 * @param trueValues
	 *            The set of strings representing a <code>true</code> value.
	 * @param falseValues
	 *            The set of strings representing a <code>false</code> value.
	 */
	public final void setSourceStrings(String[] trueValues, String[] falseValues) {
		this.trueValues = new String[trueValues.length];
		for (int i = 0; i < trueValues.length; i++) {
			this.trueValues[i] = trueValues[i].toUpperCase();
		}
		Arrays.sort(this.trueValues); // for binary search

		this.falseValues = new String[falseValues.length];
		for (int i = 0; i < falseValues.length; i++) {
			this.falseValues[i] = falseValues[i].toUpperCase();
		}
		Arrays.sort(this.falseValues); // for binary search
	}

	public IStatus validate(Object value) {
		String source = (String) value;
		if (source != null && source.length() != 0) {
			source = source.toUpperCase();
			if (Arrays.binarySearch(trueValues, source) < 0
					&& Arrays.binarySearch(falseValues, source) < 0) {
				return ValidationStatus.error(parseErrorMessage);
			}
		}
		return ValidationStatus.ok();
	}
}




/*******************************************************************************
 * Copyright (c) 2009 Ovidio Mallo 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:
 *     Ovidio Mallo - initial API and implementation (bug 183055)
 ******************************************************************************/

package org.eclipse.core.databinding.validation.constraint;

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

import org.eclipse.core.databinding.util.Policy;
import org.eclipse.core.databinding.validation.IValidator;
import org.eclipse.core.internal.databinding.BindingMessages;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.MultiStatus;
import org.eclipse.core.runtime.Status;

/**
 * This class allows to aggregate a set of {@link IValidator validators} and to
 * combine their individual validation statuses in different ways.
 * 
 * <p>
 * The set of validators to be applied can be {@link #addValidator(IValidator)
 * added} to a constraints object from which an aggregate validator can then be
 * {@link #createValidator() created} which combines the statuses of all the
 * accumulated validators as dictated by the specified
 * {@link #aggregationPolicy(int) aggregation policy}.
 * </p>
 * 
 * @see IValidator
 * 
 * @since 1.3
 */
public class Constraints {

	/**
	 * Constant denoting an aggregation strategy that merges multiple non-OK
	 * status objects in a {@link MultiStatus}. Returns an OK status result if
	 * all statuses from the set of validators to apply are an OK status.
	 * Returns a single status if there is only one non-OK status.
	 * 
	 * @see #aggregationPolicy(int)
	 */
	public static final int AGGREGATION_MERGED = 1;

	/**
	 * Constant denoting an aggregation strategy that always returns the
	 * <i>most</i> severe status from the set of validators to apply. If there
	 * is more than one status at the same severity level, it picks the first
	 * one it encounters.
	 * 
	 * @see #aggregationPolicy(int)
	 */
	public static final int AGGREGATION_MAX_SEVERITY = 2;

	/**
	 * Constant denoting an aggregation strategy that always returns the
	 * <i>least</i> severe status from the set of validators to apply. If there
	 * is more than one status at the same severity level, it picks the first
	 * one it encounters.
	 * 
	 * @see #aggregationPolicy(int)
	 */
	public static final int AGGREGATION_MIN_SEVERITY = 3;

	// Will be initialized lazily.
	private List validators = null;

	private IValidator cachedValidator = null;

	private int aggregationPolicy = AGGREGATION_MAX_SEVERITY;

	/**
	 * Adds a custom validator to the set of constraints to apply.
	 * 
	 * @param validator
	 *            The custom validator to add to the set of constraints.
	 * @return This constraints instance for method chaining.
	 */
	public final Constraints addValidator(IValidator validator) {
		if (validators == null) {
			validators = new ArrayList(2);
		}
		validators.add(validator);
		cachedValidator = null;
		return this;
	}

	/**
	 * Sets the aggregation policy to apply to the individual validations which
	 * constitute this set of constraints.
	 * 
	 * @param policy
	 *            The validation aggregation policy to set. Must be one of
	 *            {@link #AGGREGATION_MERGED}, {@link #AGGREGATION_MAX_SEVERITY}
	 *            or {@link #AGGREGATION_MIN_SEVERITY}.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #AGGREGATION_MERGED
	 * @see #AGGREGATION_MAX_SEVERITY
	 * @see #AGGREGATION_MIN_SEVERITY
	 */
	public final Constraints aggregationPolicy(int policy) {
		this.aggregationPolicy = policy;
		cachedValidator = null;
		return this;
	}

	/**
	 * Creates a validator which enforces the current set of constraints.
	 * 
	 * <p>
	 * Note that this method will return <code>null</code> in case the set of
	 * constraints to apply is empty.
	 * </p>
	 * 
	 * @return A validator which enforces the current set of constraints. May be
	 *         <code>null</code>.
	 */
	public final IValidator createValidator() {
		if (validators != null && !validators.isEmpty()) {
			if (cachedValidator == null) {
				if (validators.size() == 1) {
					cachedValidator = (IValidator) validators.get(0);
				} else {
					IValidator[] currentValidators = (IValidator[]) validators
							.toArray(new IValidator[validators.size()]);
					cachedValidator = new ConstraintsValidator(
							currentValidators, aggregationPolicy);
				}
			}
			return cachedValidator;
		}
		return null;
	}

	private static final class ConstraintsValidator implements IValidator {

		private final IValidator[] validators;

		private final int aggregationPolicy;

		public ConstraintsValidator(IValidator[] validators,
				int aggregationPolicy) {
			this.validators = validators;
			this.aggregationPolicy = aggregationPolicy;
		}

		public IStatus validate(Object value) {
			switch (aggregationPolicy) {
			case AGGREGATION_MERGED:
				return validateMerged(value);
			case AGGREGATION_MAX_SEVERITY:
				return validateMaxSeverity(value);
			case AGGREGATION_MIN_SEVERITY:
				return validateMinSeverity(value);
			default:
				throw new IllegalArgumentException(
						"Unsupported aggregationPolicy: " + aggregationPolicy); //$NON-NLS-1$
			}
		}

		private IStatus validateMerged(Object value) {
			List statuses = new ArrayList();
			for (int i = 0; i < validators.length; i++) {
				IValidator validator = validators[i];
				IStatus status = validator.validate(value);
				if (!status.isOK()) {
					statuses.add(status);
				}
			}

			if (statuses.size() == 1) {
				return (IStatus) statuses.get(0);
			}

			if (!statuses.isEmpty()) {
				MultiStatus result = new MultiStatus(Policy.JFACE_DATABINDING,
						0, BindingMessages
								.getString(BindingMessages.MULTIPLE_PROBLEMS),
						null);
				for (Iterator it = statuses.iterator(); it.hasNext();) {
					IStatus status = (IStatus) it.next();
					result.merge(status);
				}
				return result;
			}

			return Status.OK_STATUS;
		}

		private IStatus validateMaxSeverity(Object value) {
			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() > maxStatus.getSeverity()) {
					maxStatus = status;
				}
			}
			return maxStatus;
		}

		private IStatus validateMinSeverity(Object value) {
			IStatus minStatus = null;
			for (int i = 0; i < validators.length; i++) {
				IValidator validator = validators[i];
				IStatus status = validator.validate(value);
				if (minStatus == null
						|| status.getSeverity() < minStatus.getSeverity()) {
					minStatus = status;
				}
			}
			return minStatus != null ? minStatus : Status.OK_STATUS;
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2009 Ovidio Mallo 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:
 *     Ovidio Mallo - initial API and implementation (bug 183055)
 ******************************************************************************/

package org.eclipse.core.databinding.editing;

import org.eclipse.core.databinding.Binding;
import org.eclipse.core.databinding.DataBindingContext;
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.observable.list.IObservableList;
import org.eclipse.core.databinding.observable.set.IObservableSet;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.core.databinding.validation.IValidator;
import org.eclipse.core.databinding.validation.constraint.Constraints;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.MultiStatus;

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

	private Constraints targetConstraints;

	private Constraints modelConstraints;

	private Constraints beforeSetModelConstraints;

	private IConverter targetConverter;

	private IConverter modelConverter;

	/**
	 * Default constructor which creates an unconfigured editing instance.
	 */
	protected Editing() {
		// empty editing instance
	}

	/**
	 * Creates an unconfigured editing instance.
	 * 
	 * @return A new, unconfigured editing instance.
	 */
	public static Editing create() {
		return new Editing();
	}

	/**
	 * Creates an editing instance with the given target-to-model and
	 * model-to-target converters.
	 * 
	 * @param t2mConverter
	 *            The target-to-model converter to set. May be <code>null</code>
	 *            .
	 * @param m2tConverter
	 *            The model-to-target converter to set. May be <code>null</code>
	 *            .
	 * @return A new editing instance with the given target-to-model and
	 *         model-to-target converters.
	 */
	public static Editing withConverters(IConverter t2mConverter,
			IConverter m2tConverter) {
		Editing editing = new Editing();
		editing.setTargetConverter(t2mConverter);
		editing.setModelConverter(m2tConverter);
		return editing;
	}

	/**
	 * Returns the target constraints to apply.
	 * 
	 * @return The target constraints to apply.
	 * 
	 * @see #createTargetConstraints()
	 */
	public final Constraints targetConstraints() {
		if (targetConstraints == null) {
			targetConstraints = createTargetConstraints();
		}
		return targetConstraints;
	}

	/**
	 * Returns the model constraints to apply.
	 * 
	 * @return The model constraints to apply.
	 * 
	 * @see #createModelConstraints()
	 */
	public final Constraints modelConstraints() {
		if (modelConstraints == null) {
			modelConstraints = createModelConstraints();
		}
		return modelConstraints;
	}

	/**
	 * Returns the before-set model constraints to apply.
	 * 
	 * @return The before-set model constraints to apply.
	 * 
	 * @see #createBeforeSetModelConstraints()
	 */
	public final Constraints beforeSetModelConstraints() {
		if (beforeSetModelConstraints == null) {
			beforeSetModelConstraints = createBeforeSetModelConstraints();
		}
		return beforeSetModelConstraints;
	}

	/**
	 * Creates the target constraints to apply.
	 * 
	 * <p>
	 * The constraints object created by this method will be exposed as the
	 * {@link #targetConstraints()} of this editing object. By default, this
	 * method returns a plain {@link Constraints} object.
	 * </p>
	 * 
	 * <p>
	 * This method will be called lazily the first time the target constraints
	 * are accessed. Subclasses may overwrite this method in order to create a
	 * custom constraints object which will then be typically exposed in the
	 * subclass as API in order to allow for a typesafe access.
	 * </p>
	 * 
	 * @return The target constraints to apply.
	 * 
	 * @see #targetConstraints()
	 */
	protected Constraints createTargetConstraints() {
		return new Constraints();
	}

	/**
	 * Creates the model constraints to apply.
	 * 
	 * <p>
	 * The constraints object created by this method will be exposed as the
	 * {@link #modelConstraints()} of this editing object. By default, this
	 * method returns a plain {@link Constraints} object.
	 * </p>
	 * 
	 * <p>
	 * This method will be called lazily the first time the model constraints
	 * are accessed. Subclasses may overwrite this method in order to create a
	 * custom constraints object which will then be typically exposed in the
	 * subclass as API in order to allow for a typesafe access.
	 * </p>
	 * 
	 * @return The model constraints to apply.
	 * 
	 * @see #modelConstraints()
	 */
	protected Constraints createModelConstraints() {
		return new Constraints();
	}

	/**
	 * Creates the before-set model constraints to apply.
	 * 
	 * <p>
	 * The constraints object created by this method will be exposed as the
	 * {@link #beforeSetModelConstraints()} of this editing object. By default,
	 * this method returns a plain {@link Constraints} object.
	 * </p>
	 * 
	 * <p>
	 * This method will be called lazily the first time the before-set model
	 * constraints are accessed. Subclasses may overwrite this method in order
	 * to create a custom constraints object which will then be typically
	 * exposed in the subclass as API in order to allow for a typesafe access.
	 * </p>
	 * 
	 * @return The before-set model constraints to apply.
	 * 
	 * @see #beforeSetModelConstraints()
	 */
	protected Constraints createBeforeSetModelConstraints() {
		return new Constraints();
	}

	/**
	 * Convenience method which {@link Constraints#addValidator(IValidator)
	 * adds} the given validator to the set of {@link #targetConstraints()}.
	 * 
	 * @param validator
	 *            The validator to add to the target constraints.
	 * @return This editing instance for method chaining.
	 * 
	 * @see Constraints#addValidator(IValidator)
	 * @see #targetConstraints()
	 */
	public final Editing addTargetValidator(IValidator validator) {
		targetConstraints().addValidator(validator);
		return this;
	}

	/**
	 * Convenience method which {@link Constraints#addValidator(IValidator)
	 * adds} the given validator to the set of {@link #modelConstraints()}.
	 * 
	 * @param validator
	 *            The validator to add to the model constraints.
	 * @return This editing instance for method chaining.
	 * 
	 * @see Constraints#addValidator(IValidator)
	 * @see #modelConstraints()
	 */
	public final Editing addModelValidator(IValidator validator) {
		modelConstraints().addValidator(validator);
		return this;
	}

	/**
	 * Convenience method which {@link Constraints#addValidator(IValidator)
	 * adds} the given validator to the set of
	 * {@link #beforeSetModelConstraints()}.
	 * 
	 * @param validator
	 *            The validator to add to the before-set model constraints.
	 * @return This editing instance for method chaining.
	 * 
	 * @see Constraints#addValidator(IValidator)
	 * @see #beforeSetModelConstraints
	 */
	public final Editing addBeforeSetModelValidator(IValidator validator) {
		beforeSetModelConstraints().addValidator(validator);
		return this;
	}

	/**
	 * Sets the target-to-model converter for this editing instance.
	 * 
	 * @param converter
	 *            The target-to-model converter to set.
	 */
	protected final void setTargetConverter(IConverter converter) {
		this.targetConverter = converter;
	}

	/**
	 * Sets the model-to-target converter for this editing instance.
	 * 
	 * @param converter
	 *            The model-to-target converter to set.
	 */
	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()
	 * @see #adaptT2MValueStrategy(UpdateValueStrategy)
	 */
	public final UpdateValueStrategy createT2MValueStrategy() {
		return adaptT2MValueStrategy(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)
	 * @see #adaptT2MValueStrategy(UpdateValueStrategy)
	 */
	public final UpdateValueStrategy createT2MValueStrategy(int updatePolicy) {
		return adaptT2MValueStrategy(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()
	 * @see #adaptM2TValueStrategy(UpdateValueStrategy)
	 */
	public final UpdateValueStrategy createM2TValueStrategy() {
		return adaptM2TValueStrategy(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)
	 * @see #adaptM2TValueStrategy(UpdateValueStrategy)
	 */
	public final UpdateValueStrategy createM2TValueStrategy(int updatePolicy) {
		return adaptM2TValueStrategy(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()
	 * @see #adaptT2MListStrategy(UpdateListStrategy)
	 */
	public final UpdateListStrategy createT2MListStrategy() {
		return adaptT2MListStrategy(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)
	 * @see #adaptT2MListStrategy(UpdateListStrategy)
	 */
	public final UpdateListStrategy createT2MListStrategy(int updatePolicy) {
		return adaptT2MListStrategy(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()
	 * @see #adaptM2TListStrategy(UpdateListStrategy)
	 */
	public final UpdateListStrategy createM2TListStrategy() {
		return adaptM2TListStrategy(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)
	 * @see #adaptM2TListStrategy(UpdateListStrategy)
	 */
	public final UpdateListStrategy createM2TListStrategy(int updatePolicy) {
		return adaptM2TListStrategy(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()
	 * @see #adaptT2MSetStrategy(UpdateSetStrategy)
	 */
	public final UpdateSetStrategy createT2MSetStrategy() {
		return adaptT2MSetStrategy(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)
	 * @see #adaptT2MSetStrategy(UpdateSetStrategy)
	 */
	public final UpdateSetStrategy createT2MSetStrategy(int updatePolicy) {
		return adaptT2MSetStrategy(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()
	 * @see #adaptM2TSetStrategy(UpdateSetStrategy)
	 */
	public final UpdateSetStrategy createM2TSetStrategy() {
		return adaptM2TSetStrategy(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)
	 * @see #adaptM2TSetStrategy(UpdateSetStrategy)
	 */
	public final UpdateSetStrategy createM2TSetStrategy(int updatePolicy) {
		return adaptM2TSetStrategy(new UpdateSetStrategy(updatePolicy));
	}

	/**
	 * Configures an existing target-to-model {@link UpdateValueStrategy} with
	 * the current state of this editing object.
	 * 
	 * <p>
	 * The configuration is done as follows:
	 * <ul>
	 * <li>
	 * The {@link Constraints#createValidator() validator} of the
	 * {@link #targetConstraints() target constraints} is set as the
	 * {@link UpdateValueStrategy#setAfterGetValidator(IValidator) after-get
	 * validator} of the update strategy.</li>
	 * <li>The {@link #setTargetConverter(IConverter) target converter} is set
	 * as the {@link UpdateValueStrategy#setConverter(IConverter) converter} of
	 * the update strategy.</li>
	 * <li>
	 * The {@link Constraints#createValidator() validator} of the
	 * {@link #modelConstraints() model constraints} is set as the
	 * {@link UpdateValueStrategy#setAfterConvertValidator(IValidator)
	 * after-convert validator} of the update strategy.</li>
	 * <li>The {@link Constraints#createValidator() validator} of the
	 * {@link #beforeSetModelConstraints() before-set model constraints} is set
	 * as the {@link UpdateValueStrategy#setBeforeSetValidator(IValidator)
	 * before-set validator} of the update strategy.</li>
	 * </ul>
	 * </p>
	 * 
	 * @param updateStrategy
	 *            The {@link UpdateValueStrategy} to configure.
	 * @return The passed-in, configured target-to-model
	 *         {@link UpdateValueStrategy}.
	 * 
	 * @see UpdateValueStrategy#setAfterGetValidator(IValidator)
	 * @see UpdateValueStrategy#setConverter(IConverter)
	 * @see UpdateValueStrategy#setAfterConvertValidator(IValidator)
	 * @see UpdateValueStrategy#setBeforeSetValidator(IValidator)
	 */
	public final UpdateValueStrategy adaptT2MValueStrategy(
			UpdateValueStrategy updateStrategy) {
		updateStrategy.setAfterGetValidator(createValidator(targetConstraints));
		updateStrategy.setConverter(targetConverter);
		updateStrategy
				.setAfterConvertValidator(createValidator(modelConstraints));
		updateStrategy
				.setBeforeSetValidator(createValidator(beforeSetModelConstraints));
		return updateStrategy;
	}

	/**
	 * Configures an existing model-to-target {@link UpdateValueStrategy} with
	 * the current state of this editing object by setting the
	 * {@link #setModelConverter(IConverter) model converter} as the
	 * {@link UpdateValueStrategy#setConverter(IConverter) converter} of the
	 * update strategy.
	 * 
	 * @param updateStrategy
	 *            The {@link UpdateValueStrategy} to configure.
	 * @return The passed-in, configured model-to-target
	 *         {@link UpdateValueStrategy}.
	 * 
	 * @see UpdateValueStrategy#setConverter(IConverter)
	 */
	public final UpdateValueStrategy adaptM2TValueStrategy(
			UpdateValueStrategy updateStrategy) {
		updateStrategy.setConverter(modelConverter);
		return updateStrategy;
	}

	/**
	 * Configures an existing target-to-model {@link UpdateListStrategy} with
	 * the current state of this editing object by setting the
	 * {@link #setTargetConverter(IConverter) target converter} as the
	 * {@link UpdateListStrategy#setConverter(IConverter) converter} of the
	 * update strategy.
	 * 
	 * @param updateStrategy
	 *            The {@link UpdateListStrategy} to configure.
	 * @return The passed-in, configured target-to-model
	 *         {@link UpdateListStrategy}.
	 * 
	 * @see UpdateListStrategy#setConverter(IConverter)
	 */
	public final UpdateListStrategy adaptT2MListStrategy(
			UpdateListStrategy updateStrategy) {
		updateStrategy.setConverter(targetConverter);
		return updateStrategy;
	}

	/**
	 * Configures an existing model-to-target {@link UpdateListStrategy} with
	 * the current state of this editing object by setting the
	 * {@link #setModelConverter(IConverter) model converter} as the
	 * {@link UpdateListStrategy#setConverter(IConverter) converter} of the
	 * update strategy.
	 * 
	 * @param updateStrategy
	 *            The {@link UpdateListStrategy} to configure.
	 * @return The passed-in, configured model-to-target
	 *         {@link UpdateListStrategy}.
	 * 
	 * @see UpdateListStrategy#setConverter(IConverter)
	 */
	public final UpdateListStrategy adaptM2TListStrategy(
			UpdateListStrategy updateStrategy) {
		updateStrategy.setConverter(modelConverter);
		return updateStrategy;
	}

	/**
	 * Configures an existing target-to-model {@link UpdateListStrategy} with
	 * the current state of this editing object by setting the
	 * {@link #setTargetConverter(IConverter) target converter} as the
	 * {@link UpdateSetStrategy#setConverter(IConverter) converter} of the
	 * update strategy.
	 * 
	 * @param updateStrategy
	 *            The {@link UpdateSetStrategy} to configure.
	 * @return The passed-in, configured target-to-model
	 *         {@link UpdateSetStrategy}.
	 * 
	 * @see UpdateSetStrategy#setConverter(IConverter)
	 */
	public final UpdateSetStrategy adaptT2MSetStrategy(
			UpdateSetStrategy updateStrategy) {
		updateStrategy.setConverter(targetConverter);
		return updateStrategy;
	}

	/**
	 * Configures an existing model-to-target {@link UpdateSetStrategy} with the
	 * current state of this editing object by setting the
	 * {@link #setModelConverter(IConverter) model converter} as the
	 * {@link UpdateSetStrategy#setConverter(IConverter) converter} of the
	 * update strategy.
	 * 
	 * @param updateStrategy
	 *            The {@link UpdateSetStrategy} to configure.
	 * @return The passed-in, configured model-to-target
	 *         {@link UpdateSetStrategy}.
	 * 
	 * @see UpdateSetStrategy#setConverter(IConverter)
	 */
	public final UpdateSetStrategy adaptM2TSetStrategy(
			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 {@link #targetConstraints() target constraints} to the
	 * given target value.</li>
	 * <li>
	 * {@link #setTargetConverter(IConverter) Converting} the target value to
	 * the model value.</li>
	 * <li>
	 * Applying all the {@link #modelConstraints() model constraints} to the
	 * converted model value.</li>
	 * <li>
	 * Applying all the {@link #beforeSetModelConstraints() before-set model
	 * constraints} 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#merge(IStatus)
	 * aggregated} on the given <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. May be
	 *            <code>null</code>.
	 * @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) {
		if (!applyConstraints(targetConstraints, targetValue, validationStatus)) {
			return null;
		}

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

		if (!applyConstraints(modelConstraints, modelValue, validationStatus)) {
			return null;
		}

		if (!applyConstraints(beforeSetModelConstraints, modelValue,
				validationStatus)) {
			return null;
		}

		return modelValue;
	}

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

	/**
	 * Creates a binding between a target and model observable value on the
	 * given binding context by creating new update strategies which will be
	 * both configured with the state of this editing object before passing them
	 * to the binding.
	 * 
	 * <p>
	 * The target-to-model and model-to-target update strategies for the binding
	 * will be created by the methods {@link #createT2MValueStrategy()} and
	 * {@link #createM2TValueStrategy()}, respectively.
	 * </p>
	 * 
	 * @param dbc
	 *            The binding context on which to create the value binding.
	 * @param targetObservableValue
	 *            The target observable value of the binding.
	 * @param modelObservableValue
	 *            The model observable value of the binding.
	 * @return The new value binding.
	 * 
	 * @see #createT2MValueStrategy()
	 * @see #createM2TValueStrategy()
	 * @see DataBindingContext#bindValue(IObservableValue, IObservableValue,
	 *      UpdateValueStrategy, UpdateValueStrategy)
	 */
	public final Binding bindValue(DataBindingContext dbc,
			IObservableValue targetObservableValue,
			IObservableValue modelObservableValue) {
		return dbc.bindValue(targetObservableValue, modelObservableValue,
				createT2MValueStrategy(), createM2TValueStrategy());
	}

	/**
	 * Creates a binding between a target and model observable value on the
	 * given binding context by creating new update strategies with the provided
	 * update policies which will be both configured with the state of this
	 * editing object before passing them to the binding.
	 * 
	 * @param dbc
	 *            The binding context on which to create the value binding.
	 * @param targetObservableValue
	 *            The target observable value of the binding.
	 * @param modelObservableValue
	 *            The model observable value of the binding.
	 * @param t2mUpdatePolicy
	 *            The update policy for the target-to-model
	 *            {@link UpdateValueStrategy} which is
	 *            {@link #createT2MValueStrategy(int) created} and passed to the
	 *            new binding.
	 * @param m2tUpdatePolicy
	 *            The update policy for the model-to-target
	 *            {@link UpdateValueStrategy} which is
	 *            {@link #createM2TValueStrategy(int) created} and passed to the
	 *            new binding.
	 * @return The new value binding.
	 * 
	 * @see #createT2MValueStrategy(int)
	 * @see #createM2TValueStrategy(int)
	 * @see DataBindingContext#bindValue(IObservableValue, IObservableValue,
	 *      UpdateValueStrategy, UpdateValueStrategy)
	 */
	public final Binding bindValue(DataBindingContext dbc,
			IObservableValue targetObservableValue,
			IObservableValue modelObservableValue, int t2mUpdatePolicy,
			int m2tUpdatePolicy) {
		return dbc.bindValue(targetObservableValue, modelObservableValue,
				createT2MValueStrategy(t2mUpdatePolicy),
				createM2TValueStrategy(m2tUpdatePolicy));
	}

	/**
	 * Creates a binding between a target and model observable value on the
	 * given binding context by using the provided update strategies which will
	 * be both configured with the state of this editing object before passing
	 * them to the binding.
	 * 
	 * @param dbc
	 *            The binding context on which to create the value binding.
	 * @param targetObservableValue
	 *            The target observable value of the binding.
	 * @param modelObservableValue
	 *            The model observable value of the binding.
	 * @param t2mUpdateStrategy
	 *            The target-to-model {@link UpdateValueStrategy} of the binding
	 *            to be {@link #adaptT2MValueStrategy(UpdateValueStrategy)
	 *            configured} with the state of this editing object before
	 *            passing it to the binding.
	 * @param m2tUpdateStrategy
	 *            The model-to-target {@link UpdateValueStrategy} of the binding
	 *            to be {@link #adaptM2TValueStrategy(UpdateValueStrategy)
	 *            configured} with the state of this editing object before
	 *            passing it to the binding.
	 * @return The new value binding.
	 * 
	 * @see #adaptT2MValueStrategy(UpdateValueStrategy)
	 * @see #adaptM2TValueStrategy(UpdateValueStrategy)
	 * @see DataBindingContext#bindValue(IObservableValue, IObservableValue,
	 *      UpdateValueStrategy, UpdateValueStrategy)
	 */
	public final Binding bindValue(DataBindingContext dbc,
			IObservableValue targetObservableValue,
			IObservableValue modelObservableValue,
			UpdateValueStrategy t2mUpdateStrategy,
			UpdateValueStrategy m2tUpdateStrategy) {
		return dbc.bindValue(targetObservableValue, modelObservableValue,
				adaptT2MValueStrategy(t2mUpdateStrategy),
				adaptM2TValueStrategy(m2tUpdateStrategy));
	}

	/**
	 * Creates a binding between a target and model observable list on the given
	 * binding context by creating new update strategies which will be both
	 * configured with the state of this editing object before passing them to
	 * the binding.
	 * 
	 * <p>
	 * The target-to-model and model-to-target update strategies for the binding
	 * will be created by the methods {@link #createT2MListStrategy()} and
	 * {@link #createM2TListStrategy()}, respectively.
	 * </p>
	 * 
	 * @param dbc
	 *            The binding context on which to create the list binding.
	 * @param targetObservableList
	 *            The target observable list of the binding.
	 * @param modelObservableList
	 *            The model observable list of the binding.
	 * @return The new list binding.
	 * 
	 * @see #createT2MListStrategy()
	 * @see #createM2TListStrategy()
	 * @see DataBindingContext#bindList(IObservableList, IObservableList,
	 *      UpdateListStrategy, UpdateListStrategy)
	 */
	public final Binding bindList(DataBindingContext dbc,
			IObservableList targetObservableList,
			IObservableList modelObservableList) {
		return dbc.bindList(targetObservableList, modelObservableList,
				createT2MListStrategy(), createM2TListStrategy());
	}

	/**
	 * Creates a binding between a target and model observable list on the given
	 * binding context by creating new update strategies with the provided
	 * update policies which will be both configured with the state of this
	 * editing object before passing them to the binding.
	 * 
	 * @param dbc
	 *            The binding context on which to create the list binding.
	 * @param targetObservableList
	 *            The target observable list of the binding.
	 * @param modelObservableList
	 *            The model observable list of the binding.
	 * @param t2mUpdatePolicy
	 *            The update policy for the target-to-model
	 *            {@link UpdateListStrategy} which is
	 *            {@link #createT2MListStrategy(int) created} and passed to the
	 *            new binding.
	 * @param m2tUpdatePolicy
	 *            The update policy for the model-to-target
	 *            {@link UpdateListStrategy} which is
	 *            {@link #createM2TListStrategy(int) created} and passed to the
	 *            new binding.
	 * @return The new list binding.
	 * 
	 * @see #createT2MListStrategy(int)
	 * @see #createM2TListStrategy(int)
	 * @see DataBindingContext#bindList(IObservableList, IObservableList,
	 *      UpdateListStrategy, UpdateListStrategy)
	 */
	public final Binding bindList(DataBindingContext dbc,
			IObservableList targetObservableList,
			IObservableList modelObservableList, int t2mUpdatePolicy,
			int m2tUpdatePolicy) {
		return dbc.bindList(targetObservableList, modelObservableList,
				createT2MListStrategy(t2mUpdatePolicy),
				createM2TListStrategy(m2tUpdatePolicy));
	}

	/**
	 * Creates a binding between a target and model observable list on the given
	 * binding context by using the provided update strategies which will be
	 * both configured with the state of this editing object before passing them
	 * to the binding.
	 * 
	 * @param dbc
	 *            The binding context on which to create the list binding.
	 * @param targetObservableList
	 *            The target observable list of the binding.
	 * @param modelObservableList
	 *            The model observable list of the binding.
	 * @param t2mUpdateStrategy
	 *            The target-to-model {@link UpdateListStrategy} of the binding
	 *            to be {@link #adaptT2MListStrategy(UpdateListStrategy)
	 *            configured} with the state of this editing object before
	 *            passing it to the binding.
	 * @param m2tUpdateStrategy
	 *            The model-to-target {@link UpdateListStrategy} of the binding
	 *            to be {@link #adaptM2TListStrategy(UpdateListStrategy)
	 *            configured} with the state of this editing object before
	 *            passing it to the binding.
	 * @return The new list binding.
	 * 
	 * @see #adaptT2MListStrategy(UpdateListStrategy)
	 * @see #adaptM2TListStrategy(UpdateListStrategy)
	 * @see DataBindingContext#bindList(IObservableList, IObservableList,
	 *      UpdateListStrategy, UpdateListStrategy)
	 */
	public final Binding bindList(DataBindingContext dbc,
			IObservableList targetObservableList,
			IObservableList modelObservableList,
			UpdateListStrategy t2mUpdateStrategy,
			UpdateListStrategy m2tUpdateStrategy) {
		return dbc.bindList(targetObservableList, modelObservableList,
				adaptT2MListStrategy(t2mUpdateStrategy),
				adaptM2TListStrategy(m2tUpdateStrategy));
	}

	/**
	 * Creates a binding between a target and model observable set on the given
	 * binding context by creating new update strategies which will be both
	 * configured with the state of this editing object before passing them to
	 * the binding.
	 * 
	 * <p>
	 * The target-to-model and model-to-target update strategies for the binding
	 * will be created by the methods {@link #createT2MSetStrategy()} and
	 * {@link #createM2TSetStrategy()}, respectively.
	 * </p>
	 * 
	 * @param dbc
	 *            The binding context on which to create the set binding.
	 * @param targetObservableSet
	 *            The target observable set of the binding.
	 * @param modelObservableSet
	 *            The model observable set of the binding.
	 * @return The new set binding.
	 * 
	 * @see #createT2MSetStrategy()
	 * @see #createM2TSetStrategy()
	 * @see DataBindingContext#bindSet(IObservableSet, IObservableSet,
	 *      UpdateSetStrategy, UpdateSetStrategy)
	 */
	public final Binding bindSet(DataBindingContext dbc,
			IObservableSet targetObservableSet,
			IObservableSet modelObservableSet) {
		return dbc.bindSet(targetObservableSet, modelObservableSet,
				createT2MSetStrategy(), createM2TSetStrategy());
	}

	/**
	 * Creates a binding between a target and model observable set on the given
	 * binding context by creating new update strategies with the provided
	 * update policies which will be both configured with the state of this
	 * editing object before passing them to the binding.
	 * 
	 * @param dbc
	 *            The binding context on which to create the set binding.
	 * @param targetObservableSet
	 *            The target observable set of the binding.
	 * @param modelObservableSet
	 *            The model observable set of the binding.
	 * @param t2mUpdatePolicy
	 *            The update policy for the target-to-model
	 *            {@link UpdateSetStrategy} which is
	 *            {@link #createT2MSetStrategy(int) created} and passed to the
	 *            new binding.
	 * @param m2tUpdatePolicy
	 *            The update policy for the model-to-target
	 *            {@link UpdateSetStrategy} which is
	 *            {@link #createM2TSetStrategy(int) created} and passed to the
	 *            new binding.
	 * @return The new set binding.
	 * 
	 * @see #createT2MSetStrategy(int)
	 * @see #createM2TSetStrategy(int)
	 * @see DataBindingContext#bindSet(IObservableSet, IObservableSet,
	 *      UpdateSetStrategy, UpdateSetStrategy)
	 */
	public final Binding bindSet(DataBindingContext dbc,
			IObservableSet targetObservableSet,
			IObservableSet modelObservableSet, int t2mUpdatePolicy,
			int m2tUpdatePolicy) {
		return dbc.bindSet(targetObservableSet, modelObservableSet,
				createT2MSetStrategy(t2mUpdatePolicy),
				createM2TSetStrategy(m2tUpdatePolicy));
	}

	/**
	 * Creates a binding between a target and model observable set on the given
	 * binding context by using the provided update strategies which will be
	 * both configured with the state of this editing object before passing them
	 * to the binding.
	 * 
	 * @param dbc
	 *            The binding context on which to create the set binding.
	 * @param targetObservableSet
	 *            The target observable set of the binding.
	 * @param modelObservableSet
	 *            The model observable set of the binding.
	 * @param t2mUpdateStrategy
	 *            The target-to-model {@link UpdateSetStrategy} of the binding
	 *            to be {@link #adaptT2MSetStrategy(UpdateSetStrategy)
	 *            configured} with the state of this editing object before
	 *            passing it to the binding.
	 * @param m2tUpdateStrategy
	 *            The model-to-target {@link UpdateSetStrategy} of the binding
	 *            to be {@link #adaptM2TSetStrategy(UpdateSetStrategy)
	 *            configured} with the state of this editing object before
	 *            passing it to the binding.
	 * @return The new set binding.
	 * 
	 * @see #adaptT2MSetStrategy(UpdateSetStrategy)
	 * @see #adaptM2TSetStrategy(UpdateSetStrategy)
	 * @see DataBindingContext#bindSet(IObservableSet, IObservableSet,
	 *      UpdateSetStrategy, UpdateSetStrategy)
	 */
	public final Binding bindSet(DataBindingContext dbc,
			IObservableSet targetObservableSet,
			IObservableSet modelObservableSet,
			UpdateSetStrategy t2mUpdateStrategy,
			UpdateSetStrategy m2tUpdateStrategy) {
		return dbc.bindSet(targetObservableSet, modelObservableSet,
				adaptT2MSetStrategy(t2mUpdateStrategy),
				adaptM2TSetStrategy(m2tUpdateStrategy));
	}

	private static IValidator createValidator(Constraints constraints) {
		return constraints != null ? constraints.createValidator() : null;
	}

	private static boolean applyConstraints(Constraints constraints,
			Object value, MultiStatus aggregateStatus) {
		IValidator validator = createValidator(constraints);
		if (validator != null) {
			IStatus validationStatus = validator.validate(value);
			if (aggregateStatus != null && !validationStatus.isOK()) {
				aggregateStatus.merge(validationStatus);
			}
			return isValid(validationStatus);
		}
		return true;
	}

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




/*******************************************************************************
 * Copyright (c) 2009 Ovidio Mallo 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:
 *     Ovidio Mallo - initial API and implementation (bug 183055)
 ******************************************************************************/

package org.eclipse.core.databinding.validation.constraint;

import java.util.regex.Pattern;

import org.eclipse.core.internal.databinding.validation.NonEmptyStringValidator;
import org.eclipse.core.internal.databinding.validation.NonNullValidator;
import org.eclipse.core.internal.databinding.validation.StringLengthValidator;
import org.eclipse.core.internal.databinding.validation.StringRegexValidator;

import com.ibm.icu.text.NumberFormat;

/**
 * Provides a set of constraints to apply to <code>String</code>s.
 * 
 * <p>
 * Instances of this class can be used to define a set of constraints to apply
 * to strings. In addition, the validation messages to be issued for the
 * individual constraints as well as the way in which model objects are
 * formatted in the validation messages can be configured.
 * </p>
 * 
 * @noextend This class is not intended to be subclassed by clients.
 * @since 1.3
 */
public class StringConstraints extends Constraints {

	private NumberFormat lengthFormat = NumberFormat.getIntegerInstance();

	private String requiredMessage = null;

	private String nonEmptyMessage = null;

	private String minLengthMessage = null;

	private String maxLengthMessage = null;

	private String lengthRangeMessage = null;

	private String matchesMessage = null;

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

	/**
	 * Sets the validation message for the {@link #required()} constraint.
	 * 
	 * @param message
	 *            The validation message for the {@link #required()} constraint.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #required()
	 */
	public StringConstraints requiredMessage(String message) {
		this.requiredMessage = message;
		return this;
	}

	/**
	 * Adds a validator ensuring that the input integer is not empty. Uses the
	 * current {@link #nonEmptyMessage(String) validation message}.
	 * 
	 * @return This constraints instance for method chaining.
	 */
	public StringConstraints nonEmpty() {
		addValidator(new NonEmptyStringValidator(nonEmptyMessage));
		return this;
	}

	/**
	 * Sets the validation message for the {@link #nonEmpty()} constraint.
	 * 
	 * @param message
	 *            The validation message for the {@link #nonEmpty()} constraint.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #nonEmpty()
	 */
	public StringConstraints nonEmptyMessage(String message) {
		this.nonEmptyMessage = message;
		return this;
	}

	/**
	 * Sets the format to use when formatting the string length in any of the
	 * validation messages stemming from a length constraint.
	 * 
	 * @param format
	 *            The format to use for displaying the string length in
	 *            validation messages stemming from a length constraint.
	 *            messages.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #minLength(int)
	 * @see #maxLength(int)
	 * @see #lengthRange(int, int)
	 */
	public StringConstraints lengthFormat(NumberFormat format) {
		this.lengthFormat = format;
		return this;
	}

	/**
	 * Adds a validator ensuring that the input string has at least the
	 * specified amount of characters. Uses the current
	 * {@link #minLengthMessage(String) validation message} and
	 * {@link #lengthFormat(NumberFormat) length format}.
	 * 
	 * @param minLength
	 *            The minimal length to be enforced on the input string.
	 * @return This constraints instance for method chaining.
	 */
	public StringConstraints minLength(int minLength) {
		addValidator(StringLengthValidator.min(minLength, minLengthMessage,
				lengthFormat));
		return this;
	}

	/**
	 * Sets the validation message pattern for the {@link #minLength(int)}
	 * constraint.
	 * 
	 * @param message
	 *            The validation message pattern for the {@link #minLength(int)}
	 *            constraint. Can be parameterized with the minimum string
	 *            length.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #minLength(int)
	 */
	public StringConstraints minLengthMessage(String message) {
		this.minLengthMessage = message;
		return this;
	}

	/**
	 * Adds a validator ensuring that the input string has not more than the
	 * specified amount of characters. Uses the current
	 * {@link #maxLengthMessage(String) validation message} and
	 * {@link #lengthFormat(NumberFormat) length format}.
	 * 
	 * @param maxLength
	 *            The maximum length to be enforced on the input string.
	 * @return This constraints instance for method chaining.
	 */
	public StringConstraints maxLength(int maxLength) {
		addValidator(StringLengthValidator.max(maxLength, maxLengthMessage,
				lengthFormat));
		return this;
	}

	/**
	 * Sets the validation message pattern for the {@link #maxLength(int)}
	 * constraint.
	 * 
	 * @param message
	 *            The validation message pattern for the {@link #maxLength(int)}
	 *            constraint. Can be parameterized with the maximum string
	 *            length.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #maxLength(int)
	 */
	public StringConstraints maxLengthMessage(String message) {
		this.maxLengthMessage = message;
		return this;
	}

	/**
	 * Adds a validator ensuring that the length of the input string is between
	 * the given bounds. Uses the current {@link #lengthRangeMessage(String)
	 * validation message} and {@link #lengthFormat(NumberFormat) length format}
	 * .
	 * 
	 * @param minLength
	 *            The minimal length to be enforced on the input string.
	 * @param maxLength
	 *            The maximum length to be enforced on the input string.
	 * @return This constraints instance for method chaining.
	 */
	public StringConstraints lengthRange(int minLength, int maxLength) {
		addValidator(StringLengthValidator.range(minLength, maxLength,
				lengthRangeMessage, lengthFormat));
		return this;
	}

	/**
	 * Sets the validation message pattern for the
	 * {@link #lengthRange(int, int)} constraint.
	 * 
	 * @param message
	 *            The validation message pattern for the
	 *            {@link #lengthRange(int, int)} constraint. Can be
	 *            parameterized with the minimum and maximum string lengths.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #lengthRange(int, int)
	 */
	public StringConstraints lengthRangeMessage(String message) {
		this.lengthRangeMessage = message;
		return this;
	}

	/**
	 * Adds a 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 constraints instance for method chaining.
	 * 
	 * @see Pattern#matches(String, CharSequence)
	 */
	public StringConstraints matches(String regex) {
		addValidator(new StringRegexValidator(regex, matchesMessage));
		return this;
	}

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

	/**
	 * Sets the validation message pattern for the {@link #matches(String)}
	 * constraint.
	 * 
	 * @param message
	 *            The validation message pattern for the
	 *            {@link #matches(String)} constraint. Can be parameterized with
	 *            the pattern string which the input integer must match.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #matches(String)
	 */
	public StringConstraints matchesMessage(String message) {
		this.matchesMessage = message;
		return this;
	}
}




/*******************************************************************************
 * Copyright (c) 2009 Ovidio Mallo 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:
 *     Ovidio Mallo - initial API and implementation (bug 183055)
 ******************************************************************************/

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.internal.databinding.BindingMessages;
import org.eclipse.core.runtime.IStatus;

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

/**
 * Provides validations for the scale of decimal numbers.
 * 
 * @since 1.3
 */
public class DecimalScaleValidator implements IValidator {

	private static final String MAX_SCALE_VALIDATION_MESSAGE = BindingMessages
			.getString(BindingMessages.VALIDATE_DECIMAL_MAX_SCALE);

	private final int maxScale;

	private final String validationMessage;

	private String formattedValidationMessage;

	private final NumberFormat scaleFormat;

	private DecimalScaleValidator(int maxScale, String validationMessage,
			NumberFormat scaleFormat) {
		this.maxScale = maxScale;
		this.validationMessage = validationMessage != null ? validationMessage
				: MAX_SCALE_VALIDATION_MESSAGE;
		this.scaleFormat = scaleFormat;
	}

	/**
	 * Creates a validator which checks that an input decimal has a scale which
	 * is less or equal to the given scale.
	 * 
	 * @param maxScale
	 *            The maximum scale to enforce on the input decimal.
	 * @param validationMessage
	 *            The validation message pattern to use. Can be parameterized
	 *            with the maximum scale to be enforced.
	 * @param scaleFormat
	 *            The display format to use for formatting the scale in the
	 *            validation message.
	 * @return The validator instance.
	 */
	public static DecimalScaleValidator max(int maxScale,
			String validationMessage, NumberFormat scaleFormat) {
		return new DecimalScaleValidator(maxScale, validationMessage,
				scaleFormat);
	}

	public IStatus validate(Object value) {
		if (value != null) {
			Number number = (Number) value;
			final int scale;
			if (number instanceof BigDecimal) {
				scale = ((BigDecimal) number).scale();
			} else {
				scale = new BigDecimal(number.doubleValue()).scale();
			}
			if (scale > maxScale) {
				return ValidationStatus.error(getFormattedValidationMessage());
			}
		}
		return ValidationStatus.ok();
	}

	private synchronized String getFormattedValidationMessage() {
		if (formattedValidationMessage == null) {
			formattedValidationMessage = MessageFormat.format(
					validationMessage, getValidationMessageArguments());
		}
		return formattedValidationMessage;
	}

	private String[] getValidationMessageArguments() {
		synchronized (scaleFormat) {
			return new String[] { scaleFormat.format(new Integer(maxScale)) };
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2009 Ovidio Mallo 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:
 *     Ovidio Mallo - initial API and implementation (bug 183055)
 ******************************************************************************/

package org.eclipse.core.databinding.editing;

import org.eclipse.core.databinding.conversion.NumberToStringConverter;
import org.eclipse.core.databinding.conversion.StringToNumberConverter;
import org.eclipse.core.databinding.validation.constraint.Constraints;
import org.eclipse.core.databinding.validation.constraint.IntegerConstraints;
import org.eclipse.core.databinding.validation.constraint.StringConstraints;
import org.eclipse.core.internal.databinding.validation.AbstractStringToNumberValidator;
import org.eclipse.core.internal.databinding.validation.StringToByteValidator;
import org.eclipse.core.internal.databinding.validation.StringToIntegerValidator;
import org.eclipse.core.internal.databinding.validation.StringToLongValidator;
import org.eclipse.core.internal.databinding.validation.StringToShortValidator;

import com.ibm.icu.text.NumberFormat;

/**
 * @noextend This class is not intended to be subclassed by clients.
 * @since 1.3
 */
public class IntegerEditing extends Editing {

	private final NumberFormat displayFormat;

	/**
	 * Creates a new editing object for integer numbers.
	 * 
	 * @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.
	 * @param integerType
	 *            The specific integer type for which to set up an editing
	 *            instance.
	 * 
	 * @noreference This constructor is not intended to be referenced by
	 *              clients.
	 */
	protected IntegerEditing(NumberFormat format, String parseErrorMessage,
			String outOfRangeMessage, Class integerType) {
		this.displayFormat = format;

		final StringToNumberConverter targetConverter;
		final NumberToStringConverter modelConverter;
		final AbstractStringToNumberValidator targetValidator;
		if (Long.class.equals(integerType)) {
			targetConverter = StringToNumberConverter.toLong(format, false);
			modelConverter = NumberToStringConverter.fromLong(format, false);
			targetValidator = new StringToLongValidator(targetConverter);
		} else if (Integer.class.equals(integerType)) {
			targetConverter = StringToNumberConverter.toInteger(format, false);
			modelConverter = NumberToStringConverter.fromInteger(format, false);
			targetValidator = new StringToIntegerValidator(targetConverter);
		} else if (Short.class.equals(integerType)) {
			targetConverter = StringToNumberConverter.toShort(format, false);
			modelConverter = NumberToStringConverter.fromShort(format, false);
			targetValidator = new StringToShortValidator(targetConverter);
		} else if (Byte.class.equals(integerType)) {
			targetConverter = StringToNumberConverter.toByte(format, false);
			modelConverter = NumberToStringConverter.fromByte(format, false);
			targetValidator = new StringToByteValidator(targetConverter);
		} else {
			throw new IllegalArgumentException(
					"Unsupported integer type: " + integerType); //$NON-NLS-1$
		}

		if (parseErrorMessage != null) {
			targetValidator.setParseErrorMessage(parseErrorMessage);
		}
		if (outOfRangeMessage != null) {
			targetValidator.setOutOfRangeMessage(outOfRangeMessage);
		}

		setTargetConverter(targetConverter);
		setModelConverter(modelConverter);
		addTargetValidator(targetValidator);
	}

	/**
	 * Creates a new editing object for {@link Long}s 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 withLongDefaults() {
		return withLongDefaults(null, null);
	}

	/**
	 * Creates a new editing object for {@link Long}s 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>Long.MIN_VALUE</code> and
	 *            <code>Long.MAX_VALUE</code> values.
	 * @return The new editing object using the default validations and
	 *         conversions for editing.
	 * 
	 * @see NumberFormat#getIntegerInstance()
	 */
	public static IntegerEditing withLongDefaults(String parseErrorMessage,
			String outOfRangeMessage) {
		return new IntegerEditing(NumberFormat.getIntegerInstance(),
				parseErrorMessage, outOfRangeMessage, Long.class);
	}

	/**
	 * Creates a new editing object for {@link Long}s 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 forLongFormat(NumberFormat format) {
		return forLongFormat(format, null, null);
	}

	/**
	 * Creates a new editing object for {@link Long}s 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>Long.MIN_VALUE</code> and
	 *            <code>Long.MAX_VALUE</code> values.
	 * @return The new editing object configured by the given integer format.
	 */
	public static IntegerEditing forLongFormat(NumberFormat format,
			String parseErrorMessage, String outOfRangeMessage) {
		return new IntegerEditing(format, parseErrorMessage, outOfRangeMessage,
				Long.class);
	}

	/**
	 * Creates a new editing object for {@link Integer}s 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 withIntegerDefaults() {
		return withIntegerDefaults(null, null);
	}

	/**
	 * Creates a new editing object for {@link Integer}s 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.
	 * 
	 * @see NumberFormat#getIntegerInstance()
	 */
	public static IntegerEditing withIntegerDefaults(String parseErrorMessage,
			String outOfRangeMessage) {
		return new IntegerEditing(NumberFormat.getIntegerInstance(),
				parseErrorMessage, outOfRangeMessage, Integer.class);
	}

	/**
	 * Creates a new editing object for {@link Integer}s 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 forIntegerFormat(NumberFormat format) {
		return forIntegerFormat(format, null, null);
	}

	/**
	 * Creates a new editing object for {@link Integer}s 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 forIntegerFormat(NumberFormat format,
			String parseErrorMessage, String outOfRangeMessage) {
		return new IntegerEditing(format, parseErrorMessage, outOfRangeMessage,
				Integer.class);
	}

	/**
	 * Creates a new editing object for {@link Short}s 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 withShortDefaults() {
		return withShortDefaults(null, null);
	}

	/**
	 * Creates a new editing object for {@link Short}s 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>Short.MIN_VALUE</code> and
	 *            <code>Short.MAX_VALUE</code> values.
	 * @return The new editing object using the default validations and
	 *         conversions for editing.
	 * 
	 * @see NumberFormat#getIntegerInstance()
	 */
	public static IntegerEditing withShortDefaults(String parseErrorMessage,
			String outOfRangeMessage) {
		return new IntegerEditing(NumberFormat.getIntegerInstance(),
				parseErrorMessage, outOfRangeMessage, Short.class);
	}

	/**
	 * Creates a new editing object for {@link Short}s 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 forShortFormat(NumberFormat format) {
		return forShortFormat(format, null, null);
	}

	/**
	 * Creates a new editing object for {@link Short}s 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>Short.MIN_VALUE</code> and
	 *            <code>Short.MAX_VALUE</code> values.
	 * @return The new editing object configured by the given integer format.
	 */
	public static IntegerEditing forShortFormat(NumberFormat format,
			String parseErrorMessage, String outOfRangeMessage) {
		return new IntegerEditing(format, parseErrorMessage, outOfRangeMessage,
				Short.class);
	}

	/**
	 * Creates a new editing object for {@link Byte}s 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 withByteDefaults() {
		return withByteDefaults(null, null);
	}

	/**
	 * Creates a new editing object for {@link Byte}s 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>Byte.MIN_VALUE</code> and
	 *            <code>Byte.MAX_VALUE</code> values.
	 * @return The new editing object using the default validations and
	 *         conversions for editing.
	 * 
	 * @see NumberFormat#getIntegerInstance()
	 */
	public static IntegerEditing withByteDefaults(String parseErrorMessage,
			String outOfRangeMessage) {
		return new IntegerEditing(NumberFormat.getIntegerInstance(),
				parseErrorMessage, outOfRangeMessage, Byte.class);
	}

	/**
	 * Creates a new editing object for {@link Byte}s 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 forByteFormat(NumberFormat format) {
		return forByteFormat(format, null, null);
	}

	/**
	 * Creates a new editing object for {@link Byte}s 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>Byte.MIN_VALUE</code> and
	 *            <code>Byte.MAX_VALUE</code> values.
	 * @return The new editing object configured by the given integer format.
	 */
	public static IntegerEditing forByteFormat(NumberFormat format,
			String parseErrorMessage, String outOfRangeMessage) {
		return new IntegerEditing(format, parseErrorMessage, outOfRangeMessage,
				Byte.class);
	}

	/**
	 * Returns the target constraints to apply.
	 * 
	 * <p>
	 * This method provides a typesafe access to the {@link StringConstraints
	 * string target constraints} of this editing object and is equivalent to
	 * {@code (StringConstraints) targetConstraints()}.
	 * </p>
	 * 
	 * @return The target constraints to apply.
	 * 
	 * @see #targetConstraints()
	 * @see StringConstraints
	 */
	public StringConstraints targetStringConstraints() {
		return (StringConstraints) targetConstraints();
	}

	/**
	 * Returns the model constraints to apply.
	 * 
	 * <p>
	 * This method provides a typesafe access to the {@link IntegerConstraints
	 * integer model constraints} of this editing object and is equivalent to
	 * {@code (IntegerConstraints) modelConstraints()}.
	 * </p>
	 * 
	 * @return The model constraints to apply.
	 * 
	 * @see #modelConstraints()
	 * @see IntegerConstraints
	 */
	public IntegerConstraints modelIntegerConstraints() {
		return (IntegerConstraints) modelConstraints();
	}

	/**
	 * Returns the before-set model constraints to apply.
	 * 
	 * <p>
	 * This method provides a typesafe access to the {@link IntegerConstraints
	 * integer before-set model constraints} of this editing object and is
	 * equivalent to {@code (IntegerConstraints) beforeSetModelConstraints()}.
	 * </p>
	 * 
	 * @return The before-set model constraints to apply.
	 * 
	 * @see #beforeSetModelConstraints()
	 * @see IntegerConstraints
	 */
	public IntegerConstraints beforeSetModelIntegerConstraints() {
		return (IntegerConstraints) beforeSetModelConstraints();
	}

	protected Constraints createTargetConstraints() {
		return new StringConstraints();
	}

	protected Constraints createModelConstraints() {
		return new IntegerConstraints().integerFormat(displayFormat);
	}

	protected Constraints createBeforeSetModelConstraints() {
		return new IntegerConstraints().integerFormat(displayFormat);
	}

	/**
	 * Convenience method which adds a {@link IntegerConstraints#required()
	 * required constraint} to the set of {@link #modelIntegerConstraints()}.
	 * 
	 * @return This editing instance for method chaining.
	 * 
	 * @see IntegerConstraints#required()
	 * @see #modelIntegerConstraints()
	 */
	public IntegerEditing required() {
		modelIntegerConstraints().required();
		return this;
	}

	/**
	 * Convenience method which adds a {@link IntegerConstraints#greater(long)
	 * greater constraint} to the set of {@link #modelIntegerConstraints()}.
	 * 
	 * @param number
	 *            The number of the greater constraint.
	 * @return This editing instance for method chaining.
	 * 
	 * @see IntegerConstraints#greater(long)
	 * @see #modelIntegerConstraints()
	 */
	public IntegerEditing greater(long number) {
		modelIntegerConstraints().greater(number);
		return this;
	}

	/**
	 * Convenience method which adds a
	 * {@link IntegerConstraints#greaterEqual(long) greater-equal constraint} to
	 * the set of {@link #modelIntegerConstraints()}.
	 * 
	 * @param number
	 *            The number of the greater-equal constraint.
	 * @return This editing instance for method chaining.
	 * 
	 * @see IntegerConstraints#greaterEqual(long)
	 * @see #modelIntegerConstraints()
	 */
	public IntegerEditing greaterEqual(long number) {
		modelIntegerConstraints().greaterEqual(number);
		return this;
	}

	/**
	 * Convenience method which adds a {@link IntegerConstraints#less(long) less
	 * constraint} to the set of {@link #modelIntegerConstraints()}.
	 * 
	 * @param number
	 *            The number of the less constraint.
	 * @return This editing instance for method chaining.
	 * 
	 * @see IntegerConstraints#less(long)
	 * @see #modelIntegerConstraints()
	 */
	public IntegerEditing less(long number) {
		modelIntegerConstraints().less(number);
		return this;
	}

	/**
	 * Convenience method which adds a
	 * {@link IntegerConstraints#lessEqual(long) less-equal constraint} to the
	 * set of {@link #modelIntegerConstraints()}.
	 * 
	 * @param number
	 *            The number of the less-equal constraint.
	 * @return This editing instance for method chaining.
	 * 
	 * @see IntegerConstraints#lessEqual(long)
	 * @see #modelIntegerConstraints()
	 */
	public IntegerEditing lessEqual(long number) {
		modelIntegerConstraints().lessEqual(number);
		return this;
	}

	/**
	 * Convenience method which adds a
	 * {@link IntegerConstraints#range(long, long) range constraint} to the set
	 * of {@link #modelIntegerConstraints()}.
	 * 
	 * @param min
	 *            The min number of the range constraint.
	 * @param max
	 *            The max number of the range constraint.
	 * @return This editing instance for method chaining.
	 * 
	 * @see IntegerConstraints#range(long, long)
	 * @see #modelIntegerConstraints()
	 */
	public IntegerEditing range(long min, long max) {
		modelIntegerConstraints().range(min, max);
		return this;
	}

	/**
	 * Convenience method which adds a {@link IntegerConstraints#positive()
	 * positive constraint} to the set of {@link #modelIntegerConstraints()}.
	 * 
	 * @return This editing instance for method chaining.
	 * 
	 * @see IntegerConstraints#positive()
	 * @see #modelIntegerConstraints()
	 */
	public IntegerEditing positive() {
		modelIntegerConstraints().positive();
		return this;
	}

	/**
	 * Convenience method which adds a {@link IntegerConstraints#nonNegative()
	 * non-negative constraint} to the set of {@link #modelIntegerConstraints()}
	 * .
	 * 
	 * @return This editing instance for method chaining.
	 * 
	 * @see IntegerConstraints#nonNegative()
	 * @see #modelIntegerConstraints()
	 */
	public IntegerEditing nonNegative() {
		modelIntegerConstraints().nonNegative();
		return this;
	}
}




/*******************************************************************************
 * Copyright (c) 2009 Ovidio Mallo 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:
 *     Ovidio Mallo - initial API and implementation (bug 183055)
 ******************************************************************************/

package org.eclipse.core.databinding.editing;

import java.util.Date;

import org.eclipse.core.databinding.validation.constraint.Constraints;
import org.eclipse.core.databinding.validation.constraint.DateConstraints;
import org.eclipse.core.databinding.validation.constraint.StringConstraints;
import org.eclipse.core.internal.databinding.conversion.DateToStringConverter;
import org.eclipse.core.internal.databinding.conversion.StringToDateConverter;
import org.eclipse.core.internal.databinding.validation.StringToDateValidator;

import com.ibm.icu.text.DateFormat;

/**
 * @noextend This class is not intended to be subclassed by clients.
 * @since 1.3
 */
public class DateEditing extends Editing {

	private final DateFormat displayFormat;

	/**
	 * Creates a new editing object for <code>Date</code>s.
	 * 
	 * @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.
	 * 
	 * @noreference This constructor is not intended to be referenced by
	 *              clients.
	 */
	protected DateEditing(DateFormat[] inputFormats, String parseErrorMessage,
			DateFormat displayFormat) {
		this.displayFormat = displayFormat;

		StringToDateConverter targetConverter = new StringToDateConverter();
		if (inputFormats != null) {
			targetConverter.setFormatters(inputFormats);
		}

		DateToStringConverter modelConverter = new DateToStringConverter();
		if (displayFormat != null) {
			modelConverter.setFormatters(new DateFormat[] { displayFormat });
		}

		StringToDateValidator targetValidator = new StringToDateValidator(
				targetConverter);
		if (parseErrorMessage != null) {
			targetValidator.setParseErrorMessage(parseErrorMessage);
		}

		setTargetConverter(targetConverter);
		setModelConverter(modelConverter);
		addTargetValidator(targetValidator);
	}

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

	/**
	 * Returns the target constraints to apply.
	 * 
	 * <p>
	 * This method provides a typesafe access to the {@link StringConstraints
	 * string target constraints} of this editing object and is equivalent to
	 * {@code (StringConstraints) targetConstraints()}.
	 * </p>
	 * 
	 * @return The target constraints to apply.
	 * 
	 * @see #targetConstraints()
	 * @see StringConstraints
	 */
	public StringConstraints targetStringConstraints() {
		return (StringConstraints) targetConstraints();
	}

	/**
	 * Returns the model constraints to apply.
	 * 
	 * <p>
	 * This method provides a typesafe access to the {@link DateConstraints date
	 * model constraints} of this editing object and is equivalent to {@code
	 * (DateConstraints) modelConstraints()}.
	 * </p>
	 * 
	 * @return The model constraints to apply.
	 * 
	 * @see #modelConstraints()
	 * @see DateConstraints
	 */
	public DateConstraints modelDateConstraints() {
		return (DateConstraints) modelConstraints();
	}

	/**
	 * Returns the before-set model constraints to apply.
	 * 
	 * <p>
	 * This method provides a typesafe access to the {@link DateConstraints date
	 * before-set model constraints} of this editing object and is equivalent to
	 * {@code (DateConstraints) beforeSetModelConstraints()}.
	 * </p>
	 * 
	 * @return The before-set model constraints to apply.
	 * 
	 * @see #beforeSetModelConstraints()
	 * @see DateConstraints
	 */
	public DateConstraints beforeSetModelDateConstraints() {
		return (DateConstraints) beforeSetModelConstraints();
	}

	protected Constraints createTargetConstraints() {
		return new StringConstraints();
	}

	protected Constraints createModelConstraints() {
		return new DateConstraints().dateFormat(displayFormat);
	}

	protected Constraints createBeforeSetModelConstraints() {
		return new DateConstraints().dateFormat(displayFormat);
	}

	/**
	 * Convenience method which adds a {@link DateConstraints#required()
	 * required constraint} to the set of {@link #modelDateConstraints()}.
	 * 
	 * @return This editing instance for method chaining.
	 * 
	 * @see DateConstraints#required()
	 * @see #modelDateConstraints()
	 */
	public DateEditing required() {
		modelDateConstraints().required();
		return this;
	}

	/**
	 * Convenience method which adds a {@link DateConstraints#after(Date) after
	 * constraint} to the set of {@link #modelDateConstraints()}.
	 * 
	 * @param date
	 *            The date of the after constraint.
	 * @return This editing instance for method chaining.
	 * 
	 * @see DateConstraints#after(Date)
	 * @see #modelDateConstraints()
	 */
	public DateEditing after(Date date) {
		modelDateConstraints().after(date);
		return this;
	}

	/**
	 * Convenience method which adds a {@link DateConstraints#afterEqual(Date)
	 * after-equal constraint} to the set of {@link #modelDateConstraints()}.
	 * 
	 * @param date
	 *            The date of the after-equal constraint.
	 * @return This editing instance for method chaining.
	 * 
	 * @see DateConstraints#afterEqual(Date)
	 * @see #modelDateConstraints()
	 */
	public DateEditing afterEqual(Date date) {
		modelDateConstraints().afterEqual(date);
		return this;
	}

	/**
	 * Convenience method which adds a {@link DateConstraints#before(Date)
	 * before constraint} to the set of {@link #modelDateConstraints()}.
	 * 
	 * @param date
	 *            The date of the before constraint.
	 * @return This editing instance for method chaining.
	 * 
	 * @see DateConstraints#before(Date)
	 * @see #modelDateConstraints()
	 */
	public DateEditing before(Date date) {
		modelDateConstraints().before(date);
		return this;
	}

	/**
	 * Convenience method which adds a {@link DateConstraints#beforeEqual(Date)
	 * after-equal constraint} to the set of {@link #modelDateConstraints()}.
	 * 
	 * @param date
	 *            The date of the after-equal constraint.
	 * @return This editing instance for method chaining.
	 * 
	 * @see DateConstraints#afterEqual(Date)
	 * @see #modelDateConstraints()
	 */
	public DateEditing beforeEqual(Date date) {
		modelDateConstraints().beforeEqual(date);
		return this;
	}

	/**
	 * Convenience method which adds a {@link DateConstraints#range(Date, Date)
	 * range constraint} to the set of {@link #modelDateConstraints()}.
	 * 
	 * @param minDate
	 *            The min date of the range constraint.
	 * @param maxDate
	 *            The max date of the range constraint.
	 * @return This editing instance for method chaining.
	 * 
	 * @see DateConstraints#range(Date, Date)
	 * @see #modelDateConstraints()
	 */
	public DateEditing range(Date minDate, Date maxDate) {
		modelDateConstraints().range(minDate, maxDate);
		return this;
	}
}




/*******************************************************************************
 * Copyright (c) 2009 Ovidio Mallo 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:
 *     Ovidio Mallo - initial API and implementation (bug 183055)
 ******************************************************************************/

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.internal.databinding.BindingMessages;
import org.eclipse.core.runtime.IStatus;

/**
 * Provides validations for strings which must match a given regular expression.
 * 
 * @since 1.3
 */
public class StringRegexValidator implements IValidator {

	private static final String REGEX_VALIDATION_MESSAGE = BindingMessages
			.getString(BindingMessages.VALIDATE_STRING_REGEX);

	private final Pattern pattern;
	private final String validationMessage;
	private String formattedValidationMessage;

	/**
	 * Creates a new regex validator.
	 * 
	 * @param regex
	 *            The regular expression which the input string must match.
	 * @param validationMessage
	 *            The validation message pattern to use. Can be parameterized
	 *            with the given regular expression string.
	 */
	public StringRegexValidator(String regex, String validationMessage) {
		this(Pattern.compile(regex), validationMessage);
	}

	/**
	 * Creates a new regex validator.
	 * 
	 * @param pattern
	 *            The pattern which the input string must match.
	 * @param validationMessage
	 *            The validation message pattern to use. Can be parameterized
	 *            with the given regular expression string.
	 */
	public StringRegexValidator(Pattern pattern, String validationMessage) {
		this.pattern = pattern;
		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()) {
				return ValidationStatus.error(getFormattedValidationMessage());
			}
		}
		return ValidationStatus.ok();
	}

	private synchronized String getFormattedValidationMessage() {
		if (formattedValidationMessage == null) {
			formattedValidationMessage = MessageFormat.format(
					validationMessage, new String[] { pattern.pattern() });
		}
		return formattedValidationMessage;
	}
}




/*******************************************************************************
 * Copyright (c) 2009 Ovidio Mallo 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:
 *     Ovidio Mallo - initial API and implementation (bug 183055)
 ******************************************************************************/

package org.eclipse.core.databinding.editing;

import org.eclipse.core.databinding.conversion.NumberToStringConverter;
import org.eclipse.core.databinding.conversion.StringToNumberConverter;
import org.eclipse.core.databinding.validation.constraint.Constraints;
import org.eclipse.core.databinding.validation.constraint.DecimalConstraints;
import org.eclipse.core.databinding.validation.constraint.StringConstraints;
import org.eclipse.core.internal.databinding.validation.AbstractStringToNumberValidator;
import org.eclipse.core.internal.databinding.validation.StringToDoubleValidator;
import org.eclipse.core.internal.databinding.validation.StringToFloatValidator;

import com.ibm.icu.text.NumberFormat;

/**
 * @noextend This class is not intended to be subclassed by clients.
 * @since 1.3
 */
public class DecimalEditing extends Editing {

	private final NumberFormat displayFormat;

	/**
	 * Creates a new editing object for decimal numbers.
	 * 
	 * @param format
	 *            The number format defining the validations and conversions
	 *            used for editing.
	 * @param parseErrorMessage
	 *            The validation message issued in case the input string cannot
	 *            be parsed to a double.
	 * @param outOfRangeMessage
	 *            The validation message issued in case the input string
	 *            represents a double whose value is out of range.
	 * @param decimalType
	 *            The specific decimal type for which to set up an editing
	 *            instance.
	 * 
	 * @noreference This constructor is not intended to be referenced by
	 *              clients.
	 */
	protected DecimalEditing(NumberFormat format, String parseErrorMessage,
			String outOfRangeMessage, Class decimalType) {
		this.displayFormat = format;

		final StringToNumberConverter targetConverter;
		final NumberToStringConverter modelConverter;
		final AbstractStringToNumberValidator targetValidator;
		if (Double.class.equals(decimalType)) {
			targetConverter = StringToNumberConverter.toDouble(format, false);
			modelConverter = NumberToStringConverter.fromDouble(format, false);
			targetValidator = new StringToDoubleValidator(targetConverter);
		} else if (Float.class.equals(decimalType)) {
			targetConverter = StringToNumberConverter.toFloat(format, false);
			modelConverter = NumberToStringConverter.fromFloat(format, false);
			targetValidator = new StringToFloatValidator(targetConverter);
		} else {
			throw new IllegalArgumentException(
					"Unsupported decimal type: " + decimalType); //$NON-NLS-1$
		}

		if (parseErrorMessage != null) {
			targetValidator.setParseErrorMessage(parseErrorMessage);
		}
		if (outOfRangeMessage != null) {
			targetValidator.setOutOfRangeMessage(outOfRangeMessage);
		}

		setTargetConverter(targetConverter);
		setModelConverter(modelConverter);
		addTargetValidator(targetValidator);
	}

	/**
	 * Creates a new editing object for {@link Double}s 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#getNumberInstance()
	 */
	public static DecimalEditing withDoubleDefaults() {
		return withDoubleDefaults(null, null);
	}

	/**
	 * Creates a new editing object for {@link Double}s 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 a double.
	 * @param outOfRangeMessage
	 *            The validation message issued in case the input string
	 *            represents a double whose value is out of range. Can be
	 *            parameterized by the <code>-Double.MAX_VALUE</code> and
	 *            <code>+Double.MAX_VALUE</code> values.
	 * @return The new editing object using the default validations and
	 *         conversions for editing.
	 * 
	 * @see NumberFormat#getNumberInstance()
	 */
	public static DecimalEditing withDoubleDefaults(String parseErrorMessage,
			String outOfRangeMessage) {
		return new DecimalEditing(NumberFormat.getNumberInstance(),
				parseErrorMessage, outOfRangeMessage, Double.class);
	}

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

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

	/**
	 * Creates a new editing object for {@link Float}s 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#getNumberInstance()
	 */
	public static DecimalEditing withFloatDefaults() {
		return withFloatDefaults(null, null);
	}

	/**
	 * Creates a new editing object for {@link Float}s 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 a double.
	 * @param outOfRangeMessage
	 *            The validation message issued in case the input string
	 *            represents a float whose value is out of range. Can be
	 *            parameterized by the <code>-Float.MAX_VALUE</code> and
	 *            <code>+Float.MAX_VALUE</code> values.
	 * @return The new editing object using the default validations and
	 *         conversions for editing.
	 * 
	 * @see NumberFormat#getNumberInstance()
	 */
	public static DecimalEditing withFloatDefaults(String parseErrorMessage,
			String outOfRangeMessage) {
		return new DecimalEditing(NumberFormat.getNumberInstance(),
				parseErrorMessage, outOfRangeMessage, Float.class);
	}

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

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

	/**
	 * Returns the target constraints to apply.
	 * 
	 * <p>
	 * This method provides a typesafe access to the {@link StringConstraints
	 * string target constraints} of this editing object and is equivalent to
	 * {@code (StringConstraints) targetConstraints()}.
	 * </p>
	 * 
	 * @return The target constraints to apply.
	 * 
	 * @see #targetConstraints()
	 * @see StringConstraints
	 */
	public StringConstraints targetStringConstraints() {
		return (StringConstraints) targetConstraints();
	}

	/**
	 * Returns the model constraints to apply.
	 * 
	 * <p>
	 * This method provides a typesafe access to the {@link DecimalConstraints
	 * decimal model constraints} of this editing object and is equivalent to
	 * {@code (DecimalConstraints) modelConstraints()}.
	 * </p>
	 * 
	 * @return The model constraints to apply.
	 * 
	 * @see #modelConstraints()
	 * @see DecimalConstraints
	 */
	public DecimalConstraints modelDecimalConstraints() {
		return (DecimalConstraints) modelConstraints();
	}

	/**
	 * Returns the before-set model constraints to apply.
	 * 
	 * <p>
	 * This method provides a typesafe access to the {@link DecimalConstraints
	 * decimal before-set model constraints} of this editing object and is
	 * equivalent to {@code (DecimalConstraints) beforeSetModelConstraints()}.
	 * </p>
	 * 
	 * @return The before-set model constraints to apply.
	 * 
	 * @see #beforeSetModelConstraints()
	 * @see DecimalConstraints
	 */
	public DecimalConstraints beforeSetModelDecimalConstraints() {
		return (DecimalConstraints) beforeSetModelConstraints();
	}

	protected Constraints createTargetConstraints() {
		return new StringConstraints();
	}

	protected Constraints createModelConstraints() {
		return new DecimalConstraints().decimalFormat(displayFormat);
	}

	protected Constraints createBeforeSetModelConstraints() {
		return new DecimalConstraints().decimalFormat(displayFormat);
	}

	/**
	 * Convenience method which adds a {@link DecimalConstraints#required()
	 * required constraint} to the set of {@link #modelDecimalConstraints()}.
	 * 
	 * @return This editing instance for method chaining.
	 * 
	 * @see DecimalConstraints#required()
	 * @see #modelDecimalConstraints()
	 */
	public DecimalEditing required() {
		modelDecimalConstraints().required();
		return this;
	}

	/**
	 * Convenience method which adds a
	 * {@link DecimalConstraints#greater(double) greater constraint} to the set
	 * of {@link #modelDecimalConstraints()}.
	 * 
	 * @param number
	 *            The number of the greater constraint.
	 * @return This editing instance for method chaining.
	 * 
	 * @see DecimalConstraints#greater(double)
	 * @see #modelDecimalConstraints()
	 */
	public DecimalEditing greater(double number) {
		modelDecimalConstraints().greater(number);
		return this;
	}

	/**
	 * Convenience method which adds a
	 * {@link DecimalConstraints#greaterEqual(double) greater-equal constraint}
	 * to the set of {@link #modelDecimalConstraints()}.
	 * 
	 * @param number
	 *            The number of the greater-equal constraint.
	 * @return This editing instance for method chaining.
	 * 
	 * @see DecimalConstraints#greaterEqual(double)
	 * @see #modelDecimalConstraints()
	 */
	public DecimalEditing greaterEqual(double number) {
		modelDecimalConstraints().greaterEqual(number);
		return this;
	}

	/**
	 * Convenience method which adds a {@link DecimalConstraints#less(double)
	 * less constraint} to the set of {@link #modelDecimalConstraints()}.
	 * 
	 * @param number
	 *            The number of the less constraint.
	 * @return This editing instance for method chaining.
	 * 
	 * @see DecimalConstraints#less(double)
	 * @see #modelDecimalConstraints()
	 */
	public DecimalEditing less(double number) {
		modelDecimalConstraints().less(number);
		return this;
	}

	/**
	 * Convenience method which adds a
	 * {@link DecimalConstraints#lessEqual(double) less-equal constraint} to the
	 * set of {@link #modelDecimalConstraints()}.
	 * 
	 * @param number
	 *            The number of the less-equal constraint.
	 * @return This editing instance for method chaining.
	 * 
	 * @see DecimalConstraints#lessEqual(double)
	 * @see #modelDecimalConstraints()
	 */
	public DecimalEditing lessEqual(double number) {
		modelDecimalConstraints().lessEqual(number);
		return this;
	}

	/**
	 * Convenience method which adds a
	 * {@link DecimalConstraints#range(double, double) range constraint} to the
	 * set of {@link #modelDecimalConstraints()}.
	 * 
	 * @param min
	 *            The min number of the range constraint.
	 * @param max
	 *            The max number of the range constraint.
	 * @return This editing instance for method chaining.
	 * 
	 * @see DecimalConstraints#range(double, double)
	 * @see #modelDecimalConstraints()
	 */
	public DecimalEditing range(double min, double max) {
		modelDecimalConstraints().range(min, max);
		return this;
	}

	/**
	 * Convenience method which adds a {@link DecimalConstraints#positive()
	 * positive constraint} to the set of {@link #modelDecimalConstraints()}.
	 * 
	 * @return This editing instance for method chaining.
	 * 
	 * @see DecimalConstraints#positive()
	 * @see #modelDecimalConstraints()
	 */
	public DecimalEditing positive() {
		modelDecimalConstraints().positive();
		return this;
	}

	/**
	 * Convenience method which adds a {@link DecimalConstraints#nonNegative()
	 * non-negative constraint} to the set of {@link #modelDecimalConstraints()}
	 * .
	 * 
	 * @return This editing instance for method chaining.
	 * 
	 * @see DecimalConstraints#nonNegative()
	 * @see #modelDecimalConstraints()
	 */
	public DecimalEditing nonNegative() {
		modelDecimalConstraints().nonNegative();
		return this;
	}

	/**
	 * Convenience method which adds a {@link DecimalConstraints#maxScale(int)
	 * max-scale constraint} to the set of {@link #modelDecimalConstraints()} .
	 * 
	 * @param scale
	 *            The maximum scale to enforce.
	 * @return This editing instance for method chaining.
	 * 
	 * @see DecimalConstraints#maxScale(int)
	 * @see #modelDecimalConstraints()
	 */
	public DecimalEditing maxScale(int scale) {
		modelDecimalConstraints().maxScale(scale);
		return this;
	}

	/**
	 * Convenience method which adds a
	 * {@link DecimalConstraints#maxPrecision(int) max-precision constraint} to
	 * the set of {@link #modelDecimalConstraints()} .
	 * 
	 * @param precision
	 *            The maximum precision to enforce.
	 * @return This editing instance for method chaining.
	 * 
	 * @see DecimalConstraints#maxPrecision(int)
	 * @see #modelDecimalConstraints()
	 */
	public DecimalEditing maxPrecision(int precision) {
		modelDecimalConstraints().maxPrecision(precision);
		return this;
	}
}




/*******************************************************************************
 * Copyright (c) 2009 Ovidio Mallo 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:
 *     Ovidio Mallo - initial API and implementation (bug 183055)
 ******************************************************************************/

package org.eclipse.core.databinding.editing;

import java.math.BigDecimal;

import org.eclipse.core.databinding.conversion.NumberToStringConverter;
import org.eclipse.core.databinding.conversion.StringToNumberConverter;
import org.eclipse.core.databinding.validation.constraint.BigDecimalConstraints;
import org.eclipse.core.databinding.validation.constraint.Constraints;
import org.eclipse.core.databinding.validation.constraint.StringConstraints;
import org.eclipse.core.internal.databinding.validation.AbstractStringToNumberValidator;
import org.eclipse.core.internal.databinding.validation.StringToBigDecimalValidator;

import com.ibm.icu.text.NumberFormat;

/**
 * @noextend This class is not intended to be subclassed by clients.
 * @since 1.3
 */
public class BigDecimalEditing extends Editing {

	private final NumberFormat displayFormat;

	/**
	 * Creates a new editing object for <code>BigDecimal</code>s.
	 * 
	 * @param format
	 *            The BigDecimal format defining the validations and conversions
	 *            used for editing.
	 * @param parseErrorMessage
	 *            The validation message issued in case the input string cannot
	 *            be parsed to a BigDecimal.
	 * 
	 * @noreference This constructor is not intended to be referenced by
	 *              clients.
	 */
	protected BigDecimalEditing(NumberFormat format, String parseErrorMessage) {
		this.displayFormat = format;

		final StringToNumberConverter targetConverter = StringToNumberConverter
				.toBigDecimal(format);
		final NumberToStringConverter modelConverter = NumberToStringConverter
				.fromBigDecimal(format);

		final AbstractStringToNumberValidator targetValidator = new StringToBigDecimalValidator(
				targetConverter);
		if (parseErrorMessage != null) {
			targetValidator.setParseErrorMessage(parseErrorMessage);
		}

		setTargetConverter(targetConverter);
		setModelConverter(modelConverter);
		addTargetValidator(targetValidator);
	}

	/**
	 * Creates a new editing object for {@link BigDecimal}s 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#getNumberInstance()
	 */
	public static BigDecimalEditing withDefaults() {
		return withDefaults(null);
	}

	/**
	 * Creates a new editing object for {@link BigDecimal}s which defaults the
	 * validations and conversions used for editing based on the platform's
	 * locale. Uses the specified custom validation message.
	 * 
	 * @param parseErrorMessage
	 *            The validation message issued in case the input string cannot
	 *            be parsed to a BigDecimal.
	 * @return The new editing object using the default validations and
	 *         conversions for editing.
	 * 
	 * @see NumberFormat#getNumberInstance()
	 */
	public static BigDecimalEditing withDefaults(String parseErrorMessage) {
		return new BigDecimalEditing(NumberFormat.getNumberInstance(),
				parseErrorMessage);
	}

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

	/**
	 * Creates a new editing object for {@link BigDecimal}s whose validations
	 * and conversions used for editing are based on the given BigDecimal
	 * format. Uses the specified custom validation message.
	 * 
	 * @param format
	 *            The BigDecimal format defining the validations and conversions
	 *            used for editing.
	 * @param parseErrorMessage
	 *            The validation message issued in case the input string cannot
	 *            be parsed to a BigDecimal.
	 * @return The new editing object configured by the given BigDecimal format.
	 */
	public static BigDecimalEditing forFormat(NumberFormat format,
			String parseErrorMessage) {
		return new BigDecimalEditing(format, parseErrorMessage);
	}

	/**
	 * Returns the target constraints to apply.
	 * 
	 * <p>
	 * This method provides a typesafe access to the {@link StringConstraints
	 * string target constraints} of this editing object and is equivalent to
	 * {@code (StringConstraints) targetConstraints()}.
	 * </p>
	 * 
	 * @return The target constraints to apply.
	 * 
	 * @see #targetConstraints()
	 * @see StringConstraints
	 */
	public StringConstraints targetStringConstraints() {
		return (StringConstraints) targetConstraints();
	}

	/**
	 * Returns the model constraints to apply.
	 * 
	 * <p>
	 * This method provides a typesafe access to the
	 * {@link BigDecimalConstraints BigDecimal model constraints} of this
	 * editing object and is equivalent to {@code (BigDecimalConstraints)
	 * modelConstraints()}.
	 * </p>
	 * 
	 * @return The model constraints to apply.
	 * 
	 * @see #modelConstraints()
	 * @see BigDecimalConstraints
	 */
	public BigDecimalConstraints modelBigDecimalConstraints() {
		return (BigDecimalConstraints) modelConstraints();
	}

	/**
	 * Returns the before-set model constraints to apply.
	 * 
	 * <p>
	 * This method provides a typesafe access to the
	 * {@link BigDecimalConstraints BigDecimal before-set model constraints} of
	 * this editing object and is equivalent to {@code (BigDecimalConstraints)
	 * beforeSetModelConstraints()}.
	 * </p>
	 * 
	 * @return The before-set model constraints to apply.
	 * 
	 * @see #beforeSetModelConstraints()
	 * @see BigDecimalConstraints
	 */
	public BigDecimalConstraints beforeSetModelBigDecimalConstraints() {
		return (BigDecimalConstraints) beforeSetModelConstraints();
	}

	protected Constraints createTargetConstraints() {
		return new StringConstraints();
	}

	protected Constraints createModelConstraints() {
		return new BigDecimalConstraints().bigDecimalFormat(displayFormat);
	}

	protected Constraints createBeforeSetModelConstraints() {
		return new BigDecimalConstraints().bigDecimalFormat(displayFormat);
	}

	/**
	 * Convenience method which adds a {@link BigDecimalConstraints#required()
	 * required constraint} to the set of {@link #modelBigDecimalConstraints()}.
	 * 
	 * @return This editing instance for method chaining.
	 * 
	 * @see BigDecimalConstraints#required()
	 * @see #modelBigDecimalConstraints()
	 */
	public BigDecimalEditing required() {
		modelBigDecimalConstraints().required();
		return this;
	}

	/**
	 * Convenience method which adds a
	 * {@link BigDecimalConstraints#greater(BigDecimal) greater constraint} to
	 * the set of {@link #modelBigDecimalConstraints()}.
	 * 
	 * @param number
	 *            The number of the greater constraint.
	 * @return This editing instance for method chaining.
	 * 
	 * @see BigDecimalConstraints#greater(BigDecimal)
	 * @see #modelBigDecimalConstraints()
	 */
	public BigDecimalEditing greater(BigDecimal number) {
		modelBigDecimalConstraints().greater(number);
		return this;
	}

	/**
	 * Convenience method which adds a
	 * {@link BigDecimalConstraints#greaterEqual(BigDecimal) greater-equal
	 * constraint} to the set of {@link #modelBigDecimalConstraints()}.
	 * 
	 * @param number
	 *            The number of the greater-equal constraint.
	 * @return This editing instance for method chaining.
	 * 
	 * @see BigDecimalConstraints#greaterEqual(BigDecimal)
	 * @see #modelBigDecimalConstraints()
	 */
	public BigDecimalEditing greaterEqual(BigDecimal number) {
		modelBigDecimalConstraints().greaterEqual(number);
		return this;
	}

	/**
	 * Convenience method which adds a
	 * {@link BigDecimalConstraints#less(BigDecimal) less constraint} to the set
	 * of {@link #modelBigDecimalConstraints()}.
	 * 
	 * @param number
	 *            The number of the less constraint.
	 * @return This editing instance for method chaining.
	 * 
	 * @see BigDecimalConstraints#less(BigDecimal)
	 * @see #modelBigDecimalConstraints()
	 */
	public BigDecimalEditing less(BigDecimal number) {
		modelBigDecimalConstraints().less(number);
		return this;
	}

	/**
	 * Convenience method which adds a
	 * {@link BigDecimalConstraints#lessEqual(BigDecimal) less-equal constraint}
	 * to the set of {@link #modelBigDecimalConstraints()}.
	 * 
	 * @param number
	 *            The number of the less-equal constraint.
	 * @return This editing instance for method chaining.
	 * 
	 * @see BigDecimalConstraints#lessEqual(BigDecimal)
	 * @see #modelBigDecimalConstraints()
	 */
	public BigDecimalEditing lessEqual(BigDecimal number) {
		modelBigDecimalConstraints().lessEqual(number);
		return this;
	}

	/**
	 * Convenience method which adds a
	 * {@link BigDecimalConstraints#range(BigDecimal, BigDecimal) range
	 * constraint} to the set of {@link #modelBigDecimalConstraints()}.
	 * 
	 * @param min
	 *            The min number of the range constraint.
	 * @param max
	 *            The max number of the range constraint.
	 * @return This editing instance for method chaining.
	 * 
	 * @see BigDecimalConstraints#range(BigDecimal, BigDecimal)
	 * @see #modelBigDecimalConstraints()
	 */
	public BigDecimalEditing range(BigDecimal min, BigDecimal max) {
		modelBigDecimalConstraints().range(min, max);
		return this;
	}

	/**
	 * Convenience method which adds a {@link BigDecimalConstraints#positive()
	 * positive constraint} to the set of {@link #modelBigDecimalConstraints()}.
	 * 
	 * @return This editing instance for method chaining.
	 * 
	 * @see BigDecimalConstraints#positive()
	 * @see #modelBigDecimalConstraints()
	 */
	public BigDecimalEditing positive() {
		modelBigDecimalConstraints().positive();
		return this;
	}

	/**
	 * Convenience method which adds a
	 * {@link BigDecimalConstraints#nonNegative() non-negative constraint} to
	 * the set of {@link #modelBigDecimalConstraints()} .
	 * 
	 * @return This editing instance for method chaining.
	 * 
	 * @see BigDecimalConstraints#nonNegative()
	 * @see #modelBigDecimalConstraints()
	 */
	public BigDecimalEditing nonNegative() {
		modelBigDecimalConstraints().nonNegative();
		return this;
	}

	/**
	 * Convenience method which adds a
	 * {@link BigDecimalConstraints#maxScale(int) max-scale constraint} to the
	 * set of {@link #modelBigDecimalConstraints()} .
	 * 
	 * @param scale
	 *            The maximum scale to enforce.
	 * @return This editing instance for method chaining.
	 * 
	 * @see BigDecimalConstraints#maxScale(int)
	 * @see #modelBigDecimalConstraints()
	 */
	public BigDecimalEditing maxScale(int scale) {
		modelBigDecimalConstraints().maxScale(scale);
		return this;
	}

	/**
	 * Convenience method which adds a
	 * {@link BigDecimalConstraints#maxPrecision(int) max-precision constraint}
	 * to the set of {@link #modelBigDecimalConstraints()} .
	 * 
	 * @param precision
	 *            The maximum precision to enforce.
	 * @return This editing instance for method chaining.
	 * 
	 * @see BigDecimalConstraints#maxPrecision(int)
	 * @see #modelBigDecimalConstraints()
	 */
	public BigDecimalEditing maxPrecision(int precision) {
		modelBigDecimalConstraints().maxPrecision(precision);
		return this;
	}
}




/*******************************************************************************
 * Copyright (c) 2009 Ovidio Mallo 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:
 *     Ovidio Mallo - initial API and implementation (bug 183055)
 ******************************************************************************/

package org.eclipse.core.internal.databinding.validation;

import com.ibm.icu.text.NumberFormat;

/**
 * Provides validations for integer numbers which must lie within an open/closed
 * range.
 * 
 * @since 1.3
 */
public class IntegerRangeValidator extends NumberRangeValidator {

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

	/**
	 * Single constructor which supports the individual integer range types.
	 * 
	 * @param min
	 *            The min integer of the range or <code>null</code> in case no
	 *            lower bound is defined.
	 * @param max
	 *            The max integer of the range or <code>null</code> in case no
	 *            upper bound is defined.
	 * @param minConstraint
	 *            The type of constraint imposed by the lower bound of the
	 *            range.
	 * @param maxConstraint
	 *            The type of constraint imposed by the upper bound of the
	 *            range.
	 * @param validationMessage
	 *            The validation message pattern to use. Can be parameterized by
	 *            the lower and upper bound of the range, if defined.
	 * @param format
	 *            The integer format to use for formatting integers in the
	 *            validation message.
	 */
	private IntegerRangeValidator(Number min, Number max, int minConstraint,
			int maxConstraint, String validationMessage, NumberFormat format) {
		super(min, max, minConstraint, maxConstraint, validationMessage, format);
	}

	/**
	 * Creates a validator which checks that an input integer is greater than
	 * the given number.
	 * 
	 * @param number
	 *            The reference number of the greater constraint.
	 * @param validationMessage
	 *            The validation message pattern to use. Can be parameterized
	 *            with the given reference number.
	 * @param format
	 *            The display format to use for formatting integers in the
	 *            validation message.
	 * @return The validator instance.
	 */
	public static IntegerRangeValidator greater(long number,
			String validationMessage, NumberFormat format) {
		return new IntegerRangeValidator(new Long(number), null, GREATER,
				UNDEFINED, defaultIfNull(validationMessage, GREATER_MESSAGE),
				format);
	}

	/**
	 * Creates a validator which checks that an input integer is greater than or
	 * equal to the given number.
	 * 
	 * @param number
	 *            The reference number of the greater-equal constraint.
	 * @param validationMessage
	 *            The validation message pattern to use. Can be parameterized
	 *            with the given reference number.
	 * @param format
	 *            The display format to use for formatting integers in the
	 *            validation message.
	 * @return The validator instance.
	 */
	public static IntegerRangeValidator greaterEqual(long number,
			String validationMessage, NumberFormat format) {
		return new IntegerRangeValidator(new Long(number), null, GREATER_EQUAL,
				UNDEFINED, defaultIfNull(validationMessage,
						GREATER_EQUAL_MESSAGE), format);
	}

	/**
	 * Creates a validator which checks that an input integer is less than the
	 * given number.
	 * 
	 * @param number
	 *            The reference number of the less constraint.
	 * @param validationMessage
	 *            The validation message pattern to use. Can be parameterized
	 *            with the given reference number.
	 * @param format
	 *            The display format to use for formatting integers in the
	 *            validation message.
	 * @return The validator instance.
	 */
	public static IntegerRangeValidator less(long number,
			String validationMessage, NumberFormat format) {
		return new IntegerRangeValidator(null, new Long(number), UNDEFINED,
				LESS, defaultIfNull(validationMessage, LESS_MESSAGE), format);
	}

	/**
	 * Creates a validator which checks that an input integer is less than or
	 * equal to the given number.
	 * 
	 * @param number
	 *            The reference number of the less-equal constraint.
	 * @param validationMessage
	 *            The validation message pattern to use. Can be parameterized
	 *            with the given reference number.
	 * @param format
	 *            The display format to use for formatting integers in the
	 *            validation message.
	 * @return The validator instance.
	 */
	public static IntegerRangeValidator lessEqual(long number,
			String validationMessage, NumberFormat format) {
		return new IntegerRangeValidator(null, new Long(number), UNDEFINED,
				LESS_EQUAL,
				defaultIfNull(validationMessage, LESS_EQUAL_MESSAGE), format);
	}

	/**
	 * Creates a validator which checks that an input integer is within the
	 * given range.
	 * 
	 * @param min
	 *            The lower bound of the range (inclusive).
	 * @param max
	 *            The upper bound of the range (inclusive).
	 * @param validationMessage
	 *            The validation message pattern to use. Can be parameterized
	 *            with the range's lower and upper bound.
	 * @param format
	 *            The display format to use for formatting integers in the
	 *            validation message.
	 * @return The validator instance.
	 */
	public static IntegerRangeValidator range(long min, long max,
			String validationMessage, NumberFormat format) {
		return new IntegerRangeValidator(new Long(min), new Long(max),
				GREATER_EQUAL, LESS_EQUAL, defaultIfNull(validationMessage,
						WITHIN_RANGE_MESSAGE), format);
	}

	/**
	 * Creates a validator which checks that an input integer is positive.
	 * 
	 * @param validationMessage
	 *            The validation message to use.
	 * @param format
	 *            The display format to use for formatting integers in the
	 *            validation message.
	 * @return The validator instance.
	 */
	public static IntegerRangeValidator positive(String validationMessage,
			NumberFormat format) {
		return new IntegerRangeValidator(ONE, null, GREATER_EQUAL, UNDEFINED,
				defaultIfNull(validationMessage, POSITIVE_MESSAGE), format);
	}

	/**
	 * Creates a validator which checks that an input integer is non-negative.
	 * 
	 * @param validationMessage
	 *            The validation message to use.
	 * @param format
	 *            The display format to use for formatting integers in the
	 *            validation message.
	 * @return The validator instance.
	 */
	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) {
		long val1 = number1.longValue();
		long val2 = number2.longValue();
		return (val1 < val2) ? -1 : ((val1 > val2) ? + 1 : 0);
	}

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




/*******************************************************************************
 * Copyright (c) 2009 Ovidio Mallo 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:
 *     Ovidio Mallo - initial API and implementation (bug 183055)
 ******************************************************************************/

package org.eclipse.core.databinding.validation.constraint;

import java.math.BigInteger;

import org.eclipse.core.internal.databinding.validation.BigIntegerRangeValidator;
import org.eclipse.core.internal.databinding.validation.NonNullValidator;

import com.ibm.icu.text.NumberFormat;

/**
 * Provides a set of constraints to apply to <code>BigInteger</code>s.
 * 
 * <p>
 * Instances of this class can be used to define a set of constraints to apply
 * to BigInteger numbers. In addition, the validation messages to be issued for
 * the individual constraints as well as the way in which model objects are
 * formatted in the validation messages can be configured.
 * </p>
 * 
 * @see BigInteger
 * 
 * @noextend This class is not intended to be subclassed by clients.
 * @since 1.3
 */
public class BigIntegerConstraints extends Constraints {

	private NumberFormat bigIntegerFormat = NumberFormat.getIntegerInstance();

	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;

	/**
	 * Sets the format to use when formatting a BigInteger to be included in any
	 * of the validation messages.
	 * 
	 * @param format
	 *            The format to use for displaying BigIntegers in validation
	 *            messages.
	 * @return This constraints instance for method chaining.
	 */
	public BigIntegerConstraints bigIntegerFormat(NumberFormat format) {
		this.bigIntegerFormat = format;
		return this;
	}

	/**
	 * Adds a validator ensuring that the input BigInteger is not
	 * <code>null</code>. Uses the current {@link #requiredMessage(String)
	 * validation message}.
	 * 
	 * @return This constraints instance for method chaining.
	 */
	public BigIntegerConstraints required() {
		addValidator(new NonNullValidator(requiredMessage));
		return this;
	}

	/**
	 * Sets the validation message for the {@link #required()} constraint.
	 * 
	 * @param message
	 *            The validation message for the {@link #required()} constraint.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #required()
	 */
	public BigIntegerConstraints requiredMessage(String message) {
		this.requiredMessage = message;
		return this;
	}

	/**
	 * Adds a validator ensuring that the input BigInteger is greater than the
	 * given number. Uses the current {@link #greaterMessage(String) validation
	 * message} and {@link #bigIntegerFormat(NumberFormat) BigInteger format}.
	 * 
	 * @param number
	 *            The number which the input BigInteger must be greater than.
	 * @return This constraints instance for method chaining.
	 */
	public BigIntegerConstraints greater(BigInteger number) {
		addValidator(BigIntegerRangeValidator.greater(number, greaterMessage,
				bigIntegerFormat));
		return this;
	}

	/**
	 * Sets the validation message pattern for the {@link #greater(BigInteger)}
	 * constraint.
	 * 
	 * @param message
	 *            The validation message pattern for the
	 *            {@link #greater(BigInteger)} constraint. Can be parameterized
	 *            with the number which the input BigInteger must be greater
	 *            than.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #greater(BigInteger)
	 */
	public BigIntegerConstraints greaterMessage(String message) {
		this.greaterMessage = message;
		return this;
	}

	/**
	 * Adds a validator ensuring that the input BigInteger is greater than or
	 * equal to the given number. Uses the current
	 * {@link #greaterEqualMessage(String) validation message} and
	 * {@link #bigIntegerFormat(NumberFormat) BigInteger format}.
	 * 
	 * @param number
	 *            The number which the input BigInteger must be greater than or
	 *            equal to.
	 * @return This constraints instance for method chaining.
	 */
	public BigIntegerConstraints greaterEqual(BigInteger number) {
		addValidator(BigIntegerRangeValidator.greaterEqual(number,
				greaterEqualMessage, bigIntegerFormat));
		return this;
	}

	/**
	 * Sets the validation message pattern for the
	 * {@link #greaterEqual(BigInteger)} constraint.
	 * 
	 * @param message
	 *            The validation message pattern for the
	 *            {@link #greaterEqual(BigInteger)} constraint. Can be
	 *            parameterized with the number which the input BigInteger must
	 *            be greater than or equal to.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #greaterEqual(BigInteger)
	 */
	public BigIntegerConstraints greaterEqualMessage(String message) {
		this.greaterEqualMessage = message;
		return this;
	}

	/**
	 * Adds a validator ensuring that the input BigInteger is less than the
	 * given number. Uses the current {@link #lessMessage(String) validation
	 * message} and {@link #bigIntegerFormat(NumberFormat) BigInteger format}.
	 * 
	 * @param number
	 *            The number which the input BigInteger must be less than.
	 * @return This constraints instance for method chaining.
	 */
	public BigIntegerConstraints less(BigInteger number) {
		addValidator(BigIntegerRangeValidator.less(number, lessMessage,
				bigIntegerFormat));
		return this;
	}

	/**
	 * Sets the validation message pattern for the {@link #less(BigInteger)}
	 * constraint.
	 * 
	 * @param message
	 *            The validation message pattern for the
	 *            {@link #less(BigInteger)} constraint. Can be parameterized
	 *            with the number which the input BigInteger must be less than.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #less(BigInteger)
	 */
	public BigIntegerConstraints lessMessage(String message) {
		this.lessMessage = message;
		return this;
	}

	/**
	 * Adds a validator ensuring that the input BigInteger is less than or equal
	 * to the given number. Uses the current {@link #lessEqualMessage(String)
	 * validation message} and {@link #bigIntegerFormat(NumberFormat) BigInteger
	 * format}.
	 * 
	 * @param number
	 *            The number which the input BigInteger must be less than or
	 *            equal to.
	 * @return This constraints instance for method chaining.
	 */
	public BigIntegerConstraints lessEqual(BigInteger number) {
		addValidator(BigIntegerRangeValidator.greaterEqual(number,
				lessEqualMessage, bigIntegerFormat));
		return this;
	}

	/**
	 * Sets the validation message pattern for the
	 * {@link #lessEqual(BigInteger)} constraint.
	 * 
	 * @param message
	 *            The validation message pattern for the
	 *            {@link #lessEqual(BigInteger)} constraint. Can be
	 *            parameterized with the number which the input BigInteger must
	 *            be less than or equal to.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #lessEqual(BigInteger)
	 */
	public BigIntegerConstraints lessEqualMessage(String message) {
		this.lessEqualMessage = message;
		return this;
	}

	/**
	 * Adds a validator ensuring that the input BigInteger is within the given
	 * range. Uses the current {@link #rangeMessage(String) validation message}
	 * and {@link #bigIntegerFormat(NumberFormat) BigInteger format}.
	 * 
	 * @param min
	 *            The lower bound of the range (inclusive).
	 * @param max
	 *            The upper bound of the range (inclusive).
	 * @return This constraints instance for method chaining.
	 */
	public BigIntegerConstraints range(BigInteger min, BigInteger max) {
		addValidator(BigIntegerRangeValidator.range(min, max, rangeMessage,
				bigIntegerFormat));
		return this;
	}

	/**
	 * Sets the validation message pattern for the
	 * {@link #range(BigInteger, BigInteger)} constraint.
	 * 
	 * @param message
	 *            The validation message pattern for the
	 *            {@link #range(BigInteger, BigInteger)} constraint. Can be
	 *            parameterized with the min and max values of the range in
	 *            which the input BigInteger must lie.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #range(BigInteger, BigInteger)
	 */
	public BigIntegerConstraints rangeMessage(String message) {
		this.rangeMessage = message;
		return this;
	}

	/**
	 * Adds a validator ensuring that the input BigInteger is positive. Uses the
	 * current {@link #positiveMessage(String) validation message} and
	 * {@link #bigIntegerFormat(NumberFormat) BigInteger format}.
	 * 
	 * @return This constraints instance for method chaining.
	 */
	public BigIntegerConstraints positive() {
		addValidator(BigIntegerRangeValidator.positive(positiveMessage,
				bigIntegerFormat));
		return this;
	}

	/**
	 * Sets the validation message pattern for the {@link #positive()}
	 * constraint.
	 * 
	 * @param message
	 *            The validation message pattern for the {@link #positive()}
	 *            constraint.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #positive()
	 */
	public BigIntegerConstraints positiveMessage(String message) {
		this.positiveMessage = message;
		return this;
	}

	/**
	 * Adds a validator ensuring that the input BigInteger is non-negative. Uses
	 * the current {@link #nonNegativeMessage(String) validation message} and
	 * {@link #bigIntegerFormat(NumberFormat) BigInteger format}.
	 * 
	 * @return This constraints instance for method chaining.
	 */
	public BigIntegerConstraints nonNegative() {
		addValidator(BigIntegerRangeValidator.nonNegative(nonNegativeMessage,
				bigIntegerFormat));
		return this;
	}

	/**
	 * Sets the validation message pattern for the {@link #nonNegative()}
	 * constraint.
	 * 
	 * @param message
	 *            The validation message pattern for the {@link #nonNegative()}
	 *            constraint.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #nonNegative()
	 */
	public BigIntegerConstraints nonNegativeMessage(String message) {
		this.nonNegativeMessage = message;
		return this;
	}
}




/*******************************************************************************
 * Copyright (c) 2009 Ovidio Mallo 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:
 *     Ovidio Mallo - initial API and implementation (bug 183055)
 ******************************************************************************/

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.internal.databinding.BindingMessages;
import org.eclipse.core.runtime.IStatus;

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

	private static final int VALIDATE_NO_WHITESPACE = 0;
	private static final int VALIDATE_NO_SPACE = 1;
	private static final int VALIDATE_LETTER = 2;
	private static final int VALIDATE_DIGIT = 3;
	private static final int VALIDATE_LETTER_OR_DIGIT = 4;

	private static final String NO_WHITESPACE_VALIDATION_MESSAGE = BindingMessages
			.getString(BindingMessages.VALIDATE_CHARACTER_NO_WHITESPACE);
	private static final String NO_SPACE_VALIDATION_MESSAGE = BindingMessages
			.getString(BindingMessages.VALIDATE_CHARACTER_NO_SPACE);
	private static final String LETTER_VALIDATION_MESSAGE = BindingMessages
			.getString(BindingMessages.VALIDATE_CHARACTER_LETTER);
	private static final String DIGIT_VALIDATION_MESSAGE = BindingMessages
			.getString(BindingMessages.VALIDATE_CHARACTER_DIGIT);
	private static final String LETTER_OR_DIGIT_VALIDATION_MESSAGE = BindingMessages
			.getString(BindingMessages.VALIDATE_CHARACTER_LETTER_OR_DIGIT);

	private final int validation;
	private final String validationMessage;

	private CharacterValidator(int validation, String validationMessage) {
		this.validation = validation;
		this.validationMessage = validationMessage;
	}

	/**
	 * Creates a validator which checks that an input character is no
	 * {@link Character#isWhitespace(char) whitespace}.
	 * 
	 * @param validationMessage
	 *            The validation message to use.
	 * @return The validator instance.
	 */
	public static CharacterValidator noWhitespace(String validationMessage) {
		return new CharacterValidator(VALIDATE_NO_WHITESPACE, defaultIfNull(
				NO_WHITESPACE_VALIDATION_MESSAGE, validationMessage));
	}

	/**
	 * Creates a validator which checks that an input character is no
	 * {@link Character#isSpaceChar(char) space}.
	 * 
	 * @param validationMessage
	 *            The validation message to use.
	 * @return The validator instance.
	 */
	public static CharacterValidator noSpace(String validationMessage) {
		return new CharacterValidator(VALIDATE_NO_SPACE, defaultIfNull(
				NO_SPACE_VALIDATION_MESSAGE, validationMessage));
	}

	/**
	 * Creates a validator which checks that an input character is a
	 * {@link Character#isLetter(char) letter}.
	 * 
	 * @param validationMessage
	 *            The validation message to use.
	 * @return The validator instance.
	 */
	public static CharacterValidator letter(String validationMessage) {
		return new CharacterValidator(VALIDATE_LETTER, defaultIfNull(
				LETTER_VALIDATION_MESSAGE, validationMessage));
	}

	/**
	 * Creates a validator which checks that an input character is a
	 * {@link Character#isDigit(char) digit}.
	 * 
	 * @param validationMessage
	 *            The validation message to use.
	 * @return The validator instance.
	 */
	public static CharacterValidator digit(String validationMessage) {
		return new CharacterValidator(VALIDATE_DIGIT, defaultIfNull(
				DIGIT_VALIDATION_MESSAGE, validationMessage));
	}

	/**
	 * Creates a validator which checks that an input character is a
	 * {@link Character#isLetterOrDigit(char) letter or ditig}.
	 * 
	 * @param validationMessage
	 *            The validation message to use.
	 * @return The validator instance.
	 */
	public static CharacterValidator letterOrDigit(String validationMessage) {
		return new CharacterValidator(VALIDATE_LETTER_OR_DIGIT, defaultIfNull(
				LETTER_OR_DIGIT_VALIDATION_MESSAGE, validationMessage));
	}

	public IStatus validate(Object value) {
		if (value != null) {
			char character = ((Character) value).charValue();
			if (!isValid(character)) {
				return ValidationStatus.error(validationMessage);
			}
		}
		return ValidationStatus.ok();
	}

	private boolean isValid(char character) {
		switch (validation) {
		case VALIDATE_NO_WHITESPACE:
			return !Character.isWhitespace(character);
		case VALIDATE_NO_SPACE:
			return !Character.isSpaceChar(character);
		case VALIDATE_LETTER:
			return Character.isLetter(character);
		case VALIDATE_DIGIT:
			return Character.isDigit(character);
		case VALIDATE_LETTER_OR_DIGIT:
			return Character.isLetterOrDigit(character);
		default:
			throw new IllegalArgumentException(
					"Unsupported validation: " + validation); //$NON-NLS-1$
		}
	}

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




/*******************************************************************************
 * Copyright (c) 2009 Ovidio Mallo 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:
 *     Ovidio Mallo - initial API and implementation (bug 183055)
 ******************************************************************************/

package org.eclipse.core.databinding.editing;

import org.eclipse.core.databinding.validation.constraint.CharacterConstraints;
import org.eclipse.core.databinding.validation.constraint.Constraints;
import org.eclipse.core.databinding.validation.constraint.StringConstraints;
import org.eclipse.core.internal.databinding.conversion.CharacterToStringConverter;
import org.eclipse.core.internal.databinding.conversion.StringToCharacterConverter;
import org.eclipse.core.internal.databinding.validation.StringToCharacterValidator;

/**
 * @noextend This class is not intended to be subclassed by clients.
 * @since 1.3
 */
public class CharacterEditing extends Editing {

	/**
	 * Creates a new editing object for booleans.
	 * 
	 * @param parseErrorMessage
	 *            The validation message issued in case the input string is not
	 *            a valid character.
	 * 
	 * @noreference This constructor is not intended to be referenced by
	 *              clients.
	 */
	protected CharacterEditing(String parseErrorMessage) {
		StringToCharacterConverter targetConverter = new StringToCharacterConverter(
				false);
		CharacterToStringConverter modelConverter = CharacterToStringConverter
				.fromCharacter(false);

		StringToCharacterValidator targetValidator = new StringToCharacterValidator(
				targetConverter);
		if (parseErrorMessage != null) {
			targetValidator.setParseErrorMessage(parseErrorMessage);
		}

		setTargetConverter(targetConverter);
		setModelConverter(modelConverter);
		addTargetValidator(targetValidator);
	}

	/**
	 * Creates a new editing object which uses the default validations and
	 * conversions for the editing of characters.
	 * 
	 * @return The new editing object for the default editing of characters.
	 */
	public static CharacterEditing withDefaults() {
		return withDefaults(null);
	}

	/**
	 * Creates a new editing object which uses the default validations and
	 * conversions for the editing of characters. Uses the specified custom
	 * validation message.
	 * 
	 * @param parseErrorMessage
	 *            The validation message issued in case the input string is not
	 *            a valid character.
	 * @return The new editing object for the default editing of characters.
	 */
	public static CharacterEditing withDefaults(String parseErrorMessage) {
		return new CharacterEditing(parseErrorMessage);
	}

	/**
	 * Returns the target constraints to apply.
	 * 
	 * <p>
	 * This method provides a typesafe access to the {@link StringConstraints
	 * string target constraints} of this editing object and is equivalent to
	 * {@code (StringConstraints) targetConstraints()}.
	 * </p>
	 * 
	 * @return The target constraints to apply.
	 * 
	 * @see #targetConstraints()
	 * @see StringConstraints
	 */
	public StringConstraints targetStringConstraints() {
		return (StringConstraints) targetConstraints();
	}

	/**
	 * Returns the model constraints to apply.
	 * 
	 * <p>
	 * This method provides a typesafe access to the
	 * {@link CharacterConstraints character model constraints} of this editing
	 * object and is equivalent to {@code (CharacterConstraints)
	 * modelConstraints()}.
	 * </p>
	 * 
	 * @return The model constraints to apply.
	 * 
	 * @see #modelConstraints()
	 * @see CharacterConstraints
	 */
	public CharacterConstraints modelCharacterConstraints() {
		return (CharacterConstraints) modelConstraints();
	}

	/**
	 * Returns the before-set model constraints to apply.
	 * 
	 * <p>
	 * This method provides a typesafe access to the
	 * {@link CharacterConstraints character before-set model constraints} of
	 * this editing object and is equivalent to {@code (CharacterConstraints)
	 * beforeSetModelConstraints()}.
	 * </p>
	 * 
	 * @return The before-set model constraints to apply.
	 * 
	 * @see #beforeSetModelConstraints()
	 * @see CharacterConstraints
	 */
	public CharacterConstraints beforeSetModelCharacterConstraints() {
		return (CharacterConstraints) beforeSetModelConstraints();
	}

	protected Constraints createTargetConstraints() {
		return new StringConstraints();
	}

	protected Constraints createModelConstraints() {
		return new CharacterConstraints();
	}

	protected Constraints createBeforeSetModelConstraints() {
		return new CharacterConstraints();
	}

	/**
	 * Convenience method which adds a {@link CharacterConstraints#required()
	 * required constraint} to the set of {@link #modelCharacterConstraints()}.
	 * 
	 * @return This editing instance for method chaining.
	 * 
	 * @see CharacterConstraints#required()
	 * @see #modelCharacterConstraints()
	 */
	public CharacterEditing required() {
		modelCharacterConstraints().required();
		return this;
	}

	/**
	 * Convenience method which adds a
	 * {@link CharacterConstraints#noWhitespace() no-whitespace constraint} to
	 * the set of {@link #modelCharacterConstraints()}.
	 * 
	 * @return This editing instance for method chaining.
	 * 
	 * @see CharacterConstraints#noWhitespace()
	 * @see #modelCharacterConstraints()
	 */
	public CharacterEditing noWhitespace() {
		modelCharacterConstraints().noWhitespace();
		return this;
	}

	/**
	 * Convenience method which adds a {@link CharacterConstraints#noSpace()
	 * no-space constraint} to the set of {@link #modelCharacterConstraints()}.
	 * 
	 * @return This editing instance for method chaining.
	 * 
	 * @see CharacterConstraints#noSpace()
	 * @see #modelCharacterConstraints()
	 */
	public CharacterEditing noSpace() {
		modelCharacterConstraints().noSpace();
		return this;
	}

	/**
	 * Convenience method which adds a {@link CharacterConstraints#letter()
	 * letter constraint} to the set of {@link #modelCharacterConstraints()}.
	 * 
	 * @return This editing instance for method chaining.
	 * 
	 * @see CharacterConstraints#letter()
	 * @see #modelCharacterConstraints()
	 */
	public CharacterEditing letter() {
		modelCharacterConstraints().letter();
		return this;
	}

	/**
	 * Convenience method which adds a {@link CharacterConstraints#digit() digit
	 * constraint} to the set of {@link #modelCharacterConstraints()}.
	 * 
	 * @return This editing instance for method chaining.
	 * 
	 * @see CharacterConstraints#digit()
	 * @see #modelCharacterConstraints()
	 */
	public CharacterEditing digit() {
		modelCharacterConstraints().digit();
		return this;
	}

	/**
	 * Convenience method which adds a
	 * {@link CharacterConstraints#letterOrDigit() letter-or-digit constraint}
	 * to the set of {@link #modelCharacterConstraints()}.
	 * 
	 * @return This editing instance for method chaining.
	 * 
	 * @see CharacterConstraints#letterOrDigit()
	 * @see #modelCharacterConstraints()
	 */
	public CharacterEditing letterOrDigit() {
		modelCharacterConstraints().letterOrDigit();
		return this;
	}
}




/*******************************************************************************
 * Copyright (c) 2007 Ovidio Mallo 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:
 *     Ovidio Mallo - initial API and implementation (bug 183055)
 ******************************************************************************/

package org.eclipse.core.internal.databinding.validation;

/**
 * Validates that a string is of the appropriate format for a BigInteger.
 * 
 * @since 1.3
 */
public class StringToBigIntegerValidator extends
		AbstractStringToNumberValidator {

	/**
	 * @param converter
	 */
	public StringToBigIntegerValidator(NumberFormatConverter converter) {
		super(converter, null, null);
	}

	protected boolean isInRange(Number number) {
		return true;
	}
}




/*******************************************************************************
 * Copyright (c) 2009 Ovidio Mallo 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:
 *     Ovidio Mallo - initial API and implementation (bug 183055)
 ******************************************************************************/

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.internal.databinding.BindingMessages;
import org.eclipse.core.runtime.IStatus;

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

	private static final String NON_NULL_VALIDATION_MESSAGE = BindingMessages
			.getString(BindingMessages.VALIDATE_NON_NULL);

	private final String validationMessage;

	/**
	 * @param validationMessage
	 */
	public NonNullValidator(String validationMessage) {
		this.validationMessage = validationMessage != null ? validationMessage
				: NON_NULL_VALIDATION_MESSAGE;
	}

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




/*******************************************************************************
 * Copyright (c) 2009 Ovidio Mallo 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:
 *     Ovidio Mallo - initial API and implementation (bug 183055)
 ******************************************************************************/

package org.eclipse.core.internal.databinding.validation;

import com.ibm.icu.text.NumberFormat;

/**
 * Provides validations for decimal numbers which must lie within an open/closed
 * range.
 * 
 * @since 1.3
 */
public class DecimalRangeValidator extends NumberRangeValidator {

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

	/**
	 * Single constructor which supports the individual decimal range types.
	 * 
	 * @param min
	 *            The min decimal of the range or <code>null</code> in case no
	 *            lower bound is defined.
	 * @param max
	 *            The max decimal of the range or <code>null</code> in case no
	 *            upper bound is defined.
	 * @param minConstraint
	 *            The type of constraint imposed by the lower bound of the
	 *            range.
	 * @param maxConstraint
	 *            The type of constraint imposed by the upper bound of the
	 *            range.
	 * @param validationMessage
	 *            The validation message pattern to use. Can be parameterized by
	 *            the lower and upper bound of the range, if defined.
	 * @param format
	 *            The decimal format to use for formatting integers in the
	 *            validation message.
	 */
	private DecimalRangeValidator(Number min, Number max, int minConstraint,
			int maxConstraint, String validationMessage, NumberFormat format) {
		super(min, max, minConstraint, maxConstraint, validationMessage, format);
	}

	/**
	 * Creates a validator which checks that an input decimal is greater than
	 * the given number.
	 * 
	 * @param number
	 *            The reference number of the greater constraint.
	 * @param validationMessage
	 *            The validation message pattern to use. Can be parameterized
	 *            with the given reference number.
	 * @param format
	 *            The display format to use for formatting integers in the
	 *            validation message.
	 * @return The validator instance.
	 */
	public static DecimalRangeValidator greater(double number,
			String validationMessage, NumberFormat format) {
		return new DecimalRangeValidator(new Double(number), null, GREATER,
				UNDEFINED, defaultIfNull(validationMessage, GREATER_MESSAGE),
				format);
	}

	/**
	 * Creates a validator which checks that an input decimal is greater than or
	 * equal to the given number.
	 * 
	 * @param number
	 *            The reference number of the greater-equal constraint.
	 * @param validationMessage
	 *            The validation message pattern to use. Can be parameterized
	 *            with the given reference number.
	 * @param format
	 *            The display format to use for formatting integers in the
	 *            validation message.
	 * @return The validator instance.
	 */
	public static DecimalRangeValidator greaterEqual(double number,
			String validationMessage, NumberFormat format) {
		return new DecimalRangeValidator(new Double(number), null,
				GREATER_EQUAL, UNDEFINED, defaultIfNull(validationMessage,
						GREATER_EQUAL_MESSAGE), format);
	}

	/**
	 * Creates a validator which checks that an input decimal is less than the
	 * given number.
	 * 
	 * @param number
	 *            The reference number of the less constraint.
	 * @param validationMessage
	 *            The validation message pattern to use. Can be parameterized
	 *            with the given reference number.
	 * @param format
	 *            The display format to use for formatting integers in the
	 *            validation message.
	 * @return The validator instance.
	 */
	public static DecimalRangeValidator less(double number,
			String validationMessage, NumberFormat format) {
		return new DecimalRangeValidator(null, new Double(number), UNDEFINED,
				LESS, defaultIfNull(validationMessage, LESS_MESSAGE), format);
	}

	/**
	 * Creates a validator which checks that an input decimal is less than or
	 * equal to the given number.
	 * 
	 * @param number
	 *            The reference number of the less-equal constraint.
	 * @param validationMessage
	 *            The validation message pattern to use. Can be parameterized
	 *            with the given reference number.
	 * @param format
	 *            The display format to use for formatting integers in the
	 *            validation message.
	 * @return The validator instance.
	 */
	public static DecimalRangeValidator lessEqual(double number,
			String validationMessage, NumberFormat format) {
		return new DecimalRangeValidator(null, new Double(number), UNDEFINED,
				LESS_EQUAL,
				defaultIfNull(validationMessage, LESS_EQUAL_MESSAGE), format);
	}

	/**
	 * Creates a validator which checks that an input decimal is within the
	 * given range.
	 * 
	 * @param min
	 *            The lower bound of the range (inclusive).
	 * @param max
	 *            The upper bound of the range (inclusive).
	 * @param validationMessage
	 *            The validation message pattern to use. Can be parameterized
	 *            with the range's lower and upper bound.
	 * @param format
	 *            The display format to use for formatting integers in the
	 *            validation message.
	 * @return The validator instance.
	 */
	public static DecimalRangeValidator range(double min, double max,
			String validationMessage, NumberFormat format) {
		return new DecimalRangeValidator(new Double(min), new Double(max),
				GREATER_EQUAL, LESS_EQUAL, defaultIfNull(validationMessage,
						WITHIN_RANGE_MESSAGE), format);
	}

	/**
	 * Creates a validator which checks that an input decimal is positive.
	 * 
	 * @param validationMessage
	 *            The validation message to use.
	 * @param format
	 *            The display format to use for formatting integers in the
	 *            validation message.
	 * @return The validator instance.
	 */
	public static DecimalRangeValidator positive(String validationMessage,
			NumberFormat format) {
		return new DecimalRangeValidator(ONE, null, GREATER_EQUAL, UNDEFINED,
				defaultIfNull(validationMessage, POSITIVE_MESSAGE), format);
	}

	/**
	 * Creates a validator which checks that an input decimal is non-negative.
	 * 
	 * @param validationMessage
	 *            The validation message to use.
	 * @param format
	 *            The display format to use for formatting integers in the
	 *            validation message.
	 * @return The validator instance.
	 */
	public static DecimalRangeValidator nonNegative(String validationMessage,
			NumberFormat format) {
		return new DecimalRangeValidator(ZERO, null, GREATER_EQUAL, UNDEFINED,
				defaultIfNull(validationMessage, NON_NEGATIVE_MESSAGE), format);
	}

	protected int compare(Number number1, Number number2) {
		double val1 = number1.doubleValue();
		double val2 = number2.doubleValue();
		return (val1 < val2) ? -1 : ((val1 > val2) ? + 1 : 0);
	}

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




/*******************************************************************************
 * Copyright (c) 2009 Ovidio Mallo 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:
 *     Ovidio Mallo - initial API and implementation (bug 183055)
 ******************************************************************************/

package org.eclipse.core.internal.databinding.validation;

import java.math.BigDecimal;

import com.ibm.icu.text.NumberFormat;

/**
 * Provides validations for BigDecimals which must lie within an open/closed
 * range.
 * 
 * @since 1.3
 */
public class BigDecimalRangeValidator extends NumberRangeValidator {

	private static final BigDecimal ZERO = new BigDecimal("0"); //$NON-NLS-1$
	private static final BigDecimal ONE = new BigDecimal("1"); //$NON-NLS-1$

	/**
	 * Single constructor which supports the individual integer range types.
	 * 
	 * @param min
	 *            The min BigDecimal of the range or <code>null</code> in case
	 *            no lower bound is defined.
	 * @param max
	 *            The max BigDecimal of the range or <code>null</code> in case
	 *            no upper bound is defined.
	 * @param minConstraint
	 *            The type of constraint imposed by the lower bound of the
	 *            range.
	 * @param maxConstraint
	 *            The type of constraint imposed by the upper bound of the
	 *            range.
	 * @param validationMessage
	 *            The validation message pattern to use. Can be parameterized by
	 *            the lower and upper bound of the range, if defined.
	 * @param format
	 *            The BigDecimal format to use for formatting integers in the
	 *            validation message.
	 */
	private BigDecimalRangeValidator(BigDecimal min, BigDecimal max,
			int minConstraint, int maxConstraint, String validationMessage,
			NumberFormat format) {
		super(min, max, minConstraint, maxConstraint, validationMessage, format);
	}

	/**
	 * Creates a validator which checks that an input BigDecimal is greater than
	 * the given number.
	 * 
	 * @param number
	 *            The reference number of the greater constraint.
	 * @param validationMessage
	 *            The validation message pattern to use. Can be parameterized
	 *            with the given reference number.
	 * @param format
	 *            The display format to use for formatting BigDecimals in the
	 *            validation message.
	 * @return The validator instance.
	 */
	public static BigDecimalRangeValidator greater(BigDecimal number,
			String validationMessage, NumberFormat format) {
		return new BigDecimalRangeValidator(number, null, GREATER, UNDEFINED,
				defaultIfNull(validationMessage, GREATER_MESSAGE), format);
	}

	/**
	 * Creates a validator which checks that an input BigDecimal is greater than
	 * or equal to the given number.
	 * 
	 * @param number
	 *            The reference number of the greater-equal constraint.
	 * @param validationMessage
	 *            The validation message pattern to use. Can be parameterized
	 *            with the given reference number.
	 * @param format
	 *            The display format to use for formatting BigDecimals in the
	 *            validation message.
	 * @return The validator instance.
	 */
	public static BigDecimalRangeValidator greaterEqual(BigDecimal number,
			String validationMessage, NumberFormat format) {
		return new BigDecimalRangeValidator(number, null, GREATER_EQUAL,
				UNDEFINED, defaultIfNull(validationMessage,
						GREATER_EQUAL_MESSAGE), format);
	}

	/**
	 * Creates a validator which checks that an input BigDecimal is less than
	 * the given number.
	 * 
	 * @param number
	 *            The reference number of the less constraint.
	 * @param validationMessage
	 *            The validation message pattern to use. Can be parameterized
	 *            with the given reference number.
	 * @param format
	 *            The display format to use for formatting BigDecimals in the
	 *            validation message.
	 * @return The validator instance.
	 */
	public static BigDecimalRangeValidator less(BigDecimal number,
			String validationMessage, NumberFormat format) {
		return new BigDecimalRangeValidator(null, number, UNDEFINED, LESS,
				defaultIfNull(validationMessage, LESS_MESSAGE), format);
	}

	/**
	 * Creates a validator which checks that an input BigDecimal is less than or
	 * equal to the given number.
	 * 
	 * @param number
	 *            The reference number of the less-equal constraint.
	 * @param validationMessage
	 *            The validation message pattern to use. Can be parameterized
	 *            with the given reference number.
	 * @param format
	 *            The display format to use for formatting BigDecimals in the
	 *            validation message.
	 * @return The validator instance.
	 */
	public static BigDecimalRangeValidator lessEqual(BigDecimal number,
			String validationMessage, NumberFormat format) {
		return new BigDecimalRangeValidator(null, number, UNDEFINED,
				LESS_EQUAL,
				defaultIfNull(validationMessage, LESS_EQUAL_MESSAGE), format);
	}

	/**
	 * Creates a validator which checks that an input BigDecimal is within the
	 * given range.
	 * 
	 * @param min
	 *            The lower bound of the range (inclusive).
	 * @param max
	 *            The upper bound of the range (inclusive).
	 * @param validationMessage
	 *            The validation message pattern to use. Can be parameterized
	 *            with the range's lower and upper bound.
	 * @param format
	 *            The display format to use for formatting BigDecimals in the
	 *            validation message.
	 * @return The validator instance.
	 */
	public static BigDecimalRangeValidator range(BigDecimal min,
			BigDecimal max, String validationMessage, NumberFormat format) {
		return new BigDecimalRangeValidator(min, max, GREATER_EQUAL,
				LESS_EQUAL, defaultIfNull(validationMessage,
						WITHIN_RANGE_MESSAGE), format);
	}

	/**
	 * Creates a validator which checks that an input BigDecimal is positive.
	 * 
	 * @param validationMessage
	 *            The validation message to use.
	 * @param format
	 *            The display format to use for formatting BigDecimals in the
	 *            validation message.
	 * @return The validator instance.
	 */
	public static BigDecimalRangeValidator positive(String validationMessage,
			NumberFormat format) {
		return new BigDecimalRangeValidator(ONE, null, GREATER_EQUAL,
				UNDEFINED, defaultIfNull(validationMessage, POSITIVE_MESSAGE),
				format);
	}

	/**
	 * Creates a validator which checks that an input BigDecimal is
	 * non-negative.
	 * 
	 * @param validationMessage
	 *            The validation message to use.
	 * @param format
	 *            The display format to use for formatting BigDecimals in the
	 *            validation message.
	 * @return The validator instance.
	 */
	public static BigDecimalRangeValidator nonNegative(
			String validationMessage, NumberFormat format) {
		return new BigDecimalRangeValidator(ZERO, null, GREATER_EQUAL,
				UNDEFINED, defaultIfNull(validationMessage,
						NON_NEGATIVE_MESSAGE), format);
	}

	protected int compare(Number number1, Number number2) {
		BigDecimal bigDecimal1 = (BigDecimal) number1;
		BigDecimal bigDecimal2 = (BigDecimal) number2;
		return bigDecimal1.compareTo(bigDecimal2);
	}

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




/*******************************************************************************
 * Copyright (c) 2009 Ovidio Mallo 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:
 *     Ovidio Mallo - initial API and implementation (bug 183055)
 ******************************************************************************/

package org.eclipse.core.internal.databinding.conversion;

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

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

	// Those are the defaults used up to now in UpdateStrategy where a simple
	// ObjectToStringConverter was used for converting booleans to strings.
	// FIXME: Should/may we change this to convert to a localized string?
	private String trueValue = Boolean.TRUE.toString();
	private String falseValue = Boolean.FALSE.toString();

	/**
	 * Creates a new converter which converts a boolean to its default string
	 * representation.
	 * 
	 * @param booleanType
	 *            The boolean type. Must be one of {@code Boolean.TYPE} or
	 *            {@code Boolean.class}.
	 */
	public BooleanToStringConverter(Class booleanType) {
		super(booleanType, String.class);
	}

	/**
	 * Sets the string values to which a <code>true</code> and
	 * <code>false</code> value should be converted.
	 * 
	 * @param trueValue
	 *            The string to which to convert a <code>true</code> value.
	 * @param falseValue
	 *            The string to which to convert a <code>false</code> value.
	 */
	public final void setTargetStrings(String trueValue, String falseValue) {
		this.trueValue = trueValue;
		this.falseValue = falseValue;
	}

	public Object convert(Object source) {
		Boolean value = (Boolean) source;
		if (value != null) {
			return value.booleanValue() ? trueValue : falseValue;
		}
		return ""; //$NON-NLS-1$
	}
}




/*******************************************************************************
 * Copyright (c) 2009 Ovidio Mallo 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:
 *     Ovidio Mallo - initial API and implementation (bug 183055)
 ******************************************************************************/

package org.eclipse.core.databinding.editing;

import java.math.BigInteger;

import org.eclipse.core.databinding.conversion.NumberToStringConverter;
import org.eclipse.core.databinding.conversion.StringToNumberConverter;
import org.eclipse.core.databinding.validation.constraint.BigIntegerConstraints;
import org.eclipse.core.databinding.validation.constraint.Constraints;
import org.eclipse.core.databinding.validation.constraint.StringConstraints;
import org.eclipse.core.internal.databinding.validation.AbstractStringToNumberValidator;
import org.eclipse.core.internal.databinding.validation.StringToBigIntegerValidator;

import com.ibm.icu.text.NumberFormat;

/**
 * @noextend This class is not intended to be subclassed by clients.
 * @since 1.3
 */
public class BigIntegerEditing extends Editing {

	private final NumberFormat displayFormat;

	/**
	 * Creates a new editing object for <code>BigInteger</code>s.
	 * 
	 * @param format
	 *            The BigInteger format defining the validations and conversions
	 *            used for editing.
	 * @param parseErrorMessage
	 *            The validation message issued in case the input string cannot
	 *            be parsed to a BigInteger.
	 * 
	 * @noreference This constructor is not intended to be referenced by
	 *              clients.
	 */
	protected BigIntegerEditing(NumberFormat format, String parseErrorMessage) {
		this.displayFormat = format;

		final StringToNumberConverter targetConverter = StringToNumberConverter
				.toBigInteger(format);
		final NumberToStringConverter modelConverter = NumberToStringConverter
				.fromBigInteger(format);

		final AbstractStringToNumberValidator targetValidator = new StringToBigIntegerValidator(
				targetConverter);
		if (parseErrorMessage != null) {
			targetValidator.setParseErrorMessage(parseErrorMessage);
		}

		setTargetConverter(targetConverter);
		setModelConverter(modelConverter);
		addTargetValidator(targetValidator);
	}

	/**
	 * Creates a new editing object for {@link BigInteger}s 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 BigIntegerEditing withDefaults() {
		return withDefaults(null);
	}

	/**
	 * Creates a new editing object for {@link BigInteger}s which defaults the
	 * validations and conversions used for editing based on the platform's
	 * locale. Uses the specified custom validation message.
	 * 
	 * @param parseErrorMessage
	 *            The validation message issued in case the input string cannot
	 *            be parsed to a BigInteger.
	 * @return The new editing object using the default validations and
	 *         conversions for editing.
	 * 
	 * @see NumberFormat#getIntegerInstance()
	 */
	public static BigIntegerEditing withDefaults(String parseErrorMessage) {
		return new BigIntegerEditing(NumberFormat.getIntegerInstance(),
				parseErrorMessage);
	}

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

	/**
	 * Creates a new editing object for {@link BigInteger}s whose validations
	 * and conversions used for editing are based on the given BigInteger
	 * format. Uses the specified custom validation message.
	 * 
	 * @param format
	 *            The BigInteger format defining the validations and conversions
	 *            used for editing.
	 * @param parseErrorMessage
	 *            The validation message issued in case the input string cannot
	 *            be parsed to a BigInteger.
	 * @return The new editing object configured by the given BigInteger format.
	 */
	public static BigIntegerEditing forFormat(NumberFormat format,
			String parseErrorMessage) {
		return new BigIntegerEditing(format, parseErrorMessage);
	}

	/**
	 * Returns the target constraints to apply.
	 * 
	 * <p>
	 * This method provides a typesafe access to the {@link StringConstraints
	 * string target constraints} of this editing object and is equivalent to
	 * {@code (StringConstraints) targetConstraints()}.
	 * </p>
	 * 
	 * @return The target constraints to apply.
	 * 
	 * @see #targetConstraints()
	 * @see StringConstraints
	 */
	public StringConstraints targetStringConstraints() {
		return (StringConstraints) targetConstraints();
	}

	/**
	 * Returns the model constraints to apply.
	 * 
	 * <p>
	 * This method provides a typesafe access to the
	 * {@link BigIntegerConstraints BigInteger model constraints} of this
	 * editing object and is equivalent to {@code (BigIntegerConstraints)
	 * modelConstraints()}.
	 * </p>
	 * 
	 * @return The model constraints to apply.
	 * 
	 * @see #modelConstraints()
	 * @see BigIntegerConstraints
	 */
	public BigIntegerConstraints modelBigIntegerConstraints() {
		return (BigIntegerConstraints) modelConstraints();
	}

	/**
	 * Returns the before-set model constraints to apply.
	 * 
	 * <p>
	 * This method provides a typesafe access to the
	 * {@link BigIntegerConstraints BigInteger before-set model constraints} of
	 * this editing object and is equivalent to {@code (BigIntegerConstraints)
	 * beforeSetModelConstraints()}.
	 * </p>
	 * 
	 * @return The before-set model constraints to apply.
	 * 
	 * @see #beforeSetModelConstraints()
	 * @see BigIntegerConstraints
	 */
	public BigIntegerConstraints beforeSetModelBigIntegerConstraints() {
		return (BigIntegerConstraints) beforeSetModelConstraints();
	}

	protected Constraints createTargetConstraints() {
		return new StringConstraints();
	}

	protected Constraints createModelConstraints() {
		return new BigIntegerConstraints().bigIntegerFormat(displayFormat);
	}

	protected Constraints createBeforeSetModelConstraints() {
		return new BigIntegerConstraints().bigIntegerFormat(displayFormat);
	}

	/**
	 * Convenience method which adds a {@link BigIntegerConstraints#required()
	 * required constraint} to the set of {@link #modelBigIntegerConstraints()}.
	 * 
	 * @return This editing instance for method chaining.
	 * 
	 * @see BigIntegerConstraints#required()
	 * @see #modelBigIntegerConstraints()
	 */
	public BigIntegerEditing required() {
		modelBigIntegerConstraints().required();
		return this;
	}

	/**
	 * Convenience method which adds a
	 * {@link BigIntegerConstraints#greater(BigInteger) greater constraint} to
	 * the set of {@link #modelBigIntegerConstraints()}.
	 * 
	 * @param number
	 *            The number of the greater constraint.
	 * @return This editing instance for method chaining.
	 * 
	 * @see BigIntegerConstraints#greater(BigInteger)
	 * @see #modelBigIntegerConstraints()
	 */
	public BigIntegerEditing greater(BigInteger number) {
		modelBigIntegerConstraints().greater(number);
		return this;
	}

	/**
	 * Convenience method which adds a
	 * {@link BigIntegerConstraints#greaterEqual(BigInteger) greater-equal
	 * constraint} to the set of {@link #modelBigIntegerConstraints()}.
	 * 
	 * @param number
	 *            The number of the greater-equal constraint.
	 * @return This editing instance for method chaining.
	 * 
	 * @see BigIntegerConstraints#greaterEqual(BigInteger)
	 * @see #modelBigIntegerConstraints()
	 */
	public BigIntegerEditing greaterEqual(BigInteger number) {
		modelBigIntegerConstraints().greaterEqual(number);
		return this;
	}

	/**
	 * Convenience method which adds a
	 * {@link BigIntegerConstraints#less(BigInteger) less constraint} to the set
	 * of {@link #modelBigIntegerConstraints()}.
	 * 
	 * @param number
	 *            The number of the less constraint.
	 * @return This editing instance for method chaining.
	 * 
	 * @see BigIntegerConstraints#less(BigInteger)
	 * @see #modelBigIntegerConstraints()
	 */
	public BigIntegerEditing less(BigInteger number) {
		modelBigIntegerConstraints().less(number);
		return this;
	}

	/**
	 * Convenience method which adds a
	 * {@link BigIntegerConstraints#lessEqual(BigInteger) less-equal constraint}
	 * to the set of {@link #modelBigIntegerConstraints()}.
	 * 
	 * @param number
	 *            The number of the less-equal constraint.
	 * @return This editing instance for method chaining.
	 * 
	 * @see BigIntegerConstraints#lessEqual(BigInteger)
	 * @see #modelBigIntegerConstraints()
	 */
	public BigIntegerEditing lessEqual(BigInteger number) {
		modelBigIntegerConstraints().lessEqual(number);
		return this;
	}

	/**
	 * Convenience method which adds a
	 * {@link BigIntegerConstraints#range(BigInteger, BigInteger) range
	 * constraint} to the set of {@link #modelBigIntegerConstraints()}.
	 * 
	 * @param min
	 *            The min number of the range constraint.
	 * @param max
	 *            The max number of the range constraint.
	 * @return This editing instance for method chaining.
	 * 
	 * @see BigIntegerConstraints#range(BigInteger, BigInteger)
	 * @see #modelBigIntegerConstraints()
	 */
	public BigIntegerEditing range(BigInteger min, BigInteger max) {
		modelBigIntegerConstraints().range(min, max);
		return this;
	}

	/**
	 * Convenience method which adds a {@link BigIntegerConstraints#positive()
	 * positive constraint} to the set of {@link #modelBigIntegerConstraints()}.
	 * 
	 * @return This editing instance for method chaining.
	 * 
	 * @see BigIntegerConstraints#positive()
	 * @see #modelBigIntegerConstraints()
	 */
	public BigIntegerEditing positive() {
		modelBigIntegerConstraints().positive();
		return this;
	}

	/**
	 * Convenience method which adds a
	 * {@link BigIntegerConstraints#nonNegative() non-negative constraint} to
	 * the set of {@link #modelBigIntegerConstraints()} .
	 * 
	 * @return This editing instance for method chaining.
	 * 
	 * @see BigIntegerConstraints#nonNegative()
	 * @see #modelBigIntegerConstraints()
	 */
	public BigIntegerEditing nonNegative() {
		modelBigIntegerConstraints().nonNegative();
		return this;
	}
}




/*******************************************************************************
 * Copyright (c) 2009 Ovidio Mallo 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:
 *     Ovidio Mallo - initial API and implementation (bug 183055)
 ******************************************************************************/

package org.eclipse.core.databinding.validation.constraint;

import org.eclipse.core.internal.databinding.validation.IntegerRangeValidator;
import org.eclipse.core.internal.databinding.validation.NonNullValidator;

import com.ibm.icu.text.NumberFormat;

/**
 * Provides a set of constraints to apply to integer numbers.
 * 
 * <p>
 * Instances of this class can be used to define a set of constraints to apply
 * to integer numbers. In addition, the validation messages to be issued for the
 * individual constraints as well as the way in which model objects are
 * formatted in the validation messages can be configured.
 * </p>
 * 
 * <p>
 * The integer types supported by this class are <code>long</code>,
 * <code>int</code>, <code>short</code>, and <code>byte</code>.
 * </p>
 * 
 * @noextend This class is not intended to be subclassed by clients.
 * @since 1.3
 */
public class IntegerConstraints extends Constraints {

	private NumberFormat integerFormat = NumberFormat.getIntegerInstance();

	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;

	/**
	 * Sets the format to use when formatting an integer to be included in any
	 * of the validation messages.
	 * 
	 * @param format
	 *            The format to use for displaying integers in validation
	 *            messages.
	 * @return This constraints instance for method chaining.
	 */
	public IntegerConstraints integerFormat(NumberFormat format) {
		this.integerFormat = format;
		return this;
	}

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

	/**
	 * Sets the validation message for the {@link #required()} constraint.
	 * 
	 * @param message
	 *            The validation message for the {@link #required()} constraint.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #required()
	 */
	public IntegerConstraints requiredMessage(String message) {
		this.requiredMessage = message;
		return this;
	}

	/**
	 * Adds a validator ensuring that the input integer is greater than the
	 * given number. Uses the current {@link #greaterMessage(String) validation
	 * message} and {@link #integerFormat(NumberFormat) integer format}.
	 * 
	 * @param number
	 *            The number which the input integer must be greater than.
	 * @return This constraints instance for method chaining.
	 */
	public IntegerConstraints greater(long number) {
		addValidator(IntegerRangeValidator.greater(number, greaterMessage,
				integerFormat));
		return this;
	}

	/**
	 * Sets the validation message pattern for the {@link #greater(long)}
	 * constraint.
	 * 
	 * @param message
	 *            The validation message pattern for the {@link #greater(long)}
	 *            constraint. Can be parameterized with the number which the
	 *            input integer must be greater than.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #greater(long)
	 */
	public IntegerConstraints greaterMessage(String message) {
		this.greaterMessage = message;
		return this;
	}

	/**
	 * Adds a validator ensuring that the input integer is greater than or equal
	 * to the given number. Uses the current
	 * {@link #greaterEqualMessage(String) validation message} and
	 * {@link #integerFormat(NumberFormat) integer format}.
	 * 
	 * @param number
	 *            The number which the input integer must be greater than or
	 *            equal to.
	 * @return This constraints instance for method chaining.
	 */
	public IntegerConstraints greaterEqual(long number) {
		addValidator(IntegerRangeValidator.greaterEqual(number,
				greaterEqualMessage, integerFormat));
		return this;
	}

	/**
	 * Sets the validation message pattern for the {@link #greaterEqual(long)}
	 * constraint.
	 * 
	 * @param message
	 *            The validation message pattern for the
	 *            {@link #greaterEqual(long)} constraint. Can be parameterized
	 *            with the number which the input integer must be greater than
	 *            or equal to.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #greaterEqual(long)
	 */
	public IntegerConstraints greaterEqualMessage(String message) {
		this.greaterEqualMessage = message;
		return this;
	}

	/**
	 * Adds a validator ensuring that the input integer is less than the given
	 * number. Uses the current {@link #lessMessage(String) validation message}
	 * and {@link #integerFormat(NumberFormat) integer format}.
	 * 
	 * @param number
	 *            The number which the input integer must be less than.
	 * @return This constraints instance for method chaining.
	 */
	public IntegerConstraints less(long number) {
		addValidator(IntegerRangeValidator.less(number, lessMessage,
				integerFormat));
		return this;
	}

	/**
	 * Sets the validation message pattern for the {@link #less(long)}
	 * constraint.
	 * 
	 * @param message
	 *            The validation message pattern for the {@link #less(long)}
	 *            constraint. Can be parameterized with the number which the
	 *            input integer must be less than.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #less(long)
	 */
	public IntegerConstraints lessMessage(String message) {
		this.lessMessage = message;
		return this;
	}

	/**
	 * Adds a validator ensuring that the input integer is less than or equal to
	 * the given number. Uses the current {@link #lessEqualMessage(String)
	 * validation message} and {@link #integerFormat(NumberFormat) integer
	 * format}.
	 * 
	 * @param number
	 *            The number which the input integer must be less than or equal
	 *            to.
	 * @return This constraints instance for method chaining.
	 */
	public IntegerConstraints lessEqual(long number) {
		addValidator(IntegerRangeValidator.greaterEqual(number,
				lessEqualMessage, integerFormat));
		return this;
	}

	/**
	 * Sets the validation message pattern for the {@link #lessEqual(long)}
	 * constraint.
	 * 
	 * @param message
	 *            The validation message pattern for the
	 *            {@link #lessEqual(long)} constraint. Can be parameterized with
	 *            the number which the input integer must be less than or equal
	 *            to.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #lessEqual(long)
	 */
	public IntegerConstraints lessEqualMessage(String message) {
		this.lessEqualMessage = message;
		return this;
	}

	/**
	 * Adds a validator ensuring that the input integer is within the given
	 * range. Uses the current {@link #rangeMessage(String) validation message}
	 * and {@link #integerFormat(NumberFormat) integer format}.
	 * 
	 * @param min
	 *            The lower bound of the range (inclusive).
	 * @param max
	 *            The upper bound of the range (inclusive).
	 * @return This constraints instance for method chaining.
	 */
	public IntegerConstraints range(long min, long max) {
		addValidator(IntegerRangeValidator.range(min, max, rangeMessage,
				integerFormat));
		return this;
	}

	/**
	 * Sets the validation message pattern for the {@link #range(long, long)}
	 * constraint.
	 * 
	 * @param message
	 *            The validation message pattern for the
	 *            {@link #range(long, long)} constraint. Can be parameterized
	 *            with the min and max values of the range in which the input
	 *            integer must lie.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #range(long, long)
	 */
	public IntegerConstraints rangeMessage(String message) {
		this.rangeMessage = message;
		return this;
	}

	/**
	 * Adds a validator ensuring that the input integer is positive. Uses the
	 * current {@link #positiveMessage(String) validation message} and
	 * {@link #integerFormat(NumberFormat) integer format}.
	 * 
	 * @return This constraints instance for method chaining.
	 */
	public IntegerConstraints positive() {
		addValidator(IntegerRangeValidator.positive(positiveMessage,
				integerFormat));
		return this;
	}

	/**
	 * Sets the validation message pattern for the {@link #positive()}
	 * constraint.
	 * 
	 * @param message
	 *            The validation message pattern for the {@link #positive()}
	 *            constraint.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #positive()
	 */
	public IntegerConstraints positiveMessage(String message) {
		this.positiveMessage = message;
		return this;
	}

	/**
	 * Adds a validator ensuring that the input integer is non-negative. Uses
	 * the current {@link #nonNegativeMessage(String) validation message} and
	 * {@link #integerFormat(NumberFormat) integer format}.
	 * 
	 * @return This constraints instance for method chaining.
	 */
	public IntegerConstraints nonNegative() {
		addValidator(IntegerRangeValidator.nonNegative(nonNegativeMessage,
				integerFormat));
		return this;
	}

	/**
	 * Sets the validation message pattern for the {@link #nonNegative()}
	 * constraint.
	 * 
	 * @param message
	 *            The validation message pattern for the {@link #nonNegative()}
	 *            constraint.
	 * @return This constraints instance for method chaining.
	 * 
	 * @see #nonNegative()
	 */
	public IntegerConstraints nonNegativeMessage(String message) {
		this.nonNegativeMessage = message;
		return this;
	}
}




/*******************************************************************************
 * Copyright (c) 2009 Ovidio Mallo 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:
 *     Ovidio Mallo - initial API and implementation (bug 183055)
 ******************************************************************************/

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.internal.databinding.BindingMessages;
import org.eclipse.core.runtime.IStatus;

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

	private static final String NON_EMPTY_STRING_VALIDATION_MESSAGE = BindingMessages
			.getString(BindingMessages.VALIDATE_NON_EMPTY_STRING);

	private final String validationMessage;

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

	/**
	 * @param validationMessage
	 */
	public NonEmptyStringValidator(String validationMessage) {
		this.validationMessage = validationMessage != null ? validationMessage
				: NON_EMPTY_STRING_VALIDATION_MESSAGE;
	}

	public IStatus validate(Object value) {
		String input = (String) value;
		if (input == null || input.length() == 0) {
			return ValidationStatus.error(validationMessage);
		}
		return ValidationStatus.ok();
	}
}




/*******************************************************************************
 * Copyright (c) 2009 Ovidio Mallo 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:
 *     Ovidio Mallo - initial API and implementation (bug 183055)
 ******************************************************************************/

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 >= stripStart
					&& Character.isWhitespace(string.charAt(stripEnd))) {
				stripEnd--;
			}

			if (stripStart <= stripEnd) {
				string = string.substring(stripStart, stripEnd + 1);
			} else {
				string = ""; //$NON-NLS-1$
			}
		}

		if (stripToNull && string != null && string.length() == 0) {
			string = null;
		}

		return string;
	}
}

Return to bug 183055

Added Link Here

(-)src/org/eclipse/jface/examples/databinding/util/ObservableMapEditingSupport.java (+88 lines)
1	/*******************************************************************************
2	* Copyright (c) 2009 Ovidio Mallo 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	* Ovidio Mallo - initial API and implementation (bug 183055)
10	******************************************************************************/
11
12	package org.eclipse.jface.examples.databinding.util;
13
14	import org.eclipse.core.databinding.editing.Editing;
15	import org.eclipse.core.databinding.observable.map.IObservableMap;
16	import org.eclipse.core.databinding.util.Policy;
17	import org.eclipse.core.runtime.IStatus;
18	import org.eclipse.core.runtime.MultiStatus;
19	import org.eclipse.jface.dialogs.MessageDialog;
20	import org.eclipse.jface.viewers.CellEditor;
21	import org.eclipse.jface.viewers.ColumnViewer;
22	import org.eclipse.jface.viewers.EditingSupport;
23	import org.eclipse.jface.viewers.TextCellEditor;
24	import org.eclipse.swt.widgets.Composite;
25
26	/**
27	* @since 3.2
28	*/
29	public class ObservableMapEditingSupport extends EditingSupport {
30
31	private final IObservableMap attributeMap;
32
33	private final Editing editing;
34
35	private final CellEditor cellEditor;
36
37	public ObservableMapEditingSupport(ColumnViewer viewer, IObservableMap attributeMap, Editing editing) {
38	super(viewer);
39	this.attributeMap = attributeMap;
40	this.editing = editing;
41	this.cellEditor = new TextCellEditor((Composite) getViewer().getControl());
42	}
43
44	protected boolean canEdit(Object element) {
45	return true;
46	}
47
48	protected CellEditor getCellEditor(Object element) {
49	return cellEditor;
50	}
51
52	protected Object getValue(Object element) {
53	return editing.convertToTarget(attributeMap.get(element));
54	}
55
56	protected void setValue(Object element, Object value) {
57	MultiStatus validationStatus = new MultiStatus(Policy.JFACE_DATABINDING, 0, null, null);
58	Object modelValue = editing.convertToModel(value, validationStatus);
59	if (handleValidation(validationStatus)) {
60	attributeMap.put(element, modelValue);
61	}
62	}
63
64	private boolean handleValidation(IStatus validationStatus) {
65	if (validationStatus.matches(IStatus.ERROR \| IStatus.CANCEL)) {
66	MessageDialog.openError(getViewer().getControl().getShell(), "Validation Error", getValidationMessage(validationStatus));
67	return false;
68	}
69	return true;
70	}
71
72	private static String getValidationMessage(IStatus validationStatus) {
73	if (!validationStatus.isMultiStatus()) {
74	return validationStatus.getMessage();
75	}
76
77	MultiStatus multiStatus = (MultiStatus) validationStatus;
78	StringBuffer sb = new StringBuffer();
79	IStatus[] childStatus = multiStatus.getChildren();
80	for (int i = 0; i < childStatus.length; i++) {
81	if (i > 0) {
82	sb.append('\n');
83	}
84	sb.append(getValidationMessage(childStatus[i]));
85	}
86	return sb.toString();
87	}
88	}

Added Link Here

(-)src/org/eclipse/jface/examples/databinding/snippets/Snippet035Editing.java (+276 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006, 2009 Ovidio Mallo 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	* Ovidio Mallo - initial API and implementation (bug 183055)
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.BooleanEditing;
20	import org.eclipse.core.databinding.editing.DateEditing;
21	import org.eclipse.core.databinding.editing.DecimalEditing;
22	import org.eclipse.core.databinding.editing.Editing;
23	import org.eclipse.core.databinding.editing.IntegerEditing;
24	import org.eclipse.core.databinding.observable.Realm;
25	import org.eclipse.core.databinding.observable.list.WritableList;
26	import org.eclipse.core.databinding.observable.value.IObservableValue;
27	import org.eclipse.core.databinding.observable.value.WritableValue;
28	import org.eclipse.core.databinding.validation.IValidator;
29	import org.eclipse.core.databinding.validation.ValidationStatus;
30	import org.eclipse.core.databinding.validation.constraint.Constraints;
31	import org.eclipse.core.databinding.validation.constraint.IntegerConstraints;
32	import org.eclipse.core.runtime.IStatus;
33	import org.eclipse.jface.databinding.swt.ISWTObservableValue;
34	import org.eclipse.jface.databinding.swt.SWTObservables;
35	import org.eclipse.jface.databinding.viewers.ObservableListContentProvider;
36	import org.eclipse.jface.examples.databinding.util.EditingFactory;
37	import org.eclipse.jface.internal.databinding.provisional.fieldassist.ControlDecorationSupport;
38	import org.eclipse.jface.layout.GridDataFactory;
39	import org.eclipse.jface.layout.GridLayoutFactory;
40	import org.eclipse.jface.viewers.LabelProvider;
41	import org.eclipse.jface.viewers.ListViewer;
42	import org.eclipse.swt.SWT;
43	import org.eclipse.swt.events.FocusAdapter;
44	import org.eclipse.swt.events.FocusEvent;
45	import org.eclipse.swt.events.SelectionAdapter;
46	import org.eclipse.swt.events.SelectionEvent;
47	import org.eclipse.swt.layout.GridLayout;
48	import org.eclipse.swt.widgets.Composite;
49	import org.eclipse.swt.widgets.Control;
50	import org.eclipse.swt.widgets.Display;
51	import org.eclipse.swt.widgets.Group;
52	import org.eclipse.swt.widgets.Label;
53	import org.eclipse.swt.widgets.Shell;
54	import org.eclipse.swt.widgets.Text;
55
56	import com.ibm.icu.text.MessageFormat;
57
58	public class Snippet035Editing {
59
60	private DataBindingContext dbc;
61
62	public static void main(String[] args) {
63	Display display = new Display();
64
65	Realm.runWithDefault(SWTObservables.getRealm(display), new Runnable() {
66	public void run() {
67	Shell shell = new Snippet035Editing().createShell();
68	Display display = Display.getCurrent();
69	while (!shell.isDisposed()) {
70	if (!display.readAndDispatch()) {
71	display.sleep();
72	}
73	}
74	}
75	});
76	}
77
78	private Shell createShell() {
79	Display display = Display.getCurrent();
80	Shell shell = new Shell(display);
81	shell.setText("Editing");
82	shell.setLayout(new GridLayout(1, false));
83
84	dbc = new DataBindingContext();
85
86	createValueSection(shell);
87	createListSection(shell);
88
89	shell.pack();
90	shell.open();
91
92	return shell;
93	}
94
95	private void createValueSection(Composite parent) {
96	Group section = createSectionGroup(parent, "Value bindings", false);
97
98	// Edit an e-mail address.
99	Text emailText = createTextField(section, "E-Mail*");
100	Editing emailEditing = EditingFactory.forEmailString().required();
101	bindTextField(emailText, new WritableValue(), emailEditing);
102
103	// Edit a required, positive short using the default validation message.
104	Text positiveText = createTextField(section, "Positive short*");
105	IntegerEditing positiveEditing = EditingFactory.forShort().required().positive();
106	bindTextField(positiveText, new WritableValue(), positiveEditing);
107
108	// Edit a required double with a maximum of five significant and two
109	// fractional digits.
110	Text doubleText = createTextField(section, "Price [$]*");
111	DecimalEditing doubleEditing = EditingFactory.forDouble().required().maxPrecision(5).maxScale(2);
112	bindTextField(doubleText, new WritableValue(), doubleEditing);
113
114	// Edit an integer within the range [1, 100] using the default
115	// validation message.
116	Text rangeText = createTextField(section, "Value in [1, 100]");
117	IntegerEditing rangeEditing = EditingFactory.forInteger().range(1, 100);
118	bindTextField(rangeText, new WritableValue(0, null), rangeEditing);
119
120	// Edit a percentage value which must lie within [0, 100] using a custom
121	// validation message which indicates that the value actually represents
122	// a percentage value. Note that the constraint message must be specified
123	// before the actual constraint.
124	Text percentText = createTextField(section, "Percentage [%]");
125	IntegerEditing percentEditing = EditingFactory.forInteger();
126	percentEditing.modelIntegerConstraints()
127	.rangeMessage("Please specify a percentage value within [{0}, {1}].")
128	.range(0, 100);
129	bindTextField(percentText, new WritableValue(-1, null), percentEditing);
130
131	// Edit a hex integer within the range [0x00, 0xff]. The range validation
132	// message will display the range boundaries in hex format as well.
133	Text hexText = createTextField(section, "Hex value in [0x00, 0xff]");
134	IntegerEditing hexEditing = EditingFactory.forHexInteger(2).range(0x00, 0xff);
135	bindTextField(hexText, new WritableValue(0, null), hexEditing);
136
137	// Edit a boolean value.
138	Text boolText = createTextField(section, "Boolean value");
139	BooleanEditing boolEditing = EditingFactory.forBoolean();
140	bindTextField(boolText, new WritableValue(true, null), boolEditing);
141
142	// Edit a value within [1, 10] or [20, 30].
143	Text rangesText = createTextField(section, "Value in [1, 10] or [20, 30]");
144	Editing rangesEditing = EditingFactory.forInteger().addModelValidator(new RangesValidator(1, 10, 20, 30));
145	bindTextField(rangesText, new WritableValue(), rangesEditing);
146	}
147
148	private void createListSection(Composite parent) {
149	Group section = createSectionGroup(parent, "List bindings", true);
150
151	// Our date should be >= 01.01.1990.
152	Calendar year1990Calendar = Calendar.getInstance();
153	year1990Calendar.clear();
154	year1990Calendar.set(1990, 0, 1);
155	Date year1990 = year1990Calendar.getTime();
156
157	// Edit a date supporting the default input/display patterns.
158	Text dateText = createTextField(section, "Date");
159	DateEditing dateEditing = EditingFactory.forDate().afterEqual(year1990);
160	final WritableValue dateObservable = new WritableValue();
161	final Binding dateBinding = bindTextField(dateText, dateObservable, dateEditing);
162
163	// Create a list to which the dates are added when the user hits ENTER.
164	new Label(section, SWT.LEFT);
165	ListViewer dateListViewer = new ListViewer(section);
166	GridDataFactory.fillDefaults().grab(true, true).hint(150, 200).applyTo(dateListViewer.getList());
167
168	dateListViewer.setContentProvider(new ObservableListContentProvider());
169	dateListViewer.setLabelProvider(new LabelProvider());
170
171	// We use the same DateEditing object as for the text field above to
172	// create a list binding which maps the entered dates to their string
173	// representation which is then set as input on the ListViewer.
174	final WritableList targetDateList = new WritableList();
175	final WritableList modelDateList = new WritableList();
176	dateEditing.bindList(dbc, targetDateList, modelDateList);
177
178	// Set the list containing the string representation of the dates as input.
179	dateListViewer.setInput(targetDateList);
180
181	// Add the current date in the text field when the user hits ENTER.
182	dateText.addSelectionListener(new SelectionAdapter() {
183	public void widgetDefaultSelected(SelectionEvent e) {
184	IStatus dateValidationStatus = (IStatus) dateBinding.getValidationStatus().getValue();
185	Date date = (Date) dateObservable.getValue();
186	if (dateValidationStatus.isOK() && date != null) {
187	modelDateList.add(date);
188	}
189	}
190	});
191	}
192
193	private Binding bindTextField(Text text, IObservableValue modelValue, Editing editing) {
194	// Create the binding using the editing object.
195	ISWTObservableValue textObservable = SWTObservables.observeText(text, SWT.Modify);
196	Binding binding = editing.bindValue(dbc, textObservable, modelValue);
197
198	// Decorate the control with the validation status.
199	ControlDecorationSupport.create(binding, SWT.TOP);
200
201	// Re-format when the text field looses the focus in order to always
202	// display the model in the default format in case multiple input formats
203	// are supported.
204	formatOnFocusOut(text, binding);
205
206	return binding;
207	}
208
209	private static void formatOnFocusOut(final Control control, final Binding binding) {
210	control.addFocusListener(new FocusAdapter() {
211	public void focusLost(FocusEvent e) {
212	IStatus dateValidationStatus = (IStatus) binding.getValidationStatus().getValue();
213	if (dateValidationStatus.isOK()) {
214	binding.updateModelToTarget();
215	}
216	}
217	});
218	}
219
220	private static Group createSectionGroup(Composite parent, String groupText, boolean grabVertical) {
221	Group section = new Group(parent, SWT.SHADOW_ETCHED_IN);
222	section.setText(groupText);
223	GridLayoutFactory.fillDefaults()
224	.numColumns(2)
225	.equalWidth(false)
226	.margins(5, 5)
227	.spacing(15, 5)
228	.applyTo(section);
229	GridDataFactory.fillDefaults().grab(true, grabVertical).applyTo(section);
230	return section;
231	}
232
233	private static Text createTextField(Composite parent, String labelText) {
234	Label label = new Label(parent, SWT.LEFT);
235	label.setText(labelText);
236	GridDataFactory.fillDefaults().align(SWT.LEFT, SWT.CENTER).applyTo(label);
237
238	final Text text = new Text(parent, SWT.BORDER);
239	GridDataFactory.fillDefaults().grab(true, false).hint(150, SWT.DEFAULT).applyTo(text);
240
241	// Select the text when gaining focus.
242	text.addFocusListener(new FocusAdapter() {
243	public void focusGained(FocusEvent e) {
244	text.selectAll();
245	}
246	});
247
248	return text;
249	}
250
251	private static final class RangesValidator implements IValidator {
252
253	private final String validationMessage;
254
255	private final IValidator validator;
256
257	public RangesValidator(int min1, int max1, int min2, int max2) {
258	this.validationMessage = MessageFormat.format(
259	"The value must lie within [{0}, {1}] or [{2}, {3}].",
260	new Object[] { min1, max1, min2, max2 });
261	this.validator =
262	new IntegerConstraints()
263	.range(min1, max1)
264	.range(min2, max2)
265	.aggregationPolicy(Constraints.AGGREGATION_MIN_SEVERITY)
266	.createValidator();
267	}
268
269	public IStatus validate(Object value) {
270	if (!validator.validate(value).isOK()) {
271	return ValidationStatus.error(validationMessage);
272	}
273	return ValidationStatus.ok();
274	}
275	}
276	}

Lines 12-17 Link Here

(-)src/org/eclipse/core/tests/internal/databinding/BindingMessagesTest.java (-2 / +3 lines)
12	*	12	*
13	* Contributors:	13	* Contributors:
14	* IBM Corporation - initial API and implementation	14	* IBM Corporation - initial API and implementation
		15	* Ovidio Mallo - bug 183055
15	******************************************************************************/	16	******************************************************************************/
16		17
17	/**	18	/**
Lines 21-33 Link Here
21	public class BindingMessagesTest extends TestCase {	22	public class BindingMessagesTest extends TestCase {
22	public void testFormatString() throws Exception {	23	public void testFormatString() throws Exception {
23	String key = "Validate_NumberOutOfRangeError";	24	String key = "Validate_NumberOutOfRangeError";
24	String result = BindingMessages.formatString(key, new Object[] {"1", "2"});	25	String result = BindingMessages.getFormattedString(key, new Object[] {"1", "2"});
25	assertFalse("key should not be returned", key.equals(result));	26	assertFalse("key should not be returned", key.equals(result));
26	}	27	}
27		28
28	public void testFormatStringForKeyNotFound() throws Exception {	29	public void testFormatStringForKeyNotFound() throws Exception {
29	String key = "key_that_does_not_exist";	30	String key = "key_that_does_not_exist";
30	String result = BindingMessages.formatString(key, null);	31	String result = BindingMessages.getFormattedString(key, null);
31	assertTrue(key.equals(result));	32	assertTrue(key.equals(result));
32	}	33	}
33	}	34	}

Lines 10-15 Link Here

(-)src/org/eclipse/core/internal/databinding/conversion/DateConversionSupport.java (+15 lines)
10	* db4objects - Initial API and implementation	10	* db4objects - Initial API and implementation
11	* Tom Schindl<tom.schindl@bestsolution.at> - bugfix for 217940	11	* Tom Schindl<tom.schindl@bestsolution.at> - bugfix for 217940
12	* Matthew Hall - bug 121110	12	* Matthew Hall - bug 121110
		13	* Ovidio Mallo - bug 183055
13	******************************************************************************/	14	******************************************************************************/
14	package org.eclipse.core.internal.databinding.conversion;	15	package org.eclipse.core.internal.databinding.conversion;
15		16
Lines 52-57 Link Here
52	};	53	};
53		54
54	/**	55	/**
		56	* Sets the {@link DateFormat}s to be used for parsing/formatting dates. Any
		57	* of the supplied formats will be used for {@link #parse(String) parsing} a
		58	* date from a string while the first format in the array will be used for
		59	* {@link #format(Date) formatting} a date as a string.
		60	*
		61	* @param formatters
		62	* The {@link DateFormat}s to be used for parsing/formatting
		63	* dates.
		64	*/
		65	public final void setFormatters(DateFormat[] formatters) {
		66	this.formatters = formatters;
		67	}
		68
		69	/**
55	* Tries all available formatters to parse the given string according to the	70	* 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	71	* default locale or as a raw millisecond value and returns the result of the
57	* first successful run.	72	* first successful run.

Lines 9-14 Link Here

(-)src/org/eclipse/core/databinding/UpdateStrategy.java (-2 / +3 lines)
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
10	* Matt Carter - bug 180392	10	* Matt Carter - bug 180392
11	* - bug 197679 (Character support completed)	11	* - bug 197679 (Character support completed)
		12	* Ovidio Mallo - bug 183055
12	*******************************************************************************/	13	*******************************************************************************/
13		14
14	package org.eclipse.core.databinding;	15	package org.eclipse.core.databinding;
Lines 24-29 Link Here
24	import org.eclipse.core.databinding.util.Policy;	25	import org.eclipse.core.databinding.util.Policy;
25	import org.eclipse.core.internal.databinding.ClassLookupSupport;	26	import org.eclipse.core.internal.databinding.ClassLookupSupport;
26	import org.eclipse.core.internal.databinding.Pair;	27	import org.eclipse.core.internal.databinding.Pair;
		28	import org.eclipse.core.internal.databinding.conversion.BooleanToStringConverter;
27	import org.eclipse.core.internal.databinding.conversion.CharacterToStringConverter;	29	import org.eclipse.core.internal.databinding.conversion.CharacterToStringConverter;
28	import org.eclipse.core.internal.databinding.conversion.IdentityConverter;	30	import org.eclipse.core.internal.databinding.conversion.IdentityConverter;
29	import org.eclipse.core.internal.databinding.conversion.IntegerToStringConverter;	31	import org.eclipse.core.internal.databinding.conversion.IntegerToStringConverter;
Lines 35-41 Link Here
35	import org.eclipse.core.internal.databinding.conversion.NumberToIntegerConverter;	37	import org.eclipse.core.internal.databinding.conversion.NumberToIntegerConverter;
36	import org.eclipse.core.internal.databinding.conversion.NumberToLongConverter;	38	import org.eclipse.core.internal.databinding.conversion.NumberToLongConverter;
37	import org.eclipse.core.internal.databinding.conversion.NumberToShortConverter;	39	import org.eclipse.core.internal.databinding.conversion.NumberToShortConverter;
38	import org.eclipse.core.internal.databinding.conversion.ObjectToStringConverter;
39	import org.eclipse.core.internal.databinding.conversion.StringToByteConverter;	40	import org.eclipse.core.internal.databinding.conversion.StringToByteConverter;
40	import org.eclipse.core.internal.databinding.conversion.StringToCharacterConverter;	41	import org.eclipse.core.internal.databinding.conversion.StringToCharacterConverter;
41	import org.eclipse.core.internal.databinding.conversion.StringToShortConverter;	42	import org.eclipse.core.internal.databinding.conversion.StringToShortConverter;
Lines 307-313 Link Here
307	new Pair(BOOLEAN_CLASS, "java.lang.Boolean"), new IdentityConverter(Boolean.class, Boolean.class)); //$NON-NLS-1$	308	new Pair(BOOLEAN_CLASS, "java.lang.Boolean"), new IdentityConverter(Boolean.class, Boolean.class)); //$NON-NLS-1$
308	converterMap	309	converterMap
309	.put(	310	.put(
310	new Pair(BOOLEAN_CLASS, "java.lang.String"), new ObjectToStringConverter(Boolean.class)); //$NON-NLS-1$	311	new Pair(BOOLEAN_CLASS, "java.lang.String"), new BooleanToStringConverter(Boolean.class)); //$NON-NLS-1$
311	converterMap	312	converterMap
312	.put(	313	.put(
313	new Pair(BOOLEAN_CLASS, "java.lang.Object"), new IdentityConverter(Boolean.class, Object.class)); //$NON-NLS-1$	314	new Pair(BOOLEAN_CLASS, "java.lang.Object"), new IdentityConverter(Boolean.class, Object.class)); //$NON-NLS-1$

Added Link Here

(-)src/org/eclipse/core/databinding/editing/StringEditing.java (+286 lines)
1	/*******************************************************************************
2	* Copyright (c) 2009 Ovidio Mallo 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	* Ovidio Mallo - initial API and implementation (bug 183055)
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.databinding.validation.constraint.Constraints;
18	import org.eclipse.core.databinding.validation.constraint.StringConstraints;
19	import org.eclipse.core.internal.databinding.conversion.StringStripConverter;
20	import org.eclipse.core.internal.databinding.conversion.StringTrimConverter;
21
22	/**
23	* @noextend This class is not intended to be subclassed by clients.
24	* @since 1.3
25	*/
26	public class StringEditing extends Editing {
27
28	/**
29	* Creates a new editing object for booleans.
30	*
31	* @param targetConverter
32	* The {@link #setTargetConverter(IConverter) target converter}
33	* to use for editing.
34	*
35	* @noreference This constructor is not intended to be referenced by
36	* clients.
37	*/
38	protected StringEditing(IConverter targetConverter) {
39	setTargetConverter(targetConverter);
40	}
41
42	/**
43	* Creates a new editing object for strings which performs no validation or
44	* conversion.
45	*
46	* @return The new editing object which performs no validation or
47	* conversion.
48	*/
49	public static StringEditing withDefaults() {
50	return new StringEditing(null);
51	}
52
53	/**
54	* Creates a new editing object which strips whitespace from both ends of
55	* the input string.
56	*
57	* @return The new editing object which strips whitespace from both ends of
58	* the input string.
59	*
60	* @see Character#isWhitespace(char)
61	*/
62	public static StringEditing stripped() {
63	return new StringEditing(new StringStripConverter(false));
64	}
65
66	/**
67	* Creates a new editing object which strips whitespace from both ends of
68	* the input string. In case stripping the input string results in an empty
69	* string, the input string will be converted to <code>null</code>.
70	*
71	* @return The new editing object which strips whitespace from both ends of
72	* the input string. Resulting empty strings are converted to
73	* <code>null</code>.
74	*
75	* @see Character#isWhitespace(char)
76	*/
77	public static StringEditing strippedToNull() {
78	return new StringEditing(new StringStripConverter(true));
79	}
80
81	/**
82	* Creates a new editing object which {@link String#trim()}s the input
83	* string.
84	*
85	* @return The new editing object which trims whitespace from both ends of
86	* the input string.
87	*
88	* @see String#trim()
89	*/
90	public static StringEditing trimmed() {
91	return new StringEditing(new StringTrimConverter(false));
92	}
93
94	/**
95	* Creates a new editing object which {@link String#trim()}s the input
96	* string. In case trimming the input string results in an empty string, the
97	* input string will be converted to <code>null</code>.
98	*
99	* @return The new editing object which trims whitespace from both ends of
100	* the input string. Resulting empty strings are converted to
101	* <code>null</code>.
102	*
103	* @see String#trim()
104	*/
105	public static StringEditing trimmedToNull() {
106	return new StringEditing(new StringTrimConverter(true));
107	}
108
109	/**
110	* Returns the target constraints to apply.
111	*
112	* <p>
113	* This method provides a typesafe access to the {@link StringConstraints
114	* string target constraints} of this editing object and is equivalent to
115	* {@code (StringConstraints) targetConstraints()}.
116	* </p>
117	*
118	* @return The target constraints to apply.
119	*
120	* @see #targetConstraints()
121	* @see StringConstraints
122	*/
123	public StringConstraints targetStringConstraints() {
124	return (StringConstraints) targetConstraints();
125	}
126
127	/**
128	* Returns the model constraints to apply.
129	*
130	* <p>
131	* This method provides a typesafe access to the {@link StringConstraints
132	* string model constraints} of this editing object and is equivalent to
133	* {@code (StringConstraints) modelConstraints()}.
134	* </p>
135	*
136	* @return The model constraints to apply.
137	*
138	* @see #modelConstraints()
139	* @see StringConstraints
140	*/
141	public StringConstraints modelStringConstraints() {
142	return (StringConstraints) modelConstraints();
143	}
144
145	/**
146	* Returns the before-set model constraints to apply.
147	*
148	* <p>
149	* This method provides a typesafe access to the {@link StringConstraints
150	* string before-set model constraints} of this editing object and is
151	* equivalent to {@code (StringConstraints) beforeSetModelConstraints()}.
152	* </p>
153	*
154	* @return The before-set model constraints to apply.
155	*
156	* @see #beforeSetModelConstraints()
157	* @see StringConstraints
158	*/
159	public StringConstraints beforeSetModelStringConstraints() {
160	return (StringConstraints) beforeSetModelConstraints();
161	}
162
163	protected Constraints createTargetConstraints() {
164	return new StringConstraints();
165	}
166
167	protected Constraints createModelConstraints() {
168	return new StringConstraints();
169	}
170
171	protected Constraints createBeforeSetModelConstraints() {
172	return new StringConstraints();
173	}
174
175	/**
176	* Convenience method which adds a {@link StringConstraints#required()
177	* required constraint} to the set of {@link #modelStringConstraints()}.
178	*
179	* @return This editing instance for method chaining.
180	*
181	* @see StringConstraints#required()
182	* @see #modelStringConstraints()
183	*/
184	public StringEditing required() {
185	modelStringConstraints().required();
186	return this;
187	}
188
189	/**
190	* Convenience method which adds a {@link StringConstraints#nonEmpty()
191	* non-empty constraint} to the set of {@link #modelStringConstraints()}.
192	*
193	* @return This editing instance for method chaining.
194	*
195	* @see StringConstraints#nonEmpty()
196	* @see #modelStringConstraints()
197	*/
198	public StringEditing nonEmpty() {
199	modelStringConstraints().nonEmpty();
200	return this;
201	}
202
203	/**
204	* Convenience method which adds a {@link StringConstraints#minLength(int)
205	* min-length constraint} to the set of {@link #modelStringConstraints()}.
206	*
207	* @param minLength
208	* The min length of the min-length constraint.
209	* @return This editing instance for method chaining.
210	*
211	* @see StringConstraints#minLength(int)
212	* @see #modelStringConstraints()
213	*/
214	public StringEditing minLength(int minLength) {
215	modelStringConstraints().minLength(minLength);
216	return this;
217	}
218
219	/**
220	* Convenience method which adds a {@link StringConstraints#maxLength(int)
221	* max-length constraint} to the set of {@link #modelStringConstraints()}.
222	*
223	* @param maxLength
224	* The max length of the max-length constraint.
225	* @return This editing instance for method chaining.
226	*
227	* @see StringConstraints#maxLength(int)
228	* @see #modelStringConstraints()
229	*/
230	public StringEditing maxLength(int maxLength) {
231	modelStringConstraints().maxLength(maxLength);
232	return this;
233	}
234
235	/**
236	* Convenience method which adds a
237	* {@link StringConstraints#lengthRange(int, int) length-range constraint}
238	* to the set of {@link #modelStringConstraints()}.
239	*
240	* @param minLength
241	* The min length of the length-range constraint.
242	* @param maxLength
243	* The max length of the length-range constraint.
244	* @return This editing instance for method chaining.
245	*
246	* @see StringConstraints#lengthRange(int, int)
247	* @see #modelStringConstraints()
248	*/
249	public StringEditing lengthRange(int minLength, int maxLength) {
250	modelStringConstraints().lengthRange(minLength, maxLength);
251	return this;
252	}
253
254	/**
255	* Convenience method which adds a {@link StringConstraints#matches(String)
256	* matches constraint} to the set of {@link #modelStringConstraints()}.
257	*
258	* @param regex
259	* The regular expression of the matches constraint.
260	* @return This editing instance for method chaining.
261	*
262	* @see StringConstraints#matches(String)
263	* @see #modelStringConstraints()
264	*/
265	public StringEditing matches(String regex) {
266	modelStringConstraints().matches(regex);
267	return this;
268	}
269
270	/**
271	* Convenience method which adds a
272	* {@link StringConstraints#matches(Pattern) matches constraint} to the set
273	* of {@link #modelStringConstraints()}.
274	*
275	* @param pattern
276	* The pattern of the matches constraint.
277	* @return This editing instance for method chaining.
278	*
279	* @see StringConstraints#matches(Pattern)
280	* @see #modelStringConstraints()
281	*/
282	public StringEditing matches(Pattern pattern) {
283	modelStringConstraints().matches(pattern);
284	return this;
285	}
286	}

Added Link Here

(-)src/org/eclipse/core/databinding/validation/constraint/CharacterConstraints.java (+199 lines)
1	/*******************************************************************************
2	* Copyright (c) 2009 Ovidio Mallo 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	* Ovidio Mallo - initial API and implementation (bug 183055)
10	******************************************************************************/
11
12	package org.eclipse.core.databinding.validation.constraint;
13
14	import org.eclipse.core.internal.databinding.validation.CharacterValidator;
15	import org.eclipse.core.internal.databinding.validation.NonNullValidator;
16
17	/**
18	* Provides a set of constraints to apply to <code>Character</code>s.
19	*
20	* <p>
21	* Instances of this class can be used to define a set of constraints to apply
22	* to characters. In addition, the validation messages to be issued for the
23	* individual constraints can be configured.
24	* </p>
25	*
26	* @noextend This class is not intended to be subclassed by clients.
27	* @since 1.3
28	*/
29	public class CharacterConstraints extends Constraints {
30
31	private String requiredMessage = null;
32
33	private String noWhitespaceMessage = null;
34
35	private String noSpaceMessage = null;
36
37	private String letterMessage = null;
38
39	private String digitMessage = null;
40
41	private String letterOrDigitMessage = null;
42
43	/**
44	* Adds a validator ensuring that the character is not <code>null</code> .
45	* Uses the current {@link #requiredMessage(String) validation message}.
46	*
47	* @return This constraints instance for method chaining.
48	*/
49	public CharacterConstraints required() {
50	addValidator(new NonNullValidator(requiredMessage));
51	return this;
52	}
53
54	/**
55	* Sets the validation message for the {@link #required()} constraint.
56	*
57	* @param message
58	* The validation message for the {@link #required()} constraint.
59	* @return This constraints instance for method chaining.
60	*
61	* @see #required()
62	*/
63	public CharacterConstraints requiredMessage(String message) {
64	this.requiredMessage = message;
65	return this;
66	}
67
68	/**
69	* Adds a validator ensuring that the character is no
70	* {@link Character#isWhitespace(char) whitespace}. Uses the current
71	* {@link #noWhitespaceMessage(String) validation message}.
72	*
73	* @return This constraints instance for method chaining.
74	*/
75	public CharacterConstraints noWhitespace() {
76	addValidator(CharacterValidator.noWhitespace(noWhitespaceMessage));
77	return this;
78	}
79
80	/**
81	* Sets the validation message for the {@link #noWhitespace()} constraint.
82	*
83	* @param message
84	* The validation message for the {@link #noWhitespace()}
85	* constraint.
86	* @return This constraints instance for method chaining.
87	*
88	* @see #noWhitespace()
89	*/
90	public CharacterConstraints noWhitespaceMessage(String message) {
91	this.noWhitespaceMessage = message;
92	return this;
93	}
94
95	/**
96	* Adds a validator ensuring that the character is no
97	* {@link Character#isSpaceChar(char) space}. Uses the current
98	* {@link #noSpaceMessage(String) validation message}.
99	*
100	* @return This constraints instance for method chaining.
101	*/
102	public CharacterConstraints noSpace() {
103	addValidator(CharacterValidator.noSpace(noSpaceMessage));
104	return this;
105	}
106
107	/**
108	* Sets the validation message for the {@link #noSpace()} constraint.
109	*
110	* @param message
111	* The validation message for the {@link #noSpace()} constraint.
112	* @return This constraints instance for method chaining.
113	*
114	* @see #noSpace()
115	*/
116	public CharacterConstraints noSpaceMessage(String message) {
117	this.noSpaceMessage = message;
118	return this;
119	}
120
121	/**
122	* Adds a validator ensuring that the character is a
123	* {@link Character#isLetter(char) letter}. Uses the current
124	* {@link #letterMessage(String) validation message}.
125	*
126	* @return This constraints instance for method chaining.
127	*/
128	public CharacterConstraints letter() {
129	addValidator(CharacterValidator.letter(letterMessage));
130	return this;
131	}
132
133	/**
134	* Sets the validation message for the {@link #letter()} constraint.
135	*
136	* @param message
137	* The validation message for the {@link #letter()} constraint.
138	* @return This constraints instance for method chaining.
139	*
140	* @see #letter()
141	*/
142	public CharacterConstraints letterMessage(String message) {
143	this.letterMessage = message;
144	return this;
145	}
146
147	/**
148	* Adds a validator ensuring that the character is a
149	* {@link Character#isDigit(char) digit}. Uses the current
150	* {@link #digitMessage(String) validation message}.
151	*
152	* @return This constraints instance for method chaining.
153	*/
154	public CharacterConstraints digit() {
155	addValidator(CharacterValidator.digit(digitMessage));
156	return this;
157	}
158
159	/**
160	* Sets the validation message for the {@link #digit()} constraint.
161	*
162	* @param message
163	* The validation message for the {@link #digit()} constraint.
164	* @return This constraints instance for method chaining.
165	*
166	* @see #digit()
167	*/
168	public CharacterConstraints digitMessage(String message) {
169	this.digitMessage = message;
170	return this;
171	}
172
173	/**
174	* Adds a validator ensuring that the character is a
175	* {@link Character#isLetterOrDigit(char) letter or digit}. Uses the current
176	* {@link #letterOrDigitMessage(String) validation message}.
177	*
178	* @return This constraints instance for method chaining.
179	*/
180	public CharacterConstraints letterOrDigit() {
181	addValidator(CharacterValidator.letterOrDigit(letterOrDigitMessage));
182	return this;
183	}
184
185	/**
186	* Sets the validation message for the {@link #letterOrDigit()} constraint.
187	*
188	* @param message
189	* The validation message for the {@link #letterOrDigit()}
190	* constraint.
191	* @return This constraints instance for method chaining.
192	*
193	* @see #letterOrDigit()
194	*/
195	public CharacterConstraints letterOrDigitMessage(String message) {
196	this.letterOrDigitMessage = message;
197	return this;
198	}
199	}

Added Link Here

(-)src/org/eclipse/core/internal/databinding/validation/StringToBigDecimalValidator.java (+32 lines)
1	/*******************************************************************************
2	* Copyright (c) 2007 Ovidio Mallo 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	* Ovidio Mallo - initial API and implementation (bug 183055)
10	******************************************************************************/
11
12	package org.eclipse.core.internal.databinding.validation;
13
14	/**
15	* Validates that a string is of the appropriate format for a BigDecimal.
16	*
17	* @since 1.3
18	*/
19	public class StringToBigDecimalValidator extends
20	AbstractStringToNumberValidator {
21
22	/**
23	* @param converter
24	*/
25	public StringToBigDecimalValidator(NumberFormatConverter converter) {
26	super(converter, null, null);
27	}
28
29	protected boolean isInRange(Number number) {
30	return true;
31	}
32	}