Attachment #124747 for bug #262407

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

View | Details | Raw Unified | Return to bug 262407
Collapse All | Expand All




 *
 * Contributors:
 *     Matthew Hall - initial API and implementation (bug 173735)
 *     Matthew Hall - bug 262407
 *******************************************************************************/

package org.eclipse.core.tests.databinding.observable.value;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

import org.eclipse.core.databinding.observable.list.IObservableList;
import org.eclipse.core.databinding.observable.list.WritableList;
import org.eclipse.core.databinding.observable.value.DuplexingObservableValue;
import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;
import org.eclipse.jface.util.Util;

/**
 * @since 1.0

	}

	public void test_getValue() throws Exception {
		observable = DuplexingObservableValue.withDefaults(list, null,
				"<Multiple Values>");
				Iterator it = elements.iterator();
				if (!it.hasNext())
					return null;
				Object first = it.next();
				while (it.hasNext()) {
					Object next = it.next();
					if (!Util.equals(first, next))
						return "<Multiple Values>";
				}
				return first;
			}
		};
		assertNull(observable.getValue());
		list.add("42");
		assertEquals("Value should be \"42\"", "42", observable.getValue());




 *
 * Contributors:
 *     Matthew Hall - initial API and implementation (bug 175735)
 *     Matthew Hall - bug 262407
 ******************************************************************************/

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

import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
import java.util.Collection;
import java.util.Iterator;

import org.eclipse.core.databinding.DataBindingContext;
import org.eclipse.core.databinding.beans.BeanProperties;

import org.eclipse.jface.databinding.viewers.ObservableListContentProvider;
import org.eclipse.jface.databinding.viewers.ObservableMapLabelProvider;
import org.eclipse.jface.databinding.viewers.ViewerProperties;
import org.eclipse.jface.util.Util;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.swt.SWT;

		IObservableList selections = ViewerProperties.multipleSelection()
				.observe(viewer);
		dbc.bindValue(WidgetProperties.text(SWT.Modify).observe(title),
				DuplexingObservableValue.withDefaults(BeanProperties.value(
						"title").observeDetail(selections), "",
						"<Multiple titles>"));
		dbc.bindValue(WidgetProperties.text(SWT.Modify).observe(releaseDate),
				DuplexingObservableValue.withDefaults(BeanProperties.value(
						"releaseDate").observeDetail(selections), "",
						"<Multiple dates>"));
		dbc.bindValue(WidgetProperties.text(SWT.Modify).observe(director),
				DuplexingObservableValue.withDefaults(BeanProperties.value(
						"director").observeDetail(selections), "",
						"<Multiple directors>"));
		dbc.bindValue(WidgetProperties.text(SWT.Modify).observe(writer),
				DuplexingObservableValue.withDefaults(BeanProperties.value(
						"writer").observeDetail(selections), "",
						"<Multiple writers>"));

	private static class StringDuplexingObservableValue extends
			DuplexingObservableValue {

		public StringDuplexingObservableValue(IObservableList target) {
			super(target);
		}

		protected Object coalesceElements(Collection elements) {
			Iterator it = elements.iterator();
			if (!it.hasNext())
				return "";
			Object first = it.next();
			while (it.hasNext()) {
				if (!Util.equals(first, it.next()))
					return "<Multiple values>";
			}
			return first;
		}
	}
}




 *
 * Contributors:
 *     Matthew Hall - initial API and implementation (bug 175735)
 *     Matthew Hall - bug 262407
 ******************************************************************************/

package org.eclipse.core.databinding.observable.value;

import java.util.Collection;
import java.util.Iterator;

import org.eclipse.core.databinding.observable.ChangeEvent;
import org.eclipse.core.databinding.observable.IChangeListener;
import org.eclipse.core.databinding.observable.IStaleListener;
import org.eclipse.core.databinding.observable.StaleEvent;
import org.eclipse.core.databinding.observable.list.IObservableList;
import org.eclipse.core.internal.databinding.Util;

/**
 * @since 1.2
 */
public abstract class DuplexingObservableValue extends AbstractObservableValue {
	/**
	 * Returns a DuplexingObservableValue implementation with predefined values
	 * to use if the list is empty or contains multiple different values.
	 * 
	 * @param target
	 *            the observable list
	 * @param emptyValue
	 *            the value to use when the target list is empty
	 * @param multiValue
	 *            the value to use when the target list contains multiple values
	 *            that are not equivalent to eachother.
	 * @return a DuplexingObservableValue implementation with predefined values
	 *         to use if the list is empty or contains multiple different
	 *         values.
	 */
	public static DuplexingObservableValue withDefaults(IObservableList target,
			final Object emptyValue, final Object multiValue) {
		return new DuplexingObservableValue(target) {
			protected Object coalesceElements(Collection elements) {
				if (elements.isEmpty())
					return emptyValue;
				Iterator it = elements.iterator();
				Object first = it.next();
				while (it.hasNext())
					if (!Util.equals(first, it.next()))
						return multiValue;
				return first;
			}
		};
	}

