Attachment #122864 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

Lines 13-19 Link Here

(-)src/org/eclipse/jface/internal/databinding/viewers/ViewerInputProperty.java (-3 / +3 lines)
13	package org.eclipse.jface.internal.databinding.viewers;	13	package org.eclipse.jface.internal.databinding.viewers;
14		14
15	import org.eclipse.core.databinding.property.INativePropertyListener;	15	import org.eclipse.core.databinding.property.INativePropertyListener;
16	import org.eclipse.core.databinding.property.IPropertyChangeListener;	16	import org.eclipse.core.databinding.property.ISimplePropertyListener;
17	import org.eclipse.jface.viewers.Viewer;	17	import org.eclipse.jface.viewers.Viewer;
18		18
19	/**	19	/**
Lines 33-40 Link Here
33	((Viewer) source).setInput(value);	33	((Viewer) source).setInput(value);
34	}	34	}
35		35
36	protected INativePropertyListener adaptListener(	36	public INativePropertyListener adaptListener(
37	IPropertyChangeListener listener) {	37	ISimplePropertyListener listener) {
38	return null;	38	return null;
39	}	39	}
40		40




package org.eclipse.jface.internal.databinding.viewers;

import org.eclipse.core.databinding.property.INativePropertyListener;
import org.eclipse.core.databinding.property.ISimplePropertyListener;
import org.eclipse.core.databinding.property.SimplePropertyEvent;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.ISelectionProvider;

	}

	public INativePropertyListener adaptListener(
			ISimplePropertyListener listener) {
		return new SelectionChangedListener(listener);
	}



	private class SelectionChangedListener implements INativePropertyListener,
			ISelectionChangedListener {
		private ISimplePropertyListener listener;

		private SelectionChangedListener(ISimplePropertyListener listener) {
			this.listener = listener;
		}

		public void selectionChanged(SelectionChangedEvent event) {
			listener.handlePropertyChange(new SimplePropertyEvent(event
					.getSource(),
					SelectionProviderSingleSelectionProperty.this, null));
		}

Lines 18-24 Link Here

(-)src/org/eclipse/jface/internal/databinding/viewers/StructuredViewerFiltersProperty.java (-2 / +2 lines)
18		18
19	import org.eclipse.core.databinding.observable.set.SetDiff;	19	import org.eclipse.core.databinding.observable.set.SetDiff;
20	import org.eclipse.core.databinding.property.INativePropertyListener;	20	import org.eclipse.core.databinding.property.INativePropertyListener;
21	import org.eclipse.core.databinding.property.IPropertyChangeListener;	21	import org.eclipse.core.databinding.property.ISimplePropertyListener;
22	import org.eclipse.jface.viewers.StructuredViewer;	22	import org.eclipse.jface.viewers.StructuredViewer;
23	import org.eclipse.jface.viewers.ViewerFilter;	23	import org.eclipse.jface.viewers.ViewerFilter;
24		24
Lines 48-54 Link Here
48	}	48	}
49		49
50	public INativePropertyListener adaptListener(	50	public INativePropertyListener adaptListener(
51	IPropertyChangeListener listener) {	51	ISimplePropertyListener listener) {
52	return null;	52	return null;
53	}	53	}
54		54




import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.observable.set.SetDiff;
import org.eclipse.core.databinding.property.INativePropertyListener;
import org.eclipse.core.databinding.property.ISimplePropertyListener;
import org.eclipse.core.databinding.property.SimplePropertyEvent;
import org.eclipse.jface.viewers.CheckStateChangedEvent;
import org.eclipse.jface.viewers.ICheckStateListener;
import org.eclipse.jface.viewers.ICheckable;

	}

	public INativePropertyListener adaptListener(
			ISimplePropertyListener listener) {
		return new CheckStateListener(listener);
	}



	private class CheckStateListener implements INativePropertyListener,
			ICheckStateListener {
		private ISimplePropertyListener listener;

		private CheckStateListener(ISimplePropertyListener listener) {
			this.listener = listener;
		}


			Set additions = checked ? elementSet : Collections.EMPTY_SET;
			Set removals = checked ? Collections.EMPTY_SET : elementSet;
			SetDiff diff = Diffs.createSetDiff(additions, removals);
			listener.handlePropertyChange(new SimplePropertyEvent(event
					.getSource(), CheckableCheckedElementsProperty.this, diff));
		}
	}





import org.eclipse.core.databinding.observable.list.ListDiff;
import org.eclipse.core.databinding.property.INativePropertyListener;
import org.eclipse.core.databinding.property.ISimplePropertyListener;
import org.eclipse.core.databinding.property.SimplePropertyEvent;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.ISelectionProvider;

	}

	public INativePropertyListener adaptListener(
			ISimplePropertyListener listener) {
		return new SelectionChangedListener(listener);
	}



	private class SelectionChangedListener implements INativePropertyListener,
			ISelectionChangedListener {
		private ISimplePropertyListener listener;

		private SelectionChangedListener(ISimplePropertyListener listener) {
			this.listener = listener;
		}

		public void selectionChanged(SelectionChangedEvent event) {
			listener.handlePropertyChange(new SimplePropertyEvent(event
					.getSource(),
					SelectionProviderMultipleSelectionProperty.this, null));
		}

Lines 17-23 Link Here

(-)src/org/eclipse/jface/internal/databinding/swt/ControlStringListProperty.java (-2 / +2 lines)
17		17
18	import org.eclipse.core.databinding.observable.list.ListDiff;	18	import org.eclipse.core.databinding.observable.list.ListDiff;
19	import org.eclipse.core.databinding.property.INativePropertyListener;	19	import org.eclipse.core.databinding.property.INativePropertyListener;
20	import org.eclipse.core.databinding.property.IPropertyChangeListener;	20	import org.eclipse.core.databinding.property.ISimplePropertyListener;
21	import org.eclipse.swt.widgets.Control;	21	import org.eclipse.swt.widgets.Control;
22		22
23	/**	23	/**
Lines 44-50 Link Here
44	abstract String[] doGetStringList(Control control);	44	abstract String[] doGetStringList(Control control);
45		45
46	public INativePropertyListener adaptListener(	46	public INativePropertyListener adaptListener(
47	IPropertyChangeListener listener) {	47	ISimplePropertyListener listener) {
48	return null;	48	return null;
49	}	49	}
50		50




import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.core.databinding.property.INativePropertyListener;
import org.eclipse.core.databinding.property.ISimplePropertyListener;
import org.eclipse.core.databinding.property.SimplePropertyEvent;
import org.eclipse.core.databinding.property.value.SimpleValueProperty;
import org.eclipse.jface.databinding.swt.ISWTObservableValue;
import org.eclipse.jface.databinding.swt.SWTObservables;

		this.events = events;
	}

	public INativePropertyListener adaptListener(
			ISimplePropertyListener listener) {
		return new WidgetListener(listener);
	}


	}

	private class WidgetListener implements INativePropertyListener, Listener {
		private final ISimplePropertyListener listener;

		protected WidgetListener(ISimplePropertyListener listener) {
			this.listener = listener;
		}

		public void handleEvent(Event event) {
			listener.handlePropertyChange(new SimplePropertyEvent(event.widget,
					WidgetValueProperty.this, null));
		}
	}




import org.eclipse.core.databinding.observable.set.SetDiff;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.core.databinding.property.INativePropertyListener;
import org.eclipse.core.databinding.property.ISimplePropertyListener;
import org.eclipse.core.databinding.property.SimplePropertyEvent;
import org.eclipse.core.databinding.property.set.DelegatingSetProperty;
import org.eclipse.core.databinding.property.set.ISetProperty;
import org.eclipse.core.databinding.property.set.SimpleSetProperty;

			}
		}

		public INativePropertyListener adaptListener(
				final ISimplePropertyListener listener) {
			return new Listener(listener);
		}

		private class Listener implements INativePropertyListener,
				PropertyChangeListener {
			private final ISimplePropertyListener listener;

			Listener(ISimplePropertyListener listener) {
				this.listener = listener;
			}

			public void propertyChange(java.beans.PropertyChangeEvent evt) {
				listener.handlePropertyChange(new SimplePropertyEvent(evt
						.getSource(), ContactGroupContactsProperty.this, null));
			}
		}




import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.observable.set.SetDiff;
import org.eclipse.core.databinding.property.INativePropertyListener;
import org.eclipse.core.databinding.property.ISimplePropertyListener;
import org.eclipse.core.databinding.property.SimplePropertyEvent;
import org.eclipse.core.databinding.property.set.SimpleSetProperty;

/**

	}

	public INativePropertyListener adaptListener(
			final ISimplePropertyListener listener) {
		return new Listener(listener);
	}

	private class Listener implements INativePropertyListener,
			PropertyChangeListener {
		private final ISimplePropertyListener listener;

		private Listener(ISimplePropertyListener listener) {
			this.listener = listener;
		}


				diff = null;
			}
			if (propertyDescriptor.getName().equals(evt.getPropertyName())) {
				listener.handlePropertyChange(new SimplePropertyEvent(evt
						.getSource(), BeanSetProperty.this, diff));
			}
		}

Lines 15-21 Link Here

(-)src/org/eclipse/core/internal/databinding/beans/PojoValueProperty.java (-2 / +2 lines)
15	import java.beans.PropertyDescriptor;	15	import java.beans.PropertyDescriptor;
16		16
17	import org.eclipse.core.databinding.property.INativePropertyListener;	17	import org.eclipse.core.databinding.property.INativePropertyListener;
18	import org.eclipse.core.databinding.property.IPropertyChangeListener;	18	import org.eclipse.core.databinding.property.ISimplePropertyListener;
19	import org.eclipse.core.databinding.property.value.SimpleValueProperty;	19	import org.eclipse.core.databinding.property.value.SimpleValueProperty;
20		20
21	/**	21	/**
Lines 52-58 Link Here
52	}	52	}
53		53
54	public INativePropertyListener adaptListener(	54	public INativePropertyListener adaptListener(
55	IPropertyChangeListener listener) {	55	ISimplePropertyListener listener) {
56	return null;	56	return null;
57	}	57	}
58		58

Lines 21-27 Link Here

(-)src/org/eclipse/core/internal/databinding/beans/PojoSetProperty.java (-2 / +2 lines)
21		21
22	import org.eclipse.core.databinding.observable.set.SetDiff;	22	import org.eclipse.core.databinding.observable.set.SetDiff;
23	import org.eclipse.core.databinding.property.INativePropertyListener;	23	import org.eclipse.core.databinding.property.INativePropertyListener;
24	import org.eclipse.core.databinding.property.IPropertyChangeListener;	24	import org.eclipse.core.databinding.property.ISimplePropertyListener;
25	import org.eclipse.core.databinding.property.set.SimpleSetProperty;	25	import org.eclipse.core.databinding.property.set.SimpleSetProperty;
26		26
27	/**	27	/**
Lines 79-85 Link Here
79	}	79	}
80		80
81	public INativePropertyListener adaptListener(	81	public INativePropertyListener adaptListener(
82	IPropertyChangeListener listener) {	82	ISimplePropertyListener listener) {
83	return null;	83	return null;
84	}	84	}
85		85




import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.observable.list.ListDiff;
import org.eclipse.core.databinding.property.INativePropertyListener;
import org.eclipse.core.databinding.property.ISimplePropertyListener;
import org.eclipse.core.databinding.property.SimplePropertyEvent;
import org.eclipse.core.databinding.property.list.SimpleListProperty;

/**

		return propertyValue;
	}

	public INativePropertyListener adaptListener(
			final ISimplePropertyListener listener) {
		return new Listener(listener);
	}

	private class Listener implements INativePropertyListener,
			PropertyChangeListener {
		private final ISimplePropertyListener listener;

		private Listener(ISimplePropertyListener listener) {
			this.listener = listener;
		}


				} else {
					diff = null;
				}
				listener.handlePropertyChange(new SimplePropertyEvent(evt
						.getSource(), BeanListProperty.this, diff));
			}
		}

Lines 18-24 Link Here

(-)src/org/eclipse/core/internal/databinding/beans/PojoMapProperty.java (-2 / +2 lines)
18		18
19	import org.eclipse.core.databinding.observable.map.MapDiff;	19	import org.eclipse.core.databinding.observable.map.MapDiff;
20	import org.eclipse.core.databinding.property.INativePropertyListener;	20	import org.eclipse.core.databinding.property.INativePropertyListener;
21	import org.eclipse.core.databinding.property.IPropertyChangeListener;	21	import org.eclipse.core.databinding.property.ISimplePropertyListener;
22	import org.eclipse.core.databinding.property.map.SimpleMapProperty;	22	import org.eclipse.core.databinding.property.map.SimpleMapProperty;
23		23
24	/**	24	/**
Lines 66-72 Link Here
66	}	66	}
67		67
68	public INativePropertyListener adaptListener(	68	public INativePropertyListener adaptListener(
69	IPropertyChangeListener listener) {	69	ISimplePropertyListener listener) {
70	return null;	70	return null;
71	}	71	}
72		72




import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.observable.map.MapDiff;
import org.eclipse.core.databinding.property.INativePropertyListener;
import org.eclipse.core.databinding.property.ISimplePropertyListener;
import org.eclipse.core.databinding.property.SimplePropertyEvent;
import org.eclipse.core.databinding.property.map.SimpleMapProperty;

/**

	}

	public INativePropertyListener adaptListener(
			final ISimplePropertyListener listener) {
		return new Listener(listener);
	}

	private class Listener implements INativePropertyListener,
			PropertyChangeListener {
		private final ISimplePropertyListener listener;

		private Listener(ISimplePropertyListener listener) {
			this.listener = listener;
		}


				} else {
					diff = null;
				}
				listener.handlePropertyChange(new SimplePropertyEvent(evt
						.getSource(), BeanMapProperty.this, diff));
			}
		}

Lines 20-26 Link Here

(-)src/org/eclipse/core/internal/databinding/beans/PojoListProperty.java (-2 / +2 lines)
20		20
21	import org.eclipse.core.databinding.observable.list.ListDiff;	21	import org.eclipse.core.databinding.observable.list.ListDiff;
22	import org.eclipse.core.databinding.property.INativePropertyListener;	22	import org.eclipse.core.databinding.property.INativePropertyListener;
23	import org.eclipse.core.databinding.property.IPropertyChangeListener;	23	import org.eclipse.core.databinding.property.ISimplePropertyListener;
24	import org.eclipse.core.databinding.property.list.SimpleListProperty;	24	import org.eclipse.core.databinding.property.list.SimpleListProperty;
25		25
26	/**	26	/**
Lines 79-85 Link Here
79	}	79	}
80		80
81	public INativePropertyListener adaptListener(	81	public INativePropertyListener adaptListener(
82	IPropertyChangeListener listener) {	82	ISimplePropertyListener listener) {
83	return null;	83	return null;
84	}	84	}
85		85




import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.observable.value.ValueDiff;
import org.eclipse.core.databinding.property.INativePropertyListener;
import org.eclipse.core.databinding.property.ISimplePropertyListener;
import org.eclipse.core.databinding.property.SimplePropertyEvent;
import org.eclipse.core.databinding.property.value.SimpleValueProperty;

/**

	}

	public INativePropertyListener adaptListener(
			final ISimplePropertyListener listener) {
		return new Listener(listener);
	}

	private class Listener implements INativePropertyListener,
			PropertyChangeListener {
		private final ISimplePropertyListener listener;

		private Listener(ISimplePropertyListener listener) {
			this.listener = listener;
		}


				} else {
					diff = null;
				}
				listener.handlePropertyChange(new SimplePropertyEvent(evt
						.getSource(), BeanValueProperty.this, diff));
			}
		}




import java.util.Collections;
import java.util.Map;

import org.eclipse.core.databinding.observable.IDiff;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.map.IObservableMap;
import org.eclipse.core.databinding.observable.map.MapDiff;
import org.eclipse.core.databinding.property.INativePropertyListener;
import org.eclipse.core.databinding.property.ISimplePropertyListener;
import org.eclipse.core.internal.databinding.property.map.SimpleMapPropertyObservableMap;

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

 * <li> {@link #getValueType()}
 * <li> {@link #doGetMap(Object)}
 * <li> {@link #doSetMap(Object, Map, MapDiff)}
 * <li> {@link #adaptListener(ISimplePropertyListener)}
 * <li> {@link #doAddListener(Object, INativePropertyListener)}
 * <li> {@link #doRemoveListener(Object, INativePropertyListener)}
 * </ul>

 * @since 1.2
 */
