Attachment #115196 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 7-16 Link Here

(-)src/org/eclipse/core/databinding/observable/map/MapDiff.java (+34 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
		10	* Matthew Hall - bug 194734
10	*******************************************************************************/	11	*******************************************************************************/
11		12
12	package org.eclipse.core.databinding.observable.map;	13	package org.eclipse.core.databinding.observable.map;
13		14
		15	import java.util.Iterator;
		16	import java.util.Map;
14	import java.util.Set;	17	import java.util.Set;
15		18
16	/**	19	/**
Lines 18-23 Link Here
18	*	21	*
19	*/	22	*/
20	public abstract class MapDiff {	23	public abstract class MapDiff {
		24	/**
		25	* Returns true if the diff has no added, removed or changed entries.
		26	*
		27	* @return true if the diff has no added, removed or changed entries.
		28	* @since 1.2
		29	*/
		30	public boolean isEmpty() {
		31	return getAddedKeys().isEmpty() && getRemovedKeys().isEmpty()
		32	&& getChangedKeys().isEmpty();
		33	}
		34
		35	/**
		36	* Applies the changes in this diff to the given map
		37	*
		38	* @param map
		39	* the map to which the diff will be applied
		40	* @since 1.2
		41	*/
		42	public void applyTo(Map map) {
		43	for (Iterator it = getAddedKeys().iterator(); it.hasNext();) {
		44	Object key = it.next();
		45	map.put(key, getNewValue(key));
		46	}
		47	for (Iterator it = getChangedKeys().iterator(); it.hasNext();) {
		48	Object key = it.next();
		49	map.put(key, getNewValue(key));
		50	}
		51	for (Iterator it = getRemovedKeys().iterator(); it.hasNext();) {
		52	map.remove(it.next());
		53	}
		54	}
21		55
22	/**	56	/**
23	* @return the set of keys which were added	57	* @return the set of keys which were added

Lines 7-17 Link Here

(-)src/org/eclipse/core/databinding/observable/list/ListDiff.java (-1 / +39 lines)
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
10	* Matthew Hall - bug 208858	10	* Matthew Hall - bug 208858, 194734
11	*******************************************************************************/	11	*******************************************************************************/
12		12
13	package org.eclipse.core.databinding.observable.list;	13	package org.eclipse.core.databinding.observable.list;
14		14
		15	import java.util.List;
		16
15	import org.eclipse.core.internal.databinding.Util;	17	import org.eclipse.core.internal.databinding.Util;
16		18
17	/**	19	/**
Lines 84-89 Link Here
84	}	86	}
85		87
86	/**	88	/**
		89	* Returns true if the diff contains no added, removed, moved or replaced
		90	* elements.
		91	*
		92	* @return true if the diff contains no added, removed, moved or replaced
		93	* elements.
		94	* @since 1.2
		95	*/
		96	public boolean isEmpty() {
		97	return getDifferences().length == 0;
		98	}
		99
		100	/**
		101	* Applies the changes in this diff to the given list
		102	*
		103	* @param list
		104	* the list to which the diff will be applied
		105	* @since 1.2
		106	*/
		107	public void applyTo(final List list) {
		108	accept(new ListDiffVisitor() {
		109	public void handleAdd(int index, Object element) {
		110	list.add(index, element);
		111	}
		112
		113	public void handleRemove(int index, Object element) {
		114	list.remove(index);
		115	}
		116
		117	public void handleReplace(int index, Object oldElement,
		118	Object newElement) {
		119	list.set(index, newElement);
		120	}
		121	});
		122	}
		123
		124	/**
87	* @see java.lang.Object#toString()	125	* @see java.lang.Object#toString()
88	*/	126	*/
89	public String toString() {	127	public String toString() {




 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Matthew Hall - bug 194734
 *******************************************************************************/

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

	public abstract Set getRemovals();
	
	/**
	 * Returns true if the diff has no added or removed elements.
	 * 
	 * @return true if the diff has no added or removed elements.
	 * @since 1.2
	 */
	public boolean isEmpty() {
		return getAdditions().isEmpty() && getRemovals().isEmpty();
	}

	/**
	 * Applies the changes in this diff to the given set
	 * 
	 * @param set
	 *            the set to which the diff will be applied
	 * @since 1.2
	 */
	public void applyTo(Set set) {
		set.addAll(getAdditions());
		set.removeAll(getRemovals());
	}

	/**
	 * @see java.lang.Object#toString()
	 */
	public String toString() {




/*******************************************************************************
 * 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.property.IProperty;


/**
 * Interface for value-typed properties
 * 
 * @since 1.2
 * @noimplement This interface is not intended to be implemented by clients.
 */
public interface IValueProperty extends IProperty {
	/**
	 * Returns the source's value property
	 * 
	 * @param source
	 *            the property source
	 * @return the current value of the source's value property
	 */
	public Object getValue(Object source);

	/**
	 * Sets the source's value property to the specified value
	 * 
	 * @param source
	 *            the property source
	 * @param value
	 *            the new value
	 */
	public void setValue(Object source, Object value);

	/**
	 * Returns the value type of the property, or <code>null</code> if untyped.
	 * 
	 * @return the value type of the property, or <code>null</code> if untyped.
	 */
	public Object getValueType();

	/**
	 * Adds the given value property change listener to the list of listeners
	 * for the given source.
	 * 
	 * @param source
	 *            the property source
	 * @param listener
	 *            the listener
	 */
	public void addValueChangeListener(Object source,
			IValuePropertyChangeListener listener);

	/**
	 * Removes the given list property change listener from the list of
	 * listeners for the given source.
	 * 
	 * @param source
	 *            the property source
	 * @param listener
	 *            the listener
	 */
	public void removeValueChangeListener(Object source,
			IValuePropertyChangeListener listener);
}




/*******************************************************************************
 * 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 org.eclipse.core.databinding.property.IPropertyChangeListener;

/**
 * Listener for changes to set properties on a property source
 * 
 * @since 1.2
 */
public interface ISetPropertyChangeListener extends IPropertyChangeListener {
	/**
	 * Handle a change to a set property on a specific property source.
	 * 
	 * @param event
	 *            an event describing the set change that occured.
	 */
	public void handleSetPropertyChange(SetPropertyChangeEvent 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
 ******************************************************************************/

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

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

import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.observable.set.SetDiff;
import org.eclipse.core.databinding.property.SimpleProperty;

/**
 * Abstract set property implementation for properties where the set can be
 * completely replaced in a single atomic operation.
 * <p>
 * For example, a set-typed bean property Customer.addresses can be modified by
 * calling Customer.setAddresses(List addresses).
 * 
 * @since 1.2
 */
public abstract class SimpleSetProperty extends SimpleProperty implements
		ISetProperty {
	public void addSetChangeListener(Object source,
			ISetPropertyChangeListener listener) {
		addPropertyChangeListener(source, listener);
	}

	public void removeSetChangeListener(Object source,
			ISetPropertyChangeListener listener) {
		removePropertyChangeListener(source, listener);
	}

	protected final Object getProperty(Object source) {
		return getSet(source);
	}

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

	public boolean containsAll(Object source, Collection c) {
		return getSet(source).containsAll(c);
	}

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

	public int hashCode(Object source) {
		return getSet(source).hashCode();
	}

	public boolean isEmpty(Object source) {
		return getSet(source).isEmpty();
	}

	public int size(Object source) {
		return getSet(source).size();
	}

	public Object[] toArray(Object source, Object[] array) {
		return getSet(source).toArray(array);
	}

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

	private void updateSetAndFireChange(Object source, Set set, SetDiff diff) {
		setUpdating(source, true);
		try {
			updateSet(source, set, diff);
		} finally {
			setUpdating(source, false);
		}

		if (hasListeners(source)) {
			fireSetChange(source, diff);
		}
	}

	/**
	 * Updates the property on the source with the specified change. A set
	 * change event is fired in the calling method, so implementers do not need
	 * to call {@link #fireSetChange(Object, SetDiff)}.
	 * 
	 * @param source
	 *            the property source
	 * @param set
	 *            the new set
	 * @param diff
	 *            a diff describing the change
	 */
	protected abstract void updateSet(Object source, Set set, SetDiff diff);

	/**
	 * Notifies that the source's property changed. Listeners registered in the
	 * {@link #addListenerTo(Object)} method should call this method when a
	 * property change is observed on the source object.
	 * 
	 * @param source
	 *            the property source
	 * @param diff
	 *            a diff describing the set change. If null, a diff will be
	 *            computed from the cached state and the current state.
	 */
	protected final void fireSetChange(Object source, SetDiff diff) {
		if (!isUpdating(source) && hasListeners(source)) {
			if (diff == null) {
				diff = Diffs.computeSetDiff((Set) getCached(source),
						getSet(source));
			}
			if (!diff.isEmpty()) {
				firePropertyChange(new SetPropertyChangeEvent(source, this,
						diff));
			}
		}
	}

	public boolean add(Object source, Object o) {
		Set set = getSet(source);
		if (!set.contains(o)) {
			set = new HashSet(set);
			boolean added = set.add(o);
			if (added) {
				updateSetAndFireChange(source, set, Diffs.createSetDiff(
						Collections.singleton(o), Collections.EMPTY_SET));
			}
			return added;
		}
		return false;
	}

	public boolean addAll(Object source, Collection c) {
		if (c.isEmpty())
			return false;

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

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

	public void clear(Object source) {
		if (!isEmpty(source)) {
			updateSetAndFireChange(source, new HashSet(), Diffs.createSetDiff(
					Collections.EMPTY_SET, getSet(source)));
		}
	}

	public boolean remove(Object source, Object o) {
		Set set = getSet(source);
		if (set.contains(o)) {
			set = new HashSet(set);
			boolean removed = set.remove(o);
			if (removed) {
				updateSetAndFireChange(source, set, Diffs.createSetDiff(
						Collections.EMPTY_SET, Collections.singleton(o)));
			}
			return removed;
		}
		return false;
	}

	public boolean removeAll(Object source, Collection c) {
		if (c.isEmpty())
			return false;

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

	public boolean retainAll(Object source, Collection c) {
		if (isEmpty(source))
			return false;
		if (c.isEmpty()) {
			clear(source);
			return true;
		}

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




/*******************************************************************************
 * 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.Collection;
import java.util.List;

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

/**
 * Interface for list-typed properties.
 * 
 * @since 1.2
 * @noimplement This interface is not intended to be implemented by clients.
 */
public interface IListProperty extends ICollectionProperty {
	/**
	 * Returns a List with the current contents of the source's list property
	 * 
	 * @param source
	 *            the property source
	 * @return a List with the current contents of the source's list property
	 */
	List getList(Object source);

	/**
	 * Inserts all elements in the specified collection into the source's list
	 * property at the specified index.
	 * 
	 * @param source
	 *            the property source
	 * @param index
	 *            the insertion index
	 * @param c
	 *            the collection of elements to add
	 * @return whether the source's list property was changed
	 */
	boolean addAll(Object source, int index, Collection c);

	/**
	 * Returns the element at the specified position in the source's list
	 * property
	 * 
	 * @param source
	 *            the property source
	 * @param index
	 *            the element position
	 * @return the element at the given position in the source's list property
	 */
	Object get(Object source, int index);

	/**
	 * Replaces the element at the specified position in the source's list
	 * property with the given element.
	 * 
	 * @param source
	 *            the property source
	 * @param index
	 *            the element position
	 * @param element
	 *            the replacement element
	 * @return the element previously at the specified position in the source's
	 *         list property
	 */
	Object set(Object source, int index, Object element);

	/**
	 * Moves the element at the specified old position in the source's list
	 * property to the specified new position
	 * 
	 * @param source
	 *            the property source
	 * @param oldIndex
	 *            the old element position
	 * @param newIndex
	 *            the new element position
	 * @return the element that was moved
	 */
	Object move(Object source, int oldIndex, int newIndex);

	/**
	 * Inserts the element into the source's list property at the specified
	 * position
	 * 
	 * @param source
	 *            the property source
	 * @param index
	 *            the insertion index
	 * @param element
	 *            the element to insert
	 */
	void add(Object source, int index, Object element);

	/**
	 * Removes the element from the source's list property which is located at
	 * the specified position
	 * 
	 * @param source
	 *            the property source
	 * @param index
	 *            the index of the element to remove
	 * @return the element that was removed from the source's list property
	 */
	Object remove(Object source, int index);

	/**
	 * Returns the index of the first location of the given element in the
	 * source's list property, or -1 if the list does not contain the element.
	 * 
	 * @param source
	 *            the property source
	 * @param o
	 *            the element
	 * @return the index of the first location of the given element in the
	 *         source's list property, or -1 if the list does not contain the
	 *         element
	 */
	int indexOf(Object source, Object o);

	/**
	 * Returns the index of the last location of the given element in the
	 * source's list property, or -1 if the list does not contain the given
	 * element.
	 * 
	 * @param source
	 * @param o
	 * @return the index of the last location of the given element in the
	 *         source's list property, or -1 if the list does not contain the
	 *         element
	 */
	int lastIndexOf(Object source, Object o);

	/**
	 * Adds the given list property change listener to the list of listeners for
	 * the given source.
	 * 
	 * @param source
	 *            the property source
	 * @param listener
	 *            the listener
	 */
	public void addListChangeListener(Object source,
			IListPropertyChangeListener listener);

	/**
	 * Removes the given list property change listener from the list of
	 * listeners for the given source.
	 * 
	 * @param source
	 *            the property source
	 * @param listener
	 *            the listener
	 */
	public void removeListChangeListener(Object source,
			IListPropertyChangeListener listener);
}




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

import java.util.Collection;
import java.util.Collections;
import java.util.Map;
import java.util.Set;

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.property.IProperty;
import org.eclipse.core.databinding.property.IPropertyObservable;
import org.eclipse.core.databinding.property.map.IMapProperty;
import org.eclipse.core.databinding.property.map.IMapPropertyChangeListener;
import org.eclipse.core.databinding.property.map.MapPropertyChangeEvent;

/**
 * @since 3.3
 * 
 */
public class PropertyObservableMap extends AbstractObservableMap implements
		IPropertyObservable {
	private Object source;
	private IMapProperty property;

	private volatile boolean updating = false;

	private boolean disposed = false;

	private transient volatile int modCount = 0;

	private IMapPropertyChangeListener listener = new IMapPropertyChangeListener() {
		public void handleMapPropertyChange(final MapPropertyChangeEvent event) {
			if (!disposed && !updating) {
				getRealm().exec(new Runnable() {
					public void run() {
						getRealm().exec(new Runnable() {
							public void run() {
								modCount++;
								fireMapChange(event.diff);
							}
						});
					}
				});
			}
		}
	};

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

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

	protected void firstListenerAdded() {
		if (!disposed) {
			property.addMapChangeListener(source, listener);
		}
	}

	protected void lastListenerRemoved() {
		if (!disposed) {
			property.removeMapChangeListener(source, listener);
		}
	}

	public boolean containsKey(Object key) {
		getterCalled();
		return property.containsKey(source, key);
	}

	public boolean containsValue(Object value) {
		getterCalled();
		return property.containsValue(source, value);
	}

	public Set entrySet() {
		getterCalled();
		// unmodifiable for now
		return Collections.unmodifiableSet(property.getMap(source).entrySet());
	}

	public Object get(Object key) {
		getterCalled();
		return property.get(source, key);
	}

	public boolean isEmpty() {
		getterCalled();
		return property.isEmpty(source);
	}

	public Set keySet() {
		getterCalled();
		return Collections.unmodifiableSet(property.getMap(source).keySet());
	}

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

	public void putAll(Map m) {
		checkRealm();
		property.putAll(source, m);
	}

	public Object remove(Object key) {
		checkRealm();
		return property.remove(source, key);
	}

	public int size() {
		getterCalled();
		return property.size(source);
	}

	public Collection values() {
		getterCalled();
		return Collections.unmodifiableCollection(property.getMap(source)
				.values());
	}

	public void clear() {
		getterCalled();
		property.clear(source);
	}

	public boolean equals(Object o) {
		getterCalled();
		return property.equals(source, o);
	}

	public int hashCode() {
		getterCalled();
		return property.hashCode(source);
	}

	public Object getObserved() {
		return source;
	}

	public IProperty getProperty() {
		return property;
	}

	public synchronized void dispose() {
		if (!disposed) {
			disposed = true;
			property.removeMapChangeListener(source, listener);
			property = null;
			source = 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;

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

import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.observable.value.ValueDiff;
import org.eclipse.core.databinding.property.value.IValueProperty;
import org.eclipse.core.databinding.property.value.IValuePropertyChangeListener;
import org.eclipse.core.databinding.property.value.ValueProperty;
import org.eclipse.core.databinding.property.value.ValuePropertyChangeEvent;

/**
 * @since 1.2
 * 
 */
public class ValuePropertyDetailValue extends ValueProperty implements
		IValueProperty {
	private IValueProperty masterProperty;
	private IValueProperty detailProperty;

	private Map sourceToDetailListener = new HashMap();

	private IValuePropertyChangeListener masterListener = new MasterPropertyListener();

	private class MasterPropertyListener implements
			IValuePropertyChangeListener {
		public void handleValuePropertyChange(ValuePropertyChangeEvent event) {
			Object oldSource = event.diff.getOldValue();
			Object newSource = event.diff.getNewValue();

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

			ValueDiff diff = Diffs.createValueDiff(oldValue, newValue);

			Object source = event.getSource();

			removeDetailPropertyListener(source);
			addDetailPropertyListener(source);

			fireValueChange(source, diff);
		}
	}

	private class DetailPropertyListener implements
			IValuePropertyChangeListener {
		private Object source;
		private Object masterValue;

		DetailPropertyListener(Object source, Object masterValue) {
			this.source = source;
			this.masterValue = masterValue;
		}

		public void handleValuePropertyChange(ValuePropertyChangeEvent event) {
			fireValueChange(source, event.diff);
		}
	}

	/**
	 * @param masterProperty
	 * @param detailProperty
	 */
	public ValuePropertyDetailValue(IValueProperty masterProperty,
			IValueProperty detailProperty) {
		this.masterProperty = masterProperty;
		this.detailProperty = detailProperty;
	}

	protected void addListenerTo(Object source) {
		masterProperty.addValueChangeListener(source, masterListener);
		addDetailPropertyListener(source);
	}

	protected void removeListenerFrom(Object source) {
		masterProperty.removeValueChangeListener(source, masterListener);
		removeDetailPropertyListener(source);
	}

	private void addDetailPropertyListener(Object source) {
		Object masterValue = masterProperty.getValue(source);
		DetailPropertyListener detailListener = new DetailPropertyListener(
				source, masterValue);
		detailProperty.addValueChangeListener(masterValue, detailListener);
		sourceToDetailListener.put(source, detailListener);
	}

	private void removeDetailPropertyListener(Object source) {
		DetailPropertyListener detailListener = (DetailPropertyListener) sourceToDetailListener
				.remove(source);
		if (detailListener != null) {
			detailProperty.removeValueChangeListener(
					detailListener.masterValue, detailListener);
		}
		sourceToDetailListener.remove(source);
	}

	public Object getValue(Object source) {
		Object masterValue = masterProperty.getValue(source);
		return detailProperty.getValue(masterValue);
	}

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

	public void setValue(Object source, Object value) {
		Object masterValue = masterProperty.getValue(source);
		detailProperty.setValue(masterValue, value);
	}
}




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

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.ObservableTracker;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.list.AbstractObservableList;
import org.eclipse.core.databinding.property.IProperty;
import org.eclipse.core.databinding.property.IPropertyObservable;
import org.eclipse.core.databinding.property.list.IListProperty;
import org.eclipse.core.databinding.property.list.IListPropertyChangeListener;
import org.eclipse.core.databinding.property.list.ListPropertyChangeEvent;

/**
 * @since 3.3
 * 
 */
public class PropertyObservableList extends AbstractObservableList implements
		IPropertyObservable {
	private Object source;
	private IListProperty property;

	private volatile boolean updating = false;

	private boolean disposed = false;

	private transient volatile int modCount = 0;

	private IListPropertyChangeListener listener = new IListPropertyChangeListener() {
		public void handleListPropertyChange(final ListPropertyChangeEvent event) {
			if (!disposed && !updating) {
				getRealm().exec(new Runnable() {
					public void run() {
						getRealm().exec(new Runnable() {
							public void run() {
								modCount++;
								fireListChange(event.diff);
							}
						});
					}
				});
			}
		}
	};

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

	protected void firstListenerAdded() {
		if (!disposed) {
			property.addListChangeListener(source, listener);
		}
	}

	protected void lastListenerRemoved() {
		if (!disposed) {
			property.removeListChangeListener(source, listener);
		}
	}

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

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

	// Queries

	protected int doGetSize() {
		return property.size(source);
	}

	public boolean contains(Object o) {
		getterCalled();
		return property.contains(source, o);
	}

	public boolean containsAll(Collection c) {
		getterCalled();
		return property.containsAll(source, c);
	}

	public Object get(int index) {
		getterCalled();
		return property.get(source, index);
	}

	public int indexOf(Object o) {
		getterCalled();
		return property.indexOf(source, o);
	}

	public boolean isEmpty() {
		getterCalled();
		return property.isEmpty(source);
	}

	public int lastIndexOf(Object o) {
		getterCalled();
		return property.lastIndexOf(source, o);
	}

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

	public Object[] toArray(Object[] a) {
		getterCalled();
		return property.toArray(source, a);
	}

	// Single change operations

	public boolean add(Object o) {
		checkRealm();
		return property.add(source, o);
	}

	public Iterator iterator() {
		getterCalled();
		return new Iterator() {
			int lastReturned = -1;
			int expectedModCount = modCount;
			ListIterator delegate = new ArrayList(property.getList(source))
					.listIterator();

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

			public Object next() {
				getterCalled();
				checkForComodification();
				Object next = delegate.next();
				lastReturned = delegate.previousIndex();
				return next;
			}

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

				delegate.remove(); // stay in sync

				property.remove(source, lastReturned);

				lastReturned = -1;
				expectedModCount = modCount;
			}

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

	public Object move(int oldIndex, int newIndex) {
		getterCalled();
		return property.move(source, oldIndex, newIndex);
	}

	public boolean remove(Object o) {
		getterCalled();
		return property.remove(source, o);
	}

	public void add(int index, Object o) {
		getterCalled();
		property.add(source, index, o);
	}

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

	public ListIterator listIterator(final int index) {
		getterCalled();
		return new ListIterator() {
			int lastReturned = -1;
			int expectedModCount = modCount;
			ListIterator delegate = new ArrayList(property.getList(source))
					.listIterator(index);

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

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

			public Object next() {
				getterCalled();
				checkForComodification();
				Object next = delegate.next();
				lastReturned = delegate.previousIndex();
				return next;
			}

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

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

			public Object previous() {
				getterCalled();
				checkForComodification();
				Object previous = delegate.previous();
				lastReturned = delegate.nextIndex();
				return previous;
			}

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

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

				property.add(source, index, o);

				lastReturned = -1;
				expectedModCount = modCount;
			}

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

				delegate.set(o);

				property.set(source, lastReturned, o);

				expectedModCount = modCount;
			}

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

				delegate.remove(); // keep in sync

				property.remove(source, lastReturned);

				lastReturned = -1;
				expectedModCount = modCount;
			}

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

		};
	}

	public Object remove(int index) {
		getterCalled();
		return property.remove(source, index);
	}

	public Object set(int index, Object o) {
		getterCalled();
		return property.set(source, index, o);
	}

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

	// Bulk change operations

	public boolean addAll(Collection c) {
		getterCalled();
		return property.addAll(source, c);
	}

	public boolean addAll(int index, Collection c) {
		getterCalled();
		return property.addAll(source, index, c);
	}

	public boolean removeAll(Collection c) {
		getterCalled();
		return property.removeAll(source, c);
	}

	public boolean retainAll(Collection c) {
		getterCalled();
		return property.retainAll(source, c);
	}

	public void clear() {
		getterCalled();
		property.clear(source);
	}

	public boolean equals(Object o) {
		getterCalled();
		return property.equals(source, o);
	}

	public int hashCode() {
		getterCalled();
		return property.hashCode(source);
	}

	public Object getObserved() {
		return source;
	}

	public IProperty getProperty() {
		return property;
	}

	public synchronized void dispose() {
		if (!disposed) {
			disposed = true;
			property.removeListChangeListener(source, listener);
			property = null;
			source = 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.observable.masterdetail;

import java.util.AbstractSet;
import java.util.HashMap;
import java.util.HashSet;
import java.util.IdentityHashMap;
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.property.value.IValueProperty;
import org.eclipse.core.databinding.property.value.IValuePropertyChangeListener;
import org.eclipse.core.databinding.property.value.ValuePropertyChangeEvent;
import org.eclipse.core.internal.databinding.Util;

/**
 * @since 3.3
 * 
 */
public class MapValuePropertyObservableMap extends AbstractObservableMap
		implements IObserving {
	private IObservableMap map;
	private IValueProperty property;

	private Map keyToMasterValueListener;

	private boolean updating = false;
	private boolean disposed = false;

	private IMapChangeListener mapListener = new IMapChangeListener() {
		public void handleMapChange(final MapChangeEvent event) {
			if (!updating && !disposed) {
				getRealm().exec(new Runnable() {
					public void run() {
						Map oldValues = new HashMap();
						Map newValues = new HashMap();

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

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

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

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

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

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

							removePropertySourceListener(key, oldSource);
							addPropertySourceListener(key, newSource);
						}

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

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

	/**
	 * @param map
	 * @param valueProperty
	 */
	public MapValuePropertyObservableMap(IObservableMap map,
			IValueProperty valueProperty) {
		super(map.getRealm());
		this.map = map;
		this.property = valueProperty;

		this.keyToMasterValueListener = new IdentityHashMap();
	}

	private class ValuePropertySourceChangeListener implements
			IValuePropertyChangeListener {
		private final Object key;

		public ValuePropertySourceChangeListener(Object key) {
			this.key = key;
		}

		public void handleValuePropertyChange(ValuePropertyChangeEvent event) {
			Object oldSource = event.diff.getOldValue();
			Object oldValue = property.getValue(oldSource);
			property.removeValueChangeListener(oldSource, this);

			Object newSource = event.diff.getNewValue();
			Object newValue = property.getValue(newSource);
			property.addValueChangeListener(newSource, this);

			if (!Util.equals(oldValue, newValue))
				fireMapChange(Diffs.createMapDiffSingleChange(key, oldValue,
						newValue));
		}
	}

	protected void firstListenerAdded() {
		if (!disposed) {
			map.addMapChangeListener(mapListener);
			map.addStaleListener(staleListener);
			for (Iterator iterator = map.entrySet().iterator(); iterator
					.hasNext();) {
				Map.Entry entry = (Map.Entry) iterator.next();
				Object key = entry.getKey();
				Object masterValue = entry.getValue();

				addPropertySourceListener(key, masterValue);
			}
		}
	}

	protected void lastListenerRemoved() {
		if (!disposed) {
			map.removeMapChangeListener(mapListener);
			map.removeStaleListener(staleListener);
			for (Iterator iterator = map.entrySet().iterator(); iterator
					.hasNext();) {
				Map.Entry entry = (Map.Entry) iterator.next();
				Object key = entry.getKey();
				Object propertySource = entry.getValue();

				removePropertySourceListener(key, propertySource);
			}
		}
	}

	private void addPropertySourceListener(Object key, Object propertySource) {
		IValuePropertyChangeListener propertyListener = new ValuePropertySourceChangeListener(
				key);
		property.addValueChangeListener(propertySource, propertyListener);
		keyToMasterValueListener.put(key, propertyListener);
	}

	private void removePropertySourceListener(Object key, Object propertySource) {
		IValuePropertyChangeListener propertyListener = (IValuePropertyChangeListener) keyToMasterValueListener
				.remove(key);
		if (propertyListener != null) {
			property
					.removeValueChangeListener(propertySource, propertyListener);
		}
	}

	protected Object doGet(Object key) {
		if (!map.containsKey(key))
			return null;
		return property.getValue(map.get(key));
	}

	protected Object doPut(Object key, Object value) {
		if (!map.containsKey(key))
			return null;
		Object source = map.get(key);

		Object oldValue = property.getValue(source);

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

		Object newValue = property.getValue(source);

		if (!Util.equals(oldValue, newValue)) {
			fireMapChange(Diffs.createMapDiffSingleChange(key, oldValue,
					newValue));
		}

		return oldValue;
	}

	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 = map.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 map.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();
			return get(key);
		}

		public Object setValue(Object value) {
			return 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());
		}
	}

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

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

	public Object getObserved() {
		return map;
	}

	public synchronized void dispose() {
		if (!disposed) {
			disposed = true;
			property = 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;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.observable.set.SetDiff;
import org.eclipse.core.databinding.property.set.ISetProperty;
import org.eclipse.core.databinding.property.set.ISetPropertyChangeListener;
import org.eclipse.core.databinding.property.set.SetProperty;
import org.eclipse.core.databinding.property.set.SetPropertyChangeEvent;
import org.eclipse.core.databinding.property.value.IValueProperty;
import org.eclipse.core.databinding.property.value.IValuePropertyChangeListener;
import org.eclipse.core.databinding.property.value.ValuePropertyChangeEvent;

/**
 * @since 3.3
 * 
 */
public class ValuePropertyDetailSet extends SetProperty {
	private final IValueProperty masterProperty;
	private final ISetProperty detailProperty;

	private Map sourceToDetailListener = new HashMap();

	private IValuePropertyChangeListener masterListener = new MasterPropertyListener();

	private class MasterPropertyListener implements
			IValuePropertyChangeListener {
		public void handleValuePropertyChange(ValuePropertyChangeEvent event) {
			Object oldSource = event.diff.getOldValue();
			Object newSource = event.diff.getNewValue();

			Set oldSet = detailProperty.getSet(oldSource);
			Set newSet = detailProperty.getSet(newSource);
			SetDiff diff = Diffs.computeSetDiff(oldSet, newSet);

			Object source = event.getSource();

			removeDetailPropertyListener(source);
			addDetailPropertyListener(source);

			fireSetChange(source, diff);
		}
	}

	private class DetailPropertyListener implements ISetPropertyChangeListener {
		private Object source;
		private Object masterValue;

		DetailPropertyListener(Object source, Object masterValue) {
			this.source = source;
			this.masterValue = masterValue;
		}

		public void handleSetPropertyChange(SetPropertyChangeEvent event) {
			fireSetChange(source, event.diff);
		}
	}

	/**
	 * @param masterProperty
	 * @param detailProperty
	 */
	public ValuePropertyDetailSet(IValueProperty masterProperty,
			ISetProperty detailProperty) {
		this.masterProperty = masterProperty;
		this.detailProperty = detailProperty;
	}

	protected void addListenerTo(Object source) {
		masterProperty.addValueChangeListener(source, masterListener);
		addDetailPropertyListener(source);
	}

	protected void removeListenerFrom(Object source) {
		masterProperty.removeValueChangeListener(source, masterListener);
		removeDetailPropertyListener(source);
	}

	private void addDetailPropertyListener(Object source) {
		Object masterValue = masterProperty.getValue(source);
		DetailPropertyListener detailListener = new DetailPropertyListener(
				source, masterValue);
		detailProperty.addSetChangeListener(masterValue, detailListener);
		sourceToDetailListener.put(source, detailListener);
	}

	private void removeDetailPropertyListener(Object source) {
		DetailPropertyListener detailListener = (DetailPropertyListener) sourceToDetailListener
				.remove(source);
		if (detailListener != null) {
			detailProperty.removeSetChangeListener(detailListener.masterValue,
					detailListener);
		}
		sourceToDetailListener.remove(source);
	}

	public Set getSet(Object source) {
		Object masterValue = masterProperty.getValue(source);
		return detailProperty.getSet(masterValue);
	}

	public boolean add(Object source, Object o) {
		Object masterValue = masterProperty.getValue(source);
		return detailProperty.add(masterValue, o);
	}

	public boolean addAll(Object source, Collection c) {
		Object masterValue = masterProperty.getValue(source);
		return detailProperty.addAll(masterValue, c);
	}

	public void clear(Object source) {
		Object masterValue = masterProperty.getValue(source);
		detailProperty.clear(masterValue);
	}

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

	public boolean remove(Object source, Object o) {
		Object masterValue = masterProperty.getValue(source);
		return detailProperty.remove(masterValue, o);
	}

	public boolean removeAll(Object source, Collection c) {
		Object masterValue = masterProperty.getValue(source);
		return detailProperty.removeAll(masterValue, c);
	}

	public boolean retainAll(Object source, Collection c) {
		Object masterValue = masterProperty.getValue(source);
		return detailProperty.retainAll(masterValue, c);
	}
}




/*******************************************************************************
 * 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 org.eclipse.core.databinding.property.list.IListProperty;
import org.eclipse.core.databinding.property.map.IMapProperty;
import org.eclipse.core.databinding.property.set.ISetProperty;
import org.eclipse.core.databinding.property.value.IValueProperty;
import org.eclipse.core.internal.databinding.property.ListPropertyDetailValueList;
import org.eclipse.core.internal.databinding.property.MapPropertyDetailValueMap;
import org.eclipse.core.internal.databinding.property.SetPropertyDetailValueMap;
import org.eclipse.core.internal.databinding.property.ValuePropertyDetailList;
import org.eclipse.core.internal.databinding.property.ValuePropertyDetailMap;
import org.eclipse.core.internal.databinding.property.ValuePropertyDetailSet;
import org.eclipse.core.internal.databinding.property.ValuePropertyDetailValue;

/**
 * A factory for chaining properties together to create nested properties.
 * <p>
 * Example: Suppose class <code>A</code> has a property <code>b</code> of type
 * <code>B</code>, and that class <code>B</code> has a property <code>c</code>
 * of type <code>C</code>:
 * 
 * <pre>
 * A a = new A();
 * B b = a.getB();
 * IValueProperty ab = BeanProperties.valueProperty(A.class, &quot;b&quot;);
 * assertTrue(ab.getValue(a) == b);
 * 
 * IValueProperty bc = BeanProperties.valueProperty(B.class, &quot;c&quot;);
 * C c = b.getC();
 * assertTrue(bc.getValue(b) == c);
 * </pre>
 * 
 * Using Properties, the <code>ab</code> and <code>bc</code>
 * properties may be combined to form a nested <code>abc</code> property:
 * 
 * <pre>
 * IValueProperty abc = Properties.detailValue(ab, bc)
 * assertTrue(abc.getValue(a) == c);
 * </pre>
 * 
 * @since 1.2
 */
public class Properties {
	// Properties of IValueProperty properties

	/**
	 * Returns the nested combination of the master value and detail value
	 * properties. Value modifications made through the returned property are
	 * delegated to the detail property, using the value of the master property
	 * as the source.
	 * 
	 * @param masterValue
	 *            the master property
	 * @param detailValue
	 *            the detail property
	 * @return the nested combination of the master and detail properties
	 */
	public static IValueProperty detailValue(IValueProperty masterValue,
			IValueProperty detailValue) {
		return new ValuePropertyDetailValue(masterValue, detailValue);
	}

	/**
	 * Returns the nested combination of the master value and detail list
	 * properties. List modifications made through the returned property are
	 * delegated to the detail property, using the value of the master property
	 * as the source.
	 * 
	 * @param masterValue
	 *            the master property
	 * @param detailList
	 *            the detail property
	 * @return the nested combination of the master value and detail list
	 *         properties
	 */
	public static IListProperty detailList(IValueProperty masterValue,
			IListProperty detailList) {
		return new ValuePropertyDetailList(masterValue, detailList);
	}

	/**
	 * Returns the nested combination of the master value and detail set
	 * properties. Set modifications made through the returned property are
	 * delegated to the detail property, using the value of the master property
	 * as the source.
	 * 
	 * @param masterValue
	 *            the master property
	 * @param detailSet
	 *            the detail property
	 * @return the nested combination of the master value and detail set
	 *         properties
	 */
	public static ISetProperty detailSet(IValueProperty masterValue,
			ISetProperty detailSet) {
		return new ValuePropertyDetailSet(masterValue, detailSet);
	}

	/**
	 * Returns the nested combination of the master value and detail map
	 * properties. Map modifications made through the returned property are
	 * delegated to the detail property, using the value of the master property
	 * as the source.
	 * 
	 * @param masterValue
	 *            the master property
	 * @param detailMap
	 *            the detail property
	 * @return the nested combination of the master value and detial map
	 *         properties
	 */
	public static IMapProperty detailMap(IValueProperty masterValue,
			IMapProperty detailMap) {
		return new ValuePropertyDetailMap(masterValue, detailMap);
	}

	// Properties of IListProperty master properties

	/**
	 * Returns the nested combination of the master list and detail value
	 * properties. Note that because this property is a projection of value
	 * properties over a list, the only modification supported is through the
	 * {@link IValueProperty#setValue(Object, Object)} method. Modifications
	 * made through the returned property are delegated to the detail property,
	 * using the corresponding list element from the master property as the
	 * source.
	 * 
	 * @param masterList
	 *            the master property
	 * @param detailValue
	 *            the detail property
	 * @return the nested combination of the master list and detail value
	 *         properties
	 */
	public static IListProperty detailValues(IListProperty masterList,
			IValueProperty detailValue) {
		return new ListPropertyDetailValueList(masterList, detailValue);
	}

	// Properties of ISetProperty master properties

	/**
	 * Returns the nested combination of the master set and detail value
	 * properties. Note that because this property is a projection of value
	 * properties over a set, the only modifications supported are through the
	 * {@link IMapProperty#put(Object, Object, Object)} and
	 * {@link IMapProperty#putAll(Object, java.util.Map)} methods. In the latter
	 * case, this property does not put entries for keys not already in the
	 * master key set. Modifications made through the returned property are
	 * delegated to the detail property, using the corresponding set element
	 * from the master property as the source.
	 * 
	 * @param masterKeySet
	 *            the master property
	 * @param detailValues
	 *            the detail property
	 * @return the nested combination of the master set and detail value
	 *         properties
	 */
	public static IMapProperty detailValues(ISetProperty masterKeySet,
			IValueProperty detailValues) {
		return new SetPropertyDetailValueMap(masterKeySet, detailValues);
	}

	// Properties of IMapProperty master properties

	/**
	 * Returns the nested combination of the master map and detail value
	 * properties. Note that because this property is a projection of value
	 * properties over a values collection, the only modifications supported are
	 * through the {@link IMapProperty#put(Object, Object, Object)} and
	 * {@link IMapProperty#putAll(Object, java.util.Map)} methods. In the latter
	 * case, this property does not entries for keys not already contained in
	 * the master map's key set. Modifications made through the returned
	 * property are delegated to the detail property, using the corresponding
	 * entry value from the master property as the source.
	 * 
	 * @param masterMap
	 *            the master property
	 * @param detailValues
	 *            the detail property
	 * @return the nested combination of the master map and detail value
	 *         properties.
	 */
	public static IMapProperty detailValues(IMapProperty masterMap,
			IValueProperty detailValues) {
		return new MapPropertyDetailValueMap(masterMap, detailValues);
	}
}




/*******************************************************************************
 * 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.value.ValueDiff;
import org.eclipse.core.databinding.property.Property;

/**
 * Abstract implementation of IValueProperty.
 * 
 * @since 1.2
 */
public abstract class ValueProperty extends Property implements IValueProperty {
	public final void addValueChangeListener(Object source,
			IValuePropertyChangeListener listener) {
		addPropertyChangeListener(source, listener);
	}

	public final void removeValueChangeListener(Object source,
			IValuePropertyChangeListener listener) {
		removePropertyChangeListener(source, listener);
	}

	/**
	 * Fires a ValuePropertyChangeEvent with the given source and diff
	 * 
	 * @param source
	 *            the property source
	 * @param diff
	 *            the value diff
	 */
	protected final void fireValueChange(Object source, ValueDiff diff) {
		firePropertyChange(new ValuePropertyChangeEvent(source, this, diff));
	}
}




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

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

/**
 * Interface for map-typed properties
 * 
 * @since 1.2
 * @noimplement This interface is not intended to be implemented by clients.
 */
public interface IMapProperty extends IProperty {
	/**
	 * Returns a 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
	 */
	Map getMap(Object source);

	/**
	 * Returns the size of the source's map property
	 * 
	 * @param source
	 *            the property source
	 * @return the size of the source's map property
	 */
	int size(Object source);

	/**
	 * Returns whether the source's map property is empty
	 * 
	 * @param source
	 *            the property source
	 * @return whether the source's map property is empty
	 */
	boolean isEmpty(Object source);

	/**
	 * Returns whether the specified key is contained in the key set of the
	 * source's map property
	 * 
	 * @param source
	 *            the property source
	 * @param key
	 *            the key
	 * @return whether the specified key is contained in the key set of the
	 *         source's map property
	 */
	boolean containsKey(Object source, Object key);

	/**
	 * Returns whether the specified value is contains in the values collection
	 * of the source's map property
	 * 
	 * @param source
	 *            the property source
	 * @param value
	 *            the value
	 * @return whether the specified value is contains in the values collection
	 *         of the source's map property
	 */
	boolean containsValue(Object source, Object value);

	/**
	 * Returns the value associated with the specified key in the source's map
	 * property
	 * 
	 * @param source
	 *            the property source
	 * @param key
	 *            the key
	 * @return the value associated with the specified key in the source's map
	 *         property
	 */
	Object get(Object source, Object key);

	/**
	 * Associates the specified value with the specified key in the source's map
	 * property
	 * 
	 * @param source
	 *            the property source
	 * @param key
	 *            the key
	 * @param value
	 *            the value
	 * @return the value that was previously associated with the given key in
	 *         the source's map property
	 */
	Object put(Object source, Object key, Object value);

	/**
	 * Removes the mapping for the specified key from the source's map property
	 * 
	 * @param source
	 *            the property source
	 * @param key
	 *            the key
	 * @return the value that was previously associated with the specified key
	 *         in the source's map property, or null if no such mapping exists
	 */
	Object remove(Object source, Object key);

	/**
	 * Adds all mappings in the specified map to the source's map property.
	 * 
	 * @param source
	 *            the property source
	 * @param t
	 *            the map
	 */
	void putAll(Object source, Map t);

	/**
	 * Removes all mapping from the source's map property
	 * 
	 * @param source
	 *            the property source
	 */
	void clear(Object source);

	/**
	 * Returns whether the source's map property is equal to the argument
	 * 
	 * @param source
	 *            the property source
	 * @param o
	 *            the object to test for equality
	 * @return whether the source's map property is equal to the argument
	 */
	boolean equals(Object source, Object o);

	/**
	 * Returns the hash code of the source's map property
	 * 
	 * @param source
	 *            the property source
	 * @return the hash code of the source's map property
	 */
	int hashCode(Object source);

	/**
	 * Adds the given map property change listener to the list of listeners for
	 * the given source.
	 * 
	 * @param source
	 *            the property source
	 * @param listener
	 *            the listener
	 */
	public void addMapChangeListener(Object source,
			IMapPropertyChangeListener listener);

	/**
	 * Removes the given map property change listener from the list of listeners
	 * for the given source.
	 * 
	 * @param source
	 *            the property source
	 * @param listener
	 *            the listener
	 */
	public void removeMapChangeListener(Object source,
			IMapPropertyChangeListener listener);
}




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

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

import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.observable.map.MapDiff;
import org.eclipse.core.databinding.property.map.IMapProperty;
import org.eclipse.core.databinding.property.map.IMapPropertyChangeListener;
import org.eclipse.core.databinding.property.map.MapProperty;
import org.eclipse.core.databinding.property.map.MapPropertyChangeEvent;
import org.eclipse.core.databinding.property.value.IValueProperty;
import org.eclipse.core.databinding.property.value.IValuePropertyChangeListener;
import org.eclipse.core.databinding.property.value.ValuePropertyChangeEvent;

/**
 * @since 3.3
 * 
 */
public class ValuePropertyDetailMap extends MapProperty {
	private final IValueProperty masterProperty;
	private final IMapProperty detailProperty;

	private Map sourceToDetailListener = new HashMap();

	private IValuePropertyChangeListener masterListener = new MasterValueListener();

	private class MasterValueListener implements IValuePropertyChangeListener {
		public void handleValuePropertyChange(ValuePropertyChangeEvent event) {
			Object oldSource = event.diff.getOldValue();
			Object newSource = event.diff.getNewValue();

			Map oldMap = detailProperty.getMap(oldSource);
			Map newMap = detailProperty.getMap(newSource);
			MapDiff diff = Diffs.computeMapDiff(oldMap, newMap);

			Object source = event.getSource();

			removeDetailPropertyListener(source);
			addDetailPropertyListener(source);

			fireMapChange(source, diff);
		}
	}

	private class DetailPropertyListener implements IMapPropertyChangeListener {
		private Object source;
		private Object masterValue;

		DetailPropertyListener(Object source, Object masterValue) {
			this.source = source;
			this.masterValue = masterValue;
		}

		public void handleMapPropertyChange(MapPropertyChangeEvent event) {
			fireMapChange(source, event.diff);
		}
	}

	/**
	 * @param masterProperty
	 * @param detailProperty
	 */
	public ValuePropertyDetailMap(IValueProperty masterProperty,
			IMapProperty detailProperty) {
		this.masterProperty = masterProperty;
		this.detailProperty = detailProperty;
	}

	protected void addListenerTo(Object source) {
		masterProperty.addValueChangeListener(source, masterListener);
		addDetailPropertyListener(source);
	}

	protected void removeListenerFrom(Object source) {
		masterProperty.removeValueChangeListener(source, masterListener);
		removeDetailPropertyListener(source);
	}

	private void addDetailPropertyListener(Object source) {
		Object masterValue = masterProperty.getValue(source);
		DetailPropertyListener detailListener = new DetailPropertyListener(
				source, masterValue);
		detailProperty.addMapChangeListener(masterValue, detailListener);
		sourceToDetailListener.put(source, detailListener);
	}

	private void removeDetailPropertyListener(Object source) {
		DetailPropertyListener detailListener = (DetailPropertyListener) sourceToDetailListener
				.remove(source);
		if (detailListener != null) {
			detailProperty.removeMapChangeListener(detailListener.masterValue,
					detailListener);
		}
		sourceToDetailListener.remove(source);
	}

	public Map getMap(Object source) {
		Object masterValue = masterProperty.getValue(source);
		return detailProperty.getMap(masterValue);
	}

	public void clear(Object source) {
		Object masterValue = masterProperty.getValue(source);
		detailProperty.clear(masterValue);
	}

	public Object put(Object source, Object key, Object value) {
		Object masterValue = masterProperty.getValue(source);
		return detailProperty.put(masterValue, key, value);
	}

	public void putAll(Object source, Map t) {
		Object masterValue = masterProperty.getValue(source);
		detailProperty.putAll(masterValue, t);
	}

	public Object remove(Object source, Object key) {
		Object masterValue = masterProperty.getValue(source);
		return detailProperty.remove(masterValue, key);
	}
}




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

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.map.MapDiff;
import org.eclipse.core.databinding.property.map.IMapProperty;
import org.eclipse.core.databinding.property.map.IMapPropertyChangeListener;
import org.eclipse.core.databinding.property.map.MapProperty;
import org.eclipse.core.databinding.property.map.MapPropertyChangeEvent;
import org.eclipse.core.databinding.property.value.IValueProperty;
import org.eclipse.core.databinding.property.value.IValuePropertyChangeListener;
import org.eclipse.core.databinding.property.value.ValuePropertyChangeEvent;
import org.eclipse.core.internal.databinding.Util;

/**
 * @since 3.3
 * 
 */
public class MapPropertyDetailValueMap extends MapProperty {
	private final IMapProperty masterProperty;
	private final IValueProperty detailProperty;

	private Map sourceToKeyToDetailListener = new HashMap();

	private IMapPropertyChangeListener masterListener = new MasterPropertyListener();

	private class MasterPropertyListener implements IMapPropertyChangeListener {
		public void handleMapPropertyChange(final MapPropertyChangeEvent event) {
			Object source = event.getSource();

			Map oldValues = new HashMap();
			Map newValues = new HashMap();

			Set addedKeys = event.diff.getAddedKeys();
			for (Iterator it = addedKeys.iterator(); it.hasNext();) {
				Object key = it.next();
				Object newMasterValue = event.diff.getNewValue(key);
				Object newDetailValue = detailProperty.getValue(newMasterValue);
				newValues.put(key, newDetailValue);
				addPropertySourceListener(source, key, newMasterValue);
			}

			Set removedKeys = event.diff.getRemovedKeys();
			for (Iterator it = removedKeys.iterator(); it.hasNext();) {
				Object key = it.next();
				Object oldMasterValue = event.diff.getOldValue(key);
				Object oldDetailValue = detailProperty.getValue(oldMasterValue);
				oldValues.put(key, oldDetailValue);
				removePropertySourceListener(source, key, oldMasterValue);
			}

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

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

				Object oldDetailValue = detailProperty.getValue(oldMasterValue);
				Object newDetailValue = detailProperty.getValue(newMasterValue);

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

				removePropertySourceListener(source, key, oldMasterValue);
				addPropertySourceListener(source, key, newMasterValue);
			}

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

			fireMapChange(source, diff);
		}

		private void addPropertySourceListener(Object source, Object key,
				Object masterValue) {
			Map keyToDetailListener = (Map) sourceToKeyToDetailListener
					.get(source);
			if (keyToDetailListener == null) {
				sourceToKeyToDetailListener.put(source,
						keyToDetailListener = new HashMap());
			}
			if (!keyToDetailListener.containsKey(key)) {
				DetailPropertyListener detailListener = new DetailPropertyListener(
						source, key);
				detailProperty.addValueChangeListener(masterValue,
						detailListener);
				keyToDetailListener.put(key, detailListener);
			}
		}

		private void removePropertySourceListener(Object source, Object key,
				Object masterValue) {
			Map keyToDetailListener = (Map) sourceToKeyToDetailListener
					.get(source);
			if (keyToDetailListener != null
					&& keyToDetailListener.containsKey(key)) {
				DetailPropertyListener detailListener = (DetailPropertyListener) keyToDetailListener
						.remove(key);
				detailProperty.removeValueChangeListener(masterValue,
						detailListener);
			}
		}
	}

	private class DetailPropertyListener implements
			IValuePropertyChangeListener {
		private Object source;
		private Object key;

		DetailPropertyListener(Object source, Object key) {
			this.source = source;
			this.key = key;
		}

		public void handleValuePropertyChange(ValuePropertyChangeEvent event) {
			fireMapChange(source, Diffs.createMapDiffSingleChange(key,
					event.diff.getOldValue(), event.diff.getNewValue()));
		}
	}

	/**
	 * @param masterProperty
	 * @param detailProperty
	 */
	public MapPropertyDetailValueMap(IMapProperty masterProperty,
			IValueProperty detailProperty) {
		this.masterProperty = masterProperty;
		this.detailProperty = detailProperty;
	}

	protected void addListenerTo(Object source) {
		masterProperty.addMapChangeListener(source, masterListener);

		Map keyToDetailListener = new HashMap();
		for (Iterator it = masterProperty.getMap(source).entrySet().iterator(); it
				.hasNext();) {
			Map.Entry entry = (Map.Entry) it.next();
			Object key = entry.getKey();
			Object masterValue = entry.getValue();
			DetailPropertyListener detailListener = new DetailPropertyListener(
					source, key);
			detailProperty.addValueChangeListener(masterValue, detailListener);
			keyToDetailListener.put(masterValue, detailListener);
		}

		sourceToKeyToDetailListener.put(source, keyToDetailListener);
	}

	protected void removeListenerFrom(Object source) {
		masterProperty.removeMapChangeListener(source, masterListener);
		Map masterElementToDetailListener = (Map) sourceToKeyToDetailListener
				.remove(source);
		if (masterElementToDetailListener != null) {
			for (Iterator it = masterElementToDetailListener.entrySet()
					.iterator(); it.hasNext();) {
				Map.Entry entry = (Map.Entry) it.next();
				detailProperty.removeValueChangeListener(entry.getKey(),
						(DetailPropertyListener) entry.getValue());
			}
		}
	}

	public Map getMap(Object source) {
		Map result = new HashMap();
		for (Iterator it = masterProperty.getMap(source).entrySet().iterator(); it
				.hasNext();) {
			Map.Entry entry = (Map.Entry) it.next();
			result.put(entry.getKey(), detailProperty
					.getValue(entry.getValue()));
		}
		return result;
	}

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

	public Object put(Object source, Object key, Object value) {
		if (!masterProperty.containsKey(source, key))
			return null;
		Object masterValue = masterProperty.get(source, key);

		Object result = detailProperty.getValue(masterValue);
		detailProperty.setValue(masterValue, value);
		return result;
	}

	public void putAll(Object source, Map t) {
		for (Iterator it = t.entrySet().iterator(); it.hasNext();) {
			Map.Entry entry = (Map.Entry) it.next();
			Object masterKey = entry.getKey();
			Object detailValue = entry.getValue();
			if (masterProperty.getMap(source).containsKey(masterKey)) {
				detailProperty.setValue(masterKey, detailValue);
			}
		}
	}

	public Object remove(Object source, Object key) {
		throw new UnsupportedOperationException();
	}
}




/*******************************************************************************
 * 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.value.ValueDiff;
import org.eclipse.core.databinding.property.IPropertyChangeListener;
import org.eclipse.core.databinding.property.PropertyChangeEvent;
import org.eclipse.core.runtime.Assert;

/**
 * Value change event describing a change of a value property on a particular
 * property source.
 * 
 * @since 1.2
 */
public class ValuePropertyChangeEvent extends PropertyChangeEvent {
	private static final long serialVersionUID = 1L;

	/**
	 * The value property that changed
	 */
	public final IValueProperty property;

	/**
	 * ValueDiff with the old and new values of the property.
	 */
	public final ValueDiff diff;

	/**
	 * Constructs a ValuePropertyChangeEvent with the given attributes
	 * 
	 * @param source
	 *            the property source
	 * @param property
	 *            the property that changed on the source
	 * @param diff
	 *            a ValueDiff describing the changes to the value property
	 */
	public ValuePropertyChangeEvent(Object source, IValueProperty property,
			ValueDiff diff) {
		super(source);
		this.property = property;
		Assert.isNotNull(diff, "diff cannot be null"); //$NON-NLS-1$
		this.diff = diff;
	}

	protected void dispatch(IPropertyChangeListener listener) {
		((IValuePropertyChangeListener) listener)
				.handleValuePropertyChange(this);
	}
}




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

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.property.IProperty;
import org.eclipse.core.databinding.property.IPropertyObservable;
import org.eclipse.core.databinding.property.value.IValueProperty;
import org.eclipse.core.databinding.property.value.IValuePropertyChangeListener;
import org.eclipse.core.databinding.property.value.ValuePropertyChangeEvent;
import org.eclipse.core.internal.databinding.Util;

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

	private boolean updating = false;

	private boolean disposed = false;

	private IValuePropertyChangeListener listener = new IValuePropertyChangeListener() {
		public void handleValuePropertyChange(
				final ValuePropertyChangeEvent event) {
			if (!disposed && !updating) {
				getRealm().exec(new Runnable() {
					public void run() {
						fireValueChange(event.diff);
					}
				});
			}
		}
	};

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

	protected void firstListenerAdded() {
		if (!disposed) {
			property.addValueChangeListener(source, listener);
		}
	}

	protected void lastListenerRemoved() {
		if (!disposed) {
			property.removeValueChangeListener(source, listener);
		}
	}

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

	protected void doSetValue(Object value) {
		Object oldValue = doGetValue();

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

		Object newValue = doGetValue();
		if (!Util.equals(oldValue, newValue)) {
			fireValueChange(Diffs.createValueDiff(oldValue, newValue));
		}
	}

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

	public Object getObserved() {
		return source;
	}

	public IProperty getProperty() {
		return property;
	}

	public synchronized void dispose() {
		if (!disposed) {
			disposed = true;
			property.removeValueChangeListener(source, listener);
			property = null;
			source = 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;

/**
 * Interface for observing a property of a source object.
 * 
 * @since 1.2
 * @noimplement This interface is not intended to be implemented by clients.
 */
public interface IProperty {
	/**
	 * Returns whether the property is disposed
	 * @return whether the property is disposed
	 */
	public boolean isDisposed();

	/**
	 * Disposes the property, removing all property listeners on source objects.
	 */
	public void 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.list;

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.list.ListDiff;
import org.eclipse.core.databinding.observable.list.ListDiffEntry;
import org.eclipse.core.databinding.property.SimpleProperty;

/**
 * Abstract IListProperty implementation for properties where the list can be
 * completely replaced in a single atomic operation.
 * <p>
 * For example, a list-typed bean property Customer.invoices can be modified by
 * calling Customer.setInvoices(List invoices).
 * 
 * @since 1.2
 */
public abstract class SimpleListProperty extends SimpleProperty implements
		IListProperty {
	public void addListChangeListener(Object source,
			IListPropertyChangeListener listener) {
		addPropertyChangeListener(source, listener);
	}

	public void removeListChangeListener(Object source,
			IListPropertyChangeListener listener) {
		removePropertyChangeListener(source, listener);
	}

	protected final Object getProperty(Object source) {
		return getList(source);
	}

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

	public boolean containsAll(Object source, Collection c) {
		return getList(source).containsAll(c);
	}

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

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

	public int hashCode(Object source) {
		return getList(source).hashCode();
	}

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

	public boolean isEmpty(Object source) {
		return getList(source).isEmpty();
	}

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

	public int size(Object source) {
		return getList(source).size();
	}

	public Object[] toArray(Object source, Object[] array) {
		return getList(source).toArray(array);
	}

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

	private void updateListAndFireChange(Object source, List list, ListDiff diff) {
		setUpdating(source, true);
		try {
			updateList(source, list, diff);
		} finally {
			setUpdating(source, false);
		}

		if (hasListeners(source)) {
			fireListChange(source, diff);
		}
	}

	/**
	 * Updates the property on the source with the specified change. A list
	 * change is fired in the calling method, so implementers do not need to
	 * call {@link #fireListChange(Object, ListDiff)}.
	 * 
	 * @param source
	 *            the property source
	 * @param list
	 *            the new list
	 * @param diff
	 *            a diff describing the change
	 */
	protected abstract void updateList(Object source, List list, ListDiff diff);

	/**
	 * Notifies that the source's property changed. Listeners registered in the
	 * {@link #addListenerTo(Object)} method should call this method when a
	 * property change is observed on the source object.
	 * 
	 * @param source
	 *            the property source
	 * @param diff
	 *            a diff describing the list change. If null, a diff will be
	 *            computed from the cached state and the current state.
	 */
	protected final void fireListChange(Object source, ListDiff diff) {
		if (!isUpdating(source) && hasListeners(source)) {
			if (diff == null) {
				diff = Diffs.computeListDiff((List) getCached(source),
						getList(source));
			}
			if (!diff.isEmpty()) {
				firePropertyChange(new ListPropertyChangeEvent(source, this,
						diff));
			}
		}
	}

	public boolean add(Object source, Object o) {
		add(source, size(source), o);
		return true;
	}

	public void add(Object source, int index, Object element) {
		List list = new ArrayList(getList(source));
		list.add(index, element);
		updateListAndFireChange(source, list, Diffs.createListDiff(Diffs
				.createListDiffEntry(index, true, element)));
	}

	public boolean addAll(Object source, Collection c) {
		if (c.isEmpty())
			return false;
		addAll(source, size(source), c);
		return true;
	}

	public boolean addAll(Object source, int index, Collection c) {
		if (c.isEmpty()) {
			return false;
		}

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

	public void clear(Object source) {
		if (!isEmpty(source)) {
			List list = getList(source);
			ListDiffEntry[] entries = new ListDiffEntry[list.size()];
			int i = 0;
			for (Iterator it = getList(source).iterator(); it.hasNext(); i++) {
				entries[i] = Diffs.createListDiffEntry(0, false, it.next());
			}
			updateListAndFireChange(source, new ArrayList(), Diffs
					.createListDiff(entries));
		}
	}

	public Object move(Object source, int oldIndex, int newIndex) {
		if (oldIndex == newIndex)
			return get(source, oldIndex);
		List list = new ArrayList(getList(source));
		Object result = list.remove(oldIndex);
		list.add(newIndex, result);
		updateListAndFireChange(source, list, Diffs.createListDiff(Diffs
				.createListDiffEntry(oldIndex, false, result), Diffs
				.createListDiffEntry(newIndex, true, result)));
		return result;
	}

	public boolean remove(Object source, Object o) {
		int i = indexOf(source, o);
		if (i == -1)
			return false;
		remove(source, i);
		return true;
	}

	public Object remove(Object source, int index) {
		List list = new ArrayList(getList(source));
		Object result = list.remove(index);
		updateListAndFireChange(source, list, Diffs.createListDiff(Diffs
				.createListDiffEntry(index, false, result)));
		return result;
	}

	public boolean removeAll(Object source, Collection c) {
		if (isEmpty(source)) {
			return false;
		}
		if (c.isEmpty()) {
			return false;
		}
		List list = new ArrayList(getList(source));
		List entries = new ArrayList();
		for (ListIterator it = list.listIterator(); it.hasNext();) {
			Object o = it.next();
			if (c.contains(o)) {
				entries.add(Diffs.createListDiffEntry(it.previousIndex(),
						false, o));
				it.remove();
			}
		}
		boolean changed = !entries.isEmpty();
		if (changed) {
			ListDiffEntry[] ea = (ListDiffEntry[]) entries
					.toArray(new ListDiffEntry[entries.size()]);
			updateListAndFireChange(source, list, Diffs.createListDiff(ea));
		}
		return changed;
	}

	public boolean retainAll(Object source, Collection c) {
		if (isEmpty(source)) {
			return false;
		}
		if (c.isEmpty()) {
			clear(source);
			return true;
		}
		List list = new ArrayList(getList(source));
		List entries = new ArrayList();
		for (ListIterator it = list.listIterator(); it.hasNext();) {
			Object o = it.next();
			if (!c.contains(o)) {
				entries.add(Diffs.createListDiffEntry(it.previousIndex(),
						false, o));
				it.remove();
			}
		}
		boolean changed = !entries.isEmpty();
		if (changed) {
			ListDiffEntry[] ea = (ListDiffEntry[]) entries
					.toArray(new ListDiffEntry[entries.size()]);
			updateListAndFireChange(source, list, Diffs.createListDiff(ea));
		}
		return changed;
	}

	public Object set(Object source, int index, Object element) {
		List list = new ArrayList(getList(source));
		Object result = list.set(index, element);
		updateListAndFireChange(source, list, Diffs.createListDiff(Diffs
				.createListDiffEntry(index, false, result), Diffs
				.createListDiffEntry(index, true, element)));
		return result;
	}
}




/*******************************************************************************
 * 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 org.eclipse.core.databinding.observable.IObserving;

/**
 * Provides access to the details of property observables
 * 
 * @since 1.2
 */
public interface IPropertyObservable extends IObserving {
	/**
	 * Returns the property being observed
	 * 
	 * @return the property being observed
	 */
	IProperty getProperty();
}




/*******************************************************************************
 * 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 org.eclipse.core.databinding.observable.set.SetDiff;
import org.eclipse.core.databinding.property.IPropertyChangeListener;
import org.eclipse.core.databinding.property.PropertyChangeEvent;
import org.eclipse.core.runtime.Assert;

/**
 * Set change event describing an incremental change of a set property on a
 * particular property source.
 * 
 * @since 1.2
 */
public class SetPropertyChangeEvent extends PropertyChangeEvent {
	private static final long serialVersionUID = 1L;

	/**
	 * The set property that changed
	 */
	public final ISetProperty property;

	/**
	 * SetDiff enumerating the added and removed elements in the set.
	 */
	public final SetDiff diff;

	/**
	 * Constructs a SetPropertyChangeEvent with the given attributes
	 * 
	 * @param source
	 *            the property source
	 * @param property
	 *            the property that changed on the source
	 * @param diff
	 *            a SetDiff describing the changes to the set property
	 */
	public SetPropertyChangeEvent(Object source, ISetProperty property,
			SetDiff diff) {
		super(source);
		this.property = property;
		Assert.isNotNull(diff, "diff cannot be null"); //$NON-NLS-1$
		this.diff = diff;
	}

	protected void dispatch(IPropertyChangeListener listener) {
		((ISetPropertyChangeListener) listener).handleSetPropertyChange(this);
	}
}




/*******************************************************************************
 * 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.property.IPropertyChangeListener;

/**
 * Listener for changes to value properties on a property source
 * 
 * @since 1.2
 */
public interface IValuePropertyChangeListener extends IPropertyChangeListener {
	/**
	 * Handle a change to a value property on a specific property source.
	 * 
	 * @param event
	 *            an event describing the value change that occured.
	 */
	public void handleValuePropertyChange(ValuePropertyChangeEvent 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 org.eclipse.core.internal.databinding.property.PropertyCache;
import org.eclipse.core.internal.databinding.property.PropertyUpdateHelper;

/**
 * Abstract IProperty implementation with
 * 
 * @since 1.2
 */
public abstract class SimpleProperty extends Property {
	private PropertyCache cache = new PropertyCache();
	private PropertyUpdateHelper updateHelper = new PropertyUpdateHelper();

	protected final Object getCached(Object source) {
		PropertyCache cache = this.cache;
		return cache == null ? null : cache.get(source);
	}

	/**
	 * Returns whether this property is currently being updated on the source.
	 * Implementors should query this value to avoid unnecessary calculations,
	 * such as computing a diff.
	 * 
	 * @param source
	 *            the property source
	 * @return whether this property is currently being updated on the source.
	 */
	protected final boolean isUpdating(Object source) {
		if (!hasListeners(source))
			return false;
		PropertyUpdateHelper updateHelper = this.updateHelper;
		return updateHelper != null && updateHelper.isUpdating(source);
	}

	protected final void setUpdating(Object source, boolean state) {
		PropertyUpdateHelper updateHelper = this.updateHelper;
		if (updateHelper != null)
			updateHelper.setUpdating(source, state);
	}

	/**
	 * Adds a listener to the specified property source.
	 * <p>
	 * The <code>SimpleProperty</code> implementation of this method ensures
	 * that the property state is cached for as long as the property has
	 * listeners on the given source. If overriding this method in a subclass,
	 * <code>super.addListenerTo</code> must be invoked.
	 */
	protected void addListenerTo(Object source) {
		PropertyCache cache = this.cache;
		if (cache != null)
			cache.put(source, getProperty(source));
	}

	/**
	 * Removes a listener from the specified property source.
	 * <p>
	 * The <code>SimpleProperty</code> implementation of this method ensures
	 * that the property state for the given source is removed from the cache.
	 * If overriding this method in a subclass,
	 * <code>super.removeListenerFrom</code> must be invoked.
	 */
	protected void removeListenerFrom(Object source) {
		PropertyCache cache = this.cache;
		if (cache != null)
			cache.remove(source);
	}

	protected abstract Object getProperty(Object source);

	protected void firePropertyChange(PropertyChangeEvent event) {
		Object source = event.getSource();
		if (!isUpdating(source)) {
			PropertyCache cache = this.cache;
			if (cache != null)
				cache.put(source, getProperty(source));
			super.firePropertyChange(event);
		}
	}

	public synchronized void dispose() {
		if (cache != null) {
			cache.dispose();
			cache = null;
		}
		if (updateHelper != null) {
			updateHelper.dispose();
			updateHelper = 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.list;

import java.util.Collection;

import org.eclipse.core.databinding.observable.list.ListDiff;
import org.eclipse.core.databinding.property.Property;

/**
 * Abstract implementation of IListProperty.
 * 
 * @since 1.2
 */
public abstract class ListProperty extends Property implements
		IListProperty {
	public boolean contains(Object source, Object o) {
		return getList(source).contains(o);
	}

	public boolean containsAll(Object source, Collection c) {
		return getList(source).containsAll(c);
	}

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

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

	public int hashCode(Object source) {
		return getList(source).hashCode();
	}

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

	public boolean isEmpty(Object source) {
		return getList(source).isEmpty();
	}

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

	public int size(Object source) {
		return getList(source).size();
	}

	public Object[] toArray(Object source, Object[] array) {
		return getList(source).toArray(array);
	}

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

	public final void addListChangeListener(Object source,
			IListPropertyChangeListener listener) {
		addPropertyChangeListener(source, listener);
	}

	public final void removeListChangeListener(Object source,
			IListPropertyChangeListener listener) {
		removePropertyChangeListener(source, listener);
	}

	/**
	 * Fires a ListPropertyChangeEvent with the given source and diff
	 * 
	 * @param source
	 *            the property source
	 * @param diff
	 *            the list diff
	 */
	protected final void fireListChange(Object source, ListDiff diff) {
		firePropertyChange(new ListPropertyChangeEvent(source, this, diff));
	}
}




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

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

	protected PropertyChangeEvent(Object source) {
		super(source);
	}

	protected abstract void dispatch(IPropertyChangeListener listener);

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

		return getSource().equals(((PropertyChangeEvent) obj).getSource());
	}

	public int hashCode() {
		return getSource().hashCode();
	}
}




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

/**
 * Interface for collection-typed properties.
 * 
 * @since 1.2
 * @noimplement This interface is not intended to be implemented by clients.
 */
public interface ICollectionProperty extends IProperty {
	/**
	 * Returns the size of the source's collection property
	 * 
	 * @param source
	 *            the property source
	 * @return the size of the source's collection property
	 */
	int size(Object source);

	/**
	 * Returns whether the source's collection property is empty
	 * 
	 * @param source
	 *            the property source
	 * @return whether the source's collection property is empty
	 */
	boolean isEmpty(Object source);

	/**
	 * Returns whether the source's collection property contains the given
	 * element.
	 * 
	 * @param source
	 *            the property source
	 * @param o
	 *            the element
	 * @return whether the source's collection property contains the given
	 *         element.
	 */
	boolean contains(Object source, Object o);

	/**
	 * Returns an array of all elements in the source's collection property
	 * 
	 * @param source
	 *            the property source
	 * @return an array of all elements in the source's collection property
	 */
	Object[] toArray(Object source);

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

	/**
	 * Adds the element to the source's collection property
	 * 
	 * @param source
	 *            the property source
	 * @param o
	 *            the element to add
	 * @return whether the element was added to the source's collection property
	 */
	boolean add(Object source, Object o);

	/**
	 * Removes the element from the source's collection property
	 * 
	 * @param source
	 *            the property source
	 * @param o
	 *            the element to remove
	 * @return whether the element was removed from the source's collection
	 *         property
	 */
	boolean remove(Object source, Object o);

	/**
	 * Returns whether the source's collection property contains all elements in
	 * the given collection
	 * 
	 * @param source
	 *            the property source
	 * @param c
	 *            the collection of elements to test for
	 * @return whether the source's collection property contains all elements in
	 *         the given collection
	 */
	boolean containsAll(Object source, Collection c);

	/**
	 * Adds all elements in the specified collection to the source's collection
	 * property.
	 * 
	 * @param source
	 *            the property source
	 * @param c
	 *            the collection of elements to add.
	 * @return whether the source's collection property was changed
	 */
	boolean addAll(Object source, Collection c);

	/**
	 * Removes all elements from the source's collection property which are
	 * contained in the specified collection.
	 * 
	 * @param source
	 *            the property source
	 * @param c
	 *            the collection of elements to be removed
	 * @return whether the source's collection property was changed
	 */
	boolean removeAll(Object source, Collection c);

	/**
	 * Removes all elements from the source's collection property which are not
	 * contained in the specified collection.
	 * 
	 * @param source
	 *            the property source
	 * @param c
	 *            the collection of elements to retain
	 * @return whether the source's collection property was changed
	 */
	boolean retainAll(Object source, Collection c);

	/**
	 * Removes all elements from the source's collection property.
	 * 
	 * @param source
	 *            the property source
	 */
	void clear(Object source);

	/**
	 * Returns whether the source's collection property is equal to the
	 * argument.
	 * 
	 * @param source
	 *            the property source
	 * @param o
	 *            the object to test for equality to the source's collection
	 *            property
	 * @return whether the source's collection property is equal to the argument
	 */
	boolean equals(Object source, Object o);

	/**
	 * Returns the hash code of the source's collection property.
	 * 
	 * @param source
	 *            the property source
	 * @return the hash code of the source's collection property
	 */
	int hashCode(Object source);

	/**
	 * Returns the type of the elements in the collection or <code>null</code>
	 * if untyped
	 * 
	 * @return the type of the elements in the collection or <code>null</code>
	 *         if untyped
	 */
	Object getElementType();
}




/*******************************************************************************
 * 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 org.eclipse.core.databinding.property.IPropertyChangeListener;

/**
 * Listener for changes to map properties on a property source
 * 
 * @since 1.2
 */
public interface IMapPropertyChangeListener extends IPropertyChangeListener {
	/**
	 * Handle a change to a map property on a specific property source.
	 * 
	 * @param event
	 *            an event describing the map change that occured.
	 */
	public void handleMapPropertyChange(MapPropertyChangeEvent 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.internal.databinding.observable.masterdetail;

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.value.IValueProperty;
import org.eclipse.core.databinding.property.value.IValuePropertyChangeListener;
import org.eclipse.core.databinding.property.value.ValuePropertyChangeEvent;

/**
 * @since 3.3
 * 
 */
public class SetValuePropertyObservableMap extends ComputedObservableMap
		implements IObserving {
	private IValueProperty property;

	private boolean disposed = false;

	private IValuePropertyChangeListener listener = new IValuePropertyChangeListener() {
		public void handleValuePropertyChange(
				final ValuePropertyChangeEvent event) {
			if (!disposed) {
				getRealm().exec(new Runnable() {
					public void run() {
						Object key = event.getSource();
						Object oldValue = event.diff.getOldValue();
						Object newValue = event.diff.getNewValue();
						fireMapChange(Diffs.createMapDiffSingleChange(key,
								oldValue, newValue));
					}
				});
			}
		}
	};

	/**
	 * @param keySet
	 * @param valueProperty
	 */
	public SetValuePropertyObservableMap(IObservableSet keySet,
			IValueProperty valueProperty) {
		super(keySet);
		this.property = valueProperty;
	}

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

	protected Object doPut(Object key, Object value) {
		Object result = property.getValue(key);
		property.setValue(key, value);
		return result;
	}

	protected void hookListener(Object addedKey) {
		if (!disposed)
			property.addValueChangeListener(addedKey, listener);
	}

	protected void unhookListener(Object removedKey) {
		if (!disposed)
			property.removeValueChangeListener(removedKey, listener);
	}

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

	public synchronized void dispose() {
		super.dispose();

		if (!disposed) {
			disposed = true;
			property = null;
			listener = 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;

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

import org.eclipse.core.internal.databinding.IdentityWrapper;
import org.eclipse.core.runtime.ListenerList;

/**
 * Utility class which maintains a listener list per property source object.
 * 
 * @since 1.2
 */
abstract class PropertyChangeSupport {
	private Map changeListeners;

	PropertyChangeSupport() {
		this.changeListeners = null;
	}

	/**
	 * Adds the listener to the list of listeners for the specified source
	 * 
	 * @param source
	 *            the property source
	 * @param listener
	 *            the listener to add
	 */
	synchronized final void addListener(Object source,
			IPropertyChangeListener listener) {
		boolean hadListeners = hasListeners(source);

		if (changeListeners == null) {
			changeListeners = new HashMap();
		}

		ListenerList listeners;
		IdentityWrapper identityWrapper = new IdentityWrapper(source);
		if (changeListeners.containsKey(identityWrapper)) {
			listeners = (ListenerList) changeListeners.get(identityWrapper);
		} else {
			changeListeners
					.put(identityWrapper, listeners = new ListenerList());
		}

		listeners.add(listener);

		if (!hadListeners) {
			addListenerTo(source);
		}
	}

	/**
	 * Removes the listener from the list of listeners for the specified source
	 * 
	 * @param source
	 *            the property source
	 * @param listener
	 *            the listener to remove
	 */
	synchronized final void removeListener(Object source,
			IPropertyChangeListener listener) {
		if (changeListeners != null) {
			IdentityWrapper identityWrapper = new IdentityWrapper(source);
			ListenerList listeners = (ListenerList) changeListeners
					.get(identityWrapper);
			if (listeners != null) {
				listeners.remove(listener);
				if (listeners.isEmpty()) {
					synchronized (listeners) {
						if (listeners.isEmpty()) {
							changeListeners.remove(identityWrapper);
							removeListenerFrom(source);
						}
					}
				}
			}
		}
	}

	/**
	 * Returns whether the change support has listeners registered for the given
	 * property source
	 * 
	 * @param source
	 *            the property source
	 * @return whether the change support has listeners registered for the given
	 *         property source
	 */
	synchronized final boolean hasListeners(Object source) {
		return changeListeners != null
				&& changeListeners.containsKey(new IdentityWrapper(source));
	}

	protected abstract void addListenerTo(Object source);

	protected abstract void removeListenerFrom(Object source);

	private synchronized final Object[] getListeners(Object source) {
		if (changeListeners == null)
			return null;
		ListenerList list = (ListenerList) changeListeners
				.get(new IdentityWrapper(source));
		if (list == null)
			return null;
		return list.getListeners();
	}

	/**
	 * Notifies all registered listeners of the specified property change
	 * 
	 * @param event
	 *            the property change event
	 */
	public final void firePropertyChange(PropertyChangeEvent event) {
		Object[] listeners = getListeners(event.getSource());
		if (listeners != null) {
			for (int i = 0; i < listeners.length; i++) {
				event.dispatch((IPropertyChangeListener) listeners[i]);
			}
		}
	}

	/**
	 * Diposes the change support, removing all registered listeners
	 */
	public synchronized void dispose() {
		if (changeListeners != null) {
			for (Iterator iterator = changeListeners.keySet().iterator(); iterator
					.hasNext();) {
				Object source = ((IdentityWrapper) iterator.next()).unwrap();
				removeListenerFrom(source);
				iterator.remove();
			}
			changeListeners = 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;

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.map.MapDiff;
import org.eclipse.core.databinding.property.map.MapProperty;
import org.eclipse.core.databinding.property.set.ISetProperty;
import org.eclipse.core.databinding.property.set.ISetPropertyChangeListener;
import org.eclipse.core.databinding.property.set.SetPropertyChangeEvent;
import org.eclipse.core.databinding.property.value.IValueProperty;
import org.eclipse.core.databinding.property.value.IValuePropertyChangeListener;
import org.eclipse.core.databinding.property.value.ValuePropertyChangeEvent;

/**
 * @since 3.3
 * 
 */
public class SetPropertyDetailValueMap extends MapProperty {
	private final ISetProperty masterProperty;
	private final IValueProperty detailProperty;

	private Map sourceToMasterElementToDetailListener = new HashMap();

	private ISetPropertyChangeListener masterListener = new MasterPropertyListener();

	private class MasterPropertyListener implements ISetPropertyChangeListener {
		public void handleSetPropertyChange(final SetPropertyChangeEvent event) {
			Object source = event.getSource();

			MapDiff diff;
			if (event.diff == null) {
				diff = null;
			} else {
				final Set removals = event.diff.getRemovals();
				final Set additions = event.diff.getAdditions();

				diff = new MapDiff() {
					public Set getAddedKeys() {
						return additions;
					}

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

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

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

					private Object getValue(Object key) {
						return detailProperty.getValue(key);
					}

					public Set getRemovedKeys() {
						return removals;
					}
				};

				for (Iterator it = removals.iterator(); it.hasNext();) {
					removeElementPropertyListener(source, it.next());
				}
				for (Iterator it = additions.iterator(); it.hasNext();) {
					addElementPropertyListener(source, it.next());
				}
			}

			fireMapChange(source, diff);
		}

		private void addElementPropertyListener(Object source, Object element) {
			Map elementToDetailListener = (Map) sourceToMasterElementToDetailListener
					.get(source);
			if (elementToDetailListener == null) {
				sourceToMasterElementToDetailListener.put(source,
						elementToDetailListener = new HashMap());
			}
			if (!elementToDetailListener.containsKey(element)) {
				DetailPropertyListener detailListener = new DetailPropertyListener(
						source, element);
				detailProperty.addValueChangeListener(element, detailListener);
				elementToDetailListener.put(element, detailListener);
			}
		}

		private void removeElementPropertyListener(Object source, Object element) {
			Map elementToDetailListener = (Map) sourceToMasterElementToDetailListener
					.get(source);
			if (elementToDetailListener != null
					&& elementToDetailListener.containsKey(element)) {
				DetailPropertyListener detailListener = (DetailPropertyListener) elementToDetailListener
						.remove(element);
				detailProperty.removeValueChangeListener(element,
						detailListener);
			}
		}
	}

	private class DetailPropertyListener implements
			IValuePropertyChangeListener {
		private Object source;
		private Object masterValue;

		DetailPropertyListener(Object source, Object masterValue) {
			this.source = source;
			this.masterValue = masterValue;
		}

		public void handleValuePropertyChange(ValuePropertyChangeEvent event) {
			MapDiff diff;
			if (event.diff == null) {
				diff = null;
			} else {
				diff = Diffs.createMapDiffSingleChange(masterValue, event.diff
						.getOldValue(), event.diff.getNewValue());
			}
			fireMapChange(source, diff);
		}
	}

	/**
	 * @param masterProperty
	 * @param detailProperty
	 */
	public SetPropertyDetailValueMap(ISetProperty masterProperty,
			IValueProperty detailProperty) {
		this.masterProperty = masterProperty;
		this.detailProperty = detailProperty;
	}

	protected void addListenerTo(Object source) {
		masterProperty.addSetChangeListener(source, masterListener);

		Map masterElementToDetailListener = new HashMap();
		for (Iterator it = masterProperty.getSet(source).iterator(); it
				.hasNext();) {
			Object masterElement = it.next();
			DetailPropertyListener detailListener = new DetailPropertyListener(
					source, masterElement);
			detailProperty
					.addValueChangeListener(masterElement, detailListener);
			masterElementToDetailListener.put(masterElement, detailListener);
		}

		sourceToMasterElementToDetailListener.put(source,
				masterElementToDetailListener);
	}

	protected void removeListenerFrom(Object source) {
		masterProperty.removeSetChangeListener(source, masterListener);
		Map masterElementToDetailListener = (Map) sourceToMasterElementToDetailListener
				.remove(source);
		if (masterElementToDetailListener != null) {
			for (Iterator it = masterElementToDetailListener.entrySet()
					.iterator(); it.hasNext();) {
				Map.Entry entry = (Map.Entry) it.next();
				detailProperty.removeValueChangeListener(entry.getKey(),
						(DetailPropertyListener) entry.getValue());
			}
		}
	}

	public Map getMap(Object source) {
		Map result = new HashMap();
		for (Iterator it = masterProperty.getSet(source).iterator(); it
				.hasNext();) {
			Object element = it.next();
			result.put(element, detailProperty.getValue(element));
		}
		return result;
	}

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

	public Object put(Object source, Object key, Object value) {
		if (!masterProperty.contains(source, key))
			return null;
		Object result = detailProperty.getValue(key);
		detailProperty.setValue(key, value);
		return result;
	}

	public void putAll(Object source, Map t) {
		Set masterSet = masterProperty.getSet(source);
		for (Iterator it = t.entrySet().iterator(); it.hasNext();) {
			Map.Entry entry = (Map.Entry) it.next();
			if (masterSet.contains(entry.getKey())) {
				detailProperty.setValue(entry.getKey(), entry.getValue());
			}
		}
	}

	public Object remove(Object source, Object key) {
		throw new UnsupportedOperationException();
	}
}




/*******************************************************************************
 * 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 org.eclipse.core.databinding.observable.map.MapDiff;
import org.eclipse.core.databinding.property.Property;

/**
 * Abstract implementation of IMapProperty
 * 
 * @since 1.2
 */
public abstract class MapProperty extends Property implements IMapProperty {
	public boolean containsKey(Object source, Object key) {
		return getMap(source).containsKey(key);
	}

	public boolean containsValue(Object source, Object value) {
		return getMap(source).containsValue(value);
	}

	public boolean equals(Object source, Object o) {
		return getMap(source).equals(o);
	}

	public Object get(Object source, Object key) {
		return getMap(source).get(key);
	}

	public int hashCode(Object source) {
		return getMap(source).hashCode();
	}

	public boolean isEmpty(Object source) {
		return getMap(source).isEmpty();
	}

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

	public final void addMapChangeListener(Object source,
			IMapPropertyChangeListener listener) {
		addPropertyChangeListener(source, listener);
	}

	public final void removeMapChangeListener(Object source,
			IMapPropertyChangeListener listener) {
		removePropertyChangeListener(source, listener);
	}

	/**
	 * Fires a MapPropertyChangeEvent with the given source and diff
	 * 
	 * @param source
	 *            the property source
	 * @param diff
	 *            the map diff
	 */
	protected final void fireMapChange(Object source, MapDiff diff) {
		firePropertyChange(new MapPropertyChangeEvent(source, this, diff));
	}
}




/*******************************************************************************
 * 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 org.eclipse.core.databinding.observable.set.SetDiff;
import org.eclipse.core.databinding.property.Property;

/**
 * Abstract implementation of ISetProperty
 * 
 * @since 1.2
 */
public abstract class SetProperty extends Property implements
		ISetProperty {
	public boolean contains(Object source, Object o) {
		return getSet(source).contains(o);
	}

	public boolean containsAll(Object source, Collection c) {
		return getSet(source).containsAll(c);
	}

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

	public int hashCode(Object source) {
		return getSet(source).hashCode();
	}

	public boolean isEmpty(Object source) {
		return getSet(source).isEmpty();
	}

	public int size(Object source) {
		return getSet(source).size();
	}

	public Object[] toArray(Object source, Object[] array) {
		return getSet(source).toArray(array);
	}

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

	public final void addSetChangeListener(Object source,
			ISetPropertyChangeListener listener) {
		addPropertyChangeListener(source, listener);
	}

	public final void removeSetChangeListener(Object source,
			ISetPropertyChangeListener listener) {
		removePropertyChangeListener(source, listener);
	}

	/**
	 * Fires a SetPropertyChangeEvent with the given source and diff
	 * 
	 * @param source
	 *            the property source
	 * @param diff
	 *            the set diff
	 */
	protected final void fireSetChange(Object source, SetDiff diff) {
		firePropertyChange(new SetPropertyChangeEvent(source, this, diff));
	}
}




/*******************************************************************************
 * 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 org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.observable.value.ValueDiff;
import org.eclipse.core.databinding.property.SimpleProperty;
import org.eclipse.core.internal.databinding.Util;

/**
 * Abstract implementation of IValueProperty. This class satisfies many of the
 * functional requirements of the IValueProperty interface, and tries to leave
 * only the aspects specific to the concrete class
 * <p>
 * 
 * 
 * @since 1.2
 */
public abstract class SimpleValueProperty extends SimpleProperty implements
		IValueProperty {
	public void addValueChangeListener(Object source,
			IValuePropertyChangeListener listener) {
		addPropertyChangeListener(source, listener);
	}

	public void removeValueChangeListener(Object source,
			IValuePropertyChangeListener listener) {
		removePropertyChangeListener(source, listener);
	}

	protected final Object getProperty(Object source) {
		return getValue(source);
	}

	/**
	 * Sets the value property on the source to the specified value, then fires
	 * a value change.
	 * 
	 * @param source
	 *            the property source
	 * @param value
	 *            the new value
	 */
	public final void setValue(Object source, Object value) {
		Object oldValue = getCached(source);

		setUpdating(source, true);
		try {
			updateValue(source, value, Diffs.createValueDiff(oldValue, value));
		} finally {
			setUpdating(source, false);
		}

		if (hasListeners(source)) {
			Object newValue = getValue(source);
			if (!Util.equals(oldValue, newValue)) {
				fireValueChange(source, Diffs.createValueDiff(oldValue,
						newValue));
			}
		}
	}

	/**
	 * Updates the property on the source with the specified change. A value
	 * change event is fired in the calling method, so implementers do not need
	 * to call {@link #fireValueChange(Object, ValueDiff)}.
	 * 
	 * @param source
	 *            the property source
	 * @param value
	 *            the new value
	 * @param diff
	 *            a diff describing the change
	 */
	protected abstract void updateValue(Object source, Object value,
			ValueDiff diff);

	/**
	 * Notifies that the source's property changed. Listeners registered in the
	 * {@link #addListenerTo(Object)} method should call this method when a
	 * property change is observed on the source object.
	 * 
	 * @param source
	 *            the property source
	 * @param diff
	 *            a diff describing the value change. If null, a diff will be
	 *            created from the cached value and the current value.
	 */
	protected final void fireValueChange(Object source, ValueDiff diff) {
		if (!isUpdating(source) && hasListeners(source)) {
			if (diff == null) {
				diff = Diffs.createValueDiff(getCached(source),
						getValue(source));
			}
			if (!Util.equals(diff.getOldValue(), diff.getNewValue())) {
				firePropertyChange(new ValuePropertyChangeEvent(source, this,
						diff));
			}
		}
	}
}




/*******************************************************************************
 * 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 org.eclipse.core.databinding.observable.IObservable;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.list.IObservableList;
import org.eclipse.core.databinding.observable.map.IObservableMap;
import org.eclipse.core.databinding.observable.masterdetail.IObservableFactory;
import org.eclipse.core.databinding.observable.masterdetail.MasterDetailObservables;
import org.eclipse.core.databinding.observable.set.IObservableSet;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.core.databinding.property.list.IListProperty;
import org.eclipse.core.databinding.property.map.IMapProperty;
import org.eclipse.core.databinding.property.set.ISetProperty;
import org.eclipse.core.databinding.property.value.IValueProperty;
import org.eclipse.core.internal.databinding.observable.PropertyObservableList;
import org.eclipse.core.internal.databinding.observable.PropertyObservableMap;
import org.eclipse.core.internal.databinding.observable.PropertyObservableSet;
import org.eclipse.core.internal.databinding.observable.PropertyObservableValue;
import org.eclipse.core.internal.databinding.observable.masterdetail.ListValuePropertyObservableList;
import org.eclipse.core.internal.databinding.observable.masterdetail.MapValuePropertyObservableMap;
import org.eclipse.core.internal.databinding.observable.masterdetail.SetValuePropertyObservableMap;

/**
 * A factory for creating observables observing properties of source objects
 * 
 * @since 1.2
 */
public class PropertyObservables {
	/**
	 * Returns an observable value on the default realm that tracks the given
	 * property of the source object.
	 * 
	 * @param source
	 *            the property value
	 * @param property
	 *            the value property to observe
	 * @return an observable value on the default realm that tracks the given
	 *         property of the source object.
	 * @since 1.2
	 */
	public static IObservableValue observeValue(Object source,
			IValueProperty property) {
		return observeValue(Realm.getDefault(), source, property);
	}

	/**
	 * Returns an observable value on the given realm that tracks the given
	 * property of the source object
	 * 
	 * @param realm
	 *            the realm
	 * @param source
	 *            the property source
	 * @param property
	 *            the value property observe
	 * @return an observable value that tracks the given property of the source
	 *         object
	 * @since 1.2
	 */
	public static IObservableValue observeValue(Realm realm, Object source,
			IValueProperty property) {
		return new PropertyObservableValue(realm, source, property);
	}

	/**
	 * Returns a factory for creating observable values on the default realm
	 * tracking the given property of a particular source object
	 * 
	 * @param property
	 *            the property to observe
	 * @return a factory for creating observable values on the default realm
	 *         tracking the given property of a particular source object
	 */
	public static IObservableFactory valueFactory(IValueProperty property) {
		return valueFactory(Realm.getDefault(), property);
	}

	/**
	 * Returns a factory for creating observable values on the given realm
	 * tracking the given property of a particular source object
	 * 
	 * @param realm
	 *            the realm
	 * @param property
	 *            the property to observe
	 * @return a factory for creating observable values on the given realm
	 *         tracking the given property of a particular source object
	 */
	public static IObservableFactory valueFactory(final Realm realm,
			final IValueProperty property) {
		return new IObservableFactory() {
			public IObservable createObservable(Object target) {
				return observeValue(realm, target, property);
			}
		};
	}

	/**
	 * Returns an observable value on the master observable's realm which tracks
	 * the given property of the current value of <code>master</code>.
	 * 
	 * @param master
	 *            the master observable
	 * @param property
	 *            the property to observe
	 * @return an observable value which tracks the given property of the
	 *         current value of <code>master</code>.
	 */
	public static IObservableValue observeDetailValue(IObservableValue master,
			IValueProperty property) {
		return MasterDetailObservables.detailValue(master, valueFactory(master
				.getRealm(), property), property.getValueType());
	}

	/**
	 * Returns an observable set on the default realm that tracks the given
	 * property of the source object
	 * 
	 * @param source
	 *            the property source
	 * @param property
	 *            the property to observe
	 * @return an observable set on the default realm that tracks the given
	 *         property of the source object
	 */
	public static IObservableSet observeSet(Object source, ISetProperty property) {
		return observeSet(Realm.getDefault(), source, property);
	}

	/**
	 * Returns an observable set on the given realm that tracks the given
	 * property of the source object
	 * 
	 * @param realm
	 *            the realm
	 * @param source
	 *            the property source
	 * @param property
	 *            the property to observe
	 * @return an observable set on the given realm that tracks the given
	 *         property of the source object
	 */
	public static IObservableSet observeSet(Realm realm, Object source,
			ISetProperty property) {
		return new PropertyObservableSet(realm, source, property);
	}

	/**
	 * Returns a factory for creating observable sets on the default realm
	 * tracking the given property of a particular source object
	 * 
	 * @param property
	 *            the property to be observed
	 * @return a factory for creating observable sets on the default realm
	 *         tracking the given property of a particular source object
	 */
	public static IObservableFactory setFactory(ISetProperty property) {
		return setFactory(Realm.getDefault(), property);
	}

	/**
	 * Returns a factory for creating obervable sets on the given realm tracking
	 * the given property of a particular source object
	 * 
	 * @param realm
	 *            the realm
	 * @param property
	 *            the property to be observed
	 * @return a factory for creating obervable sets on the given realm tracking
	 *         the given property of a particular source object
	 */
	public static IObservableFactory setFactory(final Realm realm,
			final ISetProperty property) {
		return new IObservableFactory() {
			public IObservable createObservable(Object target) {
				return observeSet(realm, target, property);
			}
		};
	}

	/**
	 * Returns an observable set on the master observable's realm which tracks
	 * the given property of the current value of <code>master</code>.
	 * 
	 * @param master
	 *            the master observable
	 * @param property
	 *            the property to observe
	 * @return an observable set on the given realm which tracks the given
	 *         property of the current value of <code>master</code>.
	 */
	public static IObservableSet observeDetailSet(IObservableValue master,
			ISetProperty property) {
		return MasterDetailObservables.detailSet(master, setFactory(master
				.getRealm(), property), property.getElementType());
	}

	/**
	 * Returns an observable list on the default realm that tracks the given
	 * property of the source object
	 * 
	 * @param source
	 *            the property source
	 * @param property
	 *            the property to observe
	 * @return an observable list on the default realm that tracks the given
	 *         property of the source object
	 */
	public static IObservableList observeList(Object source,
			IListProperty property) {
		return observeList(Realm.getDefault(), source, property);
	}

	/**
	 * Returns an observable list on the given realm that tracks the given
	 * property of the source object
	 * 
	 * @param realm
	 *            the realm
	 * @param source
	 *            the property source
	 * @param property
	 *            the property to observe
	 * @return an observable list on the given realm that tracks the given
	 *         property of the source object
	 */
	public static IObservableList observeList(Realm realm, Object source,
			IListProperty property) {
		return new PropertyObservableList(realm, source, property);
	}

	/**
	 * Returns a factory for creating observable lists on the default realm
	 * tracking the given property of a particular source object
	 * 
	 * @param property
	 *            the property to be observed
	 * @return an observable value factory on
	 */
	public static IObservableFactory listFactory(IListProperty property) {
		return listFactory(Realm.getDefault(), property);
	}

	/**
	 * Returns a factory for creating obervable lists on the given realm
	 * tracking the given property of a particular source object
	 * 
	 * @param realm
	 *            the realm
	 * @param property
	 *            the property to be observed
	 * @return an observable value factory on
	 */
	public static IObservableFactory listFactory(final Realm realm,
			final IListProperty property) {
		return new IObservableFactory() {
			public IObservable createObservable(Object target) {
				return observeList(realm, target, property);
			}
		};
	}

	/**
	 * Returns an observable list on the master observable's realm which tracks
	 * the given property of the current value of <code>master</code>.
	 * 
	 * @param master
	 *            the master observable
	 * @param property
	 *            the property to observe
	 * @return an observable list on the given realm which tracks the given
	 *         property of the current value of <code>master</code>.
	 */
	public static IObservableList observeDetailList(IObservableValue master,
			IListProperty property) {
		return MasterDetailObservables.detailList(master, listFactory(master
				.getRealm(), property), property.getElementType());
	}

	/**
	 * Returns an observable list on the master observable's realm which tracks
	 * the given property of each element of <code>master</code>.
	 * 
	 * @param master
	 *            the master observable
	 * @param property
	 *            the property to observe on each element in the master
	 *            observable
	 * @return an observable
	 */
	public static IObservableList observeDetailValues(IObservableList master,
			IValueProperty property) {
		return new ListValuePropertyObservableList(master, property);
	}

	/**
	 * Returns an observable map on the default realm which tracks the given
	 * property of the source object
	 * 
	 * @param source
	 *            the property source
	 * @param property
	 *            the property to observe
	 * @return an observable map on the default realm which tracks the given
	 *         property of the source object
	 */
	public static IObservableMap observeMap(Object source, IMapProperty property) {
		return observeMap(Realm.getDefault(), source, property);
	}

	/**
	 * Returns an observable map on the given realm which tracks the given
	 * property of the source object
	 * 
	 * @param realm
	 *            the realm
	 * @param source
	 *            the property source
	 * @param property
	 *            the property to observe
	 * @return an observable map on the given realm which tracks the given
	 *         property of the source object
	 */
	public static IObservableMap observeMap(Realm realm, Object source,
			IMapProperty property) {
		return new PropertyObservableMap(realm, source, property);
	}

	/**
	 * Returns an observable map on the master observable's realm tracking the
	 * current values of the given property for the elements in the given set.
	 * 
	 * @param keySet
	 *            the master observable
	 * @param valueProperty
	 *            the property to observe on each element of the master
	 *            observable
	 * @return an observable map that tracks the current value of the given
	 *         property for the elements in the given set.
	 */
	public static IObservableMap observeDetailValues(IObservableSet keySet,
			IValueProperty valueProperty) {
		return new SetValuePropertyObservableMap(keySet, valueProperty);
	}

	/**
	 * Returns an observable map on the master observable's realm which tracks
	 * the current values of the given property for the entry values in the
	 * given map.
	 * 
	 * @param map
	 *            the master observable
	 * @param valueProperty
	 *            the property to observe on each entry value in the master
	 *            observable
	 * @return an observable map on the master observable's realm which tracks
	 *         the current value of the given property for the elements in the
	 *         given map's values collection
	 */
	public static IObservableMap observeDetailValues(IObservableMap map,
			IValueProperty valueProperty) {
		return new MapValuePropertyObservableMap(map, valueProperty);
	}
}




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

import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.property.list.IListProperty;
import org.eclipse.core.databinding.property.list.IListPropertyChangeListener;
import org.eclipse.core.databinding.property.list.ListProperty;
import org.eclipse.core.databinding.property.list.ListPropertyChangeEvent;
import org.eclipse.core.databinding.property.value.IValueProperty;
import org.eclipse.core.databinding.property.value.IValuePropertyChangeListener;
import org.eclipse.core.databinding.property.value.ValuePropertyChangeEvent;

/**
 * @since 3.3
 * 
 */
public class ValuePropertyDetailList extends ListProperty {
	private final IValueProperty masterProperty;
	private final IListProperty detailProperty;

	private Map sourceToDetailListener = new HashMap();

	private IValuePropertyChangeListener masterListener = new MasterPropertyListener();

	private class MasterPropertyListener implements
			IValuePropertyChangeListener {
		public void handleValuePropertyChange(ValuePropertyChangeEvent event) {
			Object oldSource = event.diff.getOldValue();
			Object newSource = event.diff.getNewValue();

			List oldList = detailProperty.getList(oldSource);
			List newList = detailProperty.getList(newSource);

			Object source = event.getSource();

			removeDetailPropertyListener(source);
			addDetailPropertyListener(source);

			fireListChange(source, Diffs.computeListDiff(oldList, newList));
		}
	}

	private class DetailPropertyListener implements IListPropertyChangeListener {
		private Object source;
		private Object masterValue;

		DetailPropertyListener(Object source, Object masterValue) {
			this.source = source;
			this.masterValue = masterValue;
		}

		public void handleListPropertyChange(ListPropertyChangeEvent event) {
			fireListChange(source, event.diff);
		}
	}

	/**
	 * @param masterProperty
	 * @param detailProperty
	 */
	public ValuePropertyDetailList(IValueProperty masterProperty,
			IListProperty detailProperty) {
		this.masterProperty = masterProperty;
		this.detailProperty = detailProperty;
	}

	protected void addListenerTo(Object source) {
		masterProperty.addValueChangeListener(source, masterListener);
		addDetailPropertyListener(source);
	}

	protected void removeListenerFrom(Object source) {
		masterProperty.removeValueChangeListener(source, masterListener);
		removeDetailPropertyListener(source);
	}

	private void addDetailPropertyListener(Object source) {
		Object masterValue = masterProperty.getValue(source);
		DetailPropertyListener detailListener = new DetailPropertyListener(
				source, masterValue);
		detailProperty.addListChangeListener(masterValue, detailListener);
		sourceToDetailListener.put(source, detailListener);
	}

	private void removeDetailPropertyListener(Object source) {
		DetailPropertyListener detailListener = (DetailPropertyListener) sourceToDetailListener
				.remove(source);
		if (detailListener != null) {
			detailProperty.removeListChangeListener(detailListener.masterValue,
					detailListener);
		}
		sourceToDetailListener.remove(source);
	}

	public List getList(Object source) {
		Object masterValue = masterProperty.getValue(source);
		return detailProperty.getList(masterValue);
	}

	public boolean add(Object source, Object o) {
		Object masterValue = masterProperty.getValue(source);
		return detailProperty.add(masterValue, o);
	}

	public boolean addAll(Object source, Collection c) {
		Object masterValue = masterProperty.getValue(source);
		return detailProperty.addAll(masterValue, c);
	}

	public void clear(Object source) {
		Object masterValue = masterProperty.getValue(source);
		detailProperty.clear(masterValue);
	}

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

	public boolean remove(Object source, Object o) {
		Object masterValue = masterProperty.getValue(source);
		return detailProperty.remove(masterValue, o);
	}

	public boolean removeAll(Object source, Collection c) {
		Object masterValue = masterProperty.getValue(source);
		return detailProperty.removeAll(masterValue, c);
	}

	public boolean retainAll(Object source, Collection c) {
		Object masterValue = masterProperty.getValue(source);
		return detailProperty.retainAll(masterValue, c);
	}

	public void add(Object source, int index, Object element) {
		Object masterValue = masterProperty.getValue(source);
		detailProperty.add(masterValue, index, element);
	}

	public boolean addAll(Object source, int index, Collection c) {
		Object masterValue = masterProperty.getValue(source);
		return detailProperty.addAll(masterValue, index, c);
	}

	public Object move(Object source, int oldIndex, int newIndex) {
		Object masterValue = masterProperty.getValue(source);
		return detailProperty.move(masterValue, oldIndex, newIndex);
	}

	public Object remove(Object source, int index) {
		Object masterValue = masterProperty.getValue(source);
		return detailProperty.remove(masterValue, index);
	}

	public Object set(Object source, int index, Object element) {
		Object masterValue = masterProperty.getValue(source);
		return detailProperty.set(masterValue, index, element);
	}
}




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

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.list.ListDiff;
import org.eclipse.core.databinding.observable.list.ListDiffEntry;
import org.eclipse.core.databinding.property.list.IListProperty;
import org.eclipse.core.databinding.property.list.IListPropertyChangeListener;
import org.eclipse.core.databinding.property.list.ListProperty;
import org.eclipse.core.databinding.property.list.ListPropertyChangeEvent;
import org.eclipse.core.databinding.property.value.IValueProperty;
import org.eclipse.core.databinding.property.value.IValuePropertyChangeListener;
import org.eclipse.core.databinding.property.value.ValuePropertyChangeEvent;
import org.eclipse.core.internal.databinding.Util;

/**
 * @since 3.3
 * 
 */
public class ListPropertyDetailValueList extends ListProperty {
	private final IListProperty masterProperty;
	private final IValueProperty detailProperty;

	private Map sourceToMasterElementToDetailListener = new HashMap();

	private IListPropertyChangeListener masterListener = new MasterPropertyListener();

	private class MasterPropertyListener implements IListPropertyChangeListener {
		public void handleListPropertyChange(ListPropertyChangeEvent event) {
			Object source = event.getSource();
			ListDiffEntry[] masterEntries = event.diff.getDifferences();
			ListDiffEntry[] detailEntries = new ListDiffEntry[masterEntries.length];
			Set masterElementsAdded = new HashSet();
			Set masterElementsRemoved = new HashSet();
			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);
				if (addition)
					masterElementsAdded.add(masterElement);
				else
					masterElementsRemoved.add(masterElement);
			}

			ListDiff diff = Diffs.createListDiff(detailEntries);

			for (Iterator it = masterElementsRemoved.iterator(); it.hasNext();) {
				Object element = it.next();
				if (!masterProperty.contains(source, element))
					removeElementPropertyListener(source, element);
			}
			for (Iterator it = masterElementsAdded.iterator(); it.hasNext();) {
				Object element = it.next();
				if (masterProperty.contains(source, element))
					addElementPropertyListener(source, element);
			}

			fireListChange(source, diff);
		}

		private void addElementPropertyListener(Object source, Object element) {
			Map elementToDetailListener = (Map) sourceToMasterElementToDetailListener
					.get(source);
			if (elementToDetailListener == null) {
				sourceToMasterElementToDetailListener.put(source,
						elementToDetailListener = new HashMap());
			}
			if (!elementToDetailListener.containsKey(element)) {
				DetailPropertyListener detailListener = new DetailPropertyListener(
						source, element);
				detailProperty.addValueChangeListener(element, detailListener);
				elementToDetailListener.put(element, detailListener);
			}
		}

		private void removeElementPropertyListener(Object source, Object element) {
			Map elementToDetailListener = (Map) sourceToMasterElementToDetailListener
					.get(source);
			if (elementToDetailListener != null
					&& elementToDetailListener.containsKey(element)) {
				DetailPropertyListener detailListener = (DetailPropertyListener) elementToDetailListener
						.remove(element);
				detailProperty.removeValueChangeListener(element,
						detailListener);
			}
		}
	}

	private class DetailPropertyListener implements
			IValuePropertyChangeListener {
		private Object source;
		private Object masterElement;

		DetailPropertyListener(Object source, Object masterElement) {
			this.source = source;
			this.masterElement = masterElement;
		}

		private int[] findIndices() {
			List indices = new ArrayList();

			List list = masterProperty.getList(source);
			for (ListIterator it = list.listIterator(); it.hasNext();) {
				if (Util.equals(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;
		}

		public void handleValuePropertyChange(ValuePropertyChangeEvent event) {
			int[] indices = findIndices();
			Object oldValue = event.diff.getOldValue();
			Object newValue = event.diff.getNewValue();
			ListDiffEntry[] entries = new ListDiffEntry[indices.length * 2];
			for (int i = 0; i < indices.length; i++) {
				int index = indices[i];
				entries[i * 2] = Diffs.createListDiffEntry(index, false,
						oldValue);
				entries[i * 2 + 1] = Diffs.createListDiffEntry(index, true,
						newValue);
			}

			ListDiff diff = Diffs.createListDiff(entries);
			fireListChange(source, diff);
		}
	}

	/**
	 * @param masterProperty
	 * @param detailProperty
	 */
	public ListPropertyDetailValueList(IListProperty masterProperty,
			IValueProperty detailProperty) {
		this.masterProperty = masterProperty;
		this.detailProperty = detailProperty;
	}

	protected void addListenerTo(Object source) {
		masterProperty.addListChangeListener(source, masterListener);

		Map masterElementToDetailListener = new HashMap();
		for (Iterator it = masterProperty.getList(source).iterator(); it
				.hasNext();) {
			Object masterElement = it.next();
			DetailPropertyListener detailListener = new DetailPropertyListener(
					source, masterElement);
			detailProperty
					.addValueChangeListener(masterElement, detailListener);
			masterElementToDetailListener.put(masterElement, detailListener);
		}

		sourceToMasterElementToDetailListener.put(source,
				masterElementToDetailListener);
	}

	protected void removeListenerFrom(Object source) {
		masterProperty.removeListChangeListener(source, masterListener);
		Map masterElementToDetailListener = (Map) sourceToMasterElementToDetailListener
				.remove(source);
		if (masterElementToDetailListener != null) {
			for (Iterator it = masterElementToDetailListener.entrySet()
					.iterator(); it.hasNext();) {
				Map.Entry entry = (Map.Entry) it.next();
				detailProperty.removeValueChangeListener(entry.getKey(),
						(DetailPropertyListener) entry.getValue());
			}
		}
	}

	public List getList(Object source) {
		List result = new ArrayList();
		for (Iterator it = masterProperty.getList(source).iterator(); it
				.hasNext();) {
			result.add(detailProperty.getValue(it.next()));
		}
		return result;
	}

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

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

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

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

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

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

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

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

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

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

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

	public Object set(Object source, int index, Object element) {
		Object masterElement = masterProperty.get(source, index);
		Object result = detailProperty.getValue(masterElement);
		detailProperty.setValue(masterElement, element);
		return result;
	}
}




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

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

import org.eclipse.core.internal.databinding.IdentityWrapper;

/**
 * @since 3.3
 * 
 */
public class PropertyCache {
	private Map map;

	private Map getMap() {
		if (map == null)
			map = new HashMap();
		return map;
	}

	/**
	 * @param source
	 * @param property
	 */
	public synchronized void put(Object source, Object property) {
		getMap().put(new IdentityWrapper(source), property);
	}

	/**
	 * @param source
	 * @return the cached property
	 */
	public synchronized Object get(Object source) {
		return map == null ? null : map.get(new IdentityWrapper(source));
	}

	/**
	 * @param source
	 */
	public synchronized void remove(Object source) {
		if (map != null)
			map.remove(new IdentityWrapper(source));
	}

	/**
	 * 
	 */
	public void dispose() {
		if (map != null) {
			map.clear();
			map = 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.list;

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

/**
 * Listener for changes to list properties on a property source
 * 
 * @since 1.2
 */
public interface IListPropertyChangeListener extends IPropertyChangeListener {
	/**
	 * Handle a change to a list property on a specific property source.
	 * 
	 * @param event
	 *            an event describing the list change that occured.
	 */
	public void handleListPropertyChange(ListPropertyChangeEvent 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.internal.databinding.observable.masterdetail;

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.IObserving;
import org.eclipse.core.databinding.observable.ObservableTracker;
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.value.IValueProperty;
import org.eclipse.core.databinding.property.value.IValuePropertyChangeListener;
import org.eclipse.core.databinding.property.value.ValuePropertyChangeEvent;
import org.eclipse.core.internal.databinding.Util;

/**
 * @since 3.3
 * 
 */
public class ListValuePropertyObservableList extends AbstractObservableList
		implements IObserving {
	private IObservableList masterList;
	private IValueProperty detailProperty;

	private IObservableSet knownMasterElements;

	private boolean disposed = false;

	private IListChangeListener masterListener = new IListChangeListener() {
		public void handleListChange(ListChangeEvent event) {
			ListDiffEntry[] masterEntries = event.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);
			}

			// Removes listeners from elements removed from list
			knownMasterElements.retainAll(masterList);

			// Adds listeners to elements added to list
			knownMasterElements.addAll(masterList);

			fireListChange(Diffs.createListDiff(detailEntries));
		}
	};

	private IValuePropertyChangeListener detailListener = new IValuePropertyChangeListener() {
		public void handleValuePropertyChange(
				final ValuePropertyChangeEvent event) {
			if (!disposed) {
				Object source = event.getSource();
				int[] indices = findIndices(source);
				Object oldValue = event.diff.getOldValue();
				Object newValue = event.diff.getNewValue();
				ListDiffEntry[] entries = new ListDiffEntry[indices.length * 2];
				for (int i = 0; i < indices.length; i++) {
					int index = indices[i];
					entries[i * 2] = Diffs.createListDiffEntry(index, false,
							oldValue);
					entries[i * 2 + 1] = Diffs.createListDiffEntry(index, true,
							newValue);
				}

				ListDiff diff = Diffs.createListDiff(entries);
				fireListChange(diff);
			}
		}

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

			for (ListIterator it = masterList.listIterator(); it.hasNext();) {
				if (Util.equals(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;
		}
	};

	/**
	 * @param masterList
	 * @param valueProperty
	 */
	public ListValuePropertyObservableList(IObservableList masterList,
			IValueProperty valueProperty) {
		super(masterList.getRealm());
		this.masterList = masterList;
		this.detailProperty = valueProperty;
	}

	protected void firstListenerAdded() {
		knownMasterElements = new WritableSet(getRealm());
		knownMasterElements.addSetChangeListener(new ISetChangeListener() {
			public void handleSetChange(SetChangeEvent event) {
				for (Iterator it = event.diff.getRemovals().iterator(); it
						.hasNext();) {
					detailProperty.addValueChangeListener(it.next(),
							detailListener);
				}
				for (Iterator it = event.diff.getAdditions().iterator(); it
						.hasNext();) {
					detailProperty.removeValueChangeListener(it.next(),
							detailListener);
				}
			}
		});
		knownMasterElements.addAll(masterList);
		masterList.addListChangeListener(masterListener);
	}

	protected void lastListenerRemoved() {
		masterList.removeListChangeListener(masterListener);
		if (knownMasterElements != null) {
			knownMasterElements.clear();
			knownMasterElements.dispose();
			knownMasterElements = 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();

		Iterator it;
		if (knownMasterElements != null)
			it = knownMasterElements.iterator();
		else
			it = masterList.iterator();
		for (; 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 lastReturned;
			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();
				Object result = lastReturned = detailProperty.getValue(it
						.next());
				haveIterated = true;
				return result;
			}

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

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

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

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

			public void set(Object o) {
				checkRealm();
				if (!haveIterated)
					throw new IllegalStateException();
				// if listeners are registered, the value property listener will
				// cause the list change event to fire. otherwise it doesn't
				// matter because noone is listening
				detailProperty.setValue(lastReturned, o);
			}
		};
	}

	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);
		detailProperty.setValue(masterElement, o);
		return oldValue;
	}

	public Object getObserved() {
		return masterList;
	}

	public synchronized void dispose() {
		if (masterList != null) {
			masterList.removeListChangeListener(masterListener);
			masterList = null;
			masterListener = null;
		}
		if (knownMasterElements != null) {
			knownMasterElements.clear();
			knownMasterElements.dispose();
			knownMasterElements = null;
			detailListener = null;
		}
		detailProperty = null;
		disposed = true;

		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;

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

import org.eclipse.core.internal.databinding.IdentityWrapper;

/**
 * @since 3.3
 * 
 */
public class PropertyUpdateHelper {
	private ThreadLocal localMap = new ThreadLocal() {
		protected Object initialValue() {
			return new HashMap();
		}
	};

	/**
	 * @param source
	 * @return blah
	 */
	public boolean isUpdating(Object source) {
		Map map = (Map) localMap.get();
		return map.containsKey(new IdentityWrapper(source));
	}

	/**
	 * @param source
	 * @param state
	 */
	public void setUpdating(Object source, boolean state) {
		Map map = (Map) localMap.get();
		IdentityWrapper identityWrapper = new IdentityWrapper(source);
		Integer count = (Integer) map.get(identityWrapper);
		int newCount = (count == null ? 0 : count.intValue())
				+ (state ? 1 : -1);
		if (newCount > 0)
			map.put(identityWrapper, new Integer(newCount));
		else
			map.remove(identityWrapper);
	}

	/**
	 * 
	 */
	public void dispose() {
		if (localMap != null) {
			Map map = (Map) localMap.get();
			if (map != null) {
				map.clear();
				localMap.set(null);
			}
			localMap = 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;

/**
 * Marker interface for all listener types in the properties framework.
 * 
 * @noimplement This interface is not intended to be implemented by clients.
 * 
 * @since 1.2
 */
public interface IPropertyChangeListener {

}




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

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

import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.observable.map.MapDiff;
import org.eclipse.core.databinding.property.SimpleProperty;
import org.eclipse.core.internal.databinding.Util;

/**
 * Abstract map property implementation for properties where the map can be
 * completely replaced in a single atomic operation.
 * <p>
 * For example, a map-typed bean property Customer.phoneNumbers can be modified
 * by calling Customer.setPhoneNumbers(Map phoneNumbers).
 * 
 * @since 1.2
 */
public abstract class SimpleMapProperty extends SimpleProperty implements
		IMapProperty {
	public final void addMapChangeListener(Object source,
			IMapPropertyChangeListener listener) {
		addPropertyChangeListener(source, listener);
	}

	public final void removeMapChangeListener(Object source,
			IMapPropertyChangeListener listener) {
		removePropertyChangeListener(source, listener);
	}

	protected final Object getProperty(Object source) {
		return getMap(source);
	}

	public boolean containsKey(Object source, Object key) {
		return getMap(source).containsKey(key);
	}

	public boolean containsValue(Object source, Object value) {
		return getMap(source).containsValue(value);
	}

	public boolean equals(Object source, Object o) {
		return getMap(source).equals(o);
	}

	public Object get(Object source, Object key) {
		return getMap(source).get(key);
	}

	public int hashCode(Object source) {
		return getMap(source).hashCode();
	}

	public boolean isEmpty(Object source) {
		return getMap(source).isEmpty();
	}

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

	private void updateMapAndFireChange(Object source, Map map, MapDiff diff) {
		setUpdating(source, true);
		try {
			updateMap(source, map, diff);
		} finally {
			setUpdating(source, false);
		}

		if (hasListeners(source)) {
			fireMapChange(source, diff);
		}
	}

	/**
	 * Updates the property on the source with the specified change. A map
	 * change event is fired in the calling method, so implementers do not need
	 * to call {@link #fireMapChange(Object, MapDiff)}.
	 * 
	 * @param source
	 *            the property source
	 * @param map
	 *            the new map
	 * @param diff
	 *            a diff describing the change
	 */
	protected abstract void updateMap(Object source, Map map, MapDiff diff);

	/**
	 * Notifies that the source's property changed. Listeners registered in the
	 * {@link #addListenerTo(Object)} method should call this method when a
	 * property change is observed on the source object.
	 * 
	 * @param source
	 *            the property source
	 * @param diff
	 *            a diff describing the map change. If null, a diff will be
	 *            computed from the cached state and the current state.
	 */
	protected final void fireMapChange(Object source, MapDiff diff) {
		if (!isUpdating(source) && hasListeners(source)) {
			if (diff == null) {
				diff = Diffs.computeMapDiff((Map) getCached(source),
						getMap(source));
			}
			if (!diff.isEmpty()) {
				firePropertyChange(new MapPropertyChangeEvent(source, this,
						diff));
			}
		}
	}

	public void clear(Object source) {
		if (!isEmpty(source)) {
			updateMapAndFireChange(source, new HashMap(), Diffs
					.createMapDiffRemoveAll(new HashMap(getMap(source))));
		}
	}

	public Object put(Object source, Object key, Object value) {
		Map map = new HashMap(getMap(source));
		boolean addition = !map.containsKey(key);
		Object result = map.put(key, value);
		MapDiff diff;
		if (addition) {
			diff = Diffs.createMapDiffSingleAdd(key, value);
		} else {
			diff = Diffs.createMapDiffSingleChange(key, result, value);
		}
		updateMapAndFireChange(source, map, diff);
		return result;
	}

	public void putAll(Object source, Map t) {
		if (t.isEmpty())
			return;

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

	public Object remove(Object source, Object key) {
		Map map = getMap(source);
		if (map.containsKey(key)) {
			map = new HashMap(map);
			Object result = map.remove(key);
			updateMapAndFireChange(source, map, Diffs
					.createMapDiffSingleRemove(key, result));
			return result;
		}
		return 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.set;

import java.util.Set;

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

/**
 * Interface for set-typed properties
 * 
 * @since 1.2
 * @noimplement This interface is not intended to be implemented by clients.
 */
public interface ISetProperty extends ICollectionProperty {
	/**
	 * 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
	 */
	public Set getSet(Object source);

	/**
	 * Adds the given set property change listener to the list of listeners for
	 * the given source.
	 * 
	 * @param source
	 *            the property source
	 * @param listener
	 *            the listener
	 */
	public void addSetChangeListener(Object source,
			ISetPropertyChangeListener listener);

	/**
	 * Removes the given set property change listener from the list of listeners
	 * for the given source.
	 * 
	 * @param source
	 *            the property source
	 * @param listener
	 *            the listener
	 */
	public void removeSetChangeListener(Object source,
			ISetPropertyChangeListener listener);
}




/*******************************************************************************
 * 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 org.eclipse.core.databinding.observable.list.ListDiff;
import org.eclipse.core.databinding.property.IPropertyChangeListener;
import org.eclipse.core.databinding.property.PropertyChangeEvent;
import org.eclipse.core.runtime.Assert;

/**
 * List change event describing an incremental change of a list property on a
 * particular property source.
 * 
 * @since 1.2
 */
public class ListPropertyChangeEvent extends PropertyChangeEvent {
	private static final long serialVersionUID = 1L;

	/**
	 * The list property that changed
	 */
	public final IListProperty property;

	/**
	 * ListDiff enumerating the added and removed elements in the list.
	 */
	public final ListDiff diff;

	/**
	 * Constructs a ListPropertyChangeEvent with the given attributes
	 * 
	 * @param source
	 *            the property source
	 * @param property
	 *            the property that changed on the source
	 * @param diff
	 *            a ListDiff describing the changes to the list property
	 */
	public ListPropertyChangeEvent(Object source, IListProperty property,
			ListDiff diff) {
		super(source);
		this.property = property;
		Assert.isNotNull(diff, "diff cannot be null"); //$NON-NLS-1$
		this.diff = diff;
	}

	protected void dispatch(IPropertyChangeListener listener) {
		((IListPropertyChangeListener) listener).handleListPropertyChange(this);
	}
}




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

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

import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.set.AbstractObservableSet;
import org.eclipse.core.databinding.property.IProperty;
import org.eclipse.core.databinding.property.IPropertyObservable;
import org.eclipse.core.databinding.property.set.ISetProperty;
import org.eclipse.core.databinding.property.set.ISetPropertyChangeListener;
import org.eclipse.core.databinding.property.set.SetPropertyChangeEvent;

/**
 * @since 3.3
 * 
 */
public class PropertyObservableSet extends AbstractObservableSet implements
		IPropertyObservable {
	private Object source;
	private ISetProperty property;

	private boolean updating = false;

	private boolean disposed = false;

	private transient volatile int modCount = 0;

	private ISetPropertyChangeListener listener = new ISetPropertyChangeListener() {
		public void handleSetPropertyChange(final SetPropertyChangeEvent event) {
			if (!disposed && !updating) {
				getRealm().exec(new Runnable() {
					public void run() {
						getRealm().exec(new Runnable() {
							public void run() {
								modCount++;
								fireSetChange(event.diff);
							}
						});
					}
				});
			}
		}
	};

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

	protected void firstListenerAdded() {
		if (!disposed) {
			property.addSetChangeListener(source, listener);
		}
	}

	protected void lastListenerRemoved() {
		if (!disposed) {
			property.removeSetChangeListener(source, listener);
		}
	}

	protected Set getWrappedSet() {
		return property.getSet(source);
	}

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

	// Queries

	protected int doGetSize() {
		return property.size(source);
	}

	// Single change operations

	public boolean add(Object o) {
		checkRealm();
		return property.add(source, o);
	}

	public Iterator iterator() {
		getterCalled();
		return new Iterator() {
			int expectedModCount = modCount;
			Iterator delegate = new HashSet(property.getSet(source)).iterator();
			Object last = null;

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

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

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

				delegate.remove(); // stay in sync

				property.remove(source, last);

				last = null;
				expectedModCount = modCount;
			}

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

	public boolean remove(Object o) {
		getterCalled();
		return property.remove(source, o);
	}

	// Bulk change operations

	public boolean addAll(Collection c) {
		getterCalled();
		return property.addAll(source, c);
	}

	public boolean removeAll(Collection c) {
		getterCalled();
		return property.removeAll(source, c);
	}

	public boolean retainAll(Collection c) {
		getterCalled();
		return property.retainAll(source, c);
	}

	public void clear() {
		getterCalled();
		property.clear(source);
	}

	public boolean equals(Object o) {
		return property.equals(source, o);
	}

	public int hashCode() {
		return property.hashCode(source);
	}

	public Object getObserved() {
		return source;
	}

	public IProperty getProperty() {
		return property;
	}

	public synchronized void dispose() {
		if (!disposed) {
			disposed = true;
			property.removeSetChangeListener(source, listener);
			property = null;
			source = 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.map;

import org.eclipse.core.databinding.observable.map.MapDiff;
import org.eclipse.core.databinding.property.IPropertyChangeListener;
import org.eclipse.core.databinding.property.PropertyChangeEvent;
import org.eclipse.core.runtime.Assert;

/**
 * Map change event describing an incremental change of a map property on a
 * particular property source.
 * 
 * @since 1.2
 */
public class MapPropertyChangeEvent extends PropertyChangeEvent {
	private static final long serialVersionUID = 1L;

	/**
	 * The map property that changed
	 */
	public final IMapProperty property;

	/**
	 * MapDiff enumerating the added, changed, and removed entries in the map.
	 */
	public final MapDiff diff;

	/**
	 * Constructs a MapPropertyChangeEvent with the given attributes
	 * 
	 * @param source
	 *            the property source
	 * @param property
	 *            the property that changed on the source
	 * @param diff
	 *            a MapDiff describing the changes to the map property
	 */
	public MapPropertyChangeEvent(Object source, IMapProperty property,
			MapDiff diff) {
		super(source);
		this.property = property;
		Assert.isNotNull(diff, "diff cannot be null"); //$NON-NLS-1$
		this.diff = diff;
	}

	protected void dispatch(IPropertyChangeListener listener) {
		((IMapPropertyChangeListener) listener).handleMapPropertyChange(this);
	}
}




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

/**
 * Abstract implementation of IProperty
 * 
 * @since 1.2
 */
public abstract class Property implements IProperty {
	private PropertyChangeSupport changeSupport;

	private boolean disposed;

	private synchronized PropertyChangeSupport getChangeSupport() {
		if (changeSupport == null) {
			changeSupport = new PropertyChangeSupport() {
				protected void addListenerTo(Object source) {
					Property.this.addListenerTo(source);
				}

				protected void removeListenerFrom(Object source) {
					Property.this.removeListenerFrom(source);
				}
			};
		}
		return changeSupport;
	}

	/**
	 * Adds the listener to the list of listeners for the specified property
	 * source.
	 * 
	 * @param source
	 *            the property source
	 * @param listener
	 *            the listener to add
	 */
	protected final synchronized void addPropertyChangeListener(Object source,
			IPropertyChangeListener listener) {
		if (!isDisposed()) {
			getChangeSupport().addListener(source, listener);
		}
	}

	/**
	 * Removes the listener from the list of listeners for the specified
	 * property source.
	 * 
	 * @param source
	 *            the property source
	 * @param listener
	 *            the listener to remove
	 */
	protected final synchronized void removePropertyChangeListener(
			Object source, IPropertyChangeListener listener) {
		if (changeSupport != null) {
			changeSupport.removeListener(source, listener);
		}
	}

	/**
	 * Returns whether this property has listeners registered for the given
	 * property source
	 * 
	 * @param source
	 *            the property source
	 * @return whether this property has listeners registered for the given
	 *         property source
	 */
	protected final boolean hasListeners(Object source) {
		PropertyChangeSupport changeSupport = this.changeSupport;
		return changeSupport != null && changeSupport.hasListeners(source);
	}

	/**
	 * Fires a property change notification for all listeners registered on the
	 * property source indicated by the event object
	 * 
	 * @param event
	 *            the property change event
	 */
	protected void firePropertyChange(PropertyChangeEvent event) {
		PropertyChangeSupport changeSupport = this.changeSupport;
		if (changeSupport != null
				&& changeSupport.hasListeners(event.getSource())) {
			changeSupport.firePropertyChange(event);
		}
	}

	/**
	 * Adds a listener on the given property source for changes to the property.
	 * The listener should fire a property change event whenever the a property
	 * change is observed. This method is called when the first property change
	 * listener is added for the given source object.
	 * <p>
	 * This method does nothing if the source object has no listener support for
	 * the property.
	 * 
	 * @param source
	 *            the source object to observe for property changes.
	 * @see #removeListenerFrom(Object)
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected abstract void addListenerTo(Object source);

	/**
	 * Remove the listeners previous added on the property source for changes to
	 * the property. This method is called when the last property change
	 * listener is removed for the given source object.
	 * <p>
	 * This method does nothing if the source object has no listener support for
	 * the property.
	 * 
	 * @param source
	 *            the source object to stop observing for property changes.
	 * @see #addListenerTo(Object)
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected abstract void removeListenerFrom(Object source);

	public boolean isDisposed() {
		return disposed;
	}

	public synchronized void dispose() {
		if (!disposed) {
			if (changeSupport != null) {
				changeSupport.dispose();
				changeSupport = null;
			}
			disposed = true;
		}
	}
}




/*******************************************************************************
 * 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.tests.databinding.property;

import org.eclipse.core.databinding.property.IPropertyChangeListener;
import org.eclipse.core.databinding.property.Property;
import org.eclipse.core.databinding.property.PropertyChangeEvent;

import junit.framework.TestCase;

/**
 * @since 3.2
 * 
 */
public class PropertyTest extends TestCase {
	private Source source;
	private SourceProperty property;
	private ChangeListener listener;

	protected void setUp() throws Exception {
		source = new Source();
		property = new SourceProperty();
		listener = new ChangeListener();
	}

	public void testAddListenerTo() {
		assertFalse(source.hasListener());
		property.addChangeListener(source, listener);
		assertTrue(source.hasListener());

		assertEquals(0, listener.count);

		source.change();

		assertEquals(1, listener.count);
		assertEquals(new ChangeEvent(source, "Version 1"), listener.event);
	}

	public void testAddListenerTo_MultipleListeners() {
		assertFalse(source.hasListener());

		property.addChangeListener(source, listener);

		assertTrue(source.hasListener());

		ChangeListener listener2 = new ChangeListener();
		property.addChangeListener(source, listener2);

		assertTrue(source.hasListener());

		property.removeChangeListener(source, listener);

		assertTrue(source.hasListener());

		property.removeChangeListener(source, listener2);

		assertFalse(source.hasListener());
	}

	public void testRemoveListenerFrom() {
		property.addChangeListener(source, listener);
		assertTrue(source.hasListener());
		property.removeChangeListener(source, listener);
		assertFalse(source.hasListener());

		source.change();

		assertEquals(0, listener.count);
	}

	public void testIsDisposed() {
		assertFalse(property.isDisposed());
		property.dispose();
		assertTrue(property.isDisposed());
	}

	public void testDispose() {
		property.addChangeListener(source, listener);
		assertTrue(source.hasListener());
		property.dispose();
		assertFalse(source.hasListener());
	}

	static class Source {
		private int version = 0;

		private ISourceListener listener;

		void change() {
			++version;
			if (listener != null)
				listener.notify(this, "Version " + version);
		}

		boolean hasListener() {
			return listener != null;
		}
	}

	interface ISourceListener {
		void notify(Object source, String message);
	}

	static class SourceProperty extends Property {
		private ISourceListener listener = new ISourceListener() {
			public void notify(Object source, String message) {
				firePropertyChange(new ChangeEvent(source, message));
			}
		};

		public void addChangeListener(Object source, IChangeListener listener) {
			addPropertyChangeListener(source, listener);
		}

		public void removeChangeListener(Object source, IChangeListener listener) {
			removePropertyChangeListener(source, listener);
		}

		protected void addListenerTo(Object source) {
			((Source) source).listener = listener;
		}

		protected void removeListenerFrom(Object source) {
			((Source) source).listener = null;
		}

		void change(Object source) {
			((Source) source).change();
		}
	}

	static interface IChangeListener extends IPropertyChangeListener {
		void handlePropertyStubChange(ChangeEvent event);
	}

	static class ChangeListener implements IChangeListener {
		int count = 0;
		ChangeEvent event;

		public void handlePropertyStubChange(ChangeEvent event) {
			count++;
			this.event = event;
		}
	}

	static class ChangeEvent extends PropertyChangeEvent {
		private static final long serialVersionUID = 1L;

		final String message;

		ChangeEvent(Object source, String message) {
			super(source);
			this.message = message;
		}

		protected void dispatch(IPropertyChangeListener listener) {
			((IChangeListener) listener).handlePropertyStubChange(this);
		}

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

			ChangeEvent that = (ChangeEvent) obj;
			return message.equals(that.message);
		}

		public int hashCode() {
			int hash = super.hashCode();
			hash = hash * 37 + message.hashCode();
			return hash;
		}
	}
}

Return to bug 194734

Lines 14-19 Link Here

(-)META-INF/MANIFEST.MF (+6 lines)
14	org.eclipse.core.databinding.observable.masterdetail,	14	org.eclipse.core.databinding.observable.masterdetail,
15	org.eclipse.core.databinding.observable.set;x-internal:=false,	15	org.eclipse.core.databinding.observable.set;x-internal:=false,
16	org.eclipse.core.databinding.observable.value;x-internal:=false,	16	org.eclipse.core.databinding.observable.value;x-internal:=false,
		17	org.eclipse.core.databinding.property,
		18	org.eclipse.core.databinding.property.list,
		19	org.eclipse.core.databinding.property.map,
		20	org.eclipse.core.databinding.property.set,
		21	org.eclipse.core.databinding.property.value,
17	org.eclipse.core.databinding.util,	22	org.eclipse.core.databinding.util,
18	org.eclipse.core.databinding.validation;x-internal:=false,	23	org.eclipse.core.databinding.validation;x-internal:=false,
19	org.eclipse.core.internal.databinding;x-friends:="org.eclipse.core.databinding.beans",	24	org.eclipse.core.internal.databinding;x-friends:="org.eclipse.core.databinding.beans",
Lines 21-26 Link Here
21	org.eclipse.core.internal.databinding.observable;x-internal:=true,	26	org.eclipse.core.internal.databinding.observable;x-internal:=true,
22	org.eclipse.core.internal.databinding.observable.masterdetail;x-friends:="org.eclipse.jface.tests.databinding",	27	org.eclipse.core.internal.databinding.observable.masterdetail;x-friends:="org.eclipse.jface.tests.databinding",
23	org.eclipse.core.internal.databinding.observable.tree;x-friends:="org.eclipse.jface.databinding,org.eclipse.jface.tests.databinding",	28	org.eclipse.core.internal.databinding.observable.tree;x-friends:="org.eclipse.jface.databinding,org.eclipse.jface.tests.databinding",
		29	org.eclipse.core.internal.databinding.property;x-friends:="org.eclipse.jface.databinding,org.eclipse.jface.tests.databinding",
24	org.eclipse.core.internal.databinding.validation;x-friends:="org.eclipse.jface.tests.databinding"	30	org.eclipse.core.internal.databinding.validation;x-friends:="org.eclipse.jface.tests.databinding"
25	Require-Bundle: org.eclipse.equinox.common;bundle-version="[3.2.0,4.0.0)"	31	Require-Bundle: org.eclipse.equinox.common;bundle-version="[3.2.0,4.0.0)"
26	Import-Package-Comment: see http://wiki.eclipse.org/	32	Import-Package-Comment: see http://wiki.eclipse.org/

Added Link Here

(-)src/org/eclipse/core/databinding/property/value/IValueProperty.java (+73 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.value;
13
14	import org.eclipse.core.databinding.property.IProperty;
15
16
17	/**
18	* Interface for value-typed properties
19	*
20	* @since 1.2
21	* @noimplement This interface is not intended to be implemented by clients.
22	*/
23	public interface IValueProperty extends IProperty {
24	/**
25	* Returns the source's value property
26	*
27	* @param source
28	* the property source
29	* @return the current value of the source's value property
30	*/
31	public Object getValue(Object source);
32
33	/**
34	* Sets the source's value property to the specified value
35	*
36	* @param source
37	* the property source
38	* @param value
39	* the new value
40	*/
41	public void setValue(Object source, Object value);
42
43	/**
44	* Returns the value type of the property, or <code>null</code> if untyped.
45	*
46	* @return the value type of the property, or <code>null</code> if untyped.
47	*/
48	public Object getValueType();
49
50	/**
51	* Adds the given value property change listener to the list of listeners
52	* for the given source.
53	*
54	* @param source
55	* the property source
56	* @param listener
57	* the listener
58	*/
59	public void addValueChangeListener(Object source,
60	IValuePropertyChangeListener listener);
61
62	/**
63	* Removes the given list property change listener from the list of
64	* listeners for the given source.
65	*
66	* @param source
67	* the property source
68	* @param listener
69	* the listener
70	*/
71	public void removeValueChangeListener(Object source,
72	IValuePropertyChangeListener listener);
73	}

Added Link Here

(-)src/org/eclipse/core/internal/databinding/observable/PropertyObservableMap.java (+177 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.internal.databinding.observable;
13
14	import java.util.Collection;
15	import java.util.Collections;
16	import java.util.Map;
17	import java.util.Set;
18
19	import org.eclipse.core.databinding.observable.ObservableTracker;
20	import org.eclipse.core.databinding.observable.Realm;
21	import org.eclipse.core.databinding.observable.map.AbstractObservableMap;
22	import org.eclipse.core.databinding.property.IProperty;
23	import org.eclipse.core.databinding.property.IPropertyObservable;
24	import org.eclipse.core.databinding.property.map.IMapProperty;
25	import org.eclipse.core.databinding.property.map.IMapPropertyChangeListener;
26	import org.eclipse.core.databinding.property.map.MapPropertyChangeEvent;
27
28	/**
29	* @since 3.3
30	*
31	*/
32	public class PropertyObservableMap extends AbstractObservableMap implements
33	IPropertyObservable {
34	private Object source;
35	private IMapProperty property;
36
37	private volatile boolean updating = false;
38
39	private boolean disposed = false;
40
41	private transient volatile int modCount = 0;
42
43	private IMapPropertyChangeListener listener = new IMapPropertyChangeListener() {
44	public void handleMapPropertyChange(final MapPropertyChangeEvent event) {
45	if (!disposed && !updating) {
46	getRealm().exec(new Runnable() {
47	public void run() {
48	getRealm().exec(new Runnable() {
49	public void run() {
50	modCount++;
51	fireMapChange(event.diff);
52	}
53	});
54	}
55	});
56	}
57	}
58	};
59
60	/**
61	* @param realm
62	* @param source
63	* @param property
64	*/
65	public PropertyObservableMap(Realm realm, Object source,
66	IMapProperty property) {
67	super(realm);
68	this.source = source;
69	this.property = property;
70	}
71
72	private void getterCalled() {
73	ObservableTracker.getterCalled(this);
74	}
75
76	protected void firstListenerAdded() {
77	if (!disposed) {
78	property.addMapChangeListener(source, listener);
79	}
80	}
81
82	protected void lastListenerRemoved() {
83	if (!disposed) {
84	property.removeMapChangeListener(source, listener);
85	}
86	}
87
88	public boolean containsKey(Object key) {
89	getterCalled();
90	return property.containsKey(source, key);
91	}
92
93	public boolean containsValue(Object value) {
94	getterCalled();
95	return property.containsValue(source, value);
96	}
97
98	public Set entrySet() {
99	getterCalled();
100	// unmodifiable for now
101	return Collections.unmodifiableSet(property.getMap(source).entrySet());
102	}
103
104	public Object get(Object key) {
105	getterCalled();
106	return property.get(source, key);
107	}
108
109	public boolean isEmpty() {
110	getterCalled();
111	return property.isEmpty(source);
112	}
113
114	public Set keySet() {
115	getterCalled();
116	return Collections.unmodifiableSet(property.getMap(source).keySet());
117	}
118
119	public Object put(Object key, Object value) {
120	checkRealm();
121	return property.put(source, key, value);
122	}
123
124	public void putAll(Map m) {
125	checkRealm();
126	property.putAll(source, m);
127	}
128
129	public Object remove(Object key) {
130	checkRealm();
131	return property.remove(source, key);
132	}
133
134	public int size() {
135	getterCalled();
136	return property.size(source);
137	}
138
139	public Collection values() {
140	getterCalled();
141	return Collections.unmodifiableCollection(property.getMap(source)
142	.values());
143	}
144
145	public void clear() {
146	getterCalled();
147	property.clear(source);
148	}
149
150	public boolean equals(Object o) {
151	getterCalled();
152	return property.equals(source, o);
153	}
154
155	public int hashCode() {
156	getterCalled();
157	return property.hashCode(source);
158	}
159
160	public Object getObserved() {
161	return source;
162	}
163
164	public IProperty getProperty() {
165	return property;
166	}
167
168	public synchronized void dispose() {
169	if (!disposed) {
170	disposed = true;
171	property.removeMapChangeListener(source, listener);
172	property = null;
173	source = null;
174	}
175	super.dispose();
176	}
177	}

Lines 13-19 Link Here

(-)src/org/eclipse/jface/tests/databinding/BindingTestSuite.java (-1 / +5 lines)
13	* Ashley Cambrell - bugs 198903, 198904	13	* Ashley Cambrell - bugs 198903, 198904
14	* Matthew Hall - bugs 210115, 212468, 212223, 206839, 208858, 208322,	14	* Matthew Hall - bugs 210115, 212468, 212223, 206839, 208858, 208322,
15	* 212518, 215531, 221351, 184830, 213145, 218269, 239015,	15	* 212518, 215531, 221351, 184830, 213145, 218269, 239015,
16	* 237703, 237718, 222289, 247394, 233306, 247647	16	* 237703, 237718, 222289, 247394, 233306, 247647, 194734
17	* Ovidio Mallo - bug 237163, bug 235195	17	* Ovidio Mallo - bug 237163, bug 235195
18	*******************************************************************************/	18	*******************************************************************************/
19	package org.eclipse.jface.tests.databinding;	19	package org.eclipse.jface.tests.databinding;
Lines 64-69 Link Here
64	import org.eclipse.core.tests.databinding.observable.value.ComputedValueTest;	64	import org.eclipse.core.tests.databinding.observable.value.ComputedValueTest;
65	import org.eclipse.core.tests.databinding.observable.value.DecoratingObservableValueTest;	65	import org.eclipse.core.tests.databinding.observable.value.DecoratingObservableValueTest;
66	import org.eclipse.core.tests.databinding.observable.value.WritableValueTest;	66	import org.eclipse.core.tests.databinding.observable.value.WritableValueTest;
		67	import org.eclipse.core.tests.databinding.property.PropertyTest;
67	import org.eclipse.core.tests.databinding.util.PolicyTest;	68	import org.eclipse.core.tests.databinding.util.PolicyTest;
68	import org.eclipse.core.tests.databinding.validation.MultiValidatorTest;	69	import org.eclipse.core.tests.databinding.validation.MultiValidatorTest;
69	import org.eclipse.core.tests.databinding.validation.ValidationStatusTest;	70	import org.eclipse.core.tests.databinding.validation.ValidationStatusTest;
Lines 256-261 Link Here
256	addTest(DecoratingObservableValueTest.suite());	257	addTest(DecoratingObservableValueTest.suite());
257	addTest(WritableValueTest.suite());	258	addTest(WritableValueTest.suite());
258		259
		260	//org.eclipse.core.tests.databinding.property
		261	addTestSuite(PropertyTest.class);
		262
259	//org.eclipse.core.tests.databinding.validation	263	//org.eclipse.core.tests.databinding.validation
260	addTestSuite(MultiValidatorTest.class);	264	addTestSuite(MultiValidatorTest.class);
261	addTestSuite(ValidationStatusTest.class);	265	addTestSuite(ValidationStatusTest.class);

Added Link Here

(-)src/org/eclipse/core/tests/databinding/property/PropertyTest.java (+185 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.tests.databinding.property;
13
14	import org.eclipse.core.databinding.property.IPropertyChangeListener;
15	import org.eclipse.core.databinding.property.Property;
16	import org.eclipse.core.databinding.property.PropertyChangeEvent;
17
18	import junit.framework.TestCase;
19
20	/**
21	* @since 3.2
22	*
23	*/
24	public class PropertyTest extends TestCase {
25	private Source source;
26	private SourceProperty property;
27	private ChangeListener listener;
28
29	protected void setUp() throws Exception {
30	source = new Source();
31	property = new SourceProperty();
32	listener = new ChangeListener();
33	}
34
35	public void testAddListenerTo() {
36	assertFalse(source.hasListener());
37	property.addChangeListener(source, listener);
38	assertTrue(source.hasListener());
39
40	assertEquals(0, listener.count);
41
42	source.change();
43
44	assertEquals(1, listener.count);
45	assertEquals(new ChangeEvent(source, "Version 1"), listener.event);
46	}
47
48	public void testAddListenerTo_MultipleListeners() {
49	assertFalse(source.hasListener());
50
51	property.addChangeListener(source, listener);
52
53	assertTrue(source.hasListener());
54
55	ChangeListener listener2 = new ChangeListener();
56	property.addChangeListener(source, listener2);
57
58	assertTrue(source.hasListener());
59
60	property.removeChangeListener(source, listener);
61
62	assertTrue(source.hasListener());
63
64	property.removeChangeListener(source, listener2);
65
66	assertFalse(source.hasListener());
67	}
68
69	public void testRemoveListenerFrom() {
70	property.addChangeListener(source, listener);
71	assertTrue(source.hasListener());
72	property.removeChangeListener(source, listener);
73	assertFalse(source.hasListener());
74
75	source.change();
76
77	assertEquals(0, listener.count);
78	}
79
80	public void testIsDisposed() {
81	assertFalse(property.isDisposed());
82	property.dispose();
83	assertTrue(property.isDisposed());
84	}
85
86	public void testDispose() {
87	property.addChangeListener(source, listener);
88	assertTrue(source.hasListener());
89	property.dispose();
90	assertFalse(source.hasListener());
91	}
92
93	static class Source {
94	private int version = 0;
95
96	private ISourceListener listener;
97
98	void change() {
99	++version;
100	if (listener != null)
101	listener.notify(this, "Version " + version);
102	}
103
104	boolean hasListener() {
105	return listener != null;
106	}
107	}
108
109	interface ISourceListener {
110	void notify(Object source, String message);
111	}
112
113	static class SourceProperty extends Property {
114	private ISourceListener listener = new ISourceListener() {
115	public void notify(Object source, String message) {
116	firePropertyChange(new ChangeEvent(source, message));
117	}
118	};
119
120	public void addChangeListener(Object source, IChangeListener listener) {
121	addPropertyChangeListener(source, listener);
122	}
123
124	public void removeChangeListener(Object source, IChangeListener listener) {
125	removePropertyChangeListener(source, listener);
126	}
127
128	protected void addListenerTo(Object source) {
129	((Source) source).listener = listener;
130	}
131
132	protected void removeListenerFrom(Object source) {
133	((Source) source).listener = null;
134	}
135
136	void change(Object source) {
137	((Source) source).change();
138	}
139	}
140
141	static interface IChangeListener extends IPropertyChangeListener {
142	void handlePropertyStubChange(ChangeEvent event);
143	}
144
145	static class ChangeListener implements IChangeListener {
146	int count = 0;
147	ChangeEvent event;
148
149	public void handlePropertyStubChange(ChangeEvent event) {
150	count++;
151	this.event = event;
152	}
153	}
154
155	static class ChangeEvent extends PropertyChangeEvent {
156	private static final long serialVersionUID = 1L;
157
158	final String message;
159
160	ChangeEvent(Object source, String message) {
161	super(source);
162	this.message = message;
163	}
164
165	protected void dispatch(IPropertyChangeListener listener) {
166	((IChangeListener) listener).handlePropertyStubChange(this);
167	}
168
169	public boolean equals(Object obj) {
170	if (obj == this)
171	return true;
172	if (!super.equals(obj))
173	return false;
174
175	ChangeEvent that = (ChangeEvent) obj;
176	return message.equals(that.message);
177	}
178
179	public int hashCode() {
180	int hash = super.hashCode();
181	hash = hash * 37 + message.hashCode();
182	return hash;
183	}
184	}
185	}