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




 */
public abstract class ComputedObservableMap extends AbstractObservableMap {

	private IObservableSet keySet;

	private ISetChangeListener setChangeListener = new ISetChangeListener() {
		public void handleSetChange(SetChangeEvent event) {

	 * @return the old value for the given key
	 */
	protected abstract Object doPut(Object key, Object value);

	public void dispose() {
		if (keySet != null) {
			Object[] keys = keySet.toArray();
			for (int i = 0; i < keys.length; i++) {
				unhookListener(keys[i]);
			}
			keySet = null;
		}
		entrySet = null;
		super.dispose();
	}
}

Lines 76-86 Link Here

(-)src/org/eclipse/core/databinding/observable/list/AbstractObservableList.java (-6 / +18 lines)
76	}	76	}
77		77
78	public synchronized void addListChangeListener(IListChangeListener listener) {	78	public synchronized void addListChangeListener(IListChangeListener listener) {
79	changeSupport.addListener(ListChangeEvent.TYPE, listener);	79	if (changeSupport != null) {
		80	changeSupport.addListener(ListChangeEvent.TYPE, listener);
		81	}
80	}	82	}
81		83
82	public synchronized void removeListChangeListener(IListChangeListener listener) {	84	public synchronized void removeListChangeListener(IListChangeListener listener) {
83	changeSupport.removeListener(ListChangeEvent.TYPE, listener);	85	if (changeSupport != null) {
		86	changeSupport.removeListener(ListChangeEvent.TYPE, listener);
		87	}
84	}	88	}
85		89
86	protected void fireListChange(ListDiff diff) {	90	protected void fireListChange(ListDiff diff) {
Lines 90-108 Link Here
90	}	94	}
91		95
92	public synchronized void addChangeListener(IChangeListener listener) {	96	public synchronized void addChangeListener(IChangeListener listener) {
93	changeSupport.addChangeListener(listener);	97	if (changeSupport != null) {
		98	changeSupport.addChangeListener(listener);
		99	}
94	}	100	}
95		101
96	public synchronized void removeChangeListener(IChangeListener listener) {	102	public synchronized void removeChangeListener(IChangeListener listener) {
97	changeSupport.removeChangeListener(listener);	103	if (changeSupport != null) {
		104	changeSupport.removeChangeListener(listener);
		105	}
98	}	106	}
99		107
100	public synchronized void addStaleListener(IStaleListener listener) {	108	public synchronized void addStaleListener(IStaleListener listener) {
101	changeSupport.addStaleListener(listener);	109	if (changeSupport != null) {
		110	changeSupport.addStaleListener(listener);
		111	}
102	}	112	}
103		113
104	public synchronized void removeStaleListener(IStaleListener listener) {	114	public synchronized void removeStaleListener(IStaleListener listener) {
105	changeSupport.removeStaleListener(listener);	115	if (changeSupport != null) {
		116	changeSupport.removeStaleListener(listener);
		117	}
106	}	118	}
107		119
108	/**	120	/**

Lines 14-19 Link Here

(-)META-INF/MANIFEST.MF (+1 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,
17	org.eclipse.core.databinding.util,	18	org.eclipse.core.databinding.util,
18	org.eclipse.core.databinding.validation;x-internal:=false,	19	org.eclipse.core.databinding.validation;x-internal:=false,
19	org.eclipse.core.internal.databinding;x-friends:="org.eclipse.core.databinding.beans",	20	org.eclipse.core.internal.databinding;x-friends:="org.eclipse.core.databinding.beans",




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

/**
 * @since 1.2
 * 
 */
public interface IListProperty extends ICollectionProperty {
	/**
	 * @param source
	 * @return a List with the current contents of the source's list property
	 */
	List getList(Object source);

	/**
	 * @param source
	 * @param index
	 * @param c
	 * @return whether the source's list property was changed
	 */
	boolean addAll(Object source, int index, Collection c);

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

	/**
	 * @param source
	 * @param index
	 * @param element
	 * @return the element previous at the given location in the source's list
	 *         property
	 */
	Object set(Object source, int index, Object element);

	/**
	 * @param source
	 * @param oldIndex
	 * @param newIndex
	 * @return the element that was moved
	 */
	Object move(Object source, int oldIndex, int newIndex);

	/**
	 * @param source
	 * @param index
	 * @param element
	 */
	void add(Object source, int index, Object element);

	/**
	 * @param source
	 * @param index
	 * @return the element that was removed from the source's list property
	 */
	Object remove(Object source, int index);

	/**
	 * @param source
	 * @param o
	 * @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);

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

	/**
	 * @param source
	 * @param listener
	 */
	public void addListChangeListener(Object source,
			IListPropertyChangeListener listener);

	/**
	 * @param source
	 * @param 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.databinding.property;

import java.util.Set;

/**
 * @since 1.2
 */
public interface ISetProperty extends ICollectionProperty {
	/**
	 * @param source
	 * @return a Set with the current contents of the source's set property
	 */
	public Set getSet(Object source);

	/**
	 * @param source
	 * @param listener
	 */
	public void addSetChangeListener(Object source,
			ISetPropertyChangeListener listener);

	/**
	 * @param source
	 * @param 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;

import org.eclipse.core.databinding.observable.list.IObservableList;
import org.eclipse.core.databinding.observable.map.IObservableMap;
import org.eclipse.core.databinding.observable.set.IObservableSet;
import org.eclipse.core.databinding.observable.value.IObservableValue;

/**
 * @since 1.2
 * 
 */
public class ObservableProperties {
	/**
	 * @param observable
	 * @return blah
	 */
	public static IValueProperty detailValue(IObservableValue observable) {
		return null;
	}

	/**
	 * @param observable
	 * @return blah
	 */
	public static ISetProperty detailSet(IObservableSet observable) {
		return null;
	}

	/**
	 * @param observable
	 * @return blah
	 */
	public static IListProperty detailList(IObservableList observable) {
		return null;
	}

