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




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.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.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.internal.databinding.beans.JavaBeanPropertyObservableMap;
import org.eclipse.core.runtime.Assert;

/**

	 */
	public static IObservableValue observeValue(Realm realm, Object bean,
			String propertyName) {
		return PropertyObservables.observeValue(realm, bean, BeanProperties
				.valueProperty(bean.getClass(), propertyName));
		return new JavaBeanObservableValue(realm, bean, descriptor);
	}

	/**

	 */
	public static IObservableMap observeMap(IObservableSet domain,
			Class beanClass, String propertyName) {
		return PropertyObservables.observeMap(domain, BeanProperties
				.valueProperty(beanClass, propertyName));
		return new JavaBeanObservableMap(domain, descriptor);
	}

	/**

	 */
	public static IObservableMap observeMap(Realm realm, Object bean,
			String propertyName) {
		return PropertyObservables.observeMap(realm, bean, BeanProperties
				.mapProperty(bean.getClass(), propertyName));
		return new JavaBeanPropertyObservableMap(realm, bean, descriptor);
	}

	/**

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

	/* package */static PropertyDescriptor getPropertyDescriptor(
			Class beanClass, String propertyName) {
		BeanInfo beanInfo;
		try {
			beanInfo = Introspector.getBeanInfo(beanClass);

	 * 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) {
		return PropertyObservables.observeList(realm, bean, BeanProperties
				.listProperty(bean.getClass(), propertyName, elementType));
		elementType = getCollectionElementType(elementType, propertyDescriptor);

		return new JavaBeanObservableList(realm, bean, propertyDescriptor,
				elementType);
	}

	/**


		IObservableValue value = MasterDetailObservables.detailValue(master,
				valueFactory(realm, propertyName), propertyType);
		return new BeanObservableValueDecorator(value, master,
				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, master,
				getPropertyDescriptor(masterType, propertyName));
						propertyName));

		return decorator;
	}

	/**

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

		return decorator;
	}

	/**

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

		return decorator;
	}

	/**

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

	/**

	 */
	public static IObservableSet observeSet(Realm realm, Object bean,
			String propertyName, Class elementType) {
		return PropertyObservables.observeSet(realm, bean, BeanProperties
				.setProperty(bean.getClass(), propertyName, elementType));
		elementType = getCollectionElementType(elementType, propertyDescriptor);

		return new JavaBeanObservableSet(realm, bean, propertyDescriptor,
				elementType);
	}

	/**

	 * @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

	}

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




package org.eclipse.core.databinding.beans;

import java.beans.PropertyChangeEvent;
import java.beans.PropertyDescriptor;

import org.eclipse.core.databinding.observable.IObservable;
import org.eclipse.core.databinding.observable.Realm;

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.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.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.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) {
		return PropertyObservables.observeValue(realm, pojo, PojoProperties
				.valueProperty(pojo.getClass(), propertyName));
				pojo.getClass(), propertyName);
		return new JavaBeanObservableValue(realm, pojo, descriptor, false);
	}

	/**

	 */
	public static IObservableMap observeMap(IObservableSet domain,
			Class pojoClass, String propertyName) {
		return PropertyObservables.observeMap(domain, PojoProperties
				.valueProperty(pojoClass, propertyName));
		return new JavaBeanObservableMap(domain, descriptor, false);
	}

	/**

	 */
	public static IObservableMap observeMap(Realm realm, Object pojo,
			String propertyName) {
		return PropertyObservables.observeMap(realm, pojo, PojoProperties
				.mapProperty(pojo.getClass(), propertyName));
		return new JavaBeanPropertyObservableMap(realm, pojo, descriptor, false);
	}

	/**

	 * 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) {
		return PropertyObservables.observeList(realm, pojo, PojoProperties
				.listProperty(pojo.getClass(), propertyName, elementType));
		elementType = BeansObservables.getCollectionElementType(elementType,
				propertyDescriptor);

		return new JavaBeanObservableList(realm, pojo, propertyDescriptor,
				elementType, false);
	}

	/**

	 */
	public static IObservableSet observeSet(Realm realm, Object pojo,
			String propertyName, Class elementType) {
		return PropertyObservables.observeSet(realm, pojo, PojoProperties
				.setProperty(pojo.getClass(), propertyName, elementType));
		elementType = BeansObservables.getCollectionElementType(elementType,
				propertyDescriptor);

		return new JavaBeanObservableSet(realm, pojo, propertyDescriptor,
				elementType, false);
	}

	/**


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

		return decorator;
	}

	/**

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

		return decorator;
	}

	/**

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

		return decorator;
	}

	/**

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

	/**




/*******************************************************************************
 * Copyright (c) 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
 ******************************************************************************/

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

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

import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.beans.PropertyDescriptor;
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.observable.map.MapDiff;
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 boolean updating;

	private ListenerSupport listenerSupport;

	/**
	 * @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) {
							if (!updating) {
								MapDiff diff;
								if (evt.getOldValue() == null
										&& evt.getNewValue() == null) {
									// Obscure condition indicating new and old
									// values are unknown
									diff = null;
								} else {
									diff = Diffs.computeMapDiff(asMap(evt
											.getOldValue()), asMap(evt
											.getNewValue()));
								}
								fireMapChange(evt.getSource(), diff);
							}
						}
					};
					listenerSupport = new ListenerSupport(
							propertyChangeListener, propertyDescriptor
									.getName());
				}
			}
		}
	}

	protected void addListenerTo(Object source) {
		if (attachListener) {
			initListenerSupport();
			listenerSupport.hookListener(source);
		}
	}

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

	public Map getMap(Object source) {
		return asMap(BeanPropertyHelper.getProperty(source, propertyDescriptor));
	}

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

	public void setMap(Object source, Map map) {
		Map oldMap = getMap(source);

		if (Util.equals(oldMap, map)) {
			return;
		}

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

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

	public synchronized void dispose() {
		if (listenerSupport != null) {
			listenerSupport.dispose();
			listenerSupport = null;
		}
		propertyDescriptor = 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
 ******************************************************************************/

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

import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.beans.PropertyDescriptor;

import org.eclipse.core.databinding.beans.IBeanProperty;
import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.observable.value.ValueDiff;
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 boolean updating;

	private ListenerSupport listenerSupport;

	/**
	 * @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) {
							if (!updating) {
								ValueDiff diff;
								if (evt.getOldValue() == null
										&& evt.getOldValue() == null) {
									// Obscure condition indicating new and old
									// values are unknown
									diff = null;
								} else {
									diff = Diffs.createValueDiff(evt
											.getOldValue(), evt.getNewValue());
								}
								fireValueChange(evt.getSource(), diff);
							}
						}
					};
					listenerSupport = new ListenerSupport(
							propertyChangeListener, propertyDescriptor
									.getName());
				}
			}
		}
	}

	protected void addListenerTo(Object source) {
		if (attachListener) {
			initListenerSupport();
			listenerSupport.hookListener(source);
		}
	}

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

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

	public void setValue(Object source, Object value) {
		Object oldValue = getValue(source);

		if (Util.equals(oldValue, value)) {
			return;
		}

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

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

	public Object getValueType() {
		return valueType;
	}

	public synchronized void dispose() {
		if (listenerSupport != null) {
			listenerSupport.dispose();
			listenerSupport = null;
		}
		propertyDescriptor = 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
 ******************************************************************************/

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.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(BeansObservables.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(BeansObservables.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(BeansObservables.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(BeansObservables.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
 ******************************************************************************/

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.List;

import org.eclipse.core.databinding.beans.IBeanProperty;
import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.observable.list.ListDiff;
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 boolean updating;

	private ListenerSupport listenerSupport;

	/**
	 * @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) {
							if (!updating) {
								ListDiff diff;
								if (evt.getOldValue() == null
										&& evt.getOldValue() == null) {
									// Obscure condition indicating new and old
									// values are unknown
									diff = null;
								} else {
									diff = Diffs.computeListDiff(asList(evt
											.getOldValue()), asList(evt
											.getNewValue()));
								}
								fireListChange(evt.getSource(), diff);
							}
						}
					};
					listenerSupport = new ListenerSupport(
							propertyChangeListener, propertyDescriptor
									.getName());
				}
			}
		}
	}

	protected void addListenerTo(Object source) {
		if (attachListener) {
			initListenerSupport();
			listenerSupport.hookListener(source);
		}
	}

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

	public List getList(Object source) {
		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;
	}

	public void setList(Object source, List list) {
		List oldList = getList(source);

		if (Util.equals(oldList, list))
			return;

		updating = true;
		try {
			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;
			}
			BeanPropertyHelper.setProperty(source, propertyDescriptor,
					propertyValue);
		} finally {
			updating = false;
		}

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

	public Object getElementType() {
		return elementType;
	}

	public synchronized void dispose() {
		if (listenerSupport != null) {
			listenerSupport.dispose();
			listenerSupport = null;
		}
		propertyDescriptor = 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
 ******************************************************************************/

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.HashSet;
import java.util.Set;

import org.eclipse.core.databinding.beans.IBeanProperty;
import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.observable.set.SetDiff;
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 boolean updating;

	private ListenerSupport listenerSupport;

	/**
	 * @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) {
							if (!updating) {
								SetDiff diff;
								if (evt.getOldValue() == null
										&& evt.getOldValue() == null) {
									// Obscure condition indicating new and old
									// values are unknown
									diff = null;
								} else {
									diff = Diffs.computeSetDiff(asSet(evt
											.getOldValue()), asSet(evt
											.getNewValue()));
								}
								fireSetChange(evt.getSource(), diff);
							}
						}
					};
					listenerSupport = new ListenerSupport(
							propertyChangeListener, propertyDescriptor
									.getName());
				}
			}
		}
	}

	protected void addListenerTo(Object source) {
		if (attachListener) {
			initListenerSupport();
			listenerSupport.hookListener(source);
		}
	}

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

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

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

	public void setSet(Object source, Set set) {
		Set oldSet = getSet(source);

		if (Util.equals(oldSet, set))
			return;

		updating = true;
		try {
			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;
			}
			BeanPropertyHelper.setProperty(source, propertyDescriptor,
					propertyValue);
		} finally {
			updating = false;
		}

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

	public Object getElementType() {
		return elementType;
	}

	public synchronized void dispose() {
		if (listenerSupport != null) {
			listenerSupport.dispose();
			listenerSupport = null;
		}
		propertyDescriptor = 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
 ******************************************************************************/

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.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(BeansObservables.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(BeansObservables.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(BeansObservables.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(BeansObservables.getPropertyDescriptor(
				beanClass, propertyName), true);
	}
}




/*******************************************************************************
 * Copyright (c) 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
 ******************************************************************************/

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

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




 */
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 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 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.core.databinding.property;

import java.util.List;

/**
 * @since 1.2
 * 
 */
public interface IListProperty extends IProperty {
	/**
	 * @param source
	 * @return the list property of the given source
	 */
	public List getList(Object source);

	/**
	 * @param source
	 * @param list
	 */
	public void setList(Object source, List list);

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

	/**
	 * @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 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.core.databinding.property;

import java.util.Set;

/**
 * @since 1.2
 * 
 */
public interface ISetProperty extends IProperty {
	/**
	 * @param source
	 * @return the list property of the given source
	 */
	public Set getSet(Object source);

	/**
	 * @param source
	 * @param set
	 */
	public void setSet(Object source, Set set);

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

	/**
	 * @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 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.core.databinding.property;

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

/**
 * @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;
		this.diff = diff;
	}

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




/*******************************************************************************
 * Copyright (c) 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
 ******************************************************************************/

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 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 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.core.databinding.property;

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

/**
 * @since 1.2
 */
public abstract class ListProperty extends Property implements IListProperty {
	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 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

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

import java.util.Collection;
import java.util.Collections;
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.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 {
	private Object source;
	private IMapProperty property;

	private Map cachedMap;

	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++;
								if (event.diff == null) {
									Map oldMap = cachedMap;
									Map newMap = cachedMap = property
											.getMap(source);
									fireMapChange(Diffs.computeMapDiff(oldMap,
											newMap));
								} else {
									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;

		this.cachedMap = property.getMap(source);
	}

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

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

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

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

	private void setMap(Map set) {
		Map oldMap = cachedMap;

		updating = true;
		try {
			property.setMap(source, new HashMap(set));
			modCount++;
		} finally {
			updating = false;
		}

		Map newMap = cachedMap = getMap();
		if (!oldMap.equals(newMap)) {
			fireMapChange(Diffs.computeMapDiff(oldMap, newMap));
		}
	}

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

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

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

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

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

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

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

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

	public Object put(Object key, Object value) {
		checkRealm();
		Map map = new HashMap(getMap());
		Object result = map.put(key, value);
		setMap(map);
		return result;
	}

	public void putAll(Map m) {
		checkRealm();
		Map map = new HashMap(getMap());
		map.putAll(m);
		setMap(map);
	}

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

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

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

	public void clear() {
		getterCalled();
		setMap(new HashMap());
	}

	public synchronized void dispose() {
		if (!disposed) {
			disposed = true;
			property.removeMapChangeListener(source, listener);
			property = null;
			source = null;
		}
		super.dispose();
	}
}




/*******************************************************************************
 * Copyright (c) 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
 ******************************************************************************/

package org.eclipse.core.databinding.property;

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

/**
 * @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;
		this.diff = diff;
	}

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




/*******************************************************************************
 * Copyright (c) 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
 ******************************************************************************/

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 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.core.databinding.property;

import java.util.Map;

/**
 * @since 1.2
 * 
 */
public interface IMapProperty extends IProperty {
	/**
	 * @param source
	 * @return the list property of the given source
	 */
	public Map getMap(Object source);

	/**
	 * @param source
	 * @param map
	 */
	public void setMap(Object source, Map map);

	/**
	 * @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 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.core.databinding.property;

/**
 * @since 1.2
 */
public interface IMapPropertyChangeListener extends IPropertyChangeListener {
	/**
	 * @param event
	 */
	public void handleMapPropertyChange(MapPropertyChangeEvent event);
}




/*******************************************************************************
 * Copyright (c) 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
 ******************************************************************************/

package org.eclipse.core.databinding.property;

/**
 * @since 1.2
 */
public interface IValuePropertyChangeListener extends IPropertyChangeListener {
	/**
	 * @param event
	 */
	public void handleValuePropertyChange(ValuePropertyChangeEvent event);
}




/*******************************************************************************
 * Copyright (c) 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
 ******************************************************************************/

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 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

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

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

import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.observable.IStaleListener;
import org.eclipse.core.databinding.observable.ObservableTracker;
import org.eclipse.core.databinding.observable.StaleEvent;
import org.eclipse.core.databinding.observable.map.AbstractObservableMap;
import org.eclipse.core.databinding.observable.map.IMapChangeListener;
import org.eclipse.core.databinding.observable.map.IObservableMap;
import org.eclipse.core.databinding.observable.map.MapChangeEvent;
import org.eclipse.core.databinding.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 {
	private IObservableMap map;
	private IValueProperty property;

	private Map keyToPropertySourceListener;

	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 newPropertySource = event.diff
									.getNewValue(key);
							Object newValue = property
									.getValue(newPropertySource);
							newValues.put(key, newValue);
							addPropertySourceListener(key, newPropertySource);
						}

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

						Set changedKeys = new HashSet(event.diff
								.getChangedKeys());
						for (Iterator it = changedKeys.iterator(); it.hasNext();) {
							Object key = it.next();
							Object oldPropertySource = event.diff
									.getOldValue(key);
							Object oldValue = property
									.getValue(oldPropertySource);
							Object newPropertySource = event.diff
									.getNewValue(key);
							Object newValue = property
									.getValue(newPropertySource);
							if (Util.equals(oldValue, newValue)) {
								it.remove();
							} else {
								oldValues.put(key, oldValue);
								newValues.put(key, newValue);
							}
							addPropertySourceListener(key, newPropertySource);
							removePropertySourceListener(key, oldPropertySource);
						}

						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.keyToPropertySourceListener = new HashMap();
	}

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

			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 propertySource = entry.getValue();

				addPropertySourceListener(key, propertySource);
			}
		}
	}

	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);
		keyToPropertySourceListener.put(key, propertyListener);
	}

	private void removePropertySourceListener(Object key, Object propertySource) {
		IValuePropertyChangeListener propertyListener = (IValuePropertyChangeListener) keyToPropertySourceListener
				.get(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 propertySource = map.get(key);

		Object oldValue = property.getValue(propertySource);

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

		Object newValue = property.getValue(propertySource);

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

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 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.core.databinding.property;

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

/**
 * @since 1.2
 */
public abstract class SetProperty extends Property implements ISetProperty {
	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 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.core.databinding.property;

/**
 * @since 1.2
 */
public interface ISetPropertyChangeListener extends IPropertyChangeListener {
	/**
	 * @param event
	 */
	public void handleSetPropertyChange(SetPropertyChangeEvent event);
}




/*******************************************************************************
 * Copyright (c) 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
 ******************************************************************************/

package org.eclipse.core.databinding.property;

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

/**
 * @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;
		this.diff = diff;
	}

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




/*******************************************************************************
 * Copyright (c) 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
 ******************************************************************************/

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 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.core.databinding.property;

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

/**
 * @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;
		this.diff = diff;
	}

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




/*******************************************************************************
 * Copyright (c) 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
 ******************************************************************************/

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 = changeListeners != null
				&& changeListeners.containsKey(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);
	}

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

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 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

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

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

	private List cachedList;

	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++;
								if (event.diff == null) {
									List oldList = cachedList;
									List newList = cachedList = property
											.getList(source);
									fireListChange(Diffs.computeListDiff(
											oldList, newList));
								} else {
									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;

		this.cachedList = property.getList(source);
	}

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

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

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

	private void setList(List list) {
		List oldList = cachedList;

		updating = true;
		try {
			property.setList(source, new ArrayList(list));
			modCount++;
		} finally {
			updating = false;
		}

		List newList = cachedList = getList();
		if (!oldList.equals(newList)) {
			fireListChange(Diffs.computeListDiff(oldList, newList));
		}
	}

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

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

	// Queries

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

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

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

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

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

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

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

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

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

	// Single change operations

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

	public Iterator iterator() {
		getterCalled();
		return new Iterator() {
			int lastReturned = -1;
			int expectedModCount = modCount;
			ListIterator delegate = new ArrayList(getList()).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();

				List list = new ArrayList(getList());
				list.remove(lastReturned);
				setList(list);
				delegate.remove(); // stay in sync
				lastReturned = -1;
				expectedModCount = modCount;
			}

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

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

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

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

	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(getList())
					.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

				List list = new ArrayList(getList());
				list.add(index, o);
				setList(list);

				lastReturned = -1;
				expectedModCount = modCount;
			}

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

				delegate.set(o);

				List list = new ArrayList(getList());
				list.set(lastReturned, o);
				setList(list);
				expectedModCount = modCount;
			}

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

				delegate.remove(); // keep in sync

				List list = new ArrayList(getList());
				list.remove(lastReturned);
				setList(list);
				lastReturned = -1;
				expectedModCount = modCount;
			}

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

		};
	}

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

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

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

	// Bulk change operations

	public boolean addAll(Collection c) {
		getterCalled();
		List list = new ArrayList(getList());
		boolean result = list.addAll(c);
		if (result) {
			setList(list);
		}
		return result;
	}

	public boolean addAll(int index, Collection c) {
		getterCalled();
		List list = new ArrayList(getList());
		boolean result = list.addAll(index, c);
		if (result) {
			setList(list);
		}
		return result;
	}

	public boolean removeAll(Collection c) {
		getterCalled();
		List list = new ArrayList(getList());
		boolean result = list.removeAll(c);
		if (result) {
			setList(list);
		}
		return result;
	}

	public boolean retainAll(Collection c) {
		getterCalled();
		List list = new ArrayList(getList());
		boolean result = retainAll(c);
		if (result) {
			setList(list);
		}
		return result;
	}

	public void clear() {
		getterCalled();
		setList(new ArrayList());
	}

	public synchronized void dispose() {
		if (!disposed) {
			disposed = true;
			property.removeListChangeListener(source, listener);
			property = null;
			source = null;
		}
		super.dispose();
	}

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

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




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

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 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 ******************************************************************************/

package org.eclipse.core.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.Diffs;
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 {
	private Object source;
	private ISetProperty property;

	private Set cachedSet;

	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++;
								if (event.diff == null) {
									Set oldSet = cachedSet;
									Set newSet = cachedSet = property
											.getSet(source);
									fireSetChange(Diffs.computeSetDiff(oldSet,
											newSet));
								} else {
									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;

		this.cachedSet = property.getSet(source);
	}

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

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

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

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

	private void setSet(Set set) {
		Set oldSet = cachedSet;

		updating = true;
		try {
			property.setSet(source, new HashSet(set));
			modCount++;
		} finally {
			updating = false;
		}

		Set newSet = cachedSet = getSet();
		if (!oldSet.equals(newSet)) {
			fireSetChange(Diffs.computeSetDiff(oldSet, newSet));
		}
	}

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

	// Queries

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

	// Single change operations

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

	public Iterator iterator() {
		getterCalled();
		return new Iterator() {
			int expectedModCount = modCount;
			Iterator delegate = new HashSet(getSet()).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

				Set set = new HashSet(getSet());
				set.remove(last);
				setSet(set);

				last = null;
				expectedModCount = modCount;
			}

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

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

	// Bulk change operations

	public boolean addAll(Collection c) {
		getterCalled();
		Set set = new HashSet(getSet());
		boolean result = set.addAll(c);
		if (result) {
			setSet(set);
		}
		return result;
	}

	public boolean removeAll(Collection c) {
		getterCalled();
		Set set = new HashSet(getSet());
		boolean result = set.removeAll(c);
		if (result) {
			setSet(set);
		}
		return result;
	}

	public boolean retainAll(Collection c) {
		getterCalled();
		Set set = new HashSet(getSet());
		boolean result = retainAll(c);
		if (result) {
			setSet(set);
		}
		return result;
	}

	public void clear() {
		getterCalled();
		setSet(new HashSet());
	}

	public synchronized void dispose() {
		if (!disposed) {
			disposed = true;
			property.removeSetChangeListener(source, listener);
			property = null;
			source = null;
		}
		super.dispose();
	}
}




/*******************************************************************************
 * Copyright (c) 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
 ******************************************************************************/

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

import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.observable.map.ComputedObservableMap;
import org.eclipse.core.databinding.observable.set.IObservableSet;
import org.eclipse.core.databinding.property.IValueProperty;
import org.eclipse.core.databinding.property.IValuePropertyChangeListener;
import org.eclipse.core.databinding.property.ValuePropertyChangeEvent;

/**
 * @since 3.3
 * 
 */
public class SetValuePropertyObservableMap extends ComputedObservableMap {
	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 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
 ******************************************************************************/

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

import org.eclipse.core.databinding.observable.Diffs;
import org.eclipse.core.databinding.observable.Realm;
import org.eclipse.core.databinding.observable.value.AbstractObservableValue;
import org.eclipse.core.databinding.property.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 {
	private Object source;
	private IValueProperty property;

	private Object cachedValue;

	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() {
						if (event.diff == null) {
							Object oldValue = cachedValue;
							Object newValue = cachedValue = property
									.getValue(source);
							fireValueChange(Diffs.createValueDiff(oldValue,
									newValue));
						} else {
							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;

		this.cachedValue = property.getValue(source);
	}

	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 = cachedValue;

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

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

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

	public synchronized void dispose() {
		if (!disposed) {
			disposed = true;
			property.removeValueChangeListener(source, listener);
			cachedValue = null;
			property = null;
			source = null;
		}
		super.dispose();
	}
}




/*******************************************************************************
 * Copyright (c) 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
 ******************************************************************************/

package org.eclipse.core.databinding.property;

/**
 * @since 1.2
 */
public class MasterDetailProperties {
	/**
	 * @param masterValue
	 * @param detailValue
	 * @return blah
	 */
	public static IValueProperty detailValue(IValueProperty masterValue,
			IValueProperty detailValue) {
		return null;
	}

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

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

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

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

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

	/**
	 * @param masterMap
	 * @param detailValues
	 * @return blah
	 */
	public static IMapProperty detailMap(IMapProperty masterMap,
			IValueProperty detailValues) {
		return null;
	}
}




/*******************************************************************************
 * Copyright (c) 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
 ******************************************************************************/

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

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

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

Return to bug 194734

Lines 13-19 Link Here

(-)src/org/eclipse/core/databinding/beans/PojoObservables.java (-54 / +27 lines)
13	package org.eclipse.core.databinding.beans;	13	package org.eclipse.core.databinding.beans;
14		14
15	import java.beans.PropertyChangeEvent;	15	import java.beans.PropertyChangeEvent;
16	import java.beans.PropertyDescriptor;
17		16
18	import org.eclipse.core.databinding.observable.IObservable;	17	import org.eclipse.core.databinding.observable.IObservable;
19	import org.eclipse.core.databinding.observable.Realm;	18	import org.eclipse.core.databinding.observable.Realm;
Lines 23-37 Link Here
23	import org.eclipse.core.databinding.observable.masterdetail.MasterDetailObservables;	22	import org.eclipse.core.databinding.observable.masterdetail.MasterDetailObservables;
24	import org.eclipse.core.databinding.observable.set.IObservableSet;	23	import org.eclipse.core.databinding.observable.set.IObservableSet;
25	import org.eclipse.core.databinding.observable.value.IObservableValue;	24	import org.eclipse.core.databinding.observable.value.IObservableValue;
		25	import org.eclipse.core.databinding.property.PropertyObservables;
26	import org.eclipse.core.internal.databinding.beans.BeanObservableListDecorator;	26	import org.eclipse.core.internal.databinding.beans.BeanObservableListDecorator;
27	import org.eclipse.core.internal.databinding.beans.BeanObservableMapDecorator;	27	import org.eclipse.core.internal.databinding.beans.BeanObservableMapDecorator;
28	import org.eclipse.core.internal.databinding.beans.BeanObservableSetDecorator;	28	import org.eclipse.core.internal.databinding.beans.BeanObservableSetDecorator;
29	import org.eclipse.core.internal.databinding.beans.BeanObservableValueDecorator;	29	import org.eclipse.core.internal.databinding.beans.BeanObservableValueDecorator;
30	import org.eclipse.core.internal.databinding.beans.JavaBeanObservableList;
31	import org.eclipse.core.internal.databinding.beans.JavaBeanObservableMap;
32	import org.eclipse.core.internal.databinding.beans.JavaBeanObservableSet;
33	import org.eclipse.core.internal.databinding.beans.JavaBeanObservableValue;
34	import org.eclipse.core.internal.databinding.beans.JavaBeanPropertyObservableMap;
35		30
36	/**	31	/**
37	* A factory for creating observable objects for POJOs (plain old java objects)	32	* A factory for creating observable objects for POJOs (plain old java objects)
Lines 73-82 Link Here
73	*/	68	*/
74	public static IObservableValue observeValue(Realm realm, Object pojo,	69	public static IObservableValue observeValue(Realm realm, Object pojo,
75	String propertyName) {	70	String propertyName) {
76		71	return PropertyObservables.observeValue(realm, pojo, PojoProperties
77	PropertyDescriptor descriptor = BeansObservables.getPropertyDescriptor(	72	.valueProperty(pojo.getClass(), propertyName));
78	pojo.getClass(), propertyName);
79	return new JavaBeanObservableValue(realm, pojo, descriptor, false);
80	}	73	}
81		74
82	/**	75	/**
Lines 94-102 Link Here
94	*/	87	*/
95	public static IObservableMap observeMap(IObservableSet domain,	88	public static IObservableMap observeMap(IObservableSet domain,
96	Class pojoClass, String propertyName) {	89	Class pojoClass, String propertyName) {
97	PropertyDescriptor descriptor = BeansObservables.getPropertyDescriptor(	90	return PropertyObservables.observeMap(domain, PojoProperties
98	pojoClass, propertyName);	91	.valueProperty(pojoClass, propertyName));
99	return new JavaBeanObservableMap(domain, descriptor, false);
100	}	92	}
101		93
102	/**	94	/**
Lines 136-144 Link Here
136	*/	128	*/
137	public static IObservableMap observeMap(Realm realm, Object pojo,	129	public static IObservableMap observeMap(Realm realm, Object pojo,
138	String propertyName) {	130	String propertyName) {
139	PropertyDescriptor descriptor = BeansObservables.getPropertyDescriptor(	131	return PropertyObservables.observeMap(realm, pojo, PojoProperties
140	pojo.getClass(), propertyName);	132	.mapProperty(pojo.getClass(), propertyName));
141	return new JavaBeanPropertyObservableMap(realm, pojo, descriptor, false);
142	}	133	}
143		134
144	/**	135	/**
Lines 200-208 Link Here
200	* collection-typed named property of the given bean object. The returned	191	* collection-typed named property of the given bean object. The returned
201	* list is mutable. When an item is added or removed the setter is invoked	192	* list is mutable. When an item is added or removed the setter is invoked
202	* for the list on the parent bean to provide notification to other	193	* for the list on the parent bean to provide notification to other
203	* listeners via <code>PropertyChangeEvents</code>. This is done to	194	* listeners via <code>PropertyChangeEvents</code>. This is done to provide
204	* provide the same behavior as is expected from arrays as specified in the	195	* the same behavior as is expected from arrays as specified in the bean
205	* bean spec in section 7.2.	196	* spec in section 7.2.
206	*	197	*
207	* @param realm	198	* @param realm
208	* the realm	199	* the realm
Lines 211-218 Link Here
211	* @param propertyName	202	* @param propertyName
212	* the name of the property	203	* the name of the property
213	* @param elementType	204	* @param elementType
214	* type of the elements in the list. If <code>null</code> and	205	* type of the elements in the list. If <code>null</code> and the
215	* the property is an array the type will be inferred. If	206	* property is an array the type will be inferred. If
216	* <code>null</code> and the property type cannot be inferred	207	* <code>null</code> and the property type cannot be inferred
217	* element type will be <code>null</code>.	208	* element type will be <code>null</code>.
218	* @return an observable list tracking the collection-typed named property	209	* @return an observable list tracking the collection-typed named property
Lines 220-232 Link Here
220	*/	211	*/
221	public static IObservableList observeList(Realm realm, Object pojo,	212	public static IObservableList observeList(Realm realm, Object pojo,
222	String propertyName, Class elementType) {	213	String propertyName, Class elementType) {
223	PropertyDescriptor propertyDescriptor = BeansObservables	214	return PropertyObservables.observeList(realm, pojo, PojoProperties
224	.getPropertyDescriptor(pojo.getClass(), propertyName);	215	.listProperty(pojo.getClass(), propertyName, elementType));
225	elementType = BeansObservables.getCollectionElementType(elementType,
226	propertyDescriptor);
227
228	return new JavaBeanObservableList(realm, pojo, propertyDescriptor,
229	elementType, false);
230	}	216	}
231		217
232	/**	218	/**
Lines 310-322 Link Here
310	*/	296	*/
311	public static IObservableSet observeSet(Realm realm, Object pojo,	297	public static IObservableSet observeSet(Realm realm, Object pojo,
312	String propertyName, Class elementType) {	298	String propertyName, Class elementType) {
313	PropertyDescriptor propertyDescriptor = BeansObservables	299	return PropertyObservables.observeSet(realm, pojo, PojoProperties
314	.getPropertyDescriptor(pojo.getClass(), propertyName);	300	.setProperty(pojo.getClass(), propertyName, elementType));
315	elementType = BeansObservables.getCollectionElementType(elementType,
316	propertyDescriptor);
317
318	return new JavaBeanObservableSet(realm, pojo, propertyDescriptor,
319	elementType, false);
320	}	301	}
321		302
322	/**	303	/**
Lines 540-550 Link Here
540		521
541	IObservableValue value = MasterDetailObservables.detailValue(master,	522	IObservableValue value = MasterDetailObservables.detailValue(master,
542	valueFactory(realm, propertyName), propertyType);	523	valueFactory(realm, propertyName), propertyType);
543	BeanObservableValueDecorator decorator = new BeanObservableValueDecorator(	524	return new BeanObservableValueDecorator(value, master, BeansObservables
544	value, master, BeansObservables.getValueTypePropertyDescriptor(	525	.getValueTypePropertyDescriptor(master, propertyName));
545	master, propertyName));
546
547	return decorator;
548	}	526	}
549		527
550	/**	528	/**
Lines 587-597 Link Here
587	IObservableList observableList = MasterDetailObservables.detailList(	565	IObservableList observableList = MasterDetailObservables.detailList(
588	master, listFactory(realm, propertyName, propertyType),	566	master, listFactory(realm, propertyName, propertyType),
589	propertyType);	567	propertyType);
590	BeanObservableListDecorator decorator = new BeanObservableListDecorator(	568	return new BeanObservableListDecorator(observableList, master,
591	observableList, master, BeansObservables	569	BeansObservables.getValueTypePropertyDescriptor(master,
592	.getValueTypePropertyDescriptor(master, propertyName));	570	propertyName));
593
594	return decorator;
595	}	571	}
596		572
597	/**	573	/**
Lines 635-645 Link Here
635	IObservableSet observableSet = MasterDetailObservables.detailSet(	611	IObservableSet observableSet = MasterDetailObservables.detailSet(
636	master, setFactory(realm, propertyName, propertyType),	612	master, setFactory(realm, propertyName, propertyType),
637	propertyType);	613	propertyType);
638	BeanObservableSetDecorator decorator = new BeanObservableSetDecorator(	614	return new BeanObservableSetDecorator(observableSet, master,
639	observableSet, master, BeansObservables	615	BeansObservables.getValueTypePropertyDescriptor(master,
640	.getValueTypePropertyDescriptor(master, propertyName));	616	propertyName));
641
642	return decorator;
643	}	617	}
644		618
645	/**	619	/**
Lines 676-685 Link Here
676	IObservableValue master, String propertyName) {	650	IObservableValue master, String propertyName) {
677	IObservableMap observableMap = MasterDetailObservables.detailMap(	651	IObservableMap observableMap = MasterDetailObservables.detailMap(
678	master, mapPropertyFactory(realm, propertyName));	652	master, mapPropertyFactory(realm, propertyName));
679	BeanObservableMapDecorator decorator = new BeanObservableMapDecorator(	653	return new BeanObservableMapDecorator(observableMap, master,
680	observableMap, master, BeansObservables	654	BeansObservables.getValueTypePropertyDescriptor(master,
681	.getValueTypePropertyDescriptor(master, propertyName));	655	propertyName));
682	return decorator;
683	}	656	}
684		657
685	/**	658	/**

Added Link Here

(-)src/org/eclipse/core/internal/databinding/beans/BeanMapProperty.java (+133 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
10	******************************************************************************/
11
12	package org.eclipse.core.internal.databinding.beans;
13
14	import java.beans.PropertyChangeEvent;
15	import java.beans.PropertyChangeListener;
16	import java.beans.PropertyDescriptor;
17	import java.util.HashMap;
18	import java.util.Map;
19
20	import org.eclipse.core.databinding.beans.IBeanProperty;
21	import org.eclipse.core.databinding.observable.Diffs;
22	import org.eclipse.core.databinding.observable.map.MapDiff;
23	import org.eclipse.core.databinding.property.MapProperty;
24	import org.eclipse.core.internal.databinding.Util;
25
26	/**
27	* @since 3.3
28	*
29	*/
30	public class BeanMapProperty extends MapProperty implements IBeanProperty {
31	private PropertyDescriptor propertyDescriptor;
32	private boolean attachListener;
33
34	private boolean updating;
35
36	private ListenerSupport listenerSupport;
37
38	/**
39	* @param propertyDescriptor
40	* @param attachListener
41	*/
42	public BeanMapProperty(PropertyDescriptor propertyDescriptor,
43	boolean attachListener) {
44	this.propertyDescriptor = propertyDescriptor;
45	this.attachListener = attachListener;
46	}
47
48	private void initListenerSupport() {
49	if (listenerSupport == null) {
50	synchronized (this) {
51	if (listenerSupport == null) {
52	PropertyChangeListener propertyChangeListener = new PropertyChangeListener() {
53	public void propertyChange(PropertyChangeEvent evt) {
54	if (!updating) {
55	MapDiff diff;
56	if (evt.getOldValue() == null
57	&& evt.getNewValue() == null) {
58	// Obscure condition indicating new and old
59	// values are unknown
60	diff = null;
61	} else {
62	diff = Diffs.computeMapDiff(asMap(evt
63	.getOldValue()), asMap(evt
64	.getNewValue()));
65	}
66	fireMapChange(evt.getSource(), diff);
67	}
68	}
69	};
70	listenerSupport = new ListenerSupport(
71	propertyChangeListener, propertyDescriptor
72	.getName());
73	}
74	}
75	}
76	}
77
78	protected void addListenerTo(Object source) {
79	if (attachListener) {
80	initListenerSupport();
81	listenerSupport.hookListener(source);
82	}
83	}
84
85	protected void removeListenerFrom(Object source) {
86	if (attachListener && listenerSupport != null) {
87	listenerSupport.unhookListener(source);
88	}
89	}
90
91	public Map getMap(Object source) {
92	return asMap(BeanPropertyHelper.getProperty(source, propertyDescriptor));
93	}
94
95	private Map asMap(Object propertyValue) {
96	if (propertyValue == null)
97	return new HashMap();
98	return (Map) propertyValue;
99	}
100
101	public void setMap(Object source, Map map) {
102	Map oldMap = getMap(source);
103
104	if (Util.equals(oldMap, map)) {
105	return;
106	}
107
108	updating = true;
109	try {
110	BeanPropertyHelper.setProperty(source, propertyDescriptor, map);
111	} finally {
112	updating = false;
113	}
114
115	Map newMap = getMap(source);
116	if (!Util.equals(oldMap, newMap)) {
117	fireMapChange(source, Diffs.computeMapDiff(oldMap, newMap));
118	}
119	}
120
121	public synchronized void dispose() {
122	if (listenerSupport != null) {
123	listenerSupport.dispose();
124	listenerSupport = null;
125	}
126	propertyDescriptor = null;
127	super.dispose();
128	}
129
130	public PropertyDescriptor getPropertyDescriptor() {
131	return propertyDescriptor;
132	}
133	}

Added Link Here

(-)src/org/eclipse/core/internal/databinding/beans/BeanValueProperty.java (+135 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
10	******************************************************************************/
11
12	package org.eclipse.core.internal.databinding.beans;
13
14	import java.beans.PropertyChangeEvent;
15	import java.beans.PropertyChangeListener;
16	import java.beans.PropertyDescriptor;
17
18	import org.eclipse.core.databinding.beans.IBeanProperty;
19	import org.eclipse.core.databinding.observable.Diffs;
20	import org.eclipse.core.databinding.observable.value.ValueDiff;
21	import org.eclipse.core.databinding.property.ValueProperty;
22	import org.eclipse.core.internal.databinding.Util;
23
24	/**
25	* @since 3.3
26	*
27	*/
28	public class BeanValueProperty extends ValueProperty implements IBeanProperty {
29	private PropertyDescriptor propertyDescriptor;
30	private Class valueType;
31
32	private boolean attachListener;
33
34	private boolean updating;
35
36	private ListenerSupport listenerSupport;
37
38	/**
39	* @param propertyDescriptor
40	* @param valueType
41	* @param attachListener
42	*/
43	public BeanValueProperty(PropertyDescriptor propertyDescriptor,
44	Class valueType, boolean attachListener) {
45	this.propertyDescriptor = propertyDescriptor;
46	this.valueType = valueType == null ? propertyDescriptor
47	.getPropertyType() : valueType;
48
49	this.attachListener = attachListener;
50
51	}
52
53	private void initListenerSupport() {
54	if (listenerSupport == null) {
55	synchronized (this) {
56	if (listenerSupport == null) {
57	PropertyChangeListener propertyChangeListener = new PropertyChangeListener() {
58	public void propertyChange(PropertyChangeEvent evt) {
59	if (!updating) {
60	ValueDiff diff;
61	if (evt.getOldValue() == null
62	&& evt.getOldValue() == null) {
63	// Obscure condition indicating new and old
64	// values are unknown
65	diff = null;
66	} else {
67	diff = Diffs.createValueDiff(evt
68	.getOldValue(), evt.getNewValue());
69	}
70	fireValueChange(evt.getSource(), diff);
71	}
72	}
73	};
74	listenerSupport = new ListenerSupport(
75	propertyChangeListener, propertyDescriptor
76	.getName());
77	}
78	}
79	}
80	}
81
82	protected void addListenerTo(Object source) {
83	if (attachListener) {
84	initListenerSupport();
85	listenerSupport.hookListener(source);
86	}
87	}
88
89	protected void removeListenerFrom(Object source) {
90	if (attachListener && listenerSupport != null) {
91	listenerSupport.unhookListener(source);
92	}
93	}
94
95	public Object getValue(Object source) {
96	return BeanPropertyHelper.getProperty(source, propertyDescriptor);
97	}
98
99	public void setValue(Object source, Object value) {
100	Object oldValue = getValue(source);
101
102	if (Util.equals(oldValue, value)) {
103	return;
104	}
105
106	updating = true;
107	try {
108	BeanPropertyHelper.setProperty(source, propertyDescriptor, value);
109	} finally {
110	updating = false;
111	}
112
113	Object newValue = getValue(source);
114	if (!Util.equals(oldValue, newValue)) {
115	fireValueChange(source, Diffs.createValueDiff(oldValue, newValue));
116	}
117	}
118
119	public Object getValueType() {
120	return valueType;
121	}
122
123	public synchronized void dispose() {
124	if (listenerSupport != null) {
125	listenerSupport.dispose();
126	listenerSupport = null;
127	}
128	propertyDescriptor = null;
129	super.dispose();
130	}
131
132	public PropertyDescriptor getPropertyDescriptor() {
133	return propertyDescriptor;
134	}
135	}

Added Link Here

(-)src/org/eclipse/core/internal/databinding/beans/BeanListProperty.java (+157 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
10	******************************************************************************/
11
12	package org.eclipse.core.internal.databinding.beans;
13
14	import java.beans.PropertyChangeEvent;
15	import java.beans.PropertyChangeListener;
16	import java.beans.PropertyDescriptor;
17	import java.lang.reflect.Array;
18	import java.util.ArrayList;
19	import java.util.Arrays;
20	import java.util.List;
21
22	import org.eclipse.core.databinding.beans.IBeanProperty;
23	import org.eclipse.core.databinding.observable.Diffs;
24	import org.eclipse.core.databinding.observable.list.ListDiff;
25	import org.eclipse.core.databinding.property.ListProperty;
26	import org.eclipse.core.internal.databinding.Util;
27
28	/**
29	* @since 3.3
30	*
31	*/
32	public class BeanListProperty extends ListProperty implements IBeanProperty {
33	private PropertyDescriptor propertyDescriptor;
34	private Class elementType;
35	private boolean attachListener;
36
37	private boolean updating;
38
39	private ListenerSupport listenerSupport;
40
41	/**
42	* @param propertyDescriptor
43	* @param elementType
44	* @param attachListener
45	*/
46	public BeanListProperty(PropertyDescriptor propertyDescriptor,
47	Class elementType, boolean attachListener) {
48	this.propertyDescriptor = propertyDescriptor;
49	this.elementType = elementType == null ? BeanPropertyHelper
50	.getCollectionPropertyElementType(propertyDescriptor)
51	: elementType;
52	this.attachListener = attachListener;
53	}
54
55	private void initListenerSupport() {
56	if (listenerSupport == null) {
57	synchronized (this) {
58	if (listenerSupport == null) {
59	PropertyChangeListener propertyChangeListener = new PropertyChangeListener() {
60	public void propertyChange(PropertyChangeEvent evt) {
61	if (!updating) {
62	ListDiff diff;
63	if (evt.getOldValue() == null
64	&& evt.getOldValue() == null) {
65	// Obscure condition indicating new and old
66	// values are unknown
67	diff = null;
68	} else {
69	diff = Diffs.computeListDiff(asList(evt
70	.getOldValue()), asList(evt
71	.getNewValue()));
72	}
73	fireListChange(evt.getSource(), diff);
74	}
75	}
76	};
77	listenerSupport = new ListenerSupport(
78	propertyChangeListener, propertyDescriptor
79	.getName());
80	}
81	}
82	}
83	}
84
85	protected void addListenerTo(Object source) {
86	if (attachListener) {
87	initListenerSupport();
88	listenerSupport.hookListener(source);
89	}
90	}
91
92	protected void removeListenerFrom(Object source) {
93	if (attachListener && listenerSupport != null) {
94	listenerSupport.unhookListener(source);
95	}
96	}
97
98	public List getList(Object source) {
99	Object propertyValue = BeanPropertyHelper.getProperty(source,
100	propertyDescriptor);
101	return asList(propertyValue);
102	}
103
104	private List asList(Object propertyValue) {
105	if (propertyValue == null)
106	return new ArrayList();
107	if (propertyDescriptor.getPropertyType().isArray())
108	return new ArrayList(Arrays.asList((Object[]) propertyValue));
109	return (List) propertyValue;
110	}
111
112	public void setList(Object source, List list) {
113	List oldList = getList(source);
114
115	if (Util.equals(oldList, list))
116	return;
117
118	updating = true;
119	try {
120	Object propertyValue = list;
121	if (propertyDescriptor.getPropertyType().isArray()) {
122	Class componentType = propertyDescriptor.getPropertyType()
123	.getComponentType();
124	Object[] array = (Object[]) Array.newInstance(componentType,
125	list.size());
126	list.toArray(array);
127	propertyValue = array;
128	}
129	BeanPropertyHelper.setProperty(source, propertyDescriptor,
130	propertyValue);
131	} finally {
132	updating = false;
133	}
134
135	List newList = getList(source);
136	if (!Util.equals(oldList, newList)) {
137	fireListChange(source, Diffs.computeListDiff(oldList, newList));
138	}
139	}
140
141	public Object getElementType() {
142	return elementType;
143	}
144
145	public synchronized void dispose() {
146	if (listenerSupport != null) {
147	listenerSupport.dispose();
148	listenerSupport = null;
149	}
150	propertyDescriptor = null;
151	super.dispose();
152	}
153
154	public PropertyDescriptor getPropertyDescriptor() {
155	return propertyDescriptor;
156	}
157	}

Added Link Here

(-)src/org/eclipse/core/internal/databinding/beans/BeanSetProperty.java (+157 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
10	******************************************************************************/
11
12	package org.eclipse.core.internal.databinding.beans;
13
14	import java.beans.PropertyChangeEvent;
15	import java.beans.PropertyChangeListener;
16	import java.beans.PropertyDescriptor;
17	import java.lang.reflect.Array;
18	import java.util.Arrays;
19	import java.util.HashSet;
20	import java.util.Set;
21
22	import org.eclipse.core.databinding.beans.IBeanProperty;
23	import org.eclipse.core.databinding.observable.Diffs;
24	import org.eclipse.core.databinding.observable.set.SetDiff;
25	import org.eclipse.core.databinding.property.SetProperty;
26	import org.eclipse.core.internal.databinding.Util;
27
28	/**
29	* @since 3.3
30	*
31	*/
32	public class BeanSetProperty extends SetProperty implements IBeanProperty {
33	private PropertyDescriptor propertyDescriptor;
34	private Class elementType;
35	private boolean attachListener;
36
37	private boolean updating;
38
39	private ListenerSupport listenerSupport;
40
41	/**
42	* @param propertyDescriptor
43	* @param elementType
44	* @param attachListener
45	*/
46	public BeanSetProperty(PropertyDescriptor propertyDescriptor,
47	Class elementType, boolean attachListener) {
48	this.propertyDescriptor = propertyDescriptor;
49	this.elementType = elementType == null ? BeanPropertyHelper
50	.getCollectionPropertyElementType(propertyDescriptor)
51	: elementType;
52	this.attachListener = attachListener;
53	}
54
55	private void initListenerSupport() {
56	if (listenerSupport == null) {
57	synchronized (this) {
58	if (listenerSupport == null) {
59	PropertyChangeListener propertyChangeListener = new PropertyChangeListener() {
60	public void propertyChange(PropertyChangeEvent evt) {
61	if (!updating) {
62	SetDiff diff;
63	if (evt.getOldValue() == null
64	&& evt.getOldValue() == null) {
65	// Obscure condition indicating new and old
66	// values are unknown
67	diff = null;
68	} else {
69	diff = Diffs.computeSetDiff(asSet(evt
70	.getOldValue()), asSet(evt
71	.getNewValue()));
72	}
73	fireSetChange(evt.getSource(), diff);
74	}
75	}
76	};
77	listenerSupport = new ListenerSupport(
78	propertyChangeListener, propertyDescriptor
79	.getName());
80	}
81	}
82	}
83	}
84
85	protected void addListenerTo(Object source) {
86	if (attachListener) {
87	initListenerSupport();
88	listenerSupport.hookListener(source);
89	}
90	}
91
92	protected void removeListenerFrom(Object source) {
93	if (attachListener && listenerSupport != null) {
94	listenerSupport.unhookListener(source);
95	}
96	}
97
98	public Set getSet(Object source) {
99	Object propertyValue = BeanPropertyHelper.getProperty(source,
100	propertyDescriptor);
101	return asSet(propertyValue);
102	}
103
104	private Set asSet(Object propertyValue) {
105	if (propertyValue == null)
106	return new HashSet();
107	if (propertyDescriptor.getPropertyType().isArray())
108	return new HashSet(Arrays.asList((Object[]) propertyValue));
109	return (Set) propertyValue;
110	}
111
112	public void setSet(Object source, Set set) {
113	Set oldSet = getSet(source);
114
115	if (Util.equals(oldSet, set))
116	return;
117
118	updating = true;
119	try {
120	Object propertyValue = set;
121	if (propertyDescriptor.getPropertyType().isArray()) {
122	Class componentType = propertyDescriptor.getPropertyType()
123	.getComponentType();
124	Object[] array = (Object[]) Array.newInstance(componentType,
125	set.size());
126	set.toArray(array);
127	propertyValue = array;
128	}
129	BeanPropertyHelper.setProperty(source, propertyDescriptor,
130	propertyValue);
131	} finally {
132	updating = false;
133	}
134
135	Set newSet = new HashSet(getSet(source));
136	if (!Util.equals(oldSet, newSet)) {
137	fireSetChange(source, Diffs.computeSetDiff(oldSet, newSet));
138	}
139	}
140
141	public Object getElementType() {
142	return elementType;
143	}
144
145	public synchronized void dispose() {
146	if (listenerSupport != null) {
147	listenerSupport.dispose();
148	listenerSupport = null;
149	}
150	propertyDescriptor = null;
151	super.dispose();
152	}
153
154	public PropertyDescriptor getPropertyDescriptor() {
155	return propertyDescriptor;
156	}
157	}

Added Link Here

(-)src/org/eclipse/core/databinding/beans/IBeanProperty.java (+27 lines)
1	/*******************************************************************************
2	* Copyright (c) 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	******************************************************************************/
11
12	package org.eclipse.core.databinding.beans;
13
14	import java.beans.PropertyDescriptor;
15
16	import org.eclipse.core.databinding.property.IProperty;
17
18	/**
19	* @since 1.2
20	*
21	*/
22	public interface IBeanProperty extends IProperty {
23	/**
24	* @return property descriptor for the bean property
25	*/
26	public PropertyDescriptor getPropertyDescriptor();
27	}

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 (+51 lines)
1	/*******************************************************************************
2	* Copyright (c) 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	******************************************************************************/
11
12	package org.eclipse.core.databinding.property;
13
14	import java.util.List;
15
16	/**
17	* @since 1.2
18	*
19	*/
20	public interface IListProperty extends IProperty {
21	/**
22	* @param source
23	* @return the list property of the given source
24	*/
25	public List getList(Object source);
26
27	/**
28	* @param source
29	* @param list
30	*/
31	public void setList(Object source, List list);
32
33	/**
34	* @return the type of the elements or <code>null</code> if untyped
35	*/
36	public Object getElementType();
37
38	/**
39	* @param source
40	* @param listener
41	*/
42	public void addListChangeListener(Object source,
43	IListPropertyChangeListener listener);
44
45	/**
46	* @param source
47	* @param listener
48	*/
49	public void removeListChangeListener(Object source,
50	IListPropertyChangeListener listener);
51	}

Added Link Here

(-)src/org/eclipse/core/databinding/property/IPropertyChangeListener.java (+23 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	*******************************************************************************/
11
12	package org.eclipse.core.databinding.property;
13
14	/**
15	* Marker interface for all listener types in the properties framework.
16	*
17	* @noimplement This interface is not intended to be implemented by clients.
18	*
19	* @since 1.2
20	*/
21	public interface IPropertyChangeListener {
22
23	}