	private IObservableList target;
	private final Object valueType;


Return to bug 262407

Lines 7-20 Link Here

(-)src/org/eclipse/jface/examples/databinding/snippets/Snippet028DuplexingObservableValue.java (-31 / +13 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* Matthew Hall - initial API and implementation (bug 175735)	9	* Matthew Hall - initial API and implementation (bug 175735)
		10	* Matthew Hall - bug 262407
10	******************************************************************************/	11	******************************************************************************/
11		12
12	package org.eclipse.jface.examples.databinding.snippets;	13	package org.eclipse.jface.examples.databinding.snippets;
13		14
14	import java.beans.PropertyChangeListener;	15	import java.beans.PropertyChangeListener;
15	import java.beans.PropertyChangeSupport;	16	import java.beans.PropertyChangeSupport;
16	import java.util.Collection;
17	import java.util.Iterator;
18		17
19	import org.eclipse.core.databinding.DataBindingContext;	18	import org.eclipse.core.databinding.DataBindingContext;
20	import org.eclipse.core.databinding.beans.BeanProperties;	19	import org.eclipse.core.databinding.beans.BeanProperties;
Lines 28-34 Link Here
28	import org.eclipse.jface.databinding.viewers.ObservableListContentProvider;	27	import org.eclipse.jface.databinding.viewers.ObservableListContentProvider;
29	import org.eclipse.jface.databinding.viewers.ObservableMapLabelProvider;	28	import org.eclipse.jface.databinding.viewers.ObservableMapLabelProvider;
30	import org.eclipse.jface.databinding.viewers.ViewerProperties;	29	import org.eclipse.jface.databinding.viewers.ViewerProperties;
31	import org.eclipse.jface.util.Util;
32	import org.eclipse.jface.viewers.StructuredSelection;	30	import org.eclipse.jface.viewers.StructuredSelection;
33	import org.eclipse.jface.viewers.TableViewer;	31	import org.eclipse.jface.viewers.TableViewer;
34	import org.eclipse.swt.SWT;	32	import org.eclipse.swt.SWT;
Lines 286-321 Link Here
286	IObservableList selections = ViewerProperties.multipleSelection()	284	IObservableList selections = ViewerProperties.multipleSelection()
287	.observe(viewer);	285	.observe(viewer);
288	dbc.bindValue(WidgetProperties.text(SWT.Modify).observe(title),	286	dbc.bindValue(WidgetProperties.text(SWT.Modify).observe(title),
289	new StringDuplexingObservableValue(BeanProperties	287	DuplexingObservableValue.withDefaults(BeanProperties.value(
290	.value("title").observeDetail(selections)));	288	"title").observeDetail(selections), "",
		289	"<Multiple titles>"));
291	dbc.bindValue(WidgetProperties.text(SWT.Modify).observe(releaseDate),	290	dbc.bindValue(WidgetProperties.text(SWT.Modify).observe(releaseDate),
292	new StringDuplexingObservableValue(BeanProperties.value(	291	DuplexingObservableValue.withDefaults(BeanProperties.value(
293	"releaseDate").observeDetail(selections)));	292	"releaseDate").observeDetail(selections), "",
		293	"<Multiple dates>"));
294	dbc.bindValue(WidgetProperties.text(SWT.Modify).observe(director),	294	dbc.bindValue(WidgetProperties.text(SWT.Modify).observe(director),
295	new StringDuplexingObservableValue(BeanProperties.value(	295	DuplexingObservableValue.withDefaults(BeanProperties.value(
296	"director").observeDetail(selections)));	296	"director").observeDetail(selections), "",
		297	"<Multiple directors>"));
297	dbc.bindValue(WidgetProperties.text(SWT.Modify).observe(writer),	298	dbc.bindValue(WidgetProperties.text(SWT.Modify).observe(writer),
298	new StringDuplexingObservableValue(BeanProperties.value(	299	DuplexingObservableValue.withDefaults(BeanProperties.value(
299	"writer").observeDetail(selections)));	300	"writer").observeDetail(selections), "",
300	}	301	"<Multiple writers>"));
301
302	private static class StringDuplexingObservableValue extends
303	DuplexingObservableValue {
304
305	public StringDuplexingObservableValue(IObservableList target) {
306	super(target);
307	}
308
309	protected Object coalesceElements(Collection elements) {
310	Iterator it = elements.iterator();
311	if (!it.hasNext())
312	return "";
313	Object first = it.next();
314	while (it.hasNext()) {
315	if (!Util.equals(first, it.next()))
316	return "<Multiple values>";
317	}
318	return first;
319	}
320	}	302	}
321	}	303	}

Lines 7-25 Link Here