public abstract class SimpleMapProperty extends MapProperty implements
		ISimpleMapProperty {
	public IObservableMap observe(Realm realm, Object source) {
		return new SimpleMapPropertyObservableMap(realm, source, this);
	}

	// Accessors

	public final Object get(Object source) {
	 * Returns an unmodifiable Map with the current contents of the source's map
	 * property.
	 * 
	 * @param source
	 *            the property source
	 * @return a Map with the current contents of the source's map property
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected final Map getMap(Object source) {
		if (source == null)
			return Collections.EMPTY_MAP;
		return Collections.unmodifiableMap(doGetMap(source));


	// Mutators

	public final void set(Object source, Object value, IDiff diff) {
		Map map = (Map) value;
		MapDiff mapDiff = (MapDiff) diff;
		if (source != null && !mapDiff.isEmpty())
			doSetMap(source, map, mapDiff);
	 * @param map
	 *            the new map
	 * @param diff
	 *            a diff describing the change
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected final void setMap(Object source, Map map, MapDiff diff) {
		if (source != null && !diff.isEmpty())
			doSetMap(source, map, diff);
	}

	/**

	 *             ISetProperty or IMapProperty) depending on the property.
	 * @noreference This method is not intended to be referenced by clients.
	 */
	public abstract INativePropertyListener adaptListener(
			ISimplePropertyListener listener);

	/**
	 * 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(ISimplePropertyListener)}
	 * returns null), this method does nothing.
	 * 
	 * @param source
	 *            the property source
	 * @param listener
	 *            a listener obtained from calling
	 *            {@link #adaptListener(ISimplePropertyListener)} .
	 * @noreference This method is not intended to be referenced by clients.
	 */
	public final void addListener(Object source,
			INativePropertyListener listener) {
		if (source != null)
			doAddListener(source, listener);

	/**
	 * 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(ISimplePropertyListener)}
	 * returns null), this method does nothing.
	 * 
	 * @param source
	 *            the property source
	 * @param listener
	 *            a listener obtained from calling
	 *            {@link #adaptListener(ISimplePropertyListener)} .
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected abstract void doAddListener(Object source,

	/**
	 * 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(ISimplePropertyListener)}
	 * returns null), this method does nothing.
	 * 
	 * @param source
	 *            the property source
	 * @param listener
	 *            a listener obtained from calling
	 *            {@link #adaptListener(ISimplePropertyListener)} .
	 * @noreference This method is not intended to be referenced by clients.
	 */
	public final void removeListener(Object source,
			INativePropertyListener listener) {
		if (source != null)
			doRemoveListener(source, listener);

	/**
	 * 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(ISimplePropertyListener)}
	 * returns null), this method does nothing.
	 * 
	 * @param source
	 *            the property source
	 * @param listener
	 *            a listener obtained from calling
	 *            {@link #adaptListener(ISimplePropertyListener)} .
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected abstract void doRemoveListener(Object source,

Lines 18-24 Link Here

(-)src/org/eclipse/core/databinding/property/map/DelegatingMapProperty.java (-4 / +22 lines)
18	import org.eclipse.core.databinding.observable.map.IObservableMap;	18	import org.eclipse.core.databinding.observable.map.IObservableMap;
19	import org.eclipse.core.databinding.observable.map.MapDiff;	19	import org.eclipse.core.databinding.observable.map.MapDiff;
20	import org.eclipse.core.databinding.property.INativePropertyListener;	20	import org.eclipse.core.databinding.property.INativePropertyListener;
21	import org.eclipse.core.databinding.property.IPropertyChangeListener;	21	import org.eclipse.core.databinding.property.ISimplePropertyListener;
22		22
23	/**	23	/**
24	* @since 1.2	24	* @since 1.2
Lines 38-44 Link Here
38	this.valueType = valueType;	38	this.valueType = valueType;
39	}	39	}
40		40
41	protected final IMapProperty getDelegate(Object source) {	41	/**
		42	* Returns the property to delegate to for the specified source object.
		43	* Repeated calls to this method with the same source object returns the
		44	* same delegate instance.
		45	*
		46	* @param source
		47	* the property source (may be null)
		48	* @return the property to delegate to for the specified source object.
		49	*/
		50	public final IMapProperty getDelegate(Object source) {
42	if (source == null)	51	if (source == null)
43	return null;	52	return null;
44	IMapProperty delegate = doGetDelegate(source);	53	IMapProperty delegate = doGetDelegate(source);
Lines 47-52 Link Here
47	return delegate;	56	return delegate;
48	}	57	}
49		58
		59	/**
		60	* Returns the property to delegate to for the specified source object.
		61	* Implementers must ensure that repeated calls to this method with the same
		62	* source object returns the same delegate instance.
		63	*
		64	* @param source
		65	* the property source
		66	* @return the property to delegate to for the specified source object.
		67	*/
50	protected abstract IMapProperty doGetDelegate(Object source);	68	protected abstract IMapProperty doGetDelegate(Object source);
51		69
52	public Object getKeyType() {	70	public Object getKeyType() {
Lines 69-76 Link Here
69	protected void doSetMap(Object source, Map map, MapDiff diff) {	87	protected void doSetMap(Object source, Map map, MapDiff diff) {
70	}	88	}
71		89
72	protected INativePropertyListener adaptListener(	90	public INativePropertyListener adaptListener(
73	IPropertyChangeListener listener) {	91	ISimplePropertyListener listener) {
74	return null;	92	return null;
75	}	93	}
76		94




/*******************************************************************************
 * Copyright (c) 2008 Matthew Hall and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Matthew Hall - initial API and implementation (bug 194734)
 ******************************************************************************/

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

import java.util.AbstractSet;
import java.util.Collection;
import java.util.Collections;
import java.util.ConcurrentModificationException;
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.ObservableTracker;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.map.AbstractObservableMap;
import org.eclipse.core.databinding.observable.map.MapDiff;
import org.eclipse.core.databinding.property.INativePropertyListener;
import org.eclipse.core.databinding.property.IProperty;
import org.eclipse.core.databinding.property.IPropertyChangeListener;
import org.eclipse.core.databinding.property.IPropertyObservable;
import org.eclipse.core.databinding.property.PropertyChangeEvent;

/**
 * @since 1.2
 */
class SimpleMapPropertyObservableMap extends AbstractObservableMap implements
		IPropertyObservable {
	private Object source;
	private SimpleMapProperty property;

	private volatile boolean updating = false;

	private volatile int modCount = 0;

	private INativePropertyListener listener;

	private Map cachedMap;

	/**
	 * @param realm
	 * @param source
	 * @param property
	 */
	public SimpleMapPropertyObservableMap(Realm realm, Object source,
			SimpleMapProperty property) {
		super(realm);
		this.source = source;
		this.property = property;
	}

	public Object getKeyType() {
		return property.getKeyType();
	}

	public Object getValueType() {
		return property.getValueType();
	}

	private void getterCalled() {
		ObservableTracker.getterCalled(this);
	}

	protected void firstListenerAdded() {
		if (!isDisposed()) {
			cachedMap = new HashMap(this);

			if (listener == null) {
				listener = property
						.adaptListener(new IPropertyChangeListener() {
							public void handlePropertyChange(
									final PropertyChangeEvent event) {
								modCount++;
								if (!isDisposed() && !updating) {
									getRealm().exec(new Runnable() {
										public void run() {
											notifyIfChanged((MapDiff) event.diff);
										}
									});
								}
							}
						});
			}
			property.addListener(source, listener);
		}
	}

	protected void lastListenerRemoved() {
		if (listener != null) {
			property.removeListener(source, listener);
		}

		cachedMap.clear();
		cachedMap = null;
	}

	// Queries

	private Map getMap() {
		return property.getMap(source);
	}

	// Single change operations

	private EntrySet es = new EntrySet();

	public Set entrySet() {
		getterCalled();
		return es;
	}

	private class EntrySet extends AbstractSet {
		public Iterator iterator() {
			return new EntrySetIterator();
		}

		public int size() {
			return getMap().size();
		}
	}

	private class EntrySetIterator implements Iterator {
		private volatile int expectedModCount = modCount;
		Map map = new HashMap(getMap());
		Iterator iterator = map.entrySet().iterator();
		Map.Entry last = null;

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

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

		public void remove() {
			getterCalled();
			checkForComodification();

			iterator.remove(); // stay in sync
			MapDiff diff = Diffs.createMapDiffSingleRemove(last.getKey(), last
					.getValue());

			boolean wasUpdating = updating;
			updating = true;
			try {
				property.setMap(source, map, diff);
			} finally {
				updating = wasUpdating;
			}

			notifyIfChanged(null);

			last = null;
			expectedModCount = modCount;
		}

		private void checkForComodification() {
			if (expectedModCount != modCount)
				throw new ConcurrentModificationException();
		}
	}

	public Set keySet() {
		getterCalled();
		// AbstractMap depends on entrySet() to fulfil keySet() API, so all
		// getterCalled() and comodification checks will still be handled
		return super.keySet();
	}

	public Object put(Object key, Object value) {
		checkRealm();

		Map map = new HashMap(getMap());

		boolean add = !map.containsKey(key);

		Object oldValue = map.put(key, value);

		MapDiff diff;
		if (add)
			diff = Diffs.createMapDiffSingleAdd(key, value);
		else
			diff = Diffs.createMapDiffSingleChange(key, oldValue, value);

		boolean wasUpdating = updating;
		updating = true;
		try {
			property.setMap(source, map, diff);
			modCount++;
		} finally {
			updating = wasUpdating;
		}

		notifyIfChanged(null);

		return oldValue;
	}

	public void putAll(Map m) {
		checkRealm();

		Map map = new HashMap(getMap());

		Map oldValues = new HashMap();
		Map newValues = new HashMap();
		Set changedKeys = new HashSet();
		Set addedKeys = new HashSet();
		for (Iterator it = m.entrySet().iterator(); it.hasNext();) {
			Map.Entry entry = (Entry) it.next();
			Object key = entry.getKey();
			Object newValue = entry.getValue();
			if (map.containsKey(key)) {
				changedKeys.add(key);
				oldValues.put(key, map.get(key));
			} else {
				addedKeys.add(key);
			}
			map.put(key, newValue);

			newValues.put(key, newValue);
		}

		MapDiff diff = Diffs.createMapDiff(addedKeys, Collections.EMPTY_SET,
				changedKeys, oldValues, newValues);

		boolean wasUpdating = updating;
		updating = true;
		try {
			property.setMap(source, map, diff);
			modCount++;
		} finally {
			updating = wasUpdating;
		}

		notifyIfChanged(null);
	}

	public Object remove(Object key) {
		checkRealm();
		return super.remove(key);
	}

	public Collection values() {
		getterCalled();
		// AbstractMap depends on entrySet() to fulfil values() API, so all
		// getterCalled() and comodification checks will still be handled
		return super.values();
	}

	private void notifyIfChanged(MapDiff diff) {
		if (hasListeners()) {
			Map oldMap = cachedMap;
			Map newMap = cachedMap = property.getMap(source);
			if (diff == null)
				diff = Diffs.computeMapDiff(oldMap, newMap);
			if (!diff.isEmpty())
				fireMapChange(diff);
		}
	}

	public Object getObserved() {
		return source;
	}

	public IProperty getProperty() {
		return property;
	}

	public synchronized void dispose() {
		if (!isDisposed()) {
			if (listener != null)
				property.removeListener(source, listener);
			property = null;
			source = null;
			listener = null;
		}
		super.dispose();
	}
}




/*******************************************************************************
 * Copyright (c) 2008 Matthew Hall and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Matthew Hall - initial API and implementation (bug 194734)
 ******************************************************************************/

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

import java.util.AbstractSet;
import java.util.Collections;
import java.util.HashMap;
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.IObserving;
import org.eclipse.core.databinding.observable.IStaleListener;
import org.eclipse.core.databinding.observable.ObservableTracker;
import org.eclipse.core.databinding.observable.StaleEvent;
import org.eclipse.core.databinding.observable.map.AbstractObservableMap;
import org.eclipse.core.databinding.observable.map.MapDiff;
import org.eclipse.core.databinding.observable.set.IObservableSet;
import org.eclipse.core.databinding.observable.set.ISetChangeListener;
import org.eclipse.core.databinding.observable.set.SetChangeEvent;
import org.eclipse.core.databinding.observable.set.SetDiff;
import org.eclipse.core.internal.databinding.Util;

/**
 * @since 1.2
 */
class ObservableSetDelegatingValuePropertyObservableMap extends
		AbstractObservableMap implements IObserving {
	private IObservableSet masterSet;
	private DelegatingValueProperty detailProperty;
	private DelegatingCache cache;

	private Set entrySet;

	class EntrySet extends AbstractSet {
		public Iterator iterator() {
			return new Iterator() {
				final Iterator it = masterSet.iterator();

				public boolean hasNext() {
					return it.hasNext();
				}

				public Object next() {
					return new MapEntry(it.next());
				}

				public void remove() {
					it.remove();
				}
			};
		}

		public int size() {
			return masterSet.size();
		}
	}

	class MapEntry implements Map.Entry {
		private final Object key;

		MapEntry(Object key) {
			this.key = key;
		}

		public Object getKey() {
			getterCalled();
			return key;
		}

		public Object getValue() {
			getterCalled();

			if (!masterSet.contains(key))
				return null;

			return cache.get(key);
		}

		public Object setValue(Object value) {
			checkRealm();

			if (!masterSet.contains(key))
				return null;

			return cache.put(key, value);
		}

		public boolean equals(Object o) {
			getterCalled();
			if (o == this)
				return true;
			if (o == null)
				return false;
			if (!(o instanceof Map.Entry))
				return false;
			Map.Entry that = (Map.Entry) o;
			return Util.equals(this.getKey(), that.getKey())
					&& Util.equals(this.getValue(), that.getValue());
		}

		public int hashCode() {
			getterCalled();
			Object value = getValue();
			return (key == null ? 0 : key.hashCode())
					^ (value == null ? 0 : value.hashCode());
		}
	}

	private ISetChangeListener masterListener = new ISetChangeListener() {
		public void handleSetChange(SetChangeEvent event) {
			if (isDisposed())
				return;

			cache.addAll(masterSet);

			// Need both obsolete and new elements to convert diff
			MapDiff diff = convertDiff(event.diff);

			cache.retainAll(masterSet);

			fireMapChange(diff);
		}

		private MapDiff convertDiff(SetDiff diff) {
			// Convert diff to detail value
			Map oldValues = new HashMap();
			Map newValues = new HashMap();

			for (Iterator it = diff.getRemovals().iterator(); it.hasNext();) {
				Object masterElement = it.next();
				oldValues.put(masterElement, cache.get(masterElement));
			}
			for (Iterator it = diff.getAdditions().iterator(); it.hasNext();) {
				Object masterElement = it.next();
				newValues.put(masterElement, cache.get(masterElement));
			}
			return Diffs.createMapDiff(diff.getAdditions(), diff.getRemovals(),
					Collections.EMPTY_SET, oldValues, newValues);
		}
	};

	private IStaleListener staleListener = new IStaleListener() {
		public void handleStale(StaleEvent staleEvent) {
			fireStale();
		}
	};

	/**
	 * @param keySet
	 * @param valueProperty
	 */
	public ObservableSetDelegatingValuePropertyObservableMap(
			IObservableSet keySet, DelegatingValueProperty valueProperty) {
		super(keySet.getRealm());
		this.masterSet = keySet;
		this.detailProperty = valueProperty;
		this.cache = new DelegatingCache(getRealm(), valueProperty) {
			void handleValueChange(Object masterElement, Object oldValue,
					Object newValue) {
				fireMapChange(Diffs.createMapDiffSingleChange(masterElement,
						oldValue, newValue));
			}
		};
		cache.addAll(masterSet);

		masterSet.addSetChangeListener(masterListener);
		masterSet.addStaleListener(staleListener);
	}

	public Set entrySet() {
		getterCalled();
		if (entrySet == null)
			entrySet = new EntrySet();
		return entrySet;
	}

	private void getterCalled() {
		ObservableTracker.getterCalled(this);
	}

	public Object get(Object key) {
		getterCalled();
		return cache.get(key);
	}

	public Object put(Object key, Object value) {
		checkRealm();
		return cache.put(key, value);
	}

	public boolean isStale() {
		return masterSet.isStale();
	}

	public Object getObserved() {
		return masterSet;
	}

	public Object getKeyType() {
		return masterSet.getElementType();
	}

	public Object getValueType() {
		return detailProperty.getValueType();
	}

	public synchronized void dispose() {
		if (masterSet != null) {
			masterSet.removeSetChangeListener(masterListener);
			masterSet.removeStaleListener(staleListener);
			masterSet = null;
		}

		if (cache != null) {
			cache.dispose();
			cache = null;
		}

		masterListener = null;
		detailProperty = null;

		super.dispose();
	}
}




/*******************************************************************************
 * Copyright (c) 2009 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

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

import java.util.Collection;
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.Realm;
import org.eclipse.core.databinding.observable.map.IMapChangeListener;
import org.eclipse.core.databinding.observable.map.IObservableMap;
import org.eclipse.core.databinding.observable.map.MapChangeEvent;
import org.eclipse.core.databinding.observable.set.IObservableSet;
import org.eclipse.core.databinding.observable.set.ISetChangeListener;
import org.eclipse.core.databinding.observable.set.SetChangeEvent;
import org.eclipse.core.databinding.observable.set.WritableSet;
import org.eclipse.core.internal.databinding.IdentityWrapper;
import org.eclipse.core.internal.databinding.Util;

/**
 * @since 3.3
 * 
 */
abstract class DelegatingCache {
	private Realm realm;
	private DelegatingValueProperty detailProperty;
	private IObservableSet elements;
	private Map delegateCaches;

	private class DelegateCache implements IMapChangeListener {
		private final IValueProperty delegate;
		private final IObservableSet masterElements;
		private final IObservableMap masterElementValues;
		private final Map cachedValues;

		DelegateCache(IValueProperty delegate) {
			this.delegate = delegate;
			this.masterElements = new WritableSet(realm, Collections.EMPTY_SET,
					elements.getElementType());
			this.masterElementValues = delegate.observeDetail(masterElements);
			this.cachedValues = new HashMap();

			masterElementValues.addMapChangeListener(this);
		}

		void add(Object masterElement) {
			boolean wasEmpty = masterElements.isEmpty();

			masterElements.add(masterElement);
			cachedValues.put(new IdentityWrapper(masterElement),
					masterElementValues.get(masterElement));

			if (wasEmpty)
				delegateCaches.put(delegate, this);
		}

		void remove(Object masterElement) {
			cachedValues.remove(new IdentityWrapper(masterElement));
			masterElements.remove(masterElement);
			if (cachedValues.isEmpty())
				dispose();
		}

		Object get(Object masterElement) {
			return cachedValues.get(new IdentityWrapper(masterElement));
		}

		Object put(Object masterElement, Object detailValue) {
			Object oldValue = masterElementValues.put(masterElement,
					detailValue);
			notifyIfChanged(masterElement);
			return oldValue;
		}

		boolean containsValue(Object detailValue) {
			return cachedValues.containsValue(detailValue);
		}

		public void handleMapChange(MapChangeEvent event) {
			Set changedKeys = event.diff.getChangedKeys();
			for (Iterator it = changedKeys.iterator(); it.hasNext();)
				notifyIfChanged(it.next());
		}

		private void notifyIfChanged(Object masterElement) {
			Object oldValue = cachedValues.get(new IdentityWrapper(
					masterElement));
			Object newValue = masterElementValues.get(masterElement);
			if (!Util.equals(oldValue, newValue)) {
				cachedValues.put(new IdentityWrapper(masterElement), newValue);
				handleValueChange(masterElement, oldValue, newValue);
			}
		}

		void handleValueChange(Object masterElement, Object oldValue,
				Object newValue) {
			DelegatingCache.this.handleValueChange(masterElement, oldValue,
					newValue);
		}

		void dispose() {
			delegateCaches.remove(delegate);
			masterElementValues.dispose();
			masterElements.dispose();
			cachedValues.clear();
		}
	}

	DelegatingCache(Realm realm, DelegatingValueProperty detailProperty) {
		this.realm = realm;
		this.detailProperty = detailProperty;

		this.elements = new WritableSet(realm);
		this.delegateCaches = new HashMap();

		elements.addSetChangeListener(new ISetChangeListener() {
			public void handleSetChange(SetChangeEvent event) {
				for (Iterator it = event.diff.getRemovals().iterator(); it
						.hasNext();) {
					IdentityWrapper wrapper = (IdentityWrapper) it.next();
					Object element = wrapper.unwrap();
					getCache(element).remove(element);

				}
				for (Iterator it = event.diff.getAdditions().iterator(); it
						.hasNext();) {
					IdentityWrapper wrapper = (IdentityWrapper) it.next();
					Object element = wrapper.unwrap();
					getCache(element).add(element);
				}
			}
		});
	}

	private DelegateCache getCache(Object masterElement) {
		IValueProperty delegate = detailProperty.getDelegate(masterElement);
		if (delegateCaches.containsKey(delegate)) {
			return (DelegateCache) delegateCaches.get(delegate);
		}
		return new DelegateCache(delegate);
	}

	Object get(Object element) {
		return getCache(element).get(element);
	}

	Object put(Object element, Object value) {
		return getCache(element).put(element, value);
	}

	boolean contains(Object value) {
		for (Iterator it = delegateCaches.values().iterator(); it.hasNext();) {
			DelegateCache cache = (DelegateCache) it.next();
			if (cache.containsValue(value))
				return true;
		}
		return false;
	}

	private Set identitySet(Collection elements) {
		Set result = new HashSet();
		for (Iterator it = elements.iterator(); it.hasNext();) {
			result.add(new IdentityWrapper(it.next()));
		}
		return result;
	}

	void addAll(Collection elements) {
		this.elements.addAll(identitySet(elements));
	}

	void retainAll(Collection elements) {
		this.elements.retainAll(identitySet(elements));
	}

	abstract void handleValueChange(Object masterElement, Object oldValue,
			Object newValue);

	void dispose() {
		if (elements != null) {
			elements.clear(); // clears caches
			elements.dispose();
			elements = null;
		}

		if (delegateCaches != null) {
			for (Iterator it = delegateCaches.values().iterator(); it.hasNext();) {
				DelegateCache cache = (DelegateCache) it.next();
				cache.dispose();
			}
			delegateCaches.clear();
			delegateCaches = null;
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2008 Matthew Hall and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Matthew Hall - initial API and implementation (bug 194734)
 ******************************************************************************/

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

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.Set;

import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.observable.IObserving;
import org.eclipse.core.databinding.observable.IStaleListener;
import org.eclipse.core.databinding.observable.ObservableTracker;
import org.eclipse.core.databinding.observable.StaleEvent;
import org.eclipse.core.databinding.observable.list.AbstractObservableList;
import org.eclipse.core.databinding.observable.list.IListChangeListener;
import org.eclipse.core.databinding.observable.list.IObservableList;
import org.eclipse.core.databinding.observable.list.ListChangeEvent;
import org.eclipse.core.databinding.observable.list.ListDiff;
import org.eclipse.core.databinding.observable.list.ListDiffEntry;
import org.eclipse.core.databinding.observable.set.IObservableSet;
import org.eclipse.core.databinding.observable.set.ISetChangeListener;
import org.eclipse.core.databinding.observable.set.SetChangeEvent;
import org.eclipse.core.databinding.observable.set.WritableSet;
import org.eclipse.core.databinding.property.INativePropertyListener;
import org.eclipse.core.databinding.property.IPropertyChangeListener;
import org.eclipse.core.databinding.property.PropertyChangeEvent;
import org.eclipse.core.internal.databinding.IdentityWrapper;
import org.eclipse.core.internal.databinding.Util;

/**
 * @since 1.2
 */
class ObservableListSimpleValuePropertyObservableList extends
		AbstractObservableList implements IObserving {
	private IObservableList masterList;
	private SimpleValueProperty detailProperty;

	private IObservableSet knownMasterElements;
	private Map cachedValues;

	private boolean updating;

	private IListChangeListener masterListener = new IListChangeListener() {
		public void handleListChange(ListChangeEvent event) {
			if (!isDisposed()) {
				updateKnownElements();
				fireListChange(convertDiff(event.diff));
			}
		}

		private void updateKnownElements() {
			Set identityKnownElements = new HashSet();
			for (Iterator it = masterList.iterator(); it.hasNext();) {
				identityKnownElements.add(new IdentityWrapper(it.next()));
			}

			knownMasterElements.retainAll(identityKnownElements);
			knownMasterElements.addAll(identityKnownElements);
		}

		private ListDiff convertDiff(ListDiff diff) {
			// Convert diff to detail value
			ListDiffEntry[] masterEntries = diff.getDifferences();
			ListDiffEntry[] detailEntries = new ListDiffEntry[masterEntries.length];
			for (int i = 0; i < masterEntries.length; i++) {
				ListDiffEntry masterDifference = masterEntries[i];
				int index = masterDifference.getPosition();
				boolean addition = masterDifference.isAddition();
				Object masterElement = masterDifference.getElement();
				Object elementDetailValue = detailProperty
						.getValue(masterElement);
				detailEntries[i] = Diffs.createListDiffEntry(index, addition,
						elementDetailValue);
			}
			return Diffs.createListDiff(detailEntries);
		}
	};

	private IStaleListener staleListener = new IStaleListener() {
		public void handleStale(StaleEvent staleEvent) {
			fireStale();
		}
	};

	private INativePropertyListener detailListener;

	/**
	 * @param masterList
	 * @param valueProperty
	 */
	public ObservableListSimpleValuePropertyObservableList(
			IObservableList masterList, SimpleValueProperty valueProperty) {
		super(masterList.getRealm());
		this.masterList = masterList;
		this.detailProperty = valueProperty;

		IPropertyChangeListener listener = new IPropertyChangeListener() {
			public void handlePropertyChange(PropertyChangeEvent event) {
				if (!isDisposed() && !updating) {
					notifyIfChanged(event.getSource());
				}
			}
		};
		this.detailListener = detailProperty.adaptListener(listener);
	}

	protected void firstListenerAdded() {
		knownMasterElements = new WritableSet(getRealm());
		cachedValues = new HashMap();
		knownMasterElements.addSetChangeListener(new ISetChangeListener() {
			public void handleSetChange(SetChangeEvent event) {
				for (Iterator it = event.diff.getRemovals().iterator(); it
						.hasNext();) {
					IdentityWrapper wrapper = (IdentityWrapper) it.next();
					Object key = wrapper.unwrap();
					detailProperty.removeListener(key, detailListener);
					cachedValues.remove(wrapper);
				}
				for (Iterator it = event.diff.getAdditions().iterator(); it
						.hasNext();) {
					IdentityWrapper wrapper = (IdentityWrapper) it.next();
					Object key = wrapper.unwrap();
					cachedValues.put(wrapper, detailProperty.getValue(key));
					detailProperty.addListener(key, detailListener);
				}
			}
		});
		for (Iterator it = masterList.iterator(); it.hasNext();) {
			knownMasterElements.add(new IdentityWrapper(it.next()));
		}

		masterList.addListChangeListener(masterListener);
		masterList.addStaleListener(staleListener);
	}

	protected void lastListenerRemoved() {
		masterList.removeListChangeListener(masterListener);
		masterList.removeStaleListener(staleListener);
		if (knownMasterElements != null) {
			knownMasterElements.clear(); // clears cachedValues
			knownMasterElements.dispose();
			knownMasterElements = null;
		}
		cachedValues.clear();
		cachedValues = null;
	}

	protected int doGetSize() {
		getterCalled();
		return masterList.size();
	}

	private void getterCalled() {
		ObservableTracker.getterCalled(this);
	}

	public Object getElementType() {
		return detailProperty.getValueType();
	}

	public Object get(int index) {
		getterCalled();
		Object masterElement = masterList.get(index);
		return detailProperty.getValue(masterElement);
	}

	public boolean add(Object o) {
		throw new UnsupportedOperationException();
	}

	public boolean addAll(Collection c) {
		throw new UnsupportedOperationException();
	}

	public boolean addAll(int index, Collection c) {
		throw new UnsupportedOperationException();
	}

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

		for (Iterator it = masterList.iterator(); it.hasNext();) {
			if (Util.equals(detailProperty.getValue(it.next()), o))
				return true;
		}
		return false;
	}

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

	public boolean isStale() {
		getterCalled();
		return masterList.isStale();
	}

	public Iterator iterator() {
		getterCalled();
		return new Iterator() {
			Iterator it = masterList.iterator();

			public boolean hasNext() {
				getterCalled();
				return it.hasNext();
			}

			public Object next() {
				getterCalled();
				Object masterElement = it.next();
				return detailProperty.getValue(masterElement);
			}

			public void remove() {
				throw new UnsupportedOperationException();
			}
		};
	}

	public Object move(int oldIndex, int newIndex) {
		throw new UnsupportedOperationException();
	}

	public boolean remove(Object o) {
		throw new UnsupportedOperationException();
	}

	public boolean removeAll(Collection c) {
		throw new UnsupportedOperationException();
	}

	public boolean retainAll(Collection c) {
		throw new UnsupportedOperationException();
	}

	public Object[] toArray() {
		getterCalled();
		Object[] masterElements = masterList.toArray();
		Object[] result = new Object[masterElements.length];
		for (int i = 0; i < result.length; i++) {
			result[i] = detailProperty.getValue(masterElements[i]);
		}
		return result;
	}

	public Object[] toArray(Object[] a) {
		getterCalled();
		Object[] masterElements = masterList.toArray();
		if (a.length < masterElements.length)
			a = (Object[]) Array.newInstance(a.getClass().getComponentType(),
					masterElements.length);
		for (int i = 0; i < masterElements.length; i++) {
			a[i] = detailProperty.getValue(masterElements[i]);
		}
		return a;
	}

	public void add(int index, Object o) {
		throw new UnsupportedOperationException();
	}

	public void clear() {
		throw new UnsupportedOperationException();
	}

	public ListIterator listIterator() {
		return listIterator(0);
	}

	public ListIterator listIterator(final int index) {
		getterCalled();
		return new ListIterator() {
			ListIterator it = masterList.listIterator(index);
			Object lastMasterElement;
			Object lastElement;
			boolean haveIterated = false;

			public void add(Object arg0) {
				throw new UnsupportedOperationException();
			}

			public boolean hasNext() {
				getterCalled();
				return it.hasNext();
			}

			public boolean hasPrevious() {
				getterCalled();
				return it.hasPrevious();
			}

			public Object next() {
				getterCalled();
				lastMasterElement = it.next();
				lastElement = detailProperty.getValue(lastMasterElement);
				haveIterated = true;
				return lastElement;
			}

			public int nextIndex() {
				getterCalled();
				return it.nextIndex();
			}

			public Object previous() {
				getterCalled();
				lastMasterElement = it.previous();
				lastElement = detailProperty.getValue(lastMasterElement);
				haveIterated = true;
				return lastElement;
			}

			public int previousIndex() {
				getterCalled();
				return it.previousIndex();
			}

			public void remove() {
				throw new UnsupportedOperationException();
			}

			public void set(Object o) {
				checkRealm();
				if (!haveIterated)
					throw new IllegalStateException();

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

				notifyIfChanged(lastMasterElement);

				lastElement = o;
			}
		};
	}

	private void notifyIfChanged(Object masterElement) {
		if (cachedValues != null) {
			Object oldValue = cachedValues.get(new IdentityWrapper(
					masterElement));
			Object newValue = detailProperty.getValue(masterElement);
			if (!Util.equals(oldValue, newValue)) {
				cachedValues.put(new IdentityWrapper(masterElement), newValue);
				fireListChange(indicesOf(masterElement), oldValue, newValue);
			}
		}
	}

	private int[] indicesOf(Object masterElement) {
		List indices = new ArrayList();

		for (ListIterator it = ObservableListSimpleValuePropertyObservableList.this.masterList
				.listIterator(); it.hasNext();) {
			if (masterElement == it.next())
				indices.add(new Integer(it.previousIndex()));
		}

		int[] result = new int[indices.size()];
		for (int i = 0; i < result.length; i++) {
			result[i] = ((Integer) indices.get(i)).intValue();
		}
		return result;
	}

	private void fireListChange(int[] indices, Object oldValue, Object newValue) {
		ListDiffEntry[] differences = new ListDiffEntry[indices.length * 2];
		for (int i = 0; i < indices.length; i++) {
			int index = indices[i];
			differences[i * 2] = Diffs.createListDiffEntry(index, false,
					oldValue);
			differences[i * 2 + 1] = Diffs.createListDiffEntry(index, true,
					newValue);
		}
		fireListChange(Diffs.createListDiff(differences));
	}

	public Object remove(int index) {
		throw new UnsupportedOperationException();
	}

	public Object set(int index, Object o) {
		checkRealm();
		Object masterElement = masterList.get(index);
		Object oldValue = detailProperty.getValue(masterElement);

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

		notifyIfChanged(masterElement);

		return oldValue;
	}

	public Object getObserved() {
		return masterList;
	}

	public synchronized void dispose() {
		if (masterList != null) {
			masterList.removeListChangeListener(masterListener);
			masterList = null;
		}
		if (knownMasterElements != null) {
			knownMasterElements.clear(); // detaches listeners
			knownMasterElements.dispose();
			knownMasterElements = null;
		}

		masterListener = null;
		detailListener = null;
		detailProperty = null;
		cachedValues = null;

		super.dispose();
	}
}




/*******************************************************************************
 * Copyright (c) 2008 Matthew Hall and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Matthew Hall - initial API and implementation (bug 194734)
 ******************************************************************************/

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

import java.util.AbstractSet;
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.IObserving;
import org.eclipse.core.databinding.observable.IStaleListener;
import org.eclipse.core.databinding.observable.ObservableTracker;
import org.eclipse.core.databinding.observable.StaleEvent;
import org.eclipse.core.databinding.observable.map.AbstractObservableMap;
import org.eclipse.core.databinding.observable.map.IMapChangeListener;
import org.eclipse.core.databinding.observable.map.IObservableMap;
import org.eclipse.core.databinding.observable.map.MapChangeEvent;
import org.eclipse.core.databinding.observable.map.MapDiff;
import org.eclipse.core.internal.databinding.Util;

/**
 * @since 1.2
 */
class ObservableMapDelegatingValuePropertyObservableMap extends
		AbstractObservableMap implements IObserving {
	private IObservableMap masterMap;
	private DelegatingValueProperty detailProperty;
	private DelegatingCache cache;

	private Set entrySet;

	class EntrySet extends AbstractSet {
		public Iterator iterator() {
			return new Iterator() {
				Iterator it = masterMap.entrySet().iterator();

				public boolean hasNext() {
					getterCalled();
					return it.hasNext();
				}

				public Object next() {
					getterCalled();
					Map.Entry next = (Map.Entry) it.next();
					return new MapEntry(next.getKey());
				}

				public void remove() {
					it.remove();
				}
			};
		}

		public int size() {
			return masterMap.size();
		}
	}

	class MapEntry implements Map.Entry {
		private Object key;

		MapEntry(Object key) {
			this.key = key;
		}

		public Object getKey() {
			getterCalled();
			return key;
		}

		public Object getValue() {
			getterCalled();

			if (!masterMap.containsKey(key))
				return null;

			Object masterValue = masterMap.get(key);
			return cache.get(masterValue);
		}

		public Object setValue(Object value) {
			checkRealm();

			if (!masterMap.containsKey(key))
				return null;

			Object masterValue = masterMap.get(key);
			return cache.put(masterValue, value);
		}

		public boolean equals(Object o) {
			getterCalled();
			if (o == this)
				return true;
			if (o == null)
				return false;
			if (!(o instanceof Map.Entry))
				return false;
			Map.Entry that = (Map.Entry) o;
			return Util.equals(this.getKey(), that.getKey())
					&& Util.equals(this.getValue(), that.getValue());
		}

		public int hashCode() {
			getterCalled();
			Object value = getValue();
			return (key == null ? 0 : key.hashCode())
					^ (value == null ? 0 : value.hashCode());
		}
	}

	private IMapChangeListener masterListener = new IMapChangeListener() {
		public void handleMapChange(final MapChangeEvent event) {
			if (isDisposed())
				return;

			cache.addAll(masterMap.values());

			// Need both obsolete and new master values to convert diff
			MapDiff diff = convertDiff(event.diff);

			cache.retainAll(masterMap.values());

			fireMapChange(diff);
		}

		private MapDiff convertDiff(MapDiff diff) {
			Map oldValues = new HashMap();
			Map newValues = new HashMap();

			Set addedKeys = diff.getAddedKeys();
			for (Iterator it = addedKeys.iterator(); it.hasNext();) {
				Object key = it.next();
				Object masterValue = diff.getNewValue(key);
				Object newValue = cache.get(masterValue);
				newValues.put(key, newValue);
			}

			Set removedKeys = diff.getRemovedKeys();
			for (Iterator it = removedKeys.iterator(); it.hasNext();) {
				Object key = it.next();
				Object masterValue = diff.getOldValue(key);
				Object oldValue = cache.get(masterValue);
				oldValues.put(key, oldValue);
			}

			Set changedKeys = new HashSet(diff.getChangedKeys());
			for (Iterator it = changedKeys.iterator(); it.hasNext();) {
				Object key = it.next();

				Object oldMasterValue = diff.getOldValue(key);
				Object newMasterValue = diff.getNewValue(key);

				Object oldValue = cache.get(oldMasterValue);
				Object newValue = cache.get(newMasterValue);

				if (Util.equals(oldValue, newValue)) {
					it.remove();
				} else {
					oldValues.put(key, oldValue);
					newValues.put(key, newValue);
				}
			}

			return Diffs.createMapDiff(addedKeys, removedKeys, changedKeys,
					oldValues, newValues);
		}
	};

	private IStaleListener staleListener = new IStaleListener() {
		public void handleStale(StaleEvent staleEvent) {
			fireStale();
		}
	};

	/**
	 * @param map
	 * @param valueProperty
	 */
	public ObservableMapDelegatingValuePropertyObservableMap(
			IObservableMap map, DelegatingValueProperty valueProperty) {
		super(map.getRealm());
		this.masterMap = map;
		this.detailProperty = valueProperty;
		this.cache = new DelegatingCache(getRealm(), valueProperty) {
			void handleValueChange(Object masterElement, Object oldValue,
					Object newValue) {
				fireMapChange(keysFor(masterElement), oldValue, newValue);
			}
		};
		cache.addAll(masterMap.values());

		masterMap.addMapChangeListener(masterListener);
		masterMap.addStaleListener(staleListener);
	}

	public Set entrySet() {
		getterCalled();
		if (entrySet == null)
			entrySet = new EntrySet();
		return entrySet;
	}

	private void getterCalled() {
		ObservableTracker.getterCalled(this);
	}

	public Object get(Object key) {
		getterCalled();
		Object masterValue = masterMap.get(key);
		return cache.get(masterValue);
	}

	public Object put(Object key, Object value) {
		if (!masterMap.containsKey(key))
			return null;
		Object masterValue = masterMap.get(key);
		return cache.put(masterValue, value);
	}

	public boolean isStale() {
		getterCalled();
		return masterMap.isStale();
	}

	public Object getObserved() {
		return masterMap;
	}

	public Object getKeyType() {
		return masterMap.getKeyType();
	}

	public Object getValueType() {
		return detailProperty.getValueType();
	}

	private Set keysFor(Object masterValue) {
		Set keys = new HashSet();

		for (Iterator it = masterMap.entrySet().iterator(); it.hasNext();) {
			Map.Entry entry = (Entry) it.next();
			if (entry.getValue() == masterValue) {
				keys.add(entry.getKey());
			}
		}

		return keys;
	}

	private void fireMapChange(final Set changedKeys, final Object oldValue,
			final Object newValue) {
		fireMapChange(new MapDiff() {
			public Set getAddedKeys() {
				return Collections.EMPTY_SET;
			}

			public Set getRemovedKeys() {
				return Collections.EMPTY_SET;
			}

			public Set getChangedKeys() {
				return Collections.unmodifiableSet(changedKeys);
			}

			public Object getOldValue(Object key) {
				if (changedKeys.contains(key))
					return oldValue;
				return null;
			}

			public Object getNewValue(Object key) {
				if (changedKeys.contains(key))
					return newValue;
				return null;
			}
		});
	}

	public synchronized void dispose() {
		if (masterMap != null) {
			masterMap.removeMapChangeListener(masterListener);
			masterMap.removeStaleListener(staleListener);
			masterMap = null;
		}

		if (cache != null) {
			cache.dispose();
			cache = null;
		}

		masterListener = null;
		detailProperty = null;

		super.dispose();
	}
}




/*******************************************************************************
 * Copyright (c) 2008 Matthew Hall and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Matthew Hall - initial API and implementation (bug 194734)
 ******************************************************************************/

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

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.observable.IObserving;
import org.eclipse.core.databinding.observable.map.ComputedObservableMap;
import org.eclipse.core.databinding.observable.set.IObservableSet;
import org.eclipse.core.databinding.property.INativePropertyListener;
import org.eclipse.core.databinding.property.IPropertyChangeListener;
import org.eclipse.core.databinding.property.PropertyChangeEvent;
import org.eclipse.core.internal.databinding.Util;

/**
 * @since 1.2
 */
class ObservableSetSimpleValuePropertyObservableMap extends
		ComputedObservableMap implements IObserving {
	private SimpleValueProperty detailProperty;

	private INativePropertyListener listener;

	private Map cachedValues;

	private boolean updating;

	/**
	 * @param keySet
	 * @param valueProperty
	 */
	public ObservableSetSimpleValuePropertyObservableMap(IObservableSet keySet,
			SimpleValueProperty valueProperty) {
		super(keySet);
		this.detailProperty = valueProperty;
	}

	protected void firstListenerAdded() {
		cachedValues = new HashMap(this);
		if (listener == null) {
			listener = detailProperty
					.adaptListener(new IPropertyChangeListener() {
						public void handlePropertyChange(
								final PropertyChangeEvent event) {
							if (!isDisposed() && !updating) {
								getRealm().exec(new Runnable() {
									public void run() {
										notifyIfChanged(event.getSource());
									}
								});
							}
						}
					});
		}
		super.firstListenerAdded();
	}

	protected void lastListenerRemoved() {
		super.lastListenerRemoved();
		cachedValues.clear();
		cachedValues = null;
	}

	protected void hookListener(Object addedKey) {
		if (listener != null) {
			cachedValues.put(addedKey, detailProperty.getValue(addedKey));
			detailProperty.addListener(addedKey, listener);
		}
	}

	protected void unhookListener(Object removedKey) {
		if (listener != null) {
			detailProperty.removeListener(removedKey, listener);
			cachedValues.remove(removedKey);
		}
	}

	protected Object doGet(Object key) {
		return detailProperty.getValue(key);
	}

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

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

		notifyIfChanged(key);

		return oldValue;
	}

	private void notifyIfChanged(Object key) {
		if (cachedValues != null) {
			Object oldValue = cachedValues.get(key);
			Object newValue = detailProperty.getValue(key);
			if (!Util.equals(oldValue, newValue)) {
				cachedValues.put(key, newValue);
				fireMapChange(Diffs.createMapDiffSingleChange(key, oldValue,
						newValue));
			}
		}
	}

	public Object getObserved() {
		return keySet();
	}

	public synchronized void dispose() {
		if (!isDisposed()) {
			if (listener != null) {
				for (Iterator it = values().iterator(); it.hasNext();) {
					unhookListener(it.next());
				}
				listener = null;
			}
			detailProperty = null;
		}

		super.dispose();
	}
}




/*******************************************************************************
 * Copyright (c) 2008 Matthew Hall and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Matthew Hall - initial API and implementation
 ******************************************************************************/

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

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Collection;
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.IStaleListener;
import org.eclipse.core.databinding.observable.ObservableTracker;
import org.eclipse.core.databinding.observable.StaleEvent;
import org.eclipse.core.databinding.observable.list.AbstractObservableList;
import org.eclipse.core.databinding.observable.list.IListChangeListener;
import org.eclipse.core.databinding.observable.list.IObservableList;
import org.eclipse.core.databinding.observable.list.ListChangeEvent;
import org.eclipse.core.databinding.observable.list.ListDiff;
import org.eclipse.core.databinding.observable.list.ListDiffEntry;

/**
 * @since 1.2
 */
class ObservableListDelegatingValuePropertyObservableList extends
		AbstractObservableList {
	private IObservableList masterList;
	private DelegatingValueProperty detailProperty;
	private DelegatingCache cache;

	private IListChangeListener masterListener = new IListChangeListener() {
		public void handleListChange(ListChangeEvent event) {
			if (isDisposed())
				return;

			cache.addAll(masterList);

			// Need both obsolete and new elements to convert diff
			ListDiff diff = convertDiff(event.diff);

			cache.retainAll(masterList);

			fireListChange(diff);
		}

		private ListDiff convertDiff(ListDiff diff) {
			// Convert diff to detail value
			ListDiffEntry[] masterEntries = diff.getDifferences();
			ListDiffEntry[] detailEntries = new ListDiffEntry[masterEntries.length];
			for (int i = 0; i < masterEntries.length; i++) {
				ListDiffEntry masterDifference = masterEntries[i];
				int index = masterDifference.getPosition();
				boolean addition = masterDifference.isAddition();
				Object masterElement = masterDifference.getElement();
				Object detailValue = cache.get(masterElement);

				detailEntries[i] = Diffs.createListDiffEntry(index, addition,
						detailValue);
			}
			return Diffs.createListDiff(detailEntries);
		}
	};

	private IStaleListener staleListener = new IStaleListener() {
		public void handleStale(StaleEvent staleEvent) {
			fireStale();
		}
	};

	/**
	 * @param masterList
	 * @param valueProperty
	 */
	public ObservableListDelegatingValuePropertyObservableList(
			IObservableList masterList, DelegatingValueProperty valueProperty) {
		super(masterList.getRealm());
		this.masterList = masterList;
		this.detailProperty = valueProperty;
		this.cache = new DelegatingCache(getRealm(), valueProperty) {
			void handleValueChange(Object masterElement, Object oldValue,
					Object newValue) {
				fireListChange(indicesOf(masterElement), oldValue, newValue);
			}
		};
		cache.addAll(masterList);

		masterList.addListChangeListener(masterListener);
		masterList.addStaleListener(staleListener);
	}

	protected int doGetSize() {
		getterCalled();
		return masterList.size();
	}

	private void getterCalled() {
		ObservableTracker.getterCalled(this);
	}

	public Object get(int index) {
		getterCalled();
		Object masterElement = masterList.get(index);
		return cache.get(masterElement);
	}

	public boolean add(Object o) {
		throw new UnsupportedOperationException();
	}

	public boolean addAll(Collection c) {
		throw new UnsupportedOperationException();
	}

	public boolean addAll(int index, Collection c) {
		throw new UnsupportedOperationException();
	}

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

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

	public boolean isStale() {
		getterCalled();
		return masterList.isStale();
	}

	public Iterator iterator() {
		getterCalled();
		return new Iterator() {
			Iterator it = masterList.iterator();

			public boolean hasNext() {
				getterCalled();
				return it.hasNext();
			}

			public Object next() {
				getterCalled();
				Object masterElement = it.next();
				return cache.get(masterElement);
			}

			public void remove() {
				throw new UnsupportedOperationException();
			}
		};
	}

	public Object move(int oldIndex, int newIndex) {
		throw new UnsupportedOperationException();
	}

	public boolean remove(Object o) {
		throw new UnsupportedOperationException();
	}

	public boolean removeAll(Collection c) {
		throw new UnsupportedOperationException();
	}

	public boolean retainAll(Collection c) {
		throw new UnsupportedOperationException();
	}

	public Object[] toArray() {
		getterCalled();
		Object[] masterElements = masterList.toArray();
		Object[] result = new Object[masterElements.length];
		for (int i = 0; i < result.length; i++) {
			result[i] = cache.get(masterElements[i]);
		}
		return result;
	}

	public Object[] toArray(Object[] a) {
		getterCalled();
		Object[] masterElements = masterList.toArray();
		if (a.length < masterElements.length)
			a = (Object[]) Array.newInstance(a.getClass().getComponentType(),
					masterElements.length);
		for (int i = 0; i < masterElements.length; i++) {
			a[i] = cache.get(masterElements[i]);
		}
		return a;
	}

	public void add(int index, Object o) {
		throw new UnsupportedOperationException();
	}

	public void clear() {
		throw new UnsupportedOperationException();
	}

	public ListIterator listIterator() {
		return listIterator(0);
	}

	public ListIterator listIterator(final int index) {
		getterCalled();
		return new ListIterator() {
			ListIterator it = masterList.listIterator(index);
			Object lastMasterElement;
			Object lastElement;
			boolean haveIterated = false;

			public void add(Object arg0) {
				throw new UnsupportedOperationException();
			}

			public boolean hasNext() {
				getterCalled();
				return it.hasNext();
			}

			public boolean hasPrevious() {
				getterCalled();
				return it.hasPrevious();
			}

			public Object next() {
				getterCalled();
				lastMasterElement = it.next();
				lastElement = cache.get(lastMasterElement);
				haveIterated = true;
				return lastElement;
			}

			public int nextIndex() {
				getterCalled();
				return it.nextIndex();
			}

			public Object previous() {
				getterCalled();
				lastMasterElement = it.previous();
				lastElement = cache.get(lastMasterElement);
				haveIterated = true;
				return lastElement;
			}

			public int previousIndex() {
				getterCalled();
				return it.previousIndex();
			}

			public void remove() {
				throw new UnsupportedOperationException();
			}

			public void set(Object o) {
				checkRealm();
				if (!haveIterated)
					throw new IllegalStateException();

				cache.put(lastMasterElement, o);

				lastElement = o;
			}
		};
	}

	private int[] indicesOf(Object masterElement) {
		List indices = new ArrayList();

		for (ListIterator it = masterList.listIterator(); it.hasNext();) {
			if (masterElement == it.next())
				indices.add(new Integer(it.previousIndex()));
		}

		int[] result = new int[indices.size()];
		for (int i = 0; i < result.length; i++) {
			result[i] = ((Integer) indices.get(i)).intValue();
		}
		return result;
	}

	private void fireListChange(int[] indices, Object oldValue, Object newValue) {
		ListDiffEntry[] differences = new ListDiffEntry[indices.length * 2];
		for (int i = 0; i < indices.length; i++) {
			int index = indices[i];
			differences[i * 2] = Diffs.createListDiffEntry(index, false,
					oldValue);
			differences[i * 2 + 1] = Diffs.createListDiffEntry(index, true,
					newValue);
		}
		fireListChange(Diffs.createListDiff(differences));
	}

	public Object remove(int index) {
		throw new UnsupportedOperationException();
	}

	public Object set(int index, Object o) {
		checkRealm();
		Object masterElement = masterList.get(index);
		return cache.put(masterElement, o);
	}

	public Object getObserved() {
		return masterList;
	}

	public Object getElementType() {
		return detailProperty.getValueType();
	}

	public synchronized void dispose() {
		if (masterList != null) {
			masterList.removeListChangeListener(masterListener);
			masterList.removeStaleListener(staleListener);
			masterList = null;
		}

		if (cache != null) {
			cache.dispose();
			cache = null;
		}

		masterListener = null;
		detailProperty = null;

		super.dispose();
	}
}





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

import org.eclipse.core.databinding.observable.IDiff;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.list.IObservableList;
import org.eclipse.core.databinding.observable.map.IObservableMap;
import org.eclipse.core.databinding.observable.set.IObservableSet;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.core.databinding.property.INativePropertyListener;
import org.eclipse.core.databinding.property.ISimplePropertyListener;
import org.eclipse.core.internal.databinding.property.value.ObservableListSimpleValuePropertyObservableList;
import org.eclipse.core.internal.databinding.property.value.ObservableMapSimpleValuePropertyObservableMap;
import org.eclipse.core.internal.databinding.property.value.ObservableSetSimpleValuePropertyObservableMap;
import org.eclipse.core.internal.databinding.property.value.SimpleValuePropertyObservableValue;

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

 * <li> {@link #getValueType()}
 * <li> {@link #doGetValue(Object)}
 * <li> {@link #doSetValue(Object, Object)}
 * <li> {@link #adaptListener(ISimplePropertyListener)}
 * <li> {@link #doAddListener(Object, INativePropertyListener)}
 * <li> {@link #doRemoveListener(Object, INativePropertyListener)}
 * </ul>

 * 
 * @since 1.2
 */
public abstract class SimpleValueProperty extends ValueProperty implements
		ISimpleValueProperty {
	public final Object get(Object source) {
	 * 
	 * @param source
	 *            the property source (may be null)
	 * @return the current value of the source's value property
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected final Object getValue(Object source) {
		return source == null ? null : doGetValue(source);
	}


	 */
	protected abstract Object doGetValue(Object source);

	public final void set(Object source, Object value, IDiff diff) {
	 * Sets the source's value property to the specified value
	 * 
	 * @param source
	 *            the property source
	 * @param value
	 *            the new value
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected final void setValue(Object source, Object value) {
		if (source != null)
			doSetValue(source, value);
	}

	protected abstract void doSetValue(Object source, Object value);

	public abstract INativePropertyListener adaptListener(
			ISimplePropertyListener listener);
	 * the expected source object, and which parlays property change events from
	 * the source object to the given listener. If there is no listener API for
	 * this property, this method returns null.
	 * 
	 * @param listener
	 *            the property listener to receive events
	 * @return a native listener which parlays property change events to the
	 *         specified listener.
	 * @throws ClassCastException
	 *             if the provided listener does not implement the correct
	 *             listener interface (IValueProperty, IListProperty,
	 *             ISetProperty or IMapProperty) depending on the property.
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected abstract INativePropertyListener adaptListener(
			IPropertyChangeListener listener);

	public final void addListener(Object source,
	 * 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(IPropertyChangeListener)}
	 * returns null), this method does nothing.
	 * 
	 * @param source
	 *            the property source
	 * @param listener
	 *            a listener obtained from calling
	 *            {@link #adaptListener(IPropertyChangeListener)}.
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected final void addListener(Object source,
			INativePropertyListener listener) {
		if (source != null)
			doAddListener(source, listener);

	/**
	 * 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(ISimplePropertyListener)}
	 * returns null), this method does nothing.
	 * 
	 * @param source
	 *            the property source
	 * @param listener
	 *            a listener obtained from calling
	 *            {@link #adaptListener(ISimplePropertyListener)}.
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected abstract void doAddListener(Object source,
			INativePropertyListener listener);

	public final void removeListener(Object source,
	 * 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(IPropertyChangeListener)}
	 * returns null), this method does nothing.
	 * 
	 * @param source
	 *            the property source
	 * @param listener
	 *            a listener obtained from calling
	 *            {@link #adaptListener(IPropertyChangeListener)}.
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected final void removeListener(Object source,
			INativePropertyListener listener) {
		if (source != null)
			doRemoveListener(source, listener);

	/**
	 * 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(ISimplePropertyListener)}
	 * returns null), this method does nothing.
	 * 
	 * @param source
	 *            the property source
	 * @param listener
	 *            a listener obtained from calling
	 *            {@link #adaptListener(ISimplePropertyListener)}.
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected abstract void doRemoveListener(Object source,




/*******************************************************************************
 * Copyright (c) 2008 Matthew Hall and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Matthew Hall - initial API and implementation (bug 194734)
 ******************************************************************************/

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

import java.util.AbstractSet;
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.IObserving;
import org.eclipse.core.databinding.observable.IStaleListener;
import org.eclipse.core.databinding.observable.ObservableTracker;
import org.eclipse.core.databinding.observable.StaleEvent;
import org.eclipse.core.databinding.observable.map.AbstractObservableMap;
import org.eclipse.core.databinding.observable.map.IMapChangeListener;
import org.eclipse.core.databinding.observable.map.IObservableMap;
import org.eclipse.core.databinding.observable.map.MapChangeEvent;
import org.eclipse.core.databinding.observable.map.MapDiff;
import org.eclipse.core.databinding.observable.set.IObservableSet;
import org.eclipse.core.databinding.observable.set.ISetChangeListener;
import org.eclipse.core.databinding.observable.set.SetChangeEvent;
import org.eclipse.core.databinding.observable.set.WritableSet;
import org.eclipse.core.databinding.property.INativePropertyListener;
import org.eclipse.core.databinding.property.IPropertyChangeListener;
import org.eclipse.core.databinding.property.PropertyChangeEvent;
import org.eclipse.core.internal.databinding.IdentityWrapper;
import org.eclipse.core.internal.databinding.Util;

/**
 * @since 1.2
 * 
 */
class ObservableMapSimpleValuePropertyObservableMap extends
		AbstractObservableMap implements IObserving {
	private IObservableMap masterMap;
	private SimpleValueProperty detailProperty;

	private IObservableSet knownMasterValues;
	private Map cachedValues;

	private boolean updating = false;

	private IMapChangeListener masterListener = new IMapChangeListener() {
		public void handleMapChange(final MapChangeEvent event) {
			if (!isDisposed()) {
				updateKnownValues();
				if (!updating)
					fireMapChange(convertDiff(event.diff));
			}
		}

		private void updateKnownValues() {
			Set identityKnownValues = new HashSet();
			for (Iterator it = masterMap.values().iterator(); it.hasNext();) {
				identityKnownValues.add(new IdentityWrapper(it.next()));
			}

			knownMasterValues.retainAll(identityKnownValues);
			knownMasterValues.addAll(identityKnownValues);
		}

		private MapDiff convertDiff(MapDiff diff) {
			Map oldValues = new HashMap();
			Map newValues = new HashMap();

			Set addedKeys = diff.getAddedKeys();
			for (Iterator it = addedKeys.iterator(); it.hasNext();) {
				Object key = it.next();
				Object newSource = diff.getNewValue(key);
				Object newValue = detailProperty.getValue(newSource);
				newValues.put(key, newValue);
			}

			Set removedKeys = diff.getRemovedKeys();
			for (Iterator it = removedKeys.iterator(); it.hasNext();) {
				Object key = it.next();
				Object oldSource = diff.getOldValue(key);
				Object oldValue = detailProperty.getValue(oldSource);
				oldValues.put(key, oldValue);
			}

			Set changedKeys = new HashSet(diff.getChangedKeys());
			for (Iterator it = changedKeys.iterator(); it.hasNext();) {
				Object key = it.next();

				Object oldSource = diff.getOldValue(key);
				Object newSource = diff.getNewValue(key);

				Object oldValue = detailProperty.getValue(oldSource);
				Object newValue = detailProperty.getValue(newSource);

				if (Util.equals(oldValue, newValue)) {
					it.remove();
				} else {
					oldValues.put(key, oldValue);
					newValues.put(key, newValue);
				}
			}

			return Diffs.createMapDiff(addedKeys, removedKeys, changedKeys,
					oldValues, newValues);
		}
	};

	private IStaleListener staleListener = new IStaleListener() {
		public void handleStale(StaleEvent staleEvent) {
			fireStale();
		}
	};

	private INativePropertyListener detailListener;

	/**
	 * @param map
	 * @param valueProperty
	 */
	public ObservableMapSimpleValuePropertyObservableMap(IObservableMap map,
			SimpleValueProperty valueProperty) {
		super(map.getRealm());
		this.masterMap = map;
		this.detailProperty = valueProperty;

		IPropertyChangeListener listener = new IPropertyChangeListener() {
			public void handlePropertyChange(PropertyChangeEvent event) {
				notifyIfChanged(event.getSource());
			}
		};
		this.detailListener = detailProperty.adaptListener(listener);
	}

	protected void firstListenerAdded() {
		knownMasterValues = new WritableSet(getRealm());
		cachedValues = new HashMap();
		knownMasterValues.addSetChangeListener(new ISetChangeListener() {
			public void handleSetChange(SetChangeEvent event) {
				for (Iterator it = event.diff.getRemovals().iterator(); it
						.hasNext();) {
					IdentityWrapper wrapper = (IdentityWrapper) it.next();
					Object key = wrapper.unwrap();
					detailProperty.removeListener(key, detailListener);
					cachedValues.remove(wrapper);
				}
				for (Iterator it = event.diff.getAdditions().iterator(); it
						.hasNext();) {
					IdentityWrapper wrapper = (IdentityWrapper) it.next();
					Object key = wrapper.unwrap();
					cachedValues.put(wrapper, detailProperty.getValue(key));
					detailProperty.addListener(key, detailListener);
				}
			}
		});
		for (Iterator it = masterMap.values().iterator(); it.hasNext();) {
			knownMasterValues.add(new IdentityWrapper(it.next()));
		}

		masterMap.addMapChangeListener(masterListener);
		masterMap.addStaleListener(staleListener);
	}

	protected void lastListenerRemoved() {
		masterMap.removeMapChangeListener(masterListener);
		masterMap.removeStaleListener(staleListener);
		if (knownMasterValues != null) {
			knownMasterValues.clear(); // removes attached listeners
			knownMasterValues.dispose();
			knownMasterValues = null;
		}
		cachedValues.clear();
		cachedValues = null;
	}

	private Set entrySet;

	public Set entrySet() {
		getterCalled();
		if (entrySet == null)
			entrySet = new EntrySet();
		return entrySet;
	}

	class EntrySet extends AbstractSet {
		public Iterator iterator() {
			return new Iterator() {
				Iterator it = masterMap.entrySet().iterator();

				public boolean hasNext() {
					getterCalled();
					return it.hasNext();
				}

				public Object next() {
					getterCalled();
					Map.Entry next = (Map.Entry) it.next();
					return new MapEntry(next.getKey());
				}

				public void remove() {
					it.remove();
				}
			};
		}

		public int size() {
			return masterMap.size();
		}
	}

	class MapEntry implements Map.Entry {
		private Object key;

		MapEntry(Object key) {
			this.key = key;
		}

		public Object getKey() {
			getterCalled();
			return key;
		}

		public Object getValue() {
			getterCalled();
			if (!masterMap.containsKey(key))
				return null;
			return detailProperty.getValue(masterMap.get(key));
		}

		public Object setValue(Object value) {
			if (!masterMap.containsKey(key))
				return null;
			Object source = masterMap.get(key);

			Object oldValue = detailProperty.getValue(source);

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

			notifyIfChanged(source);

			return oldValue;
		}

		public boolean equals(Object o) {
			getterCalled();
			if (o == this)
				return true;
			if (o == null)
				return false;
			if (!(o instanceof Map.Entry))
				return false;
			Map.Entry that = (Map.Entry) o;
			return Util.equals(this.getKey(), that.getKey())
					&& Util.equals(this.getValue(), that.getValue());
		}

		public int hashCode() {
			getterCalled();
			Object value = getValue();
			return (key == null ? 0 : key.hashCode())
					^ (value == null ? 0 : value.hashCode());
		}
	}

	public Object put(Object key, Object value) {
		if (!masterMap.containsKey(key))
			return null;
		Object masterValue = masterMap.get(key);
		Object oldValue = detailProperty.getValue(key);
		detailProperty.setValue(masterValue, value);
		notifyIfChanged(masterValue);
		return oldValue;
	}

	private void notifyIfChanged(Object masterValue) {
		if (cachedValues != null) {
			final Set keys = keysFor(masterValue);

			final Object oldValue = cachedValues.get(new IdentityWrapper(
					masterValue));
			final Object newValue = detailProperty.getValue(masterValue);

			if (!Util.equals(oldValue, newValue)) {
				cachedValues.put(new IdentityWrapper(masterValue), newValue);
				fireMapChange(new MapDiff() {
					public Set getAddedKeys() {
						return Collections.EMPTY_SET;
					}

					public Set getChangedKeys() {
						return keys;
					}

					public Set getRemovedKeys() {
						return Collections.EMPTY_SET;
					}

					public Object getNewValue(Object key) {
						return newValue;
					}

					public Object getOldValue(Object key) {
						return oldValue;
					}
				});
			}
		}
	}

	private Set keysFor(Object value) {
		Set keys = new HashSet();

		for (Iterator it = masterMap.entrySet().iterator(); it.hasNext();) {
			Map.Entry entry = (Entry) it.next();
			if (entry.getValue() == value) {
				keys.add(entry.getKey());
			}
		}

		return keys;
	}

	public boolean isStale() {
		getterCalled();
		return masterMap.isStale();
	}

	private void getterCalled() {
		ObservableTracker.getterCalled(this);
	}

	public Object getObserved() {
		return masterMap;
	}

	public synchronized void dispose() {
		if (masterMap != null) {
			masterMap.removeMapChangeListener(masterListener);
			masterMap = null;
		}
		if (knownMasterValues != null) {
			knownMasterValues.clear(); // detaches listeners
			knownMasterValues.dispose();
			knownMasterValues = null;
		}

		masterListener = null;
		detailListener = null;
		detailProperty = null;
		cachedValues = null;

		super.dispose();
	}
}




/*******************************************************************************
 * Copyright (c) 2008 Matthew Hall and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Matthew Hall - initial API and implementation (bug 194734)
 ******************************************************************************/

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

import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.value.AbstractObservableValue;
import org.eclipse.core.databinding.observable.value.ValueDiff;
import org.eclipse.core.databinding.property.INativePropertyListener;
import org.eclipse.core.databinding.property.IProperty;
import org.eclipse.core.databinding.property.IPropertyChangeListener;
import org.eclipse.core.databinding.property.IPropertyObservable;
import org.eclipse.core.databinding.property.PropertyChangeEvent;
import org.eclipse.core.internal.databinding.Util;

/**
 * @since 1.2
 * 
 */
class SimpleValuePropertyObservableValue extends AbstractObservableValue
		implements IPropertyObservable {
	private Object source;
	private SimpleValueProperty property;

	private boolean updating = false;
	private Object cachedValue;

	private INativePropertyListener listener;

	/**
	 * @param realm
	 * @param source
	 * @param property
	 */
	public SimpleValuePropertyObservableValue(Realm realm, Object source,
			SimpleValueProperty property) {
		super(realm);
		this.source = source;
		this.property = property;
	}

	protected void firstListenerAdded() {
		if (!isDisposed()) {
			cachedValue = property.getValue(source);
			if (listener == null) {
				listener = property
						.adaptListener(new IPropertyChangeListener() {
							public void handlePropertyChange(
									final PropertyChangeEvent event) {
								if (!isDisposed() && !updating) {
									getRealm().exec(new Runnable() {
										public void run() {
											notifyIfChanged((ValueDiff) event.diff);
										}
									});
								}
							}
						});
			}
			property.addListener(source, listener);
		}
	}

	protected void lastListenerRemoved() {
		if (listener != null) {
			property.removeListener(source, listener);
		}
		cachedValue = null;
	}

	protected Object doGetValue() {
		notifyIfChanged(null);
		return property.getValue(source);
	}

	protected void doSetValue(Object value) {
		updating = true;
		try {
			property.setValue(source, value);
		} finally {
			updating = false;
		}

		notifyIfChanged(null);
	}

	private void notifyIfChanged(ValueDiff diff) {
		if (hasListeners()) {
			Object oldValue = cachedValue;
			Object newValue = cachedValue = property.getValue(source);
			if (diff == null)
				diff = Diffs.createValueDiff(oldValue, newValue);
			if (hasListeners() && !Util.equals(oldValue, newValue)) {
				fireValueChange(diff);
			}
		}
	}

	public Object getValueType() {
		return property.getValueType();
	}

	public Object getObserved() {
		return source;
	}

	public IProperty getProperty() {
		return property;
	}

	public synchronized void dispose() {
		if (!isDisposed()) {
			if (listener != null)
				property.removeListener(source, listener);
			source = null;
			property = null;
			listener = null;
		}
		super.dispose();
	}
}

Lines 17-23 Link Here

(-)src/org/eclipse/core/databinding/property/value/DelegatingValueProperty.java (-4 / +16 lines)
17	import org.eclipse.core.databinding.observable.set.IObservableSet;	17	import org.eclipse.core.databinding.observable.set.IObservableSet;
18	import org.eclipse.core.databinding.observable.value.IObservableValue;	18	import org.eclipse.core.databinding.observable.value.IObservableValue;
19	import org.eclipse.core.databinding.property.INativePropertyListener;	19	import org.eclipse.core.databinding.property.INativePropertyListener;
20	import org.eclipse.core.databinding.property.IPropertyChangeListener;	20	import org.eclipse.core.databinding.property.ISimplePropertyListener;
		21	import org.eclipse.core.internal.databinding.property.value.ObservableListDelegatingValuePropertyObservableList;
		22	import org.eclipse.core.internal.databinding.property.value.ObservableMapDelegatingValuePropertyObservableMap;
		23	import org.eclipse.core.internal.databinding.property.value.ObservableSetDelegatingValuePropertyObservableMap;
21		24
22	/**	25	/**
23	* @since 1.2	26	* @since 1.2
Lines 35-41 Link Here
35	this.valueType = valueType;	38	this.valueType = valueType;
36	}	39	}
37		40
38	protected final IValueProperty getDelegate(Object source) {	41	/**
		42	* Returns the property to delegate to for the specified source object.
		43	* Repeated calls to this method with the same source object returns the
		44	* same delegate instance.
		45	*
		46	* @param source
		47	* the property source (may be null)
		48	* @return the property to delegate to for the specified source object.
		49	*/
		50	public final IValueProperty getDelegate(Object source) {
39	if (source == null)	51	if (source == null)
40	return null;	52	return null;
41	IValueProperty delegate = doGetDelegate(source);	53	IValueProperty delegate = doGetDelegate(source);
Lines 90-97 Link Here
90	protected void doSetValue(Object source, Object value) {	102	protected void doSetValue(Object source, Object value) {
91	}	103	}
92		104
93	protected INativePropertyListener adaptListener(	105	public INativePropertyListener adaptListener(
94	IPropertyChangeListener listener) {	106	ISimplePropertyListener listener) {
95	return null;	107	return null;
96	}	108	}
97		109

Lines 18-23 Link Here

(-)src/org/eclipse/core/databinding/property/INativePropertyListener.java (+1 lines)
18	* provided when the native listener was constructed.	18	* provided when the native listener was constructed.
19	*	19	*
20	* @since 1.2	20	* @since 1.2
		21	* @see ISimpleProperty#adaptListener(ISimplePropertyListener)
21	*/	22	*/
22	public interface INativePropertyListener {	23	public interface INativePropertyListener {
23	}	24	}




/*******************************************************************************
 * Copyright (c) 2008 Matthew Hall and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Matthew Hall - initial API and implementation (bug 194734)
 *     Matthew Hall - but 194734
 ******************************************************************************/

package org.eclipse.core.databinding.property;

/**
 * Listener for changes to properties on a particular source object
 * 
 * @noextend This interface is not intended to be extended by clients.
 * 
 * @since 1.2
 */
public interface IPropertyChangeListener {
	/**
	 * Handle the property change described in the event.
	 * 
	 * @param event
	 *            an event describing the list change that occured.
	 */
	public void handlePropertyChange(PropertyChangeEvent event);
}




/*******************************************************************************
 * Copyright (c) 2008 Matthew Hall and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Matthew Hall - initial API and implementation (bug 194734)
 ******************************************************************************/

package org.eclipse.core.databinding.property;

import java.util.EventObject;

import org.eclipse.core.databinding.observable.IDiff;
import org.eclipse.core.internal.databinding.Util;

/**
 * Base class for change events in the properties API
 * 
 * @since 1.2
 */
public final class PropertyChangeEvent extends EventObject {
	private static final long serialVersionUID = 1L;

	/**
	 * The property that changed
	 */
	public final IProperty property;

	/**
	 * A diff object describing the change in state, or null for an unknown
	 * change.
	 */
	public final IDiff diff;

	/**
	 * Constructs a PropertyChangeEvent with the given attributes
	 * 
	 * @param source
	 *            the property source
	 * @param property
	 *            the property that changed on the source
	 * @param diff
	 *            a diff describing the change in state, or null if the change
	 *            is unknown.
	 */
	public PropertyChangeEvent(Object source, IProperty property, IDiff diff) {
		super(source);
		this.property = property;
		this.diff = diff;
	}

	public boolean equals(Object obj) {
		if (obj == this)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;

		PropertyChangeEvent that = (PropertyChangeEvent) obj;
		return Util.equals(getSource(), that.getSource())
				&& Util.equals(this.property, that.property)
				&& Util.equals(this.diff, that.diff);
	}

	public int hashCode() {
		int hash = 17;
		hash = hash * 37 + getSource().hashCode();
		hash = hash * 37 + property.hashCode();
		hash = hash * 37 + (diff == null ? 0 : diff.hashCode());
		return hash;
	}
}

Lines 18-24 Link Here

(-)src/org/eclipse/core/databinding/property/list/DelegatingListProperty.java (-4 / +22 lines)
18	import org.eclipse.core.databinding.observable.list.IObservableList;	18	import org.eclipse.core.databinding.observable.list.IObservableList;
19	import org.eclipse.core.databinding.observable.list.ListDiff;	19	import org.eclipse.core.databinding.observable.list.ListDiff;
20	import org.eclipse.core.databinding.property.INativePropertyListener;	20	import org.eclipse.core.databinding.property.INativePropertyListener;
21	import org.eclipse.core.databinding.property.IPropertyChangeListener;	21	import org.eclipse.core.databinding.property.ISimplePropertyListener;
22		22
23	/**	23	/**
24	* @since 1.2	24	* @since 1.2
Lines 37-43 Link Here
37	this.nullProperty = new NullListProperty();	37	this.nullProperty = new NullListProperty();
38	}	38	}
39		39
40	protected final IListProperty getDelegate(Object source) {	40	/**
		41	* Returns the property to delegate to for the specified source object.
		42	* Repeated calls to this method with the same source object returns the
		43	* same delegate instance.
		44	*
		45	* @param source
		46	* the property source (may be null)
		47	* @return the property to delegate to for the specified source object.
		48	*/
		49	public final IListProperty getDelegate(Object source) {
41	if (source == null)	50	if (source == null)
42	return null;	51	return null;
43	IListProperty delegate = doGetDelegate(source);	52	IListProperty delegate = doGetDelegate(source);
Lines 46-51 Link Here
46	return delegate;	55	return delegate;
47	}	56	}
48		57
		58	/**
		59	* Returns the property to delegate to for the specified source object.
		60	* Implementers must ensure that repeated calls to this method with the same
		61	* source object returns the same delegate instance.
		62	*
		63	* @param source
		64	* the property source
		65	* @return the property to delegate to for the specified source object.
		66	*/
49	protected abstract IListProperty doGetDelegate(Object source);	67	protected abstract IListProperty doGetDelegate(Object source);
50		68
51	public Object getElementType() {	69	public Object getElementType() {
Lines 68-75 Link Here
68	protected void doSetList(Object source, List list, ListDiff diff) {	86	protected void doSetList(Object source, List list, ListDiff diff) {
69	}	87	}
70		88
71	protected INativePropertyListener adaptListener(	89	public INativePropertyListener adaptListener(
72	IPropertyChangeListener listener) {	90	ISimplePropertyListener listener) {
73	return null;	91	return null;
74	}	92	}
75		93




/*******************************************************************************
 * Copyright (c) 2008 Matthew Hall and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Matthew Hall - initial API and implementation (bug 194734)
 ******************************************************************************/

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

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.ConcurrentModificationException;
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.ObservableTracker;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.list.AbstractObservableList;
import org.eclipse.core.databinding.observable.list.ListDiff;
import org.eclipse.core.databinding.observable.list.ListDiffEntry;
import org.eclipse.core.databinding.property.IProperty;
import org.eclipse.core.databinding.property.INativePropertyListener;
import org.eclipse.core.databinding.property.IPropertyChangeListener;
import org.eclipse.core.databinding.property.IPropertyObservable;
import org.eclipse.core.databinding.property.PropertyChangeEvent;

/**
 * @since 1.2
 * 
 */
class SimpleListPropertyObservableList extends AbstractObservableList implements
		IPropertyObservable {
	private Object source;
	private SimpleListProperty property;

	private volatile boolean updating = false;

	private volatile int modCount = 0;

	private INativePropertyListener listener;

	private List cachedList;

	/**
	 * @param realm
	 * @param source
	 * @param property
	 */
	public SimpleListPropertyObservableList(Realm realm, Object source,
			SimpleListProperty property) {
		super(realm);
		this.source = source;
		this.property = property;
	}

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

			if (listener == null) {
				listener = property
						.adaptListener(new IPropertyChangeListener() {
							public void handlePropertyChange(
									final PropertyChangeEvent event) {
								modCount++;
								if (!isDisposed() && !updating) {
									getRealm().exec(new Runnable() {
										public void run() {
											notifyIfChanged((ListDiff) event.diff);
										}
									});
								}
							}
						});
			}
			property.addListener(source, listener);
		}
	}

	protected void lastListenerRemoved() {
		if (listener != null) {
			property.removeListener(source, listener);
		}

		cachedList = null;
	}

	private void getterCalled() {
		ObservableTracker.getterCalled(this);
	}

	public Object getElementType() {
		return property.getElementType();
	}

	// 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;
		updating = true;
		List list = new ArrayList(getList());
		list.add(index, o);
		ListDiff diff = Diffs.createListDiff(Diffs.createListDiffEntry(index,
				true, o));
		try {
			property.setList(source, list, diff);
			modCount++;
		} finally {
			updating = wasUpdating;
		}

		notifyIfChanged(null);
	}

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

			public void remove() {
				checkRealm();
				checkForComodification();
				if (lastIndex == -1)
					throw new IllegalStateException();

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

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

				notifyIfChanged(null);

				lastElement = null;
				lastIndex = -1;

				expectedModCount = modCount;
			}

			private void checkForComodification() {
				if (expectedModCount != modCount)
					throw new ConcurrentModificationException();
			}
		};
	}

	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;
		updating = true;
		try {
			property.setList(source, list, diff);
			modCount++;
		} finally {
			updating = wasUpdating;
		}

		notifyIfChanged(null);

		return element;
	}

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

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

		remove(index);

		return true;
	}

	public ListIterator listIterator() {
		return listIterator(0);
	}

	public ListIterator listIterator(final int index) {
		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;
				updating = true;
				try {
					property.setList(source, list, diff);
					modCount++;
				} finally {
					updating = wasUpdating;
				}

				notifyIfChanged(null);

				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;
				updating = true;
				try {
					property.setList(source, list, diff);
					modCount++;
				} finally {
					updating = wasUpdating;
				}

				notifyIfChanged(null);

				lastElement = o;
				expectedModCount = modCount;
			}

			public void remove() {
				checkRealm();
				checkForComodification();
				if (lastIndex == -1)
					throw new IllegalStateException();

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

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

				notifyIfChanged(null);

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

			private void checkForComodification() {
				if (expectedModCount != modCount)
					throw new ConcurrentModificationException();
			}
		};
	}

	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;
		updating = true;
		try {
			property.setList(source, list, diff);
			modCount++;
		} finally {
			updating = wasUpdating;
		}

		notifyIfChanged(null);

		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;
		updating = true;
		try {
			property.setList(source, list, diff);
			modCount++;
		} finally {
			updating = wasUpdating;
		}

		notifyIfChanged(null);

		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) {
		checkRealm();

		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();) {
			Object element = it.next();
			entries[offsetIndex] = Diffs.createListDiffEntry(index
					+ offsetIndex, true, element);
			offsetIndex++;
		}
		ListDiff diff = Diffs.createListDiff(entries);

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

		notifyIfChanged(null);

		return true;
	}

	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;
		updating = true;
		try {
			for (ListIterator it = list.listIterator(); it.hasNext();) {
				Object element = it.next();
				int index = it.previousIndex();
				if (c.contains(element)) {
					it.remove();
					entries.add(Diffs
							.createListDiffEntry(index, false, element));
				}
			}
			if (entries.isEmpty())
				return false;

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

		notifyIfChanged(null);

		return !diff.isEmpty();
	}

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

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

		if (c.isEmpty()) {
			clear();
			return true;
		}

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

		boolean wasUpdating = updating;
		updating = true;
		try {
			for (ListIterator it = list.listIterator(); it.hasNext();) {
				Object element = it.next();
				int index = it.previousIndex();
				if (!c.contains(element)) {
					it.remove();
					entries.add(Diffs
							.createListDiffEntry(index, false, element));
				}
			}
			if (entries.isEmpty())
				return false;

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

		notifyIfChanged(null);

		return !diff.isEmpty();
	}

	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;
		updating = true;
		try {
			property.setList(source, Collections.EMPTY_LIST, diff);
			modCount++;
		} finally {
			updating = wasUpdating;
		}

		notifyIfChanged(null);
	}

	private void notifyIfChanged(ListDiff diff) {
		if (hasListeners()) {
			List oldList = cachedList;
			List newList = cachedList = property.getList(source);
			if (diff == null)
				diff = Diffs.computeListDiff(oldList, newList);
			if (!diff.isEmpty()) {
				fireListChange(diff);
			}
		}
	}

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

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

	public Object getObserved() {
		return source;
	}

	public IProperty getProperty() {
		return property;
	}

	public synchronized void dispose() {
		if (!isDisposed()) {
			if (listener != null)
				property.removeListener(source, listener);
			property = null;
			source = null;
			listener = null;
		}
		super.dispose();
	}
}




import java.util.Collections;
import java.util.List;

import org.eclipse.core.databinding.observable.IDiff;
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.property.INativePropertyListener;
import org.eclipse.core.databinding.property.ISimplePropertyListener;
import org.eclipse.core.internal.databinding.property.list.SimpleListPropertyObservableList;

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

 * <li> {@link #getElementType()}
 * <li> {@link #doGetList(Object)}
 * <li> {@link #doSetList(Object, List, ListDiff)}
 * <li> {@link #adaptListener(ISimplePropertyListener)}
 * <li> {@link #doAddListener(Object, INativePropertyListener)}
 * <li> {@link #doRemoveListener(Object, INativePropertyListener)}
 * </ul>

 * 
 * @since 1.2
 */
public abstract class SimpleListProperty extends ListProperty implements
		ISimpleListProperty {
	public IObservableList observe(Realm realm, Object source) {
		return new SimpleListPropertyObservableList(realm, source, this);
	}

	// Accessors

	public final Object get(Object source) {
	 * 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) {
		if (source == null)
			return Collections.EMPTY_LIST;
		return Collections.unmodifiableList(doGetList(source));


	// Mutators

	public final void set(Object source, Object value, IDiff diff) {
		List list = (List) value;
		ListDiff listDiff = (ListDiff) diff;
		if (source != null && !listDiff.isEmpty())
			doSetList(source, list, listDiff);
	 * @param list
	 *            the new list
	 * @param diff
	 *            a diff describing the change
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected final void setList(Object source, List list, ListDiff diff) {
		if (source != null && !diff.isEmpty())
			doSetList(source, list, diff);
	}

	/**

	 */
	protected abstract void doSetList(Object source, List list, ListDiff diff);

	public abstract INativePropertyListener adaptListener(
			ISimplePropertyListener listener);
	 * the expected source object, and which parlays property change events from
	 * the source object to the given listener. If there is no listener API for
	 * this property, this method returns null.
	 * 
	 * @param listener
	 *            the property listener to receive events
	 * @return a native listener which parlays property change events to the
	 *         specified listener.
	 * @throws ClassCastException
	 *             if the provided listener does not implement the correct
	 *             listener interface (IValueProperty, IListProperty,
	 *             ISetProperty or IMapProperty) depending on the property.
	 * @noreference This method is not intended to be referenced by clients.
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected abstract INativePropertyListener adaptListener(
			IPropertyChangeListener listener);

	public final void addListener(Object source,
	 * 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(IPropertyChangeListener)}
	 * returns null), this method does nothing.
	 * 
	 * @param source
	 *            the property source
	 * @param listener
	 *            a listener obtained from calling
	 *            {@link #adaptListener(IPropertyChangeListener)}.
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected final void addListener(Object source,
			INativePropertyListener listener) {
		if (source != null)
			doAddListener(source, listener);

	/**
	 * 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(ISimplePropertyListener)}
	 * returns null), this method does nothing.
	 * 
	 * @param source
	 *            the property source
	 * @param listener
	 *            a listener obtained from calling
	 *            {@link #adaptListener(ISimplePropertyListener)}.
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected abstract void doAddListener(Object source,
			INativePropertyListener listener);

	public final void removeListener(Object source,
	 * 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(IPropertyChangeListener)}
	 * returns null), this method does nothing.
	 * 
	 * @param source
	 *            the property source
	 * @param listener
	 *            a listener obtained from calling
	 *            {@link #adaptListener(IPropertyChangeListener)}.
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected final void removeListener(Object source,
			INativePropertyListener listener) {
		if (source != null)
			doRemoveListener(source, listener);

	/**
	 * 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(ISimplePropertyListener)}
	 * returns null), this method does nothing.
	 * 
	 * @param source
	 *            the property source
	 * @param listener
	 *            a listener obtained from calling
	 *            {@link #adaptListener(ISimplePropertyListener)}.
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected abstract void doRemoveListener(Object source,




/*******************************************************************************
 * Copyright (c) 2008 Matthew Hall and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Matthew Hall - initial API and implementation (bug 194734)
 ******************************************************************************/

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

import java.util.Collection;
import java.util.Collections;
import java.util.ConcurrentModificationException;
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.Realm;
import org.eclipse.core.databinding.observable.set.AbstractObservableSet;
import org.eclipse.core.databinding.observable.set.SetDiff;
import org.eclipse.core.databinding.property.IProperty;
import org.eclipse.core.databinding.property.INativePropertyListener;
import org.eclipse.core.databinding.property.IPropertyChangeListener;
import org.eclipse.core.databinding.property.IPropertyObservable;
import org.eclipse.core.databinding.property.PropertyChangeEvent;

/**
 * @since 1.2
 * 
 */
class SimpleSetPropertyObservableSet extends AbstractObservableSet implements
		IPropertyObservable {
	private Object source;
	private SimpleSetProperty property;

	private volatile boolean updating = false;

	private volatile int modCount = 0;

	private INativePropertyListener listener;

	private Set cachedSet;

	/**
	 * @param realm
	 * @param source
	 * @param property
	 */
	public SimpleSetPropertyObservableSet(Realm realm, Object source,
			SimpleSetProperty property) {
		super(realm);
		this.source = source;
		this.property = property;
	}

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

			if (listener == null) {
				listener = property
						.adaptListener(new IPropertyChangeListener() {
							public void handlePropertyChange(
									final PropertyChangeEvent event) {
								modCount++;
								if (!isDisposed() && !updating) {
									getRealm().exec(new Runnable() {
										public void run() {
											notifyIfChanged((SetDiff) event.diff);
										}
									});
								}
							}
						});
			}
			property.addListener(source, listener);
		}
	}

	protected void lastListenerRemoved() {
		if (listener != null) {
			property.removeListener(source, listener);
		}

		cachedSet = null;
	}

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

	public Object getElementType() {
		return property.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);
	}

	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;
		updating = true;
		try {
			property.setSet(source, set, diff);
			modCount++;
		} finally {
			updating = wasUpdating;
		}

		notifyIfChanged(null);

		return true;
	}

	public Iterator iterator() {
		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;
			}

			public void remove() {
				checkRealm();
				checkForComodification();

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

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

				notifyIfChanged(null);

				last = null;
				expectedModCount = modCount;
			}

			private void checkForComodification() {
				if (expectedModCount != modCount)
					throw new ConcurrentModificationException();
			}
		};
	}

	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;
		updating = true;
		try {
			property.setSet(source, set, diff);
			modCount++;
		} finally {
			updating = wasUpdating;
		}

		notifyIfChanged(null);

		return true;
	}

	// Bulk change operations

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

		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;
		updating = true;
		try {
			property.setSet(source, set, diff);
			modCount++;
		} finally {
			updating = wasUpdating;
		}

		notifyIfChanged(null);

		return true;
	}

	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;
		updating = true;
		try {
			property.setSet(source, set, diff);
			modCount++;
		} finally {
			updating = wasUpdating;
		}

		notifyIfChanged(null);

		return true;
	}

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

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

		if (c.isEmpty()) {
			clear();
			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;
		updating = true;
		try {
			property.setSet(source, set, diff);
			modCount++;
		} finally {
			updating = wasUpdating;
		}

		notifyIfChanged(null);

		return true;
	}

	public void clear() {
		getterCalled();

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

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

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

		notifyIfChanged(null);
	}

	private void notifyIfChanged(SetDiff diff) {
		if (hasListeners()) {
			Set oldSet = cachedSet;
			Set newSet = cachedSet = property.getSet(source);
			if (diff == null)
				diff = Diffs.computeSetDiff(oldSet, newSet);
			if (!diff.isEmpty())
				fireSetChange(diff);
		}
	}

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

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

	public Object getObserved() {
		return source;
	}

	public IProperty getProperty() {
		return property;
	}

	public synchronized void dispose() {
		if (!isDisposed()) {
			if (listener != null)
				property.removeListener(source, listener);
			property = null;
			source = null;
			listener = null;
		}
		super.dispose();
	}
}

Lines 18-24 Link Here

(-)src/org/eclipse/core/databinding/property/set/DelegatingSetProperty.java (-3 / +21 lines)
18	import org.eclipse.core.databinding.observable.set.IObservableSet;	18	import org.eclipse.core.databinding.observable.set.IObservableSet;
19	import org.eclipse.core.databinding.observable.set.SetDiff;	19	import org.eclipse.core.databinding.observable.set.SetDiff;
20	import org.eclipse.core.databinding.property.INativePropertyListener;	20	import org.eclipse.core.databinding.property.INativePropertyListener;
21	import org.eclipse.core.databinding.property.IPropertyChangeListener;	21	import org.eclipse.core.databinding.property.ISimplePropertyListener;
22		22
23	/**	23	/**
24	* @since 1.2	24	* @since 1.2
Lines 36-41 Link Here
36	this.elementType = elementType;	36	this.elementType = elementType;
37	}	37	}
38		38
		39	/**
		40	* Returns the property to delegate to for the specified source object.
		41	* Repeated calls to this method with the same source object returns the
		42	* same delegate instance.
		43	*
		44	* @param source
		45	* the property source (may be null)
		46	* @return the property to delegate to for the specified source object.
		47	*/
39	protected final ISetProperty getDelegate(Object source) {	48	protected final ISetProperty getDelegate(Object source) {
40	if (source == null)	49	if (source == null)
41	return null;	50	return null;
Lines 45-50 Link Here
45	return delegate;	54	return delegate;
46	}	55	}
47		56
		57	/**
		58	* Returns the property to delegate to for the specified source object.
		59	* Implementers must ensure that repeated calls to this method with the same
		60	* source object returns the same delegate instance.
		61	*
		62	* @param source
		63	* the property source
		64	* @return the property to delegate to for the specified source object.
		65	*/
48	protected abstract ISetProperty doGetDelegate(Object source);	66	protected abstract ISetProperty doGetDelegate(Object source);
49		67
50	public Object getElementType() {	68	public Object getElementType() {
Lines 67-74 Link Here
67	protected void doSetSet(Object source, Set set, SetDiff diff) {	85	protected void doSetSet(Object source, Set set, SetDiff diff) {
68	}	86	}
69		87
70	protected INativePropertyListener adaptListener(	88	public INativePropertyListener adaptListener(
71	IPropertyChangeListener listener) {	89	ISimplePropertyListener listener) {
72	return null;	90	return null;
73	}	91	}
74		92




import java.util.Collections;
import java.util.Set;

import org.eclipse.core.databinding.observable.IDiff;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.set.IObservableSet;
import org.eclipse.core.databinding.observable.set.SetDiff;
import org.eclipse.core.databinding.property.INativePropertyListener;
import org.eclipse.core.databinding.property.ISimplePropertyListener;
import org.eclipse.core.internal.databinding.property.set.SimpleSetPropertyObservableSet;

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

 * <li> {@link #getElementType()}
 * <li> {@link #doGetSet(Object)}
 * <li> {@link #doSetSet(Object, Set, SetDiff)}
 * <li> {@link #adaptListener(ISimplePropertyListener)}
 * <li> {@link #doAddListener(Object, INativePropertyListener)}
 * <li> {@link #doRemoveListener(Object, INativePropertyListener)}
 * </ul>

 * 
 * @since 1.2
 */
public abstract class SimpleSetProperty extends SetProperty implements
		ISimpleSetProperty {
	public IObservableSet observe(Realm realm, Object source) {
		return new SimpleSetPropertyObservableSet(realm, source, this);
	}

	// Accessors

	public final Object get(Object source) {
	 * Returns a Set with the current contents of the source's set property
	 * 
	 * @param source
	 *            the property source
	 * @return a Set with the current contents of the source's set property
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected final Set getSet(Object source) {
		if (source == null)
			return Collections.EMPTY_SET;
		return Collections.unmodifiableSet(doGetSet(source));


	// Mutators

	public final void set(Object source, Object value, IDiff diff) {
		Set set = (Set) value;
		SetDiff setDiff = (SetDiff) diff;
		if (source != null && !setDiff.isEmpty())
			doSetSet(source, set, setDiff);
	 * @param set
	 *            the new set
	 * @param diff
	 *            a diff describing the change
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected final void setSet(Object source, Set set, SetDiff diff) {
		if (source != null && !diff.isEmpty())
			doSetSet(source, set, diff);
	}

	/**


	// Listeners

	public abstract INativePropertyListener adaptListener(
			ISimplePropertyListener listener);
	 * the expected source object, and which parlays property change events from
	 * the source object to the given listener. If there is no listener API for
	 * this property, this method returns null.
	 * 
	 * @param listener
	 *            the property listener to receive events
	 * @return a native listener which parlays property change events to the
	 *         specified listener.
	 * @throws ClassCastException
	 *             if the provided listener does not implement the correct
	 *             listener interface (IValueProperty, IListProperty,
	 *             ISetProperty or IMapProperty) depending on the property.
	 * @noreference This method is not intended to be referenced by clients.
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected abstract INativePropertyListener adaptListener(
			IPropertyChangeListener listener);

	public final void addListener(Object source,
	 * 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(IPropertyChangeListener)}
	 * returns null), this method does nothing.
	 * 
	 * @param source
	 *            the property source
	 * @param listener
	 *            a listener obtained from calling
	 *            {@link #adaptListener(IPropertyChangeListener)}.
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected final void addListener(Object source,
			INativePropertyListener listener) {
		if (source != null)
			doAddListener(source, listener);

	/**
	 * 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(ISimplePropertyListener)}
	 * returns null), this method does nothing.
	 * 
	 * @param source
	 *            the property source
	 * @param listener
	 *            a listener obtained from calling
	 *            {@link #adaptListener(ISimplePropertyListener)}.
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected abstract void doAddListener(Object source,
			INativePropertyListener listener);

	public final void removeListener(Object source,
	 * 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(IPropertyChangeListener)}
	 * returns null), this method does nothing.
	 * 
	 * @param source
	 *            the property source
	 * @param listener
	 *            a listener obtained from calling
	 *            {@link #adaptListener(IPropertyChangeListener)} .
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected final void removeListener(Object source,
			INativePropertyListener listener) {
		if (source != null)
			doRemoveListener(source, listener);

	/**
	 * 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(ISimplePropertyListener)}
	 * returns null), this method does nothing.
	 * 
	 * @param source
	 *            the property source
	 * @param listener
	 *            a listener obtained from calling
	 *            {@link #adaptListener(ISimplePropertyListener)} .
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected abstract void doRemoveListener(Object source,




/*******************************************************************************
 * Copyright (c) 2008 Matthew Hall and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Matthew Hall - initial API and implementation (bug 194734)
 ******************************************************************************/

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

import java.util.AbstractSet;
import java.util.Collection;
import java.util.Collections;
import java.util.ConcurrentModificationException;
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.ObservableTracker;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.map.AbstractObservableMap;
import org.eclipse.core.databinding.observable.map.MapDiff;
import org.eclipse.core.databinding.property.INativePropertyListener;
import org.eclipse.core.databinding.property.IProperty;
import org.eclipse.core.databinding.property.IPropertyObservable;
import org.eclipse.core.databinding.property.ISimplePropertyListener;
import org.eclipse.core.databinding.property.SimplePropertyEvent;
import org.eclipse.core.databinding.property.map.ISimpleMapProperty;

/**
 * @since 1.2
 */
public class SimpleMapPropertyObservableMap extends AbstractObservableMap
		implements IPropertyObservable {
	private Object source;
	private ISimpleMapProperty property;

	private volatile boolean updating = false;

	private volatile int modCount = 0;

	private INativePropertyListener listener;

	private Map cachedMap;

	/**
	 * @param realm
	 * @param source
	 * @param property
	 */
	public SimpleMapPropertyObservableMap(Realm realm, Object source,
			ISimpleMapProperty property) {
		super(realm);
		this.source = source;
		this.property = property;
	}

	public Object getKeyType() {
		return property.getKeyType();
	}

	public Object getValueType() {
		return property.getValueType();
	}

	private void getterCalled() {
		ObservableTracker.getterCalled(this);
	}

	protected void firstListenerAdded() {
		if (!isDisposed()) {
			cachedMap = new HashMap(this);

			if (listener == null) {
				listener = property
						.adaptListener(new ISimplePropertyListener() {
							public void handlePropertyChange(
									final SimplePropertyEvent event) {
								modCount++;
								if (!isDisposed() && !updating) {
									getRealm().exec(new Runnable() {
										public void run() {
											notifyIfChanged((MapDiff) event.diff);
										}
									});
								}
							}
						});
			}
			property.addListener(source, listener);
		}
	}

	protected void lastListenerRemoved() {
		if (listener != null) {
			property.removeListener(source, listener);
		}

		cachedMap.clear();
		cachedMap = null;
	}

	// Queries

	private Map getMap() {
		return (Map) property.get(source);
	}

	// Single change operations

	private EntrySet es = new EntrySet();

	public Set entrySet() {
		getterCalled();
		return es;
	}

	private class EntrySet extends AbstractSet {
		public Iterator iterator() {
			return new EntrySetIterator();
		}

		public int size() {
			return getMap().size();
		}
	}

	private class EntrySetIterator implements Iterator {
		private volatile int expectedModCount = modCount;
		Map map = new HashMap(getMap());
		Iterator iterator = map.entrySet().iterator();
		Map.Entry last = null;

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

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

		public void remove() {
			getterCalled();
			checkForComodification();

			iterator.remove(); // stay in sync
			MapDiff diff = Diffs.createMapDiffSingleRemove(last.getKey(), last
					.getValue());

			boolean wasUpdating = updating;
			updating = true;
			try {
				property.set(source, map, diff);
			} finally {
				updating = wasUpdating;
			}

			notifyIfChanged(null);

			last = null;
			expectedModCount = modCount;
		}

		private void checkForComodification() {
			if (expectedModCount != modCount)
				throw new ConcurrentModificationException();
		}
	}

	public Set keySet() {
		getterCalled();
		// AbstractMap depends on entrySet() to fulfil keySet() API, so all
		// getterCalled() and comodification checks will still be handled
		return super.keySet();
	}

	public Object put(Object key, Object value) {
		checkRealm();

		Map map = new HashMap(getMap());

		boolean add = !map.containsKey(key);

		Object oldValue = map.put(key, value);

		MapDiff diff;
		if (add)
			diff = Diffs.createMapDiffSingleAdd(key, value);
		else
			diff = Diffs.createMapDiffSingleChange(key, oldValue, value);

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

		notifyIfChanged(null);

		return oldValue;
	}

	public void putAll(Map m) {
		checkRealm();

		Map map = new HashMap(getMap());

		Map oldValues = new HashMap();
		Map newValues = new HashMap();
		Set changedKeys = new HashSet();
		Set addedKeys = new HashSet();
		for (Iterator it = m.entrySet().iterator(); it.hasNext();) {
			Map.Entry entry = (Entry) it.next();
			Object key = entry.getKey();
			Object newValue = entry.getValue();
			if (map.containsKey(key)) {
				changedKeys.add(key);
				oldValues.put(key, map.get(key));
			} else {
				addedKeys.add(key);
			}
			map.put(key, newValue);

			newValues.put(key, newValue);
		}

		MapDiff diff = Diffs.createMapDiff(addedKeys, Collections.EMPTY_SET,
				changedKeys, oldValues, newValues);

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

		notifyIfChanged(null);
	}

	public Object remove(Object key) {
		checkRealm();
		return super.remove(key);
	}

	public Collection values() {
		getterCalled();
		// AbstractMap depends on entrySet() to fulfil values() API, so all
		// getterCalled() and comodification checks will still be handled
		return super.values();
	}

	private void notifyIfChanged(MapDiff diff) {
		if (hasListeners()) {
			Map oldMap = cachedMap;
			Map newMap = cachedMap = (Map) property.get(source);
			if (diff == null)
				diff = Diffs.computeMapDiff(oldMap, newMap);
			if (!diff.isEmpty())
				fireMapChange(diff);
		}
	}

	public Object getObserved() {
		return source;
	}

	public IProperty getProperty() {
		return property;
	}

	public synchronized void dispose() {
		if (!isDisposed()) {
			if (listener != null)
				property.removeListener(source, listener);
			property = null;
			source = null;
			listener = null;
		}
		super.dispose();
	}
}




/*******************************************************************************
 * Copyright (c) 2008 Matthew Hall and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Matthew Hall - initial API and implementation (bug 194734)
 ******************************************************************************/

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

import java.util.Collection;
import java.util.Collections;
import java.util.ConcurrentModificationException;
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.Realm;
import org.eclipse.core.databinding.observable.set.AbstractObservableSet;
import org.eclipse.core.databinding.observable.set.SetDiff;
import org.eclipse.core.databinding.property.INativePropertyListener;
import org.eclipse.core.databinding.property.IProperty;
import org.eclipse.core.databinding.property.IPropertyObservable;
import org.eclipse.core.databinding.property.ISimplePropertyListener;
import org.eclipse.core.databinding.property.SimplePropertyEvent;
import org.eclipse.core.databinding.property.set.ISimpleSetProperty;

/**
 * @since 1.2
 * 
 */
public class SimpleSetPropertyObservableSet extends AbstractObservableSet
		implements IPropertyObservable {
	private Object source;
	private ISimpleSetProperty property;

	private volatile boolean updating = false;

	private volatile int modCount = 0;

	private INativePropertyListener listener;

	private Set cachedSet;

	/**
	 * @param realm
	 * @param source
	 * @param property
	 */
	public SimpleSetPropertyObservableSet(Realm realm, Object source,
			ISimpleSetProperty property) {
		super(realm);
		this.source = source;
		this.property = property;
	}

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

			if (listener == null) {
				listener = property
						.adaptListener(new ISimplePropertyListener() {
							public void handlePropertyChange(
									final SimplePropertyEvent event) {
								modCount++;
								if (!isDisposed() && !updating) {
									getRealm().exec(new Runnable() {
										public void run() {
											notifyIfChanged((SetDiff) event.diff);
										}
									});
								}
							}
						});
			}
			property.addListener(source, listener);
		}
	}

	protected void lastListenerRemoved() {
		if (listener != null) {
			property.removeListener(source, listener);
		}

		cachedSet = null;
	}

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

	public Object getElementType() {
		return property.getElementType();
	}

	// Queries

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

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

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

	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;
		updating = true;
		try {
			property.set(source, set, diff);
			modCount++;
		} finally {
			updating = wasUpdating;
		}

		notifyIfChanged(null);

		return true;
	}

	public Iterator iterator() {
		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;
			}

			public void remove() {
				checkRealm();
				checkForComodification();

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

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

				notifyIfChanged(null);

				last = null;
				expectedModCount = modCount;
			}

			private void checkForComodification() {
				if (expectedModCount != modCount)
					throw new ConcurrentModificationException();
			}
		};
	}

	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;
		updating = true;
		try {
			property.set(source, set, diff);
			modCount++;
		} finally {
			updating = wasUpdating;
		}

		notifyIfChanged(null);

		return true;
	}

	// Bulk change operations

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

		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;
		updating = true;
		try {
			property.set(source, set, diff);
			modCount++;
		} finally {
			updating = wasUpdating;
		}

		notifyIfChanged(null);

		return true;
	}

	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;
		updating = true;
		try {
			property.set(source, set, diff);
			modCount++;
		} finally {
			updating = wasUpdating;
		}

		notifyIfChanged(null);

		return true;
	}

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

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

		if (c.isEmpty()) {
			clear();
			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;
		updating = true;
		try {
			property.set(source, set, diff);
			modCount++;
		} finally {
			updating = wasUpdating;
		}

		notifyIfChanged(null);

		return true;
	}

	public void clear() {
		getterCalled();

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

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

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

		notifyIfChanged(null);
	}

	private void notifyIfChanged(SetDiff diff) {
		if (hasListeners()) {
			Set oldSet = cachedSet;
			Set newSet = cachedSet = (Set) property.get(source);
			if (diff == null)
				diff = Diffs.computeSetDiff(oldSet, newSet);
			if (!diff.isEmpty())
				fireSetChange(diff);
		}
	}

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

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

	public Object getObserved() {
		return source;
	}

	public IProperty getProperty() {
		return property;
	}

	public synchronized void dispose() {
		if (!isDisposed()) {
			if (listener != null)
				property.removeListener(source, listener);
			property = null;
			source = null;
			listener = null;
		}
		super.dispose();
	}
}




/*******************************************************************************
 * Copyright (c) 2008 Matthew Hall and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Matthew Hall - initial API and implementation (bug 194734)
 ******************************************************************************/

package org.eclipse.core.internal.databinding.property.value;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.observable.map.ComputedObservableMap;
import org.eclipse.core.databinding.observable.set.IObservableSet;
import org.eclipse.core.databinding.property.INativePropertyListener;
import org.eclipse.core.databinding.property.IProperty;
import org.eclipse.core.databinding.property.IPropertyObservable;
import org.eclipse.core.databinding.property.ISimplePropertyListener;
import org.eclipse.core.databinding.property.SimplePropertyEvent;
import org.eclipse.core.databinding.property.value.ISimpleValueProperty;
import org.eclipse.core.internal.databinding.Util;

/**
 * @since 1.2
 */
public class ObservableSetSimpleValuePropertyObservableMap extends
		ComputedObservableMap implements IPropertyObservable {
	private ISimpleValueProperty detailProperty;

	private INativePropertyListener listener;

	private Map cachedValues;

	private boolean updating;

	/**
	 * @param keySet
	 * @param valueProperty
	 */
	public ObservableSetSimpleValuePropertyObservableMap(IObservableSet keySet,
			ISimpleValueProperty valueProperty) {
		super(keySet);
		this.detailProperty = valueProperty;
	}

	protected void firstListenerAdded() {
		cachedValues = new HashMap(this);
		if (listener == null) {
			listener = detailProperty
					.adaptListener(new ISimplePropertyListener() {
						public void handlePropertyChange(
								final SimplePropertyEvent event) {
							if (!isDisposed() && !updating) {
								getRealm().exec(new Runnable() {
									public void run() {
										notifyIfChanged(event.getSource());
									}
								});
							}
						}
					});
		}
		super.firstListenerAdded();
	}

	protected void lastListenerRemoved() {
		super.lastListenerRemoved();
		cachedValues.clear();
		cachedValues = null;
	}

	protected void hookListener(Object addedKey) {
		if (listener != null) {
			cachedValues.put(addedKey, detailProperty.get(addedKey));
			detailProperty.addListener(addedKey, listener);
		}
	}

	protected void unhookListener(Object removedKey) {
		if (listener != null) {
			detailProperty.removeListener(removedKey, listener);
			cachedValues.remove(removedKey);
		}
	}

	protected Object doGet(Object key) {
		return detailProperty.get(key);
	}

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

		updating = true;
		try {
			detailProperty.set(key, value, Diffs.createValueDiff(oldValue,
					value));
		} finally {
			updating = false;
		}

		notifyIfChanged(key);

		return oldValue;
	}

	private void notifyIfChanged(Object key) {
		if (cachedValues != null) {
			Object oldValue = cachedValues.get(key);
			Object newValue = detailProperty.get(key);
			if (!Util.equals(oldValue, newValue)) {
				cachedValues.put(key, newValue);
				fireMapChange(Diffs.createMapDiffSingleChange(key, oldValue,
						newValue));
			}
		}
	}

	public Object getObserved() {
		return keySet();
	}

	public IProperty getProperty() {
		return detailProperty;
	}

	public synchronized void dispose() {
		if (!isDisposed()) {
			if (listener != null) {
				for (Iterator it = values().iterator(); it.hasNext();) {
					unhookListener(it.next());
				}
				listener = null;
			}
			detailProperty = null;
		}

		super.dispose();
	}
}




/*******************************************************************************
 * Copyright (c) 2008 Matthew Hall and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Matthew Hall - initial API and implementation (bug 194734)
 ******************************************************************************/

package org.eclipse.core.internal.databinding.property.value;

import java.util.AbstractSet;
import java.util.Collections;
import java.util.HashMap;
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.IStaleListener;
import org.eclipse.core.databinding.observable.ObservableTracker;
import org.eclipse.core.databinding.observable.StaleEvent;
import org.eclipse.core.databinding.observable.map.AbstractObservableMap;
import org.eclipse.core.databinding.observable.map.MapDiff;
import org.eclipse.core.databinding.observable.set.IObservableSet;
import org.eclipse.core.databinding.observable.set.ISetChangeListener;
import org.eclipse.core.databinding.observable.set.SetChangeEvent;
import org.eclipse.core.databinding.observable.set.SetDiff;
import org.eclipse.core.databinding.property.IProperty;
import org.eclipse.core.databinding.property.IPropertyObservable;
import org.eclipse.core.databinding.property.value.DelegatingValueProperty;
import org.eclipse.core.internal.databinding.Util;

/**
 * @since 1.2
 */
public class ObservableSetDelegatingValuePropertyObservableMap extends
		AbstractObservableMap implements IPropertyObservable {
	private IObservableSet masterSet;
	private DelegatingValueProperty detailProperty;
	private DelegatingCache cache;

	private Set entrySet;

	class EntrySet extends AbstractSet {
		public Iterator iterator() {
			return new Iterator() {
				final Iterator it = masterSet.iterator();

				public boolean hasNext() {
					return it.hasNext();
				}

				public Object next() {
					return new MapEntry(it.next());
				}

				public void remove() {
					it.remove();
				}
			};
		}

		public int size() {
			return masterSet.size();
		}
	}

	class MapEntry implements Map.Entry {
		private final Object key;

		MapEntry(Object key) {
			this.key = key;
		}

		public Object getKey() {
			getterCalled();
			return key;
		}

		public Object getValue() {
			getterCalled();

			if (!masterSet.contains(key))
				return null;

			return cache.get(key);
		}

		public Object setValue(Object value) {
			checkRealm();

			if (!masterSet.contains(key))
				return null;

			return cache.put(key, value);
		}

		public boolean equals(Object o) {
			getterCalled();
			if (o == this)
				return true;
			if (o == null)
				return false;
			if (!(o instanceof Map.Entry))
				return false;
			Map.Entry that = (Map.Entry) o;
			return Util.equals(this.getKey(), that.getKey())
					&& Util.equals(this.getValue(), that.getValue());
		}

		public int hashCode() {
			getterCalled();
			Object value = getValue();
			return (key == null ? 0 : key.hashCode())
					^ (value == null ? 0 : value.hashCode());
		}
	}

	private ISetChangeListener masterListener = new ISetChangeListener() {
		public void handleSetChange(SetChangeEvent event) {
			if (isDisposed())
				return;

			cache.addAll(masterSet);

			// Need both obsolete and new elements to convert diff
			MapDiff diff = convertDiff(event.diff);

			cache.retainAll(masterSet);

			fireMapChange(diff);
		}

		private MapDiff convertDiff(SetDiff diff) {
			// Convert diff to detail value
			Map oldValues = new HashMap();
			Map newValues = new HashMap();

			for (Iterator it = diff.getRemovals().iterator(); it.hasNext();) {
				Object masterElement = it.next();
				oldValues.put(masterElement, cache.get(masterElement));
			}
			for (Iterator it = diff.getAdditions().iterator(); it.hasNext();) {
				Object masterElement = it.next();
				newValues.put(masterElement, cache.get(masterElement));
			}
			return Diffs.createMapDiff(diff.getAdditions(), diff.getRemovals(),
					Collections.EMPTY_SET, oldValues, newValues);
		}
	};

	private IStaleListener staleListener = new IStaleListener() {
		public void handleStale(StaleEvent staleEvent) {
			fireStale();
		}
	};

	/**
	 * @param keySet
	 * @param valueProperty
	 */
	public ObservableSetDelegatingValuePropertyObservableMap(
			IObservableSet keySet, DelegatingValueProperty valueProperty) {
		super(keySet.getRealm());
		this.masterSet = keySet;
		this.detailProperty = valueProperty;
		this.cache = new DelegatingCache(getRealm(), valueProperty) {
			void handleValueChange(Object masterElement, Object oldValue,
					Object newValue) {
				fireMapChange(Diffs.createMapDiffSingleChange(masterElement,
						oldValue, newValue));
			}
		};
		cache.addAll(masterSet);

		masterSet.addSetChangeListener(masterListener);
		masterSet.addStaleListener(staleListener);
	}

	public Set entrySet() {
		getterCalled();
		if (entrySet == null)
			entrySet = new EntrySet();
		return entrySet;
	}

	private void getterCalled() {
		ObservableTracker.getterCalled(this);
	}

	public Object get(Object key) {
		getterCalled();
		return cache.get(key);
	}

	public Object put(Object key, Object value) {
		checkRealm();
		return cache.put(key, value);
	}

	public boolean isStale() {
		return masterSet.isStale();
	}

	public Object getObserved() {
		return masterSet;
	}

	public IProperty getProperty() {
		return detailProperty;
	}

	public Object getKeyType() {
		return masterSet.getElementType();
	}

	public Object getValueType() {
		return detailProperty.getValueType();
	}

	public synchronized void dispose() {
		if (masterSet != null) {
			masterSet.removeSetChangeListener(masterListener);
			masterSet.removeStaleListener(staleListener);
			masterSet = null;
		}

		if (cache != null) {
			cache.dispose();
			cache = null;
		}

		masterListener = null;
		detailProperty = null;

		super.dispose();
	}
}




/*******************************************************************************
 * Copyright (c) 2008 Matthew Hall and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Matthew Hall - initial API and implementation (bug 194734)
 *     Matthew Hall - but 194734
 ******************************************************************************/

package org.eclipse.core.databinding.property;

/**
 * Listener for changes to properties on a particular source object
 * 
 * @noextend This interface is not intended to be extended by clients.
 * 
 * @since 1.2
 */
public interface ISimplePropertyListener {
	/**
	 * Handle the property change described in the event.
	 * 
	 * @param event
	 *            an event describing the property change that occured.
	 */
	public void handlePropertyChange(SimplePropertyEvent event);
}




/*******************************************************************************
 * Copyright (c) 2009 Matthew Hall and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Matthew Hall - initial API and implementation (bug 194734)
 ******************************************************************************/

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

import org.eclipse.core.databinding.property.ISimpleProperty;

/**
 * @since 1.2
 * 
 */
public interface ISimpleListProperty extends ISimpleProperty, IListProperty {
}




/*******************************************************************************
 * Copyright (c) 2008 Matthew Hall and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Matthew Hall - initial API and implementation (bug 194734)
 ******************************************************************************/

package org.eclipse.core.internal.databinding.property.value;

import java.util.AbstractSet;
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.IStaleListener;
import org.eclipse.core.databinding.observable.ObservableTracker;
import org.eclipse.core.databinding.observable.StaleEvent;
import org.eclipse.core.databinding.observable.map.AbstractObservableMap;
import org.eclipse.core.databinding.observable.map.IMapChangeListener;
import org.eclipse.core.databinding.observable.map.IObservableMap;
import org.eclipse.core.databinding.observable.map.MapChangeEvent;
import org.eclipse.core.databinding.observable.map.MapDiff;
import org.eclipse.core.databinding.observable.set.IObservableSet;
import org.eclipse.core.databinding.observable.set.ISetChangeListener;
import org.eclipse.core.databinding.observable.set.SetChangeEvent;
import org.eclipse.core.databinding.observable.set.WritableSet;
import org.eclipse.core.databinding.property.INativePropertyListener;
import org.eclipse.core.databinding.property.IProperty;
import org.eclipse.core.databinding.property.IPropertyObservable;
import org.eclipse.core.databinding.property.ISimplePropertyListener;
import org.eclipse.core.databinding.property.SimplePropertyEvent;
import org.eclipse.core.databinding.property.value.ISimpleValueProperty;
import org.eclipse.core.internal.databinding.IdentityWrapper;
import org.eclipse.core.internal.databinding.Util;

/**
 * @since 1.2
 * 
 */
public class ObservableMapSimpleValuePropertyObservableMap extends
		AbstractObservableMap implements IPropertyObservable {
	private IObservableMap masterMap;
	private ISimpleValueProperty detailProperty;

	private IObservableSet knownMasterValues;
	private Map cachedValues;

	private boolean updating = false;

	private IMapChangeListener masterListener = new IMapChangeListener() {
		public void handleMapChange(final MapChangeEvent event) {
			if (!isDisposed()) {
				updateKnownValues();
				if (!updating)
					fireMapChange(convertDiff(event.diff));
			}
		}

		private void updateKnownValues() {
			Set identityKnownValues = new HashSet();
			for (Iterator it = masterMap.values().iterator(); it.hasNext();) {
				identityKnownValues.add(new IdentityWrapper(it.next()));
			}

			knownMasterValues.retainAll(identityKnownValues);
			knownMasterValues.addAll(identityKnownValues);
		}

		private MapDiff convertDiff(MapDiff diff) {
			Map oldValues = new HashMap();
			Map newValues = new HashMap();

			Set addedKeys = diff.getAddedKeys();
			for (Iterator it = addedKeys.iterator(); it.hasNext();) {
				Object key = it.next();
				Object newSource = diff.getNewValue(key);
				Object newValue = detailProperty.get(newSource);
				newValues.put(key, newValue);
			}

			Set removedKeys = diff.getRemovedKeys();
			for (Iterator it = removedKeys.iterator(); it.hasNext();) {
				Object key = it.next();
				Object oldSource = diff.getOldValue(key);
				Object oldValue = detailProperty.get(oldSource);
				oldValues.put(key, oldValue);
			}

			Set changedKeys = new HashSet(diff.getChangedKeys());
			for (Iterator it = changedKeys.iterator(); it.hasNext();) {
				Object key = it.next();

				Object oldSource = diff.getOldValue(key);
				Object newSource = diff.getNewValue(key);

				Object oldValue = detailProperty.get(oldSource);
				Object newValue = detailProperty.get(newSource);

				if (Util.equals(oldValue, newValue)) {
					it.remove();
				} else {
					oldValues.put(key, oldValue);
					newValues.put(key, newValue);
				}
			}

			return Diffs.createMapDiff(addedKeys, removedKeys, changedKeys,
					oldValues, newValues);
		}
	};

	private IStaleListener staleListener = new IStaleListener() {
		public void handleStale(StaleEvent staleEvent) {
			fireStale();
		}
	};

	private INativePropertyListener detailListener;

	/**
	 * @param map
	 * @param valueProperty
	 */
	public ObservableMapSimpleValuePropertyObservableMap(IObservableMap map,
			ISimpleValueProperty valueProperty) {
		super(map.getRealm());
		this.masterMap = map;
		this.detailProperty = valueProperty;

		ISimplePropertyListener listener = new ISimplePropertyListener() {
			public void handlePropertyChange(SimplePropertyEvent event) {
				notifyIfChanged(event.getSource());
			}
		};
		this.detailListener = detailProperty.adaptListener(listener);
	}

	protected void firstListenerAdded() {
		knownMasterValues = new WritableSet(getRealm());
		cachedValues = new HashMap();
		knownMasterValues.addSetChangeListener(new ISetChangeListener() {
			public void handleSetChange(SetChangeEvent event) {
				for (Iterator it = event.diff.getRemovals().iterator(); it
						.hasNext();) {
					IdentityWrapper wrapper = (IdentityWrapper) it.next();
					Object key = wrapper.unwrap();
					detailProperty.removeListener(key, detailListener);
					cachedValues.remove(wrapper);
				}
				for (Iterator it = event.diff.getAdditions().iterator(); it
						.hasNext();) {
					IdentityWrapper wrapper = (IdentityWrapper) it.next();
					Object key = wrapper.unwrap();
					cachedValues.put(wrapper, detailProperty.get(key));
					detailProperty.addListener(key, detailListener);
				}
			}
		});
		for (Iterator it = masterMap.values().iterator(); it.hasNext();) {
			knownMasterValues.add(new IdentityWrapper(it.next()));
		}

		masterMap.addMapChangeListener(masterListener);
		masterMap.addStaleListener(staleListener);
	}

	protected void lastListenerRemoved() {
		masterMap.removeMapChangeListener(masterListener);
		masterMap.removeStaleListener(staleListener);
		if (knownMasterValues != null) {
			knownMasterValues.clear(); // removes attached listeners
			knownMasterValues.dispose();
			knownMasterValues = null;
		}
		cachedValues.clear();
		cachedValues = null;
	}

	private Set entrySet;

	public Set entrySet() {
		getterCalled();
		if (entrySet == null)
			entrySet = new EntrySet();
		return entrySet;
	}

	class EntrySet extends AbstractSet {
		public Iterator iterator() {
			return new Iterator() {
				Iterator it = masterMap.entrySet().iterator();

				public boolean hasNext() {
					getterCalled();
					return it.hasNext();
				}

				public Object next() {
					getterCalled();
					Map.Entry next = (Map.Entry) it.next();
					return new MapEntry(next.getKey());
				}

				public void remove() {
					it.remove();
				}
			};
		}

		public int size() {
			return masterMap.size();
		}
	}

	class MapEntry implements Map.Entry {
		private Object key;

		MapEntry(Object key) {
			this.key = key;
		}

		public Object getKey() {
			getterCalled();
			return key;
		}

		public Object getValue() {
			getterCalled();
			if (!masterMap.containsKey(key))
				return null;
			return detailProperty.get(masterMap.get(key));
		}

		public Object setValue(Object value) {
			if (!masterMap.containsKey(key))
				return null;
			Object source = masterMap.get(key);

			Object oldValue = detailProperty.get(source);

			updating = true;
			try {
				detailProperty.set(source, value, Diffs.createValueDiff(
						oldValue, value));
			} finally {
				updating = false;
			}

			notifyIfChanged(source);

			return oldValue;
		}

		public boolean equals(Object o) {
			getterCalled();
			if (o == this)
				return true;
			if (o == null)
				return false;
			if (!(o instanceof Map.Entry))
				return false;
			Map.Entry that = (Map.Entry) o;
			return Util.equals(this.getKey(), that.getKey())
					&& Util.equals(this.getValue(), that.getValue());
		}

		public int hashCode() {
			getterCalled();
			Object value = getValue();
			return (key == null ? 0 : key.hashCode())
					^ (value == null ? 0 : value.hashCode());
		}
	}

	public Object put(Object key, Object value) {
		if (!masterMap.containsKey(key))
			return null;
		Object masterValue = masterMap.get(key);
		Object oldValue = detailProperty.get(key);
		detailProperty.set(masterValue, value, Diffs.createValueDiff(oldValue,
				value));
		notifyIfChanged(masterValue);
		return oldValue;
	}

	private void notifyIfChanged(Object masterValue) {
		if (cachedValues != null) {
			final Set keys = keysFor(masterValue);

			final Object oldValue = cachedValues.get(new IdentityWrapper(
					masterValue));
			final Object newValue = detailProperty.get(masterValue);

			if (!Util.equals(oldValue, newValue)) {
				cachedValues.put(new IdentityWrapper(masterValue), newValue);
				fireMapChange(new MapDiff() {
					public Set getAddedKeys() {
						return Collections.EMPTY_SET;
					}

					public Set getChangedKeys() {
						return keys;
					}

					public Set getRemovedKeys() {
						return Collections.EMPTY_SET;
					}

					public Object getNewValue(Object key) {
						return newValue;
					}

					public Object getOldValue(Object key) {
						return oldValue;
					}
				});
			}
		}
	}

	private Set keysFor(Object value) {
		Set keys = new HashSet();

		for (Iterator it = masterMap.entrySet().iterator(); it.hasNext();) {
			Map.Entry entry = (Entry) it.next();
			if (entry.getValue() == value) {
				keys.add(entry.getKey());
			}
		}

		return keys;
	}

	public boolean isStale() {
		getterCalled();
		return masterMap.isStale();
	}

	private void getterCalled() {
		ObservableTracker.getterCalled(this);
	}

	public Object getObserved() {
		return masterMap;
	}

	public IProperty getProperty() {
		return detailProperty;
	}

	public synchronized void dispose() {
		if (masterMap != null) {
			masterMap.removeMapChangeListener(masterListener);
			masterMap = null;
		}
		if (knownMasterValues != null) {
			knownMasterValues.clear(); // detaches listeners
			knownMasterValues.dispose();
			knownMasterValues = null;
		}

		masterListener = null;
		detailListener = null;
		detailProperty = null;
		cachedValues = null;

		super.dispose();
	}
}




/*******************************************************************************
 * Copyright (c) 2009 Matthew Hall and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Matthew Hall - initial API and implementation (bug 194734)
 ******************************************************************************/

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

import org.eclipse.core.databinding.property.ISimpleProperty;

/**
 * @since 1.2
 */
public interface ISimpleValueProperty extends IValueProperty, ISimpleProperty {
}




/*******************************************************************************
 * Copyright (c) 2009 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation (bug 194734)
 ******************************************************************************/

package org.eclipse.core.internal.databinding.property.value;

import java.util.Collection;
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.Realm;
import org.eclipse.core.databinding.observable.map.IMapChangeListener;
import org.eclipse.core.databinding.observable.map.IObservableMap;
import org.eclipse.core.databinding.observable.map.MapChangeEvent;
import org.eclipse.core.databinding.observable.set.IObservableSet;
import org.eclipse.core.databinding.observable.set.ISetChangeListener;
import org.eclipse.core.databinding.observable.set.SetChangeEvent;
import org.eclipse.core.databinding.observable.set.WritableSet;
import org.eclipse.core.databinding.property.value.DelegatingValueProperty;
import org.eclipse.core.databinding.property.value.IValueProperty;
import org.eclipse.core.internal.databinding.IdentityWrapper;
import org.eclipse.core.internal.databinding.Util;

/**
 * @since 3.3
 * 
 */
abstract class DelegatingCache {
	private Realm realm;
	private DelegatingValueProperty detailProperty;
	private IObservableSet elements;
	private Map delegateCaches;

	private class DelegateCache implements IMapChangeListener {
		private final IValueProperty delegate;
		private final IObservableSet masterElements;
		private final IObservableMap masterElementValues;
		private final Map cachedValues;

		DelegateCache(IValueProperty delegate) {
			this.delegate = delegate;
			this.masterElements = new WritableSet(realm, Collections.EMPTY_SET,
					elements.getElementType());
			this.masterElementValues = delegate.observeDetail(masterElements);
			this.cachedValues = new HashMap();

			masterElementValues.addMapChangeListener(this);
		}

		void add(Object masterElement) {
			boolean wasEmpty = masterElements.isEmpty();

			masterElements.add(masterElement);
			cachedValues.put(new IdentityWrapper(masterElement),
					masterElementValues.get(masterElement));

			if (wasEmpty)
				delegateCaches.put(delegate, this);
		}

		void remove(Object masterElement) {
			cachedValues.remove(new IdentityWrapper(masterElement));
			masterElements.remove(masterElement);
			if (cachedValues.isEmpty())
				dispose();
		}

		Object get(Object masterElement) {
			return cachedValues.get(new IdentityWrapper(masterElement));
		}

		Object put(Object masterElement, Object detailValue) {
			Object oldValue = masterElementValues.put(masterElement,
					detailValue);
			notifyIfChanged(masterElement);
			return oldValue;
		}

		boolean containsValue(Object detailValue) {
			return cachedValues.containsValue(detailValue);
		}

		public void handleMapChange(MapChangeEvent event) {
			Set changedKeys = event.diff.getChangedKeys();
			for (Iterator it = changedKeys.iterator(); it.hasNext();)
				notifyIfChanged(it.next());
		}

		private void notifyIfChanged(Object masterElement) {
			Object oldValue = cachedValues.get(new IdentityWrapper(
					masterElement));
			Object newValue = masterElementValues.get(masterElement);
			if (!Util.equals(oldValue, newValue)) {
				cachedValues.put(new IdentityWrapper(masterElement), newValue);
				handleValueChange(masterElement, oldValue, newValue);
			}
		}

		void handleValueChange(Object masterElement, Object oldValue,
				Object newValue) {
			DelegatingCache.this.handleValueChange(masterElement, oldValue,
					newValue);
		}

		void dispose() {
			delegateCaches.remove(delegate);
			masterElementValues.dispose();
			masterElements.dispose();
			cachedValues.clear();
		}
	}

	DelegatingCache(Realm realm, DelegatingValueProperty detailProperty) {
		this.realm = realm;
		this.detailProperty = detailProperty;

		this.elements = new WritableSet(realm);
		this.delegateCaches = new HashMap();

		elements.addSetChangeListener(new ISetChangeListener() {
			public void handleSetChange(SetChangeEvent event) {
				for (Iterator it = event.diff.getRemovals().iterator(); it
						.hasNext();) {
					IdentityWrapper wrapper = (IdentityWrapper) it.next();
					Object element = wrapper.unwrap();
					getCache(element).remove(element);

				}
				for (Iterator it = event.diff.getAdditions().iterator(); it
						.hasNext();) {
					IdentityWrapper wrapper = (IdentityWrapper) it.next();
					Object element = wrapper.unwrap();
					getCache(element).add(element);
				}
			}
		});
	}

	private DelegateCache getCache(Object masterElement) {
		IValueProperty delegate = detailProperty.getDelegate(masterElement);
		if (delegateCaches.containsKey(delegate)) {
			return (DelegateCache) delegateCaches.get(delegate);
		}
		return new DelegateCache(delegate);
	}

	Object get(Object element) {
		return getCache(element).get(element);
	}

	Object put(Object element, Object value) {
		return getCache(element).put(element, value);
	}

	boolean contains(Object value) {
		for (Iterator it = delegateCaches.values().iterator(); it.hasNext();) {
			DelegateCache cache = (DelegateCache) it.next();
			if (cache.containsValue(value))
				return true;
		}
		return false;
	}

	private Set identitySet(Collection elements) {
		Set result = new HashSet();
		for (Iterator it = elements.iterator(); it.hasNext();) {
			result.add(new IdentityWrapper(it.next()));
		}
		return result;
	}

	void addAll(Collection elements) {
		this.elements.addAll(identitySet(elements));
	}

	void retainAll(Collection elements) {
		this.elements.retainAll(identitySet(elements));
	}

	abstract void handleValueChange(Object masterElement, Object oldValue,
			Object newValue);

	void dispose() {
		if (elements != null) {
			elements.clear(); // clears caches
			elements.dispose();
			elements = null;
		}

		if (delegateCaches != null) {
			for (Iterator it = delegateCaches.values().iterator(); it.hasNext();) {
				DelegateCache cache = (DelegateCache) it.next();
				cache.dispose();
			}
			delegateCaches.clear();
			delegateCaches = null;
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2008 Matthew Hall and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Matthew Hall - initial API and implementation (bug 194734)
 ******************************************************************************/

package org.eclipse.core.internal.databinding.property.value;

import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.value.AbstractObservableValue;
import org.eclipse.core.databinding.observable.value.ValueDiff;
import org.eclipse.core.databinding.property.INativePropertyListener;
import org.eclipse.core.databinding.property.IProperty;
import org.eclipse.core.databinding.property.IPropertyObservable;
import org.eclipse.core.databinding.property.ISimplePropertyListener;
import org.eclipse.core.databinding.property.SimplePropertyEvent;
import org.eclipse.core.databinding.property.value.ISimpleValueProperty;
import org.eclipse.core.internal.databinding.Util;

/**
 * @since 1.2
 * 
 */
public class SimpleValuePropertyObservableValue extends AbstractObservableValue
		implements IPropertyObservable {
	private Object source;
	private ISimpleValueProperty property;

	private boolean updating = false;
	private Object cachedValue;

	private INativePropertyListener listener;

	/**
	 * @param realm
	 * @param source
	 * @param property
	 */
	public SimpleValuePropertyObservableValue(Realm realm, Object source,
			ISimpleValueProperty property) {
		super(realm);
		this.source = source;
		this.property = property;
	}

	protected void firstListenerAdded() {
		if (!isDisposed()) {
			cachedValue = property.get(source);
			if (listener == null) {
				listener = property
						.adaptListener(new ISimplePropertyListener() {
							public void handlePropertyChange(
									final SimplePropertyEvent event) {
								if (!isDisposed() && !updating) {
									getRealm().exec(new Runnable() {
										public void run() {
											notifyIfChanged((ValueDiff) event.diff);
										}
									});
								}
							}
						});
			}
			property.addListener(source, listener);
		}
	}

	protected void lastListenerRemoved() {
		if (listener != null) {
			property.removeListener(source, listener);
		}
		cachedValue = null;
	}

	protected Object doGetValue() {
		notifyIfChanged(null);
		return property.get(source);
	}

	protected void doSetValue(Object value) {
		updating = true;
		try {
			property.set(source, value, Diffs.createValueDiff(property
					.get(source), value));
		} finally {
			updating = false;
		}

		notifyIfChanged(null);
	}

	private void notifyIfChanged(ValueDiff diff) {
		if (hasListeners()) {
			Object oldValue = cachedValue;
			Object newValue = cachedValue = property.get(source);
			if (diff == null)
				diff = Diffs.createValueDiff(oldValue, newValue);
			if (hasListeners() && !Util.equals(oldValue, newValue)) {
				fireValueChange(diff);
			}
		}
	}

	public Object getValueType() {
		return property.getValueType();
	}

	public Object getObserved() {
		return source;
	}

	public IProperty getProperty() {
		return property;
	}

	public synchronized void dispose() {
		if (!isDisposed()) {
			if (listener != null)
				property.removeListener(source, listener);
			source = null;
			property = null;
			listener = null;
		}
		super.dispose();
	}
}




/*******************************************************************************
 * Copyright (c) 2009 Matthew Hall and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Matthew Hall - initial API and implementation (bug 194734)
 ******************************************************************************/

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

import org.eclipse.core.databinding.property.ISimpleProperty;

/**
 * @since 1.2
 * 
 */
public interface ISimpleSetProperty extends ISimpleProperty, ISetProperty {
}




/*******************************************************************************
 * Copyright (c) 2008 Matthew Hall and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Matthew Hall - initial API and implementation (bug 194734)
 ******************************************************************************/

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

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.ConcurrentModificationException;
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.ObservableTracker;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.list.AbstractObservableList;
import org.eclipse.core.databinding.observable.list.ListDiff;
import org.eclipse.core.databinding.observable.list.ListDiffEntry;
import org.eclipse.core.databinding.property.INativePropertyListener;
import org.eclipse.core.databinding.property.IProperty;
import org.eclipse.core.databinding.property.IPropertyObservable;
import org.eclipse.core.databinding.property.ISimplePropertyListener;
import org.eclipse.core.databinding.property.SimplePropertyEvent;
import org.eclipse.core.databinding.property.list.ISimpleListProperty;

/**
 * @since 1.2
 * 
 */
public class SimpleListPropertyObservableList extends AbstractObservableList
		implements IPropertyObservable {
	private Object source;
	private ISimpleListProperty property;

	private volatile boolean updating = false;

	private volatile int modCount = 0;

	private INativePropertyListener listener;

	private List cachedList;

	/**
	 * @param realm
	 * @param source
	 * @param property
	 */
	public SimpleListPropertyObservableList(Realm realm, Object source,
			ISimpleListProperty property) {
		super(realm);
		this.source = source;
		this.property = property;
	}

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

			if (listener == null) {
				listener = property
						.adaptListener(new ISimplePropertyListener() {
							public void handlePropertyChange(
									final SimplePropertyEvent event) {
								modCount++;
								if (!isDisposed() && !updating) {
									getRealm().exec(new Runnable() {
										public void run() {
											notifyIfChanged((ListDiff) event.diff);
										}
									});
								}
							}
						});
			}
			property.addListener(source, listener);
		}
	}

	protected void lastListenerRemoved() {
		if (listener != null) {
			property.removeListener(source, listener);
		}

		cachedList = null;
	}

	private void getterCalled() {
		ObservableTracker.getterCalled(this);
	}

	public Object getElementType() {
		return property.getElementType();
	}

	// Queries

	private List getList() {
		return (List) property.get(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;
		updating = true;
		List list = new ArrayList(getList());
		list.add(index, o);
		ListDiff diff = Diffs.createListDiff(Diffs.createListDiffEntry(index,
				true, o));
		try {
			property.set(source, list, diff);
			modCount++;
		} finally {
			updating = wasUpdating;
		}

		notifyIfChanged(null);
	}

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

			public void remove() {
				checkRealm();
				checkForComodification();
				if (lastIndex == -1)
					throw new IllegalStateException();

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

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

				notifyIfChanged(null);

				lastElement = null;
				lastIndex = -1;

				expectedModCount = modCount;
			}

			private void checkForComodification() {
				if (expectedModCount != modCount)
					throw new ConcurrentModificationException();
			}
		};
	}

	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;
		updating = true;
		try {
			property.set(source, list, diff);
			modCount++;
		} finally {
			updating = wasUpdating;
		}

		notifyIfChanged(null);

		return element;
	}

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

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

		remove(index);

		return true;
	}

	public ListIterator listIterator() {
		return listIterator(0);
	}

	public ListIterator listIterator(final int index) {
		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;
				updating = true;
				try {
					property.set(source, list, diff);
					modCount++;
				} finally {
					updating = wasUpdating;
				}

				notifyIfChanged(null);

				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;
				updating = true;
				try {
					property.set(source, list, diff);
					modCount++;
				} finally {
					updating = wasUpdating;
				}

				notifyIfChanged(null);

				lastElement = o;
				expectedModCount = modCount;
			}

			public void remove() {
				checkRealm();
				checkForComodification();
				if (lastIndex == -1)
					throw new IllegalStateException();

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

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

				notifyIfChanged(null);

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

			private void checkForComodification() {
				if (expectedModCount != modCount)
					throw new ConcurrentModificationException();
			}
		};
	}

	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;
		updating = true;
		try {
			property.set(source, list, diff);
			modCount++;
		} finally {
			updating = wasUpdating;
		}

		notifyIfChanged(null);

		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;
		updating = true;
		try {
			property.set(source, list, diff);
			modCount++;
		} finally {
			updating = wasUpdating;
		}

		notifyIfChanged(null);

		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) {
		checkRealm();

		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();) {
			Object element = it.next();
			entries[offsetIndex] = Diffs.createListDiffEntry(index
					+ offsetIndex, true, element);
			offsetIndex++;
		}
		ListDiff diff = Diffs.createListDiff(entries);

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

		notifyIfChanged(null);

		return true;
	}

	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;
		updating = true;
		try {
			for (ListIterator it = list.listIterator(); it.hasNext();) {
				Object element = it.next();
				int index = it.previousIndex();
				if (c.contains(element)) {
					it.remove();
					entries.add(Diffs
							.createListDiffEntry(index, false, element));
				}
			}
			if (entries.isEmpty())
				return false;

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

		notifyIfChanged(null);

		return !diff.isEmpty();
	}

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

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

		if (c.isEmpty()) {
			clear();
			return true;
		}

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

		boolean wasUpdating = updating;
		updating = true;
		try {
			for (ListIterator it = list.listIterator(); it.hasNext();) {
				Object element = it.next();
				int index = it.previousIndex();
				if (!c.contains(element)) {
					it.remove();
					entries.add(Diffs
							.createListDiffEntry(index, false, element));
				}
			}
			if (entries.isEmpty())
				return false;

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

		notifyIfChanged(null);

		return !diff.isEmpty();
	}

	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;
		updating = true;
		try {
			property.set(source, Collections.EMPTY_LIST, diff);
			modCount++;
		} finally {
			updating = wasUpdating;
		}

		notifyIfChanged(null);
	}

	private void notifyIfChanged(ListDiff diff) {
		if (hasListeners()) {
			List oldList = cachedList;
			List newList = cachedList = (List) property.get(source);
			if (diff == null)
				diff = Diffs.computeListDiff(oldList, newList);
			if (!diff.isEmpty()) {
				fireListChange(diff);
			}
		}
	}

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

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

	public Object getObserved() {
		return source;
	}

	public IProperty getProperty() {
		return property;
	}

	public synchronized void dispose() {
		if (!isDisposed()) {
			if (listener != null)
				property.removeListener(source, listener);
			property = null;
			source = null;
			listener = null;
		}
		super.dispose();
	}
}




/*******************************************************************************
 * Copyright (c) 2008 Matthew Hall and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Matthew Hall - initial API and implementation (bug 194734)
 ******************************************************************************/

package org.eclipse.core.internal.databinding.property.value;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Collection;
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.IStaleListener;
import org.eclipse.core.databinding.observable.ObservableTracker;
import org.eclipse.core.databinding.observable.StaleEvent;
import org.eclipse.core.databinding.observable.list.AbstractObservableList;
import org.eclipse.core.databinding.observable.list.IListChangeListener;
import org.eclipse.core.databinding.observable.list.IObservableList;
import org.eclipse.core.databinding.observable.list.ListChangeEvent;
import org.eclipse.core.databinding.observable.list.ListDiff;
import org.eclipse.core.databinding.observable.list.ListDiffEntry;
import org.eclipse.core.databinding.property.IProperty;
import org.eclipse.core.databinding.property.IPropertyObservable;
import org.eclipse.core.databinding.property.value.DelegatingValueProperty;

/**
 * @since 1.2
 */
public class ObservableListDelegatingValuePropertyObservableList extends
		AbstractObservableList implements IPropertyObservable {
	private IObservableList masterList;
	private DelegatingValueProperty detailProperty;
	private DelegatingCache cache;

	private IListChangeListener masterListener = new IListChangeListener() {
		public void handleListChange(ListChangeEvent event) {
			if (isDisposed())
				return;

			cache.addAll(masterList);

			// Need both obsolete and new elements to convert diff
			ListDiff diff = convertDiff(event.diff);

			cache.retainAll(masterList);

			fireListChange(diff);
		}

		private ListDiff convertDiff(ListDiff diff) {
			// Convert diff to detail value
			ListDiffEntry[] masterEntries = diff.getDifferences();
			ListDiffEntry[] detailEntries = new ListDiffEntry[masterEntries.length];
			for (int i = 0; i < masterEntries.length; i++) {
				ListDiffEntry masterDifference = masterEntries[i];
				int index = masterDifference.getPosition();
				boolean addition = masterDifference.isAddition();
				Object masterElement = masterDifference.getElement();
				Object detailValue = cache.get(masterElement);

				detailEntries[i] = Diffs.createListDiffEntry(index, addition,
						detailValue);
			}
			return Diffs.createListDiff(detailEntries);
		}
	};

	private IStaleListener staleListener = new IStaleListener() {
		public void handleStale(StaleEvent staleEvent) {
			fireStale();
		}
	};

	/**
	 * @param masterList
	 * @param valueProperty
	 */
	public ObservableListDelegatingValuePropertyObservableList(
			IObservableList masterList, DelegatingValueProperty valueProperty) {
		super(masterList.getRealm());
		this.masterList = masterList;
		this.detailProperty = valueProperty;
		this.cache = new DelegatingCache(getRealm(), valueProperty) {
			void handleValueChange(Object masterElement, Object oldValue,
					Object newValue) {
				fireListChange(indicesOf(masterElement), oldValue, newValue);
			}
		};
		cache.addAll(masterList);

		masterList.addListChangeListener(masterListener);
		masterList.addStaleListener(staleListener);
	}

	protected int doGetSize() {
		getterCalled();
		return masterList.size();
	}

	private void getterCalled() {
		ObservableTracker.getterCalled(this);
	}

	public Object get(int index) {
		getterCalled();
		Object masterElement = masterList.get(index);
		return cache.get(masterElement);
	}

	public boolean add(Object o) {
		throw new UnsupportedOperationException();
	}

	public boolean addAll(Collection c) {
		throw new UnsupportedOperationException();
	}

	public boolean addAll(int index, Collection c) {
		throw new UnsupportedOperationException();
	}

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

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

	public boolean isStale() {
		getterCalled();
		return masterList.isStale();
	}

	public Iterator iterator() {
		getterCalled();
		return new Iterator() {
			Iterator it = masterList.iterator();

			public boolean hasNext() {
				getterCalled();
				return it.hasNext();
			}

			public Object next() {
				getterCalled();
				Object masterElement = it.next();
				return cache.get(masterElement);
			}

			public void remove() {
				throw new UnsupportedOperationException();
			}
		};
	}

	public Object move(int oldIndex, int newIndex) {
		throw new UnsupportedOperationException();
	}

	public boolean remove(Object o) {
		throw new UnsupportedOperationException();
	}

	public boolean removeAll(Collection c) {
		throw new UnsupportedOperationException();
	}

	public boolean retainAll(Collection c) {
		throw new UnsupportedOperationException();
	}

	public Object[] toArray() {
		getterCalled();
		Object[] masterElements = masterList.toArray();
		Object[] result = new Object[masterElements.length];
		for (int i = 0; i < result.length; i++) {
			result[i] = cache.get(masterElements[i]);
		}
		return result;
	}

	public Object[] toArray(Object[] a) {
		getterCalled();
		Object[] masterElements = masterList.toArray();
		if (a.length < masterElements.length)
			a = (Object[]) Array.newInstance(a.getClass().getComponentType(),
					masterElements.length);
		for (int i = 0; i < masterElements.length; i++) {
			a[i] = cache.get(masterElements[i]);
		}
		return a;
	}

	public void add(int index, Object o) {
		throw new UnsupportedOperationException();
	}

	public void clear() {
		throw new UnsupportedOperationException();
	}

	public ListIterator listIterator() {
		return listIterator(0);
	}

	public ListIterator listIterator(final int index) {
		getterCalled();
		return new ListIterator() {
			ListIterator it = masterList.listIterator(index);
			Object lastMasterElement;
			Object lastElement;
			boolean haveIterated = false;

			public void add(Object arg0) {
				throw new UnsupportedOperationException();
			}

			public boolean hasNext() {
				getterCalled();
				return it.hasNext();
			}

			public boolean hasPrevious() {
				getterCalled();
				return it.hasPrevious();
			}

			public Object next() {
				getterCalled();
				lastMasterElement = it.next();
				lastElement = cache.get(lastMasterElement);
				haveIterated = true;
				return lastElement;
			}

			public int nextIndex() {
				getterCalled();
				return it.nextIndex();
			}

			public Object previous() {
				getterCalled();
				lastMasterElement = it.previous();
				lastElement = cache.get(lastMasterElement);
				haveIterated = true;
				return lastElement;
			}

			public int previousIndex() {
				getterCalled();
				return it.previousIndex();
			}

			public void remove() {
				throw new UnsupportedOperationException();
			}

			public void set(Object o) {
				checkRealm();
				if (!haveIterated)
					throw new IllegalStateException();

				cache.put(lastMasterElement, o);

				lastElement = o;
			}
		};
	}

	private int[] indicesOf(Object masterElement) {
		List indices = new ArrayList();

		for (ListIterator it = masterList.listIterator(); it.hasNext();) {
			if (masterElement == it.next())
				indices.add(new Integer(it.previousIndex()));
		}

		int[] result = new int[indices.size()];
		for (int i = 0; i < result.length; i++) {
			result[i] = ((Integer) indices.get(i)).intValue();
		}
		return result;
	}

	private void fireListChange(int[] indices, Object oldValue, Object newValue) {
		ListDiffEntry[] differences = new ListDiffEntry[indices.length * 2];
		for (int i = 0; i < indices.length; i++) {
			int index = indices[i];
			differences[i * 2] = Diffs.createListDiffEntry(index, false,
					oldValue);
			differences[i * 2 + 1] = Diffs.createListDiffEntry(index, true,
					newValue);
		}
		fireListChange(Diffs.createListDiff(differences));
	}

	public Object remove(int index) {
		throw new UnsupportedOperationException();
	}

	public Object set(int index, Object o) {
		checkRealm();
		Object masterElement = masterList.get(index);
		return cache.put(masterElement, o);
	}

	public Object getObserved() {
		return masterList;
	}

	public IProperty getProperty() {
		return detailProperty;
	}

	public Object getElementType() {
		return detailProperty.getValueType();
	}

	public synchronized void dispose() {
		if (masterList != null) {
			masterList.removeListChangeListener(masterListener);
			masterList.removeStaleListener(staleListener);
			masterList = null;
		}

		if (cache != null) {
			cache.dispose();
			cache = null;
		}

		masterListener = null;
		detailProperty = null;

		super.dispose();
	}
}




/*******************************************************************************
 * Copyright (c) 2009 Matthew Hall and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Matthew Hall - initial API and implementation (bug 194734)
 ******************************************************************************/

package org.eclipse.core.databinding.property;

import org.eclipse.core.databinding.observable.IDiff;
import org.eclipse.core.databinding.property.list.ISimpleListProperty;
import org.eclipse.core.databinding.property.map.ISimpleMapProperty;
import org.eclipse.core.databinding.property.set.ISimpleSetProperty;
import org.eclipse.core.databinding.property.value.ISimpleValueProperty;

/**
 * Interface for immediate (as opposed to nested) properties of a particular
 * source object.
 * 
 * @since 1.2
 * @noimplement This interface is not intended to be implemented by clients.
 *              Clients should instead subclass one of the classes that
 *              implement this interface. Note that direct implementers of this
 *              interface outside of the framework will be broken in future
 *              releases when methods are added to this interface.
 * @see ISimpleValueProperty
 * @see ISimpleListProperty
 * @see ISimpleSetProperty
 * @see ISimpleMapProperty
 */
public interface ISimpleProperty extends IProperty {
	/**
	 * Returns the current contents of the source's property.
	 * 
	 * @param source
	 *            the property source (may be null)
	 * @return the current contents of the source's property
	 * @noreference This method is not intended to be referenced by clients.
	 */
	public Object get(Object source);

	/**
	 * Sets the contents of the source's property to the specified value.
	 * 
	 * @param source
	 *            the property source
	 * @param value
	 *            the new value
	 * @param diff
	 *            a diff describing the change
	 * @noreference This method is not intended to be referenced by clients.
	 */
	public void set(Object source, Object value, IDiff diff);

	/**
	 * Returns a listener which implements the correct listener interface for
	 * the expected source object, and which parlays property change events from
	 * the source object to the given listener. If there is no listener API for
	 * this property, this method returns null.
	 * 
	 * @param listener
	 *            the property listener to receive events
	 * @return a native listener which parlays property change events to the
	 *         specified listener.
	 * @noreference This method is not intended to be referenced by clients.
	 */
	public INativePropertyListener adaptListener(
			ISimplePropertyListener listener);

	/**
	 * 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(ISimplePropertyListener)}
	 * returns null), this method does nothing.
	 * 
	 * @param source
	 *            the property source
	 * @param listener
	 *            a listener obtained from calling
	 *            {@link #adaptListener(ISimplePropertyListener)}.
	 * @noreference This method is not intended to be referenced by clients.
	 */
	public void addListener(Object source, INativePropertyListener listener);

	/**
	 * 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(ISimplePropertyListener)}
	 * returns null), this method does nothing.
	 * 
	 * @param source
	 *            the property source
	 * @param listener
	 *            a listener obtained from calling
	 *            {@link #adaptListener(ISimplePropertyListener)}.
	 * @noreference This method is not intended to be referenced by clients.
	 */
	public void removeListener(Object source, INativePropertyListener listener);
}




/*******************************************************************************
 * Copyright (c) 2009 Matthew Hall and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Matthew Hall - initial API and implementation (bug 194734)
 ******************************************************************************/

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

import org.eclipse.core.databinding.property.ISimpleProperty;

/**
 * @since 1.2
 */
public interface ISimpleMapProperty extends ISimpleProperty, IMapProperty {
}




/*******************************************************************************
 * Copyright (c) 2008 Matthew Hall and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Matthew Hall - initial API and implementation (bug 194734)
 ******************************************************************************/

package org.eclipse.core.internal.databinding.property.value;

import java.util.AbstractSet;
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.IStaleListener;
import org.eclipse.core.databinding.observable.ObservableTracker;
import org.eclipse.core.databinding.observable.StaleEvent;
import org.eclipse.core.databinding.observable.map.AbstractObservableMap;
import org.eclipse.core.databinding.observable.map.IMapChangeListener;
import org.eclipse.core.databinding.observable.map.IObservableMap;
import org.eclipse.core.databinding.observable.map.MapChangeEvent;
import org.eclipse.core.databinding.observable.map.MapDiff;
import org.eclipse.core.databinding.property.IProperty;
import org.eclipse.core.databinding.property.IPropertyObservable;
import org.eclipse.core.databinding.property.value.DelegatingValueProperty;
import org.eclipse.core.internal.databinding.Util;

/**
 * @since 1.2
 */
public class ObservableMapDelegatingValuePropertyObservableMap extends
		AbstractObservableMap implements IPropertyObservable {
	private IObservableMap masterMap;
	private DelegatingValueProperty detailProperty;
	private DelegatingCache cache;

	private Set entrySet;

	class EntrySet extends AbstractSet {
		public Iterator iterator() {
			return new Iterator() {
				Iterator it = masterMap.entrySet().iterator();

				public boolean hasNext() {
					getterCalled();
					return it.hasNext();
				}

				public Object next() {
					getterCalled();
					Map.Entry next = (Map.Entry) it.next();
					return new MapEntry(next.getKey());
				}

				public void remove() {
					it.remove();
				}
			};
		}

		public int size() {
			return masterMap.size();
		}
	}

	class MapEntry implements Map.Entry {
		private Object key;

		MapEntry(Object key) {
			this.key = key;
		}

		public Object getKey() {
			getterCalled();
			return key;
		}

		public Object getValue() {
			getterCalled();

			if (!masterMap.containsKey(key))
				return null;

			Object masterValue = masterMap.get(key);
			return cache.get(masterValue);
		}

		public Object setValue(Object value) {
			checkRealm();

			if (!masterMap.containsKey(key))
				return null;

			Object masterValue = masterMap.get(key);
			return cache.put(masterValue, value);
		}

		public boolean equals(Object o) {
			getterCalled();
			if (o == this)
				return true;
			if (o == null)
				return false;
			if (!(o instanceof Map.Entry))
				return false;
			Map.Entry that = (Map.Entry) o;
			return Util.equals(this.getKey(), that.getKey())
					&& Util.equals(this.getValue(), that.getValue());
		}

		public int hashCode() {
			getterCalled();
			Object value = getValue();
			return (key == null ? 0 : key.hashCode())
					^ (value == null ? 0 : value.hashCode());
		}
	}

	private IMapChangeListener masterListener = new IMapChangeListener() {
		public void handleMapChange(final MapChangeEvent event) {
			if (isDisposed())
				return;

			cache.addAll(masterMap.values());

			// Need both obsolete and new master values to convert diff
			MapDiff diff = convertDiff(event.diff);

			cache.retainAll(masterMap.values());

			fireMapChange(diff);
		}

		private MapDiff convertDiff(MapDiff diff) {
			Map oldValues = new HashMap();
			Map newValues = new HashMap();

			Set addedKeys = diff.getAddedKeys();
			for (Iterator it = addedKeys.iterator(); it.hasNext();) {
				Object key = it.next();
				Object masterValue = diff.getNewValue(key);
				Object newValue = cache.get(masterValue);
				newValues.put(key, newValue);
			}

			Set removedKeys = diff.getRemovedKeys();
			for (Iterator it = removedKeys.iterator(); it.hasNext();) {
				Object key = it.next();
				Object masterValue = diff.getOldValue(key);
				Object oldValue = cache.get(masterValue);
				oldValues.put(key, oldValue);
			}

			Set changedKeys = new HashSet(diff.getChangedKeys());
			for (Iterator it = changedKeys.iterator(); it.hasNext();) {
				Object key = it.next();

				Object oldMasterValue = diff.getOldValue(key);
				Object newMasterValue = diff.getNewValue(key);

				Object oldValue = cache.get(oldMasterValue);
				Object newValue = cache.get(newMasterValue);

				if (Util.equals(oldValue, newValue)) {
					it.remove();
				} else {
					oldValues.put(key, oldValue);
					newValues.put(key, newValue);
				}
			}

			return Diffs.createMapDiff(addedKeys, removedKeys, changedKeys,
					oldValues, newValues);
		}
	};

	private IStaleListener staleListener = new IStaleListener() {
		public void handleStale(StaleEvent staleEvent) {
			fireStale();
		}
	};

	/**
	 * @param map
	 * @param valueProperty
	 */
	public ObservableMapDelegatingValuePropertyObservableMap(
			IObservableMap map, DelegatingValueProperty valueProperty) {
		super(map.getRealm());
		this.masterMap = map;
		this.detailProperty = valueProperty;
		this.cache = new DelegatingCache(getRealm(), valueProperty) {
			void handleValueChange(Object masterElement, Object oldValue,
					Object newValue) {
				fireMapChange(keysFor(masterElement), oldValue, newValue);
			}
		};
		cache.addAll(masterMap.values());

		masterMap.addMapChangeListener(masterListener);
		masterMap.addStaleListener(staleListener);
	}

	public Set entrySet() {
		getterCalled();
		if (entrySet == null)
			entrySet = new EntrySet();
		return entrySet;
	}

	private void getterCalled() {
		ObservableTracker.getterCalled(this);
	}

	public Object get(Object key) {
		getterCalled();
		Object masterValue = masterMap.get(key);
		return cache.get(masterValue);
	}

	public Object put(Object key, Object value) {
		if (!masterMap.containsKey(key))
			return null;
		Object masterValue = masterMap.get(key);
		return cache.put(masterValue, value);
	}

	public boolean isStale() {
		getterCalled();
		return masterMap.isStale();
	}

	public Object getObserved() {
		return masterMap;
	}

	public IProperty getProperty() {
		return detailProperty;
	}

	public Object getKeyType() {
		return masterMap.getKeyType();
	}

	public Object getValueType() {
		return detailProperty.getValueType();
	}

	private Set keysFor(Object masterValue) {
		Set keys = new HashSet();

		for (Iterator it = masterMap.entrySet().iterator(); it.hasNext();) {
			Map.Entry entry = (Entry) it.next();
			if (entry.getValue() == masterValue) {
				keys.add(entry.getKey());
			}
		}

		return keys;
	}

	private void fireMapChange(final Set changedKeys, final Object oldValue,
			final Object newValue) {
		fireMapChange(new MapDiff() {
			public Set getAddedKeys() {
				return Collections.EMPTY_SET;
			}

			public Set getRemovedKeys() {
				return Collections.EMPTY_SET;
			}

			public Set getChangedKeys() {
				return Collections.unmodifiableSet(changedKeys);
			}

			public Object getOldValue(Object key) {
				if (changedKeys.contains(key))
					return oldValue;
				return null;
			}

			public Object getNewValue(Object key) {
				if (changedKeys.contains(key))
					return newValue;
				return null;
			}
		});
	}

	public synchronized void dispose() {
		if (masterMap != null) {
			masterMap.removeMapChangeListener(masterListener);
			masterMap.removeStaleListener(staleListener);
			masterMap = null;
		}

		if (cache != null) {
			cache.dispose();
			cache = null;
		}

		masterListener = null;
		detailProperty = null;

		super.dispose();
	}
}




/*******************************************************************************
 * Copyright (c) 2008 Matthew Hall and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Matthew Hall - initial API and implementation (bug 194734)
 ******************************************************************************/

package org.eclipse.core.internal.databinding.property.value;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.Set;

import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.observable.IStaleListener;
import org.eclipse.core.databinding.observable.ObservableTracker;
import org.eclipse.core.databinding.observable.StaleEvent;
import org.eclipse.core.databinding.observable.list.AbstractObservableList;
import org.eclipse.core.databinding.observable.list.IListChangeListener;
import org.eclipse.core.databinding.observable.list.IObservableList;
import org.eclipse.core.databinding.observable.list.ListChangeEvent;
import org.eclipse.core.databinding.observable.list.ListDiff;
import org.eclipse.core.databinding.observable.list.ListDiffEntry;
import org.eclipse.core.databinding.observable.set.IObservableSet;
import org.eclipse.core.databinding.observable.set.ISetChangeListener;
import org.eclipse.core.databinding.observable.set.SetChangeEvent;
import org.eclipse.core.databinding.observable.set.WritableSet;
import org.eclipse.core.databinding.property.INativePropertyListener;
import org.eclipse.core.databinding.property.IProperty;
import org.eclipse.core.databinding.property.IPropertyObservable;
import org.eclipse.core.databinding.property.ISimplePropertyListener;
import org.eclipse.core.databinding.property.SimplePropertyEvent;
import org.eclipse.core.databinding.property.value.ISimpleValueProperty;
import org.eclipse.core.internal.databinding.IdentityWrapper;
import org.eclipse.core.internal.databinding.Util;

/**
 * @since 1.2
 */
public class ObservableListSimpleValuePropertyObservableList extends
		AbstractObservableList implements IPropertyObservable {
	private IObservableList masterList;
	private ISimpleValueProperty detailProperty;

	private IObservableSet knownMasterElements;
	private Map cachedValues;

	private boolean updating;

	private IListChangeListener masterListener = new IListChangeListener() {
		public void handleListChange(ListChangeEvent event) {
			if (!isDisposed()) {
				updateKnownElements();
				fireListChange(convertDiff(event.diff));
			}
		}

		private void updateKnownElements() {
			Set identityKnownElements = new HashSet();
			for (Iterator it = masterList.iterator(); it.hasNext();) {
				identityKnownElements.add(new IdentityWrapper(it.next()));
			}

			knownMasterElements.retainAll(identityKnownElements);
			knownMasterElements.addAll(identityKnownElements);
		}

		private ListDiff convertDiff(ListDiff diff) {
			// Convert diff to detail value
			ListDiffEntry[] masterEntries = diff.getDifferences();
			ListDiffEntry[] detailEntries = new ListDiffEntry[masterEntries.length];
			for (int i = 0; i < masterEntries.length; i++) {
				ListDiffEntry masterDifference = masterEntries[i];
				int index = masterDifference.getPosition();
				boolean addition = masterDifference.isAddition();
				Object masterElement = masterDifference.getElement();
				Object elementDetailValue = detailProperty.get(masterElement);
				detailEntries[i] = Diffs.createListDiffEntry(index, addition,
						elementDetailValue);
			}
			return Diffs.createListDiff(detailEntries);
		}
	};

	private IStaleListener staleListener = new IStaleListener() {
		public void handleStale(StaleEvent staleEvent) {
			fireStale();
		}
	};

	private INativePropertyListener detailListener;

	/**
	 * @param masterList
	 * @param valueProperty
	 */
	public ObservableListSimpleValuePropertyObservableList(
			IObservableList masterList, ISimpleValueProperty valueProperty) {
		super(masterList.getRealm());
		this.masterList = masterList;
		this.detailProperty = valueProperty;

		ISimplePropertyListener listener = new ISimplePropertyListener() {
			public void handlePropertyChange(SimplePropertyEvent event) {
				if (!isDisposed() && !updating) {
					notifyIfChanged(event.getSource());
				}
			}
		};
		this.detailListener = detailProperty.adaptListener(listener);
	}

	protected void firstListenerAdded() {
		knownMasterElements = new WritableSet(getRealm());
		cachedValues = new HashMap();
		knownMasterElements.addSetChangeListener(new ISetChangeListener() {
			public void handleSetChange(SetChangeEvent event) {
				for (Iterator it = event.diff.getRemovals().iterator(); it
						.hasNext();) {
					IdentityWrapper wrapper = (IdentityWrapper) it.next();
					Object key = wrapper.unwrap();
					detailProperty.removeListener(key, detailListener);
					cachedValues.remove(wrapper);
				}
				for (Iterator it = event.diff.getAdditions().iterator(); it
						.hasNext();) {
					IdentityWrapper wrapper = (IdentityWrapper) it.next();
					Object key = wrapper.unwrap();
					cachedValues.put(wrapper, detailProperty.get(key));
					detailProperty.addListener(key, detailListener);
				}
			}
		});
		for (Iterator it = masterList.iterator(); it.hasNext();) {
			knownMasterElements.add(new IdentityWrapper(it.next()));
		}

		masterList.addListChangeListener(masterListener);
		masterList.addStaleListener(staleListener);
	}

	protected void lastListenerRemoved() {
		masterList.removeListChangeListener(masterListener);
		masterList.removeStaleListener(staleListener);
		if (knownMasterElements != null) {
			knownMasterElements.clear(); // clears cachedValues
			knownMasterElements.dispose();
			knownMasterElements = null;
		}
		cachedValues.clear();
		cachedValues = null;
	}

	protected int doGetSize() {
		getterCalled();
		return masterList.size();
	}

	private void getterCalled() {
		ObservableTracker.getterCalled(this);
	}

	public Object getElementType() {
		return detailProperty.getValueType();
	}

	public Object get(int index) {
		getterCalled();
		Object masterElement = masterList.get(index);
		return detailProperty.get(masterElement);
	}

	public boolean add(Object o) {
		throw new UnsupportedOperationException();
	}

	public boolean addAll(Collection c) {
		throw new UnsupportedOperationException();
	}

	public boolean addAll(int index, Collection c) {
		throw new UnsupportedOperationException();
	}

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

		for (Iterator it = masterList.iterator(); it.hasNext();) {
			if (Util.equals(detailProperty.get(it.next()), o))
				return true;
		}
		return false;
	}

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

	public boolean isStale() {
		getterCalled();
		return masterList.isStale();
	}

	public Iterator iterator() {
		getterCalled();
		return new Iterator() {
			Iterator it = masterList.iterator();

			public boolean hasNext() {
				getterCalled();
				return it.hasNext();
			}

			public Object next() {
				getterCalled();
				Object masterElement = it.next();
				return detailProperty.get(masterElement);
			}

			public void remove() {
				throw new UnsupportedOperationException();
			}
		};
	}

	public Object move(int oldIndex, int newIndex) {
		throw new UnsupportedOperationException();
	}

	public boolean remove(Object o) {
		throw new UnsupportedOperationException();
	}

	public boolean removeAll(Collection c) {
		throw new UnsupportedOperationException();
	}

	public boolean retainAll(Collection c) {
		throw new UnsupportedOperationException();
	}

	public Object[] toArray() {
		getterCalled();
		Object[] masterElements = masterList.toArray();
		Object[] result = new Object[masterElements.length];
		for (int i = 0; i < result.length; i++) {
			result[i] = detailProperty.get(masterElements[i]);
		}
		return result;
	}

	public Object[] toArray(Object[] a) {
		getterCalled();
		Object[] masterElements = masterList.toArray();
		if (a.length < masterElements.length)
			a = (Object[]) Array.newInstance(a.getClass().getComponentType(),
					masterElements.length);
		for (int i = 0; i < masterElements.length; i++) {
			a[i] = detailProperty.get(masterElements[i]);
		}
		return a;
	}

	public void add(int index, Object o) {
		throw new UnsupportedOperationException();
	}

	public void clear() {
		throw new UnsupportedOperationException();
	}

	public ListIterator listIterator() {
		return listIterator(0);
	}

	public ListIterator listIterator(final int index) {
		getterCalled();
		return new ListIterator() {
			ListIterator it = masterList.listIterator(index);
			Object lastMasterElement;
			Object lastElement;
			boolean haveIterated = false;

			public void add(Object arg0) {
				throw new UnsupportedOperationException();
			}

			public boolean hasNext() {
				getterCalled();
				return it.hasNext();
			}

			public boolean hasPrevious() {
				getterCalled();
				return it.hasPrevious();
			}

			public Object next() {
				getterCalled();
				lastMasterElement = it.next();
				lastElement = detailProperty.get(lastMasterElement);
				haveIterated = true;
				return lastElement;
			}

			public int nextIndex() {
				getterCalled();
				return it.nextIndex();
			}

			public Object previous() {
				getterCalled();
				lastMasterElement = it.previous();
				lastElement = detailProperty.get(lastMasterElement);
				haveIterated = true;
				return lastElement;
			}

			public int previousIndex() {
				getterCalled();
				return it.previousIndex();
			}

			public void remove() {
				throw new UnsupportedOperationException();
			}

			public void set(Object o) {
				checkRealm();
				if (!haveIterated)
					throw new IllegalStateException();

				boolean wasUpdating = updating;
				updating = true;
				try {

					detailProperty.set(lastElement, o, Diffs.createValueDiff(
							lastMasterElement, o));
				} finally {
					updating = wasUpdating;
				}

				notifyIfChanged(lastMasterElement);

				lastElement = o;
			}
		};
	}

	private void notifyIfChanged(Object masterElement) {
		if (cachedValues != null) {
			Object oldValue = cachedValues.get(new IdentityWrapper(
					masterElement));
			Object newValue = detailProperty.get(masterElement);
			if (!Util.equals(oldValue, newValue)) {
				cachedValues.put(new IdentityWrapper(masterElement), newValue);
				fireListChange(indicesOf(masterElement), oldValue, newValue);
			}
		}
	}

	private int[] indicesOf(Object masterElement) {
		List indices = new ArrayList();

		for (ListIterator it = ObservableListSimpleValuePropertyObservableList.this.masterList
				.listIterator(); it.hasNext();) {
			if (masterElement == it.next())
				indices.add(new Integer(it.previousIndex()));
		}

		int[] result = new int[indices.size()];
		for (int i = 0; i < result.length; i++) {
			result[i] = ((Integer) indices.get(i)).intValue();
		}
		return result;
	}

	private void fireListChange(int[] indices, Object oldValue, Object newValue) {
		ListDiffEntry[] differences = new ListDiffEntry[indices.length * 2];
		for (int i = 0; i < indices.length; i++) {
			int index = indices[i];
			differences[i * 2] = Diffs.createListDiffEntry(index, false,
					oldValue);
			differences[i * 2 + 1] = Diffs.createListDiffEntry(index, true,
					newValue);
		}
		fireListChange(Diffs.createListDiff(differences));
	}

	public Object remove(int index) {
		throw new UnsupportedOperationException();
	}

	public Object set(int index, Object o) {
		checkRealm();
		Object masterElement = masterList.get(index);
		Object oldValue = detailProperty.get(masterElement);

		boolean wasUpdating = updating;
		updating = true;
		try {
			detailProperty.set(masterElement, o, Diffs.createValueDiff(
					oldValue, o));
		} finally {
			updating = wasUpdating;
		}

		notifyIfChanged(masterElement);

		return oldValue;
	}

	public Object getObserved() {
		return masterList;
	}

	public IProperty getProperty() {
		return detailProperty;
	}

	public synchronized void dispose() {
		if (masterList != null) {
			masterList.removeListChangeListener(masterListener);
			masterList = null;
		}
		if (knownMasterElements != null) {
			knownMasterElements.clear(); // detaches listeners
			knownMasterElements.dispose();
			knownMasterElements = null;
		}

		masterListener = null;
		detailListener = null;
		detailProperty = null;
		cachedValues = null;

		super.dispose();
	}
}




/*******************************************************************************
 * Copyright (c) 2008 Matthew Hall and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Matthew Hall - initial API and implementation (bug 194734)
 ******************************************************************************/

package org.eclipse.core.databinding.property;

import java.util.EventObject;

import org.eclipse.core.databinding.observable.IDiff;
import org.eclipse.core.internal.databinding.Util;

/**
 * Base class for change events in the properties API
 * 
 * @since 1.2
 */
public final class SimplePropertyEvent extends EventObject {
	private static final long serialVersionUID = 1L;

	/**
	 * The property that changed
	 */
	public final ISimpleProperty property;

	/**
	 * A diff object describing the change in state, or null if the change is
	 * unknown or could not be determined.
	 */
	public final IDiff diff;

	/**
	 * Constructs a PropertyChangeEvent with the given attributes
	 * 
	 * @param source
	 *            the property source
	 * @param property
	 *            the property that changed on the source
	 * @param diff
	 *            a diff describing the change in state, or null if the change
	 *            is unknown.
	 */
	public SimplePropertyEvent(Object source, ISimpleProperty property,
			IDiff diff) {
		super(source);
		this.property = property;
		this.diff = diff;
	}

	public boolean equals(Object obj) {
		if (obj == this)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;

		SimplePropertyEvent that = (SimplePropertyEvent) obj;
		return Util.equals(getSource(), that.getSource())
				&& Util.equals(this.property, that.property)
				&& Util.equals(this.diff, that.diff);
	}

	public int hashCode() {
		int hash = 17;
		hash = hash * 37 + getSource().hashCode();
		hash = hash * 37 + property.hashCode();
		hash = hash * 37 + (diff == null ? 0 : diff.hashCode());
		return hash;
	}
}

Return to bug 194734

Lines 26-33 Link Here

(-)src/org/eclipse/jface/examples/databinding/snippets/Snippet026AnonymousBeanProperties.java (-7 / +7 lines)
26	import org.eclipse.core.databinding.observable.set.SetDiff;	26	import org.eclipse.core.databinding.observable.set.SetDiff;
27	import org.eclipse.core.databinding.observable.value.IObservableValue;	27	import org.eclipse.core.databinding.observable.value.IObservableValue;
28	import org.eclipse.core.databinding.property.INativePropertyListener;	28	import org.eclipse.core.databinding.property.INativePropertyListener;
29	import org.eclipse.core.databinding.property.IPropertyChangeListener;	29	import org.eclipse.core.databinding.property.ISimplePropertyListener;
30	import org.eclipse.core.databinding.property.PropertyChangeEvent;	30	import org.eclipse.core.databinding.property.SimplePropertyEvent;
31	import org.eclipse.core.databinding.property.set.DelegatingSetProperty;	31	import org.eclipse.core.databinding.property.set.DelegatingSetProperty;
32	import org.eclipse.core.databinding.property.set.ISetProperty;	32	import org.eclipse.core.databinding.property.set.ISetProperty;
33	import org.eclipse.core.databinding.property.set.SimpleSetProperty;	33	import org.eclipse.core.databinding.property.set.SimpleSetProperty;
Lines 242-262 Link Here
242	}	242	}
243	}	243	}
244		244
245	protected INativePropertyListener adaptListener(	245	public INativePropertyListener adaptListener(
246	final IPropertyChangeListener listener) {	246	final ISimplePropertyListener listener) {
247	return new Listener(listener);	247	return new Listener(listener);
248	}	248	}
249		249
250	private class Listener implements INativePropertyListener,	250	private class Listener implements INativePropertyListener,
251	PropertyChangeListener {	251	PropertyChangeListener {
252	private final IPropertyChangeListener listener;	252	private final ISimplePropertyListener listener;
253		253
254	Listener(IPropertyChangeListener listener) {	254	Listener(ISimplePropertyListener listener) {
255	this.listener = listener;	255	this.listener = listener;
256	}	256	}
257		257
258	public void propertyChange(java.beans.PropertyChangeEvent evt) {	258	public void propertyChange(java.beans.PropertyChangeEvent evt) {
259	listener.handlePropertyChange(new PropertyChangeEvent(evt	259	listener.handlePropertyChange(new SimplePropertyEvent(evt
260	.getSource(), ContactGroupContactsProperty.this, null));	260	.getSource(), ContactGroupContactsProperty.this, null));
261	}	261	}
262	}	262	}

Lines 15-25 Link Here

(-)src/org/eclipse/core/databinding/property/map/SimpleMapProperty.java (-39 / +23 lines)
15	import java.util.Collections;	15	import java.util.Collections;
16	import java.util.Map;	16	import java.util.Map;
17		17
		18	import org.eclipse.core.databinding.observable.IDiff;
18	import org.eclipse.core.databinding.observable.Realm;	19	import org.eclipse.core.databinding.observable.Realm;
19	import org.eclipse.core.databinding.observable.map.IObservableMap;	20	import org.eclipse.core.databinding.observable.map.IObservableMap;
20	import org.eclipse.core.databinding.observable.map.MapDiff;	21	import org.eclipse.core.databinding.observable.map.MapDiff;
21	import org.eclipse.core.databinding.property.INativePropertyListener;	22	import org.eclipse.core.databinding.property.INativePropertyListener;
22	import org.eclipse.core.databinding.property.IPropertyChangeListener;	23	import org.eclipse.core.databinding.property.ISimplePropertyListener;
		24	import org.eclipse.core.internal.databinding.property.map.SimpleMapPropertyObservableMap;
23		25
24	/**	26	/**
25	* Simplified abstract implementation of IMapProperty. This class takes care of	27	* Simplified abstract implementation of IMapProperty. This class takes care of
Lines 32-38 Link Here
32	* <li> {@link #getValueType()}	34	* <li> {@link #getValueType()}
33	* <li> {@link #doGetMap(Object)}	35	* <li> {@link #doGetMap(Object)}
34	* <li> {@link #doSetMap(Object, Map, MapDiff)}	36	* <li> {@link #doSetMap(Object, Map, MapDiff)}
35	* <li> {@link #adaptListener(IPropertyChangeListener)}	37	* <li> {@link #adaptListener(ISimplePropertyListener)}
36	* <li> {@link #doAddListener(Object, INativePropertyListener)}	38	* <li> {@link #doAddListener(Object, INativePropertyListener)}
37	* <li> {@link #doRemoveListener(Object, INativePropertyListener)}	39	* <li> {@link #doRemoveListener(Object, INativePropertyListener)}
38	* </ul>	40	* </ul>
Lines 43-65 Link Here
43	* @since 1.2	45	* @since 1.2
44	*/	46	*/
45	public abstract class SimpleMapProperty extends MapProperty implements	47	public abstract class SimpleMapProperty extends MapProperty implements
46	IMapProperty {	48	ISimpleMapProperty {
47	public IObservableMap observe(Realm realm, Object source) {	49	public IObservableMap observe(Realm realm, Object source) {
48	return new SimpleMapPropertyObservableMap(realm, source, this);	50	return new SimpleMapPropertyObservableMap(realm, source, this);
49	}	51	}
50		52
51	// Accessors	53	// Accessors
52		54
53	/**	55	public final Object get(Object source) {
54	* Returns an unmodifiable Map with the current contents of the source's map
55	* property.
56	*
57	* @param source
58	* the property source
59	* @return a Map with the current contents of the source's map property
60	* @noreference This method is not intended to be referenced by clients.
61	*/
62	protected final Map getMap(Object source) {
63	if (source == null)	56	if (source == null)
64	return Collections.EMPTY_MAP;	57	return Collections.EMPTY_MAP;
65	return Collections.unmodifiableMap(doGetMap(source));	58	return Collections.unmodifiableMap(doGetMap(source));
Lines 77-96 Link Here
77		70
78	// Mutators	71	// Mutators
79		72
80	/**	73	public final void set(Object source, Object value, IDiff diff) {
81	* Updates the property on the source with the specified change.	74	Map map = (Map) value;
82	*	75	MapDiff mapDiff = (MapDiff) diff;
83	* @param source	76	if (source != null && !mapDiff.isEmpty())
84	* the property source	77	doSetMap(source, map, mapDiff);
85	* @param map
86	* the new map
87	* @param diff
88	* a diff describing the change
89	* @noreference This method is not intended to be referenced by clients.
90	*/
91	protected final void setMap(Object source, Map map, MapDiff diff) {
92	if (source != null && !diff.isEmpty())
93	doSetMap(source, map, diff);
94	}	78	}
95		79
96	/**	80	/**
Lines 124-146 Link Here
124	* ISetProperty or IMapProperty) depending on the property.	108	* ISetProperty or IMapProperty) depending on the property.
125	* @noreference This method is not intended to be referenced by clients.	109	* @noreference This method is not intended to be referenced by clients.
126	*/	110	*/
127	protected abstract INativePropertyListener adaptListener(	111	public abstract INativePropertyListener adaptListener(
128	IPropertyChangeListener listener);	112	ISimplePropertyListener listener);
129		113
130	/**	114	/**
131	* Adds the specified listener as a listener for this property on the	115	* Adds the specified listener as a listener for this property on the
132	* specified property source. If the source object has no listener API for	116	* specified property source. If the source object has no listener API for
133	* this property (i.e. {@link #adaptListener(IPropertyChangeListener)}	117	* this property (i.e. {@link #adaptListener(ISimplePropertyListener)}
134	* returns null), this method does nothing.	118	* returns null), this method does nothing.
135	*	119	*
136	* @param source	120	* @param source
137	* the property source	121	* the property source
138	* @param listener	122	* @param listener
139	* a listener obtained from calling	123	* a listener obtained from calling
140	* {@link #adaptListener(IPropertyChangeListener)} .	124	* {@link #adaptListener(ISimplePropertyListener)} .
141	* @noreference This method is not intended to be referenced by clients.	125	* @noreference This method is not intended to be referenced by clients.
142	*/	126	*/
143	protected final void addListener(Object source,	127	public final void addListener(Object source,
144	INativePropertyListener listener) {	128	INativePropertyListener listener) {
145	if (source != null)	129	if (source != null)
146	doAddListener(source, listener);	130	doAddListener(source, listener);
Lines 149-162 Link Here
149	/**	133	/**
150	* Adds the specified listener as a listener for this property on the	134	* Adds the specified listener as a listener for this property on the
151	* specified property source. If the source object has no listener API for	135	* specified property source. If the source object has no listener API for
152	* this property (i.e. {@link #adaptListener(IPropertyChangeListener)}	136	* this property (i.e. {@link #adaptListener(ISimplePropertyListener)}
153	* returns null), this method does nothing.	137	* returns null), this method does nothing.
154	*	138	*
155	* @param source	139	* @param source
156	* the property source	140	* the property source
157	* @param listener	141	* @param listener
158	* a listener obtained from calling	142	* a listener obtained from calling
159	* {@link #adaptListener(IPropertyChangeListener)} .	143	* {@link #adaptListener(ISimplePropertyListener)} .
160	* @noreference This method is not intended to be referenced by clients.	144	* @noreference This method is not intended to be referenced by clients.
161	*/	145	*/
162	protected abstract void doAddListener(Object source,	146	protected abstract void doAddListener(Object source,
Lines 165-181 Link Here
165	/**	149	/**
166	* Removes the specified listener as a listener for this property on the	150	* Removes the specified listener as a listener for this property on the
167	* specified property source. If the source object has no listener API for	151	* specified property source. If the source object has no listener API for
168	* this property (i.e. {@link #adaptListener(IPropertyChangeListener)}	152	* this property (i.e. {@link #adaptListener(ISimplePropertyListener)}
169	* returns null), this method does nothing.	153	* returns null), this method does nothing.
170	*	154	*
171	* @param source	155	* @param source
172	* the property source	156	* the property source
173	* @param listener	157	* @param listener
174	* a listener obtained from calling	158	* a listener obtained from calling
175	* {@link #adaptListener(IPropertyChangeListener)} .	159	* {@link #adaptListener(ISimplePropertyListener)} .
176	* @noreference This method is not intended to be referenced by clients.	160	* @noreference This method is not intended to be referenced by clients.
177	*/	161	*/
178	protected final void removeListener(Object source,	162	public final void removeListener(Object source,
179	INativePropertyListener listener) {	163	INativePropertyListener listener) {
180	if (source != null)	164	if (source != null)
181	doRemoveListener(source, listener);	165	doRemoveListener(source, listener);
Lines 184-197 Link Here
184	/**	168	/**
185	* Removes the specified listener as a listener for this property on the	169	* Removes the specified listener as a listener for this property on the
186	* specified property source. If the source object has no listener API for	170	* specified property source. If the source object has no listener API for
187	* this property (i.e. {@link #adaptListener(IPropertyChangeListener)}	171	* this property (i.e. {@link #adaptListener(ISimplePropertyListener)}
188	* returns null), this method does nothing.	172	* returns null), this method does nothing.
189	*	173	*
190	* @param source	174	* @param source
191	* the property source	175	* the property source
192	* @param listener	176	* @param listener
193	* a listener obtained from calling	177	* a listener obtained from calling
194	* {@link #adaptListener(IPropertyChangeListener)} .	178	* {@link #adaptListener(ISimplePropertyListener)} .
195	* @noreference This method is not intended to be referenced by clients.	179	* @noreference This method is not intended to be referenced by clients.
196	*/	180	*/
197	protected abstract void doRemoveListener(Object source,	181	protected abstract void doRemoveListener(Object source,

Removed Link Here

(-)src/org/eclipse/core/databinding/property/map/SimpleMapPropertyObservableMap.java (-296 lines)
1	/*******************************************************************************
2	* Copyright (c) 2008 Matthew Hall and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Matthew Hall - initial API and implementation (bug 194734)
10	******************************************************************************/
11
12	package org.eclipse.core.databinding.property.map;
13
14	import java.util.AbstractSet;
15	import java.util.Collection;
16	import java.util.Collections;
17	import java.util.ConcurrentModificationException;
18	import java.util.HashMap;
19	import java.util.HashSet;
20	import java.util.Iterator;
21	import java.util.Map;
22	import java.util.Set;
23
24	import org.eclipse.core.databinding.observable.Diffs;
25	import org.eclipse.core.databinding.observable.ObservableTracker;
26	import org.eclipse.core.databinding.observable.Realm;
27	import org.eclipse.core.databinding.observable.map.AbstractObservableMap;
28	import org.eclipse.core.databinding.observable.map.MapDiff;
29	import org.eclipse.core.databinding.property.INativePropertyListener;
30	import org.eclipse.core.databinding.property.IProperty;
31	import org.eclipse.core.databinding.property.IPropertyChangeListener;
32	import org.eclipse.core.databinding.property.IPropertyObservable;
33	import org.eclipse.core.databinding.property.PropertyChangeEvent;
34
35	/**
36	* @since 1.2
37	*/
38	class SimpleMapPropertyObservableMap extends AbstractObservableMap implements
39	IPropertyObservable {
40	private Object source;
41	private SimpleMapProperty property;
42
43	private volatile boolean updating = false;
44
45	private volatile int modCount = 0;
46
47	private INativePropertyListener listener;
48
49	private Map cachedMap;
50
51	/**
52	* @param realm
53	* @param source
54	* @param property
55	*/
56	public SimpleMapPropertyObservableMap(Realm realm, Object source,
57	SimpleMapProperty property) {
58	super(realm);
59	this.source = source;
60	this.property = property;
61	}
62
63	public Object getKeyType() {
64	return property.getKeyType();
65	}
66
67	public Object getValueType() {
68	return property.getValueType();
69	}
70
71	private void getterCalled() {
72	ObservableTracker.getterCalled(this);
73	}
74
75	protected void firstListenerAdded() {
76	if (!isDisposed()) {
77	cachedMap = new HashMap(this);
78
79	if (listener == null) {
80	listener = property
81	.adaptListener(new IPropertyChangeListener() {
82	public void handlePropertyChange(
83	final PropertyChangeEvent event) {
84	modCount++;
85	if (!isDisposed() && !updating) {
86	getRealm().exec(new Runnable() {
87	public void run() {
88	notifyIfChanged((MapDiff) event.diff);
89	}
90	});
91	}
92	}
93	});
94	}
95	property.addListener(source, listener);
96	}
97	}
98
99	protected void lastListenerRemoved() {
100	if (listener != null) {
101	property.removeListener(source, listener);
102	}
103
104	cachedMap.clear();
105	cachedMap = null;
106	}
107
108	// Queries
109
110	private Map getMap() {
111	return property.getMap(source);
112	}
113
114	// Single change operations
115
116	private EntrySet es = new EntrySet();
117
118	public Set entrySet() {
119	getterCalled();
120	return es;
121	}
122
123	private class EntrySet extends AbstractSet {
124	public Iterator iterator() {
125	return new EntrySetIterator();
126	}
127
128	public int size() {
129	return getMap().size();
130	}
131	}
132
133	private class EntrySetIterator implements Iterator {
134	private volatile int expectedModCount = modCount;
135	Map map = new HashMap(getMap());
136	Iterator iterator = map.entrySet().iterator();
137	Map.Entry last = null;
138
139	public boolean hasNext() {
140	getterCalled();
141	checkForComodification();
142	return iterator.hasNext();
143	}
144
145	public Object next() {
146	getterCalled();
147	checkForComodification();
148	last = (Map.Entry) iterator.next();
149	return last;
150	}
151
152	public void remove() {
153	getterCalled();
154	checkForComodification();
155
156	iterator.remove(); // stay in sync
157	MapDiff diff = Diffs.createMapDiffSingleRemove(last.getKey(), last
158	.getValue());
159
160	boolean wasUpdating = updating;
161	updating = true;
162	try {
163	property.setMap(source, map, diff);
164	} finally {
165	updating = wasUpdating;
166	}
167
168	notifyIfChanged(null);
169
170	last = null;
171	expectedModCount = modCount;
172	}
173
174	private void checkForComodification() {
175	if (expectedModCount != modCount)
176	throw new ConcurrentModificationException();
177	}
178	}
179
180	public Set keySet() {
181	getterCalled();
182	// AbstractMap depends on entrySet() to fulfil keySet() API, so all
183	// getterCalled() and comodification checks will still be handled
184	return super.keySet();
185	}
186
187	public Object put(Object key, Object value) {
188	checkRealm();
189
190	Map map = new HashMap(getMap());
191
192	boolean add = !map.containsKey(key);
193
194	Object oldValue = map.put(key, value);
195
196	MapDiff diff;
197	if (add)
198	diff = Diffs.createMapDiffSingleAdd(key, value);
199	else
200	diff = Diffs.createMapDiffSingleChange(key, oldValue, value);
201
202	boolean wasUpdating = updating;
203	updating = true;
204	try {
205	property.setMap(source, map, diff);
206	modCount++;
207	} finally {
208	updating = wasUpdating;
209	}
210
211	notifyIfChanged(null);
212
213	return oldValue;
214	}
215
216	public void putAll(Map m) {
217	checkRealm();
218
219	Map map = new HashMap(getMap());
220
221	Map oldValues = new HashMap();
222	Map newValues = new HashMap();
223	Set changedKeys = new HashSet();
224	Set addedKeys = new HashSet();
225	for (Iterator it = m.entrySet().iterator(); it.hasNext();) {
226	Map.Entry entry = (Entry) it.next();
227	Object key = entry.getKey();
228	Object newValue = entry.getValue();
229	if (map.containsKey(key)) {
230	changedKeys.add(key);
231	oldValues.put(key, map.get(key));
232	} else {
233	addedKeys.add(key);
234	}
235	map.put(key, newValue);
236
237	newValues.put(key, newValue);
238	}
239
240	MapDiff diff = Diffs.createMapDiff(addedKeys, Collections.EMPTY_SET,
241	changedKeys, oldValues, newValues);
242
243	boolean wasUpdating = updating;
244	updating = true;
245	try {
246	property.setMap(source, map, diff);
247	modCount++;
248	} finally {
249	updating = wasUpdating;
250	}
251
252	notifyIfChanged(null);
253	}
254
255	public Object remove(Object key) {
256	checkRealm();
257	return super.remove(key);
258	}
259
260	public Collection values() {
261	getterCalled();
262	// AbstractMap depends on entrySet() to fulfil values() API, so all
263	// getterCalled() and comodification checks will still be handled
264	return super.values();
265	}
266
267	private void notifyIfChanged(MapDiff diff) {
268	if (hasListeners()) {
269	Map oldMap = cachedMap;
270	Map newMap = cachedMap = property.getMap(source);
271	if (diff == null)
272	diff = Diffs.computeMapDiff(oldMap, newMap);
273	if (!diff.isEmpty())
274	fireMapChange(diff);
275	}
276	}
277
278	public Object getObserved() {
279	return source;
280	}
281
282	public IProperty getProperty() {
283	return property;
284	}
285
286	public synchronized void dispose() {
287	if (!isDisposed()) {
288	if (listener != null)
289	property.removeListener(source, listener);
290	property = null;
291	source = null;
292	listener = null;
293	}
294	super.dispose();
295	}
296	}

Removed Link Here

(-)src/org/eclipse/core/databinding/property/value/DelegatingCache.java (-208 lines)
1	/*******************************************************************************
2	* Copyright (c) 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.core.databinding.property.value;
13
14	import java.util.Collection;
15	import java.util.Collections;
16	import java.util.HashMap;
17	import java.util.HashSet;
18	import java.util.Iterator;
19	import java.util.Map;
20	import java.util.Set;
21
22	import org.eclipse.core.databinding.observable.Realm;
23	import org.eclipse.core.databinding.observable.map.IMapChangeListener;
24	import org.eclipse.core.databinding.observable.map.IObservableMap;
25	import org.eclipse.core.databinding.observable.map.MapChangeEvent;
26	import org.eclipse.core.databinding.observable.set.IObservableSet;
27	import org.eclipse.core.databinding.observable.set.ISetChangeListener;
28	import org.eclipse.core.databinding.observable.set.SetChangeEvent;
29	import org.eclipse.core.databinding.observable.set.WritableSet;
30	import org.eclipse.core.internal.databinding.IdentityWrapper;
31	import org.eclipse.core.internal.databinding.Util;
32
33	/**
34	* @since 3.3
35	*
36	*/
37	abstract class DelegatingCache {
38	private Realm realm;
39	private DelegatingValueProperty detailProperty;
40	private IObservableSet elements;
41	private Map delegateCaches;
42
43	private class DelegateCache implements IMapChangeListener {
44	private final IValueProperty delegate;
45	private final IObservableSet masterElements;
46	private final IObservableMap masterElementValues;
47	private final Map cachedValues;
48
49	DelegateCache(IValueProperty delegate) {
50	this.delegate = delegate;
51	this.masterElements = new WritableSet(realm, Collections.EMPTY_SET,
52	elements.getElementType());
53	this.masterElementValues = delegate.observeDetail(masterElements);
54	this.cachedValues = new HashMap();
55
56	masterElementValues.addMapChangeListener(this);
57	}
58
59	void add(Object masterElement) {
60	boolean wasEmpty = masterElements.isEmpty();
61
62	masterElements.add(masterElement);
63	cachedValues.put(new IdentityWrapper(masterElement),
64	masterElementValues.get(masterElement));
65
66	if (wasEmpty)
67	delegateCaches.put(delegate, this);
68	}
69
70	void remove(Object masterElement) {
71	cachedValues.remove(new IdentityWrapper(masterElement));
72	masterElements.remove(masterElement);
73	if (cachedValues.isEmpty())
74	dispose();
75	}
76
77	Object get(Object masterElement) {
78	return cachedValues.get(new IdentityWrapper(masterElement));
79	}
80
81	Object put(Object masterElement, Object detailValue) {
82	Object oldValue = masterElementValues.put(masterElement,
83	detailValue);
84	notifyIfChanged(masterElement);
85	return oldValue;
86	}
87
88	boolean containsValue(Object detailValue) {
89	return cachedValues.containsValue(detailValue);
90	}
91
92	public void handleMapChange(MapChangeEvent event) {
93	Set changedKeys = event.diff.getChangedKeys();
94	for (Iterator it = changedKeys.iterator(); it.hasNext();)
95	notifyIfChanged(it.next());
96	}
97
98	private void notifyIfChanged(Object masterElement) {
99	Object oldValue = cachedValues.get(new IdentityWrapper(
100	masterElement));
101	Object newValue = masterElementValues.get(masterElement);
102	if (!Util.equals(oldValue, newValue)) {
103	cachedValues.put(new IdentityWrapper(masterElement), newValue);
104	handleValueChange(masterElement, oldValue, newValue);
105	}
106	}
107
108	void handleValueChange(Object masterElement, Object oldValue,
109	Object newValue) {
110	DelegatingCache.this.handleValueChange(masterElement, oldValue,
111	newValue);
112	}
113
114	void dispose() {
115	delegateCaches.remove(delegate);
116	masterElementValues.dispose();
117	masterElements.dispose();
118	cachedValues.clear();
119	}
120	}
121
122	DelegatingCache(Realm realm, DelegatingValueProperty detailProperty) {
123	this.realm = realm;
124	this.detailProperty = detailProperty;
125
126	this.elements = new WritableSet(realm);
127	this.delegateCaches = new HashMap();
128
129	elements.addSetChangeListener(new ISetChangeListener() {
130	public void handleSetChange(SetChangeEvent event) {
131	for (Iterator it = event.diff.getRemovals().iterator(); it
132	.hasNext();) {
133	IdentityWrapper wrapper = (IdentityWrapper) it.next();
134	Object element = wrapper.unwrap();
135	getCache(element).remove(element);
136
137	}
138	for (Iterator it = event.diff.getAdditions().iterator(); it
139	.hasNext();) {
140	IdentityWrapper wrapper = (IdentityWrapper) it.next();
141	Object element = wrapper.unwrap();
142	getCache(element).add(element);
143	}
144	}
145	});
146	}
147
148	private DelegateCache getCache(Object masterElement) {
149	IValueProperty delegate = detailProperty.getDelegate(masterElement);
150	if (delegateCaches.containsKey(delegate)) {
151	return (DelegateCache) delegateCaches.get(delegate);
152	}
153	return new DelegateCache(delegate);
154	}
155
156	Object get(Object element) {
157	return getCache(element).get(element);
158	}
159
160	Object put(Object element, Object value) {
161	return getCache(element).put(element, value);
162	}
163
164	boolean contains(Object value) {
165	for (Iterator it = delegateCaches.values().iterator(); it.hasNext();) {
166	DelegateCache cache = (DelegateCache) it.next();
167	if (cache.containsValue(value))
168	return true;
169	}
170	return false;
171	}
172
173	private Set identitySet(Collection elements) {
174	Set result = new HashSet();
175	for (Iterator it = elements.iterator(); it.hasNext();) {
176	result.add(new IdentityWrapper(it.next()));
177	}
178	return result;
179	}
180
181	void addAll(Collection elements) {
182	this.elements.addAll(identitySet(elements));
183	}
184
185	void retainAll(Collection elements) {
186	this.elements.retainAll(identitySet(elements));
187	}
188
189	abstract void handleValueChange(Object masterElement, Object oldValue,
190	Object newValue);
191
192	void dispose() {
193	if (elements != null) {
194	elements.clear(); // clears caches
195	elements.dispose();
196	elements = null;
197	}
198
199	if (delegateCaches != null) {
200	for (Iterator it = delegateCaches.values().iterator(); it.hasNext();) {
201	DelegateCache cache = (DelegateCache) it.next();
202	cache.dispose();
203	}
204	delegateCaches.clear();
205	delegateCaches = null;
206	}
207	}
208	}

Added Link Here

(-)src/org/eclipse/core/databinding/property/list/ISimpleListProperty.java (+21 lines)
1	/*******************************************************************************
2	* Copyright (c) 2009 Matthew Hall and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Matthew Hall - initial API and implementation (bug 194734)
10	******************************************************************************/
11
12	package org.eclipse.core.databinding.property.list;
13
14	import org.eclipse.core.databinding.property.ISimpleProperty;
15
16	/**
17	* @since 1.2
18	*
19	*/
20	public interface ISimpleListProperty extends ISimpleProperty, IListProperty {
21	}