Attachment #120914 for bug #194734

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 194734 | Differences between

and this patch

Collapse All | Expand All





	protected void firstListenerAdded() {
		if (!isDisposed()) {
			cachedSet = getSet();

			if (listener == null) {
				listener = property

	}

	protected Set getWrappedSet() {
		return getSet();
	}

	public Object getElementType() {


	// Queries

	private Set getSet() {
		return property.getSet(source);
	}

	public boolean contains(Object o) {
		getterCalled();
		return getSet().contains(o);
	}

	public boolean containsAll(Collection c) {
		getterCalled();
		return getSet().containsAll(c);
	}

	protected int doGetSize() {
		return getSet().size();
	}

	public boolean isEmpty() {
		getterCalled();
		return getSet().isEmpty();
	}

	public Object[] toArray() {
		getterCalled();
		return getSet().toArray();
	}

	public Object[] toArray(Object[] a) {
		getterCalled();
		return getSet().toArray(a);
	}

	// Single change operations

	public boolean add(Object o) {
		checkRealm();

		Set set = new HashSet(getSet());
		if (!set.add(o))
			return false;

		SetDiff diff = Diffs.createSetDiff(Collections.singleton(o),
				Collections.EMPTY_SET);

		boolean wasUpdating = updating;
		boolean changed;
		updating = true;
		try {
			changed = property.setSet(source, set, diff);
			modCount++;
		} finally {
			updating = wasUpdating;
		}

		if (changed) {
			cachedSet = getSet();
			fireSetChange(diff);
		}
					Collections.EMPTY_SET));

		return changed;
	}

		getterCalled();
		return new Iterator() {
			int expectedModCount = modCount;
			Set set = new HashSet(getSet());
			Iterator iterator = set.iterator();
			Object last = null;

			public boolean hasNext() {
				getterCalled();
				checkForComodification();
				return iterator.hasNext();
			}

			public Object next() {
				getterCalled();
				checkForComodification();
				last = iterator.next();
				return last;
			}


				checkRealm();
				checkForComodification();

				iterator.remove(); // stay in sync
				SetDiff diff = Diffs.createSetDiff(Collections.EMPTY_SET,
						Collections.singleton(last));

				boolean wasUpdating = updating;
				boolean changed;
				updating = true;
				try {
					changed = property.setSet(source, set, diff);
					modCount++;
				} finally {
					updating = wasUpdating;
				}

				if (changed) {
					cachedSet = getSet();
					fireSetChange(diff);

					last = null;
					expectedModCount = modCount;
				}
				last = null;
				expectedModCount = modCount;
			}

			private void checkForComodification() {

	public boolean remove(Object o) {
		getterCalled();

		Set set = new HashSet(getSet());
		if (!set.remove(o))
			return false;

		SetDiff diff = Diffs.createSetDiff(Collections.EMPTY_SET, Collections
				.singleton(o));

		boolean wasUpdating = updating;
		boolean changed;
		updating = true;
		try {
			changed = property.setSet(source, set, diff);
			modCount++;
		} finally {
			updating = wasUpdating;
		}

		if (changed) {
			cachedSet = property.getSet(source);
			fireSetChange(diff);
		}

		return changed;
	}

		if (c.isEmpty())
			return false;

		Set set = new HashSet(getSet());

		Set additions = new HashSet(c);
		for (Iterator it = c.iterator(); it.hasNext();) {
			Object element = it.next();
			if (set.add(element))
				additions.add(element);
		}

		if (additions.isEmpty())
			return false;

		SetDiff diff = Diffs.createSetDiff(additions, Collections.EMPTY_SET);

		boolean wasUpdating = updating;
		boolean changed;
		updating = true;
		try {
			changed = property.setSet(source, set, diff);
			modCount++;
		} finally {
			updating = wasUpdating;
		}

		if (changed) {
			cachedSet = property.getSet(source);
			fireSetChange(diff);
		}

		return changed;
	}

	public boolean removeAll(Collection c) {
		getterCalled();

		Set set = getSet();
		if (set.isEmpty())
			return false;
		if (c.isEmpty())
			return false;

		set = new HashSet(set);

		Set removals = new HashSet(c);
		for (Iterator it = c.iterator(); it.hasNext();) {
			Object element = it.next();
			if (set.remove(element))
				removals.add(element);
		}

		if (removals.isEmpty())
			return false;

		SetDiff diff = Diffs.createSetDiff(Collections.EMPTY_SET, removals);

		boolean wasUpdating = updating;
		boolean changed;
		updating = true;
		try {
			changed = property.setSet(source, set, diff);
			modCount++;
		} finally {
			updating = wasUpdating;
		}

		if (changed) {
			cachedSet = property.getSet(source);
			fireSetChange(diff);
		}

		return changed;
	}

	public boolean retainAll(Collection c) {
		getterCalled();

		Set set = getSet();
		if (set.isEmpty())
			return false;

		if (c.isEmpty()) {

			return true;
		}

		set = new HashSet(set);

		Set removals = new HashSet();
		for (Iterator it = set.iterator(); it.hasNext();) {
			Object element = it.next();
			if (!c.contains(element)) {
				it.remove();
				removals.add(element);
			}
		}

		if (removals.isEmpty())
			return false;

		SetDiff diff = Diffs.createSetDiff(Collections.EMPTY_SET, removals);

		boolean wasUpdating = updating;
		boolean changed;
		updating = true;
		try {
			changed = property.setSet(source, set, diff);
			modCount++;
		} finally {
			updating = wasUpdating;
		}

		if (changed) {
			cachedSet = property.getSet(source);
			fireSetChange(diff);
		}

		return changed;
	}

	public void clear() {
		getterCalled();

		Set set = getSet();
		if (set.isEmpty())
			return;

		SetDiff diff = Diffs.createSetDiff(Collections.EMPTY_SET, set);

		boolean wasUpdating = updating;
		boolean changed;
		updating = true;
		try {
			changed = property.setSet(source, Collections.EMPTY_SET, diff);
			modCount++;
		} finally {
			updating = wasUpdating;
		}

		if (changed) {
			cachedSet = property.getSet(source);
			fireSetChange(diff);
		}
	}

	public boolean equals(Object o) {
		getterCalled();
		return getSet().equals(o);
	}

	public int hashCode() {
		getterCalled();
		return getSet().hashCode();
	}

	public Object getObserved() {





package org.eclipse.core.databinding.property.set;

import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.observable.IObservable;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.masterdetail.IObservableFactory;

		this.elementType = elementType;
	}

	public IObservableSet observeSet(Realm realm, Object source) {
		return new SimpleSetPropertyObservableSet(realm, source, this);
	}

	public IObservableSet observeDetailSet(IObservableValue master) {
		final Realm realm = master.getRealm();
		IObservableFactory factory = new IObservableFactory() {
			public IObservable createObservable(Object target) {
				return SimpleSetProperty.this.observeSet(realm, target);
			}
		};
		return MasterDetailObservables.detailSet(master, factory,
				getElementType());
	}

	/**
	 * Returns the type of the elements in the collection or <code>null</code>
	 * if untyped

		return elementType;
	}

	// Accessors
	 * Returns whether the source's collection property contains the given
	 * element.
	 * 
	 * @param source
	 *            the property source
	 * @param o
	 *            the element
	 * @return whether the source's collection property contains the given
	 *         element.
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected boolean contains(Object source, Object o) {
		return getSet(source).contains(o);
	}

	/**
	 * Returns whether the source's collection property contains all elements in
	 * the given collection
	 * 
	 * @param source
	 *            the property source
	 * @param c
	 *            the collection of elements to test for
	 * @return whether the source's collection property contains all elements in
	 *         the given collection
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected boolean containsAll(Object source, Collection c) {
		return getSet(source).containsAll(c);
	}

	/**
	 * Returns a Set with the current contents of the source's set property

	 */
	protected abstract Set doGetSet(Object source);

	// Mutators
	 * Returns whether the source's collection property is equal to the
	 * argument.
	 * 
	 * @param source
	 *            the property source
	 * @param o
	 *            the object to test for equality to the source's collection
	 *            property
	 * @return whether the source's collection property is equal to the argument
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected boolean equals(Object source, Object o) {
		return getSet(source).equals(o);
	}

	/**
	 * Returns the hash code of the source's collection property.
	 * 
	 * @param source
	 *            the property source
	 * @return the hash code of the source's collection property
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected int hashCode(Object source) {
		return getSet(source).hashCode();
	}

	/**
	 * Returns whether the source's collection property is empty
	 * 
	 * @param source
	 *            the property source
	 * @return whether the source's collection property is empty
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected boolean isEmpty(Object source) {
		return getSet(source).isEmpty();
	}

	/**
	 * Returns the size of the source's collection property
	 * 
	 * @param source
	 *            the property source
	 * @return the size of the source's collection property
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected int size(Object source) {
		return getSet(source).size();
	}

	/**
	 * Returns an array of all elements in the source's collection property
	 * 
	 * @param source
	 *            the property source
	 * @param array
	 *            the array into which the elements will be copied. If the array
	 *            is not large enough to hold all elements, the elements will be
	 *            returned in a new array of the same runtime type.
	 * @return an array of all elements in the source's collection property
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected Object[] toArray(Object source, Object[] array) {
		return getSet(source).toArray(array);
	}

	/**
	 * Returns an array of all elements in the source's collection property
	 * 
	 * @param source
	 *            the property source
	 * @return an array of all elements in the source's collection property
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected Object[] toArray(Object source) {
		return getSet(source).toArray();
	}

	/**
	 * Updates the property on the source with the specified change.

	 *            the new set
	 * @param diff
	 *            a diff describing the change
	 * @return true if the property was modified on the source object, false
	 *         otherwise
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected abstract boolean setSet(Object source, Set set, SetDiff diff);

	/**
	 * Adds the element to the source's collection property
	 * 
	 * @param source
	 *            the property source
	 * @param o
	 *            the element to add
	 * @return whether the element was added to the source's collection property
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected boolean add(Object source, Object o) {
		Set set = getSet(source);
		if (!set.contains(o)) {
			set = new HashSet(set);
			boolean added = set.add(o);
			if (added) {
				setSet(source, set, Diffs.createSetDiff(Collections
						.singleton(o), Collections.EMPTY_SET));
			}
			return added;
		}
		return false;
	}

	/**
	 * Adds all elements in the specified collection to the source's collection
	 * property.
	 * 
	 * @param source
	 *            the property source
	 * @param c
	 *            the collection of elements to add.
	 * @return whether the source's collection property was changed
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected boolean addAll(Object source, Collection c) {
		if (c.isEmpty())
			return false;

		Set set = getSet(source);
		Set additions = new HashSet();
		for (Iterator it = c.iterator(); it.hasNext();) {
			Object o = it.next();
			if (!set.contains(o)) {
				additions.add(o);
			}
		}
		boolean changed = !additions.isEmpty();
		if (changed) {
			set = new HashSet(set);
			set.addAll(additions);

			setSet(source, set, Diffs.createSetDiff(additions,
					Collections.EMPTY_SET));
		}
		return changed;
	}

	/**
	 * Removes all elements from the source's collection property.
	 * 
	 * @param source
	 *            the property source
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected void clear(Object source) {
		if (!isEmpty(source)) {
			setSet(source, new HashSet(), Diffs.createSetDiff(
					Collections.EMPTY_SET, getSet(source)));
		}
	}

	/**
	 * Removes the element from the source's collection property
	 * 
	 * @param source
	 *            the property source
	 * @param o
	 *            the element to remove
	 * @return whether the element was removed from the source's collection
	 *         property
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected boolean remove(Object source, Object o) {
		Set set = getSet(source);
		if (set.contains(o)) {
			set = new HashSet(set);
			boolean removed = set.remove(o);
			if (removed) {
				setSet(source, set, Diffs.createSetDiff(Collections.EMPTY_SET,
						Collections.singleton(o)));
			}
			return removed;
		}
		return false;
	}

	/**
	 * Removes all elements from the source's collection property which are
	 * contained in the specified collection.
	 * 
	 * @param source
	 *            the property source
	 * @param c
	 *            the collection of elements to be removed
	 * @return whether the source's collection property was changed
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected boolean removeAll(Object source, Collection c) {
		if (c.isEmpty())
			return false;

		Set set = new HashSet(getSet(source));
		Set removals = new HashSet();
		for (Iterator it = set.iterator(); it.hasNext();) {
			Object o = it.next();
			if (c.contains(o)) {
				removals.add(o);
				it.remove();
			}
		}
		boolean changed = !removals.isEmpty();
		if (changed) {
			setSet(source, set, Diffs.createSetDiff(Collections.EMPTY_SET,
					removals));
		}
		return changed;
	}

	// Listeners
	 * Removes all elements from the source's collection property which are not
	 * contained in the specified collection.
	 * 
	 * @param source
	 *            the property source
	 * @param c
	 *            the collection of elements to retain
	 * @return whether the source's collection property was changed
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected boolean retainAll(Object source, Collection c) {
		if (isEmpty(source))
			return false;
		if (c.isEmpty()) {
			clear(source);
			return true;
		}

		Set set = new HashSet(getSet(source));
		Set removals = new HashSet();
		for (Iterator it = set.iterator(); it.hasNext();) {
			Object o = it.next();
			if (!c.contains(o)) {
				removals.add(o);
				it.remove();
			}
		}
		boolean changed = !removals.isEmpty();
		if (changed) {
			setSet(source, set, Diffs.createSetDiff(Collections.EMPTY_SET,
					removals));
		}
		return changed;
	}

	/**
	 * Returns a listener which implements the correct listener interface for

	 */
	protected abstract void removeListener(Object source,
			INativePropertyListener listener);

	public IObservableSet observeSet(Realm realm, Object source) {
		return new SimpleSetPropertyObservableSet(realm, source, this);
	}

	public IObservableSet observeDetailSet(IObservableValue master) {
		final Realm realm = master.getRealm();
		IObservableFactory factory = new IObservableFactory() {
			public IObservable createObservable(Object target) {
				return SimpleSetProperty.this.observeSet(realm, target);
			}
		};
		return MasterDetailObservables.detailSet(master, factory,
				getElementType());
	}
}