(-)src/org/eclipse/core/tests/databinding/observable/value/DuplexingObservableValueTest.java (-16 / +3 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* Matthew Hall - initial API and implementation (bug 173735)	9	* Matthew Hall - initial API and implementation (bug 173735)
		10	* Matthew Hall - bug 262407
10	*******************************************************************************/	11	*******************************************************************************/
11		12
12	package org.eclipse.core.tests.databinding.observable.value;	13	package org.eclipse.core.tests.databinding.observable.value;
13		14
14	import java.util.ArrayList;	15	import java.util.ArrayList;
15	import java.util.Collection;	16	import java.util.Collection;
16	import java.util.Iterator;
17		17
18	import org.eclipse.core.databinding.observable.list.IObservableList;	18	import org.eclipse.core.databinding.observable.list.IObservableList;
19	import org.eclipse.core.databinding.observable.list.WritableList;	19	import org.eclipse.core.databinding.observable.list.WritableList;
20	import org.eclipse.core.databinding.observable.value.DuplexingObservableValue;	20	import org.eclipse.core.databinding.observable.value.DuplexingObservableValue;
21	import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;	21	import org.eclipse.jface.tests.databinding.AbstractDefaultRealmTestCase;
22	import org.eclipse.jface.util.Util;
23		22
24	/**	23	/**
25	* @since 1.0	24	* @since 1.0
Lines 56-75 Link Here
56	}	55	}
57		56
58	public void test_getValue() throws Exception {	57	public void test_getValue() throws Exception {
59	observable = new DuplexingObservableValue(list) {	58	observable = DuplexingObservableValue.withDefaults(list, null,
60	protected Object coalesceElements(Collection elements) {	59	"<Multiple Values>");
61	Iterator it = elements.iterator();
62	if (!it.hasNext())
63	return null;
64	Object first = it.next();
65	while (it.hasNext()) {
66	Object next = it.next();
67	if (!Util.equals(first, next))
68	return "<Multiple Values>";
69	}
70	return first;
71	}
72	};
73	assertNull(observable.getValue());	60	assertNull(observable.getValue());
74	list.add("42");	61	list.add("42");
75	assertEquals("Value should be \"42\"", "42", observable.getValue());	62	assertEquals("Value should be \"42\"", "42", observable.getValue());

Lines 7-28 Link Here

(-)src/org/eclipse/core/databinding/observable/value/DuplexingObservableValue.java (+34 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* Matthew Hall - initial API and implementation (bug 175735)	9	* Matthew Hall - initial API and implementation (bug 175735)
		10	* Matthew Hall - bug 262407
10	******************************************************************************/	11	******************************************************************************/
11		12
12	package org.eclipse.core.databinding.observable.value;	13	package org.eclipse.core.databinding.observable.value;
13		14
14	import java.util.Collection;	15	import java.util.Collection;
		16	import java.util.Iterator;
15		17
16	import org.eclipse.core.databinding.observable.ChangeEvent;	18	import org.eclipse.core.databinding.observable.ChangeEvent;
17	import org.eclipse.core.databinding.observable.IChangeListener;	19	import org.eclipse.core.databinding.observable.IChangeListener;
18	import org.eclipse.core.databinding.observable.IStaleListener;	20	import org.eclipse.core.databinding.observable.IStaleListener;
19	import org.eclipse.core.databinding.observable.StaleEvent;	21	import org.eclipse.core.databinding.observable.StaleEvent;
20	import org.eclipse.core.databinding.observable.list.IObservableList;	22	import org.eclipse.core.databinding.observable.list.IObservableList;
		23	import org.eclipse.core.internal.databinding.Util;
21		24
22	/**	25	/**
23	* @since 1.2	26	* @since 1.2
24	*/	27	*/
25	public abstract class DuplexingObservableValue extends AbstractObservableValue {	28	public abstract class DuplexingObservableValue extends AbstractObservableValue {
		29	/**
		30	* Returns a DuplexingObservableValue implementation with predefined values
		31	* to use if the list is empty or contains multiple different values.
		32	*
		33	* @param target
		34	* the observable list
		35	* @param emptyValue
		36	* the value to use when the target list is empty
		37	* @param multiValue
		38	* the value to use when the target list contains multiple values
		39	* that are not equivalent to eachother.
		40	* @return a DuplexingObservableValue implementation with predefined values
		41	* to use if the list is empty or contains multiple different
		42	* values.
		43	*/
		44	public static DuplexingObservableValue withDefaults(IObservableList target,
		45	final Object emptyValue, final Object multiValue) {
		46	return new DuplexingObservableValue(target) {
		47	protected Object coalesceElements(Collection elements) {
		48	if (elements.isEmpty())
		49	return emptyValue;
		50	Iterator it = elements.iterator();
		51	Object first = it.next();
		52	while (it.hasNext())
		53	if (!Util.equals(first, it.next()))
		54	return multiValue;
		55	return first;
		56	}
		57	};
		58	}
		59
26	private IObservableList target;	60	private IObservableList target;
27	private final Object valueType;	61	private final Object valueType;
28		62