	/**
	 * @param observable
	 * @return blah
	 */
	public static IMapProperty detailMap(IObservableMap observable) {
		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;

import org.eclipse.core.databinding.observable.value.ValueDiff;
import org.eclipse.core.runtime.Assert;

/**
 * @since 1.2
 * 
 */
public class ValuePropertyChangeEvent extends PropertyChangeEvent {
	private static final long serialVersionUID = 1L;

	/**
	 * 
	 */
	public final IValueProperty property;

	/**
	 * ValueDiff with the old and new values of the property. May be null to
	 * indicate that the details of the value change are unknown.
	 */
	public final ValueDiff diff;
	
	/**
	 * @param source
	 * @param property
	 * @param diff
	 */
	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;
	}

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

import org.eclipse.core.databinding.observable.map.MapDiff;

/**
 * @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) {
		getChangeSupport().addListener(source, listener);
	}

	public final void removeMapChangeListener(Object source,
			IMapPropertyChangeListener listener) {
		getChangeSupport().removeListener(source, listener);
	}

	protected final void fireMapChange(Object source, MapDiff diff) {
		getChangeSupport().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;

import java.util.Collection;

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

/**
 * @since 1.2
 */
public abstract class ListProperty extends CollectionProperty implements IListProperty {
	Collection getCollection(Object source) {
		return getList(source);
	}

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

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

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

	public final void addListChangeListener(Object source,
			IListPropertyChangeListener listener) {
		getChangeSupport().addListener(source, listener);
	}

	public final void removeListChangeListener(Object source,
			IListPropertyChangeListener listener) {
		getChangeSupport().removeListener(source, listener);
	}

	protected final void fireListChange(Object source, ListDiff diff) {
		getChangeSupport().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.internal.databinding.property;

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

import org.eclipse.core.databinding.observable.IObserving;
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.IMapProperty;
import org.eclipse.core.databinding.property.IMapPropertyChangeListener;
import org.eclipse.core.databinding.property.MapPropertyChangeEvent;

/**
 * @since 3.3
 * 
 */
public class PropertyObservableMap extends AbstractObservableMap implements
		IObserving {
	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 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.databinding.property;

import org.eclipse.core.databinding.observable.set.SetDiff;
import org.eclipse.core.runtime.Assert;

/**
 * @since 1.2
 */
public class SetPropertyChangeEvent extends PropertyChangeEvent {
	private static final long serialVersionUID = 1L;

	/**
	 * 
	 */
	public final ISetProperty property;

	/**
	 * SetDiff enumerating the added and removed elements in the set. May be
	 * null to indicate that the details of the set change are unknown.
	 */
	public final SetDiff diff;

	/**
	 * @param source
	 * @param property
	 * @param diff
	 */
	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;
	}

	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;

/**
 * @since 1.2
 * 
 */
public interface IValueProperty extends IProperty {
	/**
	 * @param source
	 * @return the property value
	 */
	public Object getValue(Object source);

	/**
	 * @param source
	 * @param value
	 */
	public void setValue(Object source, Object value);

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

	/**
	 * @param source
	 * @param listener
	 */
	public void addValueChangeListener(Object source,
			IValuePropertyChangeListener listener);

	/**
	 * @param source
	 * @param 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;

import java.util.Map;

/**
 * @since 1.2
 */
public interface IMapProperty extends IProperty {
	/**
	 * @param source
	 * @return a Map with the current contents of the source's map property
	 */
	Map getMap(Object source);

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

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

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

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

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

	/**
	 * @param source
	 * @param key
	 * @param 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);

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

	/**
	 * @param source
	 * @param t
	 */
	void putAll(Object source, Map t);

	/**
	 * @param source
	 */
	void clear(Object source);

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

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

	/**
	 * @param source
	 * @param listener
	 */
	public void addMapChangeListener(Object source,
			IMapPropertyChangeListener listener);

	/**
	 * @param source
	 * @param 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.databinding.property;

/**
 * @since 1.2
 */
public interface IMapPropertyChangeListener extends IPropertyChangeListener {
	/**
	 * @param event
	 */
	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.databinding.property;

/**
 * @since 1.2
 */
public interface IValuePropertyChangeListener extends IPropertyChangeListener {
	/**
	 * @param event
	 */
	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.databinding.observable.value.ValueDiff;

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

	public final void removeValueChangeListener(Object source,
			IValuePropertyChangeListener listener) {
		getChangeSupport().removeListener(source, listener);
	}

	protected final void fireValueChange(Object source, ValueDiff diff) {
		getChangeSupport().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.masterdetail;

import org.eclipse.core.databinding.property.IListProperty;
import org.eclipse.core.databinding.property.IMapProperty;
import org.eclipse.core.databinding.property.ISetProperty;
import org.eclipse.core.databinding.property.IValueProperty;
import org.eclipse.core.internal.databinding.property.masterdetail.ListPropertyDetailValueList;
import org.eclipse.core.internal.databinding.property.masterdetail.MapPropertyDetailValueMap;
import org.eclipse.core.internal.databinding.property.masterdetail.SetPropertyDetailValueMap;
import org.eclipse.core.internal.databinding.property.masterdetail.ValuePropertyDetailList;
import org.eclipse.core.internal.databinding.property.masterdetail.ValuePropertyDetailMap;
import org.eclipse.core.internal.databinding.property.masterdetail.ValuePropertyDetailSet;
import org.eclipse.core.internal.databinding.property.masterdetail.ValuePropertyDetailValue;

/**
 * @since 1.2
 */
public class MasterDetailProperties {
	// Properties of IValueProperty master properties

	/**
	 * @param masterValue
	 * @param detailValue
	 * @return blah
	 */
	public static IValueProperty detailValue(IValueProperty masterValue,
			IValueProperty detailValue) {
		return new ValuePropertyDetailValue(masterValue, detailValue);
	}

	/**
	 * @param masterValue
	 * @param detailList
	 * @return blah
	 */
	public static IListProperty detailList(IValueProperty masterValue,
			IListProperty detailList) {
		return new ValuePropertyDetailList(masterValue, detailList);
	}

	/**
	 * @param masterValue
	 * @param detailSet
	 * @return blah
	 */
	public static ISetProperty detailSet(IValueProperty masterValue,
			ISetProperty detailSet) {
		return new ValuePropertyDetailSet(masterValue, detailSet);
	}

	/**
	 * @param masterValue
	 * @param detailMap
	 * @return blah
	 */
	public static IMapProperty detailMap(IValueProperty masterValue,
			IMapProperty detailMap) {
		return new ValuePropertyDetailMap(masterValue, detailMap);
	}

	// Properties of IListProperty master properties

	/**
	 * @param masterList
	 * @param detailValue
	 * @return blah
	 */
	public static IListProperty detailList(IListProperty masterList,
			IValueProperty detailValue) {
		return new ListPropertyDetailValueList(masterList, detailValue);
	}

	// Properties of ISetProperty master properties

	/**
	 * @param masterKeySet
	 * @param detailValues
	 * @return blah
	 */
	public static IMapProperty detailMap(ISetProperty masterKeySet,
			IValueProperty detailValues) {
		return new SetPropertyDetailValueMap(masterKeySet, detailValues);
	}

	// Properties of IMapProperty master properties

	/**
	 * @param masterMap
	 * @param detailValues
	 * @return blah
	 */
	public static IMapProperty detailMap(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.internal.databinding.property.masterdetail;

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

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

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

/**
 * Interface for observing a property of a source object.
 * 
 * @noimplement
 * @since 1.2
 */
public interface IProperty {
	/**
	 * 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 (bug 194734)
 ******************************************************************************/

package org.eclipse.core.databinding.property;

import java.util.Collection;

import org.eclipse.core.databinding.observable.set.SetDiff;

/**
 * @since 1.2
 */
public abstract class SetProperty extends CollectionProperty implements
		ISetProperty {
	Collection getCollection(Object source) {
		return getSet(source);
	}

	public final void addSetChangeListener(Object source,
			ISetPropertyChangeListener listener) {
		getChangeSupport().addListener(source, listener);
	}

	public final void removeSetChangeListener(Object source,
			ISetPropertyChangeListener listener) {
		getChangeSupport().removeListener(source, listener);
	}

	protected final void fireSetChange(Object source, SetDiff diff) {
		getChangeSupport().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 (bug 194734)
 ******************************************************************************/

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

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.IListProperty;
import org.eclipse.core.databinding.property.IListPropertyChangeListener;
import org.eclipse.core.databinding.property.IValueProperty;
import org.eclipse.core.databinding.property.IValuePropertyChangeListener;
import org.eclipse.core.databinding.property.ListProperty;
import org.eclipse.core.databinding.property.ListPropertyChangeEvent;
import org.eclipse.core.databinding.property.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.masterdetail;

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.IListProperty;
import org.eclipse.core.databinding.property.IListPropertyChangeListener;
import org.eclipse.core.databinding.property.IValueProperty;
import org.eclipse.core.databinding.property.IValuePropertyChangeListener;
import org.eclipse.core.databinding.property.ListProperty;
import org.eclipse.core.databinding.property.ListPropertyChangeEvent;
import org.eclipse.core.databinding.property.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(Integer.valueOf(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.masterdetail;

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.IMapProperty;
import org.eclipse.core.databinding.property.IMapPropertyChangeListener;
import org.eclipse.core.databinding.property.IValueProperty;
import org.eclipse.core.databinding.property.IValuePropertyChangeListener;
import org.eclipse.core.databinding.property.MapProperty;
import org.eclipse.core.databinding.property.MapPropertyChangeEvent;
import org.eclipse.core.databinding.property.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.databinding.property;

/**
 * @since 1.2
 */
public interface ISetPropertyChangeListener extends IPropertyChangeListener {
	/**
	 * @param event
	 */
	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 (bug 194734)
 ******************************************************************************/

package org.eclipse.core.databinding.property;

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

/**
 * @since 1.2
 */
public class MapPropertyChangeEvent extends PropertyChangeEvent {
	private static final long serialVersionUID = 1L;

	/**
	 * 
	 */
	public final IMapProperty property;

	/**
	 * MapDiff enumerating the added, changed, and removed entries in the map.
	 * May be null to indicate that the details of the map change are unknown.
	 */
	public final MapDiff diff;

	/**
	 * @param source
	 * @param property
	 * @param diff
	 */
	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;
	}

	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;

import org.eclipse.core.databinding.observable.list.ListDiff;
import org.eclipse.core.runtime.Assert;

/**
 * @since 1.2
 */
public class ListPropertyChangeEvent extends PropertyChangeEvent {
	private static final long serialVersionUID = 1L;

	/**
	 * 
	 */
	public final IListProperty property;

	/**
	 * ListDiff enumerating the added and removed elements in the list. May be
	 * null to indicate that the details of the list change are unknown.
	 */
	public final ListDiff diff;

	/**
	 * @param source
	 * @param property
	 * @param diff
	 */
	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;
	}

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

import java.util.Collection;

/**
 * @since 1.2
 * 
 */
public interface ICollectionProperty extends IProperty {
	/**
	 * @param source
	 * @return the size of the source's collection property
	 */
	int size(Object source);

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

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

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

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

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

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

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

	/**
	 * @param source
	 * @param c
	 * @return whether the source's collection property was changed
	 */
	boolean addAll(Object source, Collection c);

	/**
	 * @param source
	 * @param c
	 * @return whether the source's collection property was changed
	 */
	boolean removeAll(Object source, Collection c);

	/**
	 * @param source
	 * @param c
	 * @return whether the source's collection property was changed
	 */
	boolean retainAll(Object source, Collection c);

	/**
	 * @param source
	 */
	void clear(Object source);

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

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

	/**
	 * @return the type of the elements 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;

import java.util.EventObject;

/**
 * @since 1.2
 */
public abstract class PropertyChangeEvent extends EventObject {
	private static final long serialVersionUID = 1L;

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

	abstract void dispatch(IPropertyChangeListener 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.masterdetail;

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.IMapProperty;
import org.eclipse.core.databinding.property.IMapPropertyChangeListener;
import org.eclipse.core.databinding.property.IValueProperty;
import org.eclipse.core.databinding.property.IValuePropertyChangeListener;
import org.eclipse.core.databinding.property.MapProperty;
import org.eclipse.core.databinding.property.MapPropertyChangeEvent;
import org.eclipse.core.databinding.property.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;

import java.util.Collections;
import java.util.IdentityHashMap;
import java.util.Iterator;
import java.util.Map;

import org.eclipse.core.runtime.ListenerList;

/**
 * @since 1.2
 */
public class PropertyChangeSupport {
	private Property property;
	private Map changeListeners;

	PropertyChangeSupport(Property property) {
		this.property = property;
		this.changeListeners = null;
	}

	protected final void addListener(Object source,
			IPropertyChangeListener listener) {
		boolean wasListening = hasListeners(source);

		if (changeListeners == null) {
			synchronized (this) {
				if (changeListeners == null) {
					changeListeners = Collections
							.synchronizedMap(new IdentityHashMap());
				}
			}
		}

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

		synchronized (listeners) {
			listeners.add(listener);
		}

		if (!wasListening)
			property.addListenerTo(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
	 */
	public boolean hasListeners(Object source) {
		return changeListeners != null
				&& changeListeners.containsKey(source);
	}

	protected final void removeListener(Object source,
			IPropertyChangeListener listener) {
		if (changeListeners != null) {
			ListenerList listeners = (ListenerList) changeListeners.get(source);
			if (listeners != null) {
				listeners.remove(listener);
				if (listeners.isEmpty()) {
					synchronized (listeners) {
						if (listeners.isEmpty()) {
							changeListeners.remove(source);
							property.removeListenerFrom(source);
						}
					}
				}
			}
		}
	}

	protected final void firePropertyChange(PropertyChangeEvent event) {
		ListenerList listenerList;
		synchronized (this) {
			if (changeListeners == null)
				return;
			listenerList = (ListenerList) changeListeners
					.get(event.getSource());
		}
		if (listenerList != null) {
			Object[] listeners = listenerList.getListeners();
			for (int i = 0; i < listeners.length; i++) {
				event.dispatch((IPropertyChangeListener) listeners[i]);
			}
		}
	}

	void dispose() {
		if (changeListeners != null) {
			for (Iterator iterator = changeListeners.keySet().iterator(); iterator
					.hasNext();) {
				Object source = iterator.next();
				property.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.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.set.IObservableSet;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.core.internal.databinding.property.PropertyObservableList;
import org.eclipse.core.internal.databinding.property.PropertyObservableMap;
import org.eclipse.core.internal.databinding.property.PropertyObservableSet;
import org.eclipse.core.internal.databinding.property.PropertyObservableValue;
import org.eclipse.core.internal.databinding.property.SetValuePropertyObservableMap;

/**
 * @since 1.2
 * 
 */
public class PropertyObservables {
	/**
	 * @param source
	 * @param property
	 * @return an observable value 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);
	}

	/**
	 * @param realm
	 * @param source
	 * @param property
	 * @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);
	}

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

	/**
	 * @param realm
	 * @param source
	 * @param property
	 * @return an observable set 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);
	}

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

	/**
	 * @param realm
	 * @param source
	 * @param property
	 * @return an observable set 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);
	}

	/**
	 * @param source
	 * @param property
	 * @return an observable map that tracks the given property of the source
	 *         object
	 */
	public static IObservableMap observeMap(Object source, IMapProperty property) {
		return observeMap(Realm.getDefault(), source, property);
	}

	/**
	 * @param realm
	 * @param source
	 * @param property
	 * @return an observable set that 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 in the default realm tracking the current
	 * values of the named property for the beans in the given set.
	 * 
	 * @param keySet
	 * @param valueProperty
	 * @return an observable map 
	 */
	public static IObservableMap observeMap(IObservableSet keySet,
			IValueProperty valueProperty) {
		return new SetValuePropertyObservableMap(keySet, valueProperty);
	}

	/**
	 * Returns a factory for creating observable values 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 valueFactory(IValueProperty property) {
		return valueFactory(Realm.getDefault(), property);
	}

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

	/**
	 * Returns a factory for creating observable sets 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 setFactory(ISetProperty property) {
		return setFactory(Realm.getDefault(), property);
	}

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

	/**
	 * Returns a factory for creating observable lists 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 tracking the given
	 * property of a particular source object
	 * 
	 * @param realm
	 *            the realm to use
	 * @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);
			}
		};
	}
}




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

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.ISetProperty;
import org.eclipse.core.databinding.property.ISetPropertyChangeListener;
import org.eclipse.core.databinding.property.IValueProperty;
import org.eclipse.core.databinding.property.IValuePropertyChangeListener;
import org.eclipse.core.databinding.property.SetProperty;
import org.eclipse.core.databinding.property.SetPropertyChangeEvent;
import org.eclipse.core.databinding.property.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.internal.databinding.property;

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.IObserving;
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.IListProperty;
import org.eclipse.core.databinding.property.IListPropertyChangeListener;
import org.eclipse.core.databinding.property.ListPropertyChangeEvent;

/**
 * @since 3.3
 * 
 */
public class PropertyObservableList extends AbstractObservableList implements IObserving {
	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 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.property;

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.IObserving;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.set.AbstractObservableSet;
import org.eclipse.core.databinding.property.ISetProperty;
import org.eclipse.core.databinding.property.ISetPropertyChangeListener;
import org.eclipse.core.databinding.property.SetPropertyChangeEvent;

/**
 * @since 3.3
 * 
 */
public class PropertyObservableSet extends AbstractObservableSet implements
		IObserving {
	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 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;

/**
 * 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 (bug 194734)
 ******************************************************************************/

package org.eclipse.core.databinding.property;

import java.util.Collection;

/**
 * @since 1.2
 * 
 */
public abstract class CollectionProperty extends Property implements
		ICollectionProperty {
	abstract Collection getCollection(Object source);

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

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

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

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

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

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

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

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




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

/**
 * @since 3.3
 * 
 */
public class SetValuePropertyObservableMap extends ComputedObservableMap
		implements IObserving {
	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() {
						fireMapChange(Diffs.createMapDiffSingleChange(event
								.getSource(), event.diff.getOldValue(),
								event.diff.getNewValue()));
					}
				});
			}
		}
	};

	/**
	 * @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);
		keySet().add(key);
		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.internal.databinding.property;

import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.observable.IObserving;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.value.AbstractObservableValue;
import org.eclipse.core.databinding.property.IValueProperty;
import org.eclipse.core.databinding.property.IValuePropertyChangeListener;
import org.eclipse.core.databinding.property.ValuePropertyChangeEvent;
import org.eclipse.core.internal.databinding.Util;

/**
 * @since 1.2
 * 
 */
public class PropertyObservableValue extends AbstractObservableValue implements
		IObserving {
	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 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;

/**
 * @since 1.2
 */
public interface IListPropertyChangeListener extends IPropertyChangeListener {
	/**
	 * @param event
	 */
	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.databinding.property;

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

	synchronized PropertyChangeSupport getChangeSupport() {
		if (changeSupport == null)
			changeSupport = new PropertyChangeSupport(this);
		return changeSupport;
	}

	/**
	 * Notifies the property that the first listener has been added for the
	 * given source object. Implementers should register a listener on the
	 * source object which fires an appropriate change event when a property
	 * change is observed on the source.
	 * 
	 * @param source
	 *            the source object to observe for property changes.
	 * @see #removeListenerFrom(Object)
	 */
	protected abstract void addListenerTo(Object source);

	/**
	 * Notifies the property that the last listener has been removed for the
	 * given source object. Implementers should unregister any previously
	 * registered listeners from the source.
	 * 
	 * @param source
	 *            the source object to stop observing for property changes.
	 * @see #addListenerTo(Object)
	 */
	protected abstract void removeListenerFrom(Object source);

	/**
	 * 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 boolean hasListeners(Object source) {
		return changeSupport != null && changeSupport.hasListeners(source);
	}

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




 *
 * Contributors:
 *     Brad Reynolds - initial API and implementation
 *     Matthew Hall - bug 194734
 ******************************************************************************/

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


import org.eclipse.core.databinding.beans.IBeanObservable;
import org.eclipse.core.databinding.observable.IChangeListener;
import org.eclipse.core.databinding.observable.IObserving;
import org.eclipse.core.databinding.observable.IStaleListener;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.set.IObservableSet;

 * 
 * @since 3.3
 */
public class BeanObservableSetDecorator implements IObservableSet,
		IBeanObservable {
	private IObservableSet delegate;
	private Object observed;
	private PropertyDescriptor propertyDescriptor;

	/**
	 * @param delegate
	 * @param observed 
	 * @param propertyDescriptor
	 */
	public BeanObservableSetDecorator(IObservableSet delegate,
			Object observed,
			PropertyDescriptor propertyDescriptor) {

		this.delegate = delegate;
		this.observed = observed;
		this.propertyDescriptor = propertyDescriptor;
	}


		return delegate.toArray(a);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.core.databinding.beans.IBeanObservable#getObserved()
	 */
	public Object getObserved() {
		if (delegate instanceof IObserving)
			return ((IObserving) delegate).getObserved();
		return null;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.core.databinding.beans.IBeanObservable#getPropertyDescriptor()
	 */
	public PropertyDescriptor getPropertyDescriptor() {
		return propertyDescriptor;
	}

	 */
	public IObservableSet getDelegate() {
		return delegate;
	}
}




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

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

import java.beans.PropertyChangeListener;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;

import org.eclipse.core.databinding.beans.IBeanObservable;
import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.observable.map.ComputedObservableMap;
import org.eclipse.core.databinding.observable.set.IObservableSet;
import org.eclipse.core.databinding.util.Policy;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;

/**
 * @since 1.0
 * 
 */
public class JavaBeanObservableMap extends ComputedObservableMap implements
		IBeanObservable {

	private PropertyDescriptor propertyDescriptor;
	
	private PropertyChangeListener elementListener = new PropertyChangeListener() {
		public void propertyChange(final java.beans.PropertyChangeEvent event) {
			if (!updating) {
				getRealm().exec(new Runnable() {
					public void run() {
						fireMapChange(Diffs.createMapDiffSingleChange(
								event.getSource(), event.getOldValue(), event
								.getNewValue()));
					}
				});
			}
		}
	};

	private ListenerSupport listenerSupport;

	private boolean updating = false;

	private boolean attachListeners;

	/**
	 * @param domain
	 * @param propertyDescriptor
	 */
	public JavaBeanObservableMap(IObservableSet domain,
			PropertyDescriptor propertyDescriptor) {
		this(domain, propertyDescriptor, true);
	}

	/**
	 * @param domain
	 * @param propertyDescriptor
	 * @param attachListeners
	 */
	public JavaBeanObservableMap(IObservableSet domain,
			PropertyDescriptor propertyDescriptor, boolean attachListeners) {
		super(domain);

		this.propertyDescriptor = propertyDescriptor;
		this.attachListeners = attachListeners;
		if (attachListeners) {
			this.listenerSupport = new ListenerSupport(elementListener,
					propertyDescriptor.getName());
		}
		init();
	}

	protected void hookListener(Object domainElement) {
		if (attachListeners && domainElement != null) {
			listenerSupport.hookListener(domainElement);
		}
	}

	protected void unhookListener(Object domainElement) {
		if (attachListeners && domainElement != null) {
			listenerSupport.unhookListener(domainElement);
		}
	}

	protected Object doGet(Object key) {
		if (key == null) {
			return null;
		}
		try {
			Method readMethod = propertyDescriptor.getReadMethod();
			if (!readMethod.isAccessible()) {
				readMethod.setAccessible(true);
			}
			return readMethod.invoke(key, new Object[0]);
		} catch (Exception e) {
			Policy.getLog().log(
					new Status(IStatus.ERROR, Policy.JFACE_DATABINDING,
							IStatus.ERROR, "cannot get value", e)); //$NON-NLS-1$
			throw new RuntimeException(e);
		}
	}

	protected Object doPut(Object key, Object value) {
		try {
			Object oldValue = get(key);
			propertyDescriptor.getWriteMethod().invoke(key,
					new Object[] { value });
			keySet().add(key);
			return oldValue;
		} catch (Exception e) {
			Policy.getLog().log(
					new Status(IStatus.ERROR, Policy.JFACE_DATABINDING,
							IStatus.ERROR, "cannot set value", e)); //$NON-NLS-1$
			throw new RuntimeException(e);
		}
	}

	/* (non-Javadoc)
	 * @see org.eclipse.core.databinding.beans.IBeanObservable#getObserved()
	 */
	public Object getObserved() {
		return keySet();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.core.databinding.beans.IBeanObservable#getPropertyDescriptor()
	 */
	public PropertyDescriptor getPropertyDescriptor() {
		return propertyDescriptor;
	}
}




/*******************************************************************************
 * Copyright (c) 2006-2008 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Brad Reynolds - bug 171616
 *     Matthew Hall - bugs 208858, 221351, 213145, 223164
 *     Mike Evans - bug 217558
 *******************************************************************************/

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

import java.beans.PropertyChangeListener;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Array;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;

import org.eclipse.core.databinding.BindingException;
import org.eclipse.core.databinding.beans.IBeanObservable;
import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.list.ListDiffEntry;
import org.eclipse.core.databinding.observable.list.ObservableList;

/**
 * @since 1.0
 * 
 */
public class JavaBeanObservableList extends ObservableList implements
		IBeanObservable {

	private final Object object;

	private PropertyChangeListener collectionListener = new PropertyChangeListener() {
		public void propertyChange(java.beans.PropertyChangeEvent event) {
			if (!updating) {
				getRealm().exec(new Runnable() {
					public void run() {
						updateWrappedList( new ArrayList( Arrays.asList(getValues() ) ) );
					}
				});
			}
		}
	};

	private boolean updating = false;

	private PropertyDescriptor descriptor;

	private ListenerSupport collectionListenSupport;

	private boolean attachListeners;

	/**
	 * @param realm
	 * @param object
	 * @param descriptor
	 * @param elementType
	 */
	public JavaBeanObservableList(Realm realm, Object object,
			PropertyDescriptor descriptor, Class elementType) {
		this(realm, object, descriptor, elementType, true);
	}

	/**
	 * @param realm
	 * @param object
	 * @param descriptor
	 * @param elementType
	 * @param attachListeners
	 */
	public JavaBeanObservableList(Realm realm, Object object,
			PropertyDescriptor descriptor, Class elementType,
			boolean attachListeners) {

		super(realm, new ArrayList(), elementType);
		this.object = object;
		this.descriptor = descriptor;
		this.attachListeners = attachListeners;

		if (attachListeners) {
			this.collectionListenSupport = new ListenerSupport(
					collectionListener, descriptor.getName());
		}

		// initialize list without firing events
		wrappedList.addAll(Arrays.asList(getValues()));
	}

	protected void firstListenerAdded() {
		if (attachListeners) {
			collectionListenSupport.hookListener(this.object);
		}
	}

	protected void lastListenerRemoved() {
		if (collectionListenSupport != null) {
			collectionListenSupport.dispose();
		}
	}

	public void dispose() {
		super.dispose();
		lastListenerRemoved();
	}

	private Object primGetValues() {
		Exception ex = null;
		try {
			Method readMethod = descriptor.getReadMethod();
			if (!readMethod.isAccessible()) {
				readMethod.setAccessible(true);
			}
			return readMethod.invoke(object, new Object[0]);
		} catch (IllegalArgumentException e) {
			ex = e;
		} catch (IllegalAccessException e) {
			ex = e;
		} catch (InvocationTargetException e) {
			ex = e;
		}
		throw new BindingException("Could not read collection values", ex); //$NON-NLS-1$
	}

	private Object[] getValues() {
		Object[] values = null;

		Object result = primGetValues();
		if (descriptor.getPropertyType().isArray())
			values = (Object[]) result;
		else {
			// TODO add jUnit for POJO (var. SettableValue) collections
			Collection list = (Collection) result;
			if (list != null) {
				values = list.toArray();
			}
		}
		if (values == null)
			values = new Object[0];
		return values;
	}

	public Object getObserved() {
		return object;
	}

	public PropertyDescriptor getPropertyDescriptor() {
		return descriptor;
	}

	private void setValues() {
		if (descriptor.getPropertyType().isArray()) {
			Class componentType = descriptor.getPropertyType()
					.getComponentType();
			Object[] newArray = (Object[]) Array.newInstance(componentType,
					wrappedList.size());
			wrappedList.toArray(newArray);
			primSetValues(newArray);
		} else {
			// assume that it is a java.util.List
			primSetValues(new ArrayList(wrappedList));
		}
	}

	private void primSetValues(Object newValue) {
		Exception ex = null;
		try {
			Method writeMethod = descriptor.getWriteMethod();
			if (!writeMethod.isAccessible()) {
				writeMethod.setAccessible(true);
			}
			writeMethod.invoke(object, new Object[] { newValue });
			return;
		} catch (IllegalArgumentException e) {
			ex = e;
		} catch (IllegalAccessException e) {
			ex = e;
		} catch (InvocationTargetException e) {
			ex = e;
		}
		throw new BindingException("Could not write collection values", ex); //$NON-NLS-1$
	}

	public Object set(int index, Object element) {
		getterCalled();
		updating = true;
		try {
			Object oldElement = wrappedList.set(index, element);
			setValues();
			fireListChange(Diffs.createListDiff(Diffs.createListDiffEntry(
					index, false, oldElement), Diffs.createListDiffEntry(index,
					true, element)));
			return oldElement;
		} finally {
			updating = false;
		}
	}

	public Object move(int oldIndex, int newIndex) {
		getterCalled();
		updating = true;
		try {
			int size = wrappedList.size();
			if (oldIndex < 0 || oldIndex >= size)
				throw new IndexOutOfBoundsException(
						"oldIndex: " + oldIndex + ", size:" + size); //$NON-NLS-1$ //$NON-NLS-2$
			if (newIndex < 0 || newIndex >= size)
				throw new IndexOutOfBoundsException(
						"newIndex: " + newIndex + ", size:" + size); //$NON-NLS-1$ //$NON-NLS-2$
			if (oldIndex == newIndex)
				return wrappedList.get(oldIndex);
			Object element = wrappedList.remove(oldIndex);
			wrappedList.add(newIndex, element);
			setValues();
			fireListChange(Diffs.createListDiff(Diffs.createListDiffEntry(
					oldIndex, false, element), Diffs.createListDiffEntry(
					newIndex, true, element)));
			return element;
		} finally {
			updating = false;
		}
	}

	public Object remove(int index) {
		getterCalled();
		updating = true;
		try {
			Object oldElement = wrappedList.remove(index);
			setValues();
			fireListChange(Diffs.createListDiff(Diffs.createListDiffEntry(
					index, false, oldElement)));
			return oldElement;
		} finally {
			updating = false;
		}
	}

	public boolean add(Object element) {
		updating = true;
		try {
			int index = wrappedList.size();
			boolean result = wrappedList.add(element);
			setValues();
			fireListChange(Diffs.createListDiff(Diffs.createListDiffEntry(
					index, true, element)));
			return result;
		} finally {
			updating = false;
		}
	}

	public void add(int index, Object element) {
		updating = true;
		try {
			wrappedList.add(index, element);
			setValues();
			fireListChange(Diffs.createListDiff(Diffs.createListDiffEntry(
					index, true, element)));
		} finally {
			updating = false;
		}
	}

	public boolean addAll(Collection c) {
		if (c.isEmpty()) {
			return false;
		}
		updating = true;
		try {
			int index = wrappedList.size();
			boolean result = wrappedList.addAll(c);
			setValues();
			ListDiffEntry[] entries = new ListDiffEntry[c.size()];
			int i = 0;
			for (Iterator it = c.iterator(); it.hasNext();) {
				Object o = it.next();
				entries[i++] = Diffs.createListDiffEntry(index++, true, o);
			}
			fireListChange(Diffs.createListDiff(entries));
			return result;
		} finally {
			updating = false;
		}
	}

	public boolean addAll(int index, Collection c) {
		if (c.isEmpty()) {
			return false;
		}
		updating = true;
		try {
			boolean result = wrappedList.addAll(index, c);
			setValues();
			ListDiffEntry[] entries = new ListDiffEntry[c.size()];
			int i = 0;
			for (Iterator it = c.iterator(); it.hasNext();) {
				Object o = it.next();
				entries[i++] = Diffs.createListDiffEntry(index++, true, o);
			}
			fireListChange(Diffs.createListDiff(entries));
			return result;
		} finally {
			updating = false;
		}
	}

	public boolean remove(Object o) {
		getterCalled();
		int index = wrappedList.indexOf(o);
		if (index == -1) {
			return false;
		}
		updating = true;
		try {
			Object oldElement = wrappedList.remove(index);
			setValues();
			fireListChange(Diffs.createListDiff(Diffs.createListDiffEntry(
					index, false, oldElement)));
			return true;
		} finally {
			updating = false;
		}
	}

	public boolean removeAll(Collection c) {
		getterCalled();
		boolean changed = false;
		updating = true;
		try {
			List diffEntries = new ArrayList();
			for (Iterator it = c.iterator(); it.hasNext();) {
				Object o = it.next();
				int index = wrappedList.indexOf(o);
				if (index != -1) {
					changed = true;
					Object oldElement = wrappedList.remove(index);
					diffEntries.add(Diffs.createListDiffEntry(index, false,
							oldElement));
				}
			}
			if (changed) {
				setValues();
				fireListChange(Diffs
						.createListDiff((ListDiffEntry[]) diffEntries
								.toArray(new ListDiffEntry[diffEntries.size()])));
			}
			return changed;
		} finally {
			updating = false;
		}
	}

	public boolean retainAll(Collection c) {
		getterCalled();
		boolean changed = false;
		updating = true;
		try {
			List diffEntries = new ArrayList();
			int index = 0;
			for (Iterator it = wrappedList.iterator(); it.hasNext();) {
				Object o = it.next();
				boolean retain = c.contains(o);
				if (retain) {
					index++;
				} else {
					changed = true;
					it.remove();
					diffEntries.add(Diffs.createListDiffEntry(index, false, o));
				}
			}
			if (changed) {
				setValues();
				fireListChange(Diffs
						.createListDiff((ListDiffEntry[]) diffEntries
								.toArray(new ListDiffEntry[diffEntries.size()])));
			}
			return changed;
		} finally {
			updating = false;
		}
	}

	public void clear() {
		updating = true;
		try {
			List diffEntries = new ArrayList();
			for (Iterator it = wrappedList.iterator(); it.hasNext();) {
				Object o = it.next();
				diffEntries.add(Diffs.createListDiffEntry(0, false, o));
			}
			wrappedList.clear();
			setValues();
			fireListChange(Diffs.createListDiff((ListDiffEntry[]) diffEntries
					.toArray(new ListDiffEntry[diffEntries.size()])));
		} finally {
			updating = false;
		}
	}

}




/*******************************************************************************
 * 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 221704)
 *     Matthew Hall - bug 223164
 *******************************************************************************/

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

import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.beans.PropertyDescriptor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
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.BindingException;
import org.eclipse.core.databinding.beans.IBeanObservable;
import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.map.ObservableMap;
import org.eclipse.core.internal.databinding.Util;
import org.eclipse.core.runtime.Assert;

/**
 * @since 1.0
 * 
 */
public class JavaBeanPropertyObservableMap extends ObservableMap implements
		IBeanObservable {

	private final Object object;

	private PropertyChangeListener mapListener = new PropertyChangeListener() {
		public void propertyChange(final PropertyChangeEvent event) {
			if (!updating) {
				getRealm().exec(new Runnable() {
					public void run() {
						Map oldValue = wrappedMap;
						Map newValue = (Map) event.getNewValue();
						wrappedMap = new HashMap(newValue);
						
						fireMapChange(Diffs.computeMapDiff(oldValue, newValue));
					}
				});
			}
		}
	};

	private boolean updating = false;

	private PropertyDescriptor descriptor;

	private ListenerSupport collectionListenSupport;

	private boolean attachListeners;

	/**
	 * @param realm
	 * @param object
	 * @param descriptor
	 */
	public JavaBeanPropertyObservableMap(Realm realm, Object object,
			PropertyDescriptor descriptor) {
		this(realm, object, descriptor, true);
	}

	/**
	 * @param realm
	 * @param object
	 * @param descriptor
	 * @param attachListeners
	 */
	public JavaBeanPropertyObservableMap(Realm realm, Object object,
			PropertyDescriptor descriptor, boolean attachListeners) {
		super(realm, new HashMap());
		this.object = object;
		this.descriptor = descriptor;
		this.attachListeners = attachListeners;
		if (attachListeners) {
			this.collectionListenSupport = new ListenerSupport(mapListener,
					descriptor.getName());
		}

		wrappedMap.putAll(getMap());
	}

	protected void firstListenerAdded() {
		if (attachListeners) {
			collectionListenSupport.hookListener(this.object);
		}
	}

	protected void lastListenerRemoved() {
		if (collectionListenSupport != null) {
			collectionListenSupport.dispose();
		}
	}

	private Object primGetMap() {
		try {
			Method readMethod = descriptor.getReadMethod();
			if (!readMethod.isAccessible()) {
				readMethod.setAccessible(true);
			}
			return readMethod.invoke(object, new Object[0]);
		} catch (IllegalArgumentException e) {
		} catch (IllegalAccessException e) {
		} catch (InvocationTargetException e) {
		}
		Assert.isTrue(false, "Could not read collection values"); //$NON-NLS-1$
		return null;
	}

	private void primSetMap(Object newValue) {
		Exception ex = null;
		try {
			Method writeMethod = descriptor.getWriteMethod();
			if (!writeMethod.isAccessible()) {
				writeMethod.setAccessible(true);
			}
			writeMethod.invoke(object, new Object[] { newValue });
			return;
		} catch (IllegalArgumentException e) {
			ex = e;
		} catch (IllegalAccessException e) {
			ex = e;
		} catch (InvocationTargetException e) {
			ex = e;
		}
		throw new BindingException("Could not write collection values", ex); //$NON-NLS-1$
	}

	private Map getMap() {
		Map result = (Map) primGetMap();

		if (result == null)
			result = new HashMap();
		return result;
	}

	private void setMap() {
		primSetMap(new HashMap(wrappedMap));
	}

	public Object put(Object key, Object value) {
		checkRealm();
		updating = true;
		try {
			Object result = wrappedMap.put(key, value);
			if (!Util.equals(result, value)) {
				setMap();
				if (result == null) {
					fireMapChange(Diffs.createMapDiffSingleAdd(key, value));
				} else {
					fireMapChange(Diffs.createMapDiffSingleChange(key, result,
							value));
				}
			}
			return result;
		} finally {
			updating = false;
		}
	}

	public void putAll(Map map) {
		checkRealm();
		updating = true;
		try {
			Set addedKeys = new HashSet(map.size());
			Map changes = new HashMap(map.size());
			for (Iterator it = map.entrySet().iterator(); it.hasNext();) {
				Map.Entry entry = (Entry) it.next();
				Object key = entry.getKey();
				Object newValue = entry.getValue();
				Object oldValue = wrappedMap.put(key, newValue);
				if (oldValue == null) {
					addedKeys.add(key);
				} else if (!Util.equals(oldValue, newValue)) {
					changes.put(key, oldValue);
				}
			}
			if (!addedKeys.isEmpty() || !changes.isEmpty()) {
				setMap();
				fireMapChange(Diffs.createMapDiff(addedKeys,
						Collections.EMPTY_SET, changes.keySet(), changes,
						wrappedMap));
			}
		} finally {
			updating = false;
		}
	}

	public Object remove(Object key) {
		checkRealm();
		updating = true;
		try {
			Object result = wrappedMap.remove(key);
			if (result!=null) {
				setMap();
				fireMapChange(Diffs.createMapDiffSingleRemove(key, result));
			}
			return result;
		} finally {
			updating = false;
		}
	}

	public void clear() {
		checkRealm();
		if (wrappedMap.isEmpty())
			return;
		updating = true;
		try {
			Map oldMap = wrappedMap;
			wrappedMap = new HashMap();
			setMap();
			fireMapChange(Diffs.computeMapDiff(oldMap, Collections.EMPTY_MAP));
		} finally {
			updating = false;
		}
	}

	public Object getObserved() {
		return object;
	}

	public PropertyDescriptor getPropertyDescriptor() {
		return descriptor;
	}
}




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

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

import java.beans.PropertyChangeListener;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Array;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Arrays;
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.BindingException;
import org.eclipse.core.databinding.beans.IBeanObservable;
import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.set.ObservableSet;
import org.eclipse.core.runtime.Assert;

/**
 * @since 1.0
 * 
 */
public class JavaBeanObservableSet extends ObservableSet implements IBeanObservable {

	private final Object object;

	private PropertyChangeListener collectionListener = new PropertyChangeListener() {
		public void propertyChange(java.beans.PropertyChangeEvent event) {
			if (!updating) {
				getRealm().exec(new Runnable() {
					public void run() {
						Set newElements = new HashSet(Arrays
								.asList(getValues()));
						Set addedElements = new HashSet(newElements);
						Set removedElements = new HashSet(wrappedSet);
						// remove all new elements from old elements to compute
						// the removed elements
						removedElements.removeAll(newElements);
						addedElements.removeAll(wrappedSet);
						wrappedSet = newElements;
						fireSetChange(Diffs.createSetDiff(addedElements,
								removedElements));
					}
				});
			}
		}
	};

	private boolean updating = false;

	private PropertyDescriptor descriptor;

	private ListenerSupport collectionListenSupport;

	private boolean attachListeners;

	/**
	 * @param realm
	 * @param object
	 * @param descriptor
	 * @param elementType
	 */
	public JavaBeanObservableSet(Realm realm, Object object,
			PropertyDescriptor descriptor, Class elementType) {
		this(realm, object, descriptor, elementType, true);
	}

	/**
	 * @param realm
	 * @param object
	 * @param descriptor
	 * @param elementType
	 * @param attachListeners
	 */
	public JavaBeanObservableSet(Realm realm, Object object,
			PropertyDescriptor descriptor, Class elementType,
			boolean attachListeners) {
		super(realm, new HashSet(), elementType);
		this.object = object;
		this.descriptor = descriptor;
		this.attachListeners = attachListeners;
		if (attachListeners) {
			this.collectionListenSupport = new ListenerSupport(
					collectionListener, descriptor.getName());
		}

		wrappedSet.addAll(Arrays.asList(getValues()));
	}

	protected void firstListenerAdded() {
		if (attachListeners) {
			collectionListenSupport.hookListener(this.object);
		}
	}

	protected void lastListenerRemoved() {
		if (collectionListenSupport != null) {
			collectionListenSupport.dispose();
		}
	}

	private Object primGetValues() {
		try {
			Method readMethod = descriptor.getReadMethod();
			if (!readMethod.isAccessible()) {
				readMethod.setAccessible(true);
			}
			return readMethod.invoke(object, new Object[0]);
		} catch (IllegalArgumentException e) {
		} catch (IllegalAccessException e) {
		} catch (InvocationTargetException e) {
		}
		Assert.isTrue(false, "Could not read collection values"); //$NON-NLS-1$
		return null;
	}

	private Object[] getValues() {
		Object[] values = null;

		Object result = primGetValues();
		if (descriptor.getPropertyType().isArray())
			values = (Object[]) result;
		else {
			// TODO add jUnit for POJO (var. SettableValue) collections
			Collection list = (Collection) result;
			if (list != null)
				values = list.toArray();
		}
		if (values == null)
			values = new Object[0];
		return values;
	}

	private void setValues() {
		if (descriptor.getPropertyType().isArray()) {
			Class componentType = descriptor.getPropertyType()
					.getComponentType();
			Object[] newArray = (Object[]) Array.newInstance(componentType,
					wrappedSet.size());
			wrappedSet.toArray(newArray);
			primSetValues(newArray);
		} else {
			// assume that it is a java.util.Set
			primSetValues(new HashSet(wrappedSet));
		}
	}

	public boolean add(Object o) {
		getterCalled();
		updating = true;
		try {
			boolean added = wrappedSet.add(o);
			if (added) {
				setValues();
				fireSetChange(Diffs.createSetDiff(Collections.singleton(o),
						Collections.EMPTY_SET));
			}
			return added;
		} finally {
			updating = false;
		}
	}

	public boolean remove(Object o) {
		getterCalled();
		updating = true;
		try {
			boolean removed = wrappedSet.remove(o);
			if (removed) {
				setValues();
				fireSetChange(Diffs.createSetDiff(Collections.EMPTY_SET,
						Collections.singleton(o)));
			}
			return removed;
		} finally {
			updating = false;
		}
	}

	public boolean addAll(Collection c) {
		getterCalled();
		updating = true;
		try {
			Set additions = new HashSet();
			for (Iterator iterator = c.iterator(); iterator.hasNext();) {
				Object element = iterator.next();
				if (wrappedSet.add(element))
					additions.add(element);
			}
			boolean changed = !additions.isEmpty();
			if (changed) {
				setValues();
				fireSetChange(Diffs.createSetDiff(additions,
						Collections.EMPTY_SET));
			}
			return changed;
		} finally {
			updating = false;
		}
	}

	public boolean removeAll(Collection c) {
		getterCalled();
		updating = true;
		try {
			Set removals = new HashSet();
			for (Iterator iterator = c.iterator(); iterator.hasNext();) {
				Object element = iterator.next();
				if (wrappedSet.remove(element))
					removals.add(element);
			}
			boolean changed = !removals.isEmpty();
			if (changed) {
				setValues();
				fireSetChange(Diffs.createSetDiff(Collections.EMPTY_SET,
						removals));
			}
			return changed;
		} finally {
			updating = false;
		}
	}

	public boolean retainAll(Collection c) {
		getterCalled();
		updating = true;
		try {
			Set removals = new HashSet();
			for (Iterator iterator = wrappedSet.iterator(); iterator.hasNext();) {
				Object element = iterator.next();
				if (!c.contains(element)) {
					iterator.remove();
					removals.add(element);
				}
			}
			boolean changed = !removals.isEmpty();
			if (changed) {
				setValues();
				fireSetChange(Diffs.createSetDiff(Collections.EMPTY_SET,
						removals));
			}
			return changed;
		} finally {
			updating = false;
		}
	}

	public void clear() {
		getterCalled();
		if (wrappedSet.isEmpty())
			return;

		updating = true;
		try {
			Set removals = new HashSet(wrappedSet);
			wrappedSet.clear();
			setValues();
			fireSetChange(Diffs.createSetDiff(Collections.EMPTY_SET, removals));
		} finally {
			updating = false;
		}
	}

	private void primSetValues(Object newValue) {
		Exception ex = null;
		try {
			Method writeMethod = descriptor.getWriteMethod();
			if (!writeMethod.isAccessible()) {
				writeMethod.setAccessible(true);
			}
			writeMethod.invoke(object, new Object[] { newValue });
			return;
		} catch (IllegalArgumentException e) {
			ex = e;
		} catch (IllegalAccessException e) {
			ex = e;
		} catch (InvocationTargetException e) {
			ex = e;
		}
		throw new BindingException("Could not write collection values", ex); //$NON-NLS-1$
	}

	public Object getObserved() {
		return object;
	}

	public PropertyDescriptor getPropertyDescriptor() {
		return descriptor;
	}
}




 *
 * Contributors:
 *     Matthew Hall - initial API and implementation (bug 221704)
 *     Matthew Hall - bug 194734
 ******************************************************************************/

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


import org.eclipse.core.databinding.beans.IBeanObservable;
import org.eclipse.core.databinding.observable.IChangeListener;
import org.eclipse.core.databinding.observable.IObserving;
import org.eclipse.core.databinding.observable.IStaleListener;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.map.IMapChangeListener;

 */
public class BeanObservableMapDecorator implements IObservableMap, IBeanObservable {
	private IObservableMap delegate;
	private Object observed;
	private PropertyDescriptor propertyDescriptor;

	/**
	 * @param delegate 
	 * @param observed 
	 * @param propertyDescriptor
	 */
	public BeanObservableMapDecorator(IObservableMap delegate,
			Object observed,
			PropertyDescriptor propertyDescriptor) {
		
		this.delegate = delegate;
		this.observed = observed;
		this.propertyDescriptor = propertyDescriptor;
	}


	}

	public Object getObserved() {
		if (delegate instanceof IObserving)
			return ((IObserving) delegate).getObserved();
		return null;
	}

	public PropertyDescriptor getPropertyDescriptor() {




 *
 * Contributors:
 *     Brad Reynolds - initial API and implementation
 *     Matthew Hall - bug 194734
 ******************************************************************************/

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


import org.eclipse.core.databinding.beans.IBeanObservable;
import org.eclipse.core.databinding.observable.IChangeListener;
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.Realm;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.core.databinding.observable.value.IValueChangeListener;

		IBeanObservable {
	private final IObservableValue delegate;
	private final PropertyDescriptor descriptor;
	private final IObservableValue observed;

	/**
	 * @param delegate
	 * @param observed 
	 * @param descriptor
	 */
	public BeanObservableValueDecorator(IObservableValue delegate,
			PropertyDescriptor descriptor) {
		this.delegate = delegate;
		this.observed = observed;
		this.descriptor = descriptor;
	}


	public void dispose() {
		delegate.dispose();
	}

	public boolean equals(Object obj) {
		if (obj instanceof BeanObservableValueDecorator) {
			BeanObservableValueDecorator other = (BeanObservableValueDecorator) obj;

	}

	public Object getValue() {
		getterCalled();
		return delegate.getValue();
	}

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

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

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

		delegate.setValue(value);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.core.databinding.beans.IBeanObservable#getObserved()
	 */
	public Object getObserved() {
		if (delegate instanceof IObserving)
			return ((IObserving) delegate).getObserved();
		return null;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.core.databinding.beans.IBeanObservable#getPropertyDescriptor()
	 */
	public PropertyDescriptor getPropertyDescriptor() {
		return descriptor;
	}

	/**
	 * @return observable value delegate
	 */




/*******************************************************************************
 * Copyright (c) 2005, 2008 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Brad Reynolds - bug 164653
 *     Brad Reynolds - bug 164134, 171616
 *******************************************************************************/
package org.eclipse.core.internal.databinding.beans;

import java.beans.PropertyChangeListener;
import java.beans.PropertyDescriptor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

import org.eclipse.core.databinding.BindingException;
import org.eclipse.core.databinding.beans.BeansObservables;
import org.eclipse.core.databinding.beans.IBeanObservable;
import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.value.AbstractObservableValue;
import org.eclipse.core.databinding.observable.value.ValueDiff;
import org.eclipse.core.databinding.util.Policy;
import org.eclipse.core.internal.databinding.Util;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;

/**
 * @since 1.0
 * 
 */
public class JavaBeanObservableValue extends AbstractObservableValue implements IBeanObservable {
	private final Object object;
	private boolean updating = false;

	private final PropertyDescriptor propertyDescriptor;
	private ListenerSupport listenerSupport;

	private boolean attachListeners;

	/**
	 * @param realm
	 * @param object
	 * @param descriptor
	 */
	public JavaBeanObservableValue(Realm realm, Object object,
			PropertyDescriptor descriptor) {
		this(realm, object, descriptor, true);
	}

	/**
	 * @param realm
	 * @param object
	 * @param descriptor
	 * @param attachListeners
	 */
	public JavaBeanObservableValue(Realm realm, Object object,
			PropertyDescriptor descriptor, boolean attachListeners) {
		super(realm);
		this.object = object;
		this.propertyDescriptor = descriptor;
		this.attachListeners = attachListeners;
	}

	protected void firstListenerAdded() {
		if (!attachListeners) {
			return;
		}
			
		PropertyChangeListener listener = new PropertyChangeListener() {
			public void propertyChange(java.beans.PropertyChangeEvent event) {
				if (!updating) {
					final ValueDiff diff = Diffs.createValueDiff(event.getOldValue(),
											event.getNewValue());
					getRealm().exec(new Runnable(){
						public void run() {
							fireValueChange(diff);
						}});
				}
			}
		};
		
		if (listenerSupport == null) {
			listenerSupport = new ListenerSupport(listener, propertyDescriptor.getName());
		}
		
		listenerSupport.hookListener(object);
	}

	public void doSetValue(Object value) {
		updating = true;
		try {
			Object oldValue = doGetValue();
			
			if (Util.equals(oldValue, value)) {
				return;
			}
			
			Method writeMethod = propertyDescriptor.getWriteMethod();
			if (!writeMethod.isAccessible()) {
				writeMethod.setAccessible(true);
			}
			writeMethod.invoke(object, new Object[] { value });
			fireValueChange(Diffs.createValueDiff(oldValue, doGetValue()));
		} catch (InvocationTargetException e) {
			/*
			 * InvocationTargetException wraps any exception thrown by the
			 * invoked method.
			 */
			throw new RuntimeException(e.getCause());
		} catch (Exception e) {
			if (BeansObservables.DEBUG) {
				Policy
						.getLog()
						.log(
								new Status(
										IStatus.WARNING,
										Policy.JFACE_DATABINDING,
										IStatus.OK,
										"Could not change value of " + object + "." + propertyDescriptor.getName(), e)); //$NON-NLS-1$ //$NON-NLS-2$
			}
		} finally {
			updating = false;
		}
	}

	public Object doGetValue() {
		try {
			Method readMethod = propertyDescriptor.getReadMethod();
			if (readMethod == null) {
				throw new BindingException(propertyDescriptor.getName()
						+ " property does not have a read method."); //$NON-NLS-1$
			}
			if (!readMethod.isAccessible()) {
				readMethod.setAccessible(true);
			}
			return readMethod.invoke(object, null);
		} catch (InvocationTargetException e) {
			/*
			 * InvocationTargetException wraps any exception thrown by the
			 * invoked method.
			 */
			throw new RuntimeException(e.getCause());
		} catch (Exception e) {
			if (BeansObservables.DEBUG) {
				Policy
						.getLog()
						.log(
								new Status(
										IStatus.WARNING,
										Policy.JFACE_DATABINDING,
										IStatus.OK,
										"Could not read value of " + object + "." + propertyDescriptor.getName(), e)); //$NON-NLS-1$ //$NON-NLS-2$
			}
			return null;
		}
	}

	protected void lastListenerRemoved() {
		unhookListener();
	}

	private void unhookListener() {
		if (listenerSupport != null) {
			listenerSupport.dispose();
			listenerSupport = null;
		}
	}

	public Object getValueType() {
		return propertyDescriptor.getPropertyType();
	}

	public Object getObserved() {
		return object;
	}

	public PropertyDescriptor getPropertyDescriptor() {
		return propertyDescriptor;
	}

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




 *
 * Contributors:
 *     Brad Reynolds - initial API and implementation
 *     Matthew Hall - bugs 208858, 194734
 ******************************************************************************/

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

import java.util.ListIterator;

import org.eclipse.core.databinding.beans.IBeanObservable;
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;

	private IStaleListener delegateStaleListener;
	private IListChangeListener delegateListChangeListener;

	private Object observed;
	private PropertyDescriptor propertyDescriptor;

	/**
	 * @param delegate
	 * @param observed
	 * @param propertyDescriptor
	 */
	public BeanObservableListDecorator(IObservableList delegate,
			PropertyDescriptor propertyDescriptor) {
		super(delegate.getRealm());
		this.delegate = delegate;
		this.observed = observed;
		this.propertyDescriptor = propertyDescriptor;
	}


		return delegate;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.core.databinding.beans.IBeanObservable#getObserved()
	 */
	public Object getObserved() {
		if (delegate instanceof IObserving)
			return ((IObserving) delegate).getObserved();
		return null;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.core.databinding.beans.IBeanObservable#getPropertyDescriptor()
	 */
	public PropertyDescriptor getPropertyDescriptor() {
		return propertyDescriptor;
	}




 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Brad Reynolds - bugs 164268, 171616, 147515
 *     Matthew Hall - bugs 221704, 234686, 194734
 *     Thomas Kratz - bug 213787
 *******************************************************************************/
package org.eclipse.core.databinding.beans;

import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;

import org.eclipse.core.databinding.BindingException;
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.masterdetail.MasterDetailObservables;
import org.eclipse.core.databinding.observable.set.IObservableSet;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.core.databinding.property.IListProperty;
import org.eclipse.core.databinding.property.IMapProperty;
import org.eclipse.core.databinding.property.ISetProperty;
import org.eclipse.core.databinding.property.IValueProperty;
import org.eclipse.core.databinding.property.PropertyObservables;
import org.eclipse.core.internal.databinding.beans.BeanObservableListDecorator;
import org.eclipse.core.internal.databinding.beans.BeanObservableMapDecorator;
import org.eclipse.core.internal.databinding.beans.BeanObservableSetDecorator;
import org.eclipse.core.internal.databinding.beans.BeanObservableValueDecorator;
import org.eclipse.core.internal.databinding.beans.BeanPropertyHelper;
import org.eclipse.core.internal.databinding.beans.JavaBeanObservableMap;
import org.eclipse.core.internal.databinding.beans.JavaBeanObservableSet;
import org.eclipse.core.internal.databinding.beans.JavaBeanObservableValue;
import org.eclipse.core.internal.databinding.beans.JavaBeanPropertyObservableMap;
import org.eclipse.core.runtime.Assert;

/**

	 */
	public static IObservableValue observeValue(Realm realm, Object bean,
			String propertyName) {
		IValueProperty property = BeanProperties.valueProperty(bean.getClass(),
				propertyName);
		PropertyDescriptor propertyDescriptor = ((IBeanProperty) property)
				.getPropertyDescriptor();
		return new BeanObservableValueDecorator(PropertyObservables
				.observeValue(realm, bean, property), propertyDescriptor);
	}

	/**

	 */
	public static IObservableMap observeMap(IObservableSet domain,
			Class beanClass, String propertyName) {
		IValueProperty property = BeanProperties.valueProperty(beanClass,
				propertyName);
		PropertyDescriptor propertyDescriptor = ((IBeanProperty) property)
				.getPropertyDescriptor();
		return new BeanObservableMapDecorator(PropertyObservables.observeMap(
				domain, property), propertyDescriptor);
	}

	/**

	 */
	public static IObservableMap observeMap(Realm realm, Object bean,
			String propertyName) {
		IMapProperty property = BeanProperties.mapProperty(bean.getClass(),
				propertyName);
		PropertyDescriptor propertyDescriptor = ((IBeanProperty) property)
				.getPropertyDescriptor();
		return new BeanObservableMapDecorator(PropertyObservables.observeMap(
				realm, bean, property), propertyDescriptor);
	}

	/**

		return observeMap(Realm.getDefault(), bean, propertyName);
	}

	/*package*/ static PropertyDescriptor getPropertyDescriptor(Class beanClass,
			String propertyName) {
		BeanInfo beanInfo;
		try {
			beanInfo = Introspector.getBeanInfo(beanClass);
		} catch (IntrospectionException e) {
			// cannot introspect, give up
			return null;
		}
		PropertyDescriptor[] propertyDescriptors = beanInfo
				.getPropertyDescriptors();
		for (int i = 0; i < propertyDescriptors.length; i++) {
			PropertyDescriptor descriptor = propertyDescriptors[i];
			if (descriptor.getName().equals(propertyName)) {
				return descriptor;
			}
		}
		throw new BindingException(
				"Could not find property with name " + propertyName + " in class " + beanClass); //$NON-NLS-1$ //$NON-NLS-2$
	}

	/**
	 * Returns an array of observable maps in the default realm tracking the
	 * current values of the named propertys for the beans in the given set.

	 * collection-typed named property of the given bean object. The returned
	 * list is mutable. When an item is added or removed the setter is invoked
	 * for the list on the parent bean to provide notification to other
	 * listeners via <code>PropertyChangeEvents</code>. This is done to provide
	 * the same behavior as is expected from arrays as specified in the bean
	 * spec in section 7.2.
	 * 
	 * @param realm
	 *            the realm

	 * @param propertyName
	 *            the name of the property
	 * @param elementType
	 *            type of the elements in the list. If <code>null</code> and the
	 *            property is an array the type will be inferred. If
	 *            <code>null</code> and the property type cannot be inferred
	 *            element type will be <code>null</code>.
	 * @return an observable list tracking the collection-typed named property

	 */
	public static IObservableList observeList(Realm realm, Object bean,
			String propertyName, Class elementType) {
		IListProperty property = BeanProperties.listProperty(bean.getClass(),
				propertyName, elementType);
		PropertyDescriptor propertyDescriptor = ((IBeanProperty) property)
				.getPropertyDescriptor();
		return new BeanObservableListDecorator(PropertyObservables.observeList(
				realm, bean, property), propertyDescriptor);
	}

	/**


		IObservableValue value = MasterDetailObservables.detailValue(master,
				valueFactory(realm, propertyName), propertyType);
		return new BeanObservableValueDecorator(value, BeanPropertyHelper
				.getValueTypePropertyDescriptor(master, propertyName));
						propertyName));

		return decorator;
	}

	/**

	/**
	 * Helper method for
	 * <code>MasterDetailObservables.detailValue(master, valueFactory(realm,
	 * propertyName), propertyType)</code>. This method returns an
	 * {@link IBeanObservable} with a {@link PropertyDescriptor} based on the
	 * given master type and property name.
	 * name.
	 * 
	 * @param realm
	 *            the realm

	 * @since 1.1
	 */
	public static IObservableValue observeDetailValue(Realm realm,
			IObservableValue master, Class masterType, String propertyName,
			Class propertyType) {
		Assert.isNotNull(masterType, "masterType cannot be null"); //$NON-NLS-1$
		IObservableValue value = MasterDetailObservables.detailValue(master,
				valueFactory(realm, propertyName), propertyType);
		return new BeanObservableValueDecorator(value, BeanPropertyHelper
				.getPropertyDescriptor(masterType, propertyName));
						propertyName));

		return decorator;
	}

	/**

		IObservableList observableList = MasterDetailObservables.detailList(
				master, listFactory(realm, propertyName, propertyType),
				propertyType);
		return new BeanObservableListDecorator(observableList,
				BeanPropertyHelper.getValueTypePropertyDescriptor(master,
						propertyName));

		return decorator;
	}

	/**

		IObservableSet observableSet = MasterDetailObservables.detailSet(
				master, setFactory(realm, propertyName, propertyType),
				propertyType);
		return new BeanObservableSetDecorator(observableSet, BeanPropertyHelper
				.getValueTypePropertyDescriptor(master, propertyName));
						propertyName));

		return decorator;
	}

	/**

			IObservableValue master, String propertyName) {
		IObservableMap observableMap = MasterDetailObservables.detailMap(
				master, mapPropertyFactory(realm, propertyName));
		return new BeanObservableMapDecorator(observableMap, BeanPropertyHelper
				.getValueTypePropertyDescriptor(master, propertyName));
						propertyName));
		return decorator;
	}

	/**

	 */
	public static IObservableSet observeSet(Realm realm, Object bean,
			String propertyName, Class elementType) {
		ISetProperty property = BeanProperties.setProperty(bean.getClass(),
				propertyName, elementType);
		PropertyDescriptor propertyDescriptor = ((IBeanProperty) property)
				.getPropertyDescriptor();
		return new BeanObservableSetDecorator(PropertyObservables.observeSet(
				realm, bean, property), propertyDescriptor);
	}

	/**

	 * @param propertyName
	 *            the name of the property
	 * @return a factory for creating {@link IObservableMap} objects
	 * 
	 * @since 1.1
	 */
	public static IObservableFactory setToMapFactory(final Class beanClass,
			final String propertyName) {
		return new IObservableFactory() {
			public IObservable createObservable(Object target) {
				return observeMap((IObservableSet) target, beanClass,
						propertyName);
			}
		};
	}

	/**
	 * Returns a factory for creating an observable map. The factory, when
	 * provided with a bean object, will create an {@link IObservableMap} in the

	public static IObservableFactory mapPropertyFactory(String propertyName) {
		return mapPropertyFactory(Realm.getDefault(), propertyName);
	}

	/**
	 * @param elementType
	 *            can be <code>null</code>
	 * @param propertyDescriptor
	 * @return type of the items in a collection/array property
	 */
	/*package*/ static Class getCollectionElementType(Class elementType,
			PropertyDescriptor propertyDescriptor) {
		if (elementType == null) {
			Class propertyType = propertyDescriptor.getPropertyType();
			elementType = propertyType.isArray() ? propertyType
					.getComponentType() : Object.class;
		}

		return elementType;
	}

	/**
	 * @param observable
	 * @param propertyName
	 * @return property descriptor or <code>null</code>
	 */
	/* package*/ static PropertyDescriptor getValueTypePropertyDescriptor(
			IObservableValue observable, String propertyName) {
		return (observable.getValueType() != null) ? getPropertyDescriptor(
				(Class) observable.getValueType(), propertyName) : null;
	}
}




 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Matthew Hall - bugs 221704, 234686, 194734
 *******************************************************************************/

package org.eclipse.core.databinding.beans;

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.IListProperty;
import org.eclipse.core.databinding.property.IMapProperty;
import org.eclipse.core.databinding.property.ISetProperty;
import org.eclipse.core.databinding.property.IValueProperty;
import org.eclipse.core.databinding.property.PropertyObservables;
import org.eclipse.core.internal.databinding.beans.BeanObservableListDecorator;
import org.eclipse.core.internal.databinding.beans.BeanObservableMapDecorator;
import org.eclipse.core.internal.databinding.beans.BeanObservableSetDecorator;
import org.eclipse.core.internal.databinding.beans.BeanObservableValueDecorator;
import org.eclipse.core.internal.databinding.beans.BeanPropertyHelper;
import org.eclipse.core.internal.databinding.beans.JavaBeanObservableMap;
import org.eclipse.core.internal.databinding.beans.JavaBeanObservableSet;
import org.eclipse.core.internal.databinding.beans.JavaBeanObservableValue;
import org.eclipse.core.internal.databinding.beans.JavaBeanPropertyObservableMap;

/**
 * A factory for creating observable objects for POJOs (plain old java objects)

	 */
	public static IObservableValue observeValue(Realm realm, Object pojo,
			String propertyName) {
		IValueProperty property = PojoProperties.valueProperty(pojo.getClass(),
				propertyName);
		PropertyDescriptor propertyDescriptor = ((IBeanProperty) property)
				.getPropertyDescriptor();
		return new BeanObservableValueDecorator(PropertyObservables
				.observeValue(realm, pojo, property), propertyDescriptor);
	}

	/**

	 */
	public static IObservableMap observeMap(IObservableSet domain,
			Class pojoClass, String propertyName) {
		IValueProperty property = PojoProperties.valueProperty(pojoClass,
				propertyName);
		PropertyDescriptor propertyDescriptor = ((IBeanProperty) property)
				.getPropertyDescriptor();
		return new BeanObservableMapDecorator(PropertyObservables.observeMap(
				domain, property), propertyDescriptor);
	}

	/**

	 */
	public static IObservableMap observeMap(Realm realm, Object pojo,
			String propertyName) {
		IMapProperty property = PojoProperties.mapProperty(pojo.getClass(),
				propertyName);
		PropertyDescriptor propertyDescriptor = ((IBeanProperty) property)
				.getPropertyDescriptor();
		return new BeanObservableMapDecorator(PropertyObservables.observeMap(
				realm, pojo, property), propertyDescriptor);
	}

	/**

	 * collection-typed named property of the given bean object. The returned
	 * list is mutable. When an item is added or removed the setter is invoked
	 * for the list on the parent bean to provide notification to other
	 * listeners via <code>PropertyChangeEvents</code>. This is done to provide
	 * the same behavior as is expected from arrays as specified in the bean
	 * spec in section 7.2.
	 * 
	 * @param realm
	 *            the realm

	 * @param propertyName
	 *            the name of the property
	 * @param elementType
	 *            type of the elements in the list. If <code>null</code> and the
	 *            property is an array the type will be inferred. If
	 *            <code>null</code> and the property type cannot be inferred
	 *            element type will be <code>null</code>.
	 * @return an observable list tracking the collection-typed named property

	 */
	public static IObservableList observeList(Realm realm, Object pojo,
			String propertyName, Class elementType) {
		IListProperty property = PojoProperties.listProperty(pojo.getClass(),
				propertyName, elementType);
		PropertyDescriptor propertyDescriptor = ((IBeanProperty) property)
				.getPropertyDescriptor();
		return new BeanObservableListDecorator(PropertyObservables.observeList(
				realm, pojo, property), propertyDescriptor);
				elementType, false);
	}

	/**

	 */
	public static IObservableSet observeSet(Realm realm, Object pojo,
			String propertyName, Class elementType) {
		ISetProperty property = PojoProperties.setProperty(pojo.getClass(),
				propertyName, elementType);
		PropertyDescriptor propertyDescriptor = ((IBeanProperty) property)
				.getPropertyDescriptor();
		return new BeanObservableSetDecorator(PropertyObservables.observeSet(
				realm, pojo, property), propertyDescriptor);
				elementType, false);
	}

	/**


		IObservableValue value = MasterDetailObservables.detailValue(master,
				valueFactory(realm, propertyName), propertyType);
		return new BeanObservableValueDecorator(value, BeanPropertyHelper
				.getValueTypePropertyDescriptor(master, propertyName));
						master, propertyName));

		return decorator;
	}

	/**

		IObservableList observableList = MasterDetailObservables.detailList(
				master, listFactory(realm, propertyName, propertyType),
				propertyType);
		return new BeanObservableListDecorator(observableList,
				BeanPropertyHelper.getValueTypePropertyDescriptor(master,
						propertyName));

		return decorator;
	}

	/**

		IObservableSet observableSet = MasterDetailObservables.detailSet(
				master, setFactory(realm, propertyName, propertyType),
				propertyType);
		return new BeanObservableSetDecorator(observableSet, BeanPropertyHelper
				.getValueTypePropertyDescriptor(master, propertyName));
						.getValueTypePropertyDescriptor(master, propertyName));

		return decorator;
	}

	/**

			IObservableValue master, String propertyName) {
		IObservableMap observableMap = MasterDetailObservables.detailMap(
				master, mapPropertyFactory(realm, propertyName));
		return new BeanObservableMapDecorator(observableMap, BeanPropertyHelper
				.getValueTypePropertyDescriptor(master, propertyName));
						.getValueTypePropertyDescriptor(master, propertyName));
		return decorator;
	}

	/**




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

import java.beans.PropertyDescriptor;

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

/**
 * @since 1.2
 * 
 */
public interface IBeanProperty extends IProperty {
	/**
	 * @return property descriptor for the bean property
	 */
	public PropertyDescriptor getPropertyDescriptor();
}




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

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

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

	boolean isUpdating(Object source) {
		Map map = (Map) localMap.get();
		return map.containsKey(source);
	}

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

	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.internal.databinding.beans;

import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.beans.PropertyDescriptor;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

import org.eclipse.core.databinding.beans.IBeanProperty;
import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.property.MapProperty;
import org.eclipse.core.internal.databinding.Util;

/**
 * @since 3.3
 * 
 */
public class BeanMapProperty extends MapProperty implements IBeanProperty {
	private PropertyDescriptor propertyDescriptor;
	private boolean attachListener;

	private ListenerSupport listenerSupport;

	private PropertyUpdateHelper updateHelper = new PropertyUpdateHelper();

	private Map sourceToCachedMap = Collections.synchronizedMap(new HashMap());

	/**
	 * @param propertyDescriptor
	 * @param attachListener
	 */
	public BeanMapProperty(PropertyDescriptor propertyDescriptor,
			boolean attachListener) {
		this.propertyDescriptor = propertyDescriptor;
		this.attachListener = attachListener;
	}

	private void initListenerSupport() {
		if (listenerSupport == null) {
			synchronized (this) {
				if (listenerSupport == null) {
					PropertyChangeListener propertyChangeListener = new PropertyChangeListener() {
						public void propertyChange(PropertyChangeEvent evt) {
							Object source = evt.getSource();
							if (!updateHelper.isUpdating(source)) {
								Object oldValue = evt.getOldValue();
								Object newValue = evt.getNewValue();
								if (oldValue == null && newValue == null) {
									// Obscure condition indicating new and old
									// values are unknown
									oldValue = sourceToCachedMap.get(source);
									newValue = BeanPropertyHelper.getProperty(
											source, propertyDescriptor);
								}
								sourceToCachedMap.put(source, newValue);
								fireMapChange(source, Diffs.computeMapDiff(
										asMap(oldValue), asMap(newValue)));
							}
						}
					};
					listenerSupport = new ListenerSupport(
							propertyChangeListener, propertyDescriptor
									.getName());
				}
			}
		}
	}

	protected void addListenerTo(Object source) {
		if (source != null && attachListener) {
			initListenerSupport();
			listenerSupport.hookListener(source);
			sourceToCachedMap.put(source, BeanPropertyHelper.getProperty(
					source, propertyDescriptor));
		}
	}

	protected void removeListenerFrom(Object source) {
		if (source != null && attachListener && listenerSupport != null) {
			listenerSupport.unhookListener(source);
			sourceToCachedMap.remove(source);
		}
	}

	public Map getMap(Object source) {
		if (source == null)
			return Collections.EMPTY_MAP;
		Object propertyValue = BeanPropertyHelper.getProperty(source,
				propertyDescriptor);
		return asMap(propertyValue);
	}

	private Map asMap(Object propertyValue) {
		if (propertyValue == null)
			return new HashMap();
		return (Map) propertyValue;
	}

	private void setMap(Object source, Map map) {
		if (source == null)
			return;

		Map oldMap = getMap(source);

		updateHelper.setUpdating(source, true);
		try {
			BeanPropertyHelper.setProperty(source, propertyDescriptor, map);
		} finally {
			updateHelper.setUpdating(source, false);
		}

		if (hasListeners(source)) {
			Map newMap = getMap(source);
			if (!Util.equals(oldMap, newMap)) {
				sourceToCachedMap.put(source, newMap);
				fireMapChange(source, Diffs.computeMapDiff(oldMap, newMap));
			}
		}
	}

	public void clear(Object source) {
		setMap(source, new HashMap());
	}

	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 Object put(Object source, Object key, Object value) {
		Map map = new HashMap(getMap(source));
		Object result = map.put(key, value);
		setMap(source, map);
		return result;
	}

	public void putAll(Object source, Map t) {
		Map map = new HashMap(getMap(source));
		map.putAll(t);
		setMap(source, map);
	}

	public Object remove(Object source, Object key) {
		Map map = new HashMap(getMap(source));
		Object result = map.remove(key);
		setMap(source, map);
		return result;
	}

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

	public synchronized void dispose() {
		propertyDescriptor = null;
		attachListener = false;
		if (listenerSupport != null) {
			listenerSupport.dispose();
			listenerSupport = null;
		}
		if (updateHelper != null) {
			updateHelper.dispose();
			updateHelper = null;
		}
		if (sourceToCachedMap != null) {
			sourceToCachedMap.clear();
			sourceToCachedMap = null;
		}
		super.dispose();
	}

	public PropertyDescriptor getPropertyDescriptor() {
		return propertyDescriptor;
	}
}




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

import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.beans.PropertyDescriptor;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

import org.eclipse.core.databinding.beans.IBeanProperty;
import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.property.ValueProperty;
import org.eclipse.core.internal.databinding.Util;

/**
 * @since 3.3
 * 
 */
public class BeanValueProperty extends ValueProperty implements IBeanProperty {
	private PropertyDescriptor propertyDescriptor;
	private Class valueType;
	private boolean attachListener;

	private ListenerSupport listenerSupport;

	private PropertyUpdateHelper updateHelper = new PropertyUpdateHelper();

	private Map sourceToCachedValue = Collections
			.synchronizedMap(new HashMap());

	/**
	 * @param propertyDescriptor
	 * @param valueType
	 * @param attachListener
	 */
	public BeanValueProperty(PropertyDescriptor propertyDescriptor,
			Class valueType, boolean attachListener) {
		this.propertyDescriptor = propertyDescriptor;
		this.valueType = valueType == null ? propertyDescriptor
				.getPropertyType() : valueType;
		this.attachListener = attachListener;
	}

	private void initListenerSupport() {
		if (listenerSupport == null) {
			synchronized (this) {
				if (listenerSupport == null) {
					PropertyChangeListener propertyChangeListener = new PropertyChangeListener() {
						public void propertyChange(PropertyChangeEvent evt) {
							Object source = evt.getSource();
							if (!updateHelper.isUpdating(source)) {
								Object oldValue = evt.getOldValue();
								Object newValue = evt.getNewValue();
								if (oldValue == null && newValue == null) {
									// Obscure condition indicating new and old
									// values are unknown
									oldValue = sourceToCachedValue.get(source);
									newValue = getValue(source);
								}
								sourceToCachedValue.put(source, newValue);
								fireValueChange(source, Diffs.createValueDiff(
										oldValue, newValue));
							}
						}
					};
					listenerSupport = new ListenerSupport(
							propertyChangeListener, propertyDescriptor
									.getName());
				}
			}
		}
	}

	protected void addListenerTo(Object source) {
		if (source != null && attachListener) {
			initListenerSupport();
			listenerSupport.hookListener(source);
			sourceToCachedValue.put(source, getValue(source));
		}
	}

	protected void removeListenerFrom(Object source) {
		if (source != null && attachListener && listenerSupport != null) {
			listenerSupport.unhookListener(source);
			sourceToCachedValue.remove(source);
		}
	}

	public Object getValue(Object source) {
		if (source == null)
			return null;
		return BeanPropertyHelper.getProperty(source, propertyDescriptor);
	}

	public void setValue(Object source, Object value) {
		if (source == null)
			return;

		Object oldValue = getValue(source);

		updateHelper.setUpdating(source, true);
		try {
			BeanPropertyHelper.setProperty(source, propertyDescriptor, value);
		} finally {
			updateHelper.setUpdating(source, false);
		}

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

	public Object getValueType() {
		return valueType;
	}

	public PropertyDescriptor getPropertyDescriptor() {
		return propertyDescriptor;
	}

	public synchronized void dispose() {
		propertyDescriptor = null;
		valueType = null;
		attachListener = false;
		if (listenerSupport != null) {
			listenerSupport.dispose();
			listenerSupport = null;
		}
		if (updateHelper != null) {
			updateHelper.dispose();
			updateHelper = null;
		}
		if (sourceToCachedValue != null) {
			sourceToCachedValue.clear();
			sourceToCachedValue = 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.beans;

import org.eclipse.core.databinding.property.IListProperty;
import org.eclipse.core.databinding.property.IMapProperty;
import org.eclipse.core.databinding.property.ISetProperty;
import org.eclipse.core.databinding.property.IValueProperty;
import org.eclipse.core.internal.databinding.beans.BeanListProperty;
import org.eclipse.core.internal.databinding.beans.BeanMapProperty;
import org.eclipse.core.internal.databinding.beans.BeanPropertyHelper;
import org.eclipse.core.internal.databinding.beans.BeanSetProperty;
import org.eclipse.core.internal.databinding.beans.BeanValueProperty;

/**
 * @since 1.2
 */
public class PojoProperties {
	/**
	 * @param beanClass
	 * @param propertyName
	 * @return a value property for the given property name of the given bean
	 *         class.
	 */
	public static IValueProperty valueProperty(Class beanClass,
			String propertyName) {
		return valueProperty(beanClass, propertyName, null);
	}

	/**
	 * @param beanClass
	 * @param propertyName
	 * @param valueType
	 * @return a value property for the given property name of the given bean
	 *         class.
	 */
	public static IValueProperty valueProperty(Class beanClass,
			String propertyName, Class valueType) {
		return new BeanValueProperty(BeanPropertyHelper.getPropertyDescriptor(
				beanClass, propertyName), valueType, false);
	}

	/**
	 * @param beanClass
	 * @param propertyName
	 * @return a list property for the given property name of the given bean
	 *         class.
	 */
	public static ISetProperty setProperty(Class beanClass, String propertyName) {
		return setProperty(beanClass, propertyName, null);
	}

	/**
	 * @param beanClass
	 * @param propertyName
	 * @param elementType
	 * @return a list property for the given property name of the given bean
	 *         class.
	 */
	public static ISetProperty setProperty(Class beanClass,
			String propertyName, Class elementType) {
		return new BeanSetProperty(BeanPropertyHelper.getPropertyDescriptor(
				beanClass, propertyName), elementType, false);
	}

	/**
	 * @param beanClass
	 * @param propertyName
	 * @return a list property for the given property name of the given bean
	 *         class.
	 */
	public static IListProperty listProperty(Class beanClass,
			String propertyName) {
		return listProperty(beanClass, propertyName, null);
	}

	/**
	 * @param beanClass
	 * @param propertyName
	 * @param elementType
	 * @return a list property for the given property name of the given bean
	 *         class.
	 */
	public static IListProperty listProperty(Class beanClass,
			String propertyName, Class elementType) {
		return new BeanListProperty(BeanPropertyHelper.getPropertyDescriptor(
				beanClass, propertyName), elementType, false);
	}

	/**
	 * @param beanClass
	 * @param propertyName
	 * @return a map property for the given property name of the given bean
	 *         class.
	 */
	public static IMapProperty mapProperty(Class beanClass, String propertyName) {
		return new BeanMapProperty(BeanPropertyHelper.getPropertyDescriptor(
				beanClass, propertyName), false);
	}
}




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

import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.eclipse.core.databinding.beans.IBeanProperty;
import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.property.ListProperty;
import org.eclipse.core.internal.databinding.Util;

/**
 * @since 3.3
 * 
 */
public class BeanListProperty extends ListProperty implements IBeanProperty {
	private PropertyDescriptor propertyDescriptor;
	private Class elementType;
	private boolean attachListener;

	private ListenerSupport listenerSupport;

	private PropertyUpdateHelper updateHelper = new PropertyUpdateHelper();

	private Map sourceToCachedList = Collections.synchronizedMap(new HashMap());

	/**
	 * @param propertyDescriptor
	 * @param elementType
	 * @param attachListener
	 */
	public BeanListProperty(PropertyDescriptor propertyDescriptor,
			Class elementType, boolean attachListener) {
		this.propertyDescriptor = propertyDescriptor;
		this.elementType = elementType == null ? BeanPropertyHelper
				.getCollectionPropertyElementType(propertyDescriptor)
				: elementType;
		this.attachListener = attachListener;
	}

	private void initListenerSupport() {
		if (listenerSupport == null) {
			synchronized (this) {
				if (listenerSupport == null) {
					PropertyChangeListener propertyChangeListener = new PropertyChangeListener() {
						public void propertyChange(PropertyChangeEvent evt) {
							Object source = evt.getSource();
							if (!updateHelper.isUpdating(source)) {
								Object oldValue = evt.getOldValue();
								Object newValue = evt.getNewValue();
								if (oldValue == null && newValue == null) {
									// Obscure condition indicating new and old
									// values are unknown
									oldValue = sourceToCachedList.get(source);
									newValue = BeanPropertyHelper.getProperty(
											source, propertyDescriptor);
								}
								sourceToCachedList.put(source, newValue);
								fireListChange(source, Diffs.computeListDiff(
										asList(oldValue), asList(newValue)));
							}
						}
					};
					listenerSupport = new ListenerSupport(
							propertyChangeListener, propertyDescriptor
									.getName());
				}
			}
		}
	}

	protected void addListenerTo(Object source) {
		if (source != null && attachListener) {
			initListenerSupport();
			listenerSupport.hookListener(source);
			sourceToCachedList.put(source, BeanPropertyHelper.getProperty(
					source, propertyDescriptor));
		}
	}

	protected void removeListenerFrom(Object source) {
		if (source != null && attachListener && listenerSupport != null) {
			listenerSupport.unhookListener(source);
			sourceToCachedList.remove(source);
		}
	}

	public List getList(Object source) {
		if (source == null)
			return Collections.EMPTY_LIST;
		Object propertyValue = BeanPropertyHelper.getProperty(source,
				propertyDescriptor);
		return asList(propertyValue);
	}

	private List asList(Object propertyValue) {
		if (propertyValue == null)
			return new ArrayList();
		if (propertyDescriptor.getPropertyType().isArray())
			return new ArrayList(Arrays.asList((Object[]) propertyValue));
		return (List) propertyValue;
	}

	private void setList(Object source, List list) {
		if (source == null)
			return;

		List oldList = getList(source);

		updateHelper.setUpdating(source, true);
		try {
			BeanPropertyHelper.setProperty(source, propertyDescriptor,
					convertListToBeanPropertyType(list));
		} finally {
			updateHelper.setUpdating(source, false);
		}

		if (hasListeners(source)) {
			List newList = getList(source);
			if (!Util.equals(oldList, newList)) {
				sourceToCachedList.put(source, newList);
				fireListChange(source, Diffs.computeListDiff(oldList, newList));
			}
		}
	}

	private Object convertListToBeanPropertyType(List list) {
		Object propertyValue = list;
		if (propertyDescriptor.getPropertyType().isArray()) {
			Class componentType = propertyDescriptor.getPropertyType()
					.getComponentType();
			Object[] array = (Object[]) Array.newInstance(componentType, list
					.size());
			list.toArray(array);
			propertyValue = array;
		}
		return propertyValue;
	}

	public boolean add(Object source, Object o) {
		List list = new ArrayList(getList(source));
		boolean result = list.add(o);
		setList(source, list);
		return result;
	}

	public boolean addAll(Object source, Collection c) {
		List list = new ArrayList(getList(source));
		list.addAll(c);
		setList(source, list);
		return true;
	}

	public void clear(Object source) {
		setList(source, new ArrayList());
	}

	public boolean remove(Object source, Object o) {
		List list = new ArrayList(getList(source));
		boolean removed = list.remove(o);
		if (removed) {
			setList(source, list);
		}
		return removed;
	}

	public boolean removeAll(Object source, Collection c) {
		List list = new ArrayList(getList(source));
		boolean changed = list.removeAll(c);
		if (changed) {
			setList(source, list);
		}
		return changed;
	}

	public boolean retainAll(Object source, Collection c) {
		List list = new ArrayList(getList(source));
		boolean changed = list.retainAll(c);
		if (changed) {
			setList(source, list);
		}
		return changed;
	}

	public void add(Object source, int index, Object element) {
		List list = new ArrayList(getList(source));
		list.add(index, element);
		setList(source, list);
	}

	public boolean addAll(Object source, int index, Collection c) {
		List list = new ArrayList(getList(source));
		boolean changed = list.addAll(index, c);
		setList(source, list);
		return changed;
	}

	public Object remove(Object source, int index) {
		List list = new ArrayList(getList(source));
		Object result = list.remove(index);
		setList(source, list);
		return result;
	}

	public Object set(Object source, int index, Object element) {
		List list = new ArrayList(getList(source));
		Object result = list.set(index, element);
		setList(source, list);
		return result;
	}

	public Object move(Object source, int oldIndex, int newIndex) {
		List list = new ArrayList(getList(source));
		Object result = list.remove(oldIndex);
		list.add(newIndex, result);
		setList(source, list);
		return result;
	}

	public Object getElementType() {
		return elementType;
	}

	public PropertyDescriptor getPropertyDescriptor() {
		return propertyDescriptor;
	}

	public synchronized void dispose() {
		propertyDescriptor = null;
		elementType = null;
		attachListener = false;
		if (listenerSupport != null) {
			listenerSupport.dispose();
			listenerSupport = null;
		}
		if (updateHelper != null) {
			updateHelper.dispose();
			updateHelper = null;
		}
		if (sourceToCachedList != null) {
			sourceToCachedList.clear();
			sourceToCachedList = 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.beans;

import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import org.eclipse.core.databinding.beans.IBeanProperty;
import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.property.SetProperty;
import org.eclipse.core.internal.databinding.Util;

/**
 * @since 3.3
 * 
 */
public class BeanSetProperty extends SetProperty implements IBeanProperty {
	private PropertyDescriptor propertyDescriptor;
	private Class elementType;
	private boolean attachListener;

	private ListenerSupport listenerSupport;

	private PropertyUpdateHelper updateHelper = new PropertyUpdateHelper();

	private Map sourceToCachedSet = Collections.synchronizedMap(new HashMap());

	/**
	 * @param propertyDescriptor
	 * @param elementType
	 * @param attachListener
	 */
	public BeanSetProperty(PropertyDescriptor propertyDescriptor,
			Class elementType, boolean attachListener) {
		this.propertyDescriptor = propertyDescriptor;
		this.elementType = elementType == null ? BeanPropertyHelper
				.getCollectionPropertyElementType(propertyDescriptor)
				: elementType;
		this.attachListener = attachListener;
	}

	private void initListenerSupport() {
		if (listenerSupport == null) {
			synchronized (this) {
				if (listenerSupport == null) {
					PropertyChangeListener propertyChangeListener = new PropertyChangeListener() {
						public void propertyChange(PropertyChangeEvent evt) {
							Object source = evt.getSource();
							if (!updateHelper.isUpdating(source)) {
								Object oldValue = evt.getOldValue();
								Object newValue = evt.getNewValue();
								if (oldValue == null && newValue == null) {
									// Obscure condition indicating new and old
									// values are unknown
									oldValue = sourceToCachedSet.get(source);
									newValue = BeanPropertyHelper.getProperty(
											source, propertyDescriptor);
								}
								sourceToCachedSet.put(source, newValue);
								fireSetChange(source, Diffs.computeSetDiff(
										asSet(oldValue), asSet(newValue)));
							}
						}
					};
					listenerSupport = new ListenerSupport(
							propertyChangeListener, propertyDescriptor
									.getName());
				}
			}
		}
	}

	protected void addListenerTo(Object source) {
		if (source != null && attachListener) {
			initListenerSupport();
			listenerSupport.hookListener(source);
			sourceToCachedSet.put(source, BeanPropertyHelper.getProperty(
					source, propertyDescriptor));
		}
	}

	protected void removeListenerFrom(Object source) {
		if (source != null && attachListener && listenerSupport != null) {
			listenerSupport.unhookListener(source);
			sourceToCachedSet.remove(source);
		}
	}

	public Set getSet(Object source) {
		if (source == null)
			return Collections.EMPTY_SET;
		Object propertyValue = BeanPropertyHelper.getProperty(source,
				propertyDescriptor);
		return asSet(propertyValue);
	}

	private Set asSet(Object propertyValue) {
		if (propertyValue == null)
			return Collections.EMPTY_SET;
		if (propertyDescriptor.getPropertyType().isArray())
			return new HashSet(Arrays.asList((Object[]) propertyValue));
		return (Set) propertyValue;
	}

	private void setSet(Object source, Set set) {
		if (source == null)
			return;

		Set oldSet = getSet(source);

		updateHelper.setUpdating(source, true);
		try {
			BeanPropertyHelper.setProperty(source, propertyDescriptor,
					convertSetToBeanPropertyType(set));
		} finally {
			updateHelper.setUpdating(source, false);
		}

		if (hasListeners(source)) {
			Set newSet = new HashSet(getSet(source));
			if (!Util.equals(oldSet, newSet)) {
				sourceToCachedSet.put(source, newSet);
				fireSetChange(source, Diffs.computeSetDiff(oldSet, newSet));
			}
		}
	}

	private Object convertSetToBeanPropertyType(Set set) {
		Object propertyValue = set;
		if (propertyDescriptor.getPropertyType().isArray()) {
			Class componentType = propertyDescriptor.getPropertyType()
					.getComponentType();
			Object[] array = (Object[]) Array.newInstance(componentType, set
					.size());
			set.toArray(array);
			propertyValue = array;
		}
		return propertyValue;
	}

	public boolean add(Object source, Object o) {
		Set set = new HashSet(getSet(source));
		boolean result = set.add(o);
		setSet(source, set);
		return result;
	}

	public boolean addAll(Object source, Collection c) {
		Set set = new HashSet(getSet(source));
		boolean changed = set.addAll(c);
		if (changed) {
			setSet(source, set);
		}
		return changed;
	}

	public void clear(Object source) {
		setSet(source, new HashSet());
	}

	public boolean remove(Object source, Object o) {
		Set set = new HashSet(getSet(source));
		boolean removed = set.remove(o);
		if (removed) {
			setSet(source, set);
		}
		return removed;
	}

	public boolean removeAll(Object source, Collection c) {
		Set set = new HashSet(getSet(source));
		boolean changed = set.removeAll(c);
		if (changed) {
			setSet(source, set);
		}
		return changed;
	}

	public boolean retainAll(Object source, Collection c) {
		Set set = new HashSet(getSet(source));
		boolean changed = set.retainAll(c);
		if (changed) {
			setSet(source, set);
		}
		return changed;
	}

	public Object getElementType() {
		return elementType;
	}

	public PropertyDescriptor getPropertyDescriptor() {
		return propertyDescriptor;
	}

	public synchronized void dispose() {
		propertyDescriptor = null;
		elementType = null;
		attachListener = false;
		if (listenerSupport != null) {
			listenerSupport.dispose();
			listenerSupport = null;
		}
		if (updateHelper != null) {
			updateHelper.dispose();
			updateHelper = null;
		}
		if (sourceToCachedSet != null) {
			sourceToCachedSet.clear();
			sourceToCachedSet = 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.beans;

import org.eclipse.core.databinding.property.IListProperty;
import org.eclipse.core.databinding.property.IMapProperty;
import org.eclipse.core.databinding.property.ISetProperty;
import org.eclipse.core.databinding.property.IValueProperty;
import org.eclipse.core.internal.databinding.beans.BeanListProperty;
import org.eclipse.core.internal.databinding.beans.BeanMapProperty;
import org.eclipse.core.internal.databinding.beans.BeanPropertyHelper;
import org.eclipse.core.internal.databinding.beans.BeanSetProperty;
import org.eclipse.core.internal.databinding.beans.BeanValueProperty;

/**
 * @since 1.2
 * 
 */
public class BeanProperties {
	/**
	 * @param beanClass
	 * @param propertyName
	 * @return a value property for the given property name of the given bean
	 *         class.
	 */
	public static IValueProperty valueProperty(Class beanClass,
			String propertyName) {
		return valueProperty(beanClass, propertyName, null);
	}

	/**
	 * @param beanClass
	 * @param propertyName
	 * @param valueType
	 * @return a value property for the given property name of the given bean
	 *         class.
	 */
	public static IValueProperty valueProperty(Class beanClass,
			String propertyName, Class valueType) {
		return new BeanValueProperty(BeanPropertyHelper.getPropertyDescriptor(
				beanClass, propertyName), valueType, true);
	}

	/**
	 * @param beanClass
	 * @param propertyName
	 * @return a list property for the given property name of the given bean
	 *         class.
	 */
	public static ISetProperty setProperty(Class beanClass, String propertyName) {
		return setProperty(beanClass, propertyName, null);
	}

	/**
	 * @param beanClass
	 * @param propertyName
	 * @param elementType
	 * @return a list property for the given property name of the given bean
	 *         class.
	 */
	public static ISetProperty setProperty(Class beanClass,
			String propertyName, Class elementType) {
		return new BeanSetProperty(BeanPropertyHelper.getPropertyDescriptor(
				beanClass, propertyName), elementType, true);
	}

	/**
	 * @param beanClass
	 * @param propertyName
	 * @return a list property for the given property name of the given bean
	 *         class.
	 */
	public static IListProperty listProperty(Class beanClass,
			String propertyName) {
		return listProperty(beanClass, propertyName, null);
	}

	/**
	 * @param beanClass
	 * @param propertyName
	 * @param elementType
	 * @return a list property for the given property name of the given bean
	 *         class.
	 */
	public static IListProperty listProperty(Class beanClass,
			String propertyName, Class elementType) {
		return new BeanListProperty(BeanPropertyHelper.getPropertyDescriptor(
				beanClass, propertyName), elementType, true);
	}

	/**
	 * @param beanClass
	 * @param propertyName
	 * @return a map property for the given property name of the given bean
	 *         class.
	 */
	public static IMapProperty mapProperty(Class beanClass, String propertyName) {
		return new BeanMapProperty(BeanPropertyHelper.getPropertyDescriptor(
				beanClass, propertyName), 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.internal.databinding.beans;

import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

import org.eclipse.core.databinding.BindingException;
import org.eclipse.core.databinding.beans.BeansObservables;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.core.databinding.util.Policy;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;

/**
 * @since 1.2
 * 
 */
public class BeanPropertyHelper {
	/**
	 * Sets the contents of the given property on the given source object to the
	 * given value.
	 * 
	 * @param source
	 *            the source object which has the property being updated
	 * @param propertyDescriptor
	 *            the property being changed
	 * @param value
	 *            the new value of the property
	 */
	public static void setProperty(Object source,
			PropertyDescriptor propertyDescriptor, Object value) {
		try {
			Method writeMethod = propertyDescriptor.getWriteMethod();
			if (!writeMethod.isAccessible()) {
				writeMethod.setAccessible(true);
			}
			writeMethod.invoke(source, new Object[] { value });
		} catch (InvocationTargetException e) {
			/*
			 * InvocationTargetException wraps any exception thrown by the
			 * invoked method.
			 */
			throw new RuntimeException(e.getCause());
		} catch (Exception e) {
			if (BeansObservables.DEBUG) {
				Policy
						.getLog()
						.log(
								new Status(
										IStatus.WARNING,
										Policy.JFACE_DATABINDING,
										IStatus.OK,
										"Could not change value of " + source + "." + propertyDescriptor.getName(), e)); //$NON-NLS-1$ //$NON-NLS-2$
			}
		}
	}

	/**
	 * Returns the contents of the given property for the given bean.
	 * 
	 * @param source
	 *            the source bean
	 * @param propertyDescriptor
	 *            the property to retrieve
	 * @return the contents of the given property for the given bean.
	 */
	public static Object getProperty(Object source,
			PropertyDescriptor propertyDescriptor) {
		try {
			Method readMethod = propertyDescriptor.getReadMethod();
			if (readMethod == null) {
				throw new BindingException(propertyDescriptor.getName()
						+ " property does not have a read method."); //$NON-NLS-1$
			}
			if (!readMethod.isAccessible()) {
				readMethod.setAccessible(true);
			}
			return readMethod.invoke(source, null);
		} catch (InvocationTargetException e) {
			/*
			 * InvocationTargetException wraps any exception thrown by the
			 * invoked method.
			 */
			throw new RuntimeException(e.getCause());
		} catch (Exception e) {
			if (BeansObservables.DEBUG) {
				Policy
						.getLog()
						.log(
								new Status(
										IStatus.WARNING,
										Policy.JFACE_DATABINDING,
										IStatus.OK,
										"Could not read value of " + source + "." + propertyDescriptor.getName(), e)); //$NON-NLS-1$ //$NON-NLS-2$
			}
			return null;
		}
	}

	/**
	 * Returns the element type of the given collection-typed property for the
	 * given bean.
	 * 
	 * @param descriptor
	 *            the property being inspected
	 * @return the element type of the given collection-typed property if it is
	 *         an array property, or Object.class otherwise.
	 */
	public static Class getCollectionPropertyElementType(
			PropertyDescriptor descriptor) {
		Class propertyType = descriptor.getPropertyType();
		return propertyType.isArray() ? propertyType.getComponentType()
				: Object.class;
	}

	/**
	 * @param beanClass
	 * @param propertyName
	 * @return the PropertyDescriptor for the named property on the given bean
	 *         class
	 */
	public static PropertyDescriptor getPropertyDescriptor(Class beanClass,
			String propertyName) {
		BeanInfo beanInfo;
		try {
			beanInfo = Introspector.getBeanInfo(beanClass);
		} catch (IntrospectionException e) {
			// cannot introspect, give up
			return null;
		}
		PropertyDescriptor[] propertyDescriptors = beanInfo
				.getPropertyDescriptors();
		for (int i = 0; i < propertyDescriptors.length; i++) {
			PropertyDescriptor descriptor = propertyDescriptors[i];
			if (descriptor.getName().equals(propertyName)) {
				return descriptor;
			}
		}
		throw new BindingException(
				"Could not find property with name " + propertyName + " in class " + beanClass); //$NON-NLS-1$ //$NON-NLS-2$
	}

	/**
	 * @param observable
	 * @param propertyName
	 * @return property descriptor or <code>null</code>
	 */
	/* package */public static PropertyDescriptor getValueTypePropertyDescriptor(
			IObservableValue observable, String propertyName) {
		if (observable.getValueType() != null)
			return getPropertyDescriptor((Class) observable.getValueType(),
					propertyName);
		return null;
	}
}





package org.eclipse.core.tests.internal.databinding.beans;

import java.beans.IntrospectionException;
import java.beans.PropertyDescriptor;

import junit.framework.Test;
import junit.framework.TestSuite;

import org.eclipse.core.databinding.beans.BeanProperties;
import org.eclipse.core.databinding.beans.BeansObservables;
import org.eclipse.core.databinding.beans.IBeanObservable;
import org.eclipse.core.databinding.beans.IBeanProperty;
import org.eclipse.core.databinding.beans.PojoObservables;
import org.eclipse.core.databinding.observable.ChangeEvent;
import org.eclipse.core.databinding.observable.IChangeListener;
import org.eclipse.core.databinding.observable.IObservable;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.value.ComputedValue;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.core.databinding.property.IValueProperty;
import org.eclipse.jface.databinding.conformance.MutableObservableValueContractTest;
import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableValueContractDelegate;
import org.eclipse.jface.databinding.conformance.util.ChangeEventTracker;

 */
public class JavaBeanObservableValueTest extends AbstractDefaultRealmTestCase {
	private Bean bean;
	private IValueProperty property;
	private IBeanProperty beanProperty;

	private IObservableValue observableValue;
	private IBeanObservable beanObservable;

	private PropertyDescriptor propertyDescriptor;
	private String propertyName;

	/* (non-Javadoc)
	 * @see junit.framework.TestCase#setUp()
	 */
	protected void setUp() throws Exception {
		super.setUp();

		bean = new Bean();

		propertyName = "value";
		property = BeanProperties.valueProperty(Bean.class, propertyName);
		beanProperty = (IBeanProperty) property;
		propertyDescriptor = beanProperty.getPropertyDescriptor();

		observableValue = BeansObservables.observeValue(bean, propertyName);
		beanObservable = (IBeanObservable) observableValue;
	}

	public void testGetObserved() throws Exception {
		assertEquals(bean, beanObservable.getObserved());
	}

	public void testGetPropertyDescriptor() throws Exception {
		assertEquals(propertyDescriptor, beanObservable.getPropertyDescriptor());
	}

	public void testSetValueThrowsExceptionThrownByBean() throws Exception {
		ThrowsSetException errorThrowingBean = new ThrowsSetException();
		IObservableValue observable = BeansObservables.observeValue(
				errorThrowingBean, "value");
				new PropertyDescriptor("value", ThrowsSetException.class));

		try {
			observable.setValue("");
			fail("exception should have been thrown");
		} catch (RuntimeException e) {
			assertEquals(errorThrowingBean.thrownException, e.getCause());
		}
	}
	
	public void testGetValueThrowsExceptionThrownByBean() throws Exception {
		ThrowsGetException temp = new ThrowsGetException();
		JavaBeanObservableValue observable = new JavaBeanObservableValue(Realm
				.getDefault(), temp,
				new PropertyDescriptor("value", ThrowsGetException.class));

	public void testGetValueThrowsExceptionThrownByBean() throws Exception {
		ThrowsGetException errorThrowingBean = new ThrowsGetException();
		IObservableValue observable = BeansObservables.observeValue(
				errorThrowingBean, "value");
		try {
			observable.getValue();
			fail("exception should have been thrown");
		} catch (RuntimeException e) {
			assertEquals(errorThrowingBean.thrownException, e.getCause());
		}
	}

	public void testBug198519() {
		final SimplePerson person = new SimplePerson();
		final ComputedValue cv = new ComputedValue() {
			final IObservableValue name = BeansObservables.observeValue(person,
					"name"); //$NON-NLS-1$

			protected Object calculate() {
				return Boolean.valueOf(name.getValue() != null);
			}
		};
		cv.addChangeListener(new IChangeListener() {
			public void handleChange(ChangeEvent event) {
				cv.getValue();
			}
		});
		person.setName("foo");
	}

	public void testConstructor_RegistersListeners() throws Exception {
		IObservableValue observable = BeansObservables.observeValue(bean,
				propertyName);
		ChangeEventTracker.observe(observable);

		assertTrue(bean.hasListeners(propertyName));
	}

	public void testConstructor_SkipRegisterListeners() throws Exception {
		IObservableValue observable = PojoObservables.observeValue(bean,
				propertyName);
		ChangeEventTracker.observe(observable);

		assertFalse(bean.hasListeners(propertyName));
	}

	public static Test suite() {
		TestSuite suite = new TestSuite(JavaBeanObservableValueTest.class
				.getName());
		suite.addTestSuite(JavaBeanObservableValueTest.class);
		suite.addTest(MutableObservableValueContractTest.suite(new Delegate()));
		return suite;
	}

	/* package */static class Delegate extends
			AbstractObservableValueContractDelegate {
		private Bean bean;

		public void setUp() {
			super.setUp();

			bean = new Bean("");
		}

		public IObservableValue createObservableValue(Realm realm) {
			return BeansObservables.observeValue(realm, bean, "value");
				PropertyDescriptor propertyDescriptor = new PropertyDescriptor("value", Bean.class);
				return new JavaBeanObservableValue(realm, bean,
						propertyDescriptor);					
			} catch (IntrospectionException e) {
				throw new RuntimeException(e);
			}
		}

		public void change(IObservable observable) {
			IObservableValue observableValue = (IObservableValue) observable;
			observableValue.setValue(createValue(observableValue));
		}

		public Object getValueType(IObservableValue observable) {
			return String.class;
		}

		public Object createValue(IObservableValue observable) {
			return observable.getValue() + "a";
		}
	}

	/**
	 * Throws an exception when the value is set.
	 * 




 *
 * Contributors:
 *     Brad Reynolds - initial API and implementation
 *     Matthew Hall - bug 194734
 ******************************************************************************/

package org.eclipse.core.tests.internal.databinding.beans;

import java.beans.PropertyDescriptor;

import org.eclipse.core.databinding.observable.value.WritableValue;
import org.eclipse.core.internal.databinding.beans.BeanObservableValueDecorator;
import org.eclipse.core.internal.databinding.beans.JavaBeanObservableValue;
import org.eclipse.jface.databinding.swt.SWTObservables;

/**
 * @since 3.3
 */
public class BeanObservableValueDecoratorTest extends
		AbstractDefaultRealmTestCase {
	private Bean bean;
	private JavaBeanObservableValue observableValue;
	private BeanObservableValueDecorator decorator;
	private PropertyDescriptor propertyDescriptor;

	/*
	 * (non-Javadoc)
	 * 
	 * @see junit.framework.TestCase#setUp()
	 */
	protected void setUp() throws Exception {
		super.setUp();

		bean = new Bean();
		propertyDescriptor = new PropertyDescriptor("value", Bean.class);
		observableValue = new JavaBeanObservableValue(SWTObservables
				.getRealm(Display.getDefault()), bean, propertyDescriptor);
		decorator = new BeanObservableValueDecorator(observableValue,
				observableValue.getPropertyDescriptor());
		decorator = new BeanObservableValueDecorator(
				observableValue, new WritableValue(bean, Object.class), observableValue
						.getPropertyDescriptor());
	}

	public void testGetDelegate() throws Exception {
		assertEquals(observableValue, decorator.getDelegate());
	}

	public void testGetObserved() throws Exception {
		assertEquals(bean, decorator.getObserved());
	}




 *
 * Contributors:
 *     Brad Reynolds - initial API and implementation
 *     Matthew Hall - bug 194734
 ******************************************************************************/

package org.eclipse.core.tests.internal.databinding.beans;

		super.setUp();

		Bean bean = new Bean();
		propertyDescriptor = new PropertyDescriptor("set", Bean.class);
		observableSet = new JavaBeanObservableSet(SWTObservables
				.getRealm(Display.getDefault()), bean, propertyDescriptor,
				String.class);
		decorator = new BeanObservableSetDecorator(observableSet,
				propertyDescriptor);
				observableSet, observableSet, propertyDescriptor);
	}

	public void testGetDelegate() throws Exception {

	}

	public void testGetObserved() throws Exception {
		assertEquals(observableSet.getObserved(), decorator.getObserved());
	}

	public void testGetPropertyDescriptor() throws Exception {




 *
 * Contributors:
 *     Brad Reynolds - initial API and implementation
 *     Matthew Hall - bugs 208858, 213145, 194734
 ******************************************************************************/

package org.eclipse.core.tests.internal.databinding.beans;

	 */
	protected void setUp() throws Exception {
		super.setUp();

		Bean bean = new Bean();
		propertyDescriptor = new PropertyDescriptor("list", Bean.class,
				"getList", "setList");
		observableList = new JavaBeanObservableList(SWTObservables
				.getRealm(Display.getDefault()), bean, propertyDescriptor,
				Bean.class);
		decorator = new BeanObservableListDecorator(observableList,
				propertyDescriptor);
	}

	public void testGetDelegate() throws Exception {

	}

	public void testGetObserved() throws Exception {
		assertEquals(observableList.getObserved(), decorator.getObserved());
	}

	public void testGetPropertyDescriptor() throws Exception {

	}

	public static Test suite() {
		TestSuite suite = new TestSuite(BeanObservableListDecoratorTest.class
				.getName());
		suite.addTestSuite(BeanObservableListDecoratorTest.class);
		suite.addTest(MutableObservableListContractTest.suite(new Delegate()));
		return suite;

			final WritableList delegate = new WritableList(realm);
			for (int i = 0; i < elementCount; i++)
				delegate.add(createElement(delegate));
			return new BeanObservableListDecorator(delegate, null);
		}

		private int counter;




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

package org.eclipse.core.tests.databinding.beans;

import org.eclipse.core.databinding.beans.IBeanObservable;
import org.eclipse.core.databinding.beans.PojoObservables;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.list.IObservableList;

import org.eclipse.core.databinding.observable.set.IObservableSet;
import org.eclipse.core.databinding.observable.set.WritableSet;
import org.eclipse.core.databinding.observable.value.IObservableValue;
import org.eclipse.core.internal.databinding.beans.JavaBeanObservableList;
import org.eclipse.core.internal.databinding.beans.JavaBeanObservableMap;
import org.eclipse.core.internal.databinding.beans.JavaBeanObservableSet;
import org.eclipse.core.internal.databinding.beans.JavaBeanObservableValue;
import org.eclipse.core.tests.internal.databinding.beans.Bean;
import org.eclipse.jface.databinding.conformance.util.ChangeEventTracker;
import org.eclipse.jface.databinding.conformance.util.CurrentRealm;

		propertyName = "value";
	}

	public void testObserveValue_ReturnsIBeanObservable()
			throws Exception {
		IObservableValue value = PojoObservables.observeValue(pojo, propertyName);

		assertNotNull(value);
		assertTrue(value instanceof IBeanObservable);
	}

	public void testObserveValue_DoesNotAttachListeners() throws Exception {

		assertFalse(pojo.hasListeners(propertyName));
	}

	public void testObservableValueWithRealm_ReturnsIBeanObservable()
			throws Exception {
		CurrentRealm realm = new CurrentRealm(true);
		IObservableValue value = PojoObservables.observeValue(realm, pojo,
				propertyName);

		assertNotNull(value);
		assertTrue(value instanceof IBeanObservable);
	}

	public void testObservableMap_ReturnsIBeanObservable()
			throws Exception {
		IObservableSet set = new WritableSet();
		set.add(new Bean());

		IObservableMap map = PojoObservables.observeMap(set, Bean.class,
				propertyName);
		assertNotNull(map);
		assertTrue(map instanceof IBeanObservable);
	}
	
	public void testObservableMap_DoesNotAttachListeners() throws Exception {

		assertEquals(2, maps.length);
	}
	
	public void testObserveListWithElementType_ReturnsIBeanObservable() throws Exception {
		IObservableList list = PojoObservables.observeList(Realm.getDefault(), pojo, "list", String.class);
		assertTrue(list instanceof IBeanObservable);
	}
	
	public void testObserveListWithElementType_DoesNotAttachListeners() throws Exception {

		assertFalse(pojo.hasListeners("list"));
	}
	
	public void testObserveList_ReturnsIBeanObservable() throws Exception {
		IObservableList observable = PojoObservables.observeList(Realm.getDefault(), pojo, "list");
		assertTrue(observable instanceof IBeanObservable);
	}
	
	public void testObserveList_DoesNotAttachListeners() throws Exception {

		assertFalse(pojo.hasListeners("list"));
	}
	
	public void testObserveSetWithElementType_ReturnsIBeanObservable() throws Exception {
		IObservableSet list = PojoObservables.observeSet(Realm.getDefault(), pojo, "set", String.class);
		assertTrue(list instanceof IBeanObservable);
	}
	
	public void testObserveSetWithElementType_DoesNotAttachListeners() throws Exception {

		assertFalse(pojo.hasListeners("set"));
	}
	
	public void testObserveSet_ReturnsIBeanObservable() throws Exception {
		IObservableSet list = PojoObservables.observeSet(Realm.getDefault(), pojo, "set");
		assertTrue(list instanceof IBeanObservable);
	}
	
	public void testObserveSet_DoesNotAttachListeners() throws Exception {




 *     IBM Corporation - initial API and implementation
 *     Brad Reynolds - bug 164268, 171616
 *     Mike Evans - bug 217558
 *     Matthew Hall - bugs 221351, 194734
 *******************************************************************************/

package org.eclipse.core.tests.databinding.beans;

		BeanObservableListDecorator beanObservable = (BeanObservableListDecorator) detailList;
		assertEquals("property descriptor", Bean.class.getMethod("getList",
				null), beanObservable.getPropertyDescriptor().getReadMethod());
		assertEquals("observed", parent.getValue(), beanObservable.getObserved());

		// DetailObservableList is package level we can do a straight instanceof
		// check

		assertEquals("property descriptor", Bean.class
				.getMethod("getSet", null), beanObservable
				.getPropertyDescriptor().getReadMethod());
		assertEquals("observed", parent.getValue(), beanObservable.getObserved());

		// DetailObservableSet is package level we can't do a straight
		// instanceof check

Return to bug 194734

Lines 31-37 Link Here

(-)src/org/eclipse/core/databinding/observable/map/ComputedObservableMap.java (-1 / +13 lines)
31	*/	31	*/
32	public abstract class ComputedObservableMap extends AbstractObservableMap {	32	public abstract class ComputedObservableMap extends AbstractObservableMap {
33		33
34	private final IObservableSet keySet;	34	private IObservableSet keySet;
35		35
36	private ISetChangeListener setChangeListener = new ISetChangeListener() {	36	private ISetChangeListener setChangeListener = new ISetChangeListener() {
37	public void handleSetChange(SetChangeEvent event) {	37	public void handleSetChange(SetChangeEvent event) {
Lines 163-166 Link Here
163	* @return the old value for the given key	163	* @return the old value for the given key
164	*/	164	*/
165	protected abstract Object doPut(Object key, Object value);	165	protected abstract Object doPut(Object key, Object value);
		166
		167	public void dispose() {
		168	if (keySet != null) {
		169	Object[] keys = keySet.toArray();
		170	for (int i = 0; i < keys.length; i++) {
		171	unhookListener(keys[i]);
		172	}
		173	keySet = null;
		174	}
		175	entrySet = null;
		176	super.dispose();
		177	}
166	}	178	}

Added Link Here

(-)src/org/eclipse/core/databinding/property/IListProperty.java (+105 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;
13
14	import java.util.Collection;
15	import java.util.List;
16
17	/**
18	* @since 1.2
19	*
20	*/
21	public interface IListProperty extends ICollectionProperty {
22	/**
23	* @param source
24	* @return a List with the current contents of the source's list property
25	*/
26	List getList(Object source);
27
28	/**
29	* @param source
30	* @param index
31	* @param c
32	* @return whether the source's list property was changed
33	*/
34	boolean addAll(Object source, int index, Collection c);
35
36	/**
37	* @param source
38	* @param index
39	* @return the element at the given location in the source's list property
40	*/
41	Object get(Object source, int index);
42
43	/**
44	* @param source
45	* @param index
46	* @param element
47	* @return the element previous at the given location in the source's list
48	* property
49	*/
50	Object set(Object source, int index, Object element);
51
52	/**
53	* @param source
54	* @param oldIndex
55	* @param newIndex
56	* @return the element that was moved
57	*/
58	Object move(Object source, int oldIndex, int newIndex);
59
60	/**
61	* @param source
62	* @param index
63	* @param element
64	*/
65	void add(Object source, int index, Object element);
66
67	/**
68	* @param source
69	* @param index
70	* @return the element that was removed from the source's list property
71	*/
72	Object remove(Object source, int index);
73
74	/**
75	* @param source
76	* @param o
77	* @return the index of the first location of the given element in the
78	* source's list property, or -1 if the list does not contain the
79	* element
80	*/
81	int indexOf(Object source, Object o);
82
83	/**
84	* @param source
85	* @param o
86	* @return the index of the last location of the given element in the
87	* source's list property, or -1 if the list does not contain the
88	* element
89	*/
90	int lastIndexOf(Object source, Object o);
91
92	/**
93	* @param source
94	* @param listener
95	*/
96	public void addListChangeListener(Object source,
97	IListPropertyChangeListener listener);
98
99	/**
100	* @param source
101	* @param listener
102	*/
103	public void removeListChangeListener(Object source,
104	IListPropertyChangeListener listener);
105	}

Added Link Here

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

Removed Link Here

(-)src/org/eclipse/core/internal/databinding/beans/JavaBeanObservableMap.java (-142 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006, 2008 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	* Brad Reynolds - bug 171616
11	* Matthew hall - bugs 223164, 241585
12	*******************************************************************************/
13
14	package org.eclipse.core.internal.databinding.beans;
15
16	import java.beans.PropertyChangeListener;
17	import java.beans.PropertyDescriptor;
18	import java.lang.reflect.Method;
19
20	import org.eclipse.core.databinding.beans.IBeanObservable;
21	import org.eclipse.core.databinding.observable.Diffs;
22	import org.eclipse.core.databinding.observable.map.ComputedObservableMap;
23	import org.eclipse.core.databinding.observable.set.IObservableSet;
24	import org.eclipse.core.databinding.util.Policy;
25	import org.eclipse.core.runtime.IStatus;
26	import org.eclipse.core.runtime.Status;
27
28	/**
29	* @since 1.0
30	*
31	*/
32	public class JavaBeanObservableMap extends ComputedObservableMap implements
33	IBeanObservable {
34
35	private PropertyDescriptor propertyDescriptor;
36
37	private PropertyChangeListener elementListener = new PropertyChangeListener() {
38	public void propertyChange(final java.beans.PropertyChangeEvent event) {
39	if (!updating) {
40	getRealm().exec(new Runnable() {
41	public void run() {
42	fireMapChange(Diffs.createMapDiffSingleChange(
43	event.getSource(), event.getOldValue(), event
44	.getNewValue()));
45	}
46	});
47	}
48	}
49	};
50
51	private ListenerSupport listenerSupport;
52
53	private boolean updating = false;
54
55	private boolean attachListeners;
56
57	/**
58	* @param domain
59	* @param propertyDescriptor
60	*/
61	public JavaBeanObservableMap(IObservableSet domain,
62	PropertyDescriptor propertyDescriptor) {
63	this(domain, propertyDescriptor, true);
64	}
65
66	/**
67	* @param domain
68	* @param propertyDescriptor
69	* @param attachListeners
70	*/
71	public JavaBeanObservableMap(IObservableSet domain,
72	PropertyDescriptor propertyDescriptor, boolean attachListeners) {
73	super(domain);
74
75	this.propertyDescriptor = propertyDescriptor;
76	this.attachListeners = attachListeners;
77	if (attachListeners) {
78	this.listenerSupport = new ListenerSupport(elementListener,
79	propertyDescriptor.getName());
80	}
81	init();
82	}
83
84	protected void hookListener(Object domainElement) {
85	if (attachListeners && domainElement != null) {
86	listenerSupport.hookListener(domainElement);
87	}
88	}
89
90	protected void unhookListener(Object domainElement) {
91	if (attachListeners && domainElement != null) {
92	listenerSupport.unhookListener(domainElement);
93	}
94	}
95
96	protected Object doGet(Object key) {
97	if (key == null) {
98	return null;
99	}
100	try {
101	Method readMethod = propertyDescriptor.getReadMethod();
102	if (!readMethod.isAccessible()) {
103	readMethod.setAccessible(true);
104	}
105	return readMethod.invoke(key, new Object[0]);
106	} catch (Exception e) {
107	Policy.getLog().log(
108	new Status(IStatus.ERROR, Policy.JFACE_DATABINDING,
109	IStatus.ERROR, "cannot get value", e)); //$NON-NLS-1$
110	throw new RuntimeException(e);
111	}
112	}
113
114	protected Object doPut(Object key, Object value) {
115	try {
116	Object oldValue = get(key);
117	propertyDescriptor.getWriteMethod().invoke(key,
118	new Object[] { value });
119	keySet().add(key);
120	return oldValue;
121	} catch (Exception e) {
122	Policy.getLog().log(
123	new Status(IStatus.ERROR, Policy.JFACE_DATABINDING,
124	IStatus.ERROR, "cannot set value", e)); //$NON-NLS-1$
125	throw new RuntimeException(e);
126	}
127	}
128
129	/* (non-Javadoc)
130	* @see org.eclipse.core.databinding.beans.IBeanObservable#getObserved()
131	*/
132	public Object getObserved() {
133	return keySet();
134	}
135
136	/* (non-Javadoc)
137	* @see org.eclipse.core.databinding.beans.IBeanObservable#getPropertyDescriptor()
138	*/
139	public PropertyDescriptor getPropertyDescriptor() {
140	return propertyDescriptor;
141	}
142	}

Removed Link Here

(-)src/org/eclipse/core/internal/databinding/beans/JavaBeanObservableList.java (-410 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006-2008 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	* Brad Reynolds - bug 171616
11	* Matthew Hall - bugs 208858, 221351, 213145, 223164
12	* Mike Evans - bug 217558
13	*******************************************************************************/
14
15	package org.eclipse.core.internal.databinding.beans;
16
17	import java.beans.PropertyChangeListener;
18	import java.beans.PropertyDescriptor;
19	import java.lang.reflect.Array;
20	import java.lang.reflect.InvocationTargetException;
21	import java.lang.reflect.Method;
22	import java.util.ArrayList;
23	import java.util.Arrays;
24	import java.util.Collection;
25	import java.util.Iterator;
26	import java.util.List;
27
28	import org.eclipse.core.databinding.BindingException;
29	import org.eclipse.core.databinding.beans.IBeanObservable;
30	import org.eclipse.core.databinding.observable.Diffs;
31	import org.eclipse.core.databinding.observable.Realm;
32	import org.eclipse.core.databinding.observable.list.ListDiffEntry;
33	import org.eclipse.core.databinding.observable.list.ObservableList;
34
35	/**
36	* @since 1.0
37	*
38	*/
39	public class JavaBeanObservableList extends ObservableList implements
40	IBeanObservable {
41
42	private final Object object;
43
44	private PropertyChangeListener collectionListener = new PropertyChangeListener() {
45	public void propertyChange(java.beans.PropertyChangeEvent event) {
46	if (!updating) {
47	getRealm().exec(new Runnable() {
48	public void run() {
49	updateWrappedList( new ArrayList( Arrays.asList(getValues() ) ) );
50	}
51	});
52	}
53	}
54	};
55
56	private boolean updating = false;
57
58	private PropertyDescriptor descriptor;
59
60	private ListenerSupport collectionListenSupport;
61
62	private boolean attachListeners;
63
64	/**
65	* @param realm
66	* @param object
67	* @param descriptor
68	* @param elementType
69	*/
70	public JavaBeanObservableList(Realm realm, Object object,
71	PropertyDescriptor descriptor, Class elementType) {
72	this(realm, object, descriptor, elementType, true);
73	}
74
75	/**
76	* @param realm
77	* @param object
78	* @param descriptor
79	* @param elementType
80	* @param attachListeners
81	*/
82	public JavaBeanObservableList(Realm realm, Object object,
83	PropertyDescriptor descriptor, Class elementType,
84	boolean attachListeners) {
85
86	super(realm, new ArrayList(), elementType);
87	this.object = object;
88	this.descriptor = descriptor;
89	this.attachListeners = attachListeners;
90
91	if (attachListeners) {
92	this.collectionListenSupport = new ListenerSupport(
93	collectionListener, descriptor.getName());
94	}
95
96	// initialize list without firing events
97	wrappedList.addAll(Arrays.asList(getValues()));
98	}
99
100	protected void firstListenerAdded() {
101	if (attachListeners) {
102	collectionListenSupport.hookListener(this.object);
103	}
104	}
105
106	protected void lastListenerRemoved() {
107	if (collectionListenSupport != null) {
108	collectionListenSupport.dispose();
109	}
110	}
111
112	public void dispose() {
113	super.dispose();
114	lastListenerRemoved();
115	}
116
117	private Object primGetValues() {
118	Exception ex = null;
119	try {
120	Method readMethod = descriptor.getReadMethod();
121	if (!readMethod.isAccessible()) {
122	readMethod.setAccessible(true);
123	}
124	return readMethod.invoke(object, new Object[0]);
125	} catch (IllegalArgumentException e) {
126	ex = e;
127	} catch (IllegalAccessException e) {
128	ex = e;
129	} catch (InvocationTargetException e) {
130	ex = e;
131	}
132	throw new BindingException("Could not read collection values", ex); //$NON-NLS-1$
133	}
134
135	private Object[] getValues() {
136	Object[] values = null;
137
138	Object result = primGetValues();
139	if (descriptor.getPropertyType().isArray())
140	values = (Object[]) result;
141	else {
142	// TODO add jUnit for POJO (var. SettableValue) collections
143	Collection list = (Collection) result;
144	if (list != null) {
145	values = list.toArray();
146	}
147	}
148	if (values == null)
149	values = new Object[0];
150	return values;
151	}
152
153	public Object getObserved() {
154	return object;
155	}
156
157	public PropertyDescriptor getPropertyDescriptor() {
158	return descriptor;
159	}
160
161	private void setValues() {
162	if (descriptor.getPropertyType().isArray()) {
163	Class componentType = descriptor.getPropertyType()
164	.getComponentType();
165	Object[] newArray = (Object[]) Array.newInstance(componentType,
166	wrappedList.size());
167	wrappedList.toArray(newArray);
168	primSetValues(newArray);
169	} else {
170	// assume that it is a java.util.List
171	primSetValues(new ArrayList(wrappedList));
172	}
173	}
174
175	private void primSetValues(Object newValue) {
176	Exception ex = null;
177	try {
178	Method writeMethod = descriptor.getWriteMethod();
179	if (!writeMethod.isAccessible()) {
180	writeMethod.setAccessible(true);
181	}
182	writeMethod.invoke(object, new Object[] { newValue });
183	return;
184	} catch (IllegalArgumentException e) {
185	ex = e;
186	} catch (IllegalAccessException e) {
187	ex = e;
188	} catch (InvocationTargetException e) {
189	ex = e;
190	}
191	throw new BindingException("Could not write collection values", ex); //$NON-NLS-1$
192	}
193
194	public Object set(int index, Object element) {
195	getterCalled();
196	updating = true;
197	try {
198	Object oldElement = wrappedList.set(index, element);
199	setValues();
200	fireListChange(Diffs.createListDiff(Diffs.createListDiffEntry(
201	index, false, oldElement), Diffs.createListDiffEntry(index,
202	true, element)));
203	return oldElement;
204	} finally {
205	updating = false;
206	}
207	}
208
209	public Object move(int oldIndex, int newIndex) {
210	getterCalled();
211	updating = true;
212	try {
213	int size = wrappedList.size();
214	if (oldIndex < 0 \|\| oldIndex >= size)
215	throw new IndexOutOfBoundsException(
216	"oldIndex: " + oldIndex + ", size:" + size); //$NON-NLS-1$ //$NON-NLS-2$
217	if (newIndex < 0 \|\| newIndex >= size)
218	throw new IndexOutOfBoundsException(
219	"newIndex: " + newIndex + ", size:" + size); //$NON-NLS-1$ //$NON-NLS-2$
220	if (oldIndex == newIndex)
221	return wrappedList.get(oldIndex);
222	Object element = wrappedList.remove(oldIndex);
223	wrappedList.add(newIndex, element);
224	setValues();
225	fireListChange(Diffs.createListDiff(Diffs.createListDiffEntry(
226	oldIndex, false, element), Diffs.createListDiffEntry(
227	newIndex, true, element)));
228	return element;
229	} finally {
230	updating = false;
231	}
232	}
233
234	public Object remove(int index) {
235	getterCalled();
236	updating = true;
237	try {
238	Object oldElement = wrappedList.remove(index);
239	setValues();
240	fireListChange(Diffs.createListDiff(Diffs.createListDiffEntry(
241	index, false, oldElement)));
242	return oldElement;
243	} finally {
244	updating = false;
245	}
246	}
247
248	public boolean add(Object element) {
249	updating = true;
250	try {
251	int index = wrappedList.size();
252	boolean result = wrappedList.add(element);
253	setValues();
254	fireListChange(Diffs.createListDiff(Diffs.createListDiffEntry(
255	index, true, element)));
256	return result;
257	} finally {
258	updating = false;
259	}
260	}
261
262	public void add(int index, Object element) {
263	updating = true;
264	try {
265	wrappedList.add(index, element);
266	setValues();
267	fireListChange(Diffs.createListDiff(Diffs.createListDiffEntry(
268	index, true, element)));
269	} finally {
270	updating = false;
271	}
272	}
273
274	public boolean addAll(Collection c) {
275	if (c.isEmpty()) {
276	return false;
277	}
278	updating = true;
279	try {
280	int index = wrappedList.size();
281	boolean result = wrappedList.addAll(c);
282	setValues();
283	ListDiffEntry[] entries = new ListDiffEntry[c.size()];
284	int i = 0;
285	for (Iterator it = c.iterator(); it.hasNext();) {
286	Object o = it.next();
287	entries[i++] = Diffs.createListDiffEntry(index++, true, o);
288	}
289	fireListChange(Diffs.createListDiff(entries));
290	return result;
291	} finally {
292	updating = false;
293	}
294	}
295
296	public boolean addAll(int index, Collection c) {
297	if (c.isEmpty()) {
298	return false;
299	}
300	updating = true;
301	try {
302	boolean result = wrappedList.addAll(index, c);
303	setValues();
304	ListDiffEntry[] entries = new ListDiffEntry[c.size()];
305	int i = 0;
306	for (Iterator it = c.iterator(); it.hasNext();) {
307	Object o = it.next();
308	entries[i++] = Diffs.createListDiffEntry(index++, true, o);
309	}
310	fireListChange(Diffs.createListDiff(entries));
311	return result;
312	} finally {
313	updating = false;
314	}
315	}
316
317	public boolean remove(Object o) {
318	getterCalled();
319	int index = wrappedList.indexOf(o);
320	if (index == -1) {
321	return false;
322	}
323	updating = true;
324	try {
325	Object oldElement = wrappedList.remove(index);
326	setValues();
327	fireListChange(Diffs.createListDiff(Diffs.createListDiffEntry(
328	index, false, oldElement)));
329	return true;
330	} finally {
331	updating = false;
332	}
333	}
334
335	public boolean removeAll(Collection c) {
336	getterCalled();
337	boolean changed = false;
338	updating = true;
339	try {
340	List diffEntries = new ArrayList();
341	for (Iterator it = c.iterator(); it.hasNext();) {
342	Object o = it.next();
343	int index = wrappedList.indexOf(o);
344	if (index != -1) {
345	changed = true;
346	Object oldElement = wrappedList.remove(index);
347	diffEntries.add(Diffs.createListDiffEntry(index, false,
348	oldElement));
349	}
350	}
351	if (changed) {
352	setValues();
353	fireListChange(Diffs
354	.createListDiff((ListDiffEntry[]) diffEntries
355	.toArray(new ListDiffEntry[diffEntries.size()])));
356	}
357	return changed;
358	} finally {
359	updating = false;
360	}
361	}
362
363	public boolean retainAll(Collection c) {
364	getterCalled();
365	boolean changed = false;
366	updating = true;
367	try {
368	List diffEntries = new ArrayList();
369	int index = 0;
370	for (Iterator it = wrappedList.iterator(); it.hasNext();) {
371	Object o = it.next();
372	boolean retain = c.contains(o);
373	if (retain) {
374	index++;
375	} else {
376	changed = true;
377	it.remove();
378	diffEntries.add(Diffs.createListDiffEntry(index, false, o));
379	}
380	}
381	if (changed) {
382	setValues();
383	fireListChange(Diffs
384	.createListDiff((ListDiffEntry[]) diffEntries
385	.toArray(new ListDiffEntry[diffEntries.size()])));
386	}
387	return changed;
388	} finally {
389	updating = false;
390	}
391	}
392
393	public void clear() {
394	updating = true;
395	try {
396	List diffEntries = new ArrayList();
397	for (Iterator it = wrappedList.iterator(); it.hasNext();) {
398	Object o = it.next();
399	diffEntries.add(Diffs.createListDiffEntry(0, false, o));
400	}
401	wrappedList.clear();
402	setValues();
403	fireListChange(Diffs.createListDiff((ListDiffEntry[]) diffEntries
404	.toArray(new ListDiffEntry[diffEntries.size()])));
405	} finally {
406	updating = false;
407	}
408	}
409
410	}

Removed Link Here

(-)src/org/eclipse/core/internal/databinding/beans/JavaBeanObservableValue.java (-190 lines)
1	/*******************************************************************************
2	* Copyright (c) 2005, 2008 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	* Brad Reynolds - bug 164653
11	* Brad Reynolds - bug 164134, 171616
12	*******************************************************************************/
13	package org.eclipse.core.internal.databinding.beans;
14
15	import java.beans.PropertyChangeListener;
16	import java.beans.PropertyDescriptor;
17	import java.lang.reflect.InvocationTargetException;
18	import java.lang.reflect.Method;
19
20	import org.eclipse.core.databinding.BindingException;
21	import org.eclipse.core.databinding.beans.BeansObservables;
22	import org.eclipse.core.databinding.beans.IBeanObservable;
23	import org.eclipse.core.databinding.observable.Diffs;
24	import org.eclipse.core.databinding.observable.Realm;
25	import org.eclipse.core.databinding.observable.value.AbstractObservableValue;
26	import org.eclipse.core.databinding.observable.value.ValueDiff;
27	import org.eclipse.core.databinding.util.Policy;
28	import org.eclipse.core.internal.databinding.Util;
29	import org.eclipse.core.runtime.IStatus;
30	import org.eclipse.core.runtime.Status;
31
32	/**
33	* @since 1.0
34	*
35	*/
36	public class JavaBeanObservableValue extends AbstractObservableValue implements IBeanObservable {
37	private final Object object;
38	private boolean updating = false;
39
40	private final PropertyDescriptor propertyDescriptor;
41	private ListenerSupport listenerSupport;
42
43	private boolean attachListeners;
44
45	/**
46	* @param realm
47	* @param object
48	* @param descriptor
49	*/
50	public JavaBeanObservableValue(Realm realm, Object object,
51	PropertyDescriptor descriptor) {
52	this(realm, object, descriptor, true);
53	}
54
55	/**
56	* @param realm
57	* @param object
58	* @param descriptor
59	* @param attachListeners
60	*/
61	public JavaBeanObservableValue(Realm realm, Object object,
62	PropertyDescriptor descriptor, boolean attachListeners) {
63	super(realm);
64	this.object = object;
65	this.propertyDescriptor = descriptor;
66	this.attachListeners = attachListeners;
67	}
68
69	protected void firstListenerAdded() {
70	if (!attachListeners) {
71	return;
72	}
73
74	PropertyChangeListener listener = new PropertyChangeListener() {
75	public void propertyChange(java.beans.PropertyChangeEvent event) {
76	if (!updating) {
77	final ValueDiff diff = Diffs.createValueDiff(event.getOldValue(),
78	event.getNewValue());
79	getRealm().exec(new Runnable(){
80	public void run() {
81	fireValueChange(diff);
82	}});
83	}
84	}
85	};
86
87	if (listenerSupport == null) {
88	listenerSupport = new ListenerSupport(listener, propertyDescriptor.getName());
89	}
90
91	listenerSupport.hookListener(object);
92	}
93
94	public void doSetValue(Object value) {
95	updating = true;
96	try {
97	Object oldValue = doGetValue();
98
99	if (Util.equals(oldValue, value)) {
100	return;
101	}
102
103	Method writeMethod = propertyDescriptor.getWriteMethod();
104	if (!writeMethod.isAccessible()) {
105	writeMethod.setAccessible(true);
106	}
107	writeMethod.invoke(object, new Object[] { value });
108	fireValueChange(Diffs.createValueDiff(oldValue, doGetValue()));
109	} catch (InvocationTargetException e) {
110	/*
111	* InvocationTargetException wraps any exception thrown by the
112	* invoked method.
113	*/
114	throw new RuntimeException(e.getCause());
115	} catch (Exception e) {
116	if (BeansObservables.DEBUG) {
117	Policy
118	.getLog()
119	.log(
120	new Status(
121	IStatus.WARNING,
122	Policy.JFACE_DATABINDING,
123	IStatus.OK,
124	"Could not change value of " + object + "." + propertyDescriptor.getName(), e)); //$NON-NLS-1$ //$NON-NLS-2$
125	}
126	} finally {
127	updating = false;
128	}
129	}
130
131	public Object doGetValue() {
132	try {
133	Method readMethod = propertyDescriptor.getReadMethod();
134	if (readMethod == null) {
135	throw new BindingException(propertyDescriptor.getName()
136	+ " property does not have a read method."); //$NON-NLS-1$
137	}
138	if (!readMethod.isAccessible()) {
139	readMethod.setAccessible(true);
140	}
141	return readMethod.invoke(object, null);
142	} catch (InvocationTargetException e) {
143	/*
144	* InvocationTargetException wraps any exception thrown by the
145	* invoked method.
146	*/
147	throw new RuntimeException(e.getCause());
148	} catch (Exception e) {
149	if (BeansObservables.DEBUG) {
150	Policy
151	.getLog()
152	.log(
153	new Status(
154	IStatus.WARNING,
155	Policy.JFACE_DATABINDING,
156	IStatus.OK,
157	"Could not read value of " + object + "." + propertyDescriptor.getName(), e)); //$NON-NLS-1$ //$NON-NLS-2$
158	}
159	return null;
160	}
161	}
162
163	protected void lastListenerRemoved() {
164	unhookListener();
165	}
166
167	private void unhookListener() {
168	if (listenerSupport != null) {
169	listenerSupport.dispose();
170	listenerSupport = null;
171	}
172	}
173
174	public Object getValueType() {
175	return propertyDescriptor.getPropertyType();
176	}
177
178	public Object getObserved() {
179	return object;
180	}
181
182	public PropertyDescriptor getPropertyDescriptor() {
183	return propertyDescriptor;
184	}
185
186	public synchronized void dispose() {
187	unhookListener();
188	super.dispose();
189	}
190	}

Lines 8-24 Link Here

(-)src/org/eclipse/core/databinding/beans/BeansObservables.java (-114 / +60 lines)
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
10	* Brad Reynolds - bugs 164268, 171616, 147515	10	* Brad Reynolds - bugs 164268, 171616, 147515
11	* Matthew Hall - bug 221704, 234686	11	* Matthew Hall - bugs 221704, 234686, 194734
12	* Thomas Kratz - bug 213787	12	* Thomas Kratz - bug 213787
13	*******************************************************************************/	13	*******************************************************************************/
14	package org.eclipse.core.databinding.beans;	14	package org.eclipse.core.databinding.beans;
15		15
16	import java.beans.BeanInfo;
17	import java.beans.IntrospectionException;
18	import java.beans.Introspector;
19	import java.beans.PropertyDescriptor;	16	import java.beans.PropertyDescriptor;
20		17
21	import org.eclipse.core.databinding.BindingException;
22	import org.eclipse.core.databinding.observable.IObservable;	18	import org.eclipse.core.databinding.observable.IObservable;
23	import org.eclipse.core.databinding.observable.Realm;	19	import org.eclipse.core.databinding.observable.Realm;
24	import org.eclipse.core.databinding.observable.list.IObservableList;	20	import org.eclipse.core.databinding.observable.list.IObservableList;
Lines 27-41 Link Here
27	import org.eclipse.core.databinding.observable.masterdetail.MasterDetailObservables;	23	import org.eclipse.core.databinding.observable.masterdetail.MasterDetailObservables;
28	import org.eclipse.core.databinding.observable.set.IObservableSet;	24	import org.eclipse.core.databinding.observable.set.IObservableSet;
29	import org.eclipse.core.databinding.observable.value.IObservableValue;	25	import org.eclipse.core.databinding.observable.value.IObservableValue;
		26	import org.eclipse.core.databinding.property.IListProperty;
		27	import org.eclipse.core.databinding.property.IMapProperty;
		28	import org.eclipse.core.databinding.property.ISetProperty;
		29	import org.eclipse.core.databinding.property.IValueProperty;
		30	import org.eclipse.core.databinding.property.PropertyObservables;
30	import org.eclipse.core.internal.databinding.beans.BeanObservableListDecorator;	31	import org.eclipse.core.internal.databinding.beans.BeanObservableListDecorator;
31	import org.eclipse.core.internal.databinding.beans.BeanObservableMapDecorator;	32	import org.eclipse.core.internal.databinding.beans.BeanObservableMapDecorator;
32	import org.eclipse.core.internal.databinding.beans.BeanObservableSetDecorator;	33	import org.eclipse.core.internal.databinding.beans.BeanObservableSetDecorator;
33	import org.eclipse.core.internal.databinding.beans.BeanObservableValueDecorator;	34	import org.eclipse.core.internal.databinding.beans.BeanObservableValueDecorator;
34	import org.eclipse.core.internal.databinding.beans.JavaBeanObservableList;	35	import org.eclipse.core.internal.databinding.beans.BeanPropertyHelper;
35	import org.eclipse.core.internal.databinding.beans.JavaBeanObservableMap;
36	import org.eclipse.core.internal.databinding.beans.JavaBeanObservableSet;
37	import org.eclipse.core.internal.databinding.beans.JavaBeanObservableValue;
38	import org.eclipse.core.internal.databinding.beans.JavaBeanPropertyObservableMap;
39	import org.eclipse.core.runtime.Assert;	36	import org.eclipse.core.runtime.Assert;
40		37
41	/**	38	/**
Lines 83-91 Link Here
83	*/	80	*/
84	public static IObservableValue observeValue(Realm realm, Object bean,	81	public static IObservableValue observeValue(Realm realm, Object bean,
85	String propertyName) {	82	String propertyName) {
86	PropertyDescriptor descriptor = getPropertyDescriptor(bean.getClass(),	83	IValueProperty property = BeanProperties.valueProperty(bean.getClass(),
87	propertyName);	84	propertyName);
88	return new JavaBeanObservableValue(realm, bean, descriptor);	85	PropertyDescriptor propertyDescriptor = ((IBeanProperty) property)
		86	.getPropertyDescriptor();
		87	return new BeanObservableValueDecorator(PropertyObservables
		88	.observeValue(realm, bean, property), propertyDescriptor);
89	}	89	}
90		90
91	/**	91	/**
Lines 103-111 Link Here
103	*/	103	*/
104	public static IObservableMap observeMap(IObservableSet domain,	104	public static IObservableMap observeMap(IObservableSet domain,
105	Class beanClass, String propertyName) {	105	Class beanClass, String propertyName) {
106	PropertyDescriptor descriptor = getPropertyDescriptor(beanClass,	106	IValueProperty property = BeanProperties.valueProperty(beanClass,
107	propertyName);	107	propertyName);
108	return new JavaBeanObservableMap(domain, descriptor);	108	PropertyDescriptor propertyDescriptor = ((IBeanProperty) property)
		109	.getPropertyDescriptor();
		110	return new BeanObservableMapDecorator(PropertyObservables.observeMap(
		111	domain, property), propertyDescriptor);
109	}	112	}
110		113
111	/**	114	/**
Lines 124-132 Link Here
124	*/	127	*/
125	public static IObservableMap observeMap(Realm realm, Object bean,	128	public static IObservableMap observeMap(Realm realm, Object bean,
126	String propertyName) {	129	String propertyName) {
127	PropertyDescriptor descriptor = getPropertyDescriptor(bean.getClass(),	130	IMapProperty property = BeanProperties.mapProperty(bean.getClass(),
128	propertyName);	131	propertyName);
129	return new JavaBeanPropertyObservableMap(realm, bean, descriptor);	132	PropertyDescriptor propertyDescriptor = ((IBeanProperty) property)
		133	.getPropertyDescriptor();
		134	return new BeanObservableMapDecorator(PropertyObservables.observeMap(
		135	realm, bean, property), propertyDescriptor);
130	}	136	}
131		137
132	/**	138	/**
Lines 145-171 Link Here
145	return observeMap(Realm.getDefault(), bean, propertyName);	151	return observeMap(Realm.getDefault(), bean, propertyName);
146	}	152	}
147		153
148	/package/ static PropertyDescriptor getPropertyDescriptor(Class beanClass,
149	String propertyName) {
150	BeanInfo beanInfo;
151	try {
152	beanInfo = Introspector.getBeanInfo(beanClass);
153	} catch (IntrospectionException e) {
154	// cannot introspect, give up
155	return null;
156	}
157	PropertyDescriptor[] propertyDescriptors = beanInfo
158	.getPropertyDescriptors();
159	for (int i = 0; i < propertyDescriptors.length; i++) {
160	PropertyDescriptor descriptor = propertyDescriptors[i];
161	if (descriptor.getName().equals(propertyName)) {
162	return descriptor;
163	}
164	}
165	throw new BindingException(
166	"Could not find property with name " + propertyName + " in class " + beanClass); //$NON-NLS-1$ //$NON-NLS-2$
167	}
168
169	/**	154	/**
170	* Returns an array of observable maps in the default realm tracking the	155	* Returns an array of observable maps in the default realm tracking the
171	* current values of the named propertys for the beans in the given set.	156	* current values of the named propertys for the beans in the given set.
Lines 231-239 Link Here
231	* collection-typed named property of the given bean object. The returned	216	* collection-typed named property of the given bean object. The returned
232	* list is mutable. When an item is added or removed the setter is invoked	217	* list is mutable. When an item is added or removed the setter is invoked
233	* for the list on the parent bean to provide notification to other	218	* for the list on the parent bean to provide notification to other
234	* listeners via <code>PropertyChangeEvents</code>. This is done to	219	* listeners via <code>PropertyChangeEvents</code>. This is done to provide
235	* provide the same behavior as is expected from arrays as specified in the	220	* the same behavior as is expected from arrays as specified in the bean
236	* bean spec in section 7.2.	221	* spec in section 7.2.
237	*	222	*
238	* @param realm	223	* @param realm
239	* the realm	224	* the realm
Lines 242-249 Link Here
242	* @param propertyName	227	* @param propertyName
243	* the name of the property	228	* the name of the property
244	* @param elementType	229	* @param elementType
245	* type of the elements in the list. If <code>null</code> and	230	* type of the elements in the list. If <code>null</code> and the
246	* the property is an array the type will be inferred. If	231	* property is an array the type will be inferred. If
247	* <code>null</code> and the property type cannot be inferred	232	* <code>null</code> and the property type cannot be inferred
248	* element type will be <code>null</code>.	233	* element type will be <code>null</code>.
249	* @return an observable list tracking the collection-typed named property	234	* @return an observable list tracking the collection-typed named property
Lines 251-262 Link Here
251	*/	236	*/
252	public static IObservableList observeList(Realm realm, Object bean,	237	public static IObservableList observeList(Realm realm, Object bean,
253	String propertyName, Class elementType) {	238	String propertyName, Class elementType) {
254	PropertyDescriptor propertyDescriptor = getPropertyDescriptor(bean	239	IListProperty property = BeanProperties.listProperty(bean.getClass(),
255	.getClass(), propertyName);	240	propertyName, elementType);
256	elementType = getCollectionElementType(elementType, propertyDescriptor);	241	PropertyDescriptor propertyDescriptor = ((IBeanProperty) property)
257		242	.getPropertyDescriptor();
258	return new JavaBeanObservableList(realm, bean, propertyDescriptor,	243	return new BeanObservableListDecorator(PropertyObservables.observeList(
259	elementType);	244	realm, bean, property), propertyDescriptor);
260	}	245	}
261		246
262	/**	247	/**
Lines 439-449 Link Here
439		424
440	IObservableValue value = MasterDetailObservables.detailValue(master,	425	IObservableValue value = MasterDetailObservables.detailValue(master,
441	valueFactory(realm, propertyName), propertyType);	426	valueFactory(realm, propertyName), propertyType);
442	BeanObservableValueDecorator decorator = new BeanObservableValueDecorator(	427	return new BeanObservableValueDecorator(value, BeanPropertyHelper
443	value, master, getValueTypePropertyDescriptor(master,	428	.getValueTypePropertyDescriptor(master, propertyName));
444	propertyName));
445
446	return decorator;
447	}	429	}
448		430
449	/**	431	/**
Lines 469-478 Link Here
469	/**	451	/**
470	* Helper method for	452	* Helper method for
471	* <code>MasterDetailObservables.detailValue(master, valueFactory(realm,	453	* <code>MasterDetailObservables.detailValue(master, valueFactory(realm,
472	* propertyName), propertyType)</code>.	454	* propertyName), propertyType)</code>. This method returns an
473	* This method returns an {@link IBeanObservable} with a	455	* {@link IBeanObservable} with a {@link PropertyDescriptor} based on the
474	* {@link PropertyDescriptor} based on the given master type and property	456	* given master type and property name.
475	* name.
476	*	457	*
477	* @param realm	458	* @param realm
478	* the realm	459	* the realm
Lines 492-506 Link Here
492	* @since 1.1	473	* @since 1.1
493	*/	474	*/
494	public static IObservableValue observeDetailValue(Realm realm,	475	public static IObservableValue observeDetailValue(Realm realm,
495	IObservableValue master, Class masterType, String propertyName, Class propertyType) {	476	IObservableValue master, Class masterType, String propertyName,
		477	Class propertyType) {
496	Assert.isNotNull(masterType, "masterType cannot be null"); //$NON-NLS-1$	478	Assert.isNotNull(masterType, "masterType cannot be null"); //$NON-NLS-1$
497	IObservableValue value = MasterDetailObservables.detailValue(master,	479	IObservableValue value = MasterDetailObservables.detailValue(master,
498	valueFactory(realm, propertyName), propertyType);	480	valueFactory(realm, propertyName), propertyType);
499	BeanObservableValueDecorator decorator = new BeanObservableValueDecorator(	481	return new BeanObservableValueDecorator(value, BeanPropertyHelper
500	value, master, getPropertyDescriptor(masterType,	482	.getPropertyDescriptor(masterType, propertyName));
501	propertyName));
502
503	return decorator;
504	}	483	}
505		484
506	/**	485	/**
Lines 551-561 Link Here
551	IObservableList observableList = MasterDetailObservables.detailList(	530	IObservableList observableList = MasterDetailObservables.detailList(
552	master, listFactory(realm, propertyName, propertyType),	531	master, listFactory(realm, propertyName, propertyType),
553	propertyType);	532	propertyType);
554	BeanObservableListDecorator decorator = new BeanObservableListDecorator(	533	return new BeanObservableListDecorator(observableList,
555	observableList, master, getValueTypePropertyDescriptor(master,	534	BeanPropertyHelper.getValueTypePropertyDescriptor(master,
556	propertyName));	535	propertyName));
557
558	return decorator;
559	}	536	}
560		537
561	/**	538	/**
Lines 599-609 Link Here
599	IObservableSet observableSet = MasterDetailObservables.detailSet(	576	IObservableSet observableSet = MasterDetailObservables.detailSet(
600	master, setFactory(realm, propertyName, propertyType),	577	master, setFactory(realm, propertyName, propertyType),
601	propertyType);	578	propertyType);
602	BeanObservableSetDecorator decorator = new BeanObservableSetDecorator(	579	return new BeanObservableSetDecorator(observableSet, BeanPropertyHelper
603	observableSet, master, getValueTypePropertyDescriptor(master,	580	.getValueTypePropertyDescriptor(master, propertyName));
604	propertyName));
605
606	return decorator;
607	}	581	}
608		582
609	/**	583	/**
Lines 642-651 Link Here
642	IObservableValue master, String propertyName) {	616	IObservableValue master, String propertyName) {
643	IObservableMap observableMap = MasterDetailObservables.detailMap(	617	IObservableMap observableMap = MasterDetailObservables.detailMap(
644	master, mapPropertyFactory(realm, propertyName));	618	master, mapPropertyFactory(realm, propertyName));
645	BeanObservableMapDecorator decorator = new BeanObservableMapDecorator(	619	return new BeanObservableMapDecorator(observableMap, BeanPropertyHelper
646	observableMap, master, getValueTypePropertyDescriptor(master,	620	.getValueTypePropertyDescriptor(master, propertyName));
647	propertyName));
648	return decorator;
649	}	621	}
650		622
651	/**	623	/**
Lines 688-699 Link Here
688	*/	660	*/
689	public static IObservableSet observeSet(Realm realm, Object bean,	661	public static IObservableSet observeSet(Realm realm, Object bean,
690	String propertyName, Class elementType) {	662	String propertyName, Class elementType) {
691	PropertyDescriptor propertyDescriptor = getPropertyDescriptor(bean	663	ISetProperty property = BeanProperties.setProperty(bean.getClass(),
692	.getClass(), propertyName);	664	propertyName, elementType);
693	elementType = getCollectionElementType(elementType, propertyDescriptor);	665	PropertyDescriptor propertyDescriptor = ((IBeanProperty) property)
694		666	.getPropertyDescriptor();
695	return new JavaBeanObservableSet(realm, bean, propertyDescriptor,	667	return new BeanObservableSetDecorator(PropertyObservables.observeSet(
696	elementType);	668	realm, bean, property), propertyDescriptor);
697	}	669	}
698		670
699	/**	671	/**
Lines 780-796 Link Here
780	* @param propertyName	752	* @param propertyName
781	* the name of the property	753	* the name of the property
782	* @return a factory for creating {@link IObservableMap} objects	754	* @return a factory for creating {@link IObservableMap} objects
783	*	755	*
784	* @since 1.1	756	* @since 1.1
785	*/	757	*/
786	public static IObservableFactory setToMapFactory(final Class beanClass, final String propertyName) {	758	public static IObservableFactory setToMapFactory(final Class beanClass,
		759	final String propertyName) {
787	return new IObservableFactory() {	760	return new IObservableFactory() {
788	public IObservable createObservable(Object target) {	761	public IObservable createObservable(Object target) {
789	return observeMap((IObservableSet) target, beanClass, propertyName);	762	return observeMap((IObservableSet) target, beanClass,
		763	propertyName);
790	}	764	}
791	};	765	};
792	}	766	}
793		767
794	/**	768	/**
795	* Returns a factory for creating an observable map. The factory, when	769	* Returns a factory for creating an observable map. The factory, when
796	* provided with a bean object, will create an {@link IObservableMap} in the	770	* provided with a bean object, will create an {@link IObservableMap} in the
Lines 828-859 Link Here
828	public static IObservableFactory mapPropertyFactory(String propertyName) {	802	public static IObservableFactory mapPropertyFactory(String propertyName) {
829	return mapPropertyFactory(Realm.getDefault(), propertyName);	803	return mapPropertyFactory(Realm.getDefault(), propertyName);
830	}	804	}
831
832	/**
833	* @param elementType
834	* can be <code>null</code>
835	* @param propertyDescriptor
836	* @return type of the items in a collection/array property
837	*/
838	/package/ static Class getCollectionElementType(Class elementType,
839	PropertyDescriptor propertyDescriptor) {
840	if (elementType == null) {
841	Class propertyType = propertyDescriptor.getPropertyType();
842	elementType = propertyType.isArray() ? propertyType
843	.getComponentType() : Object.class;
844	}
845
846	return elementType;
847	}
848
849	/**
850	* @param observable
851	* @param propertyName
852	* @return property descriptor or <code>null</code>
853	*/
854	/* package*/ static PropertyDescriptor getValueTypePropertyDescriptor(
855	IObservableValue observable, String propertyName) {
856	return (observable.getValueType() != null) ? getPropertyDescriptor(
857	(Class) observable.getValueType(), propertyName) : null;
858	}
859	}	805	}

Lines 14-33 Link Here

(-)src/org/eclipse/core/tests/internal/databinding/beans/JavaBeanObservableValueTest.java (-60 / +66 lines)
14		14
15	package org.eclipse.core.tests.internal.databinding.beans;	15	package org.eclipse.core.tests.internal.databinding.beans;
16		16
17	import java.beans.IntrospectionException;
18	import java.beans.PropertyDescriptor;	17	import java.beans.PropertyDescriptor;
19		18
20	import junit.framework.Test;	19	import junit.framework.Test;
21	import junit.framework.TestSuite;	20	import junit.framework.TestSuite;
22		21
		22	import org.eclipse.core.databinding.beans.BeanProperties;
23	import org.eclipse.core.databinding.beans.BeansObservables;	23	import org.eclipse.core.databinding.beans.BeansObservables;
		24	import org.eclipse.core.databinding.beans.IBeanObservable;
		25	import org.eclipse.core.databinding.beans.IBeanProperty;
		26	import org.eclipse.core.databinding.beans.PojoObservables;
24	import org.eclipse.core.databinding.observable.ChangeEvent;	27	import org.eclipse.core.databinding.observable.ChangeEvent;
25	import org.eclipse.core.databinding.observable.IChangeListener;	28	import org.eclipse.core.databinding.observable.IChangeListener;
26	import org.eclipse.core.databinding.observable.IObservable;	29	import org.eclipse.core.databinding.observable.IObservable;
27	import org.eclipse.core.databinding.observable.Realm;	30	import org.eclipse.core.databinding.observable.Realm;
28	import org.eclipse.core.databinding.observable.value.ComputedValue;	31	import org.eclipse.core.databinding.observable.value.ComputedValue;
29	import org.eclipse.core.databinding.observable.value.IObservableValue;	32	import org.eclipse.core.databinding.observable.value.IObservableValue;
30	import org.eclipse.core.internal.databinding.beans.JavaBeanObservableValue;	33	import org.eclipse.core.databinding.property.IValueProperty;
31	import org.eclipse.jface.databinding.conformance.MutableObservableValueContractTest;	34	import org.eclipse.jface.databinding.conformance.MutableObservableValueContractTest;
32	import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableValueContractDelegate;	35	import org.eclipse.jface.databinding.conformance.delegate.AbstractObservableValueContractDelegate;
33	import org.eclipse.jface.databinding.conformance.util.ChangeEventTracker;	36	import org.eclipse.jface.databinding.conformance.util.ChangeEventTracker;
Lines 39-166 Link Here
39	*/	42	*/
40	public class JavaBeanObservableValueTest extends AbstractDefaultRealmTestCase {	43	public class JavaBeanObservableValueTest extends AbstractDefaultRealmTestCase {
41	private Bean bean;	44	private Bean bean;
42	private JavaBeanObservableValue observableValue;	45	private IValueProperty property;
		46	private IBeanProperty beanProperty;
		47
		48	private IObservableValue observableValue;
		49	private IBeanObservable beanObservable;
		50
43	private PropertyDescriptor propertyDescriptor;	51	private PropertyDescriptor propertyDescriptor;
44	private String propertyName;	52	private String propertyName;
45		53
46	/* (non-Javadoc)
47	* @see junit.framework.TestCase#setUp()
48	*/
49	protected void setUp() throws Exception {	54	protected void setUp() throws Exception {
50	super.setUp();	55	super.setUp();
51		56
52	bean = new Bean();	57	bean = new Bean();
		58
53	propertyName = "value";	59	propertyName = "value";
54	propertyDescriptor = new PropertyDescriptor(propertyName, Bean.class);	60	property = BeanProperties.valueProperty(Bean.class, propertyName);
55	observableValue = new JavaBeanObservableValue(Realm.getDefault(), bean, propertyDescriptor);	61	beanProperty = (IBeanProperty) property;
		62	propertyDescriptor = beanProperty.getPropertyDescriptor();
		63
		64	observableValue = BeansObservables.observeValue(bean, propertyName);
		65	beanObservable = (IBeanObservable) observableValue;
56	}	66	}
57		67
58	public void testGetObserved() throws Exception {	68	public void testGetObserved() throws Exception {
59	assertEquals(bean, observableValue.getObserved());	69	assertEquals(bean, beanObservable.getObserved());
60	}	70	}
61		71
62	public void testGetPropertyDescriptor() throws Exception {	72	public void testGetPropertyDescriptor() throws Exception {
63	assertEquals(propertyDescriptor, observableValue.getPropertyDescriptor());	73	assertEquals(propertyDescriptor, beanObservable.getPropertyDescriptor());
64	}	74	}
65		75
66	public void testSetValueThrowsExceptionThrownByBean() throws Exception {	76	public void testSetValueThrowsExceptionThrownByBean() throws Exception {
67	ThrowsSetException temp = new ThrowsSetException();	77	ThrowsSetException errorThrowingBean = new ThrowsSetException();
68	JavaBeanObservableValue observable = new JavaBeanObservableValue(Realm	78	IObservableValue observable = BeansObservables.observeValue(
69	.getDefault(), temp,	79	errorThrowingBean, "value");
70	new PropertyDescriptor("value", ThrowsSetException.class));
71
72	try {	80	try {
73	observable.setValue("");	81	observable.setValue("");
74	fail("exception should have been thrown");	82	fail("exception should have been thrown");
75	} catch (RuntimeException e) {	83	} catch (RuntimeException e) {
76	assertEquals(temp.thrownException, e.getCause());	84	assertEquals(errorThrowingBean.thrownException, e.getCause());
77	}	85	}
78	}	86	}
79
80	public void testGetValueThrowsExceptionThrownByBean() throws Exception {
81	ThrowsGetException temp = new ThrowsGetException();
82	JavaBeanObservableValue observable = new JavaBeanObservableValue(Realm
83	.getDefault(), temp,
84	new PropertyDescriptor("value", ThrowsGetException.class));
85		87
		88	public void testGetValueThrowsExceptionThrownByBean() throws Exception {
		89	ThrowsGetException errorThrowingBean = new ThrowsGetException();
		90	IObservableValue observable = BeansObservables.observeValue(
		91	errorThrowingBean, "value");
86	try {	92	try {
87	observable.getValue();	93	observable.getValue();
88	fail("exception should have been thrown");	94	fail("exception should have been thrown");
89	} catch (RuntimeException e) {	95	} catch (RuntimeException e) {
90	assertEquals(temp.thrownException, e.getCause());	96	assertEquals(errorThrowingBean.thrownException, e.getCause());
91	}	97	}
92	}	98	}
93		99
94	public void testBug198519() {	100	public void testBug198519() {
95	final SimplePerson person = new SimplePerson();	101	final SimplePerson person = new SimplePerson();
96	final ComputedValue cv = new ComputedValue() {	102	final ComputedValue cv = new ComputedValue() {
97	final IObservableValue name = BeansObservables.observeValue(person, "name"); //$NON-NLS-1$	103	final IObservableValue name = BeansObservables.observeValue(person,
98	protected Object calculate() {	104	"name"); //$NON-NLS-1$
99	return Boolean.valueOf(name.getValue() != null);	105
100	}	106	protected Object calculate() {
101	};	107	return Boolean.valueOf(name.getValue() != null);
102	cv.addChangeListener(new IChangeListener() {	108	}
103	public void handleChange(ChangeEvent event) {	109	};
104	cv.getValue();	110	cv.addChangeListener(new IChangeListener() {
105	}	111	public void handleChange(ChangeEvent event) {
106	});	112	cv.getValue();
107	person.setName("foo");	113	}
		114	});
		115	person.setName("foo");
108	}	116	}
109		117
110	public void testConstructor_RegistersListeners() throws Exception {	118	public void testConstructor_RegistersListeners() throws Exception {
111	JavaBeanObservableValue observable = new JavaBeanObservableValue(Realm.getDefault(), bean, propertyDescriptor);	119	IObservableValue observable = BeansObservables.observeValue(bean,
		120	propertyName);
112	ChangeEventTracker.observe(observable);	121	ChangeEventTracker.observe(observable);
113		122
114	assertTrue(bean.hasListeners(propertyName));	123	assertTrue(bean.hasListeners(propertyName));
115	}	124	}
116		125
117	public void testConstructor_SkipRegisterListeners() throws Exception {	126	public void testConstructor_SkipRegisterListeners() throws Exception {
118	JavaBeanObservableValue observable = new JavaBeanObservableValue(Realm.getDefault(), bean, propertyDescriptor, false);	127	IObservableValue observable = PojoObservables.observeValue(bean,
		128	propertyName);
119	ChangeEventTracker.observe(observable);	129	ChangeEventTracker.observe(observable);
120		130
121	assertFalse(bean.hasListeners(propertyName));	131	assertFalse(bean.hasListeners(propertyName));
122	}	132	}
123		133
124	public static Test suite() {	134	public static Test suite() {
125	TestSuite suite = new TestSuite(JavaBeanObservableValueTest.class.getName());	135	TestSuite suite = new TestSuite(JavaBeanObservableValueTest.class
		136	.getName());
126	suite.addTestSuite(JavaBeanObservableValueTest.class);	137	suite.addTestSuite(JavaBeanObservableValueTest.class);
127	suite.addTest(MutableObservableValueContractTest.suite(new Delegate()));	138	suite.addTest(MutableObservableValueContractTest.suite(new Delegate()));
128	return suite;	139	return suite;
129	}	140	}
130		141
131	/* package */ static class Delegate extends AbstractObservableValueContractDelegate {	142	/* package */static class Delegate extends
		143	AbstractObservableValueContractDelegate {
132	private Bean bean;	144	private Bean bean;
133		145
134	public void setUp() {	146	public void setUp() {
135	super.setUp();	147	super.setUp();
136		148
137	bean = new Bean("");	149	bean = new Bean("");
138	}	150	}
139		151
140	public IObservableValue createObservableValue(Realm realm) {	152	public IObservableValue createObservableValue(Realm realm) {
141	try {	153	return BeansObservables.observeValue(realm, bean, "value");
142	PropertyDescriptor propertyDescriptor = new PropertyDescriptor("value", Bean.class);
143	return new JavaBeanObservableValue(realm, bean,
144	propertyDescriptor);
145	} catch (IntrospectionException e) {
146	throw new RuntimeException(e);
147	}
148	}	154	}
149		155
150	public void change(IObservable observable) {	156	public void change(IObservable observable) {
151	IObservableValue observableValue = (IObservableValue) observable;	157	IObservableValue observableValue = (IObservableValue) observable;
152	observableValue.setValue(createValue(observableValue));	158	observableValue.setValue(createValue(observableValue));
153	}	159	}
154		160
155	public Object getValueType(IObservableValue observable) {	161	public Object getValueType(IObservableValue observable) {
156	return String.class;	162	return String.class;
157	}	163	}
158		164
159	public Object createValue(IObservableValue observable) {	165	public Object createValue(IObservableValue observable) {
160	return observable.getValue() + "a";	166	return observable.getValue() + "a";
161	}	167	}
162	}	168	}
163		169
164	/**	170	/**
165	* Throws an exception when the value is set.	171	* Throws an exception when the value is set.
166	*	172	*

Lines 7-16 Link Here

(-)src/org/eclipse/core/tests/databinding/beans/PojoObservablesTest.java (-18 / +16 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.tests.databinding.beans;	13	package org.eclipse.core.tests.databinding.beans;
13		14
		15	import org.eclipse.core.databinding.beans.IBeanObservable;
14	import org.eclipse.core.databinding.beans.PojoObservables;	16	import org.eclipse.core.databinding.beans.PojoObservables;
15	import org.eclipse.core.databinding.observable.Realm;	17	import org.eclipse.core.databinding.observable.Realm;
16	import org.eclipse.core.databinding.observable.list.IObservableList;	18	import org.eclipse.core.databinding.observable.list.IObservableList;
Lines 19-28 Link Here
19	import org.eclipse.core.databinding.observable.set.IObservableSet;	21	import org.eclipse.core.databinding.observable.set.IObservableSet;
20	import org.eclipse.core.databinding.observable.set.WritableSet;	22	import org.eclipse.core.databinding.observable.set.WritableSet;
21	import org.eclipse.core.databinding.observable.value.IObservableValue;	23	import org.eclipse.core.databinding.observable.value.IObservableValue;
22	import org.eclipse.core.internal.databinding.beans.JavaBeanObservableList;
23	import org.eclipse.core.internal.databinding.beans.JavaBeanObservableMap;
24	import org.eclipse.core.internal.databinding.beans.JavaBeanObservableSet;
25	import org.eclipse.core.internal.databinding.beans.JavaBeanObservableValue;
26	import org.eclipse.core.tests.internal.databinding.beans.Bean;	24	import org.eclipse.core.tests.internal.databinding.beans.Bean;
27	import org.eclipse.jface.databinding.conformance.util.ChangeEventTracker;	25	import org.eclipse.jface.databinding.conformance.util.ChangeEventTracker;
28	import org.eclipse.jface.databinding.conformance.util.CurrentRealm;	26	import org.eclipse.jface.databinding.conformance.util.CurrentRealm;
Lines 47-58 Link Here
47	propertyName = "value";	45	propertyName = "value";
48	}	46	}
49		47
50	public void testObserveValue_ReturnsJavaBeanObservableValue()	48	public void testObserveValue_ReturnsIBeanObservable()
51	throws Exception {	49	throws Exception {
52	IObservableValue value = PojoObservables.observeValue(pojo, propertyName);	50	IObservableValue value = PojoObservables.observeValue(pojo, propertyName);
53		51
54	assertNotNull(value);	52	assertNotNull(value);
55	assertTrue(value instanceof JavaBeanObservableValue);	53	assertTrue(value instanceof IBeanObservable);
56	}	54	}
57		55
58	public void testObserveValue_DoesNotAttachListeners() throws Exception {	56	public void testObserveValue_DoesNotAttachListeners() throws Exception {
Lines 62-78 Link Here
62	assertFalse(pojo.hasListeners(propertyName));	60	assertFalse(pojo.hasListeners(propertyName));
63	}	61	}
64		62
65	public void testObservableValueWithRealm_ReturnsJavaBeanObservable()	63	public void testObservableValueWithRealm_ReturnsIBeanObservable()
66	throws Exception {	64	throws Exception {
67	CurrentRealm realm = new CurrentRealm(true);	65	CurrentRealm realm = new CurrentRealm(true);
68	IObservableValue value = PojoObservables.observeValue(realm, pojo,	66	IObservableValue value = PojoObservables.observeValue(realm, pojo,
69	propertyName);	67	propertyName);
70		68
71	assertNotNull(value);	69	assertNotNull(value);
72	assertTrue(value instanceof JavaBeanObservableValue);	70	assertTrue(value instanceof IBeanObservable);
73	}	71	}
74		72
75	public void testObservableMap_ReturnsJavaBeanObservableMap()	73	public void testObservableMap_ReturnsIBeanObservable()
76	throws Exception {	74	throws Exception {
77	IObservableSet set = new WritableSet();	75	IObservableSet set = new WritableSet();
78	set.add(new Bean());	76	set.add(new Bean());
Lines 80-86 Link Here
80	IObservableMap map = PojoObservables.observeMap(set, Bean.class,	78	IObservableMap map = PojoObservables.observeMap(set, Bean.class,
81	propertyName);	79	propertyName);
82	assertNotNull(map);	80	assertNotNull(map);
83	assertTrue(map instanceof JavaBeanObservableMap);	81	assertTrue(map instanceof IBeanObservable);
84	}	82	}
85		83
86	public void testObservableMap_DoesNotAttachListeners() throws Exception {	84	public void testObservableMap_DoesNotAttachListeners() throws Exception {
Lines 101-109 Link Here
101	assertEquals(2, maps.length);	99	assertEquals(2, maps.length);
102	}	100	}
103		101
104	public void testObserveListWithElementType_ReturnsJavaBeanObservableList() throws Exception {	102	public void testObserveListWithElementType_ReturnsIBeanObservable() throws Exception {
105	IObservableList list = PojoObservables.observeList(Realm.getDefault(), pojo, "list", String.class);	103	IObservableList list = PojoObservables.observeList(Realm.getDefault(), pojo, "list", String.class);
106	assertTrue(list instanceof JavaBeanObservableList);	104	assertTrue(list instanceof IBeanObservable);
107	}	105	}
108		106
109	public void testObserveListWithElementType_DoesNotAttachListeners() throws Exception {	107	public void testObserveListWithElementType_DoesNotAttachListeners() throws Exception {
Lines 113-121 Link Here
113	assertFalse(pojo.hasListeners("list"));	111	assertFalse(pojo.hasListeners("list"));
114	}	112	}
115		113
116	public void testObserveList_ReturnsJavaBeanObservableList() throws Exception {	114	public void testObserveList_ReturnsIBeanObservable() throws Exception {
117	IObservableList observable = PojoObservables.observeList(Realm.getDefault(), pojo, "list");	115	IObservableList observable = PojoObservables.observeList(Realm.getDefault(), pojo, "list");
118	assertTrue(observable instanceof JavaBeanObservableList);	116	assertTrue(observable instanceof IBeanObservable);
119	}	117	}
120		118
121	public void testObserveList_DoesNotAttachListeners() throws Exception {	119	public void testObserveList_DoesNotAttachListeners() throws Exception {
Lines 125-133 Link Here
125	assertFalse(pojo.hasListeners("list"));	123	assertFalse(pojo.hasListeners("list"));
126	}	124	}
127		125
128	public void testObserveSetWithElementType_ReturnsJavaBeanObservableList() throws Exception {	126	public void testObserveSetWithElementType_ReturnsIBeanObservable() throws Exception {
129	IObservableSet list = PojoObservables.observeSet(Realm.getDefault(), pojo, "set", String.class);	127	IObservableSet list = PojoObservables.observeSet(Realm.getDefault(), pojo, "set", String.class);
130	assertTrue(list instanceof JavaBeanObservableSet);	128	assertTrue(list instanceof IBeanObservable);
131	}	129	}
132		130
133	public void testObserveSetWithElementType_DoesNotAttachListeners() throws Exception {	131	public void testObserveSetWithElementType_DoesNotAttachListeners() throws Exception {
Lines 137-145 Link Here
137	assertFalse(pojo.hasListeners("set"));	135	assertFalse(pojo.hasListeners("set"));
138	}	136	}
139		137
140	public void testObserveSet_ReturnsJavaBeanObservableList() throws Exception {	138	public void testObserveSet_ReturnsIBeanObservable() throws Exception {
141	IObservableSet list = PojoObservables.observeSet(Realm.getDefault(), pojo, "set");	139	IObservableSet list = PojoObservables.observeSet(Realm.getDefault(), pojo, "set");
142	assertTrue(list instanceof JavaBeanObservableSet);	140	assertTrue(list instanceof IBeanObservable);
143	}	141	}
144		142
145	public void testObserveSet_DoesNotAttachListeners() throws Exception {	143	public void testObserveSet_DoesNotAttachListeners() throws Exception {