package org.eclipse.core.databinding.property.map;

import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.observable.IObservable;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.map.IObservableMap;

import org.eclipse.core.databinding.observable.masterdetail.MasterDetailObservables;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.core.databinding.property.INativePropertyListener;
import org.eclipse.core.internal.databinding.Util;

/**
 * Simplified abstract implementation of IMapProperty. This class takes care of

		this.valueType = valueType;
	}

	public IObservableMap observeMap(Realm realm, Object source) {
		return new SimpleMapPropertyObservableMap(realm, source, this);
	}

	public IObservableMap observeDetailMap(IObservableValue master) {
		final Realm realm = master.getRealm();
		IObservableFactory factory = new IObservableFactory() {
			public IObservable createObservable(Object target) {
				return SimpleMapProperty.this.observeMap(realm, target);
			}
		};
		return MasterDetailObservables.detailMap(master, factory);
	}

	/**
	 * Returns the element type of the map's key set or <code>null</code> if the
	 * key set is untyped.

		return valueType;
	}

	// Accessors

	/**
	 * Returns an unmodifiable Map with the current contents of the source's map
	 * property.

	 */
	protected abstract Map doGetMap(Object source);

	// Mutators

	/**
	 * Updates the property on the source with the specified change.
	 * 
	 * @param source
	 *            the property source
	 * @param map
	 *            the new map
	 * @param diff
	 *            a diff describing the change
	 * @return true if the property was modified on the source object, false
	 *         otherwise
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected abstract boolean setMap(Object source, Map map, MapDiff diff);

	// Listeners

	/**
	 * Returns a listener which implements the correct listener interface for
	 * the expected source object, and which parlays property change events from

	 */
	protected abstract void removeListener(Object source,
			INativePropertyListener listener);

	/**
	 * Returns whether the specified key is contained in the key set of the
	 * source's map property
	 * 
	 * @param source
	 *            the property source
	 * @param key
	 *            the key
	 * @return whether the specified key is contained in the key set of the
	 *         source's map property
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected boolean containsKey(Object source, Object key) {
		return getMap(source).containsKey(key);
	}

	/**
	 * Returns whether the specified value is contains in the values collection
	 * of the source's map property
	 * 
	 * @param source
	 *            the property source
	 * @param value
	 *            the value
	 * @return whether the specified value is contains in the values collection
	 *         of the source's map property
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected boolean containsValue(Object source, Object value) {
		return getMap(source).containsValue(value);
	}

	/**
	 * Returns whether the source's map property is equal to the argument
	 * 
	 * @param source
	 *            the property source
	 * @param o
	 *            the object to test for equality
	 * @return whether the source's map property is equal to the argument
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected boolean equals(Object source, Object o) {
		return getMap(source).equals(o);
	}

	/**
	 * Returns the value associated with the specified key in the source's map
	 * property
	 * 
	 * @param source
	 *            the property source
	 * @param key
	 *            the key
	 * @return the value associated with the specified key in the source's map
	 *         property
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected Object get(Object source, Object key) {
		return getMap(source).get(key);
	}

	/**
	 * Returns the hash code of the source's map property
	 * 
	 * @param source
	 *            the property source
	 * @return the hash code of the source's map property
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected int hashCode(Object source) {
		return getMap(source).hashCode();
	}

	/**
	 * Returns whether the source's map property is empty
	 * 
	 * @param source
	 *            the property source
	 * @return whether the source's map property is empty
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected boolean isEmpty(Object source) {
		return getMap(source).isEmpty();
	}

	/**
	 * Returns the size of the source's map property
	 * 
	 * @param source
	 *            the property source
	 * @return the size of the source's map property
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected int size(Object source) {
		return getMap(source).size();
	}

	/**
	 * Updates the property on the source with the specified change.
	 * 
	 * @param source
	 *            the property source
	 * @param map
	 *            the new map
	 * @param diff
	 *            a diff describing the change
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected abstract void setMap(Object source, Map map, MapDiff diff);

	/**
	 * Removes all mapping from the source's map property
	 * 
	 * @param source
	 *            the property source
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected void clear(Object source) {
		if (!isEmpty(source)) {
			setMap(source, new HashMap(), Diffs
					.createMapDiffRemoveAll(new HashMap(getMap(source))));
		}
	}

	/**
	 * Associates the specified value with the specified key in the source's map
	 * property
	 * 
	 * @param source
	 *            the property source
	 * @param key
	 *            the key
	 * @param value
	 *            the value
	 * @return the value that was previously associated with the given key in
	 *         the source's map property
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected Object put(Object source, Object key, Object value) {
		Map map = new HashMap(getMap(source));
		boolean addition = !map.containsKey(key);
		Object result = map.put(key, value);
		MapDiff diff;
		if (addition) {
			diff = Diffs.createMapDiffSingleAdd(key, value);
		} else {
			diff = Diffs.createMapDiffSingleChange(key, result, value);
		}
		setMap(source, map, diff);
		return result;
	}

	/**
	 * Adds all mappings in the specified map to the source's map property.
	 * 
	 * @param source
	 *            the property source
	 * @param t
	 *            the map
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected void putAll(Object source, Map t) {
		if (t.isEmpty())
			return;

		Map map = new HashMap(getMap(source));
		Set addedKeys = new HashSet();
		Set changedKeys = new HashSet();
		Map oldValues = new HashMap();
		Map newValues = new HashMap();
		for (Iterator it = t.entrySet().iterator(); it.hasNext();) {
			Map.Entry entry = (Map.Entry) it.next();
			Object key = entry.getKey();
			Object newValue = entry.getValue();
			boolean addition = !map.containsKey(key);
			Object oldValue = map.put(key, newValue);
			if (addition) {
				addedKeys.add(key);
			} else if (!Util.equals(oldValue, newValue)) {
				changedKeys.add(key);
				oldValues.put(key, oldValue);
			}
			newValues.put(key, newValue);
		}
		setMap(source, map, Diffs.createMapDiff(addedKeys,
				Collections.EMPTY_SET, changedKeys, oldValues, newValues));
	}

	/**
	 * Removes the mapping for the specified key from the source's map property
	 * 
	 * @param source
	 *            the property source
	 * @param key
	 *            the key
	 * @return the value that was previously associated with the specified key
	 *         in the source's map property, or null if no such mapping exists
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected Object remove(Object source, Object key) {
		Map map = getMap(source);
		if (map.containsKey(key)) {
			map = new HashMap(map);
			Object result = map.remove(key);
			setMap(source, map, Diffs.createMapDiffSingleRemove(key, result));
			return result;
		}
		return null;
	}

	public IObservableMap observeMap(Realm realm, Object source) {
		return new SimpleMapPropertyObservableMap(realm, source, this);
	}

	public IObservableMap observeDetailMap(IObservableValue master) {
		final Realm realm = master.getRealm();
		IObservableFactory factory = new IObservableFactory() {
			public IObservable createObservable(Object target) {
				return SimpleMapProperty.this.observeMap(realm, target);
			}
		};
		return MasterDetailObservables.detailMap(master, factory);
	}
}

Lines 11-18 Link Here

(-)src/org/eclipse/core/databinding/property/map/SimpleMapPropertyObservableMap.java (-76 / +113 lines)
11		11
12	package org.eclipse.core.databinding.property.map;	12	package org.eclipse.core.databinding.property.map;
13		13
		14	import java.util.AbstractSet;
14	import java.util.Collection;	15	import java.util.Collection;
15	import java.util.Collections;	16	import java.util.Collections;
		17	import java.util.ConcurrentModificationException;
		18	import java.util.HashMap;
16	import java.util.HashSet;	19	import java.util.HashSet;
17	import java.util.Iterator;	20	import java.util.Iterator;
18	import java.util.Map;	21	import java.util.Map;
Lines 23-30 Link Here
23	import org.eclipse.core.databinding.observable.Realm;	26	import org.eclipse.core.databinding.observable.Realm;
24	import org.eclipse.core.databinding.observable.map.AbstractObservableMap;	27	import org.eclipse.core.databinding.observable.map.AbstractObservableMap;
25	import org.eclipse.core.databinding.observable.map.MapDiff;	28	import org.eclipse.core.databinding.observable.map.MapDiff;
26	import org.eclipse.core.databinding.property.IProperty;
27	import org.eclipse.core.databinding.property.INativePropertyListener;	29	import org.eclipse.core.databinding.property.INativePropertyListener;
		30	import org.eclipse.core.databinding.property.IProperty;
28	import org.eclipse.core.databinding.property.IPropertyObservable;	31	import org.eclipse.core.databinding.property.IPropertyObservable;
29		32
30	/**	33	/**
Lines 99-239 Link Here
99	cachedMap = null;	102	cachedMap = null;
100	}	103	}
101		104
102	public boolean containsKey(Object key) {	105	// Queries
103	getterCalled();
104	return property.containsKey(source, key);
105	}
106		106
107	public boolean containsValue(Object value) {	107	private Map getMap() {
108	getterCalled();	108	return property.getMap(source);
109	return property.containsValue(source, value);
110	}	109	}
111		110
		111	// Single change operations
		112
		113	private EntrySet es = new EntrySet();
		114
112	public Set entrySet() {	115	public Set entrySet() {
113	getterCalled();	116	getterCalled();
114	// unmodifiable for now	117	return es;
115	return Collections.unmodifiableSet(property.getMap(source).entrySet());
116	}	118	}
117		119
118	public Object get(Object key) {	120	private class EntrySet extends AbstractSet {
119	getterCalled();	121	public Iterator iterator() {
120	return property.get(source, key);	122	return new EntrySetIterator();
		123	}
		124
		125	public int size() {
		126	return getMap().size();
		127	}
121	}	128	}
122		129
123	public boolean isEmpty() {	130	private class EntrySetIterator implements Iterator {
124	getterCalled();	131	private volatile int expectedModCount = modCount;
125	return property.isEmpty(source);	132	Map map = new HashMap(getMap());
		133	Iterator iterator = map.entrySet().iterator();
		134	Map.Entry last = null;
		135
		136	public boolean hasNext() {
		137	getterCalled();
		138	checkForComodification();
		139	return iterator.hasNext();
		140	}
		141
		142	public Object next() {
		143	getterCalled();
		144	checkForComodification();
		145	last = (Map.Entry) iterator.next();
		146	return last;
		147	}
		148
		149	public void remove() {
		150	getterCalled();
		151	checkForComodification();
		152
		153	iterator.remove(); // stay in sync
		154	MapDiff diff = Diffs.createMapDiffSingleRemove(last.getKey(), last
		155	.getValue());
		156
		157	boolean wasUpdating = updating;
		158	boolean changed;
		159	updating = true;
		160	try {
		161	changed = property.setMap(source, map, diff);
		162	} finally {
		163	updating = wasUpdating;
		164	}
		165
		166	if (changed) {
		167	cachedMap = getMap();
		168	fireMapChange(diff);
		169
		170	last = null;
		171	expectedModCount = modCount;
		172	}
		173	}
		174
		175	private void checkForComodification() {
		176	if (expectedModCount != modCount)
		177	throw new ConcurrentModificationException();
		178	}
126	}	179	}
127		180
128	public Set keySet() {	181	public Set keySet() {
129	getterCalled();	182	getterCalled();
130	return Collections.unmodifiableSet(property.getMap(source).keySet());	183	// AbstractMap depends on entrySet() to fulfil keySet() API, so all
		184	// getterCalled() and comodification checks will still be handled
		185	return super.keySet();
131	}	186	}
132		187
133	public Object put(Object key, Object value) {	188	public Object put(Object key, Object value) {
134	checkRealm();	189	checkRealm();
135		190
136	boolean add;	191	Map map = new HashMap(getMap());
137	Object oldValue;	192
		193	boolean add = !map.containsKey(key);
		194
		195	Object oldValue = map.put(key, value);
		196
		197	MapDiff diff;
		198	if (add)
		199	diff = Diffs.createMapDiffSingleAdd(key, value);
		200	else
		201	diff = Diffs.createMapDiffSingleChange(key, oldValue, value);
138		202
139	boolean wasUpdating = updating;	203	boolean wasUpdating = updating;
		204	boolean changed;
140	updating = true;	205	updating = true;
141	try {	206	try {
142	add = !property.containsKey(source, key);	207	changed = property.setMap(source, map, diff);
143	oldValue = property.put(source, key, value);
144	modCount++;	208	modCount++;
145	} finally {	209	} finally {
146	updating = wasUpdating;	210	updating = wasUpdating;
147	}	211	}
148		212
149	cachedMap = property.getMap(source);	213	if (changed) {
150	MapDiff diff;	214	cachedMap = property.getMap(source);
151	if (add)	215	fireMapChange(diff);
152	diff = Diffs.createMapDiffSingleAdd(key, value);	216	}
153	else
154	diff = Diffs.createMapDiffSingleChange(key, oldValue, value);
155	fireMapChange(diff);
156		217
157	return property.put(source, key, value);	218	return oldValue;
158	}	219	}
159		220
160	public void putAll(Map m) {	221	public void putAll(Map m) {
161	checkRealm();	222	checkRealm();
162		223
163	Map oldValues = cachedMap;	224	Map map = new HashMap(getMap());
		225
		226	Map oldValues = new HashMap();
		227	Map newValues = new HashMap();
164	Set changedKeys = new HashSet();	228	Set changedKeys = new HashSet();
165	Set addedKeys = new HashSet();	229	Set addedKeys = new HashSet();
166	for (Iterator it = m.entrySet().iterator(); it.hasNext();) {	230	for (Iterator it = m.entrySet().iterator(); it.hasNext();) {
167	Map.Entry entry = (Entry) it.next();	231	Map.Entry entry = (Entry) it.next();
168	Object key = entry.getKey();	232	Object key = entry.getKey();
169	if (property.containsKey(source, key)) {	233	Object newValue = entry.getValue();
		234	if (map.containsKey(key)) {
170	changedKeys.add(key);	235	changedKeys.add(key);
		236	oldValues.put(key, map.get(key));
171	} else {	237	} else {
172	addedKeys.add(key);	238	addedKeys.add(key);
173	}	239	}
174	}	240	map.put(key, newValue);
175		241
176	boolean wasUpdating = updating;	242	newValues.put(key, newValue);
177	updating = true;
178	try {
179	property.putAll(source, m);
180	modCount++;
181	} finally {
182	updating = wasUpdating;
183	}	243	}
184		244
185	Map newValues = cachedMap = property.getMap(source);	245	MapDiff diff = Diffs.createMapDiff(addedKeys, Collections.EMPTY_SET,
186	fireMapChange(Diffs.createMapDiff(addedKeys, Collections.EMPTY_SET,	246	changedKeys, oldValues, newValues);
187	changedKeys, oldValues, newValues));
188	}
189
190	public Object remove(Object key) {
191	checkRealm();
192
193	if (!property.containsKey(source, key))
194	return null;
195
196	Object oldValue;
197		247
198	boolean wasUpdating = updating;	248	boolean wasUpdating = updating;
		249	boolean changed;
199	updating = true;	250	updating = true;
200	try {	251	try {
201	oldValue = property.remove(source, key);	252	changed = property.setMap(source, map, diff);
202	modCount++;	253	modCount++;
203	} finally {	254	} finally {
204	updating = wasUpdating;	255	updating = wasUpdating;
205	}	256	}
206		257
207	cachedMap = property.getMap(source);	258	if (changed) {
208	fireMapChange(Diffs.createMapDiffSingleRemove(key, oldValue));	259	cachedMap = getMap();
209		260	fireMapChange(diff);
210	return oldValue;	261	}
211	}	262	}
212		263
213	public int size() {	264	public Object remove(Object key) {
214	getterCalled();	265	checkRealm();
215	return property.size(source);	266	return super.remove(key);
216	}	267	}
217		268
218	public Collection values() {	269	public Collection values() {
219	getterCalled();	270	getterCalled();
220	return Collections.unmodifiableCollection(property.getMap(source)	271	// AbstractMap depends on entrySet() to fulfil keySet() API, so all
221	.values());	272	// getterCalled() and comodification checks will still be handled
222	}	273	return super.values();
223
224	public void clear() {
225	getterCalled();
226	property.clear(source);
227	}
228
229	public boolean equals(Object o) {
230	getterCalled();
231	return property.equals(source, o);
232	}
233
234	public int hashCode() {
235	getterCalled();
236	return property.hashCode(source);
237	}	274	}
238		275
239	public Object getObserved() {	276	public Object getObserved() {




				if (!haveIterated)
					throw new IllegalStateException();

				Object oldValue = cachedValues.get(new IdentityWrapper(
						lastMasterElement));

				boolean wasUpdating = updating;
				boolean changed;
				updating = true;
				try {
					changed = detailProperty.setValue(lastElement, o);
				} finally {
					updating = wasUpdating;
				}

				if (changed) {
					Object newValue = detailProperty.getValue(lastElement);

					if (!Util.equals(oldValue, newValue)) {
						cachedValues.put(
								new IdentityWrapper(lastMasterElement), o);
						fireListChange(Diffs.createListDiff(Diffs
								.createListDiffEntry(lastIndex, false,
										lastElement), Diffs
								.createListDiffEntry(lastIndex, true, o)));
					}
				}

				lastElement = o;
			}

		Object oldValue = detailProperty.getValue(masterElement);

		boolean wasUpdating = updating;
		boolean changed;
		updating = true;
		try {
			changed = detailProperty.setValue(masterElement, o);
		} finally {
			updating = wasUpdating;
		}

		if (changed) {
			Object newValue = detailProperty.getValue(masterElement);

			if (!Util.equals(oldValue, newValue)) {
				cachedValues.put(new IdentityWrapper(masterElement), o);
				fireListChange(Diffs.createListDiff(Diffs.createListDiffEntry(
						index, false, oldValue), Diffs.createListDiffEntry(
						index, true, o)));
			}
		}

		return oldValue;
	}




	protected Object doPut(Object key, Object value) {
		Object oldValue = detailProperty.getValue(key);

		boolean changed;
		updating = true;
		try {
			changed = detailProperty.setValue(key, value);
		} finally {
			updating = false;
		}
		
		if (changed) {
			Object newValue = detailProperty.getValue(key);
			cachedValues.put(key, newValue);
			
			if (oldValue != newValue) {
				fireMapChange(Diffs.createMapDiffSingleChange(key, oldValue,
						newValue));
			}
		}

		return oldValue;
	}


Lines 74-82 Link Here

(-)src/org/eclipse/core/databinding/property/value/SimpleValueProperty.java (-1 / +3 lines)
74	* the property source	74	* the property source
75	* @param value	75	* @param value
76	* the new value	76	* the new value
		77	* @return true if the property was modified on the source object, false
		78	* otherwise
77	* @noreference This method is not intended to be referenced by clients.	79	* @noreference This method is not intended to be referenced by clients.
78	*/	80	*/
79	protected abstract void setValue(Object source, Object value);	81	protected abstract boolean setValue(Object source, Object value);
80		82
81	/**	83	/**
82	* Returns a listener which implements the correct listener interface for	84	* Returns a listener which implements the correct listener interface for





			Object oldValue = detailProperty.getValue(source);

			boolean changed;
			updating = true;
			try {
				changed = detailProperty.setValue(source, value);
			} finally {
				updating = false;
			}

			if (changed) {
				Object newValue = detailProperty.getValue(source);
				
				if (!Util.equals(oldValue, newValue)) {
					fireMapChange(Diffs.createMapDiffSingleChange(key, oldValue,
							newValue));
				}
			}

			return oldValue;




		if (hasListeners()) {
			Object oldValue = cachedValue;

			boolean changed;
			updating = true;
			try {
				changed = property.setValue(source, value);
			} finally {
				updating = false;
			}

			if (changed) {
				Object newValue = cachedValue = property.getValue(source);
				if (hasListeners() && !Util.equals(oldValue, newValue)) {
					fireValueChange(Diffs.createValueDiff(oldValue, newValue));
				}
			}
		} else {
			property.setValue(source, value);





package org.eclipse.core.databinding.property.list;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.observable.IObservable;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.list.IObservableList;
import org.eclipse.core.databinding.observable.list.ListDiff;
import org.eclipse.core.databinding.observable.list.ListDiffEntry;
import org.eclipse.core.databinding.observable.masterdetail.IObservableFactory;
import org.eclipse.core.databinding.observable.masterdetail.MasterDetailObservables;
import org.eclipse.core.databinding.observable.value.IObservableValue;

		this.elementType = elementType;
	}

	public IObservableList observeList(Realm realm, Object source) {
		return new SimpleListPropertyObservableList(realm, source, this);
	}

	public IObservableList observeDetailList(IObservableValue master) {
		final Realm realm = master.getRealm();
		IObservableFactory factory = new IObservableFactory() {
			public IObservable createObservable(Object target) {
				return SimpleListProperty.this.observeList(realm, target);
			}
		};
		return MasterDetailObservables.detailList(master, factory,
				getElementType());
	}

	/**
	 * Returns the type of the elements in the collection or <code>null</code>
	 * if untyped

		return elementType;
	}

	// Accessors
	 * Returns whether the source's collection property contains all elements in
	 * the given collection
	 * 
	 * @param source
	 *            the property source
	 * @param c
	 *            the collection of elements to test for
	 * @return whether the source's collection property contains all elements in
	 *         the given collection
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected boolean containsAll(Object source, Collection c) {
		return getList(source).containsAll(c);
	}

	/**
	 * Returns whether the source's collection property contains the given
	 * element.
	 * 
	 * @param source
	 *            the property source
	 * @param o
	 *            the element
	 * @return whether the source's collection property contains the given
	 *         element.
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected boolean contains(Object source, Object o) {
		return getList(source).contains(o);
	}

	/**
	 * Returns an unmodifiable List with the current contents of the source's
	 * list property
	 * 
	 * @param source
	 *            the property source
	 * @param o
	 *            the object to test for equality to the source's collection
	 *            property
	 * @return whether the source's collection property is equal to the argument
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected boolean equals(Object source, Object o) {
		return getList(source).equals(o);
	}

	/**
	 * Returns the hash code of the source's collection property.
	 * 
	 * @param source
	 *            the property source
	 * @return an unmodifiable List with the current contents of the source's
	 *         list property
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected final List getList(Object source) {
		return Collections.unmodifiableList(doGetList(source));
	}

	/**
	 * Returns a List with the current contents of the source's list property
	 * 
	 * @param source
	 *            the property source
	 * @return a List with the current contents of the source's list property
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected abstract List doGetList(Object source);
		return getList(source).isEmpty();
	}

	// Mutators
	 * Returns the size of the source's collection property
	 * 
	 * @param source
	 *            the property source
	 * @return the size of the source's collection property
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected int size(Object source) {
		return getList(source).size();
	}

	/**
	 * Updates the property on the source with the specified change.
	 * 
	 * @param source
	 *            the property source
	 * @param list
	 *            the new list
	 * @param diff
	 *            a diff describing the change
	 * @return true if the property was modified on the source object, false
	 *         otherwise
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected abstract boolean setList(Object source, List list, ListDiff diff);
		return getList(source).toArray(array);
	}

	// Listeners
	 * Returns an array of all elements in the source's collection property
	 * 
	 * @param source
	 *            the property source
	 * @return an array of all elements in the source's collection property
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected Object[] toArray(Object source) {
		return getList(source).toArray();
	}

	/**
	 * Returns a listener which implements the correct listener interface for

			IListPropertyChangeListener listener);

	/**
	 * Inserts the element into the source's list property at the specified
	 * position
	 * 
	 * @param source
	 *            the property source
	 * @param index
	 *            the insertion index
	 * @param element
	 *            the element to insert
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected void add(Object source, int index, Object element) {
		List list = new ArrayList(getList(source));
		list.add(index, element);
		setList(source, list, Diffs.createListDiff(Diffs.createListDiffEntry(
				index, true, element)));
	}

	/**
	 * Adds the element to the source's collection property
	 * 
	 * @param source
	 *            the property source
	 * @param o
	 *            the element to add
	 * @return whether the element was added to the source's collection property
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected boolean add(Object source, Object o) {
		add(source, size(source), o);
		return true;
	}

	/**
	 * Adds all elements in the specified collection to the source's collection
	 * property.
	 * 
	 * @param source
	 *            the property source
	 * @param c
	 *            the collection of elements to add.
	 * @return whether the source's collection property was changed
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected boolean addAll(Object source, Collection c) {
		if (c.isEmpty())
			return false;
		addAll(source, size(source), c);
		return true;
	}

	/**
	 * Inserts all elements in the specified collection into the source's list
	 * property at the specified index.
	 * 
	 * @param source
	 *            the property source
	 * @param index
	 *            the insertion index
	 * @param c
	 *            the collection of elements to add
	 * @return whether the source's list property was changed
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected boolean addAll(Object source, int index, Collection c) {
		if (c.isEmpty()) {
			return false;
		}

		List list = new ArrayList(getList(source));
		List entries = new ArrayList();
		int i = index;
		for (Iterator it = c.iterator(); it.hasNext(); i++) {
			Object o = it.next();
			list.add(i, o);
			entries.add(Diffs.createListDiffEntry(i, true, o));
		}
		boolean changed = !entries.isEmpty();
		if (changed) {
			ListDiffEntry[] ea = (ListDiffEntry[]) entries
					.toArray(new ListDiffEntry[entries.size()]);
			setList(source, list, Diffs.createListDiff(ea));
		}
		return changed;
	}

	/**
	 * Adds the specified listener as a listener for this property on the
	 * specified property source. If the source object has no listener API for
	 * this property (i.e. {@link #adaptListener(IListPropertyChangeListener)}

			INativePropertyListener listener);

	/**
	 * Removes all elements from the source's collection property.
	 * 
	 * @param source
	 *            the property source
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected void clear(Object source) {
		if (!isEmpty(source)) {
			List list = getList(source);
			ListDiffEntry[] entries = new ListDiffEntry[list.size()];
			int i = 0;
			for (Iterator it = getList(source).iterator(); it.hasNext(); i++) {
				entries[i] = Diffs.createListDiffEntry(0, false, it.next());
			}
			setList(source, new ArrayList(), Diffs.createListDiff(entries));
		}
	}

	/**
	 * Returns the element at the specified position in the source's list
	 * property
	 * 
	 * @param source
	 *            the property source
	 * @param index
	 *            the element position
	 * @return the element at the given position in the source's list property
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected Object get(Object source, int index) {
		return getList(source).get(index);
	}

	/**
	 * Returns an unmodifiable List with the current contents of the source's
	 * list property
	 * 
	 * @param source
	 *            the property source
	 * @return an unmodifiable List with the current contents of the source's
	 *         list property
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected final List getList(Object source) {
		return Collections.unmodifiableList(doGetList(source));
	}

	/**
	 * Returns a List with the current contents of the source's list property
	 * 
	 * @param source
	 *            the property source
	 * @return a List with the current contents of the source's list property
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected abstract List doGetList(Object source);

	/**
	 * Returns the index of the first location of the given element in the
	 * source's list property, or -1 if the list does not contain the element.
	 * 
	 * @param source
	 *            the property source
	 * @param o
	 *            the element
	 * @return the index of the first location of the given element in the
	 *         source's list property, or -1 if the list does not contain the
	 *         element
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected int indexOf(Object source, Object o) {
		return getList(source).indexOf(o);
	}

	/**
	 * Returns the index of the last location of the given element in the
	 * source's list property, or -1 if the list does not contain the given
	 * element.
	 * 
	 * @param source
	 * @param o
	 * @return the index of the last location of the given element in the
	 *         source's list property, or -1 if the list does not contain the
	 *         element
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected int lastIndexOf(Object source, Object o) {
		return getList(source).lastIndexOf(o);
	}

	/**
	 * Moves the element at the specified old position in the source's list
	 * property to the specified new position
	 * 
	 * @param source
	 *            the property source
	 * @param oldIndex
	 *            the old element position
	 * @param newIndex
	 *            the new element position
	 * @return the element that was moved
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected Object move(Object source, int oldIndex, int newIndex) {
		if (oldIndex == newIndex)
			return get(source, oldIndex);
		List list = new ArrayList(getList(source));
		Object result = list.remove(oldIndex);
		list.add(newIndex, result);
		setList(source, list, Diffs.createListDiff(Diffs.createListDiffEntry(
				oldIndex, false, result), Diffs.createListDiffEntry(newIndex,
				true, result)));
		return result;
	}

	public IObservableList observeList(Realm realm, Object source) {
		return new SimpleListPropertyObservableList(realm, source, this);
	}

	public IObservableList observeDetailList(IObservableValue master) {
		final Realm realm = master.getRealm();
		IObservableFactory factory = new IObservableFactory() {
			public IObservable createObservable(Object target) {
				return SimpleListProperty.this.observeList(realm, target);
			}
		};
		return MasterDetailObservables.detailList(master, factory,
				getElementType());
	}

	/**
	 * Removes the element from the source's list property which is located at
	 * the specified position
	 * 
	 * @param source
	 *            the property source
	 * @param index
	 *            the index of the element to remove
	 * @return the element that was removed from the source's list property
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected Object remove(Object source, int index) {
		List list = new ArrayList(getList(source));
		Object result = list.remove(index);
		setList(source, list, Diffs.createListDiff(Diffs.createListDiffEntry(
				index, false, result)));
		return result;
	}

	/**
	 * Removes the element from the source's collection property
	 * 
	 * @param source
	 *            the property source
	 * @param o
	 *            the element to remove
	 * @return whether the element was removed from the source's collection
	 *         property
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected boolean remove(Object source, Object o) {
		int i = indexOf(source, o);
		if (i == -1)
			return false;
		remove(source, i);
		return true;
	}

	/**
	 * Removes all elements from the source's collection property which are
	 * contained in the specified collection.
	 * 
	 * @param source
	 *            the property source
	 * @param c
	 *            the collection of elements to be removed
	 * @return whether the source's collection property was changed
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected boolean removeAll(Object source, Collection c) {
		if (isEmpty(source)) {
			return false;
		}
		if (c.isEmpty()) {
			return false;
		}
		List list = new ArrayList(getList(source));
		List entries = new ArrayList();
		for (ListIterator it = list.listIterator(); it.hasNext();) {
			Object o = it.next();
			if (c.contains(o)) {
				entries.add(Diffs.createListDiffEntry(it.previousIndex(),
						false, o));
				it.remove();
			}
		}
		boolean changed = !entries.isEmpty();
		if (changed) {
			ListDiffEntry[] ea = (ListDiffEntry[]) entries
					.toArray(new ListDiffEntry[entries.size()]);
			setList(source, list, Diffs.createListDiff(ea));
		}
		return changed;
	}

	/**
	 * Removes the specified listener as a listener for this property on the
	 * specified property source. If the source object has no listener API for
	 * this property (i.e. {@link #adaptListener(IListPropertyChangeListener)}

	protected abstract void removeListener(Object source,
			INativePropertyListener listener);

	/**
	 * Removes all elements from the source's collection property which are not
	 * contained in the specified collection.
	 * 
	 * @param source
	 *            the property source
	 * @param c
	 *            the collection of elements to retain
	 * @return whether the source's collection property was changed
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected boolean retainAll(Object source, Collection c) {
		if (isEmpty(source)) {
			return false;
		}
		if (c.isEmpty()) {
			clear(source);
			return true;
		}
		List list = new ArrayList(getList(source));
		List entries = new ArrayList();
		for (ListIterator it = list.listIterator(); it.hasNext();) {
			Object o = it.next();
			if (!c.contains(o)) {
				entries.add(Diffs.createListDiffEntry(it.previousIndex(),
						false, o));
				it.remove();
			}
		}
		boolean changed = !entries.isEmpty();
		if (changed) {
			ListDiffEntry[] ea = (ListDiffEntry[]) entries
					.toArray(new ListDiffEntry[entries.size()]);
			setList(source, list, Diffs.createListDiff(ea));
		}
		return changed;
	}

	/**
	 * Replaces the element at the specified position in the source's list
	 * property with the given element.
	 * 
	 * @param source
	 *            the property source
	 * @param index
	 *            the element position
	 * @param element
	 *            the replacement element
	 * @return the element previously at the specified position in the source's
	 *         list property
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected Object set(Object source, int index, Object element) {
		List list = new ArrayList(getList(source));
		Object result = list.set(index, element);
		setList(source, list, Diffs.createListDiff(Diffs.createListDiffEntry(
				index, false, result), Diffs.createListDiffEntry(index, true,
				element)));
		return result;
	}

	/**
	 * Updates the property on the source with the specified change.
	 * 
	 * @param source
	 *            the property source
	 * @param list
	 *            the new list
	 * @param diff
	 *            a diff describing the change
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected abstract void setList(Object source, List list, ListDiff diff);
}





	protected void firstListenerAdded() {
		if (!isDisposed()) {
			cachedList = getList();

			if (listener == null) {
				listener = property

									getRealm().exec(new Runnable() {
										public void run() {
											List oldList = cachedList;
											List newList = cachedList = getList();
													.getList(source);
											ListDiff diff = event.diff;
											if (diff == null) {
												diff = Diffs.computeListDiff(


	// Queries

	private List getList() {
		return property.getList(source);
	}

	protected int doGetSize() {
		return getList().size();
	}

	public boolean contains(Object o) {
		getterCalled();
		return getList().contains(o);
	}

	public boolean containsAll(Collection c) {
		getterCalled();
		return getList().containsAll(c);
	}

	public Object get(int index) {
		getterCalled();
		return getList().get(index);
	}

	public int indexOf(Object o) {
		getterCalled();
		return getList().indexOf(o);
	}

	public boolean isEmpty() {
		getterCalled();
		return getList().isEmpty();
	}

	public int lastIndexOf(Object o) {
		getterCalled();
		return getList().lastIndexOf(o);
	}

	public Object[] toArray() {
		getterCalled();
		return getList().toArray();
	}

	public Object[] toArray(Object[] a) {
		getterCalled();
		return getList().toArray(a);
	}

	// Single change operations

	public boolean add(Object o) {
		checkRealm();
		add(getList().size(), o);
		return true;
	}

	public void add(int index, Object o) {
		checkRealm();
		boolean wasUpdating = updating;
		boolean changed;
		updating = true;
		List list = new ArrayList(getList());
		list.add(index, o);
		ListDiff diff = Diffs.createListDiff(Diffs.createListDiffEntry(index,
				true, o));
		try {
			changed = property.setList(source, list, diff);
			modCount++;
		} finally {
			updating = wasUpdating;
		}

		if (changed) {
			cachedList = getList();
			fireListChange(diff);
		}
	}

	public Iterator iterator() {
		getterCalled();
		return new Iterator() {
			int expectedModCount = modCount;
			List list = new ArrayList(getList());
			ListIterator iterator = list.listIterator();

			Object lastElement = null;
			int lastIndex = -1;

			public boolean hasNext() {
				getterCalled();
				checkForComodification();
				return iterator.hasNext();
			}

			public Object next() {
				getterCalled();
				checkForComodification();
				Object next = lastElement = iterator.next();
				lastIndex = iterator.previousIndex();
				return next;
			}


				if (lastIndex == -1)
					throw new IllegalStateException();

				iterator.remove(); // stay in sync
				ListDiff diff = Diffs.createListDiff(Diffs.createListDiffEntry(
						lastIndex, false, lastElement));

				boolean wasUpdating = updating;
				boolean changed;
				updating = true;
				try {
					changed = property.setList(source, list, diff);
					modCount++;
				} finally {
					updating = wasUpdating;
				}

				if (changed) {
					cachedList = getList();
					fireListChange(diff);

					lastElement = null;
					lastIndex = -1;

					expectedModCount = modCount;
				}
			}

			private void checkForComodification() {

	public Object move(int oldIndex, int newIndex) {
		checkRealm();

		List list = getList();
		int size = list.size();
		if (oldIndex < 0 || oldIndex >= size || newIndex < 0
				|| newIndex >= size)
			throw new IndexOutOfBoundsException();

		if (oldIndex == newIndex)
			return list.get(oldIndex);

		list = new ArrayList(list);
		Object element = list.remove(oldIndex);
		list.add(newIndex, element);

		ListDiff diff = Diffs.createListDiff(Diffs.createListDiffEntry(
				oldIndex, false, element), Diffs.createListDiffEntry(newIndex,
				true, element));

		boolean wasUpdating = updating;
		boolean changed;
		updating = true;
		try {
			changed = property.setList(source, list, diff);
			modCount++;
		} finally {
			updating = wasUpdating;
		}

		if (changed) {
			cachedList = getList();
			fireListChange(diff);
		}

		return element;
	}

	public boolean remove(Object o) {
		checkRealm();

		int index = getList().indexOf(o);
		if (index == -1)
			return false;


		getterCalled();
		return new ListIterator() {
			int expectedModCount = modCount;
			List list = new ArrayList(getList());
			ListIterator iterator = list.listIterator(index);

			Object lastElement = null;
			int lastIndex = -1;

			public boolean hasNext() {
				getterCalled();
				checkForComodification();
				return iterator.hasNext();
			}

			public int nextIndex() {
				getterCalled();
				checkForComodification();
				return iterator.nextIndex();
			}

			public Object next() {
				getterCalled();
				checkForComodification();
				lastElement = iterator.next();
				lastIndex = iterator.previousIndex();
				return lastElement;
			}

			public boolean hasPrevious() {
				getterCalled();
				checkForComodification();
				return iterator.hasPrevious();
			}

			public int previousIndex() {
				getterCalled();
				checkForComodification();
				return iterator.previousIndex();
			}

			public Object previous() {
				getterCalled();
				checkForComodification();
				lastElement = iterator.previous();
				lastIndex = iterator.nextIndex();
				return lastElement;
			}

			public void add(Object o) {
				checkRealm();
				checkForComodification();
				int index = iterator.nextIndex();

				iterator.add(o); // keep in sync

				List list = getList();
				list.add(index, o);
				ListDiff diff = Diffs.createListDiff(Diffs.createListDiffEntry(
						index, true, o));
				boolean wasUpdating = updating;
				boolean changed;
				updating = true;
				try {
					changed = property.setList(source, list, diff);
					modCount++;
				} finally {
					updating = wasUpdating;
				}

				if (changed) {
					cachedList = getList();
					fireListChange(diff);

					lastElement = null;
					lastIndex = -1;
					expectedModCount = modCount;
				}
			}

			public void set(Object o) {
				checkRealm();
				checkForComodification();

				iterator.set(o);
				ListDiff diff = Diffs.createListDiff(Diffs.createListDiffEntry(
						lastIndex, false, lastElement), Diffs
						.createListDiffEntry(lastIndex, true, o));

				boolean wasUpdating = updating;
				boolean changed;
				updating = true;
				try {
					changed = property.setList(source, list, diff);
					modCount++;
				} finally {
					updating = wasUpdating;
				}

				if (changed) {
					cachedList = getList();
					fireListChange(diff);
						.createListDiffEntry(lastIndex, true, o)));

					lastElement = o;

					expectedModCount = modCount;
				}
			}

			public void remove() {

				if (lastIndex == -1)
					throw new IllegalStateException();

				iterator.remove(); // keep in sync
				ListDiff diff = Diffs.createListDiff(Diffs.createListDiffEntry(
						lastIndex, false, lastElement));

				boolean wasUpdating = updating;
				boolean changed;
				updating = true;
				try {
					changed = property.setList(source, list, diff);
					modCount++;
				} finally {
					updating = wasUpdating;
				}

				if (changed) {
					cachedList = getList();
					fireListChange(diff);

					lastElement = null;
					lastIndex = -1;
					expectedModCount = modCount;
				}
			}

			private void checkForComodification() {

	public Object remove(int index) {
		checkRealm();

		List list = new ArrayList(getList());
		Object element = list.remove(index);
		ListDiff diff = Diffs.createListDiff(Diffs.createListDiffEntry(index,
				false, element));

		boolean wasUpdating = updating;
		boolean changed;
		updating = true;
		try {
			changed = property.setList(source, list, diff);
			modCount++;
		} finally {
			updating = wasUpdating;
		}

		if (changed) {
			cachedList = getList();
			fireListChange(diff);
		}

		return element;
	}

	public Object set(int index, Object o) {
		checkRealm();

		List list = new ArrayList(getList());
		Object oldElement = list.set(index, o);

		ListDiff diff = Diffs.createListDiff(Diffs.createListDiffEntry(index,
				false, oldElement), Diffs.createListDiffEntry(index, true, o));

		boolean wasUpdating = updating;
		boolean changed;
		updating = true;
		try {
			changed = property.setList(source, list, diff);
			modCount++;
		} finally {
			updating = wasUpdating;
		}

		if (changed) {
			cachedList = getList();
			fireListChange(diff);
		}

		return oldElement;
	}

	public List subList(int fromIndex, int toIndex) {
		getterCalled();
		return Collections.unmodifiableList(getList().subList(fromIndex,
				toIndex));
	}

	// Bulk change operations

	public boolean addAll(Collection c) {
		checkRealm();

		return addAll(getList().size(), c);
	}

	public boolean addAll(int index, Collection c) {

		if (c.isEmpty())
			return false;

		List list = new ArrayList(getList());
		list.addAll(index, c);

		ListDiffEntry[] entries = new ListDiffEntry[c.size()];
		int offsetIndex = 0;
		for (Iterator it = c.iterator(); it.hasNext();) {

					+ offsetIndex, true, element);
			offsetIndex++;
		}
		ListDiff diff = Diffs.createListDiff(entries);

		boolean changed;

		boolean wasUpdating = updating;
		updating = true;
		try {
			changed = property.setList(source, list, diff);
			modCount++;
		} finally {
			updating = wasUpdating;
		}

		if (changed) {
			cachedList = getList();
			fireListChange(diff);
		}

		return changed;
	}

	public boolean removeAll(Collection c) {
		checkRealm();

		if (c.isEmpty())
			return false;

		List list = getList();
		if (list.isEmpty())
			return false;

		list = new ArrayList(list);
		List entries = new ArrayList();
		ListDiff diff;

		boolean wasUpdating = updating;
		boolean changed;
		updating = true;
		try {
			List list = new ArrayList(property.getList(source));
			for (ListIterator it = list.listIterator(); it.hasNext();) {
				Object element = it.next();
				int index = it.previousIndex();

							.createListDiffEntry(index, false, element));
				}
			}
			if (entries.isEmpty())
				return false;

			diff = Diffs.createListDiff((ListDiffEntry[]) entries
					.toArray(new ListDiffEntry[entries.size()]));
			changed = property.setList(source, list, diff);
			modCount++;
		} finally {
			updating = wasUpdating;
		}

		if (changed) {
			cachedList = getList();
			fireListChange(diff);
		}
					.toArray(new ListDiffEntry[entries.size()])));

		return changed;
	}

	public boolean retainAll(Collection c) {
		checkRealm();

		List list = getList();
		if (list.isEmpty())
			return false;

		if (c.isEmpty()) {

			return true;
		}

		list = new ArrayList(list);

		List entries = new ArrayList();
		ListDiff diff;

		boolean wasUpdating = updating;
		boolean changed;
		updating = true;
		try {
			List list = new ArrayList(property.getList(source));
			for (ListIterator it = list.listIterator(); it.hasNext();) {
				Object element = it.next();
				int index = it.previousIndex();

							.createListDiffEntry(index, false, element));
				}
			}
			if (entries.isEmpty())
				return false;

			diff = Diffs.createListDiff((ListDiffEntry[]) entries
					.toArray(new ListDiffEntry[entries.size()]));
			changed = property.setList(source, list, diff);
			modCount++;
		} finally {
			updating = wasUpdating;
		}

		if (changed) {
			cachedList = getList();
			fireListChange(diff);
		}
					.toArray(new ListDiffEntry[entries.size()])));

		return changed;
	}

	public void clear() {
		checkRealm();

		List list = getList();
		if (list.isEmpty())
			return;

		List entries = new ArrayList();
		for (Iterator it = list.iterator(); it.hasNext();) {
			// always report 0 as the remove index
			entries.add(Diffs.createListDiffEntry(0, false, it.next()));
		}

		ListDiff diff = Diffs.createListDiff((ListDiffEntry[]) entries
				.toArray(new ListDiffEntry[entries.size()]));
		boolean wasUpdating = updating;
		boolean changed;
		updating = true;
		try {
			changed = property.setList(source, Collections.EMPTY_LIST, diff);
			modCount++;
		} finally {
			updating = wasUpdating;
		}

		if (changed) {
			cachedList = getList();
			fireListChange(diff);
		}
	}

	public boolean equals(Object o) {
		getterCalled();
		return getList().equals(o);
	}

	public int hashCode() {
		getterCalled();
		return getList().hashCode();
	}

	public Object getObserved() {




		return (Set) propertyValue;
	}

	protected boolean setSet(Object source, Set set, SetDiff diff) {
		if (source == null)
			return false;
		BeanPropertyHelper.writeProperty(source, propertyDescriptor,
				convertSetToBeanPropertyType(set));
		return true;
	}

	private Object convertSetToBeanPropertyType(Set set) {

Lines 43-52 Link Here

(-)src/org/eclipse/core/internal/databinding/beans/PojoValueProperty.java (-4 / +5 lines)
43	return BeanPropertyHelper.readProperty(source, propertyDescriptor);	43	return BeanPropertyHelper.readProperty(source, propertyDescriptor);
44	}	44	}
45		45
46	public void setValue(Object source, Object value) {	46	public boolean setValue(Object source, Object value) {
47	if (source != null) {	47	if (source == null)
48	BeanPropertyHelper.writeProperty(source, propertyDescriptor, value);	48	return false;
49	}	49	BeanPropertyHelper.writeProperty(source, propertyDescriptor, value);
		50	return true;
50	}	51	}
51		52
52	public PropertyDescriptor getPropertyDescriptor() {	53	public PropertyDescriptor getPropertyDescriptor() {




		return (Set) propertyValue;
	}

	protected boolean setSet(Object source, Set set, SetDiff diff) {
		if (source == null)
			return false;
		BeanPropertyHelper.writeProperty(source, propertyDescriptor,
				convertSetToBeanPropertyType(set));
		return true;
	}

	private Object convertSetToBeanPropertyType(Set set) {




		return (List) propertyValue;
	}

	protected boolean setList(Object source, List list, ListDiff diff) {
		if (source == null)
			return false;
		BeanPropertyHelper.writeProperty(source, propertyDescriptor,
				convertListToBeanPropertyType(list));
		return true;
	}

	private Object convertListToBeanPropertyType(List list) {

Lines 54-63 Link Here

(-)src/org/eclipse/core/internal/databinding/beans/PojoMapProperty.java (-4 / +5 lines)
54	return (Map) propertyValue;	54	return (Map) propertyValue;
55	}	55	}
56		56
57	protected void setMap(Object source, Map map, MapDiff diff) {	57	protected boolean setMap(Object source, Map map, MapDiff diff) {
58	if (source != null) {	58	if (source == null)
59	BeanPropertyHelper.writeProperty(source, propertyDescriptor, map);	59	return false;
60	}	60	BeanPropertyHelper.writeProperty(source, propertyDescriptor, map);
		61	return true;
61	}	62	}
62		63
63	public PropertyDescriptor getPropertyDescriptor() {	64	public PropertyDescriptor getPropertyDescriptor() {

Lines 58-67 Link Here

(-)src/org/eclipse/core/internal/databinding/beans/BeanMapProperty.java (-4 / +5 lines)
58	return (Map) propertyValue;	58	return (Map) propertyValue;
59	}	59	}
60		60
61	protected void setMap(Object source, Map map, MapDiff diff) {	61	protected boolean setMap(Object source, Map map, MapDiff diff) {
62	if (source != null) {	62	if (source == null)
63	BeanPropertyHelper.writeProperty(source, propertyDescriptor, map);	63	return false;
64	}	64	BeanPropertyHelper.writeProperty(source, propertyDescriptor, map);
		65	return true;
65	}	66	}
66		67
67	public PropertyDescriptor getPropertyDescriptor() {	68	public PropertyDescriptor getPropertyDescriptor() {




		return (List) propertyValue;
	}

	protected boolean setList(Object source, List list, ListDiff diff) {
		if (source == null)
			return false;
		BeanPropertyHelper.writeProperty(source, propertyDescriptor,
				convertListToBeanPropertyType(list));
		return true;
	}

	private Object convertListToBeanPropertyType(List list) {

Lines 48-57 Link Here

(-)src/org/eclipse/core/internal/databinding/beans/BeanValueProperty.java (-4 / +5 lines)
48	return BeanPropertyHelper.readProperty(source, propertyDescriptor);	48	return BeanPropertyHelper.readProperty(source, propertyDescriptor);
49	}	49	}
50		50
51	public void setValue(Object source, Object value) {	51	public boolean setValue(Object source, Object value) {
52	if (source != null) {	52	if (source == null)
53	BeanPropertyHelper.writeProperty(source, propertyDescriptor, value);	53	return false;
54	}	54	BeanPropertyHelper.writeProperty(source, propertyDescriptor, value);
		55	return true;
55	}	56	}
56		57
57	public PropertyDescriptor getPropertyDescriptor() {	58	public PropertyDescriptor getPropertyDescriptor() {

Lines 42-51 Link Here

(-)src/org/eclipse/jface/internal/databinding/viewers/SelectionProviderSingleSelectionProperty.java (-1 / +4 lines)
42	return null;	42	return null;
43	}	43	}
44		44
45	public void setValue(Object source, Object value) {	45	public boolean setValue(Object source, Object value) {
		46	if (source == null)
		47	return false;
46	((ISelectionProvider) source)	48	((ISelectionProvider) source)
47	.setSelection(value == null ? StructuredSelection.EMPTY	49	.setSelection(value == null ? StructuredSelection.EMPTY
48	: new StructuredSelection(value));	50	: new StructuredSelection(value));
		51	return true;
49	}	52	}
50		53
51	public INativePropertyListener adaptListener(	54	public INativePropertyListener adaptListener(

Lines 31-38 Link Here

(-)src/org/eclipse/jface/internal/databinding/viewers/ViewerInputProperty.java (-1 / +4 lines)
31	return ((Viewer) source).getInput();	31	return ((Viewer) source).getInput();
32	}	32	}
33		33
34	public void setValue(Object source, Object value) {	34	public boolean setValue(Object source, Object value) {
		35	if (source == null)
		36	return false;
35	((Viewer) source).setInput(value);	37	((Viewer) source).setInput(value);
		38	return true;
36	}	39	}
37		40
38	public INativePropertyListener adaptListener(	41	public INativePropertyListener adaptListener(

Lines 38-44 Link Here

(-)src/org/eclipse/jface/internal/databinding/viewers/StructuredViewerFiltersProperty.java (-1 / +4 lines)
38	.getFilters()));	38	.getFilters()));
39	}	39	}
40		40
41	public void setSet(Object source, Set set, SetDiff diff) {	41	public boolean setSet(Object source, Set set, SetDiff diff) {
		42	if (source == null)
		43	return false;
42	StructuredViewer viewer = (StructuredViewer) source;	44	StructuredViewer viewer = (StructuredViewer) source;
43	viewer.getControl().setRedraw(false);	45	viewer.getControl().setRedraw(false);
44	try {	46	try {
Lines 47-52 Link Here
47	} finally {	49	} finally {
48	viewer.getControl().setRedraw(true);	50	viewer.getControl().setRedraw(true);
49	}	51	}
		52	return true;
50	}	53	}
51		54
52	public INativePropertyListener adaptListener(	55	public INativePropertyListener adaptListener(

Lines 56-62 Link Here

(-)src/org/eclipse/jface/internal/databinding/viewers/CheckableCheckedElementsProperty.java (-1 / +4 lines)
56	return new HashSet();	56	return new HashSet();
57	}	57	}
58		58
59	protected void setSet(Object source, Set set, SetDiff diff) {	59	protected boolean setSet(Object source, Set set, SetDiff diff) {
		60	if (source == null)
		61	return false;
60	ICheckable checkable = (ICheckable) source;	62	ICheckable checkable = (ICheckable) source;
61	for (Iterator it = diff.getAdditions().iterator(); it.hasNext();) {	63	for (Iterator it = diff.getAdditions().iterator(); it.hasNext();) {
62	checkable.setChecked(it.next(), true);	64	checkable.setChecked(it.next(), true);
Lines 64-69 Link Here
64	for (Iterator it = diff.getRemovals().iterator(); it.hasNext();) {	66	for (Iterator it = diff.getRemovals().iterator(); it.hasNext();) {
65	checkable.setChecked(it.next(), false);	67	checkable.setChecked(it.next(), false);
66	}	68	}
		69	return true;
67	}	70	}
68		71
69	public INativePropertyListener adaptListener(	72	public INativePropertyListener adaptListener(

Lines 45-53 Link Here

(-)src/org/eclipse/jface/internal/databinding/viewers/SelectionProviderMultipleSelectionProperty.java (-1 / +4 lines)
45	return Collections.EMPTY_LIST;	45	return Collections.EMPTY_LIST;
46	}	46	}
47		47
48	protected void setList(Object source, List list, ListDiff diff) {	48	protected boolean setList(Object source, List list, ListDiff diff) {
		49	if (source == null)
		50	return false;
49	((ISelectionProvider) source)	51	((ISelectionProvider) source)
50	.setSelection(new StructuredSelection(list));	52	.setSelection(new StructuredSelection(list));
		53	return true;
51	}	54	}
52		55
53	public INativePropertyListener adaptListener(	56	public INativePropertyListener adaptListener(

Lines 28-36 Link Here

(-)src/org/eclipse/jface/internal/databinding/swt/ControlStringListProperty.java (-1 / +4 lines)
28	super(String.class);	28	super(String.class);
29	}	29	}
30		30
31	protected void setList(Object source, List list, ListDiff diff) {	31	protected boolean setList(Object source, List list, ListDiff diff) {
		32	if (source == null)
		33	return false;
32	String[] strings = (String[]) list.toArray(new String[list.size()]);	34	String[] strings = (String[]) list.toArray(new String[list.size()]);
33	doSetStringList((Control) source, strings);	35	doSetStringList((Control) source, strings);
		36	return true;
34	}	37	}
35		38
36	abstract void doSetStringList(Control control, String[] list);	39	abstract void doSetStringList(Control control, String[] list);

Lines 32-41 Link Here

(-)src/org/eclipse/jface/internal/databinding/swt/WidgetBooleanValueProperty.java (-1 / +4 lines)
32	return doGetBooleanValue(source) ? Boolean.TRUE : Boolean.FALSE;	32	return doGetBooleanValue(source) ? Boolean.TRUE : Boolean.FALSE;
33	}	33	}
34		34
35	public void setValue(Object source, Object value) {	35	public boolean setValue(Object source, Object value) {
		36	if (source == null)
		37	return false;
36	if (value == null)	38	if (value == null)
37	value = Boolean.FALSE;	39	value = Boolean.FALSE;
38	doSetBooleanValue(source, ((Boolean) value).booleanValue());	40	doSetBooleanValue(source, ((Boolean) value).booleanValue());
		41	return true;
39	}	42	}
40		43
41	abstract boolean doGetBooleanValue(Object source);	44	abstract boolean doGetBooleanValue(Object source);

Lines 30-37 Link Here

(-)src/org/eclipse/jface/internal/databinding/swt/ControlBackgroundProperty.java (-1 / +4 lines)
30	return ((Control) source).getBackground();	30	return ((Control) source).getBackground();
31	}	31	}
32		32
33	public void setValue(Object source, Object value) {	33	public boolean setValue(Object source, Object value) {
		34	if (source == null)
		35	return false;
34	((Control) source).setBackground((Color) value);	36	((Control) source).setBackground((Color) value);
		37	return true;
35	}	38	}
36		39
37	public String toString() {	40	public String toString() {

Lines 32-39 Link Here

(-)src/org/eclipse/jface/internal/databinding/swt/ControlSizeProperty.java (-1 / +4 lines)
32	return ((Control) source).getSize();	32	return ((Control) source).getSize();
33	}	33	}
34		34
35	public void setValue(Object source, Object value) {	35	public boolean setValue(Object source, Object value) {
		36	if (source == null)
		37	return false;
36	((Control) source).setSize((Point) value);	38	((Control) source).setSize((Point) value);
		39	return true;
37	}	40	}
38		41
39	public String toString() {	42	public String toString() {

Lines 28-35 Link Here

(-)src/org/eclipse/jface/internal/databinding/swt/WidgetStringValueProperty.java (-1 / +4 lines)
28	return doGetStringValue(source);	28	return doGetStringValue(source);
29	}	29	}
30		30
31	public void setValue(Object source, Object value) {	31	public boolean setValue(Object source, Object value) {
		32	if (source == null)
		33	return false;
32	doSetStringValue(source, (String) value);	34	doSetStringValue(source, (String) value);
		35	return true;
33	}	36	}
34		37
35	abstract String doGetStringValue(Object source);	38	abstract String doGetStringValue(Object source);

Lines 30-37 Link Here

(-)src/org/eclipse/jface/internal/databinding/swt/ControlFontProperty.java (-1 / +4 lines)
30	return ((Control) source).getFont();	30	return ((Control) source).getFont();
31	}	31	}
32		32
33	public void setValue(Object source, Object value) {	33	public boolean setValue(Object source, Object value) {
		34	if (source == null)
		35	return false;
34	((Control) source).setFont((Font) value);	36	((Control) source).setFont((Font) value);
		37	return true;
35	}	38	}
36		39
37	public String toString() {	40	public String toString() {

Lines 32-39 Link Here

(-)src/org/eclipse/jface/internal/databinding/swt/ControlBoundsProperty.java (-1 / +4 lines)
32	return ((Control) source).getBounds();	32	return ((Control) source).getBounds();
33	}	33	}
34		34
35	public void setValue(Object source, Object value) {	35	public boolean setValue(Object source, Object value) {
		36	if (source == null)
		37	return false;
36	((Control) source).setBounds((Rectangle) value);	38	((Control) source).setBounds((Rectangle) value);
		39	return true;
37	}	40	}
38		41
39	public String toString() {	42	public String toString() {

Lines 30-37 Link Here

(-)src/org/eclipse/jface/internal/databinding/swt/ControlForegroundProperty.java (-1 / +4 lines)
30	return ((Control) source).getForeground();	30	return ((Control) source).getForeground();
31	}	31	}
32		32
33	public void setValue(Object source, Object value) {	33	public boolean setValue(Object source, Object value) {
		34	if (source == null)
		35	return false;
34	((Control) source).setForeground((Color) value);	36	((Control) source).setForeground((Color) value);
		37	return true;
35	}	38	}
36		39
37	public String toString() {	40	public String toString() {

Lines 32-39 Link Here

(-)src/org/eclipse/jface/internal/databinding/swt/ControlLocationProperty.java (-1 / +4 lines)
32	return ((Control) source).getLocation();	32	return ((Control) source).getLocation();
33	}	33	}
34		34
35	public void setValue(Object source, Object value) {	35	public boolean setValue(Object source, Object value) {
		36	if (source == null)
		37	return false;
36	((Control) source).setLocation((Point) value);	38	((Control) source).setLocation((Point) value);
		39	return true;
37	}	40	}
38		41
39	public String toString() {	42	public String toString() {

Lines 32-39 Link Here

(-)src/org/eclipse/jface/internal/databinding/swt/WidgetIntValueProperty.java (-1 / +4 lines)
32	return new Integer(doGetIntValue(source));	32	return new Integer(doGetIntValue(source));
33	}	33	}
34		34
35	public void setValue(Object source, Object value) {	35	public boolean setValue(Object source, Object value) {
		36	if (source == null)
		37	return false;
36	doSetIntValue(source, ((Integer) value).intValue());	38	doSetIntValue(source, ((Integer) value).intValue());
		39	return true;
37	}	40	}
38		41
39	abstract int doGetIntValue(Object source);	42	abstract int doGetIntValue(Object source);

Return to bug 194734

Lines 374-391 Link Here

(-)src/org/eclipse/core/databinding/property/value/ObservableListSimpleValuePropertyObservableList.java (-9 / +29 lines)
374	if (!haveIterated)	374	if (!haveIterated)
375	throw new IllegalStateException();	375	throw new IllegalStateException();
376		376
		377	Object oldValue = cachedValues.get(new IdentityWrapper(
		378	lastMasterElement));
		379
377	boolean wasUpdating = updating;	380	boolean wasUpdating = updating;
		381	boolean changed;
378	updating = true;	382	updating = true;
379	try {	383	try {
380	detailProperty.setValue(lastElement, o);	384	changed = detailProperty.setValue(lastElement, o);
381	} finally {	385	} finally {
382	updating = wasUpdating;	386	updating = wasUpdating;
383	}	387	}
384		388
385	cachedValues.put(new IdentityWrapper(lastMasterElement), o);	389	if (changed) {
386	fireListChange(Diffs.createListDiff(Diffs.createListDiffEntry(	390	Object newValue = detailProperty.getValue(lastElement);
387	lastIndex, false, lastElement), Diffs	391
388	.createListDiffEntry(lastIndex, true, o)));	392	if (!Util.equals(oldValue, newValue)) {
		393	cachedValues.put(
		394	new IdentityWrapper(lastMasterElement), o);
		395	fireListChange(Diffs.createListDiff(Diffs
		396	.createListDiffEntry(lastIndex, false,
		397	lastElement), Diffs
		398	.createListDiffEntry(lastIndex, true, o)));
		399	}
		400	}
389		401
390	lastElement = o;	402	lastElement = o;
391	}	403	}
Lines 402-417 Link Here
402	Object oldValue = detailProperty.getValue(masterElement);	414	Object oldValue = detailProperty.getValue(masterElement);
403		415
404	boolean wasUpdating = updating;	416	boolean wasUpdating = updating;
		417	boolean changed;
405	updating = true;	418	updating = true;
406	try {	419	try {
407	detailProperty.setValue(masterElement, o);	420	changed = detailProperty.setValue(masterElement, o);
408	} finally {	421	} finally {
409	updating = wasUpdating;	422	updating = wasUpdating;
410	}	423	}
411		424
412	cachedValues.put(new IdentityWrapper(masterElement), o);	425	if (changed) {
413	fireListChange(Diffs.createListDiff(Diffs.createListDiffEntry(index,	426	Object newValue = detailProperty.getValue(masterElement);
414	false, oldValue), Diffs.createListDiffEntry(index, true, o)));	427
		428	if (!Util.equals(oldValue, newValue)) {
		429	cachedValues.put(new IdentityWrapper(masterElement), o);
		430	fireListChange(Diffs.createListDiff(Diffs.createListDiffEntry(
		431	index, false, oldValue), Diffs.createListDiffEntry(
		432	index, true, o)));
		433	}
		434	}
415		435
416	return oldValue;	436	return oldValue;
417	}	437	}

Lines 283-300 Link Here

(-)src/org/eclipse/core/databinding/property/value/ObservableMapSimpleValuePropertyObservableMap.java (-6 / +9 lines)
283		283
284	Object oldValue = detailProperty.getValue(source);	284	Object oldValue = detailProperty.getValue(source);
285		285
		286	boolean changed;
286	updating = true;	287	updating = true;
287	try {	288	try {
288	detailProperty.setValue(source, value);	289	changed = detailProperty.setValue(source, value);
289	} finally {	290	} finally {
290	updating = false;	291	updating = false;
291	}	292	}
292		293
293	Object newValue = detailProperty.getValue(source);	294	if (changed) {
294		295	Object newValue = detailProperty.getValue(source);
295	if (!Util.equals(oldValue, newValue)) {	296
296	fireMapChange(Diffs.createMapDiffSingleChange(key, oldValue,	297	if (!Util.equals(oldValue, newValue)) {
297	newValue));	298	fireMapChange(Diffs.createMapDiffSingleChange(key, oldValue,
		299	newValue));
		300	}
298	}	301	}
299		302
300	return oldValue;	303	return oldValue;

Lines 57-63 Link Here

(-)src/org/eclipse/core/databinding/property/set/SimpleSetPropertyObservableSet.java (-51 / +142 lines)
57		57
58	protected void firstListenerAdded() {	58	protected void firstListenerAdded() {
59	if (!isDisposed()) {	59	if (!isDisposed()) {
60	cachedSet = property.getSet(source);	60	cachedSet = getSet();
61		61
62	if (listener == null) {	62	if (listener == null) {
63	listener = property	63	listener = property
Lines 96-102 Link Here
96	}	96	}
97		97
98	protected Set getWrappedSet() {	98	protected Set getWrappedSet() {
99	return property.getSet(source);	99	return getSet();
100	}	100	}
101		101
102	public Object getElementType() {	102	public Object getElementType() {
Lines 105-112 Link Here
105		105
106	// Queries	106	// Queries
107		107
		108	private Set getSet() {
		109	return property.getSet(source);
		110	}
		111
		112	public boolean contains(Object o) {
		113	getterCalled();
		114	return getSet().contains(o);
		115	}
		116
		117	public boolean containsAll(Collection c) {
		118	getterCalled();
		119	return getSet().containsAll(c);
		120	}
		121
108	protected int doGetSize() {	122	protected int doGetSize() {
109	return property.size(source);	123	return getSet().size();
		124	}
		125
		126	public boolean isEmpty() {
		127	getterCalled();
		128	return getSet().isEmpty();
		129	}
		130
		131	public Object[] toArray() {
		132	getterCalled();
		133	return getSet().toArray();
		134	}
		135
		136	public Object[] toArray(Object[] a) {
		137	getterCalled();
		138	return getSet().toArray(a);
110	}	139	}
111		140
112	// Single change operations	141	// Single change operations
Lines 114-135 Link Here
114	public boolean add(Object o) {	143	public boolean add(Object o) {
115	checkRealm();	144	checkRealm();
116		145
117	boolean changed;	146	Set set = new HashSet(getSet());
		147	if (!set.add(o))
		148	return false;
		149
		150	SetDiff diff = Diffs.createSetDiff(Collections.singleton(o),
		151	Collections.EMPTY_SET);
118		152
119	boolean wasUpdating = updating;	153	boolean wasUpdating = updating;
		154	boolean changed;
120	updating = true;	155	updating = true;
121	try {	156	try {
122	changed = property.add(source, o);	157	changed = property.setSet(source, set, diff);
123	modCount++;	158	modCount++;
124	} finally {	159	} finally {
125	updating = wasUpdating;	160	updating = wasUpdating;
126	}	161	}
127		162
128	cachedSet = property.getSet(source);	163	if (changed) {
129		164	cachedSet = getSet();
130	if (changed)	165	fireSetChange(diff);
131	fireSetChange(Diffs.createSetDiff(Collections.singleton(o),	166	}
132	Collections.EMPTY_SET));
133		167
134	return changed;	168	return changed;
135	}	169	}
Lines 138-156 Link Here
138	getterCalled();	172	getterCalled();
139	return new Iterator() {	173	return new Iterator() {
140	int expectedModCount = modCount;	174	int expectedModCount = modCount;
141	Iterator delegate = new HashSet(property.getSet(source)).iterator();	175	Set set = new HashSet(getSet());
		176	Iterator iterator = set.iterator();
142	Object last = null;	177	Object last = null;
143		178
144	public boolean hasNext() {	179	public boolean hasNext() {
145	getterCalled();	180	getterCalled();
146	checkForComodification();	181	checkForComodification();
147	return delegate.hasNext();	182	return iterator.hasNext();
148	}	183	}
149		184
150	public Object next() {	185	public Object next() {
151	getterCalled();	186	getterCalled();
152	checkForComodification();	187	checkForComodification();
153	last = delegate.next();	188	last = iterator.next();
154	return last;	189	return last;
155	}	190	}
156		191
Lines 158-181 Link Here
158	checkRealm();	193	checkRealm();
159	checkForComodification();	194	checkForComodification();
160		195
161	delegate.remove(); // stay in sync	196	iterator.remove(); // stay in sync
		197	SetDiff diff = Diffs.createSetDiff(Collections.EMPTY_SET,
		198	Collections.singleton(last));
162		199
163	boolean wasUpdating = updating;	200	boolean wasUpdating = updating;
		201	boolean changed;
164	updating = true;	202	updating = true;
165	try {	203	try {
166	property.remove(source, last);	204	changed = property.setSet(source, set, diff);
167	modCount++;	205	modCount++;
168	} finally {	206	} finally {
169	updating = wasUpdating;	207	updating = wasUpdating;
170	}	208	}
171		209
172	cachedSet = property.getSet(source);	210	if (changed) {
		211	cachedSet = getSet();
		212	fireSetChange(diff);
173		213
174	fireSetChange(Diffs.createSetDiff(Collections.EMPTY_SET,	214	last = null;
175	Collections.singleton(last)));	215	expectedModCount = modCount;
176		216	}
177	last = null;
178	expectedModCount = modCount;
179	}	217	}
180		218
181	private void checkForComodification() {	219	private void checkForComodification() {
Lines 188-207 Link Here
188	public boolean remove(Object o) {	226	public boolean remove(Object o) {
189	getterCalled();	227	getterCalled();
190		228
191	boolean changed;	229	Set set = new HashSet(getSet());
		230	if (!set.remove(o))
		231	return false;
		232
		233	SetDiff diff = Diffs.createSetDiff(Collections.EMPTY_SET, Collections
		234	.singleton(o));
192		235
193	boolean wasUpdating = updating;	236	boolean wasUpdating = updating;
		237	boolean changed;
194	updating = true;	238	updating = true;
195	try {	239	try {
196	changed = property.remove(source, o);	240	changed = property.setSet(source, set, diff);
197	modCount++;	241	modCount++;
198	} finally {	242	} finally {
199	updating = wasUpdating;	243	updating = wasUpdating;
200	}	244	}
201		245
202	cachedSet = property.getSet(source);	246	if (changed) {
203	fireSetChange(Diffs.createSetDiff(Collections.EMPTY_SET, Collections	247	cachedSet = property.getSet(source);
204	.singleton(o)));	248	fireSetChange(diff);
		249	}
205		250
206	return changed;	251	return changed;
207	}	252	}
Lines 214-269 Link Here
214	if (c.isEmpty())	259	if (c.isEmpty())
215	return false;	260	return false;
216		261
		262	Set set = new HashSet(getSet());
		263
217	Set additions = new HashSet(c);	264	Set additions = new HashSet(c);
218	additions.removeAll(property.getSet(source));	265	for (Iterator it = c.iterator(); it.hasNext();) {
		266	Object element = it.next();
		267	if (set.add(element))
		268	additions.add(element);
		269	}
		270
219	if (additions.isEmpty())	271	if (additions.isEmpty())
220	return false;	272	return false;
221		273
		274	SetDiff diff = Diffs.createSetDiff(additions, Collections.EMPTY_SET);
		275
222	boolean wasUpdating = updating;	276	boolean wasUpdating = updating;
		277	boolean changed;
223	updating = true;	278	updating = true;
224	try {	279	try {
225	property.addAll(source, c);	280	changed = property.setSet(source, set, diff);
226	modCount++;	281	modCount++;
227	} finally {	282	} finally {
228	updating = wasUpdating;	283	updating = wasUpdating;
229	}	284	}
230		285
231	cachedSet = property.getSet(source);	286	if (changed) {
232	fireSetChange(Diffs.createSetDiff(additions, Collections.EMPTY_SET));	287	cachedSet = property.getSet(source);
		288	fireSetChange(diff);
		289	}
233		290
234	return true;	291	return changed;
235	}	292	}
236		293
237	public boolean removeAll(Collection c) {	294	public boolean removeAll(Collection c) {
238	getterCalled();	295	getterCalled();
239		296
240	if (property.isEmpty(source) \|\| c.isEmpty())	297	Set set = getSet();
		298	if (set.isEmpty())
		299	return false;
		300	if (c.isEmpty())
241	return false;	301	return false;
242		302
		303	set = new HashSet(set);
		304
243	Set removals = new HashSet(c);	305	Set removals = new HashSet(c);
244	removals.retainAll(property.getSet(source));	306	for (Iterator it = c.iterator(); it.hasNext();) {
		307	Object element = it.next();
		308	if (set.remove(element))
		309	removals.add(element);
		310	}
		311
245	if (removals.isEmpty())	312	if (removals.isEmpty())
246	return false;	313	return false;
247		314
		315	SetDiff diff = Diffs.createSetDiff(Collections.EMPTY_SET, removals);
		316
248	boolean wasUpdating = updating;	317	boolean wasUpdating = updating;
		318	boolean changed;
249	updating = true;	319	updating = true;
250	try {	320	try {
251	property.removeAll(source, c);	321	changed = property.setSet(source, set, diff);
252	modCount++;	322	modCount++;
253	} finally {	323	} finally {
254	updating = wasUpdating;	324	updating = wasUpdating;
255	}	325	}
256		326
257	cachedSet = property.getSet(source);	327	if (changed) {
258	fireSetChange(Diffs.createSetDiff(Collections.EMPTY_SET, removals));	328	cachedSet = property.getSet(source);
		329	fireSetChange(diff);
		330	}
259		331
260	return true;	332	return changed;
261	}	333	}
262		334
263	public boolean retainAll(Collection c) {	335	public boolean retainAll(Collection c) {
264	getterCalled();	336	getterCalled();
265		337
266	if (property.isEmpty(source))	338	Set set = getSet();
		339	if (set.isEmpty())
267	return false;	340	return false;
268		341
269	if (c.isEmpty()) {	342	if (c.isEmpty()) {
Lines 271-325 Link Here
271	return true;	344	return true;
272	}	345	}
273		346
274	Set removals = new HashSet(property.getSet(source));	347	set = new HashSet(set);
275	removals.removeAll(c);	348
		349	Set removals = new HashSet();
		350	for (Iterator it = set.iterator(); it.hasNext();) {
		351	Object element = it.next();
		352	if (!c.contains(element)) {
		353	it.remove();
		354	removals.add(element);
		355	}
		356	}
		357
276	if (removals.isEmpty())	358	if (removals.isEmpty())
277	return false;	359	return false;
278		360
		361	SetDiff diff = Diffs.createSetDiff(Collections.EMPTY_SET, removals);
		362
279	boolean wasUpdating = updating;	363	boolean wasUpdating = updating;
		364	boolean changed;
280	updating = true;	365	updating = true;
281	try {	366	try {
282	property.retainAll(source, c);	367	changed = property.setSet(source, set, diff);
283	modCount++;	368	modCount++;
284	} finally {	369	} finally {
285	updating = wasUpdating;	370	updating = wasUpdating;
286	}	371	}
287		372
288	cachedSet = property.getSet(source);	373	if (changed) {
289	fireSetChange(Diffs.createSetDiff(Collections.EMPTY_SET, removals));	374	cachedSet = property.getSet(source);
		375	fireSetChange(diff);
		376	}
290		377
291	return true;	378	return changed;
292	}	379	}
293		380
294	public void clear() {	381	public void clear() {
295	getterCalled();	382	getterCalled();
296		383
297	if (property.isEmpty(source))	384	Set set = getSet();
		385	if (set.isEmpty())
298	return;	386	return;
299		387
300	Set removals = new HashSet(property.getSet(source));	388	SetDiff diff = Diffs.createSetDiff(Collections.EMPTY_SET, set);
301		389
302	boolean wasUpdating = updating;	390	boolean wasUpdating = updating;
		391	boolean changed;
303	updating = true;	392	updating = true;
304	try {	393	try {
305	property.clear(source);	394	changed = property.setSet(source, Collections.EMPTY_SET, diff);
306	modCount++;	395	modCount++;
307	} finally {	396	} finally {
308	updating = wasUpdating;	397	updating = wasUpdating;
309	}	398	}
310		399
311	cachedSet = property.getSet(source);	400	if (changed) {
312	fireSetChange(Diffs.createSetDiff(Collections.EMPTY_SET, removals));	401	cachedSet = property.getSet(source);
		402	fireSetChange(diff);
		403	}
313	}	404	}
314		405
315	public boolean equals(Object o) {	406	public boolean equals(Object o) {
316	getterCalled();	407	getterCalled();
317	return property.equals(source, o);	408	return getSet().equals(o);
318	}	409	}
319		410
320	public int hashCode() {	411	public int hashCode() {
321	getterCalled();	412	getterCalled();
322	return property.hashCode(source);	413	return getSet().hashCode();
323	}	414	}
324		415
325	public Object getObserved() {	416	public Object getObserved() {

Lines 106-124 Link Here

(-)src/org/eclipse/core/databinding/property/value/ObservableSetSimpleValuePropertyObservableMap.java (-7 / +12 lines)
106	protected Object doPut(Object key, Object value) {	106	protected Object doPut(Object key, Object value) {
107	Object oldValue = detailProperty.getValue(key);	107	Object oldValue = detailProperty.getValue(key);
108		108
		109	boolean changed;
109	updating = true;	110	updating = true;
110	try {	111	try {
111	detailProperty.setValue(key, value);	112	changed = detailProperty.setValue(key, value);
112	} finally {	113	} finally {
113	updating = false;	114	updating = false;
114	}	115	}
115	Object newValue = detailProperty.getValue(key);	116
116	cachedValues.put(key, newValue);	117	if (changed) {
117		118	Object newValue = detailProperty.getValue(key);
118	if (oldValue != newValue) {	119	cachedValues.put(key, newValue);
119	fireMapChange(Diffs.createMapDiffSingleChange(key, oldValue,	120
120	newValue));	121	if (oldValue != newValue) {
		122	fireMapChange(Diffs.createMapDiffSingleChange(key, oldValue,
		123	newValue));
		124	}
121	}	125	}
		126
122	return oldValue;	127	return oldValue;
123	}	128	}
124		129

Lines 105-120 Link Here

(-)src/org/eclipse/core/databinding/property/value/SimpleValuePropertyObservableValue.java (-4 / +7 lines)
105	if (hasListeners()) {	105	if (hasListeners()) {
106	Object oldValue = cachedValue;	106	Object oldValue = cachedValue;
107		107
		108	boolean changed;
108	updating = true;	109	updating = true;
109	try {	110	try {
110	property.setValue(source, value);	111	changed = property.setValue(source, value);
111	} finally {	112	} finally {
112	updating = false;	113	updating = false;
113	}	114	}
114		115
115	Object newValue = cachedValue = property.getValue(source);	116	if (changed) {
116	if (hasListeners() && !Util.equals(oldValue, newValue)) {	117	Object newValue = cachedValue = property.getValue(source);
117	fireValueChange(Diffs.createValueDiff(oldValue, newValue));	118	if (hasListeners() && !Util.equals(oldValue, newValue)) {
		119	fireValueChange(Diffs.createValueDiff(oldValue, newValue));
		120	}
118	}	121	}
119	} else {	122	} else {
120	property.setValue(source, value);	123	property.setValue(source, value);

Lines 63-73 Link Here

(-)src/org/eclipse/core/internal/databinding/beans/BeanSetProperty.java (-5 / +6 lines)
63	return (Set) propertyValue;	63	return (Set) propertyValue;
64	}	64	}
65		65
66	protected void setSet(Object source, Set set, SetDiff diff) {	66	protected boolean setSet(Object source, Set set, SetDiff diff) {
67	if (source != null) {	67	if (source == null)
68	BeanPropertyHelper.writeProperty(source, propertyDescriptor,	68	return false;
69	convertSetToBeanPropertyType(set));	69	BeanPropertyHelper.writeProperty(source, propertyDescriptor,
70	}	70	convertSetToBeanPropertyType(set));
		71	return true;
71	}	72	}
72		73
73	private Object convertSetToBeanPropertyType(Set set) {	74	private Object convertSetToBeanPropertyType(Set set) {

Lines 64-74 Link Here

(-)src/org/eclipse/core/internal/databinding/beans/BeanListProperty.java (-5 / +6 lines)
64	return (List) propertyValue;	64	return (List) propertyValue;
65	}	65	}
66		66
67	protected void setList(Object source, List list, ListDiff diff) {	67	protected boolean setList(Object source, List list, ListDiff diff) {
68	if (source != null) {	68	if (source == null)
69	BeanPropertyHelper.writeProperty(source, propertyDescriptor,	69	return false;
70	convertListToBeanPropertyType(list));	70	BeanPropertyHelper.writeProperty(source, propertyDescriptor,
71	}	71	convertListToBeanPropertyType(list));
		72	return true;
72	}	73	}
73		74
74	private Object convertListToBeanPropertyType(List list) {	75	private Object convertListToBeanPropertyType(List list) {